接口

/**
 * 接口：interface 实现接口，implements
 * 1：可以定义全局常量，抽象方法，静态方法，默认方法
 * 不可以定义构造器，意味着不可以实例化，跟抽象类有点相似，
 * 2：如果类继承了接口，必须要全部重写（实现）接口中的抽象方法，才可以进行实例化
 * 换句话说，如果没有全部重写，这个类只能定义为抽象类，不可以实例化，
 * 3：接口的具体使用，体现多态性
 *
 *
 *
 *
 */


public interface InterfaceTest extends B,C{//接口可以多继承
public  static final  double PI=3.14;//全局常量
    int max=100;//其实是省略了 public static final;
    public abstract void Test();//抽象方法
    void  Test2();//省略了 public abstract
    public static  int sum() {//可以定义静态方法
    return 0;}


}
interface B{
}
interface  C{
}
 class AAA implements InterfaceTest{
    public void man(InterfaceTest interfaceTest){//接口当作形参
        interfaceTest.Test();//接口虽然不可以实例化，但是还可以进行接口名.方法进行调用
        System.out.println(132612);
    }

     public static void main(String[] args) {
         AAA aaa=new AAA();
         aaa.man(new BBB());//创建接口的非匿名类的匿名对象
     }
     @Override
     public void Test() {
         System.out.println(123);
     }

     @Override
     public void Test2() {
         System.out.println(456);
     }


 }
 class BBB implements InterfaceTest{
     @Override
     public void Test() {
         System.out.println(123456);
     }

     @Override
     public void Test2() {

     }
 }

 

interface USB{
    public abstract void Start();
    public abstract void End();
}

public class Demo3 implements USB{
    @Override
    public void Start() {
        System.out.println("开始工作");
    }

    @Override
    public void End() {
        System.out.println("结束工作");
    }

}
class usbTest{
    public void transFort(USB usb){//Usb usb=new Demo3();类继承接口后，此接口可以当作父类进行多态使用
        usb.Start();
        usb.End();
    }

    public static void main(String[] args) {
        usbTest u=new usbTest();
        u.transFort(new Demo3());
    }

}