Java-接口（一篇讲透）

一时失言乱红尘 2024-04-28 08:11 10阅读 0赞

#### 接口（interface） ####

*  前言
 *   *  一、引入
     *  二、理解
     *  三、使用
     *  四、应用：代理模式(Proxy)
     *   *  1. 应用场景
         *  2. 分类
         *  3. 代码演示
     *  五、接口和抽象类之间的对比
     *  六、经典题目（排错）

--------------------

## 前言 ##

本博主将用CSDN记录软件开发求学之路上亲身所得与所学的心得与知识，有兴趣的小伙伴可以关注博主！  
也许一个人独行，可以走的很快，但是一群人结伴而行，才能走的更远！让我们在成长的道路上互相学习，欢迎关注！

### 一、引入 ###

> 一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。  
> 另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有is-a的关系，仅仅是具有相同的行为特征而已。例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都支持USB连接。

### 二、理解 ###

> ⭕ 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的关系，而接口实现则是"能不能"的关系。

> ⭕ 接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。

### 三、使用 ###

> ⭕ 接口使用关键字`interface`来定义。

> ⭕ Java中，接口和类是并列关系，或者接口可以理解为一种特殊的类。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义(`JDK7.0`及之前)，而没有变量和方法的实现。  
> 定义Java类的语法格式：先写`extends`，后写`implements`

class SubClass extends SuperClass implements InterfaceA{
          }

> ⭕ 接口(`interface`)是抽象方法和常量值定义的集合。

> ⭕ 如何定义接口：

> 🔺JDK7及以前：只能定义全局常量和抽象方法
> 
> 1.  接口中的所有成员变量都默认是由`public static final`修饰的，可以省略不写。
> 2.  接口中的所有抽象方法都默认是由`public abstract`修饰的。

代码演示：

public interface Runner {
         
      int ID = 1;//<=>public static final int ID = 1;
      void start();//<=>public abstract void start();
      public void run();//<=>public abstract void run();
      void stop();//<=>public abstract void stop();
    }

> 🔺JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法。
> 
> 1.  静态方法：使用 `static` 关键字修饰。  
>     接口中定义的静态方法，只能通过接口来调用，并执行其方法体。我们经常在相互一起使用的类中使用静态方法。你可以在标准库中找到像`Collection/Collections`或者`Path/Paths`这样成对的接口和类。
> 2.  默认方法：默认方法使用 `default` 关键字修饰。可以通过实现类对象来调用。我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。比如：java 8 API中对`Collection`、`List`、`Comparator`等接口提供了丰富的默认方法。  
>     ● 若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接口时，会出现：接口冲突。  
>     解决办法：实现类必须覆盖接口中同名同参数的方法，来解决冲突。  
>     ● 若一个接口中定义了一个默认方法，而父类中也定义了一个同名同参数的非抽象方法，那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法，不会出现冲突问题。因为此时遵守：类优先原则。接口中具有相同名称和参数的默认方法会被忽略。  
>     ● 如何在子类(或实现类)的方法中调用父类、接口中被重写的方法?

代码演示1：

public void myMethod(){
         
    		method3();//调用自己定义的重写的方法
    		super.method3();//调用的是父类中声明的
    		//调用接口中的默认方法
    		CompareA.super.method3();
    		CompareB.super.method3();
    	}

代码演示2：

interface Filial {
         // 孝顺的
    	default void help() {
         
    		System.out.println("老妈，我来救你了");
    	}
    }
    interface Spoony {
         // 痴情的
    	default void help() {
         
    		System.out.println("媳妇，别怕，我来了");
    	}
    }
    class Father{
         
    	public void help(){
         
    		System.out.println("儿子，就我媳妇！");
    	}
    }
    
    class Man extends Father implements Filial, Spoony {
         
    	@Override
    	public void help() {
         
    		System.out.println("我该就谁呢？");
    		Filial.super.help();
    		Spoony.super.help();
    	}	
    }

> ⭕ 接口中不能定义构造器的！意味着接口不可以实例化。

> ⭕ 接口采用多继承机制。可以实现多个接口 ，弥补了Java单继承性的局限性。  
> 格式：`class AA extends BB implements CC,DD,EE;`

> ⭕ Java开发中，接口通过让类去实现(`implements`)的方式来使用。  
> 🔺 如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化 。  
> 🔺 如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类。

代码演示：

/*
    实现类SubAdapter必须给出接口SubInterface以及父接口MyInterface
    中所有方法的实现。否则，SubAdapter仍需声明为abstract的。
    */
    interface MyInterface{
         
        String s=“MyInterface”;
        public void absM1();
        }
    interface SubInterface extends MyInterface{
         
        public void absM2();
        }
    public class SubAdapter implements SubInterface{
         
        public void absM1(){
         System.out.println(“absM1”);}
        public void absM2(){
         System.out.println(“absM2”);}
    }

> ⭕ 接口与接口之间可以继承，而且可以多继承。

> ⭕ 一个类可以实现多个无关的接口。

代码演示：

interface Runner {
          public void run();}
    interface Swimmer {
         public double swim();}
    class Creator{
         public int eat(){
         …}} 
    class Man extends Creator implements Runner ,Swimmer{
         
        public void run() {
         ……}
        public double swim() {
         ……}
        public int eat() {
         ……}
    }

> ⭕ 与继承关系类似，接口与实现类之间存在多态性

代码演示：

public class Test{
         
      public static void main(String args[]){
         
        Test t = new Test();
        Man m = new Man();
        t.m1(m);
        t.m2(m);
        t.m3(m);
      }
      public String m1(Runner f) {
          f.run(); }
      public void m2(Swimmer s) {
         s.swim();}
      public void m3(Creator a) {
         a.eat();}
    }

> ⭕ 接口的匿名实现类匿名对象

代码演示：

public class USBTest {
         
    	public static void main(String[] args) {
         
    		
    		Computer com = new Computer();
    		//1.创建了接口的非匿名实现类的非匿名对象
    		Flash flash = new Flash();
    		com.transferData(flash);
    		
    		//2. 创建了接口的非匿名实现类的匿名对象
    		com.transferData(new Printer());
    		
    		//3. 创建了接口的匿名实现类的非匿名对象
    		USB phone = new USB(){
         
    			@Override
    			public void start() {
         
    				System.out.println("手机开始工作");
    			}
    			@Override
    			public void stop() {
         
    				System.out.println("手机结束工作");
    			}			
    		};
    		com.transferData(phone);
    		
    		
    		//4. 创建了接口的匿名实现类的匿名对象
    		
    		com.transferData(new USB(){
         
    			@Override
    			public void start() {
         
    				System.out.println("mp3开始工作");
    			}
    
    			@Override
    			public void stop() {
         
    				System.out.println("mp3结束工作");
    			}
    		});
    	}
    }
    
    class Computer{
         	
    	public void transferData(USB usb){
         //USB usb = new Flash();
    		usb.start();		
    		System.out.println("具体传输数据的细节");		
    		usb.stop();
    	}		
    }
    
    interface USB{
         
    	//常量：定义了长、宽、最大最小的传输速度等	
    	void start();	
    	void stop();	
    }
    
    class Flash implements USB{
         
    	@Override
    	public void start() {
         
    		System.out.println("U盘开启工作");
    	}
    	@Override
    	public void stop() {
         
    		System.out.println("U盘结束工作");
    	}	
    }
    
    class Printer implements USB{
         
    	@Override
    	public void start() {
         
    		System.out.println("打印机开启工作");
    	}
    	@Override
    	public void stop() {
         
    		System.out.println("打印机结束工作");
    	}	
    }

### 四、应用：代理模式(Proxy) ###

#### 1. 应用场景 ####

> ⭕ 安全代理：屏蔽对真实角色的直接访问。

> ⭕ 远程代理：通过代理类处理远程方法调用（RMI）。

> ⭕ 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象，比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时，不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。

#### 2. 分类 ####

> ⭕ 静态代理（静态定义代理类）  
> ⭕ 动态代理（动态生成代理类）

#### 3. 代码演示 ####

//举例一：
    interface Network {
         
        public void browse();
        }
    // 被代理类
    class RealServer implements Network {
          @Override
        public void browse() {
         
        System.out.println("真实服务器上
        网浏览信息");
        } 
    }
    // 代理类
    class ProxyServer implements Network {
         
        private Network network;
        public ProxyServer(Network network) {
         
        this.network = network; }
        public void check() {
         
        System.out.println("检查网络连接等操作");
    }
        public void browse() {
         
        check();
        network.browse();
        } 
    }
    public class ProxyDemo {
         
        public static void main(String[] args) {
         
        Network net = new ProxyServer(new
        RealServer());
        net.browse();
        } 
    }
    
    //举例二：
    public class StaticProxyTest {
         
    	public static void main(String[] args) {
         
    		Proxy s = new Proxy(new RealStar());
    		s.confer();
    		s.signContract();
    		s.bookTicket();
    		s.sing();
    		s.collectMoney();
    	}
    }
    
    interface Star {
         
    	void confer();// 面谈
    	void signContract();// 签合同
    	void bookTicket();// 订票
    	void sing();// 唱歌
    	void collectMoney();// 收钱
    }
    //被代理类
    class RealStar implements Star {
         
    	public void confer() {
         
    	}
    	public void signContract() {
         
    	}
    	public void bookTicket() {
         
    	}
    	public void sing() {
         
    		System.out.println("明星：歌唱~~~");
    	}
    	public void collectMoney() {
         
    	}
    }
    //代理类
    class Proxy implements Star {
         
    	private Star real;
    	public Proxy(Star real) {
         
    		this.real = real;
    	}
    	public void confer() {
         
    		System.out.println("经纪人面谈");
    	}
    	public void signContract() {
         
    		System.out.println("经纪人签合同");
    	}
    	public void bookTicket() {
         
    		System.out.println("经纪人订票");
    	}
    	public void sing() {
         
    		real.sing();
    	}
    	public void collectMoney() {
         
    		System.out.println("经纪人收钱");
    	}
    }

### 五、接口和抽象类之间的对比 ###

<table> 
 <thead> 
  <tr> 
   <th align="center">No.</th> 
   <th align="center">区别点</th> 
   <th align="center">抽象类</th> 
   <th align="center">接口</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">1</td> 
   <td align="center">定义</td> 
   <td align="center">包含抽象方法的类</td> 
   <td align="center">主要是抽象方法和全局常量的集合</td> 
  </tr> 
  <tr> 
   <td align="center">2</td> 
   <td align="center">组成</td> 
   <td align="center">构造方法、抽象方法、普通方法、常量、变量</td> 
   <td align="center">常量、抽象方法、(jdk8.0:默认方法、静态方法)</td> 
  </tr> 
  <tr> 
   <td align="center">3</td> 
   <td align="center">使用</td> 
   <td align="center">子类继承抽象类(<code>extends</code>)</td> 
   <td align="center">子类实现接口(<code>implements</code>)</td> 
  </tr> 
  <tr> 
   <td align="center">4</td> 
   <td align="center">关系</td> 
   <td align="center">抽象类可以实现多个接口</td> 
   <td align="center">接口不能继承抽象类，但允许继承多个接口</td> 
  </tr> 
  <tr> 
   <td align="center">5</td> 
   <td align="center">常见设计模式</td> 
   <td align="center">模板方法</td> 
   <td align="center">简单工厂、工厂方法、代理模式</td> 
  </tr> 
  <tr> 
   <td align="center">6</td> 
   <td align="center">对象</td> 
   <td align="center">都通过对象的多态性产生实例化对象</td> 
   <td align="center">都通过对象的多态性产生实例化对象</td> 
  </tr> 
  <tr> 
   <td align="center">7</td> 
   <td align="center">局限</td> 
   <td align="center">抽象类有单继承的局限</td> 
   <td align="center">接口没有此局限</td> 
  </tr> 
  <tr> 
   <td align="center">8</td> 
   <td align="center">实际</td> 
   <td align="center">作为一个模板</td> 
   <td align="center">是作为一个标准或是表示一种能力</td> 
  </tr> 
  <tr> 
   <td align="center">9</td> 
   <td align="center">选择</td> 
   <td align="center">如果抽象类和接口都可以使用的话，优先使用接口，因为避免单继承的局限</td> 
   <td align="center">如果抽象类和接口都可以使用的话，优先使用接口，因为避免单继承的局限</td> 
  </tr> 
 </tbody> 
</table>

### 六、经典题目（排错） ###

//题目一：
    interface A {
         
        int x = 0;
        }
    class B {
         
        int x = 1;
        }
    class C extends B implements A {
         
        public void pX() {
         
        System.out.println(x);
        }
    public static void main(String[] args) {
         
        new C().pX();
        } 
    }
    
    //题目二：
    interface Playable {
         
        void play();
        }
    interface Bounceable {
         
        void play();
    }
    interface Rollable extends Playable, Bounceable {
         
        Ball ball = new Ball("PingPang");
    }
    class Ball implements Rollable {
         
        private String name;
        public String getName() {
         
        return name; 
        }
        public Ball(String name) {
         
        this.name = name; 
        }
        public void play() {
         
        ball = new Ball("Football");
        System.out.println(ball.getName());
        } 
    }