Java基础——多态、抽象、接口、内部类

多态

如果失去了继承，多态就失去了意义。因此可以认为，没有继承，也就没有多态，一旦出现多态，那么一定出现了继承。那么何为多态？如下代码：

public class Animal {
    public String name = "animal";
    public void run(){
        System.out.println("动物跑起来了");
    }
}
public class Cat extends Animal{
    public String name = "cat";
    public void run(){
        System.out.println("猫跑起来了");
    }
}
public class Dog extends Animal{
    public String name = "dog";
    public void run(){
        System.out.println("狗跑起来了");
    }
}
public class Duck extends Animal{
    public String name = "duck";
    public void run(){
        System.out.println("鸭子跑起来了");
    }
}

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        System.out.println(cat.name);
        cat.run();

        Dog dog = new Dog();
        System.out.println(dog.name);
        dog.run();

        //向下转型，不需要强制转换
        Animal duck = new Duck();
        System.out.println(duck.name);
        duck.run();
        //多态的一种，在方法的参数上尤为多见,声明的时候使用的父类的类型，但是使用的时候用的又是子类的类型

        Animal animal = new Animal();
        //向上转型，必须强制转换，很容易引起转型失败
//        Dog dog1 = (Dog) cat;//cat与dog同级，不能向上转型
        Dog dog1 = (Dog) animal;

    }
}

在上述代码中，Animal类作为父类，而其下有三个子类，Cat、Dog、Duck。在主函数中我们可以很清楚的看见：

		Animal duck = new Duck();
        System.out.println(duck.name);
        duck.run();

这就是一个多态的例子，本来应该被声明为Duck的duck对象，实际上是被声明为父类的Animal，但是实例化却又是自己原本的Duck。而最终的结果为：

出现这一情况的原因在于，多态中有一句话，叫编译看左边，执行看右边，意思是：
成员变量用的哪一个取决于左边声明的类型，成员方法用哪个取决于右边实例化使用的类型

典型的多态使用

1. 当左边声明的类型是父类，但是右边new的是子类类型；

Animal duck = new Duck();

2. 方法的参数定义的是父类类型，具体使用时，传入的实际数据是子类对象。

多态的好处

提高了程序的扩展性，要更改只需要将右边实例化的类型进行更改就可以。
具体体现:定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作。

多态的弊端

不能使用子类的特有功能，多态之后，父类有哪些方法才能用哪些方法，只不过结果可以是子类重写的方法的结果。

转型

涉及到多态，那么也就不得不提到转型。

向上转型

子到父，需要强制转换，且很容易失败。向上转型，那么必须要和自己是同一个或者是自己的父类。

		Animal animal = new Animal();
        //向上转型，必须强制转换，很容易引起转型失败
//        Dog dog1 = (Dog) cat;//cat与dog同级，不能向上转型
        Dog dog1 = (Dog) animal;//animal的真实类型是dog的父类，所以可以

向下转型

父到子，不需要强制转换

//向下转型，不需要强制转换
        Animal duck = new Duck();
        System.out.println(duck.name);
        duck.run();

抽象

为什么要有抽象呢？
抽象本质上是为了应对封装在发生变化，即子类有很多情况，父类也无法明确子类到底要如何变化，于是这种变化被提取出来写为了抽象，由子类来具体实现每一种想要实现的变化。
可以理解为，抽象就是一个概念片，是在画大饼，具体的实现需要子类来实现，抽象类只是告知了会有这个东西。

抽象的特点

1. 抽象方法只有方法的声明，没有方法的实现；
2. 子类继承抽象类必须实现抽象方法（重写方法），除非子类本身也是抽象类；
3. 抽象类不能实例化，要实例化只能通过子类继承后重写方法后用子类实例化。

抽象类与一般类的异同

异

1. 抽象类需要使用abstract关键字；
2. 抽象类不能直接实例化。

同

1. 可以没有抽象方法（一般情况下一个抽象类至少要有一个抽象方法）；
2. 可以有任何类型的其他方法；
3. 可以有构造方法，但是不能实例化，构造方法的作用是用于子类访问父类数据的初始化；
4. 可以有成员变量。

接口

1. 接口是最高等级的抽象，是抽象的一种规则；
2. 使用关键字interface替代class；
3. 接口没有继承，只有实现（implements），而且接口可以多实现；
4. 接口里面只能有抽象方法，因此接口不能实例化，只能通过它的子类实现实例化；
5. 接口的成员变量只能是常量；
6. 接口没有构造方法；
7. 接口的成员方法只能是抽象方法。

抽象类与接口的区别

1. 一般情况下，如果接口里的抽象方法太多，那么把里面的抽象方法提取出来写成接口。
2. 抽象类有变量和常量，有构造方法，有抽象方法也有非抽象方法；接口只有常量和抽象方法。
3. 类与类之间有单继承；类与接口之间有实现关系（可以单实现也可以多实现）；接口与接口之间可以单继承也可以多继承。
4. 抽象类是对类的抽象，包括属性和行为；接口是对行为的抽象，主要是行为。

类与接口的关系

类与类之间有单继承；类与接口之间有实现关系（可以单实现也可以多实现）；接口与接口之间可以单继承也可以多继承（其实还是一种实现关系）。
接口之间的多继承，是Java之中唯一支持的多继承。

抽象和接口应用的例子

public abstract class AbsDoor {
    public double width;
    public double height;
    public String name;

    public AbsDoor() {
    }

    public AbsDoor(double width, double height, String name) {
        this.width = width;
        this.height = height;
        this.name = name;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public abstract void open();
    public abstract void close();
}

public interface IAlarm {
    void alarm();
}

public class WoodenDoor extends AbsDoor implements IDoor{
    public WoodenDoor() {
    }

    public WoodenDoor(double width, double height, String name) {
        super(width, height, name);
    }

    @Override
    public void open() {
        System.out.println("木门被打开了");
    }

    @Override
    public void close() {
        System.out.println("木门被关闭了");
    }
}

public class ElectricAlarmDoor extends AbsDoor implements IDoor,IAlarm{
    public ElectricAlarmDoor() {
    }

    public ElectricAlarmDoor(double width, double height, String name) {
        super(width, height, name);
    }

    @Override
    public void open() {
        System.out.println("电子报警门打开了");
    }

    @Override
    public void close() {
        System.out.println("电子报警门关闭了");
    }

    @Override
    public void alarm() {
        System.out.println("电子报警门开始报警了");
    }
}

public class DoorDemo {
    public static void main(String[] args) {
        WoodDoor woodDoor = new WoodDoor("木头门", 78.8, 189.92);
        ElectricAlarmDoor electricAlarmDoor = new ElectricAlarmDoor("高端电子门", 89.9, 188.88);

        woodDoor.open();
        woodDoor.close();
        electricAlarmDoor.open();
        electricAlarmDoor.close();
        electricAlarmDoor.alarm();
    }
}

内部类

内部类就是在一个类中定义一个类。内部类可以直接访问外部类的成员，包括私有。.外部类要访问内部类的成员，必须创建对象。

public class Person {
    private String name;
    private Address address;

    class Address{
        private String address;
    }

    public static void main(String[] args) {
        Person person = new Person();
        Person.Address address = new Person().new Address();
    }
}

Address就是一个内部类。

成员内部类

是指定义在成员内部的内部类，比如上述的Address就是一个成员内部类。
成员内部类的创建：
外部类名.内部类名 对象名 = 外部类对象.内部类对象;

局部内部类

局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用
该类可以直接访问外部类的成员，也可以访问方法内的局部变量。

匿名内部类

前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类
本质：是一个继承了该类的子类匿名对象，或者是一个实现了该接口的实现类匿名对象