Java多态实例详解三步走（三）【接口多态】

一、接口的功能：接口主要是对类功能的补充。比如说猫和狗，它们都属于动物，有一些共有的属性和方法可以。但是现在如果对狗和猫中的一部分进行训练，使它们拥有与其他猫、狗不一样的能力，这时就需要用接口来实现了。

多态分为三种：

具体类多态（几乎没有）：
class Fu { }
class Zi extends Fu { }

Fu f = new Zi();
请看 Java多态实例详解三步走（一）【具体类多态】
抽象类多态（常用）：
abstract class Fu { }
class Zi extends Fu { }

Fu f = new Zi();
请看 Java多态实例详解三步走（二）【抽象类多态】
接口类多态（最常用）：
interface class Fu { }
class Zi implements Fu { }

Fu f = new Zi();

二、接口的特点：

接口用关键字interface表示。
interface 接口名 { }
类实现接口用 implements 表示
接口不能实例化，但可以按照多态的方式来实例化
接口的子类
1、可以是抽象类。但是意义不大。
2、可以是具体类。要重写接口中的所有抽象方法。（推荐方案）

public class Main {
    public static void main(String[] args) {
        //会报错，接口不能实例化
        //AnimalTrain at = new AnimalTrain();
    }
}

interface AnimalTrain {

    public abstract void jump();

}
//可以定义为抽象类，但这样的话就需要再向下定义子类了，所以无意义。
//abstract class Cat implements AnimalTrain {}

//要重写接口中所有抽象方法
class Dog implements AnimalTrain {
    public void jump() {
        System.out.println("狗跳高");
    }
}

三、接口成员特点：

成员变量：只能是常量，并且是静态的。
默认修饰符：public static final
建议：自己手动给出
构造方法：接口没有构造方法
成员方法：只能是抽象方法
默认修饰符：public abstract
建议：自己手动给出

所有类都默认继承自一个类：Object
类Object是类层次结构的根类。每个类都是用Object作为超类。
当没有父类的时候，默认为Object


public class Main {
    public static void main(String[] args) {
        Inter a = new InterImpl();
        System.out.println(a.num);
        System.out.println(a.num2);
        System.out.println("-------------------");
        //这两个都会报错，因为接口中的成员变量都为最终变量
        //a.num = 88;
        //a.num2 = 777;

        //接口中的成员变量可以通过接口名调用，说明是静态的
        System.out.println(Inter.num);
        System.out.println(Inter.num2);
        //a = new InterImpl();
        a.show();
    }
}

interface Inter {
    //格式不全的会用默认的格式
    public int num = 100;
    public final int num2 = 99;
    //虽然会默认给出，但建议手动给出
    public static final int num3 = 78;

    //会报错，接口没有构造方法
    //public Inter() {}

    //接口方法中不能带有主体
    //public void show() {}

    //这句虽然没有abstract，但是不会报错，因为默认 public abstract
    //public void show();

    public abstract void show();

}

//接口的实现类明明格式：接口名+Impl
//约定俗成的，并不是说必须要这样写，但这样写容易看懂
class InterImpl implements Inter {
    public InterImpl() {
        super();
    }

    //因为接口默认public ，而如果没有给出权限默认最低权限，所以报错。
    //void show() {}

    //正确
    public void show() {
        System.out.println("dfdg");
    }
}

关系：

类与类：继承关系，只能单继承，可以多层继承。
类与接口：
实现关系，可以单实现，也可以多实现。
并且还可以在继承一个类的同时实现多个接口。
接口与接口：
继承关系，可以单继承，也可以多继承。

最后，一个完整的多态的代码：


interface JumpingImpl {
    public abstract void Jump();
}

interface ZuanHuoQuan {
public abstract void Z();
}

abstract class Animal {
private int age;
private String name;

public Animal() {}
public Animal(String name, int age) {
this.name = name;
this.age = age;
}

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

public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}

public abstract void eat();
public abstract void sleep();
}

class Dog extends Animal{

public Dog() {}
public Dog(String name, int age) {
super(name, age);
}

public void eat() {
System.out.println(“狗吃肉”);
}

public void sleep() {
System.out.println(“狗睡觉”);
}

}

class JumpDog extends Dog implements JumpingImpl,ZuanHuoQuan {

public JumpDog() {}
public JumpDog(String name, int age) {
super(name, age);
}

public void Z() {
System.out.println(“钻火圈狗”);
}
public void Jump() {
System.out.println(“跳高狗”);
}

}

public class Main {
public static void main(String[] args) {
Animal a = new Dog();
a.eat();
a.sleep();
a.setName(“旺财”);
System.out.println(a.getName());
a.setAge(8);
System.out.println(a.getAge());

JumpDog d = new JumpDog(“小花”, 7);
d.Jump();
d.Z();
}
}

Related Posts