Explication détaillée du principe ouvert et fermé en Java

Définition : Les entités logicielles (classes, modules, fonctions, etc.) doivent être extensibles mais non modifiables. Ouvert pour expansion, fermé pour changement. La clé est l’abstraction, séparant clairement les parties générales d’une fonctionnalité des détails de mise en œuvre.

Ici, nous devons avoir des concepts abstraits lors de l'écriture du code. Qu’est-ce que l’abstraction ? Fait référence au processus de réflexion consistant à faire abstraction des concepts des entités. Il s’agit d’extraire des caractéristiques essentielles communes à de nombreux objets. Dans le processus d'écriture de code, où une classe abstraite est nécessaire, il suffit de saisir la fonction essentielle de cette classe, et de ne pas toujours penser à sa fonction spécifique dans ce projet.

Continuons à regarder le principe ouvert et fermé. Ce principe nécessite que la partie partagée et la partie implémentation d'une fonction soient clairement séparées. Parce que vous ne pouvez pas prédire tous les changements qui se produiront lors de la première construction de l'architecture, cette classe ne restera pas inchangée. Au fur et à mesure que vous l'implémenterez dans chaque module, vous constaterez que la classe abstraite est adaptée à cette fonction, mais ce n'est pas le cas. adapté à une autre fonction. Alors, voulez-vous revenir en arrière et modifier la classe abstraite ? Ce coût est très élevé et nécessite de repenser et d’ajuster des détails spécifiques. Il est préférable que le programme n'ait pas encore été publié, revenir en arrière pour modifier la classe abstraite aura un plus grand impact. Par conséquent, lorsque nous commençons à faire abstraction, nous devons empêcher ce phénomène de se produire et suivre le principe ouvert et fermé. Les classes abstraites et les interfaces sont des standards. Une fois définies dans un programme, elles ne peuvent pas être facilement modifiées. Que dois-je faire si les exigences changent ? Vous pouvez étendre cette interface, réécrire des méthodes ou ajouter de nouvelles méthodes après l'héritage, mais veillez à ne pas la modifier.

Deux exemples sont utilisés ci-dessous pour illustrer le principe ouvert-fermé.

1. Connectez-vous à la base de données à titre d'exemple.

Par exemple, les différents types de connexions aux bases de données utilisées dans le programme, Access et Oracle. La connexion directe est la suivante :

class ConnectAccess 
{ 
  public string ConnectString() 
  { 
    string dataPath = "数据库路径"; 
    return string.Format("Provider=Microsoft.Jet.OLEDB.4.0;Data Source={0};Persist Security Info=True;Jet OLEDB:Database Password={1}", dataPath, "密码"); 
  } 
} 
class ConnectOracle 
{ 
  public string ConnectString() 
  { 
    return @"server=localhost;database=命名空间;uid=用户名;pwd=密码"; 
  } 
}

Appeler

static void Main(string[] args) 
 { 
   //连接Access 
  ConnectAccess connAccess = new ConnectAccess(); 
 
  OleDbConnection accessConnection = new OleDbConnection(connAccessConnectString()); 
 
   //连接Oracle 
  ConnectOracle connOracle = new ConnectOracle(); 
 
  OracleConnection oracleConnection = new OracleConnection(connOracleConnectString()); 
 }

comme ça à chaque fois. Vous devez réfléchir aux paramètres d'OleDbConnection à utiliser. Modifiez-le ci-dessous. Résumé d'une interface.

interface ConnectDataBase 
{ 
  string ConnectString(); 
} 
 
class ConnectAccess : ConnectDataBase 
{ 
  #region ConnectDataBase 成员 
 
  public string ConnectString() 
  { 
    string dataPath = "数据库路径"; 
 
    return stringFormat("Provider=MicrosoftJetOLEDB0;Data Source={0};Persist Security Info=True;Jet OLEDB:Database Password={1}", dataPath, "密码"); 
  } 
 
  #endregion 
} 
 
class ConnectOracle : ConnectDataBase 
{ 
  #region ConnectDataBase 成员 
 
  public string ConnectString() 
  { 
    return @"server=localhost;database=命名空间;uid=用户名;pwd=密码"; 
  } 
 
  #endregion 
}

Appeler

static void Main(string[] args) 
{ 
  ConnectDataBase conn = null; 
 
  //连接Access 
  conn = new ConnectAccess(); 
 
  OleDbConnection accessConnection = new OleDbConnection(connConnectString()); 
 
  //连接Oracle 
  conn = new ConnectOracle(); 
 
  OracleConnection oracleConnection = new OracleConnection(connConnectString()); 
}

Après le changement, il vous suffit se soucier de conn Quelle que soit la classe que vous utilisez pour instancier, c'est très bien. Cependant, vous constaterez peut-être que, puisque la connexion Oracle nécessite OracleConnection, les avantages peuvent ne pas être faciles à voir.

2. Prenez le type de base comme paramètre de méthode à titre d'exemple.

C'est la raison pour laquelle les principes généraux de conception soulignent que les paramètres de méthode doivent éviter autant que possible les types de base. Comparez les deux définitions de méthodes suivantes :

//定义1  
bool Connect(string userName, string password, string wifiAddress, int port) 
{ 
  return false; 
}

//定义2  
bool Connect(Account account) 
{ 
  return false; 
}

public class Account 
{ 
  public string UserName 
  { 
    get; 
    set; 
  } 
  public string Password 
  { 
    get; 
    set; 
  } 
  public string WifiAddress 
  { 
    get; 
    set; 
  } 
  public int Port 
  { 
    get; 
    set; 
  } 
}

En comparaison, la définition 2 a une définition de classe Account supplémentaire, et la méthode Connect() est évidemment plus stable. Si la méthode Connect() wifiAddress change, la définition 1 doit modifier l'interface de la méthode, et par conséquent, tous les objets qui appellent la méthode Connect() seront affectés tandis que la définition 2 n'a besoin que de modifier la classe Account, car l'interface de la méthode Connect() reste inchangée et l'appelant de la méthode Connect() n'a pas besoin de wifiAddress. Une telle modification n'affectera pas du tout l'appelant, réduisant ainsi l'impact des changements de demande.

En bref, la clé du principe ouvert et fermé est l'abstraction, mais cela ne signifie pas qu'une fois l'interface et la classe abstraites déterminées, elles ne doivent pas être modifiées. Cependant, lorsque nous faisons de l'abstraction, nous devons réfléchir de manière globale et nous efforcer d'éviter les modifications. Une fois les exigences modifiées, il suffit d'apporter des modifications pendant la mise en œuvre. Bien entendu, les besoins évoluent constamment. Une fois que la partie abstraite doit être modifiée, tant que le principe est strictement suivi, l'impact sera beaucoup plus faible. Bien entendu, s’il est modifié, des tests unitaires doivent être effectués et tout ce qui est utilisé doit être testé correctement.

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!