Java基础学习——多态

学习资料：

• Thinking in Java 第8掌

面相对象的程序语言三大基本特征：

抽象，继承，多态

多态从另一种角度将接口与实现分离：怎么做和做什么

对象既可以做本身使用，也可以当作基类使用。对某个对象的引用视为对其基类的引用的做法称为向上转型

---

将一个方法调用同一个方法关联起来成为绑定。若在程序执行之前进行绑定，叫做前期绑定。面向过程的语言默认的方法绑定方式，例如C

面向对象的语言采用的是后期绑定，在运行时根据对象的类型进行绑定

在Java中除了static，final方法外，private方法属于隐式final方法，构造方法属于隐式static方法，其他所有的方法都是前期绑定

将一个方法声明为final的原因：

有效关闭动态绑定。告诉编译器不需要对其进行动态绑定，这样，编译器可以为final调用生成更有效的代码。但将方法声明成final对程序的整体性能并不会有什么改观。要根据设计需要来确定是否使用final，而不是出于试图提高性能的目的滥用final

以前看到网上有人说能用就用final，理解有偏差，有点滥用了，得改

多态是一项让程序员“将改变的事物和未变的事物分离开来”

只有非private的方法，子类才能覆盖，否则就算是子类的新方法

非静态的方法可以被子类覆盖，而静态的方法子类无法进行覆盖

静态方法与类相关，而并非与单个对象相关联

---

父类的构造法方法总是在子类的构造方法中被调用，并按照继承层次逐渐向上链接，以使每个父类的构造方法都能得到调用

子类只能访问自己的成员，不能访问父类的private成员

一个复杂子类的构造方法调用顺序：

1. 调用父类的构造方法。这一步会反复递归下去，首先是根父类，然后下一层的父类，直到最低层的父类
2. 按声明顺序调用类成员的的初始方法
3. 子类自身的构造方法

在第一步之前，所有类未进行初始化，初始化父类前，将分配给子类对象用来初始化的存储空间初始化成二进制的0。书P163页构造方法内的多态行为，案例

简单例子：

class Meal
{
    public Meal(){
         System.out.println("Meal()");
    }  
}

class Bread
{
    public Bread(){
        System.out.println("Bread()");
    }   
}

class Cheese
{
    public Cheese(){
        System.out.println("Cheese()");
    }
   
}

class Lettuce
{
    public Lettuce(){
        System.out.println("Lettuce()");
    }
   
}

class Lunch extends Meal
{
    public Lunch(){
        System.out.println("Lunch()");
    }
   
}

class PortaleLunch extends Lunch
{
    public PortaleLunch(){
         System.out.println("PortaleLunch()");
    }
  
}


class Sandwich extends PortaleLunch
{
    private Bread b = new Bread();
    private Cheese c = new Cheese();
    private Lettuce l = new Lettuce ();
    public Sandwich(){
       System.out.println("Sandwich");
    }
    public static void main(String[] args) 
    {
        new Sandwich();
    }   
}

运行输出：

构造方法调用顺序

首先是根父类Meal，最后才是子类Sandwich自身

---

通过组合或者继承来创建新的类时，无需担心对象的清理问题，子类对象通常都会留给垃圾回收器进行处理

销毁并交给垃圾回收的过程与创建过程相反

编写构造方法一条有效准则：

用尽可能简单的方法使对象进入正常状态，如果可以的话，尽量避免调用其他的方法，尤其是覆盖的父类方法。在构造方法内，唯一能保证安全调用的方法是父类的final类型的方法，final方法不能被覆盖，也就不会存在啥安全隐患

---

乱起八糟的，过几天回头看，就会看不懂了吧 ：）