设计模式七大原则

最新推荐文章于 2022-09-27 21:41:56 发布
最新推荐文章于 2022-09-27 21:41:56 发布
阅读量267 收藏 1
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m_awdawdw/article/details/109329657
版权

文章目录


##设计模式常用的七大原则

单一职责元则

接口隔离原则

依赖倒转原则

里氏替换原则

开闭原则（ocp）

迪米特法则

合成复用原则

单一职责元则

简介

对类来说的，即一个类应该只负责一项职责。如类A负责两个不同职责：职责1，职责2。当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为A1，A2

简而言之，就是我们常写的Dao类就遵循了单一职责元则，UserDao中就是包含于用户相关的操作，如果UserDao中包含了与Order相关的操作，就需要将UserDao拆分成UserDao和OrderDao

应用实例

  • 案例一
public class SingleResponsibility {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("自行车");
        vehicle.run("摩托车");
        vehicle.run("飞机");
    }
}

class Vehicle {
    public void run(String vehicle){
        System.out.println(vehicle + "在公路上运行...");
    }
}

案例一总结：

在案例一中run方法违背了单一职责原则

解决办法：进行分离

  • 案例二
public class SingleResponsibility2 {
    public static void main(String[] args) {
        RoadVehicle roadVehicle = new RoadVehicle();
        roadVehicle.run("摩托车");
        roadVehicle.run("自行车");
        AirVehicle airVehicle = new AirVehicle();
        airVehicle.run("飞机");
    }
}

class RoadVehicle {
    public void run(String vehicle){
        System.out.println(vehicle + "在公路运行....");
    }
}

class AirVehicle {
    public void run(String vehicle){
        System.out.println(vehicle + "在天空运行....");
    }
}

class WaterVehicle {
    public void run(String vehicle){
        System.out.println(vehicle + "在水里运行....");
    }
}

案例二总结：

遵守了单一职责原则

但是这样做改动很大，即要将类分解，同时修改客户端

改进：直接修改Vehicle 改动的代码会比较少

  • 案例三
public class SingleResponsibility3 {
    public static void main(String[] args) {
        Vehicle2 vehicle2 = new Vehicle2();
        vehicle2.run("摩托车");
        vehicle2.runAir("飞机");
        vehicle2.runWater("小船");
    }
}
class Vehicle2{
    public void run(String vehicle){
        System.out.println(vehicle + "在公路上跑...");
    }
    public void runAir(String vehicle){
        System.out.println(vehicle + "在天上飞...");
    }
    public void runWater(String vehicle){
        System.out.println(vehicle + "在水里游...");
    }
}

案例三总结：

这种方法没有对原来的类做大的修改，只是增加了方法

这里虽然没有在类这个级别上遵守单一职责原则，但是在方法级别上遵守了单一职责原则

注意事项

  1. 降低类的复杂度，一个类只负责一项职责。

  2. 提高类的可读性，可维护性

  3. 降低变更引起的风险

  4. 通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则

接口隔离原则

简介

客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上

1603700784026

图中B类和D类都实现了interface1，此时A类通过接口会依赖B类，但是只使用到了接口的1,2,3三个方法

应用实例

  • 案例一
public class Segregation1 {
    public static void main(String[] args) {
        A a = new A();
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());

        C c= new C();
        c.depend1(new D());//C类通过接口去依赖(使用)D类
        c.depend4(new D());
        c.depend5(new D());
    }
}

interface interface1{
    void operation1();
    void operation2();
    void operation3();
    void operation4();
    void operation5();
}

class B implements interface1{

    @Override
    public void operation1() {
        System.out.println("B实现了operation 1");
    }

    @Override
    public void operation2() {
        System.out.println("B实现了operation 2");
    }

    @Override
    public void operation3() {
        System.out.println("B实现了operation 3");
    }

    @Override
    public void operation4() {
        System.out.println("B实现了operation 4");
    }

    @Override
    public void operation5() {
        System.out.println("B实现了operation 5");
    }
}

class D implements interface1{

    @Override
    public void operation1() {
        System.out.println("D实现了operation 1");
    }

    @Override
    public void operation2() {
        System.out.println("D实现了operation 2");
    }

    @Override
    public void operation3() {
        System.out.println("D实现了operation 3");
    }

    @Override
    public void operation4() {
        System.out.println("D实现了operation 4");
    }

    @Override
    public void operation5() {
        System.out.println("D实现了operation 5");
    }
}

class A{ //A类通过interface依赖B类,但是只会用到 1,2,3方法
    public void depend1(interface1 i){
        i.operation1();
    }
    public void depend2(interface1 i){
        i.operation2();
    }
    public void depend3(interface1 i){
        i.operation3();
    }
}

class C {   //C类通过接口Interface1依赖(使用)D类，但是只会用到1,4,5方法
    public void depend1(interface1 i){
        i.operation1();
    }
    public void depend4(interface1 i){
        i.operation4();
    }
    public void depend5(interface1 i){
        i.operation5();
    }
}

存在的问题：

类A通过接口Interface1依赖类B，类C通过接口Interface1依赖类D，如果接口Interface1对于类A和类C来说不是最小接口，那么类B和类D必须去实现他们不需要的方法

将接口Interface1拆分为独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则

接口Interface1中出现的方法，根据实际情况拆分为三个接口

改善

1603703613876

public class Segregation2 {
    public static void main(String[] args) {
        A a = new A();
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());

        C c= new C();
        c.depend1(new D());//C类通过接口去依赖(使用)D类
        c.depend4(new D());
        c.depend5(new D());
    }
}

interface interface1{
    void operation1();
}

interface interface2{
    void operation2();
    void operation3();
}

interface interface3{
    void operation4();
    void operation5();
}

class B implements interface1,interface2{

    @Override
    public void operation1() {
        System.out.println("B实现了operation 1");
    }

    @Override
    public void operation2() {
        System.out.println("B实现了operation 2");
    }

    @Override
    public void operation3() {
        System.out.println("B实现了operation 3");
    }
}

class D implements interface1,interface3{

    @Override
    public void operation1() {
        System.out.println("D实现了operation 1");
    }

    @Override
    public void operation4() {
        System.out.println("D实现了operation 4");
    }

    @Override
    public void operation5() {
        System.out.println("D实现了operation 5");
    }
}

class A{ //A类通过interface依赖B类,但是只会用到 1,2,3方法
    public void depend1(interface1 i){
        i.operation1();
    }
    public void depend2(interface2 i){
        i.operation2();
    }
    public void depend3(interface2 i){
        i.operation3();
    }
}

class C {   //C类通过接口Interface1依赖(使用)D类，但是只会用到1,4,5方法
    public void depend1(interface1 i){
        i.operation1();
    }
    public void depend4(interface3 i){
        i.operation4();
    }
    public void depend5(interface3 i){
        i.operation5();
    }
}

依赖倒转原则

简介

依赖倒转原则(DependenceInversionPrinciple)是指：

1)高层模块不应该依赖低层模块，二者都应该依赖其抽象

2)抽象不应该依赖细节，细节应该依赖抽象

3)依赖倒转(倒置)的中心思想是面向接口编程

4)依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中，抽象指的是接口或抽象类，细节就是具体的实现类

5)使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成

应用实例

不使用依赖倒转原则：

public class DependecyInversion {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
    }
}

class Email {
    public String getInfo(){
        return "电子邮件信息,Hello World";
    }
}

class Person {
    public void receive(Email el){
        System.out.println(el.getInfo());
    }
}

//1.简单，比较容易想到

2.如果我们获取的对象是微信，短信等等，则新增类，同时Perons也要增加相应的接收方法

3.解决思路：引入一个抽象的接口IReceiver,表示接收者,这样Person类与接口IReceiver发生依赖//因为Email,WeiXin等等属于接收的范围，他们各自实现IReceiver接口就ok,这样我们就符号依赖倒转原则

使用依赖倒转

public class DependecyInversion {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
    }
}

interface IReceive{
    String getInfo();
}

class Email implements IReceive{
    public String getInfo(){
        return "电子邮件信息,Hello World";
    }
}

class Person {
    public void receive(IReceive el){
        System.out.println(el.getInfo());
    }
}

依赖关系传递的三种方式和应用案例

接口传递、构造方法传递、setter方式传递

接口传递

public class DependencyPass {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
         ChangHong changHong = new ChangHong();
		OpenAndClose openAndClose = new OpenAndClose();
		openAndClose.open(changHong);
    }
}

// 方式1： 通过接口传递实现依赖
// 开关的接口
 interface IOpenAndClose {
 	public void open(ITV tv); //抽象方法,接收接口
 }

 interface ITV { //ITV接口
 	public void play();
 }

 class ChangHong implements ITV {

	@Override
	public void play() {
		// TODO Auto-generated method stub
		System.out.println("长虹电视机，打开");
	}

 }
// 实现接口
 class OpenAndClose implements IOpenAndClose{
 public void open(ITV tv){
 tv.play();
 }
 }

构造方法传递

public class DependencyPass {

    public static void main(String[] args) {
        ChangHong changHong = new ChangHong();

        //通过构造器进行依赖传递
        OpenAndClose openAndClose = new OpenAndClose(changHong);
        openAndClose.open();

    }

}

class ChangHong implements ITV {

    @Override
    public void play() {
        // TODO Auto-generated method stub
        System.out.println("长虹电视机，打开");
    }

}

// 方式2: 通过构造方法依赖传递
interface IOpenAndClose {
    public void open(); //抽象方法
}

interface ITV { //ITV接口
    public void play();
}

class OpenAndClose implements IOpenAndClose {
    public ITV tv; //成员

    public OpenAndClose(ITV tv) { //构造器
        this.tv = tv;
    }

    public void open() {
        this.tv.play();
    }
}

setter方式传递

public class DependencyPass {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ChangHong changHong = new ChangHong();
        OpenAndClose openAndClose = new OpenAndClose();
        openAndClose.setTv(changHong);
        openAndClose.open();
    }
}
// 方式3 , 通过setter方法传递
interface IOpenAndClose {
        public void open(); // 抽象方法

        public void setTv(ITV tv);
    }

    interface ITV { // ITV接口
        public void play();
    }

    class OpenAndClose implements IOpenAndClose {
        private ITV tv;

        public void setTv(ITV tv) {
            this.tv = tv;
        }

        public void open() {
            this.tv.play();
        }
    }

    class ChangHong implements ITV {

        @Override
        public void play() {
            // TODO Auto-generated method stub
            System.out.println("长虹电视机，打开");
        }

}

注意细节

  1. 低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好.

  2. 变量的声明类型尽量是抽象类或接口,这样我们的变量引用和实际对象间，就存在一个缓冲层，利于程序扩展和优化

  3. 继承时遵循里氏替换原则

里氏替换原则

问题的提出

1)继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏。

2)继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低，增加对象间的耦合性，如果一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到子类的功能都有可能产生故障

3)问题提出：在编程中，如何正确的使用继承?=>里氏替换原则

基本介绍

1)里氏替换原则(LiskovSubstitutionPrinciple)在1988年，由麻省理工学院的以为姓里的女士提出的。

2)如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都代换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。换句话说，所有引用基类的地方必须能透明地使用其子类的对象。

3)在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法

4)里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决问题。

应用实例

违背里氏替换原则

public class Liskov {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(" 9-2= " + a.func1(9,2));
        System.out.println(" 15-5= " + a.func1(15,5));
        System.out.println("----------------------");

        B b = new B();
        System.out.println("8 - 6 = " + b.func1(8,6));
        System.out.println("9 - 2 = " + b.func1(9,2));
    }
}

class A {
    public int func1(int num1,int num2){
        return num1 - num2;
    }
}

class B extends A {

    @Override
    public int func1(int num1,int num2){
        return num1 + num2;
    }

    public  int func2(int num1,int num2){
        return func1(num1,num2) + 9;
    }
}
// 执行结果
// 9-2= 7
// 15-5= 10
// ----------------------
// 8 - 6 = 14
// 9 - 2 = 11

解决问题

  1. 我们发现原来运行正常的相减功能发生了错误。原因就是类B无意中重写了父类的方法，造成原有功能出现错误。在实际编程中，我们常常会通过重写父类的方法完成新的功能，这样写起来虽然简单，但整个继承体系的复用性会比较差。特别是运行多态比较频繁的时候

  2. 通用的做法是：原来的父类和子类都继承一个更通俗的基类，原有的继承关系去掉，采用依赖，聚合，组合等关系代替.

    1603763388049

代码实现

public class Liskov {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(" 9-2= " + a.func1(9,2));
        System.out.println(" 15-5= " + a.func1(15,5));
        System.out.println("----------------------");

        B b = new B();
        //因为B类不再继承A类，因此调用者，不会再认为func1是求减法
        System.out.println("8 + 6 = " + b.func1(8,6));
        System.out.println("9 + 2 = " + b.func1(9,2));
    }
}

class Base{
    //把更加基础的方法和成员写到Base类
}

class A extends Base{
    public int func1(int num1,int num2){
        return num1 - num2;
    }
}

class B extends Base {
    //如果B需要使用A类的方法,使用组合关系
    private A a = new A();

    public int func1(int num1,int num2){
        return num1 + num2;
    }

    public  int func2(int num1,int num2){
        return func1(num1,num2) + 9;
    }

    //我们仍然想使用A的方法
    public int func3(int a,int b){
        return this.a.func1(a,b);
    }
}

开闭原则

基本介绍

  1. 开闭原则（OpenClosedPrinciple）是编程中**最基础、最重要**的设计原则

2)一个软件实体如类，模块和函数应该对**扩展开放(对提供方)，对修改关闭(对使用方)**。用抽象构建框架，用实现扩展细节。

3)当软件需要变化时，尽量**通过扩展软件**实体的行为来实现变化，而不是通过修改已有的代码来实现变化。

4)编程中遵循其它原则，以及使用设计模式的目的就是遵循开闭原则。

应用实例

public class OCP {
    public static void main(String[] args) {
        //使用看看存在的问题
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Circle());
        graphicEditor.drawShape(new Triangle());
    }
}
//这是一个用于绘图的类 [使用方]
class GraphicEditor {
    //接收 Shape 对象,然后根据 type,来绘制不同的图形
    public void drawShape(Shape s) {
        if (s.m_type == 1)
            drawRectangle(s);
        else if (s.m_type == 2)
            drawCircle(s);
        else if (s.m_type == 3)
            drawTriangle(s);
    }

    //绘制矩形
    public void drawRectangle(Shape r) {
        System.out.println(" 绘制矩形 ");
    }

    //绘制圆形
    public void drawCircle(Shape r) {
        System.out.println(" 绘制圆形 ");
    }

    //绘制三角形
    public void drawTriangle(Shape r) {
        System.out.println(" 绘制三角形 ");
    }
}

//Shape 类， 基类
class Shape {
    int m_type;
}

class Rectangle extends Shape {
    Rectangle() {
        super.m_type = 1;
    }
}

class Circle extends Shape {
    Circle() {
        super.m_type = 2;
    }
}

//新增画三角形
class Triangle extends Shape {
    Triangle() {
        super.m_type = 3;
    }
}

存在的问题：

例如上面的Triangle方法，就为新增的三角形方法。需要改动的代码很多。

改进

public class Ocp {

    public static void main(String[] args) {
        //使用看看存在的问题
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Circle());
        graphicEditor.drawShape(new Triangle());
        graphicEditor.drawShape(new OtherGraphic());
    }
}

//这是一个用于绘图的类 [使用方]
class GraphicEditor {
    //接收 Shape 对象， 调用 draw 方法
    public void drawShape(Shape s) {
        s.draw();
    }
}

//Shape 类, 基类
abstract class Shape {
    int m_type;
    public abstract void draw();//抽象方法
}

class Rectangle extends Shape {
    Rectangle() {
        super.m_type = 1;
    }

    @Override
    public void draw() {
        System.out.println(" 绘制矩形 ");
    }
}

class Circle extends Shape {
    Circle() {
        super.m_type = 2;
    }

    @Override
    public void draw() {
        System.out.println(" 绘制圆形 ");
    }
}

//新增画三角形
class Triangle extends Shape {
    Triangle() {
        super.m_type = 3;
    }

    @Override
    public void draw() {
        System.out.println(" 绘制三角形 ");
    }
}

//新增一个图形
class OtherGraphic extends Shape {
    OtherGraphic() {
        super.m_type = 4;
    }

    @Override
    public void draw() {
        System.out.println(" 绘制其它图形 ");
    }
}

迪米特法则

基本介绍

  1. 一个对象应该对其他对象保持最少的了解
  2. 类与类关系越密切， 耦合度越大
  3. 迪米特法则(Demeter Principle)又叫最少知道原则， 即一个类对自己依赖的类知道的越少越好。 也就是说， 对于
    被依赖的类不管多么复杂， 都尽量将逻辑封装在类的内部。 对外除了提供的 public 方法， 不对外泄露任何信息
  4. 迪米特法则还有个更简单的定义： 只与直接的朋友通信
  5. 直接的朋友： 每个对象都会与其他对象有耦合关系， 只要两个对象之间有耦合关系， 我们就说这两个对象之间是朋友关系。 耦合的方式很多， 依赖， 关联， 组合， 聚合等。 其中， 我们称出现成员变量， 方法参数， 方法返回值中的类为直接的朋友， 而出现在局部变量中的类不是直接的朋友。 也就是说， 陌生的类最好不要以局部变量的形式出现在类的内部。

应用实例

public class Demeter1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SchoolManager schoolManager = new SchoolManager();
        schoolManager.printAllEmployee(new CollegeManager());
    }
}

class Employee {
    private String id;

    public void setId(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }
}

class CollegeEmployee {
    private String id;

    public void setId(String id) {
        this.id = id;
    }
    public String getId() {
        return id;
    }
}


class CollegeManager {
    public List<CollegeEmployee> getAllEmployee() {
        List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
        for (int i = 0; i < 10; i++) {
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工id= " + i);
            list.add(emp);
        }
        return list;
    }
}
//直接朋友有Employee、CollegeManager
//CollegeEmployee 不是直接朋友，违背了迪米特法则
class SchoolManager {
    public List<Employee> getAllEmployee() {
        List<Employee> list = new ArrayList<Employee>();
        for (int i = 0; i < 5; i++) {
            Employee emp = new Employee();
            emp.setId("学校总部员工id= " + i);
            list.add(emp);
        }
        return list;
    }

    void printAllEmployee(CollegeManager sub) {

        List<CollegeEmployee> list1 = sub.getAllEmployee();
        System.out.println("------------分公司员工------------");
        for (CollegeEmployee e : list1) {
            System.out.println(e.getId());
        }
        List<Employee> list2 = this.getAllEmployee();
        System.out.println("------------学校总部员工------------");
        for (Employee e : list2) {
            System.out.println(e.getId());
        }
    }
}1209100258

使用迪米特法则

将输出学院的员工方法 封装到CollegeManager

public class Demeter1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SchoolManager schoolManager = new SchoolManager();
        schoolManager.printAllEmployee(new CollegeManager());

    }

}


class Employee {
    private String id;

    public void setId(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }
}


class CollegeEmployee {
    private String id;
    public void setId(String id) {
        this.id = id;
    }
    public String getId() {
        return id;
    }
}


class CollegeManager {
    public List<CollegeEmployee> getAllEmployee() {
        List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
        for (int i = 0; i < 10; i++) {
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工id= " + i);
            list.add(emp);
        }
        return list;
    }

    public List<Employee> getDepEmployee() {
        List<Employee> list = new ArrayList<Employee>();

        for (int i = 0; i < 5; i++) {
            Employee emp = new Employee();
            emp.setId("学校总部员工id= " + i);
            list.add(emp);
        }
        return list;
    }
}
//将输出学院的员工方法 封装到CollegeManager
class SchoolManager {
    void printAllEmployee(CollegeManager sub) {
        List<CollegeEmployee> list1 = sub.getAllEmployee();
        System.out.println("------------分公司员工------------");
        for (CollegeEmployee e : list1) {
            System.out.println(e.getId());
        }
        List<Employee> list2 = sub.getDepEmployee();
        System.out.println("------------学校总部员工------------");
        for (Employee e : list2) {
            System.out.println(e.getId());
        }
    }
}

合成复用原则

基本介绍

原则是尽量使用合成/聚合的方式， 而不是使用继承

1603856315717

核心思想

  1. 找出应用中可能需要变化之处， 把它们独立出来， 不要和那些不需要变化的代码混在一起。
  2. 针对接口编程， 而不是针对实现编程。
  3. 为了交互对象之间的松耦合设计而努力
超人不会飞aa
关注
专栏目录
设计模式的七大原则
煜城的博客
08-31 382
设计模式的目的：在编写软件的过程中，程序员面临着来之耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性等多方面的挑战，设计模式的好处是为了让程序具有如下特点： 代码重用性（即：相同功能的代码，不用多次编写） 可读性（即：程序规范性，便于其他程序员的阅读和理解） 可扩展性（即：当需要增加新的功能时，非常的方便） 可靠性（即：我们对程序增加新的功能的时候，对原来的功能没有影响） 可维护性（即：我们转让项目的时候，别人能很快的上手自己的项目） 最终目的是使程序呈现高内聚，低耦合的特性。 设计模式的七
设计模式---七大原则
G0_hw
07-07 452
    设计模式原则，其实就是程序员在编程时，应当遵守的原则，也是各种设计模式的基础(即：设计模式为什么这样设计的依据)。 一. 设计模式常用的七大原则 单一职责原则 接口隔离原则 依赖倒转(倒置)原则 里氏替换原则 开闭原则 迪米特法则 合成复用原则 二. 单一职责原则(Single Responsibility Principle)  &n...
设计模式几大原则
httphttpcn的专栏
12-16 6162
看了设计模式,最后看的总是感觉他们有很大的相似之处,就像是世界上万事万物都有其生存法则一样.仔细分析其实设计模式都是围绕一条主线来的。这就是设计模式的原则。你可以把设计原则比作一门语言。把设计模式当作这门语言编写出来的程序。如果你精通了语言剩下的编码就是很简单的事情了.对于层出不穷的设计模式,比如Gof的23种设计模式,MVC模式,到底应该怎样去学习,如果我们单纯的一个一个的研究设计模式本身,那么只能是越看越多,越来越乱.其实我们只要抓住设计模式的原则,就能很清楚的分析出它为什么会这么做.设计模式原则再加上
设计模式的几大原则
weixin_30444105的博客
12-28 80
1.单一职责原则 类的职责要单一，不能将太多的职能放在一个类中。 2.开闭原则 软件实体对扩展是开放的，但对修改是关闭的，即在不修改一个软件的基础上去扩展其功能。实现开闭原则的关键是抽象化，找到系统的可变因素，将它封装起来。 3.里氏替换原则 一个可以接受基类对象的地方必然可以接受一个子类对象。在程序中尽量使用基类类型来对对象进行定义，而在运行时再确定其子类类型，使用子类来替换父类对象。...
Java设计模式七大原则-单一职责原则.md
08-13
设计模式
Java设计模式七大原则-合成聚合复用原则.md
最新发布
08-13
java八股文
yoyiyi#SoleilNotes#001.设计模式七大原则1
07-25
2.1 单一职责原则 2.2 接口隔离原则 2.3 依赖倒置原则 2.4 里式替换原则 2.5 开闭原则 2.6 迪米特原则 2.7 合成复用原则
设计模式学习之七大原则
weixin_42797377的博客
03-08 617
设计模式学习之七大原则 一、设计模式前言 1、设计模式的概念 软件设计模式（Software Design Pattern），又称设计模式，是一套被反复使用、多数人知晓的、代码设计经验的总结。它描述了在软件设计过程中的一些不断重复发生的问题，以及该问题的解决方案。也就是说，它是解决特定问题的一系列套路，是前辈们的代码设计经验的总结，具有一定的普遍性，可以反复使用。其目的是为了提高代码的可重用性、代码的可读性和代码的可靠性。 2、设计模式的本质 设计模式的本质是面向对象设计原则的实际运用，是对类的封装性、继承
设计模式原则-
foodvc的专栏
05-15 409
书中列举的设计原则：1、封装变化。找出应用中可能需要变化之处，把他们独立出来，不要和那些不需要变化的代码混在一起。2、针对接口编程，而不是针对实现编程。举例说明：假设有一个抽象类Animal，有两个具体的实现（Dog与Cat）继承Animal。 “针对实现编程”的做法：Dog d = new Dog();d.bark();“针对接口编程”的做法：Animal anima
【设计模式】设计模式原则详解
weixin_34335458的博客
09-02 172
      我们在应用程序开发中，一般要求尽量两做到可维护性和可复用性。       应用程序的复用可以提高应用程序的开发效率和质量，节约开发成本，恰当的复用还可以改善系统的可维护性。而在面向对象的设计里面，可维护性复用都是以面向对象设计原则为基础的，这些设计原则首先都是复用的原则，遵循这些设计原则可以有效地提高系统的复用性，同时提高系统的可维护性。 面向对象设计原则和设计模式也是对系统进行合...
设计模式——七大原则
weixin_52477733的博客
09-27 699
单一职责原则指的是一个类只能执行一个职责.假设一个类执行了两个职责,当第一个职责发生变动时,肯可能会导致第二个职责执行错误.接口隔离原则指的是当一个类通过接口依赖于另一个类时应该建立在最小的接口的基础上.依赖倒转的规则有5条高级模块不依赖于低级模块.低级模块和高级模块应该都依赖于抽象(接口或抽象类)抽象不应该依赖于细节,细节应该依赖于抽象依赖倒转原则的核心是面向接口编程依赖倒转原则的设计理念是相对于细节的多变性,抽象的东西要稳定的多.使用接口和抽象类来设计规范。
设计模式-七大原则
weixin_38465575的博客
04-08 164
设计模式七大原则单一职责原则里氏替换替换原则依赖倒置原则接口隔离原则迪米特法则开闭原则合成复用原则 七大原则 23种设计模式，遵守软边编写的七大原则，因此学好设计模式必要理解软件编写的七大原则 单一职责原则 每个类均应只负责某一项职责。当类中的逻辑比较简单，方法比较少时，可以在方法级别上遵守单一职责原则。即每个方法负责一项职责。 如UserDao只应该负责关于用户这一项职责，UserDao的所有方...
java 设计模式 七大原则
09-14
Java设计模式的七大原则包括： 1) 单一职责原则：一个类应该只有一个引起变化的原因，即一个类应该只有一个职责。 2) 接口隔离原则：客户端不应该依赖它不需要的接口。应该将接口细分为更小的接口，以便于客户端只...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

超人不会飞aa

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值