<Java SE详解> 序列三-

1、多态：父类型的引用可以指向子类型的实例对象，即子类就是父类；

2、

Parent p = new Child();
p.sing();

 当使用多态的方式调用方法时，通过p引用调用其中成员时是面向Parent父类中的成员进行调用，即首先检查父类中是否有sing()方法，如果没有sing()方法，调用时将会发生编译错误；如果有，再去调用子类中覆写父类成员方法的sing()方法。

 

3、一共有两种类型的类型转换：

　　a> 向上类型转换(upcast)：比如说将Cat类型转换为Animal类型，即将子类型转换为父类型。对于向上类型转换，不需要显式指定转换的类型，因为子类就是父类，属于自动类型转换。

　　b> 向下类型转换(downcast)：比如讲Animal类型的引用转换为Cat类型的引用。即将父类型引用转换为子类型引用。对于向下类型转换，需要显式进行强制类型转换。

　　但是这种强制类型转换并不是随便就能转换的，一定要看该父类型引用所指向的对象实例具体是什么类型的对象，例如：Animal类型的引用指向Cat类型的对象，因此在使用强制类型转换的时候只能向Cat类型的方向转换，而不能想Dog类型的方向转换。如果不正确使用，编译期不会报错，但是运行时会抛出ClassCastException异常。

一般来说，可以从父类型到所指向子类型之间所包含的继承树上的任意一个类型进行转换，例如：　　　　二十-15:00

package cn.edu.bupt.baseKnowledge;

public class Press {

    public static void main(String[] args) {
        Grandparent gp = new Child();
        Parent p = (Parent)gp;
        Child c = (Child)gp;
    }
}

class Grandparent {
    
}

class Parent extends Grandparent {
    
}

class Child extends Parent {
    
}

 

package cn.edu.bupt.baseKnowledge;

public class PolyTest3 {
    public static void main(String[] args) {
        Fruit f = new Pear();
        Pear p = (Pear)f;
        p.grow();
    }
}

class Fruit {
    public void run() {
        System.out.println("fruit is running");
    }
}

class Pear extends Fruit {
    public void run() {
        System.out.println("pear is running");
    }
    public void grow() {
        System.out.println("pear is growing");
    }
}

 

4、抽象类（Abstract class）：使用了abstract关键字所修饰的类叫做抽象类。抽象类无法实例化，也就是说，不能new出来一个抽象类的对象实例，但是可以使用抽象类定义一个引用变量。

5、抽象方法（Abstract method）：使用abstract关键字所修饰的方法叫做抽象方法，抽象方法不包含方法体，仅仅存在一个方法声明即可（有声明，无实现）。抽象方法需要定义在抽象类中。相对于抽象方法，之前所定义的方法叫做具体方法（有声明，有实现）。

抽象类中可以既存在具体方法又存在抽象方法。

package cn.edu.bupt.abstractclass;

public class Test {
    public static void main(String[] args) {
        T t = new T1();
        t.method1();
        t.method();
    }
}

abstract class T {
    public void method() {
        System.out.println("method in T");
    }
    abstract public void method1();
}

class T1 extends T {
    public void method1() {
        System.out.println("method1 in T1");
    }
}

6、如果一个类包含抽象方法（abstract method），那么这个类一定是抽象类，这个类一定要声明为abstract class；

7、如果一个类是抽象类（abstract class），那么这个类可以包含具体方法（有声明，有实现），也可以包含抽象方法（有声明，无实现）；

8、无论何种情况，只要一个类是抽象类，那么这个类就无法实例化，抽象类并不是由类中的方法是否实现为标准的，而是以class头部是否加入了abstract为参考标准。即使一个不含有任何抽象方法的abstract class 他仍然是一个抽象类；

9、在子类继承父类（父类是抽象类）的情况下，那么该子类必须要实现父类中所定义的所有抽象方法；否则，该子类仍然需要声明为一个abstract class。

 例：

package cn.edu.bupt.abstractclass;

public class Test2 {
    public static void main(String[] args) {
        Shape shape = new Triangle(10, 10);
        System.out.println(shape.computeArea());
        
        shape = new Rectangle(10, 10);
        System.out.println(shape.computeArea());
    }
}

abstract class Shape {
    public abstract int computeArea();
}

class Triangle extends Shape {
    private int width;
    private int height;
    
    public Triangle(int width, int height) {
        super();
        this.width = width;
        this.height = height;
    }
    
    @Override
    public int computeArea() {
        return (this.height * this.width) / 2;
    }
}

class Rectangle extends Shape {
    private int width;
    private int height;
    
    public Rectangle(int width, int height) {
        super();
        this.width = width;
        this.height = height;
    }

    @Override
    public int computeArea() {
        return this.width * this.height;
    }
}

10、接口（interface）：接口地位等同于class，接口中的所有方法全部都是抽象方法。在声明接口中的方法时，可以使用abstract关键字，也可以不使用。但通常情况下，都会省略掉abstract关键字。

接口的作用同抽象类的作用有些类似，都是定义了一些规范，内部定义了一系列方法，这些方法有声明无实现。

可以将接口看做是特殊的抽象类（抽象类中可以有具体的方法，也可以有抽象的方法，而接口中只能有抽象方法，而不能有具体方法）。

接口可以看做是所指对象的方法的指针的集合，相当于目标对象中方法的代理，通过这些方法指针可以方便的直接调用所指对象中的成员方法。

 

11、一个类实现了某个接口，那么该类必须要实现接口中声明的所有方法。如果该类是抽象类，那么可以不用实现接口中的全部方法。

 

12、多态：就是父类型的引用可以指向子类型的对象；或者接口类型的引用可以指向实现该接口的类的实例对象。

　　关于接口和实现类之间的强制类型转换方式与父类和子类之间的强制类型转换方式完全一样。（截短和扩容）

 

补充：

13、接口中所有的方法都是abstract抽象方法。而且每个成员的访问修饰符都是public类型，关键字可以省略；

14、接口中也可以定义成员变量。接口中的成员变量一定都是public、static、final的，但是这些关键字均可以省略。但是在实际开发中很少使用这种情况,通常情况下是在接口中定义抽象方法。

　　接口都主要是起到一个方法约定的作用，也就是所指对象的方法指针集合。

15、一个类不能既是final又是abstract，因为abstract的主要目的是定义一种约定，让子类去实现这种约定，而final表示该类不能被继承，这样abstract希望该类可以被继承而final明确说明该类不能被继承，两者矛盾。因此一个类不能既是final的，又是abstract的。