Cet article vous apporte des connaissances pertinentes sur Java, qui introduit principalement des problèmes liés aux interfaces, y compris l'introduction, l'utilisation et l'application du mode proxy, ainsi que la comparaison entre les interfaces et les classes abstraites. Jetons un coup d'œil au contenu ci-dessous, J'espère que cela sera utile à tout le monde.
Étude recommandée : "Tutoriel vidéo Java"
D'une part, il est parfois nécessaire de dériver une sous-classe de plusieurs classes et d'hériter de toutes leurs propriétés et méthodes. Cependant, Java ne prend pas en charge l'héritage multiple. Avec les interfaces, vous pouvez obtenir l'effet de Héritage multiple.
Par contre, il est parfois nécessaire d'extraire certaines caractéristiques comportementales communes à plusieurs classes, et il n'y a pas de relation entre elles, elles ont juste les mêmes caractéristiques comportementales. Par exemple : les souris, claviers, imprimantes, scanners, appareils photo, chargeurs, lecteurs MP3, téléphones portables, appareils photo numériques, disques durs mobiles, etc. prennent tous en charge les connexions USB.
Une interface est une spécification, qui définit un ensemble de règles et incarne l'idée du "si vous êtes/voulez..., vous devez pouvoir..." dans le monde réel. L'héritage est une relation de type "est-ce que c'est", tandis que l'implémentation d'une interface est une relation de type "est-ce que ça peut être".
L'essence des interfaces, ce sont les contrats, les normes, les spécifications, tout comme nos lois. Une fois établi, chacun doit le respecter.
L'interface est définie à l'aide du mot clé
interface.interface来定义。
Java中，接口和类是并列关系，或者接口可以理解为一种特殊的类。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义(
JDK7.0及之前)，而没有变量和方法的实现。
定义Java类的语法格式：先写extends，后写implements
class SubClass extends SuperClass implements InterfaceA{ }接口(
interface)是抽象方法和常量值定义的集合。
如何定义接口：
JDK7及以前：只能定义全局常量和抽象方法
- 接口中的所有成员变量都默认是由
public static final修饰的，可以省略不写。- 接口中的所有抽象方法都默认是由
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：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法。
L'interface (
- 静态方法：使用
static关键字修饰。
接口中定义的静态方法，只能通过接口来调用，并执行其方法体。我们经常在相互一起使用的类中使用静态方法。你可以在标准库中找到像Collection/Collections或者Path/Paths这样成对的接口和类。- 默认方法：默认方法使用
default关键字修饰。可以通过实现类对象来调用。我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。比如：java 8 API中对Collection、List、Comparator
En Java, les interfaces et les classes sont
parallèles, ou les interfaces peuvent être comprises comme une classe spéciale. Essentiellement, une interface est une classe abstraite spéciale qui contient uniquement les définitions de constantes et de méthodes (JDK7.0et versions antérieures), sans l'implémentation de variables et de méthodes. Définir le format de syntaxe des classes Java :
Écrivez d'abordextends, puisimplementspublic void myMethod(){ method3();//调用自己定义的重写的方法 super.method3();//调用的是父类中声明的 //调用接口中的默认方法 CompareA.super.method3(); CompareB.super.method3(); }Copier après la connexioninterface) est un méthode abstraite et une collection de définitions de valeurs constantes.
Comment définir une interface :
JDK7 et avant : seules les 🎜constantes globales et méthodes abstraites peuvent être définies🎜🎜
- Toutes les 🎜variables membres🎜 de l'interface sont définies par défaut par public static final modifié, peut être omis. 🎜
- Toutes les 🎜méthodes abstraites🎜 de l'interface sont modifiées par
public abstractpar défaut. 🎜🎜🎜🎜Démonstration de code : 🎜🎜🎜JDK8 : En plus de définir des constantes globales et des méthodes abstraites, vous pouvez également définir des 🎜méthodes statiques et des méthodes par défaut🎜. 🎜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(); } }Copier après la connexion
- 🎜Méthode statique🎜 : utilisez le mot-clé
staticpour le modifier. 🎜🎜Les méthodes statiques définies dans l'interface ne peuvent être appelées que via l'interface et exécuter son corps de méthode🎜. Nous utilisons souvent des méthodes statiques dans des classes utilisées ensemble. Vous pouvez trouver des paires d'interfaces et de classes commeCollection/CollectionsouPath/Pathsdans la bibliothèque standard. 🎜- 🎜Méthode par défaut🎜 : La méthode par défaut est modifiée avec le mot clé
default. 🎜peut être appelé🎜 en implémentant un objet de classe. Nous fournissons de nouvelles méthodes dans les interfaces existantes tout en maintenant la compatibilité avec les anciennes versions de code. Par exemple : l'API Java 8 fournit des méthodes par défaut riches pour des interfaces telles queCollection,ListetComparator. 🎜 ● Si une méthode par défaut est définie dans une interface et qu'une méthode avec le même nom et les mêmes paramètres est également définie dans une autre interface (que cette méthode soit ou non la méthode par défaut), lorsque la classe d'implémentation implémente les deux interfaces, un Un message d'erreur apparaîtra : 🎜Conflit d'interface🎜. 🎜 Solution : 🎜 La classe d'implémentation doit remplacer la méthode portant le même nom et les mêmes paramètres dans l'interface pour résoudre le conflit 🎜. 🎜 ● Si une interface définit une méthode par défaut et que la classe parent définit également une méthode non abstraite avec le même nom et les mêmes paramètres, alors la sous-classe appellera la méthode du même nom dans la classe parent par défaut si elle ne remplace pas cette méthode. Les méthodes avec les mêmes paramètres ne provoqueront pas de conflits. Parce qu'en ce moment, nous respectons : 🎜le principe de priorité de classe🎜. Les méthodes par défaut portant le même nom et les mêmes paramètres dans l'interface sont ignorées. 🎜 ● Comment appeler la méthode surchargée dans la classe parent ou l'interface dans la méthode de la sous-classe (ou de la classe d'implémentation) ? l'outil d'interface ! Cela signifie que l'interface ne peut pas être instanciée. 🎜
接口采用多继承机制。可以实现多个接口 ，弥补了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("打印机结束工作");
} }安全代理：屏蔽对真实角色的直接访问。
远程代理：通过代理类处理远程方法调用（RMI）。
延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象，比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时，不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。
静态代理（静态定义代理类）
动态代理（动态生成代理类）
//举例一：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());
} }推荐学习：《java视频教程》
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
