1.面向对象基础(封装、继承、多态、抽象类)0711

  

小技巧：F12转向定义，ctrl+E+D对齐代码,ctrl+R+E封装字段

面向对象

    封装 继承 多态

对象：世间万物皆对象

    一切事物都是对象

    对象是一个具体的，

    对象的组成：一个是特征（属性），一个行为（方法）

 

类：是抽象的概念，是一种数据类型，引用类型

    类是创建对象的模板

空的构造函数，带参数的构造函数；字段，属性(ctrl+R+E)；方法

    类组成：字段、属性、方法、构造函数、事件等

 

    同一个cs文件中可以有多个类

 

    类的语法：

        [访问修饰符] class 类名

        {

        }

字段的命名：骆驼命名

属性：是一个聪明的字段。封装字段。  帕斯卡命名

 

    [访问修饰符]  数据类型  属性名

    {

        get{}

        set{}

    }

属性三种形式：

    读写属性，既有get访问器，又有set访问器

    只读属性，只有get访问器

    只写属性，只有set访问器

 

 

 

 

变量的作用域

    局部变量：方法内部的变量

    成员变量：直接属于类的变量

 

构造函数：是一种特殊的方法，给类初始化（给类内部的字段初始化）

    没有返回值，名字必须和类名一致

    [访问修饰符] 类名([参数列表])

    {

    }

 

 

实例成员 静态成员

 

    静态方法  方法使用static去修饰

           调用的时候使用  类名.方法名()  例：Console.WriteLine("")

    实例方法  对象名.方法名()    

          例：  Student stu = new Student();

            stu.SayHi();

           

    静态成员属于类所有，非静态成员属于类的实例所有。

    C#静态方法属于类所有，类实例化前即可使用

    在实例方法中可以直接调用静态方法，

    在静态方法中不可以直接调用实例方法

    静态方法和静态变量创建后始终使用同一块内存(静态存储区)，而使用实例的方式会创建多个内存

案例：猜拳

 

封装  黑匣子 隐藏具体实现

继承

    使代码可以重用

    子类继承父类的属性和方法 :

    单根继承性 继承具有传递性

 

    所有的类都直接或间接的继承自Object

   

    this 代表当前类的实例,base 代表父类的实例

    子类构造函数必须指明调用父类哪个构造函数

    访问级别约束

        子类的访问级别要比父类的低

        方法、属性等暴露的返回值、参数的数据类型不能比方法、属性或者所在类的可访问级别低

   

       

多态  不同对象执行同一行为（方法）有不同的表现

   

    里氏替换原则

        让父类引用指向子类对象

        Person per = new Student();

        per是父类的引用，它不知道有哪些子类

        不能使用父类的引用，调用子类的成员

 

    is  if (shapes[i] is Circle)

    as  Circle cir = shapes[i] as Circle;  如果转换失败返回null

   

    熟练计算形状的案例

(1)Person.cs（父类）

Person p = new Person();

            p.Name = "张三";

            Console.WriteLine(p.ToString());//输出"张三",若是不重写ToString,则输出"_08_多态.Person"

 

        public override string ToString()

        {

            return name;

        }

(2)Student.cs:

public override string ToString()

        {

            return "学生的姓名"+ base.name;

        }

====================================================================================

            //里氏替换原则

 

            //让父类引用指向子类对象

           Person p = new Student("张三",18,"男");

           //判断p对象是否是Student类型

            if (p is Student)

           {

               Console.WriteLine("学生");

           }

           // 类型转换 只能转换引用类型

           Student s = p as Student;

           if (s != null)

           {

               s.SayHello();

           }

//类也是一种数据类型，而且是引用类型，记住下面的这种用法

Person[] pers = {

                                new Student("张三",18,"男"),

                                new Student("李四",18,"男"),

                                new Student("王五",18,"男"),

                                new Teacher("老杨",18,"男"),

                                 new Teacher("老赵",18,"男"),

                                  new Teacher("老邹",18,"男")

                            };

            foreach (Person item in pers)

            {

                if (item is Student)

                {

                    //Student s = item as Student;

                    //s.SayHello();

                    Console.Write("学生  ");

                }

                else if (item is Teacher)

                {

                    Console.Write("老师  ");

                }

                item.SayHi();

            }

抽象类和抽象方法 abstract

    抽象类

        不能被实例化的类  不能去new

        !!抽象类用来实现继承 和 多态

        抽象类定义的是公共的实现和能力（抽象方法，没有实现）

        抽象类中可以包含抽象成员，也可以不包含

        抽象类不能被密封

    抽象方法

        抽象方法不能有实现

      抽象方法必须出现在抽象类中

      抽象方法必须被子类重写(override)，除非子类也是抽象类

子类必须实现(重写)父类中的所有抽象方法

 

(1)Person.cs(父类)

    public abstract class Person

{

    //abstract抽象

        //抽象方法，抽象方法不能有实现

        //抽放方法  必须出现在抽象类中

        //抽象方法 必须在子类中重写

        public abstract void SayHi();//注意不能实现，即不能有大括号{}

        public abstract void Standup();

}

(2)Student.cs(子类)

子类继承抽象类，必须重写抽象类中所有的抽象方法

 

        //重写抽象方法

        public override void SayHi()

        {

            Console.WriteLine("大家好，我是"+base.name+"学生");

        }

 

        public override void Standup()

        {

            Console.WriteLine("老师好");

        }

(3)Teacher.cs(子类)

public override void SayHi()

        {

            Console.WriteLine("同学们好，我是"+base.name+"老师");

        }

 

        public override void Standup()

        {

            Console.WriteLine("起立");

        }

Shape[] shapes = {

                             new Circle(5),

                             new Circle(6),

                             new Circle(7),

                             new Square(10,20),

                             new Square(20,40)

                             };

 

            foreach (Shape shape in shapes)

            {

                if (shape is Circle)

                {

                    Circle c = shape as Circle;

                    Console.WriteLine("园==" + "半径："+c.R);

                }

                else if (shape is Square)

                {

                    Square s = shape as Square;

                    Console.WriteLine("矩形=="+"长："+s.Width + "---高:"+s.Height);

                }

                Console.WriteLine("面积：" + shape.GetArae());

                Console.WriteLine("周长：" + shape.GetLong());

            }

多态的作用：把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。