java学习笔记-interface

java学习笔记-interface

java接口（interface）

接口定义

public interface Jumping {
    
    public abstract void jump();
    public void show1();
    //方法默认为public abstract，所以不写这两个修饰符也可以
    void show2();

    public int num = 10;
    public final int num2 = 20;
    public static final int num3 = 30;
    //变量默认为public static final，所以不写这三个修饰符也可以
    int num4 = 40;

}

实现接口的类需要实现接口里的所有方法

接口应用

public interface jumping {
    public abstract 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 String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public abstract void eat();
}

public class Cat extends Animal implements jumping{
    public Cat() {
    }

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

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

    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

public class AnimalDemo {
    public static void main(String[] args) {
        jumping j = new Cat();
        j.jump();
        ((Cat) j).eat();

        System.out.println("--------");

        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        ((Cat) a).jump();

        System.out.println("--------");

        Cat c = new Cat();
        c.setName("加菲");
        c.setAge(5);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.jump();
    }
}

运行结果：
猫可以跳高了
猫吃鱼
--------
加菲,5
猫吃鱼
猫可以跳高了
--------
加菲,5
猫吃鱼
猫可以跳高了

接口与类的关系

1. 类与类：单继承，多层继承
2. 类与接口：单实现，多实现，继承类的同时实现接口
3. 接口与接口：单继承，多继承

接口作为形参和返回值

接口作为形参时，调用方法的实参是接口的实现类；
接口作为返回值时，返回的是接口的实现类对象。

public interface Jumping {
    void jump();
}

public class Cat implements Jumping{
    @Override
    public void jump() {
        System.out.println("cat can jump");
    }
}

public class JumpingOperator {
    public void useJumping(Jumping j){
        j.jump();
    }

    public Jumping getJumping(){
        return new Cat();
    }
}

public class JumpingDemo {
    public static void main(String[] args) {
        JumpingOperator jo = new JumpingOperator();
        Jumping j = new Cat();
        jo.useJumping(j);

        Jumping j2 = jo.getJumping();
        j2.jump();
    }
}