Java基础----接口

一、先创建一个接口

package cn.yj.lpp;
/*抽象方法的定义
定义方法的格式：
public abstract 返回值类型 方法名称(参数列表);
注意事项：
修饰符必须是两个固定的关键字：public abstract，这两个关键字可以省略*/
public interface Demo01InterfaceAbstract {
    public abstract void methodA();
    abstract void methodB();
   }

 二、用实现类去实现这个接口，将这个接口中的作用方法进行重写；

package cn.yj.lpp;
//记住一点类实现接口   接口不能直接使用，必须有一个实现类去实现它
/*格式：
步骤一：
public class 实现类名称 implements 接口名称(){
    //重写接口中的抽象方法；
        }
 步骤二：
实现接口中所有的抽象方法
步骤三：
创建实现类的对象去使用*/
public class Demo01InterfaceImpl implements Demo01InterfaceAbstract {
    @Override
    public void methodA() {
        System.out.println("yi");
    }
    @Override
    public void methodB() {
        System.out.println("er");
    }
    }
}

三、创建实现类的对象去调用接口中的方法

package cn.yj.lpp;
/*不同JDK版本的接口区别
JAVA7：
1.常量
2.抽象方法
JAVA8：
1.默认方法 ????
2.静态方法
JAVA9：
私有方法*/

/*步骤一：
public class 实现类名称 implements 接口名称(){
        //重写接口中的抽象方法；
        }
        步骤二：
        实现接口中所有的抽象方法
        步骤三：
        创建实现类的对象去使用*/ //这个demo的作用就是创建实现类的对象去调用方法
public class Demo01Interface {
    //先尝试一下创建接口的对象，最然肯定是报错的
    //Demo01InterfaceAbstract demo = new Demo01InterfaceAbstract() ;//接口中不能new接口！！
      /*  Demo01InterfaceImpl imp = new Demo01InterfaceImpl();
        imp.*/   //你看这里我没有在main方法中创建对象就不能调用实现类的对象，这里是不是可以用程序执行的先后顺序来解释呢？？存疑！！
    public static void main(String[] args) {
        Demo01InterfaceImpl imp = new Demo01InterfaceImpl();
        imp.methodA();
        imp.methodB();
    }
}

四、JDK8中接口的默认方法

1.先创建一个接口，然后去是实现它（重写方法）；

2.创建对象，然后调用方法：

如果是在接口值定义的默认方法，那么就通过接口升级向上去通过接口调用该方法；如果在实现类中自己重写方法，那就直接调用该方法

package cn.yj.lpp;
/*当我们还需要在接口中新增方法时，实现类也要相应的重写方法。但是当实现类中的方法已经在使用时，不能更改；这个时候，可以用到JDK8中的
实现类的默认方法；
格式:
public default void eat(){    //因为这是存在方法体，那么就不是抽象方法了；

}

后面的Demo02InterfaceImplA，Demo02InterfaceImplB体现了接口的多实现；有么？？？？？
*/
public interface Demo02Interfac {
    public abstract void run();
    public abstract void jump();
    public default void eat(){
        System.out.println("I can eat shit,can you bitch?");
    }
}

package cn.yj.lpp;

public class Demo02InterfaceImplA implements Demo02Interfac{
    @Override
    public void run() {
        System.out.println("奔跑吧菜狗子");
    }

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

}

package cn.yj.lpp;

public class Demo02InterfaceImplB implements Demo02Interfac {

    @Override
    public void jump() {
        System.out.println("你哟本身再跳");
    }

    @Override
    public void run() {
        System.out.println("rangni10秒");
    }
    //这里在实现类中再次重写接口中的默认方法，看着两个的区别

    @Override
    public void eat() {
        System.out.println("这里是实现类中的方法重写");
    }
}

package cn.yj.lpp;

/*这个demo体现了，接口的多实现（类似多继承，你懂的吧，就是那个意思）；
在Demo02InterfaceImplB中，对eat方法进行了重写，但是不是之前的那个接口向上转型，直接调用接口中的方法。因为在实现类中都已经找到了，
就不用向上找借口去实现了*/
public class Demo02InterFace {
    public static void main(String[] args) {
        Demo02InterfaceImplA impl = new Demo02InterfaceImplA();
        impl.jump();
        impl.run();
        impl.eat();// 这里不是
        // 调用实现类里面的方法，是接口中的。体现了在接口中没找到就像上往接口里找；----->接口升级

        System.out.println("++++++++");
        Demo02InterfaceImplB imp2 = new Demo02InterfaceImplB();
        imp2.jump();
        imp2.run();
        imp2.eat();
    }
}

输出：
jump
奔跑吧菜狗子
I can eat shit,can you bitch?
++++++++
你哟本身再跳
rangni10秒
这里是实现类中的方法重写

五、JDK8中的静态方法：

和之前的静态类似，不能在是实现类中创建对象去调用它。只能使用接口名去调用！

六、JDK9当中的私有方法 待续。。。。

七、接口的向上转型------>多态

因为是父类引用指向子类对象------>  Animal a = new dog();   如果存在子类特有方法，使用多态的写法就不能调用了（编译看左，运行看右；编译不会通过)

八、向下转型（还原） ---->类似强制类型转换

格式：

子类名称 对象名 = (子类名称) 父类对象; ---->将父类对象，还原为本来的子类对象；

Animal A = new Dog();    //狗向上转型为动物，没有问题；
Dog D = (Dog)Animal;     //因为之前是狗，所以这里向下转型为狗是正确的；但是你转为其他没有的，就会报错（ClassCastException），这样就可以调用子类特有的方法了