Qu'est-ce qu'une interface et qu'est-ce qu'une classe abstraite ? Avec les classes abstraites, pourquoi avons-nous besoin d'interfaces ?
La classe abstraite est relative à la classe ordinaire. La classe ordinaire est une classe fonctionnelle complète qui peut générer directement des objets instanciés, et les classes ordinaires peuvent contenir des constructeurs, méthodes ordinaires, méthodes statiques, constantes, variables, etc. Les classes abstraites font référence à l'ajout de composants de méthode abstraite à la structure des classes ordinaires, ou à la déclaration directe de la classe comme type abstrait
De même, les méthodes abstraites sont relatives aux méthodes ordinaires ; être un "{}" au-dessus de toutes les méthodes ordinaires, qui représente le corps de la méthode. Les méthodes avec des corps de méthode doivent être directement utilisées par les objets. Les méthodes abstraites font référence à des méthodes sans corps de méthode, et les méthodes abstraites doivent également être modifiées avec le mot-clé abstract. Une classe avec des méthodes abstraites est une classe abstraite et les classes abstraites doivent être déclarées à l'aide du mot-clé abstract.
Ce qui suit est une classe abstraite simple :
package abstractdemo;
//抽象类 public abstract class AbstractDemo { //抽象方法,没有方法体 public abstract void test();
public void test1(){
System.out.println("普通方法");
}
public static void main(String[] args) {
Class<AbstractDemo> c = AbstractDemo.class;
System.out.println(c.getName());
}
}Instance de classe abstraite :
package abstractdemo;
public abstract class AbstractTest {
public static void main(String[] args) {
AbstractDemo ad = new AbstractDemo() {
@Override public void test() {
System.out.println("实例抽象类要重写抽象类中所有的抽象方法!");
}
};
ad.test();
System.out.println(ad.getClass());
}
}Comme le montre ce qui précède, les classes abstraites ne peuvent pas être instanciées directement. Pourquoi ne peut-il pas être instancié directement ? Lorsqu'une classe est instanciée, cela signifie que l'objet peut appeler des attributs ou des méthodes dans la classe, mais il existe des méthodes abstraites dans les classes abstraites, et les méthodes abstraites n'ont pas de corps de méthode et elles ne peuvent pas être appelées sans corps de méthode. Puisque les appels de méthode ne peuvent pas être effectués, comment générer des objets instanciés. Par conséquent, lors de l'instanciation d'une classe abstraite, il vous sera demandé de remplacer d'abord la méthode abstraite dans la classe abstraite ; s'il n'y a pas de méthode abstraite dans une classe abstraite, la classe ne peut pas être instanciée et une erreur de compilation sera signalée lors de l'instanciation ;
Les principes d'utilisation des classes abstraites sont les suivants :
(1) Les méthodes abstraites doivent être publiques ou protégées (car si elles sont privées, elles ne peut pas être hérité par les sous-classes, et les sous-classes ne peuvent pas les implémenter) Cette méthode) est publique par défaut
(2) Les classes abstraites ne peuvent pas être instanciées directement et doivent être gérées par les sous-classes via une transformation ascendante ; 🎜>
(3) Les classes abstraites doivent avoir des sous-classes. Utiliser l'héritage étendu. Une sous-classe ne peut hériter que d'une seule classe abstraite
(4) Les sous-classes (si ce ne sont pas des classes abstraites) doivent être utilisées. remplacer l'abstraction. Toutes les méthodes abstraites de la classe (si la sous-classe n'implémente pas la méthode abstraite de la classe parent, alors la sous-classe est également une classe abstraite)
Regardez un morceau de code ci-dessous :
package abstractdemo;
//抽象类 public abstract class AbstractDemo { //抽象方法,没有方法体 public abstract void test();
public void test1(){
System.out.println("普通方法");
}
public static void main(String[] args) {
Class<AbstractDemo> c = AbstractDemo.class;
System.out.println(c.getName());
}
}
package abstractdemo;
public class Test extends AbstractDemo{
@Override public void test() {
System.out.println("继承抽象类,一定要重写抽象类中的抽象方法,如果不重写,那么该类也是抽象类!");
}
}
package abstractdemo;
public class Demo {
public static void main(String[] args) {
AbstractDemo ad = new Test();
ad.test();
}
}现在就可以清楚的发现：
（1）抽象类继承子类里面有明确的方法覆写要求，而普通类可以有选择性的来决定是否需要覆写；
（2）抽象类实际上就比普通类多了一些抽象方法而已，其他组成部分和普通类完全一样；
（3）普通类对象可以直接实例化，但抽象类的对象必须经过向上转型之后才可以得到。
虽然一个类的子类可以去继承任意的一个普通类，可是从开发的实际要求来讲，普通类尽量不要去继承另外一个普通类，而是去继承抽象类。
抽象类的使用限制：
1.由于抽象类里会存在一些属性，那么抽象类中一定存在构造方法，其存在目的是为了属性的初始化。抽象类中是有构造函数的，所以子类继承抽象类，构造方法的调用顺序仍然是先父类构造函数，然后子类构造函数
2.抽象类不可以修饰为final，因为抽象类有子类，而final修饰的类不能被继承；
3.外部抽象类不能被修饰为static，外部抽象类不允许使用static声明，而内部的抽象类运行使用static声明。使用static声明的内部抽象类相当于一个外部抽象类的成员，继承的时候使用“外部类.内部类”的形式表示类名称。
package com.wz.abstractdemo;static abstract class A{//定义一个抽象类public abstract void print();
}class B extends A{public void print(){
System.out.println("**********");
}
}public class TestDemo {public static void main(String[] args) {
A a = new B();//向上转型 a.print();
}
}执行结果
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
Illegal modifier for the class A; only public, abstract & final are permitted
at com.wz.abstractdemo.A.<init>(TestDemo.java:3)
at com.wz.abstractdemo.B.<init>(TestDemo.java:9)
at com.wz.abstractdemo.TestDemo.main(TestDemo.java:18)再看一个关于内部抽象类：
package com.wz.abstractdemo;abstract class A{//定义一个抽象类static abstract class B{//static定义的内部类属于外部类public abstract void print();
}
}class C extends A.B{public void print(){
System.out.println("**********");
}
}public class TestDemo {public static void main(String[] args) {
A.B ab = new C();//向上转型 ab.print();
}
}执行结果：
**********
4.任何时候，如果要执行类中的static方法的时候，都可以在没有对象的情况下直接调用，对于抽象类也一样。但是修饰为abstract的抽象方法，不能修饰为static，没有意义；
5.有时候由于抽象类中只需要一个特定的系统子类操作，所以可以忽略掉外部子类。这样的设计在系统类库中会比较常见，目的是对用户隐藏不需要知道的子类。
范例如下：
package com.wz.abstractdemo;abstract class A{//定义一个抽象类public abstract void print();private static class B extends A{//内部抽象类子类public void print(){//覆写抽象类的方法System.out.println("Hello World !");
}
}//这个方法不受实例化对象的控制public static A getInstance(){return new B();
}
}public class TestDemo {public static void main(String[] args) {//此时取得抽象类对象的时候完全不需要知道B类这个子类的存在A a = A.getInstance();
a.print();
}
}运行结果：
Hello World !
抽象类的应用——模板设计模式
例如，现在有三类事物：
（1）机器人：充电，工作；
（2）人：吃饭，工作，睡觉；
（3）猪：进食，睡觉。
现要求实现一个程序，可以实现三种不同事物的行为。
先定义一个抽象行为类：
package com.wz.abstractdemo;public abstract class Action{public static final int EAT = 1 ;public static final int SLEEP = 3 ;public static final int WORK = 5 ;public abstract void eat();public abstract void sleep();public abstract void work();public void commond(int flags){ switch(flags){case EAT:this.eat();break;case SLEEP:this.sleep();break;case WORK:this.work();break;case EAT + SLEEP:this.eat();this.sleep();break;case SLEEP + WORK:this.sleep();this.work();break;default:break;
}
}
}定义一个机器人的类：
package com.wz.abstractdemo;public class Robot extends Action{
@Overridepublic void eat() {
System.out.println("机器人充电");
}
@Overridepublic void sleep() {
}
@Overridepublic void work() {
System.out.println("机器人工作");
}
}定义一个人的类：
package com.wz.abstractdemo;public class Human extends Action{
@Overridepublic void eat() {
System.out.println("人吃饭");
}
@Overridepublic void sleep() {
System.out.println("人睡觉");
}
@Overridepublic void work() {
System.out.println("人工作");
}
}定义一个猪的类：
package com.wz.abstractdemo;public class Pig extends Action{
@Overridepublic void eat() {
System.out.println("猪进食");
}
@Overridepublic void sleep() {
System.out.println("猪睡觉");
}
@Overridepublic void work() {
}
}测试主类：
package com.wz.abstractdemo;public class AbstractDemo {public static void main(String[] args) {
fun(new Robot());
fun(new Human());
fun(new Pig());
}public static void fun(Action act){
act.commond(Action.EAT);
act.commond(Action.SLEEP);
act.commond(Action.WORK);
}
}运行结果：
机器人充电 机器人工作 人吃饭 人睡觉 人工作 猪进食 猪睡觉
Si toutes les sous-classes veulent terminer l'opération normalement, elles doivent remplacer selon la méthode spécifiée. À ce stade, la fonction de la classe abstraite est la fonction d'un modèle de définition de classe.
--------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -----------------------------------------------
Une interface est une "classe" plus abstraite qu'une classe abstraite. J'ai mis "classe" entre guillemets ici parce que je ne trouve pas de meilleur mot pour l'exprimer, mais nous devons être clairs sur le fait que l'interface elle-même n'est pas une classe, ce qui ressort du fait que nous ne pouvons pas instancier une interface. Par exemple, new Runnable(); est définitivement faux, nous ne pouvons que new sa classe d'implémentation.
L'interface est utilisée pour établir un protocole entre les classes. Elle fournit uniquement un formulaire sans implémentation spécifique. Dans le même temps, la classe d'implémentation qui implémente l'interface doit implémenter toutes les méthodes de l'interface. En utilisant le mot clé Implements, cela indique que la classe suit une interface spécifique ou un groupe d'interfaces spécifiques, et elle indique également que « l'interface est ». juste son apparence, mais il faut maintenant expliquer comment cela fonctionne”.
L'interface est une extension de la classe abstraite. Afin de garantir la sécurité des données, Java ne peut pas avoir d'héritage multiple, c'est-à-dire que l'héritage ne peut avoir qu'une seule classe parent, mais l'interface l'est. différentes, et une classe peut être implémentée en même temps. Plusieurs interfaces, qu'il existe ou non une relation entre ces interfaces, donc les interfaces compensent le défaut selon lequel les classes abstraites ne peuvent pas avoir plusieurs héritages, mais il est recommandé d'utiliser l'héritage et interfaces ensemble, car cela peut non seulement garantir la sécurité des données, mais également réaliser un héritage multiple.
Vous devez faire attention aux problèmes suivants lors de l'utilisation de l'interface :
1. Tous les droits d'accès aux méthodes d'une interface sont automatiquement déclarés comme public. Pour être précis, il ne peut être que public. Bien sûr, vous pouvez le déclarer explicitement comme protégé ou privé, mais la compilation provoquera des erreurs !
2. Vous pouvez définir des "variables membres" dans l'interface, ou des constantes immuables, car les "variables membres" dans l'interface deviendront automatiquement publiques statiques finales. Il est accessible directement via le nom de la classe : ImplementClass.name.
3. Il n'y a aucune méthode implémentée dans l'interface.
4. Une classe non abstraite qui implémente une interface doit implémenter toutes les méthodes de l'interface. Les classes abstraites n'ont pas besoin d'être implémentées.
5. Vous ne pouvez pas utiliser l'opérateur new pour instancier une interface, mais vous pouvez déclarer une variable d'interface, qui doit faire référence à un objet d'une classe qui implémente l'interface. Vous pouvez utiliser instanceof pour vérifier si un objet implémente une interface spécifique. Par exemple : if (instance d'un objet de Comparable) {}.
6. Lors de l'implémentation de plusieurs interfaces, veillez à éviter la duplication des noms de méthodes.
Dans le langage Java, la classe abstraite et l'interface sont prises en charge Deux mécanismes pour la définition de classe abstraite. C’est précisément grâce à l’existence de ces deux mécanismes que Java bénéficie de puissantes capacités orientées objet. Il existe de grandes similitudes entre la classe abstraite et l'interface en termes de prise en charge de la définition de classe abstraite, et elles peuvent même être remplacées les unes par les autres. Par conséquent, de nombreux développeurs semblent être plus décontractés quant au choix de la classe abstraite et de l'interface lors de la définition des classes abstraites. En fait, il existe encore une grande différence entre les deux. Leur choix reflète même la compréhension de la nature du domaine problématique et la question de savoir si la compréhension de l'intention de conception est correcte et raisonnable.
| Cours abstrait | Interface |
Instanciation | Je ne peux pas | Je ne peux pas |
Classe | Une relation d'héritage, une classe ne peut utiliser la relation d'héritage qu'une seule fois . L'héritage multiple peut être obtenu en héritant de plusieurs interfaces | Une classe peut implémenter plusieurs interfaces |
Les membres des données | peuvent avoir leur propre | Statique ne peut pas être modifié, c'est-à-dire qu'il doit être statique final. Généralement, il n'est pas défini ici 🎜> Peut être une méthode privée et non abstraite, les méthodes abstraites doivent être implémentées |
Ne peut pas être privé, la valeur par défaut est publique, type abstrait | Variables | peut être privé et la valeur par défaut est de type convivial, sa valeur peut être redéfinie dans une sous-classe ou réaffectée |
ne peut pas être privé, la valeur par défaut est le type final statique public et doit lui être donnée. La valeur initiale ne peut pas être redéfinie dans la classe d'implémentation et sa valeur ne peut pas être modifiée. | Concept de conception | signifie "est-un" la relation |
représente la relation "comme-un" | Pour implémenter | nécessite un héritage, vous devez utiliser extends |
vous devez utiliser des outils | La classe abstraite et l'interface sont toutes deux utilisées pour créer des classes abstraites dans le langage Java (la classe abstraite dans cet article n'est pas traduite de la classe abstraite, elle représente un corps abstrait et la classe abstraite est une méthode utilisé pour définir des classes abstraites dans le langage Java), alors qu'est-ce qu'une classe abstraite et quels avantages l'utilisation de classes abstraites peut-elle nous apporter ? Une classe qui déclare l'existence d'une méthode sans l'implémenter est appelée une classe abstraite, qui est utilisée pour créer une classe qui incarne certains comportements de base, et déclarer une méthode pour la classe, mais elle ne peut pas être implémentée dans la classe. Les instances de classes abstraites ne peuvent pas être créées. Cependant, vous pouvez créer une variable dont le type est une classe abstraite et la faire pointer vers une instance d'une sous-classe concrète. Il ne peut pas y avoir de constructeurs abstraits ou de méthodes statiques abstraites. Les sous-classes de la classe Abstract fournissent des implémentations pour toutes les méthodes abstraites de leur classe parent, sinon ce sont également des classes abstraites. Au lieu de cela, implémentez la méthode dans une sous-classe. D'autres classes conscientes de son comportement peuvent implémenter ces méthodes dans leur classe. Une interface est une variante d'une classe abstraite. Dans une interface, toutes les méthodes sont abstraites. L'héritage multiple peut être obtenu en implémentant une telle interface. Toutes les méthodes de l'interface sont abstraites et aucune d'entre elles n'a de corps de programme. Les interfaces ne peuvent définir que des variables de membre final statiques. L'implémentation d'une interface est similaire au sous-classement, sauf que la classe d'implémentation ne peut pas hériter du comportement de la définition de l'interface. Lorsqu'une classe implémente une interface particulière, elle définit (c'est-à-dire donne le corps du programme) toutes les méthodes de cette interface. Il peut alors appeler les méthodes de l'interface sur n'importe quel objet de la classe qui implémente l'interface. Puisqu'il existe des classes abstraites, cela permet d'utiliser le nom de l'interface comme type de variable de référence. La liaison dynamique normale prendra effet. Les références peuvent être converties vers et depuis des types d'interface, et l'opérateur instanceof peut être utilisé pour déterminer si la classe d'un objet implémente l'interface. Les interfaces peuvent hériter des interfaces. Les classes abstraites peuvent implémenter des interfaces et les classes abstraites peuvent hériter des classes d'entités, mais le principe est que la classe d'entité doit avoir un constructeur clair. Les interfaces se concentrent davantage sur « quelles fonctions peuvent être réalisées », quelle que soit « la manière dont elles sont mises en œuvre » . 1. Similitudes 2. Différences Occasions d'application de l'interface Occasions d'application de la classe abstraite Avantages des interfaces et des classes abstraites : 好像定义接口是提前做了个多余的工作。下面我给大家总结了4点关于JAVA中接口存在的意义： 1、重要性：在Java语言中， abstract class 和interface 是支持抽象类定义的两种机制。正是由于这两种机制的存在，才赋予了Java强大的 面向对象能力。 2、简单、规范性：如果一个项目比较庞大，那么就需要一个能理清所有业务的架构师来定义一些主要的接口，这些接口不仅告诉开发人员你需要实现那些业务，而且也将命名规范限制住了（防止一些开发人员随便命名导致别的程序员无法看明白）。 3、维护、拓展性：比如你要做一个画板程序，其中里面有一个面板类，主要负责绘画功能，然后你就这样定义了这个类。 可是在不久将来，你突然发现这个类满足不了你了，然后你又要重新设计这个类，更糟糕是你可能要放弃这个类，那么其他地方可能有引用他，这样修改起来很麻烦。 如果你一开始定义一个接口，把绘制功能放在接口里，然后定义类时实现这个接口，然后你只要用这个接口去引用实现它的类就行了，以后要换的话只不过是引用另一个类而已，这样就达到维护、拓展的方便性。 4、安全、严密性：接口是实现软件松耦合的重要手段，它描叙了系统对外的所有服务，而不涉及任何具体的实现细节。这样就比较安全、严密一些（一般软件服务商考虑的比较多）。 尽管抽象类和接口之间存在较大的相同点，甚至有时候还可以互换，但这样并不能弥补他们之间的差异之处。下面将从语法层次和设计层次两个方面对抽象类和接口进行阐述。 语法层次在语法层次，java语言对于抽象类和接口分别给出了不同的定义。下面已Demo类来说明他们之间的不同之处。 使用抽象类来实现: public abstract class Demo { abstract void method1();
void method2(){ //实现 }
}Copier après la connexion
使用接口来实现 interface Demo { void method1(); void method2();
}Copier après la connexion
抽象类方式中，抽象类可以拥有任意范围的成员数据，同时也可以拥有自己的非抽象方法，但是接口方式中，它仅能够有静态、不能修改的成员数据（但是我们一般是不会在接口中使用成员数据），同时它所有的方法都必须是抽象的。在某种程度上来说，接口是抽象类的特殊化。 对子类而言，它只能继承一个抽象类（这是java为了数据安全而考虑的），但是却可以实现多个接口。 设计层次上面只是从语法层次和编程角度来区分它们之间的关系，这些都是低层次的，要真正使用好抽象类和接口，我们就必须要从较高层次来区分了。只有从设计理念的角度才能看出它们的本质所在。一般来说他们存在如下三个不同点： 1、 抽象层次不同。抽象类是对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。 2、 跨域不同。抽象类所跨域的是具有相似特点的类，而接口却可以跨域不同的类。我们知道抽象类是从子类中发现公共部分，然后泛化成抽象类，子类继承该父类即可，但是接口不同。实现它的子类可以不存在任何关系，共同之处。例如猫、狗可以抽象成一个动物类抽象类，具备叫的方法。鸟、飞机可以实现飞Fly接口，具备飞的行为，这里我们总不能将鸟、飞机共用一个父类吧！所以说抽象类所体现的是一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is-a" 关系，即父类和派生类在概念本质上应该是相同的。对于接口则不然，并不要求接口的实现者和接口定义在概念本质上是一致的， 仅仅是实现了接口定义的契约而已。 3、 设计层次不同。对于抽象类而言，它是自下而上来设计的，我们要先知道子类才能抽象出父类，而接口则不同，它根本就不需要知道子类的存在，只需要定义一个规则即可，至于什么子类、什么时候怎么实现它一概不知。比如我们只有一个猫类在这里，如果你这是就抽象成一个动物类，是不是设计有点儿过度？我们起码要有两个动物类，猫、狗在这里，我们在抽象他们的共同点形成动物抽象类吧！所以说抽象类往往都是通过重构而来的！但是接口就不同，比如说飞，我们根本就不知道会有什么东西来实现这个飞接口，怎么实现也不得而知，我们要做的就是事前定义好飞的行为接口。所以说抽象类是自底向上抽象而来的，接口是自顶向下设计出来的。 我们有一个Door的抽象概念，它具备两个行为open()和close()，此时我们可以定义通过抽象类和接口来定义这个抽象概念： 抽象类： abstract class Door{ abstract void open(); abstract void close()；
}Copier après la connexion
接口 interface Door{ void open(); void close();
}Copier après la connexion
至于其他的具体类可以通过使用extends使用抽象类方式定义Door或者Implements使用接口方式定义Door，这里发现两者并没有什么很大的差异。 但是现在如果我们需要门具有报警的功能，那么该如何实现呢？ 解决方案一：给Door增加一个报警方法:clarm(); abstract class Door{ abstract void open(); abstract void close(); abstract void alarm();
}Copier après la connexion
或者 interface Door{ void open(); void close(); void alarm();
}Copier après la connexion
这种方法违反了面向对象设计中的一个核心原则 ISP (Interface Segregation Principle)(参见:)，在Door的定义中把Door概念本身固有的行为方法和另外一个概念"报警器"的行为方 法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为"报警器"这个概念的改变而改变，反之依然。 解决方案二 既然open()、close()和alarm()属于两个不同的概念，那么我们依据ISP原则将它们分开定义在两个代表两个不同概念的抽象类里面，定义的方式有三种： 1、两个都使用抽象类来定义。 2、两个都使用接口来定义。 3、一个使用抽象类定义，一个是用接口定义。 由于java不支持多继承所以第一种是不可行的。后面两种都是可行的，但是选择何种就反映了你对问题域本质的理解。 如果选择第二种都是接口来定义，那么就反映了两个问题：1、我们可能没有理解清楚问题域，AlarmDoor在概念本质上到底是门还报警器。2、如果我们对问题域的理解没有问题，比如我们在分析时确定了AlarmDoor在本质上概念是一致的，那么我们在设计时就没有正确的反映出我们的设计意图。因为你使用了两个接口来进行定义，他们概念的定义并不能够反映上述含义。 第三种，如果我们对问题域的理解是这样的：AlarmDoor本质上Door，但同时它也拥有报警的行为功能，这个时候我们使用第三种方案恰好可以阐述我们的设计意图。AlarmDoor本质是们，所以对于这个概念我们使用抽象类来定义，同时AlarmDoor具备报警功能，说明它能够完成报警概念中定义的行为功能，所以alarm可以使用接口来进行定义。如下： abstract class Door{ abstract void open(); abstract void close();
}
interface Alarm{ void alarm();
}
class AlarmDoor extends Door implements Alarm{ void open(){} void close(){} void alarm(){}
}Copier après la connexion
这种实现方式基本上能够明确的反映出我们对于问题领域的理解，正确的揭示我们的设计意图。其实抽象类表示的是"is-a"关系，接口表示的是"like-a"关系，大家在选择时可以作为一个依据，当然这是建立在对问题领域的理解上的，比如：如果我们认为AlarmDoor在概念本质上是报警器，同时又具有Door的功能，那么上述的定义方式就要反过来了。
Résumé1. Les classes abstraites représentent une relation d'héritage dans le langage Java. Une sous-classe ne peut avoir qu'une seule classe parent, mais plusieurs interfaces peuvent exister. 2. Les classes abstraites peuvent avoir leurs propres variables membres et méthodes de classe non abstraites, mais seules les données membres statiques et immuables peuvent exister dans les interfaces (mais généralement pas dans les interfaces) définit les données membres ), et toutes ses méthodes sont abstraites. 3. Les concepts de conception reflétés par les classes abstraites et les interfaces sont différents. Les classes abstraites représentent la relation « est-un », tandis que les interfaces représentent la relation « comme-un ». Les classes abstraites et les interfaces sont deux concepts abstraits différents dans le langage Java. Leur existence offre un très bon support pour le polymorphisme, bien qu'il existe de grandes similitudes entre elles. Mais leur choix reflète souvent votre compréhension du domaine problématique. Ce n’est qu’avec une bonne compréhension de la nature du domaine problématique que nous pouvons élaborer des conceptions correctes et raisonnables. 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!
Article précédent：Introduction détaillée au webpack en Java
Article suivant：Introduction détaillée à la fonction d'annotation en Java
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Derniers articles par auteur
Derniers numéros
Pousser des objets vers un tableau, API composable
Il y a un projet. Il existe deux options de sélection « taille » (grande, petite) et quant...
Depuis 2024-04-05 14:41:47
0
1
1526
Rubriques connexes
Plus>
|
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
