java学习笔记 interface implements 接口与实现

接口是一种特殊的抽象类，里面所有的变量都是全局变量，所有的方法都是抽象方法

public class InterfaceTest {
    public static void main(String[] args) {
        A c1 = new c();
        c1.method();
        B c2 = new c();
        //c1.printInfo();//result:找不到符号 方法printInfo()
        c2.printInfo();
        System.out.println(c1.MAX);
    }    
}

interface A {
    int MAX = 99999;//接口里的成员变量都是常量，默认声明是public static final的。也只能是这样的。
    void method();    //接口里的方法都是抽象abstract方法，默认声明是public abstract。也只能是public abstract的。
}

interface B {
    void printInfo();
}

class c implements A,B {
    public void method() {
        System.out.println("Hello Word!");    
    }     
    public void printInfo() {
        System.out.println("你好");    
    }
}

/*
1.接口是一种特殊的抽象类，里面的所有的成员变量是全局变量，里面所有的方法都是抽象方法。换句话说：接口就是被子类用来实现的。
2.接口里面的成员变量默认声明是public static final的，里面的方法默认是public abatract的。如果不写也是public的。
结果：Hello Word!
            99999
3.接口解决了java的单继承局限，一个类可以实现多个接口。实现多个接口，则必须把所有接口包含的方法全部重写覆盖。
*/

java抽象类与接口

public class InterfaceTest {
    public static void main(String[] args) {
        A d1 = new D();
        d1.aPrint();
        
        F d2 = new D();
        d2.fPrint();
    }    
}

interface A {
    void aPrint();
}

interface B {
    void bPrint();
}

interface C extends A,B {
    void cPrint();
}

interface E {
    void ePrint();    
}

abstract class F implements E {
    abstract void fPrint();    
}

class D extends F implements C {
    public void aPrint() {
        System.out.println("D aPrint");    
    }
    public void bPrint() {
        System.out.println("D bPrint");    
    }
    public void cPrint() {
        System.out.println("D cPrint");    
    }
    public void ePrint() {
        System.out.println("D eprint");    
    }
    public void fPrint() {
        System.out.println("D fprint");    
    }
}
/*
1.接口可以继承其他接口，接口可以多重继承。(java中类只能单继承)。
2.如果一个接口 C 同时继承了其他接口，那么当实现C接口时必须把C接口及C接口所有继承接口中的全部方法重写覆盖实现。
3.抽象类可以实现接口。
*/

 implements与extends的进一步探究：

public class Test {
    public static void main(String[] args) {
        E d1 = new D();
        C d2 = new D();
        d1.aPrint();    
        d2.aPrint();    
    }
    
     
}

interface A {
       void aPrint();
}
 
interface B {
     void bPrint();
 }
 
abstract class C implements A,B {//这里implements 不能换成extends
   public abstract void cPrint();
}
 
interface E extends A,B {
         void ePrint();
}
 
class D extends C implements E {
     public void aPrint() {
         System.out.println("aPrint");    
     }
     
     public void bPrint() {
         System.out.println("bPrint");    
     }
     
     public void cPrint() {
         System.out.println("cPrint");    
     }
     
     public void ePrint() {
         System.out.println("ePrint");    
     }
}

/*
1.重写接口的方法，方法的声明必须是public的，因为子类方法的权限要大于父类。
2.extends只能有一个，implements允许有多个，这点在interface上是个例外。接口可以extends多个接口。
*/