多态

前提：

• 有继承关系
• 有方法重写
• 有父类引用指向子类对象

类型：

• 具体类多态
• 抽象类多态
• 接口多态

访问特点：

• 变量只能使用父类中的
• 方法也只能使用父类中的，但是由于父类中的方法被重写，所以使用的是子类的。（注意子类中的非重写方法也不能使用）

转型：

public class draft {
    public static void main(String[] args) {
        Fu f = new Zi();//向上转型
        f.read();
        //f.play(); 报错

        Zi z = (Zi) f;//向下转型
        z.play();
    }
}

class Fu {
    public void read() {
        System.out.println("Fu看书");
    }
}

class Zi extends Fu {
    @Override
    public void read() {
        System.out.println("Zi看书");
    }

    public void play() {
        System.out.println("Zi玩");
    }
}

---

抽象类

特点：

• 抽象类中可以存在抽象方法（没有方法体的方法）（没有抽象方法也可）和具体方法
• 抽象方法只存在于抽象类中
• 抽象类不能实例化，但可以通过多态的方式使用（注意子类要将抽象类的所有抽象方法重写）

public class draft {
    public static void main(String[] args) {
        Fu f = new Zi();
        f.read();
    }
}

abstract class Fu {
    public abstract void read();
}

class Zi extends Fu {
    @Override
    public void read() {
        System.out.println("Zi看书");
    }
}

成员特点：

• 可包含变量与常量
• 成员方法可以抽象也可以非抽象
• 可以有带参或无参方法（虽然不能实例化）

---

接口

类和接口关系：

• 一个类可以有多个接口（implements）
• 一个接口可以继承多个接口（extends）

成员特点：

• 成员变量默认被 public static final 修饰，即默认为常量
• 没有构造方法
• 成员方法默认被 public abstract 修饰，只能有抽象方法

---

内部类

访问特点：

• 内部类可以直接访问外部类成员，包括私有
• 外部类访问内部类要创建对象

类型：

成员内部类

//创建对象方法
a.b b = new a().new b();

class a {
    private int age = 10;//外部类私有方法

    class b {//成员内部类
        String name = "a";

        void show() {
            System.out.println(age + name);//可以访问外部类私有成员
        }
    }
}

局部内部类

class a {
    private int age = 10;

    void creat() {//位于方法中
        class b {
            String name = "a";

            void show() {
                System.out.println(age + " " + name);
            }
        }
        b b = new b();//必须在方法内创建对象才能使用
        b.show();
    }
}

匿名内部类

必须存在一个类（具体类和抽象类都可）或者接口

public class draft {
    public static void main(String[] args) {
        do_sth O1 = new do_sth();
        O1.method(new a() {

            @Override
            void try_to() {
                System.out.println("try");
            }
        }/*这一部分就相当于进行了实例化，但是并不用有一个具体的对象，这就是所谓的匿名*/).try_to();

        new b() {

            @Override
            public void show() {
                System.out.println("b");
            }
        };
    }
}

abstract class a {
    abstract void try_to();
}

interface b {
    void show();
}

class do_sth {
    a method(Object o) {
        return (a) o;
    }
}