Java接口如何定义和使用

本篇内容介绍了“Java接口如何定义和使用”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

一、引入

一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，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("经纪人收钱");
	}
}

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

六、经典题目(排错)

//题目一：
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());
    } 
}

“Java接口如何定义和使用”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注亿速云网站，小编将为大家输出更多高质量的实用文章！