深刻的理解面向对象

　　1.面向对象概念

(1) 属性-对象具有的各种特征

        1) 每个对象的每个属性都拥有特定值。

        2) 属性，比如：姓名，性别，年龄。

(2) 方法：行为，动作，执行的操作。

(3) 类：类是模板，确定对象将会拥有的特征(属性)和行为(方法)。类是对象的模型。

1. 类和对象的区别

(1) 类是抽象的概念，仅仅是模板，比如说：”人”类。

(2) 对象是一个你可以看得到，摸得着的具体实体。

(3) “人”类都有：姓名\性别\年龄等属性，有说话的方法。

(4) 张三是一个属于人类的对象，他的姓名属性的值：张三，性别属性的值：男，年龄属性的值：20，他的行为是：会说话。

(5) 对象可以叫做类的实例（Instance）。

(6) 类不占内存，对象才占内存。

1. 类的定义

(1) 定义类的语法：  [访问修饰符]  class 类型

                                    {

                                           成员;

                                           ……………….

                                    }

(2) 类中可以包含变量的定义，方法。

注：在我们自己写的类中，我们在写方法时，先不用加static。

1. 类的实例化

(1) 通过类来产生一个对象的过程，叫做类的实例化。

(2) 类的实例化，用关键字new，  语法为：类名 实例名=new 类名();

        比如：Student zsStudent=new Student();

(3) 类的成员访问：

        1) 访问类的属性       实例名.属性名

       2) 访问类的方法       实例名.方法名();

(4) 只要是没有加static的方法或者属性，都必须先要实例化，再通过实例名.方法名();或者实例名.属性名来访问。

        加static的方法或者属性，可以直接通过类名.方法名();或者类名.属性来访问。

1. 访问修饰符

(1) 在C#中有四种访问修饰符

        1) public： 可以再任何地方被访问。

        2) internal：只能在本项目中被访问。

        3) private： 只能在本类中被访问。

        4) protected： 只能在本类或者子类中被访问。

(2) 在一个类中定义变量或者方法时，没有写访问修饰符，那么默认的访问修饰福是private。和类在同一个级别的不写访问修饰符默认为internal。

(3) 字段，方法和属性都可以叫做类的成员(Member)，他们都需要定义访问级别，访问级别的用处在于控制成员在那些地方可以被访问，这样达到面向对象中”封装”的目的。

1. 属性

例如：private int age;

         public int Age

{

get{   return age;   }

set{

      if(value>=0){

        age=value;       }

else{

        age=0;             }

}
}

(1) 什么叫做属性？通俗点说，就是定义一个public的具有get/set方法的变量，这个变量用于保护一个私有的变量。

(2) 属性是为了保护与之相对应的字段的。保证对字段的读取和赋值符合要求。

(3) 属性可以分为：读写属性，只读属性，只写属性。

(4) 允许外部访问的变量，一定要声明为属性。

(5) 读写属性：具有get/set方法的属性就叫做读写属性。

  只读属性：只有get方法的属性称为只读属性，这个属性只能读取，不能写入。

只写属性：只有set方法的属性称为只写属性，这个属性只能写，不能读(用的很少)。

1. 类的构造方法

(1) 当我们实例化一个类时，系统会自动对这个类的属性进行初始化。

        数字类型初始化为：  0/0.0。

        string类型初始化为：  null。

        char类型初始化为：\0。

(2) 使用构造方法的好处是：

        1) 对多个属性进行赋值时，不需要重复的写实例名。

        2) 可以保证用户在new一个对象的时候必须对某一个属性进行赋值。

        3) 和第2类似，在创建对象时，对只读属性进行初始化。

(3) 当我们定义好一个类后，如果我们没有写构造方法，那么系统会自动给我们加上一个默认的没有参数的构造方法，在这个构造方法中什么也不做，我们也看不到。

(4) 我们可以定义一个构造方法。

        构造方法是一个特殊的方法，它的名字和类的名字相同，并且没有返回值，连void都可以省略不写，我们一旦手写一个构造方法之后，系统原先默认给我们添加的那个无参的构造方法就不会再为我们添加了。

1. 构造方法的重载

(1) 构造方法用来创建对象，并且可以再构造函数中对对象进行初始化。

(2) 构造函数是用来创建对象的特殊方法，方法名和类名一样，没有返回值，连void都不用写。

(3) 构造函数可以有参数，new对象的时候传递函数参数即可。

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

(5) 构造函数可以重载， 也就是不同的构造函数有多个参数。

(6) 认识类图：

类名  Student    代表类名

-age:int   -表示私有的字段：private         :后面表示类型

-name:string  

+Name:string   +表示公有的属性：public

   +SayHi():void   表示公有的方法

 

1. 析构函数(*)

(1) 不能在结构中定义析构函数，只能对类使用析构函数。

(2) 一个类只能有一个析构函数。

(3) 无法继承或者重载析构函数。

(4) 无法调用析构函数，他们是被自动调用的。

(5) 析构函数既没有修饰符，也没有参数

(6) 从内存中退出来时清除系统所占有的资源

例如：~Student

{

       Console.WriteLine(“调用了析构函数”);

}

1. params关键字

(1) params关键字可以指定在参数数目可变处采用参数的方法参数。

(2) 在方法声明中params关键字之后不允许有任何其他参数，并且在方法声明中只允许1个params关键字，例如：

static void Test(int age,params int[] arr)

{

}

1. 命名空间

(1) namespace(命名空间)，用于解决类重名问题，可以看做“类的文件夹”。

(2) 不在同一个命名空间下的类，不能被直接访问，要想访问别的命名空间下的类有两种方法：1) 通过using引用对方的命名空间。

           2) 写全称：命名空间名.类名;

(3) 在命名空间下面可以包含命名空间。

1. 字符串的处理 string类

(1) string可以看做是char的只读数组，char c=s[1],例如遍历输出string类中的每个元素。

        string s=”Hello，World”;

        for(int i=0;i<s.Length;i++)

        {

               Console.WriteLine(s[i]);

        }

(2) C#中字符串有一个很重要的特性：不可变性，字符串一旦声明就不在可以改变，所以只能通过索引来读取指定位置的char，不能对指定位置的char进行修改。

(3) 如果要对char进行修改，那么就必须创建一个新的字符串，用s.ToCharArray()方法得到字符串的char数组，对数组进行修改后，调用new string(char[])这个构造函数来创建char数组的字符串，一旦字符串被创建，那么char数组的修改也不会造成字符串的变化，例如，将字符串中的“h”转换为“H”。

string s=”hello,world”;

char[] chars=s.toCharArray();

chars[0]=’H’;

s=new string(chars);

Console.WriteLine(s);

1. string类常用的方法

(1) 字符串的链接“+”，两边只要有一个字符串类型，另一个也会被自动转换为字符串类型。

(2) 一切类型都可以调用.ToString()方法转换成字符串类型。

(3) ToLower() ：得到字符串的小写形式。

注：字符串是不可变的，所以这些函数都不会直接改变字符串的内容，而是把修改后的字符串的值通过函数返回值的形式返回。即s=s.ToLower();

(4) ToUpper()  ：得到字符串的大写形式。

(5) Trim()  ：去掉字符串两端的空白。

(6) s1.Equals(s2,StringComparison.OrdinallynoreCase)，两个字符串进行你叫不区分大小写，其中s1=s2。

(7) 字符串的分割

1)string[] split(params char[] separator);将字符串按照指定的分隔符分割为字符串数组。

2)string[] split(char[] separator,StringSplitOptions options将字符串按照指定的char分隔符分割为字符串数组（options取RemoveEmptyEntries的时候移除结果集中的空白字符串）。

例如：

string str=”How are you? Fine,Thank you!”;

char[] removechar={‘ ’,’?’,’,’,’!’};

string[] words=str.split(removechar,StringSplitOptions.RemoveEmptyEntires);

Console.WriteLine(words.Length);

Console.WriteLine(“这几个单词分别为：”);

for(int i=0;i<words.Length;i++)

{

       Console.WriteLine(words[i]+”  ”);

}

Console.Readkey();

例题：string date=”2012/3/25”;

string[] sp=date.split(new chart[]{‘-’,’/’},StringSplitOptions.RemoveEmptyEntries);

Console.WriteLine(“您刚刚输入的时间为：{0}年{1}月{2}日”,sp[0],sp[1],sp[2]);

Console.Readkey();

(8) 字符串的替换：string Replace(string oldvalue,string newvalue)将字符串中出现的oldvalue的地方替换为newvalue。

(9) 取子字符串

1) string Substring(int startIndex),取从位置startIndex开始一直到最后的子字符串。

       2) string Substring(int startIndex,int Length),取从位置startIndex开始长度为Length的子字符串，如果子字符串的长度不足，则会报错。

              string result=str.SubString(6,2);

(10) bool contains(string value)判断字符串中是否含有子字符串。

   Console.WriteLine(“请输入您想说的一句话？”);

   string cen=Console.ReadLine();

   string[] words={“自由”,”和谐”,”韩迎龙”,”共匪”};

int i=0;

for(i=0;i<words.Length;i++)

{

if(cem.contains(words[i]))

{

        cen=cen.Replace(words[i],”****”);

        break;

}
}

if(i<words.Length)

{

        Console.WriteLine(“您输入的内容中含有非法字符”);

}

else

{

        Console.WriteLine(“您刚刚输入的{0},发表成功！”,cen);

}

Console.ReadKey();

(11) bool startsWith(string value) 判断字符串是否以子串value开始。

(12) bool EndsWith(string value) 判断字符串是否以子串value结束。

(13) int IndexOf(string value);取子串value第一次出现的位置。

        int IndexOf(string value,int StartIndex);

例如：string str=”Hello.World”;

        Console.WriteLine(str.IndexOf(“0”,5));