java - introduction détaillée à l'orientation objet (3)

Cet article fait suite à ce qui précède : Java - Introduction détaillée à l'orientation objet (2)

Interface (interface)

Introduction : Une classe abstraite est un modèle abstrait de plusieurs classes. Si vous souhaitez rendre cette abstraction plus approfondie, vous devez utiliser une "classe abstraite" → interface spéciale ;

Exemple :

Les interfaces USB que nous entendons dans la vie ne sont pas réellement les emplacements que nous voyons, mais une spécification que ces emplacements suivent. Les emplacements que nous voyons ne sont que des exemples conçus selon ; la spécification USB, ce qui signifie que les emplacements sont des exemples d'USB

Correspondant à différents modèles de périphériques USB, leurs emplacements USB respectifs sont Il existe une spécification qui doit être respectée. Le respect de cette spécification peut garantir que. le périphérique inséré dans l'emplacement peut communiquer normalement avec la carte mère ;

Pour plusieurs emplacements USB sur la carte mère du même modèle, ils ont la même méthode d'échange de données avec les mêmes détails d'implémentation, ils peuvent être considérés comme tels. être différentes instances de la même classe

Mon résumé :

Les interfaces définissent uniquement les spécifications que les classes doivent suivre, mais ne se soucient pas des données internes de ces classes et des détails d'implémentation dans ses méthodes. .

L'interface stipule uniquement les méthodes qui doivent être fournies dans ces classes ; séparant ainsi les spécifications et la mise en œuvre. Elle améliore l'évolutivité et la maintenabilité du système

Les avantages de l'utilisation des interfaces sont meilleurs ; évolutivité et maintenabilité, nous utilisons donc souvent des interfaces en développement. (Cela équivaut à définir une norme)

définition de l'interface

L'interface définit une spécification qui stipule ce qu'est une interface. la classe doit le faire, mais peu importe comment cela est fait ;

Le nom de l'interface de l'interface [Modificateur] étend l'interface parent 1, l'interface parent 2....

Il n'y a pas de constructeur et ne peut pas être instancié ;

Les interfaces ne peuvent hériter que des interfaces, pas des classes

Il n'y a pas de méthodes ordinaires dans les interfaces, et les méthodes sont toutes abstraites ;

Le modificateur par défaut des méthodes dans l'interface est public abstract ;

Les champs de l'interface sont tous des constantes globales et le modificateur par défaut est public static final ;

Les membres de l'interface incluent (principalement les deux premiers) :

Constantes globales

Méthodes abstraites publiques

Classes internes (y compris les classes internes, les interfaces internes, les classes d'énumération internes

Mon ​​résumé :

L'interface n'a pas de constructeur et ne peut pas être instanciée !

Toutes les méthodes de l'interface sont abstraites. Il n'y a pas de méthodes ordinaires. Elles ont le modificateur par défaut public abstract et doivent être remplacées !

12. Utilisation des interfaces

Format :

public class SubImpl  extends Super  implements IA,IBLes interfaces peuvent être héritées de plusieurs sources, mais seules les interfaces peuvent être héritées, non cours.

Interface d'implémentation (prend en charge plusieurs implémentations)

[Modificateur] classe nom de classe implémente l'interface 1, l'interface 2...

L'implémentation de l'interface doit être après l'extension ;

La méthode pour implémenter l'interface doit être de type public

La relation entre l'interface et la classe :

Relation d'implémentation ou relation d'héritage.

Peut être considéré comme une classe Après avoir implémenté les méthodes de l'interface, on peut aussi dire que la classe hérite des méthodes de l'interface, avec des compréhensions différentes selon les situations !

13. Établir des normes et un modèle d'usine simple pour la programmation orientée interface

Établissez une norme et laissez les autres la mettre en œuvre ou la satisfaire !

Eg：
interface USB{//定义USB标准
    void useUSB();//USB有使用USB的行为
}

Mode usine simple

Construisez une usine, produisez-y et utilisez-la directement

Mon résumé :

Avantages : Blindage Les différences dans le la mise en œuvre de différentes sous-classes améliore l'évolutivité et la maintenabilité du code ;

package reviewDemo;
 
//简单工厂模式
 
 
 
interface Phone{//制定标准，都要实现send()方法
 
   public void send();
 
}
 
 
 
class Iphone implements Phone{
 
   @Override
 
   public void send() {
 
      System.out.println("Iphone手机在发短信");
 
   }
 
}
 
 
 
class AndroidPhone implements Phone{
 
   @Override
 
   public void send() {
 
      System.out.println("AndroidPhone手机在发短信");
 
   }
 
}
 
 
 
class MyPhone implements Phone{
 
   @Override
 
   public void send() {
 
      System.out.println("MyPhone手机在发短信");
 
   }
 
}
 
 
 
class Factory{
 
   public static void show(String type){//传入参数，根据不同的类型个性化定制
 
      if(type.equals("")){//为空的情况，不用往下执行
 
         System.out.println("对不起，类型为空！,请重新输入！");
 
         return;
 
      }
 
      Phone p = null;
 
      if("Iphone".equals(type)){//判断类型
 
         p = new Iphone();
 
      }else if("AndroidPhone".equals(type)){
 
         p = new AndroidPhone();
 
      }else{
 
         p = new MyPhone();
 
      }
 
      p.send();
 
   }
 
}
 
 
 
public class FactoryDemo17 {
 
   public static void main(String[] args) {
 
     
 
      new Factory().show("Iphone");//调用方法
 
      new Factory().show("AndroidPhone");
 
      new Factory().show("MyPhone");
 
      new Factory().show("YourPhone");
 
      new Factory().show("");
 
   }
 
}

Sortie :

L'iPhone envoie des messages texte

AndroidPhone envoie des messages texte

MyPhone envoie des SMS

MyPhone envoie des SMS

Désolé, le type est vide !

14、面向接口编程之适配器模式

使用一个现成的类，但是它的接口不完全符合你的需求,我只想要它其中的一个方法，不想覆写其他的方法。

比如,窗体有变大,变小,关闭的行为,但是我现在只需要关闭行为;

package reviewDemo;
 
//适配器模式：只想用其中的某一个方法，用适配器作为中间的过渡
 
 
 
interface Windows{
 
   void max();
 
   void min();
 
   void close();
 
}
 
 
 
//适配器模式，实现接口所有的方法，但是不写方法体！
 
class AdapterWindows implements Windows{
 
 
 
   @Override
 
   public void max() {
 
   }
 
 
 
   @Override
 
   public void min() {
 
   }
 
 
 
   @Override
 
   public void close() {
 
   }
 
  
 
}
 
 
 
class MyWindows extends AdapterWindows{
 
   //覆写父类的方法
 
   public void close(){
 
      System.out.println("这个实现的是关闭功能！");
 
   }
 
}
 
 
 
public class Demo17 {
 
   public static void main(String[] args) {
 
      new MyWindows().close();
 
   }
 
}

接口和抽象类的比较

相同点:

都位于继承的顶端,用于被其他实现或继承;

都不能实例化;

都包含抽象方法,其子类都必须覆写这些抽象方法;

区别:

抽象类为部分方法提供实现,避免子类重复实现这些方法,提供代码重用性;接口只能包含抽象方法;

一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)

二者的选用:

优先选用接口,尽量少用抽象类;

需要定义子类的行为,又要为子类提供共性功能时才选用抽象类;

总结：接口不能有构造函数，抽象类是可以有构造函数的，

abstract可以定义构造函数（包括带函数的构造函数），因为要保证其子类在创建的时候能够进行正确的初始化，但是Abstract类不能被实例化。

知识点：如果不可以或者没有创建对象，那么我们必须加上static修饰，不能用对象调用，就只好用类去调用。

16、匿名内部类

适合只使用一次的类

不能是抽象类，因为系统在创建匿名内部类的时候，会立即创建匿名内部类的对象。

匿名内部类不能定义构造器，因为匿名内部类没有类名。

格式：
new 父类构造器([实参列表]) 或 接口()
{
//匿名内部类的类体部分
}

17、枚举类

使用enum声明,默认直接继承了java.lang.Enum类，而不是Object类；

枚举类的对象是固定的,实例个数有限,不可以再new( ),枚举对象后可以跟()。

枚举元素必须位于枚举类体中的最开始部分,枚举元素后要有分号与其他成员分隔。

枚举类的构造方法的权限修饰符默认是private；

一旦枚举对象后面加上{},那么该对象实际是枚举匿名内部类对象;

所有枚举类都提供一个静态的values()方法(返回该枚举类所有对象组成的数组),便于遍历所有枚举对象；

所有枚举类都提供一个静态的valueOf(String name)方法, 返回枚举类中对象名等于 name的对象。

Eg：public enum Color{
 
        RED(), GREEN(){}, BLUE{};
 
}
 
 
 
 
 
package reviewDemo;
 
//枚举
 
 
 
enum Color{
 
   Green,Blue,Yellow;
 
  
 
   @Override
 
   public String toString() {
 
      String ret = super.toString();
 
      switch (this) {
 
      case Green:
 
         ret = "绿色";
 
         break;
 
        
 
      case Blue:
 
         ret = "蓝色";
 
         break;
 
        
 
      case Yellow:
 
         ret = "黄色";
 
         break;
 
 
 
      default:
 
         break;
 
      }
 
     
 
      return ret;
 
   }
 
  
 
}
 
 
 
class Personp{
 
   Color c = Color.Blue;
 
   void show(){
 
      System.out.println(c);
 
   }
 
}
 
 
 
public class Demo18 {
 
   public static void main(String[] args) {
 
      Color []color = Color.values();
 
      for (Color c : color) {
 
         System.out.println(c);
 
      }
 
      new Personp().show();
 
   }
 
}

输出：

绿色

蓝色

黄色

蓝色

枚举类覆写接口抽象方法的两种方式：

在枚举类中实现接口的抽象方法；

在枚举匿名内部类中实现接口的抽象方法；

interface I{
 
    void show();
 
}
 
 
 
enum Color implements I{
 
    RED(){
 
   public void show(){
 
        }
 
    }, GREEN{
 
   public void show(){
 
        }
 
    }, BLUE{
 
   public void show(){
 
        }
 
    };
 
}
 
 
 
enum Color implements I{
 
    RED(), GREEN, BLUE;
 
    public void show() {
 
    }
 
}

总结：枚举不可以new();即便是反射也不可以！

备注：一个类如果没有构造方法，那么一定有相对应的某个方法可以获取对象！

Ce qui précède est tout ce que je veux écrire sur l'orientation objet. S'il y a quelque chose qui ne va pas, veuillez nous contacter pour correction. Merci!

Pour plus de contenu connexe, veuillez visiter le site Web PHP chinois : Tutoriel vidéo 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!