8.Java中的接口

目录结构

⭕1. 接口的声明
⭕2. 接口体中包含常量定义和方法定义两部分
⭕3. 接口多继承
⭕4. 接口变量使用接口/接口回调
⭕5. Fina类
⭕6. 内部类

======================================

使用关键字interface来定义一个接口。接口的定义和类的定义很相似，分为接口的声明和接口体**。

⭕1. 接口的声明

语法：

<修饰符>  interface  <接口名>   //接口声明
{
。。。接口体。。。
}

① 接口名的命名规范与类相同，接口也可以指定所属的 包。
②接口的修饰符可以有以下几种：

• public：与类的public修饰符相同
• Abstract：通常被省略，因为接口中的方法都是抽象的。
• Strict：通常并不能限制接口中方法的实现，一般不使用。

⭕2. 接口体中包含常量定义和方法定义两部分。

• 接口中的成员都是public的，不能指定其他的访问控制修饰符。
• 常量定义：接口中属性的域默认是static final的，必须显示初始化。
• 方法：只能提供方法头声明，不能提供实现，且除abstract外，不能使用其他修饰符。接口中的方法被默认是public和abstract的，接口在声明方法时可以省略方法前面的public和abstract关键字，但是类在实现接口方法时，一定要用public来修饰。

interface C {
public abstract int fun(int x,int y);
}
class A implements C {
public int fun(int x,int y){return 2*（x+y）;}
}
class B implements C {
public int fun(int x,int y){return x*y;}
}

public class j17 {
public static void main(String args[]){
A a=new A();
B b=new B();
System.out.println("长方形周长="+a.fun(12,8));
System.out.println("长方形面积="+b.fun(12,8));
}
}

输出结果：
                  长方形周长=40
                  长方形面积=96

⭕3. 接口多继承

• Java类之间并不允许多继承，只可以单继承和实现多接口。
• 一个类只能extends一个父类，但可以implements多个接口，用逗号隔开每个接口。
  
• 却不能implements(使生效; 贯彻; 执行; 实施)任何接口，会报一个语法错误的。所以Java中的接口是可以多继承的。

JAVA的extends用法

继承

class Animal{
    void eat(){
        System.out.println("Animal eat");
    }
    void sleep(){
        System.out.println("Animal sleep");
    }
    void breathe(){
        System.out.println("Animal breathe");
    }
}
 
class Fish extends Animal{
}
 
public class TestNew {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Animal an = new Animal();
        Fish fn = new Fish();
        
        an.breathe();
        fn.breathe();
    }
}

输出结果：
                  Animal breathe!
                  Animal breathe!

覆盖

在子类中定义一个与父类同名，返回类型，参数类型均相同的一个方法，称为方法的覆盖。方法的覆盖发生在子类与父类之间。另外，可用super提供对父类的访问。

class Animal{
    void eat(){
        System.out.println("Animal eat");
    }
    void sleep(){
        System.out.println("Animal sleep");
    }
    void breathe(){
        System.out.println("Animal breathe");
    }
}
 
class Fish extends Animal{
    void breathe(){
        System.out.println("Fish breathe");
    }
}
 
public class TestNew {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Animal an = new Animal();
        Fish fn = new Fish();
        
        an.breathe();
        fn.breathe();
    }
}

输出结果：
                  Animal breathe
                  Fish breathe

参考文件

• Java接口的多继承

• Java的extends用法

• extends和implements区别

⭕4. 接口变量使用接口/接口回调

• 指把使用某一接口的类创建的对象的引用赋给该接口声明的接口变量中，那么该接口变量就可以调用被类实现的接口中的方法，当接口变量调用被类实现的接口中的方法时，就是通知相应的对象调用接口的方法，这一过程对象功能的接口回调。
• 不同的类在使用同一接口时，可能具有不同点的功能体现，即接口的方法体不必相同，因此，接口回调可能产生不同的行为。

interface ShowMessage{
void show(String s);  //接口中方法默认public
}

class Car implements ShowMessage{
public void show(String s){
System.out.println("Car="+s)
       }
}

class Bicycle implements ShowMessage{
public void show(String s){
System.out.println("Bicycle="+s));
      }
 }

public class j01{
public static void main(String args[]){
ShowMessage dm;     //声明接口变量
dm =new Car();          //接口变量中存放对象的引用
dm.show("奔驰");       //接口回调
dm =new Bicycle();
dm.show("捷安特");
      }
}

输出结果：
                Car = 奔驰
                Bicycle = 捷安特

⭕5. Fina类

一旦一个方法被修饰为fina方法，则这个方法不能被重写，即不允许子类通过重写隐藏继承的fina方法。一般对于一些比较重要且不希望子类进行更改的方法，可以声明为fina方法。可防止子类对父类关键方法的错误重写，增加了代码的安全性和正确性。

• Final+变量=常量
• Final+方法：可以被继承，不能隐藏和修改
• Static+变量=地址不变（公共设施）
• Static+方法=>类方法（可直接被调用继承）①类.Static方法名
  ②继承 ③隐藏 ④修改

⭕6. 内部类

• java语言支持在一个类中声明另一个类，即类中可以嵌套类。嵌套在其他类中的类称作内部类，而包含内部类的类成为内部类的外嵌类。
• 内部类同样可以声明自己的方法和成员变量，外嵌类把内部类看作是自己的成员。外嵌类的成员变量在内部类中仍然有效，内部类中的方法也可以调用外嵌类中的方法。不过，内部类的类体中不可以声明类变量和类方法。此外，外嵌类可以用内部类声明对象，作为外嵌类成员。