Java深入解析接口interface

package com.demo.Interface_;
public class inerface01 {
    public static void main(String[] args) {
        //创建手机相机对象
        camera c1=new camera();
        phone p1=new phone();
        //创建电脑对象
        computer cc=new computer();
        //相机工作
        cc.work(c1);
        //手机工作
        cc.work(p1);
    }
}

package com.demo.Interface_;
public interface usb {//接口
    //规定接口的相关方法
    public void start();
    public void end();
}

package com.demo.Interface_;
public class computer {
    //编写一个方法
    public void work(usb it){
        //通过接口调用方法
        it.start();
        it.end();
    }
}

package com.demo.Interface_;
//相机实现接口usb
public class camera implements usb{
    @Override
    public void start() {
        System.out.println("相机开始了工作");
    }
    @Override
    public void end() {
        System.out.println("相机停止了工作");
    }
}

package com.demo.Interface_;
//phone类实现usb接口中的方法
public class phone implements usb{
    @Override
    public void start() {
        System.out.println("手机开始了工作");
    }
    @Override
    public void end() {
        System.out.println("手机停止了工作");
    }
}

package com.demo.Interface_;
public interface Ainter {//接口
    //写属性
    public int n1=999;
    //写方法
    public void hi();//抽象方法abstract可也可不写
//    1.在jdk7.0之前，接口里所有有的方法都没有方法体，都是抽象方法、.
//    2.jdk8.0后接口可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现
//    3.但需要defaul关键字修饰；
    default public void ok(){
        System.out.println("ok.....");
    }
    //jdk8后，可以有静态方法
    public static void cry(){
        System.out.println("cry.....");
    }
}

public class interface02 {
    public static void main(String[] args) {
        A a = new A();
        a.hi();
        a.ok();
        a.cry();
    }
}
//如果一个类连接了接口，需要将接口中的方法全都实现
class A implements Ainter{
    public void hi(){
        System.out.println("hi.....");
    };
     public void ok(){
        System.out.println("ok.....");
    }
    //jdk8后，可以有静态方法
    public static void cry(){
        System.out.println("cry.....");
    }
}

package com.demo.Interface_;
public class interface_detial {
    public static void main(String[] args) {
//        1)接口不能被实例化
        //new IA();ERROR
    }
}
interface IA{
    //2)接口中所有的方法是 public方法，接口中抽象方法，可以不用abstract 修饰
    void say();//public 和 abstract可写可不写 
    void kk();
}
//        3)一个普通类实现接口,就必须将该接口的所有方法都实现。
class cat implements IA{
    @Override
    public void say() {
        System.out.println("say.......");
    }
    @Override
    public void kk() {
        System.out.println("kk/.......");
    }
}
//        4)抽象类实现接口，可以不用实现接口的方法。
abstract class dog implements IA{
}

package com.demo.Interface_;
public class interfacedetial {
    public static void main(String[] args) {
        //证明int n1=55;//等价于 public static final int n1=55;
        System.out.println("IB.n1=" IB.n1);//说明n1是static；
        //IB.n1=60;ERROR,说明n1是final
        N G = new N();
        System.out.println("G.n=" G.n);
        System.out.println("M.n=" M.n);
        System.out.println("N.n=" N.n);
    }
}
//5)一个类同时可以实现多个接口。
interface IB{
    int n1=55;//等价于 public static final int n1=55;
    void aa();
}
interface IC{
    void bb();
}
// 8)一个接口不能继承其它的类,但是可以继承多个别的接口[举例]
interface ID extends IB,IC{
}
class pp implements IB,IC{
    @Override
    public void aa() {
        System.out.println("aa....");
    }
    @Override
    public void bb() {
        System.out.println("bb...");
    }
}
// 6)接口中的属性,只能是final的，而且是 public static final 修饰符。比如:
//  int a=1;实际上是 public static final int a=1;(必须初始化)
//(7)接口中属性的访问形式:接口名.属性名
// 9)接口的修饰符只能是 public 和默认，这点和类的修饰符是一样的。
interface M{
    int n=66;
}
class N implements M{
}

package com.demo.Interface_;
public class interfacePoly {
    public static void main(String[] args) {
        //接口的多态体现
        //接口类型的变量可以指向实现了IF接口的对象实例
        IF if01=new QQ();
        if01 =new WW();
        //继承的多态体现
        //父类类型的变量可以指向继承了AAA的对象实例
        AAA t=new BBB();
        t=new CCC();
    }
}
interface IF{}
class QQ implements IF{}
class WW implements IF{}
class AAA{
}
class BBB extends AAA{
}
class CCC extends AAA{
}

package com.demo.Interface_;
public class interfacePolyarr {
    public static void main(String[] args) {
        //多态数组-》接口类型数组
        usbb []uu=new usbb[2];
        uu[0]=new ppp();
        uu[1]=new ttt();
        /*
        给Usb数组中，存放 Phone 和相机对象，Phone类还有一个特有的方法call（）请遍历Usb数组，
        如果是Phone对象，
        除了调用Usb 接口定义的方法外，还需要调用Phone 特有方法 call.
         */
        for(int i=0;i<uu.length;i  ){
            uu[i].work();//动态绑定
            //要使用call方法，需要用到线下转型
            if(uu[i] instanceof ppp){
                ((ppp)uu[i]).call();
            }
        }
    }
}
interface usbb{
    void work();
}
class ppp implements usbb{
    public void call(){
        System.out.println("ppp........");
    }
    @Override
    public void work() {
        System.out.println("ppp在工作中");
    }
}
class ttt implements usbb{
    @Override
    public void work() {
        System.out.println("ttt工作中");
    }
}