面向对象（二）——三大特性（封装、继承、多态）

一、封装

目的：保护类，让类更加安全。

做法：让类里面的成员变量变为私有（即访问修饰符）的，做相应的方法或者属性去间接的操作成员变量

※访问修饰符

private 私有的              只能在该类中访问

protected 受保护的       只能在该类和它的子类中访问

public 公有的                在任何地方都可以访问

△封装成员方法来间接操作类里面的成员变量

例：

class Ren
    {
        private string name;
        private int age;  //年龄必须在18-50之间
        //取age的值
        public int GetAge()
        {
            return age;
        }
        //给age赋值
        public void SetAge(int a)
        {
            if (age >= 18 && age <= 50)
            {
                age = a;
            }
            else
            {
                age = 18;
            }
        }
        //取name的值
        public string GetName()
        {
            return name;
        }
        //给name赋值
        public void SetName(string n)
        {
            name = n;
        }
    }

static void Main(string[] args)
        {
            Ren r = new Ren();
            r.SetAge(8);
            r.SetName("张三"); //将’张三‘赋值给成员name
            Console.WriteLine(r.GetAge+r.GetName);
            Console.ReadLine();
        }

△使用成员属性来间接访问类里面的成员变量

　　定义变量的时候最好用_下划线开头

　　选中要做的成员变量右键→重构→封装字段（ctrl+r,e）

      自动生成的代码不是成员变量也不是成员方法  是成员属性

      造好之后可以通过成员属性操作成员变量

例：

class Student
    {
        private string _Name;
        public string Name
        {
            get { return _Name; }//简化的方法
            set { _Name = value; }
        }
        private int _Age;
        public int Age 
        {
            get { return _Age; }
            set 
            {
                if (value >= 18 && value <= 50)
                {
                    _Age = value;
                }
                else
                {
                    _Age = 18;
                }
            }
        }

        private string _Sex;
        public string Sex {get;set;}//简写 缺点：不能控制值，不能用于构造函数
    }

 

static void Main(string[] args)
        {
            Student s = new Student();
            s.Name="赵四";
            s.Sex="男";
            s.Age=19;
            Console.WriteLine(s.Sex+s.Name+s.Age);
            Console.ReadLine();
        }

构造方法（函数）：

作用：造对象所要调用的方法，用来创建对象

　　    每一个类都有一个构造方法，不写也有只不过看不到而已

特殊性：写法特殊 （方法名=类名；没有返回值）

　　　　  执行时间特殊（创建对象时执行）

用途：可以对成员进行初始化

举个例子：

class Student
    {
        public Student(string s,string n)
        {
            _Sex = s;
            _Name = n;
        }
    }

static void Main(string[] args)
        {
           Student s = new Student("男","张三");//new Student()就是调用了一个方法

            Console.WriteLine(s.Sex+s.Name);
            Console.ReadLine();
        }

举个栗子：使用面向对象来求两个圆之间的面积

class Program
    {
        static void Main(string[] args)
        {
            Yuan y1 = new Yuan();
            y1.R = 10;
            Yuan y2 = new Yuan();
            y2.R = 5;

            double cha = y1.mianji() - y2.mianji();
            Console.WriteLine(cha);
            Console.ReadLine();
        }
    }
    class Yuan
    {
        private int r;

        public int R
        {
            get { return r; }
            set { r = value; }
        }
        public double mianji()
        {
            return r * r * 3.14;
        }
        public double zhouchang()
        {
            return 2 * r * 3.14;
        }
    }

函数重载：

函数重载需要的条件：函数名要相同，参数的个数或者参数的类型不同

this关键字：

虽然写在类里面，但不是属于类的，而是属于该对象的

一般来说在类里面 this关键字是可以省略的，但是如果有一个方法形参名字和成员名字重复，这时候再调用该对象里面的成员的时候需要加this关键字

is关键字： 判断变量是不是属于某个类型

例：if (y2 is Ren) 　　

    { 　　　　

                 s = "是一个人"; 　　

    } 　　

    else 　　

    { 　　　　

                s = "不是一个人"; 　　

    }

as关键字： 转换类型（只能转换兼容类型，可以将子类对象转换为父类对象）

二、继承

子类可以继承父类的一切

特点：单继承   一个子类只能有一个父类  一个父类可以有多个子类

C#特殊点：所有类的祖先都是object

base关键字：在子类中代表父类对象，用法和this关键字相同 　　　　　　  

                   如果父类有构造方法，那么子类也要有构造方法，如果父类构造需要参数，那么子类构造也必须有相应的参数。 　　　　　　  

                   子类构造后面可以通过base调用父类的构造方法 　　　　　　  

                   public China(string m):base(m) {}

class Program
    {
        static void Main(string[] args)
        {
            China c = new China("zs");
            Console.WriteLine(c.Eat());
            Console.ReadLine();
        }
    }

    class Ren
    {
        private string _Name;

        public string Name
        {
            get { return _Name; }
            set { _Name = value; }
        }
        private int _Age;

        public int Age
        {
            get { return _Age; }
            set { _Age = value; }
        }
        //父类的构造方法
        public Ren(string n)
        {
            _Name = n;
        }

        public string Speak()
        {
            return _Name+"人类正在讲话";
        }

    }

    class China:Ren
    {
        public China(string m):base(m)
        {
            
        }
        public string Eat()
        {
            return base.Name+"用筷子吃饭";
            //return base.Speak();
        }
    }
    class America : Ren
    {
        public America(string m): base(m)
        {
            
        }
        public string Eat()
        {
            return "用刀叉吃饭";
        }
    }

sealed关键字：

密封类 该类不可以被继承

sealed class 类名

{

}

部分类：partial

可以将一个类拆分成多个部分，分别放在多个文件内

调用需要namespace相同，或用use引用

namespace 命名空间 相当于虚拟文件夹

partial class 类名   //拆分的类均加partial

{

}

三、多态

1.编译多态

函数重载

2.运行多态

概念：当父类引用指向子类实例的时候，由于子类对父类的方法进行了重写，在调用该方法的时候表现出的不同就称为多态

条件：必须要有继承  父类引用指向子类实例  子类必须对父类的方法进重写

里氏代换原则：如果有一个地方需要使用到父类对象，那么你可以将一个子类对象给他

class Program
    {
        static void Main(string[] args)
        {
 　　　　    DongWu dw = new Dog();            
　　　　　　　Dog d = new Dog();
            Console.WriteLine(Ceshi(dw));
            Console.WriteLine(CeShi(d));
            Console.ReadLine();
        }

        public static string CeShi(DongWu d)
        {
            return "ok";
        }
    }

    class DongWu
    {
        public virtual string Eat() //虚方法
        {
            return "该动物在吃饭";
        }
    }
    class Dog:DongWu
    {
        public override string Eat() //重写
        {
            return "狗正在吃骨头";
        }
    }
    class Cat : DongWu
    {
        public override string Eat()
        {
            return "猫正在吃鱼";
        }
    }