Detaillierte Erläuterung des offenen und geschlossenen Prinzips in Java

Definition: Software-Entitäten (Klassen, Module, Funktionen usw.) sollten erweiterbar, aber nicht veränderbar sein. Offen für Erweiterung, geschlossen für Veränderung. Der Schlüssel liegt in der Abstraktion, die die allgemeinen Teile einer Funktion klar von den Implementierungsdetails trennt.

Hier müssen wir beim Schreiben von Code über abstrakte Konzepte verfügen. Was ist Abstraktion? Bezieht sich auf den Denkprozess der Abstraktion von Konzepten von Entitäten. Es geht darum, aus zahlreichen Objekten gemeinsame wesentliche Merkmale zu extrahieren. Wenn Sie beim Schreiben von Code eine abstrakte Klasse benötigen, müssen Sie nur die wesentliche Funktion dieser Klasse verstehen und müssen nicht immer über ihre spezifische Funktion in diesem Projekt nachdenken.

Schauen wir uns weiterhin das offene und geschlossene Prinzip an. Dieses Prinzip erfordert, dass der gemeinsame Teil und der Implementierungsteil einer Funktion klar getrennt werden sollten. Da Sie beim ersten Erstellen der Architektur nicht alle Änderungen vorhersagen können, bleibt diese Klasse nicht unverändert. Wenn Sie sie in jedem Modul implementieren, werden Sie feststellen, dass die abstrakte Klasse für diese Funktion geeignet ist für eine andere Funktion geeignet. Möchten Sie also zurückgehen und die abstrakte Klasse ändern? Dieser Aufwand ist sehr hoch und erfordert ein Überdenken und Anpassen spezifischer Details. Es ist besser, wenn das Programm noch nicht veröffentlicht wurde. Sobald das Programm veröffentlicht wurde, hat eine erneute Änderung der abstrakten Klasse eine größere Wirkung. Wenn wir mit der Abstraktion beginnen, müssen wir daher verhindern, dass dieses Phänomen auftritt, und dem Prinzip der Offenheit und Geschlossenheit folgen. Abstrakte Klassen und Schnittstellen sind Standards, die nicht einfach geändert werden können. Sie können diese Schnittstelle erweitern, Methoden neu schreiben oder nach der Vererbung neue Methoden hinzufügen, aber achten Sie darauf, sie nicht zu ändern.

Zwei Beispiele sollen im Folgenden das Offen-Geschlossen-Prinzip verdeutlichen.

1. Stellen Sie eine Verbindung zur Datenbank her.

Zum Beispiel die verschiedenen Arten von Datenbankverbindungen, die im Programm Access und Oracle verwendet werden. Die direkte Verbindung ist wie folgt:

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=密码"; 
  } 
}

Anruf

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()); 
 }

jedes Mal so. Sie müssen überlegen, welche Parameter von OleDbConnection verwendet werden sollen. Ändern Sie es unten. Eine Schnittstelle abstrahieren.

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 
}

Anruf

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()); 
}

Nach der Änderung brauchen Sie nur noch sich um conn kümmern Welche Klasse Sie auch verwenden, um es zu instanziieren, ist in Ordnung. Möglicherweise stellen Sie jedoch fest, dass die Vorteile möglicherweise nicht leicht zu erkennen sind, da für die Oracle-Verbindung OracleConnection erforderlich ist.

2. Nehmen Sie als Beispiel den Basistyp als Methodenparameter.

Aus diesem Grund betonen allgemeine Designprinzipien, dass Methodenparameter so weit wie möglich Basistypen vermeiden sollten. Vergleichen Sie die folgenden beiden Methodendefinitionen:

//定义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; 
  } 
}

Im Vergleich dazu verfügt Definition 2 über eine weitere Account-Klassendefinition und die Connect()-Methode ist offensichtlich stabiler. Wenn sich die wifiAddress der Connect()-Methode ändert, muss Definition 1 die Schnittstelle der Methode ändern, und dementsprechend sind alle Objekte betroffen, die die Connect()-Methode aufrufen, während Definition 2 nur die Account-Klasse ändern muss, da die Schnittstelle von Die Connect()-Methode bleibt unverändert und der Aufrufer der Connect()-Methode benötigt keine wifiAddress. Eine solche Änderung wirkt sich überhaupt nicht auf den Aufrufer aus, wodurch die Auswirkungen von Nachfrageänderungen verringert werden.

Kurz gesagt, der Schlüssel zum offenen und geschlossenen Prinzip ist die Abstraktion. Dies bedeutet jedoch nicht, dass die abstrakte Schnittstelle und die abstrakte Klasse nicht mehr geändert werden dürfen, sobald sie festgelegt sind. Wenn wir jedoch abstrahieren, müssen wir umfassend denken und uns bemühen, Änderungen zu vermeiden. Sobald sich die Anforderungen ändern, müssen wir nur während der Implementierung Änderungen vornehmen. Natürlich ändern sich die Anforderungen ständig. Sobald der abstrakte Teil geändert werden muss, werden die Auswirkungen viel geringer sein, solange das Prinzip strikt befolgt wird. Wenn es geändert wird, müssen natürlich Unit-Tests durchgeführt und alles, was verwendet wird, korrekt getestet werden.

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung des offenen und geschlossenen Prinzips in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!