java-----接口

接口的特点：
1.接口用关键字interface修饰
    public interface 接口名{}
2.类实现接口用implements表示
    public class 类名 implements 接口名{}
3.接口不能实例化
    接口如何实例化？参照多态方式，这叫接口多态
    多态形式：具体类多态，抽象类多态，接口多态
    多态前提：有继承/实现关系，有方法重写，有父类引用指向子类对象
4.接口实现类
    要么重写接口中所有抽象方法
    要么是抽象类

public interface Jumpping {
    public abstract void jump();
}

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

public class JumppingDemo {
    public static void main(String[] args) {
        Jumpping j=new Cat();
        j.jump();
    }
}

接口的成员的特点：

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

public interface Inter {

    public int num1=10;
    public final int num2=20;
    public static final int num3=30;


    public abstract void method();
    void show();
}

public class Intermpl extends Object implements Inter{
    public Intermpl(){
        super();
    }

    @Override
    public void method() {

        System.out.println("method");
    }

    @Override
    public void show() {
        System.out.println("show");
    }
}

public class InterDemo {
    public static void main(String[] args) {
        Inter i=new Intermpl();
//        i.num1=20;         无法将值赋给 final 变量 'num'
        System.out.println(i.num1);
//        i.num2=100;       无法将值赋给 final 变量 'num2'
        System.out.println(i.num2);
//        i.num3=100;         无法将值赋给 final 变量 'num3'
        System.out.println(i.num3);
    }

}

案例猫和狗：

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

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

    public Animal() {
    }

    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 Jumpping{

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

    public Cat() {
    }

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

    @Override
    public void Jump() {
        System.out.println("猫会跳高");
    }
}

public abstract class Dog extends Animal implements Jumpping{
    public Dog(String name, int age) {
        super(name, age);
    }

    public Dog() {
    }

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

    @Override
    public void Jump() {
        System.out.println("狗可能也会跳高");
    }
}

//在这里狗就不测了
public class AnimalDemo {
    public static void main(String[] args) {
        Animal s=new Cat();
        s.setName("加菲");
        s.setAge(5);
        System.out.println(s.getName()+","+s.getAge());
        s.eat();

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

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

        Jumpping j=new Cat();
        j.Jump();

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

希望大家批评指正

谢谢大家~