【java程序设计期末复习】chapter6 接口和实现

接口与实现

接口

为了克服Java单继承的缺点，Java使用了接口，一个类可以实现多个接口。
使用关键字interface来定义一个接口。接口的定义和类的定义很相似，分为接口的声明和接口体。

接口通过使用关键字interface来声明

interface Printable 
{
           …
}

理解的关键点是

（1）接口可以抽象出重要的行为标准，该行为标准用抽象方法来表示。//区别接口和抽象类的区别
（2）可以把实现接口的类的对象的引用赋值给接口变量，该接口变量可以调用被该类实现的接口方法，即体现该类根据接口里的行为标准给出的具体行为。

接口的变量和方法的构成规则

(1)接口中的常量自动都是public、static，final，
(2)接口中的方法默认为public abstract；接口也产生class文件。
(3)接口中的方法不能被static和final修饰，因为类要重写所有接口中的方法。
(4)接口中没有构造函数，方法可以抛出异常。

接口中的方法：
（1）接口中要么存在default的非抽象类方法（存在默认的方法定义）
（2）接口中要么存在默认为public abstract的抽象类方法

接口中的方法被重写规则：
（1）如果一个抽象类实现某个接口，它不一定要重写全部方法（与抽象类性质相违背）
（2）如果一个非抽象类实现某个接口，它必须重写接口中的全部方法

实现接口

(1)类实现接口
类需要在类声明中使用关键字implements声明该类实现一个或多个接口。如果实现多个接口，用逗号隔开接口名。

(2)重写接口中的方法
类实现了某个接口，那么这个类就自然拥有了接口中的常量，default方法（去掉了default关键字），该类也可以重写接口中的default方法（注意，重写时需要去掉default关键字）。如果一个非abstract类实现了某个接口，那么这个类必须重写该接口的所有abstract方法，即去掉abstract修饰给出方法体。

接口回调

接口回调是指：可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中，那么该接口变量就可以调用被类重写的接口方法。实际上，当接口变量调用被类重写的接口方法时，就是通知相应的对象调用这个方法

interface  ShowMessage {
   void 显示商标(String s);
   default void outPutStart(){
      System.out.println("********");
   }
}
class TV implements ShowMessage {
   public void 显示商标(String s) {
       System.out.println("tvtvtvtv");
       System.out.println(s);
       System.out.println("tvtvtvtv");
   }
}
class PC implements ShowMessage {
   public void 显示商标(String s) { 
       System.out.println("pcpcpcpc");
       System.out.println(s);
       System.out.println("pcpcpcpc");
   }
}
public class Example6_2 {
   public static void main(String args[]) {
       ShowMessage sm;                  //声明接口变量
       sm=new TV();                     //接口变量中存放对象的引用
       sm.显示商标("长城牌电视机");      //接口回调。
       sm=new PC();                     //接口变量中存放对象的引用
       sm.outPutStart();
       sm.显示商标("华为个人电脑");    //接口回调
       sm.outPutStart();
   } 
}

interface A
{
    double f(double x,double y);
}

class B implements A
{
    public double f(double x,double y)
    {
        return x*y;
    }

    int g(int a,int b)
    {
        return a + b;
    }
}
class C implements A
{
    public double f(double x,double y)
    {
        return x + y;
    }
}
public class test
{
    public static void main(String[] args) {
        A a = new C();//接口回调：接口的实例作为类的空间引用
        System.out.println(a.f(3,5));
        B b = new B();
        System.out.println(b.g(3,5));
    }
}

abstract类和接口的区别

接口和abstract类的比较如下：

1．abstract类和接口都可以有abstract方法。
2．接口中只可以有常量,不能有变量；而abstract类中即可以有常量也可以有变量。
3．abstract类中也可以有非abstract方法,接口不可以。

接口和abstract可以同时被重写

interface Com
{
    int add(int a,int b);
    
}

abstract class A
{
    abstract int add(int a,int b);

}

class B extends A implements Com
{
    public int add(int a,int b)
    {
        return a+b;
    }
}

public class test
{
    public static void main(String[] args) {
        B b = new B();
        Com com = b;
        System.out.println(com.add(12,6));

        A a = b;
        System.out.println(a.add(10, 5));
    }
}