学点设计模式0x1 面向对象基础（2）

封装

    每个对象都包含它能进行操作所需要的所有信息，这个特性 成为封装，因此对象不必依赖其他对象来完成自己的操作。

    封装的好处：

        1.良好的封装能够减少耦合
        2.类内部的实现可以自由地修改
        3.类具有清晰的对外接口

private void button2_Click(object sender,EventArgs e){
    Dog dog = new Dog("旺财");
    dog.ShoutNum = 5;
    MessageBox.Show(dog,Shout());
}

继承

    对象的继承代表了一种‘is-a’的关系，如果两个对象A和B，可以描述为‘B是A’，则表明B可以继承A。继承者可以理解为对被继承者的特殊化，因为它除了具备继承者的特性外，还具备自己都有的特性。
    继承定义了类是如何相互关联，共享特性。继承的工作方式是，定义父类和子类，或者叫做基类和和派生类，其中子类继承父类的所有特性。子类不但继承了父类的所有特性，还可以定义新的特性。

    如果子类继承于父类，第一、子类拥有父类非private的属性和功能；第二，子类具有自己的属性和功能，即可以扩展父类没有的属性和功能；第三、子类还可以以自己的方法实现父类的功能（方法重写） 

     protected

    表示继承时子类可以对基类有完全访问权，即用protected修饰的类成员，对子类公开，但不对其他类公开。

class Cat{
    private string name = "";
    public Cat(string name){
        this.name = name;
    }
    public Cat(){
        this.name = "无名";
    }
    private int shoutNum = 3;
    public int ShoutNum{
        get{
            return shoutNum;
        }
        set{
            shoutNum = value;
        }
    }
    public string Shout(){
        string result = "";
        for(int i=0;i<shoutNum;i++){
            result+="喵 ";
        }
        return "我的名字叫"+name+" "+result;
    }
}

class Dog{
    private string name = "";
    public Dog(string name){
        this.name = name;
    }
    public Dog(){
        this.name = "无名";
    }
    private int shoutNum =3;
    public int ShoutNum{
        get{
            return shoutNum;
        }
        set{
            shoutNum = value;
        }
    }
    public string Shout(){
        string result = "";
        for(int i=0;i<shoutNum;i++){
            result+="汪   ";
        }
    return "我的名字叫"+name+"  "+result;}
}

class Animal{
    protected string name = "";
    public Animal(string name){
        this.name = name;
    }
    public Animal(){
        this.name = "无名";
    }
    protected int shoutNum = 3;
    public int ShoutNum{
        get{
            return shoutNum;
        }
        set{
            shoutNum = value;
        }
    }
}

    子类从它的父类中继承的成员有方法、域、属性、事件、索引指示器，但是对于构造方法，有一些特殊，他不能被继承，只能被调用。对于调用父类的成员，可以用base关键字。

class Cat : Animal{//继承的格式 子类:父类
    public Cat():base(){
        //子类构造方法需要调用父类同样参数类型的构造方法，用base关键字代表父类
    }
    public Cat(string name):base(name){
        
    }
    public string Shout(){
        string result = "";
        for(int i=0;i<shoutNum;i++)
            result +="喵 ";
        return "我的名字叫" +name+" "+result;
    }
}

class Dog : Animal{
    public Dog():base(){}
    public Dog(string name):base(name){}
    public string Shout(){
        string result ="";
        for(int i=0;i<shoutNum;i++)
            result +="汪 "；
        return "我的名字叫"+name+" "+result;
    }
}

    不用继承的话，如果要修改功能，就必须在所有重复的方法中修改，代码越多，出错的可能性就越大，而继承的优点是，继承使得所有子类公共的部分都放在了父类，使得代码得到了共享，这就避免了重复，另外，继承可使得修改或扩展继承而来的实现都较为容易。

    继承也是有缺点的，那就是父类变，则子类不得不变。另外，继承会【破坏包装，父类实现细节暴露给子类，增大了两个类之间的耦合性。

 多态

private Animal[] arrayAnimal;//声明一个动物数组
//"动物报名"的按钮事件
private void button3_Click(object sender,EventArgs e){
    arrayAnimal = new Animal[5];
    //...
}
//"叫声比赛"的按钮事件
private void button4_Click(object sender,EventArgs e){
    foreach(Animal item in arrayAnimal){
        MessageBox.Show(item.Shout());
    }
}

    多态表示不同的对象可以执行相同的动作，但要通过他们自己的实现代码来执行。
    1.子类以父类的身份出现；2.子类在工作时以自己的方式来实现；3.子类以父类的身份出现时，子类特有的属性和方法不可以使用

    为了使子类的实例完全接替来自父类的类成员，父亲必须将该成员声明为虚拟的。这是通过在该成员的返回类型之前添加virtual关键字来实现。通常虚拟的是方法，但是其实除了字段不能是虚拟的，属性、事件和索引器都可以是虚拟的。尽管方法可以是虚拟的，但是虚方法还是有方法体，可以实际做些事情。然后，子类可以选择使用override关键字，将父类实现替换为它自己的实现，这就是方法重写Override,或者叫做方法覆写。

class Animal{
    //...
    public virtual string Shout(){
    //virtual表示此方法是虚方法，可以被子类重写
        return "";
    }
}

class Cat : Animal{
    public Cat() : base(){}
    public Cat(string name) : base(name){}
    public override string Shout(){
        string result = "";
        for(int i=0;i<shoutNum;i++)
            result += "喵  ";
        return "我的名字叫"+name +""+result;
    }
}

private Animal[] arrayAnimal;
//"动物报名"的按钮事件
private void button3_Click(object sender,EventArgs e){
    arrayAnimal = new Animal[5];
    arrayAnimal[0] = new Cat("小花");
    arrayAnimal[1] = new Dog("阿毛");
    arrayAnimal[2] = new Dog("小黑");
    arrayAnimal[3] = new Cat("娇娇");
    arrayAnimal[4] = new Cat("咪咪");
}
//“叫声比赛”的按钮技巧
private void button4_Click(object sender,EventArgs e){
    foreach(Animal item in arrayAnimal){
        //由于有了多态性，所以程序会去找item是什么对象，然后用哪个重写方法
        MessageBox.Show(item.Shout());
    }
}

    不同的对象可以执行相同的动作，但要通过它们自己的实现代码来执行。多态的原理是当方法被调用时，无论对象是否被转换为其父类，都只有位于对象继承链最末端的方法实现会被调用。也就是说，虚方法是按照其运行时类型而非编译时类型进行动态绑定调用的，