| パターン名 | 定義 |
|---|---|
| 単一責任の原則 | クラスは、1つの領域の対応する責任のみに責任があります |
| 開閉の原理 | ソフトウェアエンティティは拡張可能であり、変更可能です |
| リヒター置換 | 基本クラスへのすべての参照は、彼のサブクラスに透過的に呼び出すことができます |
| 依存性注入 | 抽象化は詳細に依存すべきではなく、詳細は抽象化に依存すべきです |
| インターフェイスの分離 | 複数の専用インターフェースを使用し、一般的なインターフェースは使用しないでください |
| 合成再利用の原則 | 再利用するときに継承を使用せず、構成/複合関係を使用してみてください |
| ミディトラの原則 | ソフトウェアエクスペリエンスにより、他のエンティティとの相互作用が減少しました |
単一責任の原則
单一职责原则，一个类、模块、方法承担一个区域的相应职责，避免多个职责相互交叉，导致修改其中一个职责的时候，影响其他职责。
__单一职责优点：__
- 複雑さを軽減する
- 読みやすさと保守性を向上させる
- 変更
例
DemoTestによって引き起こされるリスクを軽減するこの例は正しい単一責任の原則です
public class DemoTest{
public static void main(String[] args){
Demo d =new Demo();
d.run("大侠”)；
d.run("汉堡");
}
}
class Demo{
public void run(String active){
System.out.println(active)
}
}
間違った単一責任原則の例
public class ErrorTest{
public static void main(String[] args){
Errord =new Error();
d.superMan("大侠”)；
d.hanburger("汉堡");
}
}
class Error{
public void superMan(String active){
System.out.println(active)
}
public void hamburger(String active){
System.out.println(active)
}
}
開閉の原理
开闭原则是指一个实体如类、方法、模块应该只提供扩展，不提供修改。
利点：
- 製品の安定性を維持します。
- 元のコードテスト操作には影響しません。
- コードをよりモジュール化して保守しやすくします。
- 開発効率を向上させます。
例：
/**
*顶层定义一个接口，获取家具信息的接口方法
*/
public interface Furniture{
public String getName();
public double getPrice();
public String getBrand();
public double getDiscounts();
public String getMaterials();
public String getColor();
}
public class Desk implements Furniture{
private double price;
private String brand;
private String materials;
private String color;
private double width;
private double height;
public Desk( double price, String brand, String materials, String color, double width, double height) {
this.price = price;
this.brand = brand;
this.materials = materials;
this.color = color;
this.width = width;
this.height = height;
}
@Override
public double getPrice() {
return price;
}
@Override
public String getBrand() {
return brand;
}
@Override
public String getMaterials() {
return materials;
}
@Override
public String getColor() {
return color;
}
@Override
public double getWidth() {
return width;
}
@Override
public double getHeight() {
return height;
}
}
class BSPHDesk extends Desk {
private double discount;
public BSPHDesk(double discount, double price, String brand, String materials, String color, double width, double height) {
super(price, brand, materials, color, width, height);
this.discount = discount;
}
public double getDiscountPrice() {
return getPrice() * discount;
}
}
public class ExampleUnitTest {
@Test
public void addition_isCorrect() throws Exception {
BSPHDesk desk = new BSPHDesk(0.5,5000,"BSPH","实木","白色",500,600);
desk.getDiscountPrice();
System.out.println("原有价格:"+desk.getPrice()+","+"折扣价格:"+desk.getDiscountPrice());
}
}
リヒター置換原則
里氏代换原则 是指 一个实体如果使用父类，那么一定适用于子类，如果使用子类，那么他不能够使用父类。
利点
- コードの再利用性を向上させます。サブクラスには親クラスのメソッドと属性があります。
- コードのスケーラビリティを改善し、独自の特性を保持します。
例：
public class LSPBase {
/**
* 父类方法运行
*/
public void parentRun(){
System.out.println("这个是里氏代换 父类方法 ");
}
}
public class LSPChild extends LSPBase{
@Override
public void parentRun() {
System.out.println("里氏代换覆盖");
}
public void childRun(String content){
System.out.println("childRun里氏代换覆盖"+content);
}
}
public class ExampleUnitTest {
@Test
public void addition_isCorrect() throws Exception {
LSPBase base = new LSPBase();
run(base);//错误
LSPChild child = new LSPChild();
baseRun(child);//非错误
}
private void baseRun(LSPBase base){
base.parentRun();
}
private void run(LSPChild child) {
child.parentRun();
}
}
依存性注入の原理
依赖注入原则 不要依赖于具体实现，要依赖于抽象。
1）高层模块不应该依赖底层模块，两者应该都依赖于抽象（抽象类和接口）；
2）抽象（类或接口）不应该依赖于具体细节(实现类)；
3）细节（具体类或接口）应该依赖于抽象
利点：
- 関心事の分離;
- 依存関係を初期化するためのすべての作業がインジェクターコンポーネントによって処理されるため、アプリケーションクラスの定型コードが削減されます。
- アクセサリコンポーネントにより、アプリケーションを簡単に拡張できます
- モックオブジェクトを介した単体テストは簡単です
短所：
- 過度の使用は維持を困難にします。
依存性注入を使用しないでください
public class NonDependency {
public void send(String message, String title) {
System.out.println("这个消息内容:" + message + ",标题:" + title);
}
}
public class NonDependencyApplication {
NonDependency dependency = new NonDependency();
public void receive(String message, String title) {
dependency.send(message, title);
}
}
public class ExampleUnitTest {
@Test
public void addition_isCorrect() throws Exception {
NonDependencyApplication application = new NonDependencyApplication();
application.receive("这个市各消息","这个市各标题");
}
}
依存性注入を使用する
public interface Dependency {
void send(String message, String title);
}
class EmailDependency implements Dependency {
@Override
public void send(String message, String title) {
System.out.println("Email sent to "+message+ " with title="+title);
}
}
public class SMSSDependency implements Dependency{
@Override
public void send(String message, String title) {
System.out.println("Email sent to "+message+ " with title="+title);
}
}
public class ExampleUnitTest {
@Test
public void addition_isCorrect() throws Exception {
EmailDependency email= new EmailDependency();
email.send("这个是一个邮箱内容 ","这个是一个邮箱标题");
SMSSDependency smss = new SMSSDependency();
email.send("这个是一个smss内容 ","这个是一个smss标题");
}
}