Day30 接口

接口

1. 接口用关键字interface修饰（public interface 接口名{}），类实现接口用implements表示（public class 类名 implements 接口名{}）；接口不能直接实例化，参考多态方式，通过实现类对象实例化，这叫接口多态（具体类多态，抽象类多态，接口类多态）。多态前提：有继承或者实现关系；有方法重写；有父（类/接口）引用指向（子/实现）类对象；接口实现类，要么重写接口中的所有抽象方法，要么是抽象类。

//定义一个接口
public interface Jupping{
    public abstract void jump();
}
​
//定义一个子类，实现接口
//类和接口之间不能用继承extends 要用实现implements
public class Cat implements Jumpping{
    @Override
    public void jump(){
        System.out.println("猫可以跳高");
    }
}
​
//定义一个测试类
public class JumppingDemo{
    public static void main(String[] args){
      //  Jumpping j = new Jumpping();//接口不能直接实例化，还是参考多态
        Jumpping j = new Cat();
        j.jump();
    }
}

1. 接口的成员变量只能是常量，默认修饰符：public static final ； 接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在的；如果一个类没有父类，默认继承自Object类。接口中的成员方法只能是抽象方法，默认修饰符:public abstract

//定义一个接口
public interface Jumpping{
    public abstrcat void jump();
}
​
//定义一个动物类
public abstract class Animal{
    private String name;
    private int age;
    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 class Cat extends Animal implements Jumpping{
    public Cat(){}
    public Cat(String name, int age){
        super(name,age);
    }
    @Override
    public eat(){
        System.out.println("猫吃鱼");
    }
    @Override
    public void jump(){
        System.out.println("猫可以跳高了");
    }
}
​
//定义一个测试类
public class AnimalDemo{
    public static void main(String[] args){
        //创建对象，调用方法
        Jumpping j = new Cat();
        j.jump();
        
        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
       ((Cat)a).jump();
        
       //定义一个带参构造
        a = new Cat("加菲猫",5);
        System.out.println(a.getName()+","a.getAge());
        a.eat();
        
        //具体子类实现类调用所有方法
        Cat c = new Cat();
        c.setName("加菲");
        c.setAge(5);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.jump();
    }
}
​

1. 类和类的关系是继承关系，只能单继承，但是可以多层继承；类和接口的关系是实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口（public class InerImpl extends Object implements Inter 1, Inter 2, Inter 2{}）；接口和接口关系是继承关系，可以单继承，也可以多继承。

2. 抽象类的成员可以是变量，常量，有构造方法；有抽象方法，也有非抽象方法；抽象类是对类进行抽象，包括属性和行为。

   接口的成员只能是常量和抽象方法；接口主要是对行为进行抽象。

//抽象人类
public abstract class Person {
    private String name;
    private int age;
    public Person(){}
    public Person(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 class Player extends Person {
    public Player(){}
    public Player(String name, int age){
        super(name,age);
    }
    public abstract void study();
}
​
//定义一个篮球运动员继承运动员类
public class BasketballPlayer extends Player{
    public BasketballPlayer(){}
    public BasketballPlayer(String name, int age){
        super(name, age);
    }
​
    @Override
    public void study() {
        System.out.println("篮球运动员打篮球");
    }
​
    @Override
    public void eat() {
        System.out.println("篮球运动员吃牛肉");
    }
}
​
//定义一个抽象乒乓球运动员继承运动员类和实现接口类
public class PingPangPlayer extends Player implements SpeakEnglish{
    public PingPangPlayer(){}
    public PingPangPlayer(String name,int age){
        super(name,age);
    }
​
    @Override
    public void study() {
        System.out.println("乒乓球运动员学习如何打乒乓球");
    }
​
    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃白菜");
    }
    public void speak(){
        System.out.println("乒乓球运动员说英语");
    }
}
​