黑马程序员《.NET 面向对象》

------- Windows Phone 7手机开发、.Net培训、期待与您交流！ -------

(1)面向对象

面向对象的三大特性：封装，继承，多态。

封装：保证对象自身数据的完整性和安全性。

继承：建立类之间的关系，实现代码复用，方便系统的扩展。

多态：相同的方法调用可实现不同的实现方式。

何为封装？

封装又称信息隐藏，指利用抽象数据类型将数据和数据的操作结合在一起，使其构成一个不可分割的独立实体，尽可能隐藏内部的细节，只保留一些对外接口，使之与外部发生联系。(将字段封装成属性就属于封装的一种，类的私有方法也是一种封装，它的范围很广)

封装的好处：保证数据的安全性；提供清晰的对外接口；类内部实现可以任意修改，不影响其它类。

什么是泛型？

泛型是c#2.0中的一个新特性，通过泛型就可以定义类型安全的数据类型。

它的最常见应用就是创建集合类，可以约束几何类中的元素类型，比较典型的泛型集合List<T>和Dictionary<K,V>

 ,List<T>:语法：List<T> 对象名=new List<>;

 T可以对集合中的元素类型进行约束，当其他类型的数据加入到集合中时，编译就会报错。

例如： List<SE> engineers=new List<SE>();
           SE jack = new SE();//初始化三个工程师员工
           SE joe = new SE();
           SE ema= new SE();
           PM pm = new PM();
           engineers.Add(jack);
           engineers.Add(joe);
           engineers.Add(ema);
           engineers.Add(pm);//此处编译时会报错

List<T>与ArryList区别：

相同点：通过索引访问集合中的元素，添加元素方法相同，删除元素方法相同。

不同点：前者对保存元素做类型约束，添加/读取值类型元素无需拆箱，装箱。而后者可以添加任何类型，添加/读取值类型元素需要拆箱，装箱。

Dictionary<K,V>语法：

它具有泛型的全部特性，编译时检查类型约束，获取元素时无需类型转换。

Dictionary<K,V> 对象名=new Dictionary<K,V>();

Dictionary<String,SE> engineers=new Dictionary<String,SE>();

Dictionary<K,V>与Hashtble(哈希表)的对比：

相同点：通过Key获取Value，添加元素方法相同，删除元素方法相同，遍历方法相同。

不同点：前者对保存元素做类型约束，添加/读取值类型元素无需拆箱，装箱。而后者可以添加任何类型，添加/读取值类型元素需要拆箱，装箱。

泛型的有点：

①性能高，ArryList添加元素时都是object类型，如果添加一个值类型，就需要把它转化为引用类型，而取出这个元素时又需要转换为它对应的值类型，这就需要装箱和拆箱的操作，而泛型无需类型的转换操作。

②类型安全，泛型集合对它所存储的对象做了类型的约束，不是它所允许处处的类型是无法添加到泛型集合中的

③实现代码的复用。

什么是继承？

继承是面向对象编程中的一个非常重要的特性，通过类的继承，既可以扩展类的功能，又可以复用类的功能。

子类构造函数，父类起了哪些作用：

①隐式调用父类构造函数

当创建子类对象时会首先调用父类的构造函数，然后才会调用子类本身的构造函数，如果不指定要调用父类的哪一个构造函数，那么系统隐式的调用父类的无参构造函数。

②显示调用父类构造函数

c#中可以用base关键字调用父类的构造函数，实现继承属性的初始化，然后在子类本身的构造函数中完成对子类特有属性的初始化。base关键字调用父类构造函数时，只能传递参数。

*在子类中，如果不使用base关键字来显示调用父类构造函数，则将隐式调用默认的构造函数。

继承的两大特性：

传递性:例如，classA:B,classB,C,则A也可以访问C的成员。

单根性:一个类不能够同时继承自多个父类。

子类继承父类的成员，并且可以有自己的成员。

什么是多态？

多态是指两个或多个属于不同类的对象，对于一个消息作出不同相应的方式。可以用虚方法实现多态。

如何实现多态？

①实现方法重写，父类中定义SayHi()方法，用virtual关键字定义为虚方法。

例如：public virtual  string SayHi()

{问好方式}

②在子类中定义子类自己的SayHi()方法，用override关键字修饰，就实现了对父类SayHi()方法的重写

例如：public override  string SayHi()

{问好方式}

③定义父类变量，用子类对象初始化父类变量

(2)类和对象

类是创建对象的模板，对象是类的一个具体实例，这就是类和对象之间的关系，必须先有类，才能有对象，在面向对象的世界中，不同类型的事和物都称为对象，也就是一切皆对象。但对象必须是实实在在存在的一个物体。

在类中可以包含字段，属性和方法，每个类可以使用访问修饰符来设置该类的访问权限。

程序中我们把特征称为属性，行为动作称为方法。

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

装箱和拆箱：数据的存储方式可以分为值类型和应用类型，两者仍然可以互换，将值类型转换为应用类型的过程成为装箱，反之成为拆箱。

 static void Main(string[] args)
        {
            int i = 123;
            object o = i;//装箱，值类型转化成应用类型
            int j = (int)o;//拆箱，应用类型转化成值类型
            Console.WriteLine(i);
            Console.WriteLine(o);
            Console.ReadKey();

(3)类的实例化

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

语法：类名  实例名=new  类名()

如何访问类的属性和方法？

实例名.属性    实例名.方法名()  

在我们自己写的方法中我们一般不加static。只要是不加static的方法或者属性，都必须先实例化再通过  实例名.方法名或者  实例名.属性来访问，加static的方法或属性，可以直接通过类名.方法名或  类名.属性来访问。

什么叫属性？

通俗的说就是定义一个public的具有get/set 方法的变量，这个变量是用于保护一个私有变量。

凡是允许外部访问的变量一定要声明为属性，定义成属性的好处是可以进行非法值判断。

属性分为三种：读写，只读，只写

读写：具有get/set方法的属性

只读：只有get方法的属性，只能读数，不能写入

只写：只有set方法，一般没太大用处。

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

数字类型初始化成：0/0.0/0.0m

string类型初始化成：null

char类型初始化成：\0 

字段和属性的区别？

属性看似是字段，但不是字段，可以进行非法值控制，可以设置只读。

(4)下面具体参照一个实例来理解

我们定义一个Person类声明它的三个属性和两个方法

代码区：

namespace 面向对象
{
    class Person  //联系定义一个人类，人类分别用三个变量来表示起年龄，性别，名字
                  //有一个打招呼的方法，有一个走路的方法
    {
        public string name;
        public char sex;
        private int age;

        //定义一个变量，在这个变量中含有get/set两个方法，我们就叫做属性
        public int Age  //我们通过一个公共的Age来保护私有的age ，用户输入负数会被转成0
        {               //保证用户输入的数据合法
            get
            {
                return age;
            }
            set
            {
                //这里有个关键字，value中就是存储着用户赋的那个值
               if(value>=0)
                {
                    age=value;
                }
                else
                {
                    age=0;
                }                    
            }
        }
        public void SayHello()//此处能访问到name  age sex 是因为他们在同一个类中
        {
            Console.WriteLine("我叫{0}，今年{1}岁了，我是{2}性",
                name,age,sex);
        }
        public void Go()
        {
            Console.WriteLine("{0}在路上！",name);
        }
    }
}
在以上程序中我们定义了一个Person类，并且声明了它的三个属性 name  sex  age，我们把age的访问修饰符改为了private，用来保护用户输入值的合法性。

下面我们在另一个类中通过实例化来访问它

 

代码区：

namespace 面向对象    //命名空间
{
    class Program       //类
    {
        static void Main(string[] args) //  类中的成员
        {

            //Person zsPerson = new Person();
            Person zsPerson;//定义了一个变量，这个变量的类型是Person类型
            zsPerson = new Person();//通过new关键字来产生一个Person对象，并把Person产生的
            //对象赋给zsPerson

            Person lsPerson = new Person();

            zsPerson.name = "张三";
            zsPerson.sex = '男';

            zsPerson.Age = 18;//改成private后的访问方法

            lsPerson.name = "李四";
             lsPerson.sex = '男';
            lsPerson.Age = 16;

            zsPerson.SayHello();//调用张三sayhello方法  调用法则：实例名.方法名（）
            zsPerson.Go();    //调用张三GO方法

            lsPerson.SayHello();
            lsPerson.Go();
            Console.ReadKey();
        }     
    }
}

在Program类中我要访问Person的属性及方法，就要通过实例化来进行访问，Person zsPerson = new Person();这样我们就对Person这个类进行了实例化，然后通过实例名.属性  和 实例名.方法  来进行访问并进行赋值。

 

易错点，重点总结

静态方法和实例方法区别：

静态方法                               实例方法

①static关键字                          ①不需要static关键字

②使用类名调用                                                      ②使用实例对象调用

③在静态方法中，可以访问静态成员           ③实例方法中，可以直接访问静态成员

④在静态方法中，不可以直接访问实例成员      ④在实例方法中，可以直接访问实例成员

⑤调用前初始化                          ⑤实例化对象时初始化

在static方法中可以调用到其它static方法，字段，属性，但是不能调用到非static方法，字段，属性，在非static方法中可以调用到static的方法，字段，属性。

static类变量是全局变量

静态类有何特点：不能被new的类就是静态类

命名空间的意义(namespace):解决类的重名问题，可以看做是类的文件夹。

 

------- Windows Phone 7手机开发、.Net培训、期待与您交流！ -------