Bagaimana untuk menentukan dan menggunakan antara muka Java

1. Pengenalan

Di satu pihak, kadangkala perlu untuk mendapatkan subkelas daripada beberapa kelas dan mewarisi semua sifat dan kaedahnya. Walau bagaimanapun, Java tidak menyokong pelbagai warisan. Dengan antara muka, anda boleh mendapatkan kesan warisan berbilang.

Sebaliknya, kadangkala perlu mengekstrak beberapa ciri tingkah laku biasa daripada beberapa kelas, dan tidak ada perhubungan antara mereka, mereka hanya mempunyai ciri tingkah laku yang sama. Contohnya: tetikus, papan kekunci, pencetak, pengimbas, kamera, pengecas, pemain MP3, telefon mudah alih, kamera digital, pemacu keras mudah alih, dsb. semuanya menyokong sambungan USB.

2. Faham

Antara muka ialah spesifikasi, yang mentakrifkan satu set peraturan dan merangkumi idea "jika anda mahu..., anda mesti boleh.. ." di dunia nyata. Warisan ialah hubungan "adakah", manakala pelaksanaan antara muka ialah hubungan "bolehkah".

Intipati antara muka ialah kontrak, piawaian dan spesifikasi, sama seperti undang-undang kita. Setelah dirumus, semua orang mesti mematuhinya.

3 Gunakan antara muka

untuk mentakrifkannya menggunakan kata kunci interface.

Di Java, antara muka dan kelas berada dalam hubungan selari, atau antara muka boleh difahami sebagai kelas khas. Pada dasarnya, antara muka ialah kelas abstrak khas yang hanya mengandungi takrifan pemalar dan kaedah (JDK7.0 dan sebelumnya), tanpa pelaksanaan pembolehubah dan kaedah.

mentakrifkan format sintaks kelas Java: tulis extends dahulu, kemudian implements

class SubClass extends SuperClass implements InterfaceA{ }

Antaramuka (interface) ialah koleksi kaedah abstrak dan takrifan nilai malar.

Cara untuk menentukan antara muka:

JDK7 dan sebelumnya: hanya pemalar global dan kaedah abstrak boleh ditakrifkan

1. Semua pembolehubah ahli dalam antara muka adalah secara lalai public static finalPengubahsuaian boleh diabaikan.

2. Semua kaedah abstrak dalam antara muka diubah suai oleh public abstract secara lalai.

Demonstrasi kod:

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: Selain mentakrifkan pemalar global dan kaedah abstrak, anda juga boleh mentakrifkan kaedah statik dan kaedah lalai.

1. Kaedah statik: Gunakan static pengubahsuaian kata kunci.

Kaedah statik yang ditakrifkan dalam antara muka hanya boleh dipanggil melalui antara muka dan laksanakan badan kaedahnya. Kami sering menggunakan kaedah statik dalam kelas yang digunakan bersama antara satu sama lain. Anda boleh menemui pasangan antara muka dan kelas seperti Collection/Collections atau Path/Paths dalam pustaka standard.

2. Kaedah lalai: Kaedah lalai diubah suai dengan kata kunci default. Boleh dipanggil dengan melaksanakan objek kelas. Kami menyediakan kaedah baharu dalam antara muka sedia ada sambil mengekalkan keserasian dengan versi kod yang lebih lama. Contohnya: Java 8 API menyediakan kaedah lalai yang kaya untuk antara muka seperti Collection, List dan Comparator.

• Jika antara muka mentakrifkan kaedah lalai, dan antara muka lain juga mentakrifkan kaedah dengan nama yang sama dan parameter yang sama (tidak kira sama ada kaedah ini ialah kaedah lalai), sambil melaksanakan kelas Apabila kedua-dua antara muka ini dilaksanakan, konflik antara muka akan berlaku. Penyelesaian: Kelas pelaksanaan mesti mengatasi kaedah dengan nama dan parameter yang sama dalam antara muka untuk menyelesaikan konflik.

• Jika antara muka mentakrifkan kaedah lalai, dan kelas induk juga mentakrifkan kaedah bukan abstrak dengan nama dan parameter yang sama, maka subkelas tidak akan mengatasi kaedah ini tanpa kaedah , dengan nama yang sama dan parameter yang sama dalam kelas induk dipanggil secara lalai, dan tidak akan ada masalah konflik. Kerana pada masa ini kami mematuhi: prinsip keutamaan kelas. Kaedah lalai dalam antara muka dengan nama dan parameter yang sama diabaikan.

• Bagaimana untuk memanggil kaedah yang diganti dalam kelas induk atau antara muka dalam kaedah subkelas (atau kelas pelaksanaan)?

Pertunjukan kod 1:

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

Demonstrasi Kod 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();
	}	
}

Pembina tidak boleh ditakrifkan dalam antara muka! Ini bermakna antara muka tidak boleh dibuat seketika.

Antara muka menggunakan mekanisme pewarisan berbilang. Pelbagai antara muka boleh dilaksanakan, menebus batasan warisan tunggal Java.

Format: class AA extends BB implements CC,DD,EE;

Dalam pembangunan Java, antara muka digunakan dengan membenarkan kelas melaksanakannya (implements).

• Jika kelas pelaksanaan merangkumi semua kaedah abstrak dalam antara muka, maka kelas pelaksanaan ini boleh dijadikan instantiated.

• Jika kelas pelaksanaan tidak meliputi semua kaedah abstrak dalam antara muka, kelas pelaksanaan masih merupakan kelas abstrak.

Demonstrasi kod:

/*
实现类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”);}
}

Antara muka boleh diwarisi antara satu sama lain dan berbilang warisan mungkin.

Sebuah kelas boleh melaksanakan berbilang antara muka yang tidak berkaitan.

Demonstrasi Kod:

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() {……}
}

Sama seperti hubungan warisan, terdapat polimorfisme antara antara muka dan kelas pelaksanaan

Demonstrasi Kod:

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();}
}

Kelas pelaksanaan tanpa nama objek tanpa nama antara muka

Demonstrasi kod:

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("打印机结束工作");
	}	
}

4 Mod aplikasi-proksi (Proksi)

Senario aplikasi

• Proksi selamat: Sekat akses terus kepada aksara sebenar.

• Proksi jauh: Mengendalikan invokasi kaedah jauh (RMI) melalui kelas proksi.

• 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象，比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有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("经纪人收钱");
	}
}

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

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

六、经典题目(排错)

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

Atas ialah kandungan terperinci Bagaimana untuk menentukan dan menggunakan antara muka Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!