Shulou(Shulou.com)06/02 Report--

This article introduces the relevant knowledge of "Seven Design principles of java Design pattern". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Overview

A brief introduction to the seven design principles:

Open-close principle: is the core of all object-oriented design, open to extensions, closed to modifications

Dependency inversion principle: programming for interfaces, relying on abstraction rather than concrete

Single responsibility principle: an interface is responsible for only one thing, and there can only be one reason for class change.

Interface isolation principle: use multiple specialized interfaces instead of one master interface

Dimitt rule (least known principle): only communicate with friends (member variables, method input and output parameters), do not talk to strangers, control access modifiers

Richter substitution principle: subclasses can expand the functions of the parent class, but can not change the original function of the parent class

Principle of synthetic reuse: try to use object composition (has-a) / aggregation (contanis-a) instead of inheritance relationship to achieve the purpose of software reuse.

Definition of opening and closing principle

Refers to a software entity such as classes, modules, and functions that should be open to extensions and closed to modifications. The so-called opening and closing is also a principle for expanding and modifying the two behaviors. The emphasis is on building the framework with abstraction and extending the details with implementation. It can improve the reusability and maintainability of software system. The opening and closing principle is the most basic design principle in object-oriented design. It teaches us how to build a stable and flexible system, for example: our version is updated, I try not to modify the source code as much as possible, but can add new features.

The principle of opening and closing is also reflected in real life. For example, many Internet companies implement flexible interest hours, requiring them to work eight hours a day. It means that the rule of working eight hours a day is closed, but when you come and when you leave is open. Come early and leave early, come late and leave late.

Example

The core idea of implementing the open-close principle is abstract-oriented programming. Let's take a look at a piece of code:

Take the bookstore selling books as an example, create a book interface:

/ * * @ author eamon.zhang * @ date 2019-09-25 10:26 * / public interface IBook {/ / Book title public String getName (); / / Price public int getPrice (); / / author public String getAuthor ();}

Books are divided into many categories, such as novels, etc., to create novel books:

/ * @ author eamon.zhang * @ date 2019-09-25 10:30 * / public class NovelBook implements IBook {/ / title private String name; / / Price private int price; / / author private String author; / / pass data public NovelBook (String name, int price, String author) {this.name = name; this.price = price by constructor This.author = author;} / / get the title public String getName () {return this.name;} / / get the price public int getPrice () {return this.price;} / / get the author public String getAuthor () {return this.author;}}

Now we are going to do an activity for novel books with a favorable price. If you modify the getPrice () method in NovelBook, there is a risk that the results of calls elsewhere may be affected. How can we realize the function of price discount in advance without modifying the original code? Now, let's write another class that handles the offer logic, the NovelDiscountBook class (think about why it's called NovelDiscountBook instead of DiscountBook):

/ * * @ author eamon.zhang * @ date 2019-09-25 10:36 * / public class NovelDiscountBook extends NovelBook {public NovelDiscountBook (String name, int price, String author) {super (name, price, author);} public double getOriginPrice () {return super.getPrice ();} public double getPrice () {return super.getPrice () * 0.85;}} Class structure Diagram

Cdn.nlark.com/yuque/0/2019/png/239945/1569379306123-5eb0d472-aa9f-425e-9908-000af06a0c9e.png ">

Definition of dependency inversion principle

The principle of dependency inversion (DependenceInversionPrinciple,DIP) means that when designing code structures, high-level modules should not rely on the underlying modules, but both should rely on their abstractions. Abstractions should not rely on details; details should rely on abstractions. Through dependency inversion, we can reduce the coupling between classes, improve the stability of the system, improve the readability and maintainability of the code, and reduce the risk caused by modifying the program.

Example

Let's take reading books as an example, first create an Eamon class:

/ * @ author eamon.zhang * @ date 2019-09-25 11:09 * / public class Eamon {public void readNotreDame () {System.out.println ("Eamon is reading Saint Mu's Court of Paris");} public void readTheOldManAndTheSea () {System.out.println ("Eamon is reading" the Old Man and the Sea ");}}

Write a test class to call:

Public static void main (String [] args) {Eamon eamon = new Eamon (); eamon.readNotreDame (); eamon.readTheOldManAndTheSea ();}

Eamon is currently reading two books. But learning is endless. After reading these books, Eamon still wants to read The Demi-Gods & Semi-Devils. At this time, the business expansion, our code from the bottom to the high level (call layer) to modify the code at once. Add the method of readTianLongBaBu () to the Eamon class, and append the call at the high level. In this way, after the release of the system, it is actually very unstable, while modifying the code will also bring unexpected risks. Next, let's optimize the code to create an abstract IBook interface for the course:

/ * * @ author eamon.zhang * @ date 2019-09-25 11:20 * / public interface IBook {void read ();}

Then write the NotreDameBook class:

/ * * @ author eamon.zhang * @ date 2019-09-25 11:22 * / public class NotreDameBook implements IBook {public void read () {System.out.println ("Eamon is reading the Court of Saint MU Paris");}}

Then write the TheOldManAndTheSeaBook class:

/ * * @ author eamon.zhang * @ date 2019-09-25 11:23 * / public class TheOldManAndTheSeaBook implements IBook {public void read () {System.out.println ("Eamon is reading the Old Man and the Sea");}}

Modify the Eamon class

/ * * @ author eamon.zhang * @ date 2019-09-25 11:09 * / public class Eamon {public void read (IBook iBook) {iBook.read ();}}

Let's take a look at the call:

Public static void main (String [] args) {Eamon eamon = new Eamon (); eamon.read (new NotreDameBook ()); eamon.read (new TheOldManAndTheSeaBook ());}

At this point, we look at the code, Eamon wants to read any more books, for new books, I just need to create a new class, pass parameters to tell Eamon, without the need to modify the underlying code. In fact, this is a very familiar approach called dependency injection. The injection methods include constructor mode and setter mode. Let's look at how the constructor is injected:

/ * * @ author eamon.zhang * @ date 2019-09-25 11:09 * / public class Eamon {public Eamon (IBook iBook) {this.iBook = iBook;} private IBook iBook; public void read () {iBook.read ();}}

Look at the calling code:

Public static void main (String [] args) {Eamon eamon = new Eamon (new NotreDameBook ()); eamon.read ();}

According to the constructor injection, an instance is created each time the call is made. So, if Eamon is a global singleton, we can only choose to inject it in Setter and continue to modify the code of the Eamon class:

/ * * @ author eamon.zhang * @ date 2019-09-25 11:09 * / public class Eamon {private IBook iBook; public void setBook (IBook iBook) {this.iBook = iBook;} public void read () {iBook.read ();}}

Look at the calling code:

Public static void main (String [] args) {Eamon eamon = new Eamon (); eamon.setBook (new NotreDameBook ()); eamon.read (); eamon.setBook (new TheOldManAndTheSeaBook ()); eamon.read ();} final class diagram

Remember: an abstraction-based architecture is much more stable than a detail-based architecture, so after you get the requirements, you have to program for the interface and design the code structure at the top level and then in detail.

This is the end of the introduction of the Seven Design principles of java Design pattern. Thank you for your reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.