面向对象---接口

JDK1.8之前

package com.gao.test.Test7;
/*
1.类是类，接口是接口，他们是同一层次的概念。
2.接口中没有构造器
3.接口如何声明：interface
4.在JDK1.8之前，接口中只有两部分内容：
（1）常量：固定修饰符 :public static final
（2）抽象方法：固定修饰符：public abstract
注意：修饰符可以省略不写，IDE帮你自动补全，但是初学者建议写上，避免遗忘
 */

public interface TestInterface01 {
    //常量
    /* public static final */ int NUM = 10;


    //抽象方法
   /* public abstract */ void a();  //固定修饰符默认存在，可以不写
   /* public abstract */ void b(int num);
    /*public abstract */ int c(String name);
}
interface TestInterface02{ //在定义一个接口
    void e();
    void f();

}
/*
5.类和接口的关系是什么？  实现关系   类实现接口
6.一旦实现一个接口，那么实现类要重写接口中的全部的抽象方法
7.如果没有全部重写抽象方法，那么这个类可以变成一个抽象类    （类前加abstract）
8.java只有单继承，Java还有多实现，一个类继承其他类，只能直接继承一个父类，但是实现类实现接口的话，可以实现多个接口
9.写法：先继承 再实现：extends Person implements  TestInterface01,TestInterface02
 */
class Student extends Person implements  TestInterface01,TestInterface02{
    @Override           //重写方法快捷方式：打出方法名，弹出信息选择第一个
    public void a() {
        System.out.println("-----1");

    }

    @Override
    public void b(int num) {
        System.out.println("-----2");

    }

    @Override
    public int c(String name) {
        return 100;
    }

    @Override
    public void e() {
        System.out.println("-----3");
    }

    @Override
    public void f() {
        System.out.println("-----4");
    }
}

class Test{
    public static void main(String[] args) {
        //10.接口不能创建对象:
        //TestInterface02 t = new TestInterface02();
        TestInterface02 t = new Student();//接口指向实现类  ---->多态

        // 11.接口中的常量如何访问：
        System.out.println(TestInterface01.NUM);
        System.out.println(Student.NUM);
        Student s = new Student();
        System.out.println(s.NUM);
        TestInterface01 t2 = new Student();
        System.out.println(t2.NUM);
    }
}
/*
接口的作用：
定义规则，只是跟抽象 不同地方在它是接口不是类
接口定义好规则之后，实现类负责实现即可。

继承：子类堆父类的实现
实现：实现类对接口的实现

多态的应用场合:
(1)父类当做方法地形参，传入具体额子类地对象
(2)父类当做方法地返回值，返回的是具体的子类对象
(3)接口当作方法的形参，传入具体的实现类的对象
(4)接口当做方法的返回值，返回的是具体的子类的对象


 */

package com.gao.test.Test7;

public class Person {
}

JDK1.8之后

package com.gao.test.Test8;

public interface TestInterface01 {
    //常量
    public static final int NUM = 10;
    //抽象方法
    public abstract void a();
    //public default 修饰的非抽象方法：
    public default void b(){
        System.out.println("------TestInterface---b()-----");
    }
}
class Test implements TestInterface01{
    public void c(){
        //用一下接口中的b方法：
        b();//可以
        //super.b(); 不可以
        TestInterface01.super.b();//可以
    }
    @Override
    public void a() {
        System.out.println("重写了a方法");
    }

    @Override
    public void b() {
    }
}
/*
在JDK1.8之前，接口中只有两部分内容：
（1）常量：固定修饰符：    public static final
（2）抽象方法：固定修饰符：  public abstract

在JDK1.8之后，新增非抽象方法：
（1）被public default 修饰的非抽象方法：
注意1：default修饰符必须要加上，否则会出错
注意2：实现类中要是想重写接口中的非抽象方法，那么default修饰符必须不能加，否则出错

 */

package com.gao.test.Test8;

public interface TestInterface02 {
    //常量：
    public static final int num = 10;
    //抽象方法：
    public abstract void a();
    //public default 非抽象方法：
    public default void b(){
        System.out.println("----TestInterface02---b");
    }
    //静态方法：
    public static void c(){
        System.out.println("TestInterface02中的静态方法");
    }
}
class Demo implements TestInterface02{
    @Override
    public void a() {
        System.out.println("重写了a方法");
    }
    public static void c(){ //不能快捷键生成，自己手打
        System.out.println("Demo中的静态方法");
    }
}
class A{
    public static void main(String[] args) {
        Demo d = new Demo();
        d.c();
        Demo.c();
    }
}



/*
在JDK1.8之后，新增非抽象方法：
静态方法：
注意1：static不能不写
注意2：静态方法不能重写


为什么要在接口中加入非抽象方法？
如果接口中只能定义抽象方法的话，那么要是修改接口中的内容，对实现类的影响太大了，所有的实现类都会受到影响
现在在接口中加入非抽象方法，对抽象类没有影响，想调用就去调用即可。
 */