2、C#面向对象：封装、继承、多态、String、集合、文件（上）

面向对象封装

一、面向对象概念

面向过程：面向的是完成一件事情的过程，强调的是完成这件事情的动作。

面向对象：找个对象帮你完成这件事情。

二、面向对象封装

把方法进行封装，隐藏实现细节，外部直接调用。

打包，便于管理，为了解决大型项目的维护与管理。

三、什么是类？

将相同的属性和相同方法的对象进行封装，抽象出 “类”，用来确定对象具有的属性和方法。

类、对象关系：人是类，张三是人类的对象。

类是抽象的，对象是具体的。对象可以叫做类的实例，类是不站内存的，对象才占内存。

字段是类的状态，方法是类执行的动作。

三个特性：封装、继承、多态。

四、访问修饰符

public 公共的，任何地方都可以访问

private 私有的，只有本类中成员可以访问

protected 受保护的，可以在当前类以及子类访问

Intelnal 只能在当前项目中访问，在同一个项目中Intelnal和public权限是一样的。

protected Intelnal 当前项目受保护的。

修饰类的访问修饰符只有两个：public、Intelnal

定义一个类时，如果不加访问修饰符，默认是Intelnal

可访问性不一致：子类可访问性不能高于父类可访问性，可能会被暴漏父类成员。

类中的成员，如果不加访问修饰符，默认都是private

定义一个类

[public] class 类名
{
字段；
属性；
方法；
}

class person
{
public string name; //字段
public int age;
public int height;
public void sayHi()
{
Console.WriteLine("Hello , my name is {0}, my age is {1} , my height is {2}" , this.name, this.age,this.height); //this当前类
}
}

使用关键字 new 创建类的对象称之为实例化。

person p = new person();
p.name = "david";
p.age = 18;
p.height = 172;
p.sayHi();

五、属性

用来限定字段的赋值和取值。

定义属性

private int age;
public int Age{
set{
if(value < 0){ //赋值时进行判断 可以不赋值
return;
}
this.age = value;
}
get { //取值
return this.age;
}
}

简写

public int age {set; get;} //3.0后新增 自动生成get set 代码快。

六、静态(static)

非静态类

在非静态类中，既可以有实例成员，也可以有静态成员。

静态类

在静态类中，只能有静态成员。

静态类不可以用new实例化，直接用类名调用。

只有在程序全部结束之后，静态类才会释放资源。

静态方法

在调用实例方法的时候，需要先实例化，再使用对象名.实例方法。person p = new person(); p.ss;

在调用静态方法的时候，直接使用类名.静态方法。person.ss;

不用new实例化 直接可用的方法 静态（static）的方法。

static方法中可以调用其他satatic方法、字段、属性，但是不能调用非static方法、字段、属性。

在非static方法中可以调用static的方法、字段。

public static int age; //全局变量

七、构造函数

构造方法用来创建对象，并且初始化对象（对每个属性依次赋值）。

定义构造方法时构造方法的名称必须和类名相同， 没有返回值 void也不用写。

可以有参数，可以重载（多个参数不同的构造函数）。

如果不指定构造函数，则类默认有一个无参的构造函数，如果指定了构造函数，则不会再有默认的无参构造函数，需要自己来写。

定义构造函数

class person{
public string name;
public person(string name){
this.Name = name;
}
}

通过构造函数初始化属性

person hei = new person("小黑"); //此时p.name = "小黑";

八、this关键字

1、代表当前类中的对象。

2、在类当中显示的调用本类的构造函数 ：this

public person(string name; int age){ //全参构造函数
this.Name = name;
this.Age = age;
}
public person(string name):this("name",0){ //不执行方法体 去调用其他构造函数 有的写上 没有的写个值
}

九、析构函数

//当程序结束的时候析构函数才执行，用来释放资源。

 

~Student{
}

//GC可以自动释放资源，但不是马上，如果想马上释放资源则使用析构函数。

十、命名空间（namespace）

用来解决类重名问题

在其他的命名空间下使用这个命名空间时需要用using关键字引入该namespace。

using namespace;
namespace.class.person c = new namespace.class.person();

如果属于同一命名空间下则不需要用using引入；

十一、对象的引用

值类型

int double datetime bool char struct enum等类型 赋值的时候是复制传递，第二个发生变化，第一个没变化。

i = 10;j = i; i++; j //还是10

值类型存储在内存的栈中。

引用类型

对象 string则是引用类型，类似快捷方式 俩个对象都指向原地址。

person p1 = new person(10); //构造函数赋值10 age person p2 = p1; p1.age++; //都11；

引用类型存储在内存的堆中。

对象较大站内存，所以不会类似值类型那样直接赋值一份，而是共同引用同一块。

 

字符串String

一、字符串的不可变性

当給一个字符串重新赋值后，旧值依然存储在内存中，并没有被销毁，而是重新开辟一块内存空间存储新的值。

当程序结束后，GC（垃圾回收）扫描整个内存，如果发现有的空间没有被指向，则立即把他销毁。

字符串可以看作是char类型的只读数组

string s = "abcdefg";
s[0]; //可以通过数组下标的方式读取0个 'a'值，只读的不可以赋值。

如果想赋值

ToCharArray()

string s = "abcd"; //定义字符串
char[] ch = s.ToCharArray(); //ToCharArray()方法将字符串转换为字符数组
ch[0] = 'b'; //修改字符数组的第一个值
s = new string(ch); //new string (char[]) 方法将字符数组转换为字符串 内存还是新开了一个空间
Response.Write(s); //结果 "bbcd"; 更改了第一个字符

StringBuilder

每次改变值不用重新开辟内存

StringBuilder sb = new StringBuilder(); //定义StringBuilder;
sb.Append("insert "); //append 追加字符串
sb.Append(" values");

Stopwatch

用来测量程序运行时间

Stopwatch sw = new Stopwatch(); //定义
sw.Start(); //开始
//执行程序处
sw.Stop(); //结束
Response.Write(sw.Elapsed); //输出运行事件

ToString()

将任意类型转换为字符串； xxx.ToString();

Length

获得字符串的长度 xxx.Length;

ToUpper()

将字符串转换为大写

ToLower()

将字符串转换为小写

Equals()

比较两个字符串是否相等 s.Equals("s");

重载 s.Equals("s",StringComparison.OrdinalIgnoreCase) 第二个参数枚举类型 可以忽略大小写比较

Split()

将字符串按某字符进行分割，分割成字符串数组。

s.Split() 参数可字符，可字符数组，第二个参数，是否含有空白的字符数组

string s = "asdfljas;ld asljwo;ias fa sdl;fkw asdf"; 
char[] cs = { 'a', ' ', ';' }; // 需要去掉的字符
string[] sa = s.Split(cs, StringSplitOptions.RemoveEmptyEntries); // 字符串分割选项.删除空白字符

Contains()

是否包含某字符 s.Contains("白大伟"); true false

Replace()

s.Replace("白大伟","*") 将包含白大伟的字符串全部替换为*

SubString()

从哪截到哪 s.SubString(0,20) 从0开始截 截到20

StartsWith()

判断是否从某字符开始 s.StartsWith("a");

EndsWith()

判断是否从某字符结束 s.EndsWith("g");

IndexOf()

查找字符串第一次出现的位置 s.IndexOf("a") 0 找不到返回-1

重载 s.IndexOf("a",2) 从2位置开始找

LastIndexOf()

查找字符串最后一次出现的位置 s.LastIndexOf("g");

Trim()

s.Trim(); //去掉字符串所有空格
s.TrimStart(); //去掉前面的空格
s.TrimEnd(); //去掉结尾空格

IsNullOrEmpty()

string.IsNullOrEmpty("s") 判断该字符串是否为空或null

Join()

将字符串数组按照某字符进行链接，返回一个字符串 string.Join("|", "a","asdf","asdfasdf")  

 

面向对象继承

一、继承

将重复的一些成员，封装到一个类中，作为这些类的父类。 解决代码冗余

单根性：在c#中只允许继承一个父类。

定义类时不指定继承类，则默认继承object类；object类是所有类的基类

定义类时用 ： 号 继承父类

子类继承了父类的属性和方法，但是子类无法继承父类的私有字段。

子类没有继承父类的构造函数，但是子类会默认调用父类的无参构造函数，创建父类对象，让子类可以使用父类中的成员

如果父类中有构造函数，需要写一个无参的构造函数，在子类中显示的调用父类的构造函数，使用关键字:base()

二、new 关键字

隐藏从父类集成的同名成员，隐藏后子类调用不到父类的成员。

当子类的成员和父类的成员名字相同的时候，可以使用new隐藏该成员，子类将调用不到父类中的该成员。

public new void ff(){
}

三、里氏转换

子类可以赋值给父类，如果父类中装的是子类对象，那么可以将这个父类强制转换为子类对象。

class chinese:persion persion有的公共属性方法子类有 子类还有自己的age 
{
public string age{get;set;}
}
chinese s = new chinese(); //初始化子类
persion p = s; //我要人 給我中国人 成立 
chinese c = p; //我要中国人 給我个人 不敢保证 报错
if(p is chinese){
chinese china = (chinese)p; //强制转换为中国人
}
object o = 3; //成立 object基类

四、类型转换

is:如果能转换成功，返回true。if(p is chinese)

as:如果能够转换，则返回对应的对象，否则返回null。chinese chin = p as Chinese;

  

 

集合

一、ArrayList集合

与数组区别：数组长度不可变，类型单一。集合长度可以改变，类型不固定。

•protected void Page_Load(object sender, EventArgs e)
{
    ArrayList arry = new ArrayList();

    //添加单个
    arry.Add(1); //int

    arry.Add(3.14); //double

    arry.Add("字符串"); //string

    arry.Add('男'); //char

    arry.Add(500m); //decimal

    arry.Add(new int[] { 1, 2, 3, 4, 5 });

    arry.Add(new person());

    Random r = new Random(); //随机数

    r.Next(1, 9); // 1~8的随机数

    arry.Add(r); //添加集合 无需遍历

    arry.AddRange(new string[] { "one", "two", "three" }); //无需下面那样遍历也输出值

    //arry.AddRange(arry);

    arry.Remove(500m); //删除指定

    arry.RemoveAt(0); //下标删除

    arry.RemoveRange(0, 1); //根据下标移除一定范围的元素

    //arry.Sort(); //升序排序 多元素报错

    arry.Reverse(); //反转 倒序

    arry.Insert(1, "插入的"); //指定位置插入元素

    arry.InsertRange(1, new string[] { "asd", "asd" }); //指定位置插入集合

    bool b = arry.Contains("插入的"); //判断是否包含指定元素
    //清空
    //arry.Clear();

    //单个方法添加集合 遍历
    for (int i = 0; i < arry.Count; i++) // arry.Count; arry.Capacity; //可包含个数 实际个数 每次集合中实际包含的元素count超过了可包含的元素个数capcity的时候，集合就会向内存多申请一倍的空间，来保证集合的长度一直够用。
    {
        if (arry[i] is person) //不判断输出命名空间 单个添加
        {
            Response.Write(((person)arry[i]).say());
        }
        else if (arry[i] is int[])
        {
            for (int j = 0; j < ((int[])arry[i]).Length; j++)
            {
                Response.Write(((int[])arry[i])[j]);
            }
        }
        else
        {
            Response.Write(arry[i]);
        }
    }
}

class person
{
    public string say()
    {
        return "Hello";
    }
}

二、List<T>泛型集合

实现定义好类型，长度不限，省去判断类型的操作

List<int> list = new List<int>(); //创建泛型集合ArryList

list.Add(1); //添加单个

list.Add(2);

list.Add(3);

list.Add(4);

list.Add(5);

list.Add(6);

list.AddRange(new int[] { 1, 2, 3, 4 }); //添加集合

//list.Clear(); //清空

if (list.Contains(2))
{ //是否存在

    list.Remove(2); //删除指定

    list.RemoveAt(1); //删除下标

    list.RemoveRange(0, 1); //删除范围
}

var nums = list.ToArray(); //泛型集合转换为数组

for (int i = 0; i < list.Count; i++)
{
    Response.Write(list[i]);
}

for (int i = 0; i < nums.Length; i++)
{
    Response.Write(nums[i]);
}

char[] chas = new char[] { 'a', 'b' };

List<char> listc = chas.ToList(); //将数组转换为泛型集合

for (int i = 0; i < listc.Count; i++)
{
    Response.Write(listc[i]);
}

三、var推断类型

c#中的var和javascript中的var是不同的。

c#是强类型语言，必须对每一个变量的类型明确定义。如：int a= 1; char a = 'x';

js是若类型语言，var是用来声明变量的。

在c#中var关键字是用来根据“值”自动推断变量的类型，声明时，必须赋初始值。 var a = 1; var b = 'x';

四、Hashtable键值对集合

通过键来查找对应值的，在键值对集合中，键必须是唯一的，值可以重复。

Hashtable hs = new Hashtable(); //创建

hs.Add(1, "字符串"); //添加第一种

hs.Add(2, '男');

hs.Add(true, "正确的");

hs.Add(false, "错误的");

if (!hs.Contains(1)) //Contains == ContainsKey 是否包含key
{
    hs.Add(1, "aaaa");
}

if (hs.ContainsValue(1)) //是否包含值
{
    hs.Add(7, "111");
}

hs[5] = "asd"; //没有新增 有替换 添加第二种

hs[1] = "赋值"; //赋值 通过hs[key]

//hs.Clear(); //清空

hs.Remove(2); //删除key=2

foreach (var ht in hs.Keys) //foreach遍历 从什么中取
{
    Response.Write(hs[ht]);
}

五、Dictionary字典键值对集合

键值对集合，需要规范类型

Dictionary<int, string> dic = new Dictionary<int, string>(); //字典集合 规定键值对类型

dic.Add(1, "one"); //键必须唯一

dic.Add(2, "two");

dic[1] = "new"; //存在覆盖 不存在新增

foreach (var item in dic.Keys)
{
    Response.Write("key:" + item + "---value:" + dic[item]);
}

foreach (KeyValuePair<int, string> kv in dic)
{
    Response.Write("key:" + kv.Key + "---value:" + kv.Value);
}

 

文件操作

一、Path类

用来获得文件路径的

string str = @"D:\video\xxx.avi";

var fileNameExt = Path.GetFileName(str); //获得文件名包含扩展名

var fileName = Path.GetFileNameWithoutExtension(str); //获得文件名不包含扩展名

var fileExt = Path.GetExtension(str); //获得文件扩展名

var DirectoryName = Path.GetDirectoryName(str); //获得路径包含文件夹名

var FullPath = Path.GetFullPath(str); //获得文件全路径

var combine = Path.Combine(@"c:\", "b.txt"); //连接两个字符串作为路径

Response.Write(fileNameExt + "<br />" + fileName + "<br />" + fileExt + "<br />" + DirectoryName + "<br />" + FullPath + "<br />" + combine);

 

二、文件路径

1、绝对路径：在电脑的某磁盘存放的物理路径。如：d:\game\sg7\sg7.exe

2、相对路径：文件相对于程序的所在路径。如：images/abc.jpg

三、编码

因为计算机存储数据存储的是二进制，编码就是将字符串以某种形式保存为二进制。

乱码产生的原因，保存此文件时采用的编码与打开时使用的编码不符。

美国人编码ASC 128 a~z 0~9

欧洲人编码ASCII 256

中国人编码GB2312 简体字

香港、台湾人编码Big5 繁体字

后来出的通用编码unicode 解析慢

web通用编码 utf-8

四、Encoding

Encoding.Default //默认编码

Encoding cn = Encoding.GetEncoding("gb2312"); //获得中文编码

五、File类

用来操作文件的类

File.Delete(@"d:\11.txt"); //删除一个文件 不经过回收站
    if (!File.Exists(@"d:\11txt")) //判断一个文件是否存在
    {
        File.Create(@"d:\11.txt"); //创建一个文件
    }
File.Copy(@"d:\11.txt", @"d:\11_copy.txt"); //复制一个文件
File.Move(@"d:\11.txt", @"d:\11_copy.txt"); //移动一个文件

string write1 = "今天天气不错，空气挺好的。";
File.WriteAllBytes(@"d:11.txt", Encoding.Default.GetBytes(write1)); //转换为字节数组后写入

string[] write2 = new string[] { "明天天气不好", "后天天气也不好", "大后天也不好" };
File.WriteAllLines(@"d:\11.txt", write2, Encoding.Default);//行写入

string write3 = "麻烦，一次都写入就好了。";
File.WriteAllText(@"d:\11.txt", write3, Encoding.Default); //全部覆盖写入

//以字节数组形式读取
byte[] buff = File.ReadAllBytes(@"d:\11.txt");//解码 打开时 与保存时 编码需要一致
Response.Write(Encoding.GetEncoding("GB2312").GetString(buff)); 

//读取指定编码的文件的文本行
var strings = File.ReadLines(@"d:\11.txt", Encoding.Default); 
foreach (var s in strings)
{
    Response.Write(s + "<br />");
}

//读取指定编码所有行
var str = File.ReadAllText(@"d:\11.txt", Encoding.Default); 
Response.Write(str);

ReadAllBytes字节读取：读取其他文件（多媒体，音乐，图片等），时使用字节形式读取。

ReadLines行读取：读取文本文件，具体操作某一行时，使用行读取。

ReadAllText全读取：读取文本文件，不需要单行操作时，全部读取。

六、文件流

File:读取只适用于小文件，一次性读取，很耗内存。

FileStream:操作大文件，读取文件时一点一点的读取。

FileStream操作字节的、StreamReader操作文本的。

//FileStream字节读取数据
FileStream file1 = new FileStream(@"d:11.txt",FileMode.OpenOrCreate, FileAccess.ReadWrite);

byte[] by = new byte[1024 * 1024 * 5]; //限定读取多少 5m

int result = file1.Read(by, 0, by.Length); //读出来的放到by字节数组中，从0开始，读到字节数组的长度结束。 返回实际读取到的有效字节数。

string s = Encoding.Default.GetString(by, 0, result); //从多少开始解码，解码多少个

//关闭流 释放所占的资源 GC不能自动回收 需要手动回收

file1.Close(); //使用using自动关闭

file1.Dispose(); //使用using自动释放

Response.Write("该文件有：" + result / 1024 + "kb" + s);



//FileStream字节写入数据 使用using 自动关闭/释放资源 
using (FileStream file2 = new FileStream(@"d:11.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
    string str = "覆盖字符串";
    byte[] byt = Encoding.Default.GetBytes(str); //转换为字节数组
    file2.Write(byt, 0, byt.Length); //要写入的字符数组，从哪开始，到哪结束。
}


////////////////////////////////////////////多媒体大文件copy

var source = @"D:\xxx.avi";

var target = @"D:\new.avi";

using (var fsread = new FileStream(source, FileMode.Open, FileAccess.Read)) //读
{
    using (var fswrite = new FileStream(target, FileMode.OpenOrCreate, FileAccess.Write)) //写
    {
        while (true)
        {
            byte[] byread = new byte[1024 * 1024 * 5];

            int r = fsread.Read(byread, 0, byread.Length);

            if (r == 0) //0则为全部读取完毕
            {
                break;
            }
            fswrite.Write(byread, 0, r); //写入
        }
    }
}

StreamRead、StreamWrite文本读取、写入

using (StreamReader sr = new StreamReader(@"d:\11.txt", Encoding.Default))
{
    while (!sr.EndOfStream) //是否读到末尾
    {
        Response.Write(sr.ReadLine() + "<br />");
    }
}

using (StreamWriter sw = new StreamWriter(@"d:\121.txt", true))//写入文件 true追加 false覆盖
{
    sw.Write("asdflkjasdlkfjalskdfjlakszxncv.mzxcv");
}