接口

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。

接口定义：

public interface 接口名 {} 

类实现接口：

public class 类名 implements 接口名 {}

接口的特点：

 接口不能实例化：
  	我们可以创建接口的实现类对象使用
 接口的子类：
  	要么重写接口中的所有抽象方法
  	要么子类也是抽象类

接口的作用：

1、声明规范，定义规则
2、开放了扩展性


注意：接口本身不能创建对象，如需使用都是用他的实现类来创建对象使用。

public class Demo {
    public static void main(String[] args) {
        Person p = new Person();    //通过实现类来创建对象
        Dog d = new Dog();
        p.swim();
        d.swim();
    }
}



/*游泳接口，定义了规范规则，然后有类来实现，相当于老师定了学习方法，让学生们去学习*/
public interface Swimming {
    public abstract void swim();       
}


//接口实现类
class Person implements Swimming {

    @Override
    public void swim() {
        System.out.println("学习游泳");
    }
}

//接口实现类
class Dog implements Swimming {
    @Override
    public void swim() {
        System.out.println("狗刨");
    }
}

接口的组成

1、成员变量：接口中的成员变量全部都是静态常量。

默认使用 public static final 修饰，缺少哪个JVM自动补充。

2、成员方法：接口中的成员方法都是抽象方法。（主流） ——JDK8以前

默认使用public abstract修饰的，缺少哪个JVM自动补充。

注意：JDK8开始，接口中引入了一些新特性：默认方法、静态方法、私有方法。

3、构造方法：接口中没有构造方法。（因为接口中的成员变量都是static修饰的，静态类在加载的时候就初始化过了。）这里需要去了解static的内存图。

public class Demo {
    public static void main(String[] args) {
        System.out.println(Swimming.num);
    }
}

//接口
public interface Swimming {

    public static final int num = 10;

    void swim();
}


 //实现类
class Dog extends Object implements Swimming {

    public Dog() {
        super();
    }

    @Override
    public void swim() {
        System.out.println("狗刨");
    }
}

接口新特性：

默认方法：

使用default关键字修饰的方法，允许有方法体。

作用：保证了接口的功能平稳升级，不会对实现类产生影响。

public class Demo {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.jump();

        //调用接口里的方法
        dog.method();
    }
 
}


//接口
public interface Jump {
    void jump();
     //默认方法
    default void method() {                   
        System.out.println("我是默认方法");
    }
}

 
//跳远实现类
class Dog implements Jump {
    public void jump() {
        System.out.println("狗跳");
    }
}


//实现类
class WuGui implements Jump {
    @Override
    public void jump() {
        System.out.println("乌龟学会了跳高");
    }
}

静态方法：

使用static关键字修饰的方法，允许有方法体。

作用：保证了接口的功能平稳升级，不会对实现类产生影响。让方法的调用更直接了当。

public class Demo {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.jump();

        //调用接口里的方法
        Jump.method();     //可以直接调用不用去创建实现类的对象来调用
    }
 
}


//接口
public interface Jump {
    void jump();
     //静态
    static void method() {                   
        System.out.println("我是默认方法");
    }
}

 
//跳远实现类
class Dog implements Jump {
    public void jump() {
        System.out.println("狗跳"); 
    }
}


//实现类
class WuGui implements Jump {
    @Override
    public void jump() {
        System.out.println("乌龟学会了跳高");
    }
}

私有方法

使用private关键字修饰的方法，允许有方法体!（JDK9开始才能使用）

作用：将多个默认方法/静态方法中的共性内容进行抽取，提高代码的复用性！

public interface Inter {
    default void method01() {
        method();
        System.out.println("睡觉");
    }


    default  void method02() {
        method();
        System.out.println("睡大觉");
    }


    //私有方法
    private  void  method() {
        System.out.println("打游戏");
        System.out.println("打游戏");
        System.out.println("打游戏");
    }
}

接口和类的关系

类和类的关系：

单继承，多层继承。

类和接口的关系：

多实现！ 理解：一个学生可以学会很多后天技能。

//游泳接口
public interface Swimming {
    void swim();
}

//跳高接口
interface Jumping {
    void jump();
}

//写代码接口
interface Coding {
    void code();
}


//实现类 一个类学习很多后天技能
public class Student implements Swimming, Jumping, Coding {

    @Override
    public void swim() {
        System.out.println("学习游泳");
    }

    @Override
    public void jump() {
        System.out.println("学习跳高");
    }

    @Override
    public void code() {
        System.out.println("学习代码");
    }
}

接口和接口的关系：

多继承

//接口与接口的关系：多继承！  后面可以跟多个接口名
public interface SchoolRule extends CityRule, ProvinceRule {
    void cd();
}


//学校规定  接口
class Student implements SchoolRule {

    @Override
    public void cd() {

    }

    @Override
    public void xd() {

    }

    @Override
    public void my() {

    }

    @Override
    public void cx() {

    }
}

//接口   国家规定
public interface CountryRule {
    void xd();
}

//省规定  继承了国家规定
interface ProvinceRule extends CountryRule {
    void my();
}


//市规定 
interface CityRule {
    void cx();
}

接口和抽象类的区别

1. 语法区别
    成员变量:
            抽象类可以定义基本的成员变量,也可以定义静态常量.
            接口中只能定义静态常量.
    成员方法:
            抽象类中既可以定义基本的成员方法,也可以定抽象方法
            接口中用的都是抽象方法,新特性提供了(默认方法,静态方法,私有方法)
    构造方法:
            抽象类有构造,因为是作为父类设计
            接口没有构造,因为接口作为行为规范设计.

 2. 设计区别
        接口作为行为规范设计.对类的后天行为进行补充描述,进行规则的定义.
        接口和类的关系: 多实现关系.(一个人可以学习很多后天技能)
        接口和接口的关系: 多继承.(一个规则在定义的时候可能会有来自多方规则的补充约束)

        抽象类作为父类设计. 将多个子类中的共性内容提取到父类中,为了提高代码
        复用性.类和类的关系: 单继承关系.(一个人只能有一个亲爹)