3.27-3.28学习总结

类的继承：http://t.csdn.cn/vhf6p

多态，封装，包，static，初始化块：http://t.csdn.cn/g56SQ

继承与组合

代码复用的两种手段。

继承的缺点：父类的细节对子类不再透明，破坏父类封装性。

应当

1. 尽量将父类成员变量用private修饰
2. 父类中的辅助方法应用private修饰
3. 不希望被子类重写的方法用final修饰
4. 希望被重写，但不希望被外部访问，用protected修饰
5. 尽量不要在父类构造器中调用将被覆写的方法

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello world!");
        Sub sub=new Sub();//null
    }
}
class Base{
    private int date;
    public int getDate(){
        return date;
    }
    public void setDate(int x){
        date=x;
    }
    public void test(){
        System.out.println("将被覆写");
    }
    public Base(){
        test();
    }
}
class Sub extends Base{
    private String mine;
    public void test(){
        System.out.println(mine);
    }
}

不想被继承除了可以用final修饰，还可以将父类构造器用private修饰，提供一个static方法创建实例。（感觉没什么用）

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello world!");
        SuperClass sup=SuperClass.Constructor(6);//
        System.out.println(sup.getDate());//6
    }
}
class SuperClass{
    private int date;
    private SuperClass(int x){
        date=x;
    }
    public static  SuperClass Constructor(int x){
        return new SuperClass(x);
    }
    public int getDate(){
        return date;
    }
    public void setDate(int x){
        date=x;
    }
}
class SubClass extends SuperClass{

}//无法继承，找不到构造器

---

组合

继承实现代码复用

public class Main {
    public static void main(String[] args) {
        Cat A=new Cat();
        Dog B=new Dog();
        A.Call();
        A.eat();
        B.Call();
        B.eat();
    }
}
class Animal{
    public void eat(){
        System.out.println("eating");
    }
}
class Cat extends Animal{
    public void Call()
    {
        System.out.println("喵喵喵");
    }
}
class Dog extends Animal{
    public void Call()
    {
        System.out.println("汪汪汪");
    }
}

组合实现代码复用

public class Main {
    public static void main(String[] args) {
      Cat A=new Cat();
      Dog B=new Dog();
      A.Call();
      A.eat();
      B.Call();
      B.eat();
    }
}
class Animal{
    public void eat(){
        System.out.println("eating");
    }
}
class Cat{
    Animal t=new Animal();
    public void Call()
    {
        System.out.println("喵喵喵");
    }
    public void eat(){
        t.eat();
    }
}
class Dog{
    Animal t=new Animal();
    public void Call()
    {
        System.out.println("汪汪汪");
    }
    public void eat(){
        t.eat();
    }
}

分析：

从代码复用的角度，二者效果一致

在继承中，子类是父类的扩展。那么在组合里面，同样可以让旧类做为新类的一部分，到达扩展目的。

从封装性的角度，

在继承中，为了保证父类的良好封装性，在设计父类时，限制较多。但是，组合中，一个封装良好的旧类就不用顾虑会暴露给新类。

从逻辑的角度，

如果两个类符合is的关系，就可以用继承体现；如果符合has的关系，就可以用组合体现。