2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
Pourquoi y a-t-il une interface ?
Comme nous le savons tous, l'héritage consiste à extraire les abstractions communes de la sous-classe dans la classe parent et à obtenirpoint commun à tout le systèmeCependant, pour sauvegarder le code, il existe également une situation : la plupart des sous-classes ont un certain point commun, mais seules quelques sous-classes n'ont pas cette fonctionnalité, alors si ce point commun est écrit dans la classe parent, il sera hérité, ce qui est déraisonnable pour ces quelques sous-catégories.
Par exemple : les chats et les chiens peuvent nager, mais les lapins ne le peuvent pas. À l'heure actuelle, si la méthode "nager" est définie dans la classe parent, il n'est pas raisonnable que le lapin hérite. Cependant, si les chats et les chiens écrivent leurs propres méthodes de nage. respectivement, cela peut arriver. Le format d'écriture et le nom des deux méthodes sont incohérents. Par conséquent, nous devons définir un nouveau concept pour contraindre les spécifications d’écriture des méthodes de « natation » dans ces deux sous-classes.A ce stade, nous pouvons définir une « nage »interface, définissez la méthode abstraite swim() dans l'interface, puis laissez les chats et les chiens se connecter à cette interface pour garantirUnification des codes。
En résumé, l'interface est unrègle, lorsque nous devons définir des règles pour plusieurs classes en même temps, nous devons utiliserinterface。
L'interface ne représente pas un type de chose, l'interface représenteune règle, les interfaces peuvent donc être transmises en tant que paramètres aux méthodes.
"Qu'il s'agisse d'un camion, d'un trois-roues ou de main d'œuvre, tant qu'il peut bouger, ce sera utile."
搬家(车的对象);
搬家(搬家公司);
public interface 运输 {
...
}
public void 搬家(运输的接口 c) {
...
}
public interface 接口名 {}
public class 类名 implements 接口名 {}
public class 类名 implements 接口名1 , 接口名2 {}
public class 类名 extends 父类 implements 接口名1 , 接口名2 {}
pratique:Écrivez des classes Javabean standard avec des interfaces et des classes abstraites.
青蛙 属性：名字，年龄 行为：吃虫子，蛙泳
狗 属性：名字，年龄 行为：吃骨头，狗刨
兔子 属性：名字，年龄 行为：吃胡萝卜
Écrivez d'abord la classe parent. Comme les trois sous-classes mangent des choses différentes, vous pouvez définir eat() comme méthode abstraite :
package oopInterface;
public abstract class Animal {
private String name;
private int age;
public Animal() {
}
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public abstract void eat();
}
Ecrire l'interface Swim :
package oopInterface;
public interface Swim {
public abstract void swim();
}
Lors de l'écriture d'une classe frog, faites attention à l'héritage de la classe parent et à la réécriture de la méthode abstraite de la classe parent, et faites attention à l'implémentation de l'interface swim :
package oopInterface;
public class Frog extends Animal implements Swim {
public Frog() {
super();
}
public Frog(String name, int age) {
super(name, age);
}
@Override
public void swim() {
System.out.println("青蛙在蛙泳。");
}
@Override
public void eat() {
System.out.println("青蛙在吃虫子。");
}
}
Lors de l'écriture d'une classe dog, faites attention à hériter de la classe parent et à réécrire la méthode abstraite de la classe parent pour implémenter l'interface de natation :
package oopInterface;
public class Dog extends Animal implements Swim {
public Dog(){
super();
}
public Dog(String name, int age) {
super(name,age);
}
@Override
public void swim() {
System.out.println("狗在狗刨。");
}
@Override
public void eat() {
System.out.println("狗在吃骨头。");
}
}
Lors de l'écriture d'une classe lapin, notez qu'il vous suffit d'hériter de la classe parent et de remplacer la méthode abstraite, et que vous n'avez pas besoin d'implémenter l'interface de natation (vous ne pouvez pas nager) :
package oopInterface;
public class Rabbit extends Animal {
public Rabbit() {
}
public Rabbit(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("兔子在吃胡萝卜。");
}
}
Écrivez des classes de test.
package oopInterface;
public class Test {
public static void main(String[] args) {
Frog f = new Frog("小绿",23);
f.eat();
f.swim();
System.out.println(f.getName() + ", " + f.getAge());
Dog d = new Dog("大D", 24);
d.eat();
d.swim();
System.out.println(d.getName() + ", " + d.getAge());
Rabbit r = new Rabbit("兔子", 30);
r.eat();
System.out.println(r.getName() + ", " + r.getAge());
}
}
Avis:
1. Lorsqu'une classe implémente une interface, elle doit soit implémenter toutes les méthodes abstraites de l'interface, soit la classe elle-même est également une classe abstraite.
2. Une classe peut implémenter plusieurs interfaces. Si elle implémente plusieurs interfaces, elle doit l'être.tousToutes les méthodes abstraites à implémenter dans l'interface sont implémentées.
3. Les interfaces peuvent être héritées de plusieurs interfaces. Si une sous-interface hérite de plusieurs interfaces et est ensuite implémentée par une classe d'implémentation, alors la classe d'implémentation doit combiner la sous-interface et toutes ses interfaces parentes.tousToutes les méthodes abstraites sont implémentées.
pratique:Écrivez des classes Javabean standard avec des interfaces et des classes abstraites.
乒乓球运动员：姓名，年龄，学打乒乓球，说英语
篮球运动员：姓名，年龄，学打篮球
乒乓球教练：姓名，年龄，教打乒乓球，说英语
篮球教练：姓名，年龄，教打篮球
//Person类
package oopInterExp;
//因为直接创建顶层父类人的对象是没有意义的
//所以将其写为抽象类
public abstract class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
//Sporter类继承Person
package oopInterExp;
public abstract class Sporter extends Person {
public Sporter(String name, int age) {
super(name, age);
}
public Sporter() {
}
public abstract void learn();
}
//Coach类继承Person
package oopInterExp;
public abstract class Coach extends Person {
public Coach() {
}
public Coach(String name, int age) {
super(name, age);
}
public abstract void teach();
}
//SpeakEnglish接口
package oopInterExp;
public interface SpeakEnglishInter {
public abstract void speakEnglish();
}
//PingPongSporter继承Sporter，实现SpeakEnglish
package oopInterExp;
public class PingPongSporter extends Sporter implements SpeakEnglishInter {
public PingPongSporter(String name, int age) {
super(name, age);
}
public PingPongSporter() {
}
@Override
public void learn() {
System.out.println("学习乒乓球。");
}
@Override
public void speakEnglish() {
System.out.println("乒乓球运动员在说英语。");
}
}
//PingPongCoach继承Coach，实现SpeakEnglish
package oopInterExp;
public class PingPongCoach extends Coach implements SpeakEnglishInter {
public PingPongCoach() {
}
public PingPongCoach(String name, int age) {
super(name, age);
}
@Override
public void teach() {
System.out.println("教乒乓球。");
}
@Override
public void speakEnglish() {
System.out.println("乒乓球教练在说英语。");
}
}
//BasketballSporter继承Sporter
package oopInterExp;
public class BasketballSporter extends Sporter {
public BasketballSporter(String name, int age) {
super(name, age);
}
public BasketballSporter() {
}
public void learn() {
System.out.println("学篮球。");
}
}
//BasketballCoach继承Coach
package oopInterExp;
public class BasketballCoach extends Coach {
public BasketballCoach() {
}
public BasketballCoach(String name, int age) {
super(name, age);
}
public void teach() {
System.out.println("教篮球。");
}
}
Avant JDK7, seules les méthodes abstraites pouvaient être définies dans les interfaces.
La nouvelle fonctionnalité du JDK8 est la suivante : les méthodes avec des corps de méthode peuvent être définies dans l'interface (peut définirdéfautméthode oustatiqueméthode).
La nouvelle fonctionnalité du JDK9 est la suivante : elle peut être définie dans l'interfaceprivéméthode.
Les méthodes avec des corps de méthode sont définies dans l'interface, principalement pourMise à niveau de l'interfaceÉtant donné que l'interface ne peut pas être immuable, de nouvelles méthodes doivent y être ajoutées pour être mises à niveau. Si ces méthodes sont des méthodes abstraites, à l'heure actuelle, ces méthodes doivent être implémentées dans la classe d'implémentation en même temps, ce qui est très gênant et. pas facile à synchroniser ; si La mise à niveau utilise une méthode avec un corps de méthode, donc la classe d'implémentation n'a pas besoin d'être modifiée en plus. Si une modification est nécessaire, elle peut également être modifiée par réécriture.
Interface Inter1 :
package oopInterface5;
public interface Inter1 {
public abstract void method();
public default void default_method() {
System.out.println("Inter1接口中的默认方法");
}
}
Interface Inter2 :
package oopInterface5;
public interface Inter2 {
public default void default_method() {
System.out.println("Inter2接口中的默认方法");
}
}
Les deux méthodes par défaut ont le même nom. Si la classe d'implémentation implémente ces deux interfaces en même temps, cette méthode par défaut doit être réécrite !
package oopInterface5;
public class InterImpl implements Inter1, Inter2 {
@Override
public void method() {
System.out.println("抽象方法的实现");
}
@Override
public void default_method() {
System.out.println("重写接口中的默认方法");
}
}
Classe d'essai :
package oopInterface5;
public class Test {
public static void main(String[] args) {
InterImpl ii = new InterImpl();
ii.method(); //抽象方法的实现
ii.default_method(); //重写接口中的默认方法
}
}
JDK8 et versions ultérieures permettront de définir des méthodes statiques dans les interfaces, qui doivent être modifiées avec static.
dans l'interfaceméthode statiqueLe format de définition est :
Points à noter concernant les méthodes statiques dans les interfaces :
Écrivez une interface :
package oopInterface6;
public interface Inter {
public abstract void method();
public static void static_method() {
System.out.println("接口中的静态方法");
}
}
Écrivez une classe d'implémentation. Il existe également une méthode statique dans la classe avec le même nom que la méthode dans l'interface, mais cela n'est pas prioritaire car les méthodes statiques ne peuvent pas être remplacées :
package oopInterface6;
public class InteImpl implements Inter {
@Override
public void method() {
System.out.println("重写接口中的抽象方法");
}
//这不叫重写
public static void static_method() {
System.out.println("我不是重写的Inter接口中的静态方法");
}
}
Mais en réalité, les deux méthodes sont différentes.
package oopInterface6;
public class Test {
public static void main(String[] args) {
InteImpl ii = new InteImpl();
ii.method(); //重写接口中的抽象方法
Inter.static_method(); //调用接口中的静态方法
InteImpl.static_method(); //调用实现类中的一个同名的静态方法
}
}
package oopInterface7;
public interface InterA {
public default void show1() {
System.out.println("show1开始执行");
show3();
}
public default void show2() {
System.out.println("show2开始执行");
show3();
}
//普通的私有方法，给默认方法服务的
private void show3() {
System.out.println("记录程序在运行过程中的各种细节，这里有100行代码。");
}
}
package oopInterface7;
public interface InterB {
public static void show1() {
System.out.println("show1开始执行");
show3();
}
public static void show2() {
System.out.println("show2开始执行");
show3();
}
//普通的私有方法，给静态方法服务的
private static void show3() {
System.out.println("记录程序在运行过程中的各种细节，这里有100行代码。");
}
}
1. L'interface représente des règles et est une abstraction du comportement. Si vous souhaitez qu'une classe ait un comportement, laissez-la simplement implémenter l'interface correspondante.
2. Lorsque le paramètre d'une méthode est une interface, l'interface peut être passéeTous les objets de la classe d'implémentation, cette approche est appelée polymorphisme d'interface.
Les adaptateurs peuvent être utilisés pour simplifier le code et éviter les désagréments causés lorsqu'il y a trop de méthodes abstraites dans l'interface et que nous n'avons besoin d'en utiliser qu'une partie.
Les étapes d'écriture sont généralement :
1. Écrivez la classe intermédiaire XXXAdapter pour implémenter l'interface correspondante.
2. Implémentez des implémentations vides de méthodes abstraites dans l'interface.
3. Laissez la classe d'implémentation réelle hériter de la classe intermédiaire et réécrivez les méthodes requises.
4. Afin d'empêcher d'autres classes de créer des objets de la classe adaptateur, la classe adaptateur intermédiaire est décorée de résumé.
interface:
package AdapterDesignPattern;
public interface Inter {
public abstract void method1();
public abstract void method2();
public abstract void method3();
public abstract void method4();
public abstract void method5();
}
Classe d'adaptateur :
package AdapterDesignPattern;
public abstract class InterAdapter implements Inter {
@Override
public void method1() {
}
@Override
public void method2() {
}
@Override
public void method3() {
}
@Override
public void method4() {
}
@Override
public void method5() {
}
}
Classe d'implémentation :
package AdapterDesignPattern;
public class InterImpl extends InterAdapter {
//我需要用到哪个方法，就重写哪个方法就可以了
@Override
public void method5() {
System.out.println("只要用第五个方法");
}
}
Il se consacre à la recherche technologique depuis plus de 30 ans et maîtrise divers langages tels que java, linux, javascript, php, css, etc. Il a apporté de nombreuses contributions dans le domaine de l'open source. station de documentation pour les développeurs pour partager certains problèmes de développement technologique pour référence future.
