Java基础的重点知识-08-接口、多态

文章目录

接口
多态

接口

从之前的章节中，我们了解到类的内部封装了成员变量、构造方法、成员方法，那么接口的内部主要就是封装了方法，包含了抽象方法（JDK7及之前），默认方法和静态方法（JDK8）、私有方法（JDK9）。

接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。

public interface Animal {
    public abstract void action();

    public default void eat() { // JDK7版本之后支持
        // 执行语句
    }
    public static void work() { // JDK7版本之后支持
        // 执行语句
    }

   /* private void sleep() { // JDK8版本之后支持
        // 执行语句
    }*/
}

class Dog implements Animal{

    @Override
    public void eat() {
        Animal.super.eat();
    }

    @Override
    public void action() {

    }
}

abstract class Cat implements Animal{

}

从上述代码中，我们可以看到，如果说通过implements 实现了接口但是没有实现接口中的全部抽象方法就要定义为抽象类，不然就必须实现接口中的抽象方法，不然就会报错。

非抽象子类实现接口：

必须重写接口中所有抽象方法。
继承了接口的默认方法，即可以直接调用，也可以重写。
默认方法的使用：可以继承，可以重写，二选一，但是只能通过实现类的对象来调用。
静态方法的使用：静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用
私有方法的使用：私有方法只有默认方法可以调用，私有静态方法默认方法和静态方法都可以调用

私有的方法是对默认方法和静态方法的辅助

接口的多实现:
一个类可以继承一个父类同时实现多个接口，一个接口可以继承多个接口

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
	// 重写接口中抽象方法【必须】
	// 重写接口中默认方法【不重名时可选】
}

对于抽象方法：如果抽象方法有重名的，只需要重写一次
对于默认方法：如果默认方法有重名的，必须重写一次
接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

注意：

接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。
接口中，没有构造方法，不能创建对象。
接口中，没有静态代码块。

package demo02;

public interface Animal extends Biology,World{
    public abstract void action();

    public default void eat() { // JDK7版本之后支持
        // 执行语句
    }
    public static void work() { // JDK7版本之后支持
        // 执行语句
    }

   /* private void sleep() { // JDK8版本之后支持
        // 执行语句
    }*/
}
interface Biology{

}
interface World {

}

class Dog implements Animal,World{

    @Override
    public void eat() {
        Animal.super.eat();
    }

    @Override
    public void action() {

    }
}

abstract class Cat implements Animal{

}

从上述代码中我们可以看到，Dog类多接口实现，实现了Aniaml（动物接口）、World（世界接口）。Animal接口多继承了Biology（生物接口）、World（世界接口）。这里的代码就体现出了，接口的多继承，以及类的多实现。

多态

多态是继封装、继承之后，面向对象的第三大特性。

多态就是同一行为，通过不同的事物，可以体现出来的不同的形态。

这里以跑这个行为为例，猫咪、小狗、人跑起来的动作是不一样的，也就是说跑这个行为，在不同的三个事物上显现出来了不同的形态。

package demo02;

public interface Animal {
    public abstract void eat();

    public static void showCatEat (Cat c){
        c.eat();
    }
    public static void showDogEat (Dog d){
        d.eat();
    }
    public static void showAnimalEat (Animal a){
        a.eat();
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();

        showCatEat(cat);
        showDogEat(dog);
        showAnimalEat(cat);
        showAnimalEat(dog);
    }
}


class Dog implements Animal{

    @Override
    public void eat() {
        System.out.println("吃骨头");
    }
}

class Cat implements Animal{

    @Override
    public void eat() {
        System.out.println("吃鱼");
    }
}

在这里插入图片描述
由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法。不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。

引用类型转换：

向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。
向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

当我们的父类想要调用子类中拥有的方法但是父类中却没有的方法的时候就要进行向下转型。但是这里有个要注意的点就是在我们编写代码的过程中很有可能会出现类型转换异常。这时我们就要使用到instanceof关键字了。

代码示例：

package demo02;

public interface Animal {
    public abstract void eat();

    public static void main(String[] args) {
        Animal animal = new Cat();
        Dog dog = (Dog) animal;
        dog.lookHome();

    }
}


class Dog implements Animal{

    @Override
    public void eat() {
        System.out.println("吃骨头");
    }

    public void lookHome(){
        System.out.println("看家");
    }
}

class Cat implements Animal{
    @Override
    public void eat() {
        System.out.println("吃鱼");
    }
}

在这里插入图片描述
这里我们需要使用instanceof关键字来判断一下了，不然很有可能出现类型转换异常。

public interface Animal {
    public abstract void eat();

    public static void main(String[] args) {
        Animal animal = new Cat();
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.lookHome();
        } else if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
        }
    }
}


class Dog implements Animal {

    @Override
    public void eat() {
        System.out.println("吃骨头");
    }

    public void lookHome() {
        System.out.println("看家");
    }
}

class Cat implements Animal {
    @Override
    public void eat() {
        System.out.println("吃鱼");
    }
}