面向对象的设计模式

最新推荐文章于 2023-03-01 10:07:25 发布
最新推荐文章于 2023-03-01 10:07:25 发布
阅读量1.3k 收藏 1
点赞数
文章标签： 设计模式 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/dfdbb6b/article/details/128974320
版权

"万丈高楼平地起，7种模式打地基"，模式是一种规范，我们应该站在巨人的肩膀上越看越远，接下来，让我们去仔细了解了解面向对象的7种设计模式

7种设计模式

设计原则的核心思想：

  • 找出应用中可能需要变化之处，独立出来，不要和不需要变化的代码混在一起

  • 针对接口编程，而坏是针对实现编程

  • 为了交互对象的耦合性而设计

  • 为了使程序高内聚，低耦合

  • 单一职责（低耦合，高内聚）

每一个类负责的任务很明确，降低代码之间的耦合度，如果代码耦合度较高，动一点则要动全身，当变化发生时设计或遭受到意想不到的破坏

public class Run {
  
     public  void run(){
          System.out.println("跑步");
     }
}

在Run类中只负责了Run()的功能，不负责其他的功能，在设计改变类的时候对整体的影响不大

  • 开闭原则（适应性和灵活性 稳定性和延续性 可复用性和可维护性）

在软件开发的过程中，随着版本的更替，软件的需求会越来越多，如果是修改的内容的话，会很费时，但是我们换个思路，如果在设计模式的时候，我们可以先评估出最容易发生的类，然后对其进行抽象化设计，当变化发生时，只需要增加新的具体类来实现新的业务功能

未使用开/闭原则：

/*
  开闭原则引入案例
 */
public class CarDemo {

    public static void main(String[] args) {
        new CarFactory().createCar(1);
        new CarFactory().createCar(2);
        new CarFactory().createCar(3);
     //后期如果需要添加车型，CarFactory需要修改代码
        //new CarFactory().createCar(4);
        //new CarFactory().createCar(5);
    }

}

/*
   汽车工程类,专门负责造汽车
 */
class CarFactory{

    /*
       违反了开闭原则,后期如果添加新的汽车类,则需要修改代码
     */
    public void createCar(int type){
          if(type==1){
              System.out.println("造宝马汽车"+new Car("宝马汽车"));
          }else if(type==2){
              System.out.println("造奥迪汽车"+new Car("奥迪汽车"));
          }else{
              System.out.println("造大众汽车"+new Car("大众汽车"));
          }
    }

}

/*
Car类
*/
class Car{
    String name;//定义了一个成员变量

    public Car(String name) {//有参构造函数
        this.name = name;
    }
}

使用开/闭原则：

/*
开闭原则案例
 */
class CarDemo{

    public static void main(String[] args) {
           new CarFactory().carfactory(new BMW());
           new CarFactory().carfactory(new Aodi());
           new CarFactory().carfactory(new DaZhong());

    }

}

//创建一个CarFactory类
class CarFactory{
         //创建一个车辆工厂的方法

      void   carfactory(Car car){
          car.createCar();
      }
}

   //创建一个抽象类Car
abstract  class Car{
   //创建一个创建车辆的抽象方法
   public abstract   void createCar();
}

/*
如果想添加车辆型号的话，只需要创建一个类继承Car类并实现createCar（）方法，不用修改代码
*/

//继承并重写Car里的方法
class BMW extends Car{

    @Override
    public void createCar() {
        System.out.println("造宝马汽车");
    }
}

//继承并重写Car里的方法
class Aodi extends Car{
    @Override
    public void createCar() {
        System.out.println("造奥迪汽车");
    }
}

//继承并重写Car里的方法
class DaZhong extends Car{
    @Override
    public void createCar() {
        System.out.println("造大众汽车");
    }
}

//继承并重写Car里的方法
class BC extends Car{
    @Override
    public void createCar() {
        System.out.println("造奔驰汽车");

        Calendar.getInstance();
        new GregorianCalendar();
    }
}

  • 里氏替换原则（提高代码的复用性、提高代码的可扩展性 | 继承是具有侵入性的 增大了耦合性 ）

基本概念：继承必须确保超类锁拥有的性质在子类中仍然成立（子类继承父类后,尽量不要重写父类的方法,可以新增扩展其他的功能.保证子类功能的正确性. 不能让功能修改后,导致程序出错）

主要作用：

  1. 里氏替换原则是实现开闭原则的重要方式之一

  1. 克服了继承中重写父类方法造成的可复用性变差的缺点

  1. 功能正确的保证

  1. 加强了程序的健壮性，提高了程序的维护性降低需求变更时引入的风险

代码演练：

/*
  里氏替换原则演示案例
  计算器父类
*/

public class CalculatorDemo{
    public static void main(String[] args) {
        System.out.println(new SuperCalculator().sum(5,5,5));
    }

}
//计算器 基类
class Calculator {
        //加法
        public int add(int a,int b){
            return a+b;
        }
       //减法
        public int sub(int a,int b){
            return a-b;
        }
}
/*
     超级计算器子类
*/
class SuperCalculator extends Calculator{

        //重写了父类加法
        @Override
        public int add(int a, int b) {
            return a+b+5;
        }

        //求和方法 子类新增的功能
        public int sum(int a,int b,int c){
            //调用add(),但是子类重写了父类方法,此处调用的子类方法发生了变化
            int result = this.add(a,b);
            return result+c;
        }
}

没有重写父类方法时，输出还是正确结果15，但是重写之后却改变了值，输出了错误的结果20

  • 依赖倒置（都依赖于抽象）

让程序面向抽象类编程、面向接口编程（依赖于抽象接口，对抽象进行编程）

/*
  依赖倒置引入案例
 */
public class WorkerDemo{
    public static void main(String[] args) {
        new Worker().getMessage(new DingDing());
        new Worker().getMessage(new WeChat());
        //每创建一个信息都要进行修改代码
    }
}

 class Worker {

    public void getMessage(DingDing ding){
        System.out.println(ding.sendMessage());
    }
    public void getMessage(WeChat weChat){
         System.out.println(weChat.sendMessage());
    }
    //每添加一个信息都要进行修改代码
}

//钉钉消息
class DingDing{
    public String sendMessage(){
           return "钉钉消息";
    }
}

//微信消息
class WeChat{
    public String sendMessage(){
        return "微信消息";
    }
}
/*
   依赖倒置案例演示
 */
public class WorkerDemo{

    public static void main(String[] args) {
        new Worker().getMessage(new WeChat());//具有可变性，有较高的适用性
    }

}

class Worker {

    public void getMessage(Message message){
        System.out.println(message.sendMessage());
    }

}

interface Message{
    public String sendMessage();
}

//添加一个信息需要创建一个类实现Message接口
class WeChat implements Message{
    @Override
    public String sendMessage() {
        return "微信消息";
    }
}
class DingDing implements Message{

    @Override
    public String sendMessage() {
        return "钉钉消息";
    }
}

  • 接口隔离

使用多个接口，不使用单一的总接口（这个最好理解，在这里就不解释了）

  • 迪米特原则

一个对象应该对其他对象有最少的了解（在一个类中，应尽量少的使用与其没有直接关系的类）

直接关系：

  1. 类中的成员属性

  1. 在类中的方法作为参数使用

  1. 在类中的方法作为返回值类型

注意事项：

  1. 核心是降低类之间的耦合

  1. 从被依赖折者的角度来看，尽量将逻辑封装在类的内部，对外除了提供的public方法，不泄露任何信息

  1. 从依赖者的角度来说，只依赖应该依赖的对象

  1. 切记不要为了用而用

代码实现：

public class Demeter {

    public static void main(String[] args) {
             new SchoolManger().printAllEmployee(new CollegeManger());
    }
}

/*
  学校员工类
 */
class SchoolEmployee{
    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 CollegeManger{
    //生成学院所有的员工
    public List<CollegeEmployee> getCollegeEmployee(){
        ArrayList<CollegeEmployee> collegeEmployeeArrayList = new ArrayList<>();
        for (int i = 0; i <10 ; i++) {
            CollegeEmployee collegeEmployee = new CollegeEmployee();
            collegeEmployee.setId("学院员工的id="+i); //添加学院员工
            collegeEmployeeArrayList.add(collegeEmployee);
        }
        return collegeEmployeeArrayList;
    }

}
//学校员工管理类
class SchoolManger {
    //生成学校的员工
    public List<SchoolEmployee> getSchoolEmployee() {
        ArrayList<SchoolEmployee> employeeArrayList = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            SchoolEmployee employee = new SchoolEmployee();
            employee.setId("学校的员工id=" + i);
            employeeArrayList.add(employee);
        }
        return employeeArrayList;
    }

    //输出学校员工和学院员工信息
    public void printAllEmployee(CollegeManger collegeManger) {
        //获取到学校员工
        List<SchoolEmployee> employeeArrayList = this.getSchoolEmployee();
        System.out.println("--------学校员工--------");
        for (SchoolEmployee employee1 : employeeArrayList) {
            System.out.println(employee1.getId());
        }

        System.out.println("--------学院员工--------");
        List<CollegeEmployee> collegeEmployees = collegeManger.getCollegeEmployee();
        //此处学校管理类中出现CollegeEmployee,此类与SchoolManger并非直接朋友,不合理
        for (CollegeEmployee collegeEmployee : collegeEmployees) {
            System.out.println(collegeEmployee.getId());
        }

    }
}
public class Demeter {

    public static void main(String[] args) {
             new SchoolManger().printAllEmployee(new CollegeManger());
    }
}

/*
  学校员工类
 */
class SchoolEmployee{
    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 CollegeManger{
    //生成学员所有的员工
    public List<CollegeEmployee> getCollegeEmployee(){
        ArrayList<CollegeEmployee> collegeEmployeeArrayList = new ArrayList<>();
        for (int i = 0; i <10 ; i++) {
            CollegeEmployee collegeEmployee = new CollegeEmployee();
            collegeEmployee.setId("学院员工的id="+i); //添加学院员工
            collegeEmployeeArrayList.add(collegeEmployee);
        }
        return collegeEmployeeArrayList;
    }

    public void printCollegeEmployee(){
        List<CollegeEmployee> collegeEmployee = getCollegeEmployee();
        for (CollegeEmployee employee : collegeEmployee) {
            System.out.println("学员员工id="+employee.getId());
        }

    }

}
//学校员工管理类
class SchoolManger {
    //生成学校的员工
    public List<SchoolEmployee> getSchoolEmployee() {
        ArrayList<SchoolEmployee> employeeArrayList = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            SchoolEmployee employee = new SchoolEmployee();
            employee.setId("学校的员工id=" + i);
            employeeArrayList.add(employee);
        }
        return employeeArrayList;
    }

    //输出学校员工和学院员工信息
    public void printAllEmployee(CollegeManger collegeManger) {
        //获取到学校员工
        List<SchoolEmployee> employeeArrayList = this.getSchoolEmployee();
        System.out.println("--------学校员工--------");
        for (SchoolEmployee employee1 : employeeArrayList) {
            System.out.println(employee1.getId());
        }

        //CollegeManger与SchoolManger是直接朋友,相互之间访问
        System.out.println("--------学员员工-----------");
                collegeManger.printCollegeEmployee();
    }
}

  • 组合/聚合复用原则（优先使用组合，使系统更灵活，其次才考虑继承，达到复用的目的）

代码实现：

/*
   组合/聚合复用原则案例1  使用依赖实现复用
 */
public class A {

    public void method01() {
    }

    public void method02() {
    }
}


class B extends A {
    private A a;

    public void method() {
    }
}

class Test {
    public static void main(String[] args) {
        new B().method01();
        new B().method02();
    }
}
/*
   组合/聚合复用原则案例2  使用组合/聚合实现复用
 */
public class A {

      public void method01(){
      }

      public void method02(){
      }
}


class B{

     A a;

     public void setA(A a){
         this.a = a;
     }

     public void use(){
         a.method01();
         a.method02();
     }

}

class Test{
    public static void main(String[] args) {
         A a = new A();
         B b = new B();
         b.setA(a);
         b.use();
    }
}

/*
   组合/聚合复用原则案例3  使用依赖实现复用
 */
public class A {

      public void method01(){
      }

      public void method02(){
      }
}


class B{
     public void use(A a){
         a.method01();
         a.method02();
     }


}

class Test{
    public static void main(String[] args) {
         A a = new A();
         B b = new B();
         b.use(a);
    }
}

面向对象设计模式概述
Anna_0110的博客
02-10 174
一、面向对象三大机制： 封装：隐藏内部实现 继承：复用现有代码 多态：改写对象行为二、面向对象设计模式： 面向对象设计模式解决的是类与相互通信的对象之间的组织关系。三、面向对象设计原则： 针对接口编程，而不是针对实现编程 优先使用对象组合，而不是类继承 封装变化点四、具体的设计原则： 单一职责原则（SRP）：一个类应该仅有一个引起它变化的原...
【设计模式】面向对象的设计模式概述
最新发布
OpenSeek的博客
03-27 1155
设计模式的灵感源于建筑领域。1977年，Christopher Alexander在《A Pattern Language》中提出253个建筑模式，强调“环境条件 - 目标问题 - 解决方案”的通用范式。1994年，GoF（四人组）将模式思想引入软件工程，出版《设计模式：可复用面向对象软件的基础》，总结23种经典模式（不包含简单工厂模式），奠定了现代软件设计的基础。设计模式是前辈们对面向对象编程设计中反复出现的问题总结的一套解决方案，是一种共享专家设计经验的总结。
面向对象程序的设计模式
weixin_34082854的博客
07-02 106
设计模式很难定义，通俗来说，就像是写作文的套路。程序员在程序设计总结了很多开发经验，就形成了设计模式。其实在有了框架之后，不会去开发完整的应用，设计模式的重要性降低了很多。 基本思想：1.将变化的和不变的部分分开，在修改和维护时只需要改动变化的部分。 具体方式： 1.类继承是oop中的三大特点之一，可以实现代码复用，并且代码层次更清晰，但是继承会使类的耦合度变高，简单来说，一个类的改...
面向对象 之 设计模式
狗老板的博客
03-01 863
面向对象设计模式，设计模式解释，设计模式分类，
C#面向对象设计模式纵横谈（视频与源码）
05-08
C#面向对象设计模式纵横谈(1)：面向对象设计模式与原则 C#面向对象设计模式纵横谈(2)：Singleton 单件(创建型模式) C#面向对象设计模式纵横谈(3)：Abstract Factory 抽象工厂模式(创建型模式) C#面向对象设计...
C++ 21种面向对象设计模式源代码.zip
01-23
面向对象设计模式是软件开发中的一种重要思想，它提供了一种在特定场景下解决常见问题的标准模板。在C++编程中，21种经典的设计模式是每个专业开发者必须掌握的知识。这个压缩包“C++ 21种面向对象设计模式源代码....
PHP面向对象设计模式详解
10-03
内容概要：本文详细阐述了23种PHP面向对象设计模式，包括但不限于工厂模式、单例模式、建造者模式、原型模式、适配器模式等。每种模式均配有UML类图和相应的PHP示例代码。并通过具体生活中的实例来辅助理解每种模式...
《C#面向对象设计模式纵横谈》.pdf
08-13
### C#面向对象设计模式知识点解析 #### 面向对象设计模式与原则 面向对象设计模式（OOP Design Patterns）是软件工程中用于解决常见设计问题的一种方案，目的是使软件更加可复用、灵活和易于维护。C#作为一门支持...
PHP面向对象设计模式
06-08
本系列教程围绕"PHP面向对象设计模式"展开，旨在帮助读者深入理解和应用面向对象设计原则，构建出易于扩展、高度复用的项目框架。 1. **设计模式基础**：设计模式是对软件设计中常见问题的通用解决方案，它们并不...
面向对象设计模式
偶是不器的博客
04-11 178
设计模式 设计模式是一类问题的最佳解决方法，是面向对象编程人员经过长期总结改良出来的工程化的代码模块。 设计模式类型 这些模式可以分为三大类：创建型模式(Creational Patterns)、结构型模式(Structural Patterns)、行为型模式(Behavioral Patterns)。 创建型模式：将创建对象的逻辑隐藏起来，不使用new新建对象。包含设计...
Java jsp设计模式
jeanboy
11-14 1256
JavaWeb技术之--面向对象设计模式 面向对象设计模式 面向对象软件开发领域中，设计模式包括一些规则来完成一定任务。设计模式针对一些特定的问题，提出一种解决方案。 常用的面向对象设计模式有4种： Factory模式、Singleton模式、Facade模式和MVC架构模式。 JSP设计模式 SUN公司推出JSP技术后，同时也推荐了两种web应用程序的开发模式，一种是JSP+Java...
十分钟了解21种设计模式
小明同学
01-08 771
装饰模式 装饰模式是给一个已有的功能动态的添加更多的功能的一种方式 - 使用场景: 当需要向旧的类中添加新的代码，而新的代码只是用于装饰类原本的核心职责，这种情况下就可以使用装饰模式 例如： ​ 当需要进行数据持久化操作时，需要先对数据进行过滤和加密，这个功能的核心职责就是数据持久化而过滤和加密属于装饰功能 - 模式优点： 将类的核心职责与类的装饰功能区分开，并且可以去除相关类的中的重复的装饰逻辑 代理模式 代理模式就是在就访问对象时增加一定的间接性，这种间接性可以有多种用途，由代理对象去执行真实对
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

吃橘子的Crow

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

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

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

打赏作者

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

抵扣说明：

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

余额充值