设计模式——Day01

最新推荐文章于 2024-10-06 09:57:54 发布
最新推荐文章于 2024-10-06 09:57:54 发布
阅读量244 收藏
点赞数
文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44289860/article/details/107958074
版权

设计模式 Day 01

文章总结自B站尚硅谷视频

1. 什么是设计模式

设计模式（design pattern）是对软件设计中普遍存在（反复出现）的问题，题出的解决方案。
优势（目的）：

  1. 可扩展性：添加新的功能时比较方便；
  2. 可读性：代码规范，方便其它程序员理解；
  3. 可重用性：相同功能的代码不需要多次编写；
  4. 可靠性：新增或者减少功能对原有的功能没有影响；
  5. 模块内部聚合性高，对其它模块的依赖（耦合）低。

2. 设计模式的七大原则

2.1 单一职责原则

对类来说，一个类只负责一项职责。
作用：

  1. 降低类的复杂度；
  2. 提高可读性，可维护性；
  3. 降低改变引起的风险；
  4. 一般情况下需要在类的级别上遵守单一职责，但是如果方法足够少，逻辑足够简单，可以在方法上遵守单一原则。

没有遵守单一职责原则：飞机和轮船是不能在公路上运行的。

/**
 * @date 2020/8/13 14:04
 * 单一职责原则01
 */
public class SingleResponsibility01 {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("小汽车");
        vehicle.run("轮船");
        vehicle.run("飞机");
    }
}


// 方式1：
//  上面调用run方法违反了单一职责原则。
//  解决方案：根据交通工具的不同分解成不同的类。

/**
 * 交通工具类
 */
class Vehicle{
    public void  run(String vehicle){
        System.out.println(vehicle+"   在公路上运行......");
    }
}

遵守了单一职责原则，但是过于臃肿。

/**
 * @date 2020/8/13 14:10
 * 单一职责原则02
 */
public class SingleResponsibility02 {
    public static void main(String[] args) {
        RoadVehicle roadVehicle = new RoadVehicle();
        roadVehicle.run("小汽车");

        AirVehicle airVehicle = new AirVehicle();
        airVehicle.run("飞机");

        WaterVehicle waterVehicle = new WaterVehicle();
        waterVehicle.run("轮船");
    }
}


// 方案2：
//    优点：遵守了单一职责原则
//    缺点：改动很大，
//    改进方案：直接修改原先的Vehicle类。


/**
 * 陆地交通工具类
 */
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+"    在水里走......");
    }
}

在方法中遵守的单一职责的原则。

/**
 * @date 2020/8/13 14:17
 * 单一职责原则03
 */
public class SingleResponsibility03 {
    public static void main(String[] args) {
        Vehicle02 vehicle02 = new Vehicle02();
        vehicle02.run("小汽车");
        vehicle02.runAir("飞机");
        vehicle02.runWater("轮船");
    }
}


// 方式3：
//  优点：没有对原来的类做大的修改
//  缺点：这里虽然没有在类级别上遵守单一职责原则，但是在方法上仍然遵守了。

class Vehicle02{
    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+"在水中中");
    }
}

2.2 接口隔离原则

客户端不因该依赖它不需要的接口，一个类对另一个类的依赖应该建立在最小的接口上。也就是说，如果一个类要依赖另一个类实现的接口，这个接口里面有用不到的方法，应该将这个接口分解成多个接口。
案例：有AB两个类，需要通过CD两个类的实现去调用接口interface1里面的方法，但是A只需要调用operation1、operation1、operation3，B只需要调用operaction1、operation4、operation5。
如果直接让CD两个类去实现interface1里面全部的方法，那么AB两个类就必须也要继承全部的方法，有违接口隔离原则。
这个是没有分离接口的

/**
 * @date 2020/8/13 14:41
 * 接口隔离01
 */
public class Segregation01 {
    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.depend4(new D());
        c.depend5(new D());
    }
}

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


class B implements Interface1{

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

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

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

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

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

class D implements Interface1{

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

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

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

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

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

// A 通过interface1 引用 B类的 123 方法
class A{
    public void depend1(Interface1 interface1){
        interface1.operation1();
    }
    public void depend2(Interface1 interface1){
        interface1.operation2();
    }
    public void depend3(Interface1 interface1){
        interface1.operation3();
    }
}

// C 通过interface1 引用 C类的 145 方法
class C{
    public void depend1(Interface1 interface1){
        interface1.operation1();
    }
    public void depend4(Interface1 interface1){
        interface1.operation4();
    }
    public void depend5(Interface1 interface1){
        interface1.operation5();
    }
}

解决方案：interface1接口分解成三个接口，分别有operation1方法的interface1接口，operation2、operation3方法的interface2接口以及opercation4、operation5方法的interface3接口。让CD分别继承interface1、interface2和interface1、interface3。

将接口分离的：
分离接口之后的

/**
 * @date 2020/8/13 14:55
 * 接口隔离原则02
 */
public class Segregation02 {
    public static void main(String[] args) {
        A1 a1 = new A1();
        a1.depend1(new B1());
        a1.depend2(new B1());
        a1.depend3(new B1());

        C1 c1 = new C1();
        c1.depend1(new D1());
        c1.depend4(new D1());
        c1.depend5(new D1());
    }
}

interface Interface01{
    void operation1();
}

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

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

class B1 implements Interface01,Interface02{

    public void operation1() {
        System.out.println("B1 实现 operation1");
    }

    public void operation2() {
        System.out.println("B1 实现 operation2");
    }

    public void operation3() {
        System.out.println("B1 实现 operation3");
    }
}

class D1 implements Interface01,Interface03{

    public void operation1() {
        System.out.println("D1 实现 operation1");
    }

    public void operation4() {
        System.out.println("D1 实现 operation4");
    }

    public void operation5() {
        System.out.println("D1 实现 operation5");
    }
}

class A1{
    public void depend1(Interface01 interface1){
        interface1.operation1();
    }
    public void depend2(Interface02 interface1){
        interface1.operation2();
    }
    public void depend3(Interface02 interface1){
        interface1.operation3();
    }
}


class C1{
    public void depend1(Interface01 interface1){
        interface1.operation1();
    }
    public void depend4(Interface03 interface1){
        interface1.operation4();
    }
    public void depend5(Interface03 interface1){
        interface1.operation5();
    }
}

优势：

  1. 可读性高，可维护性高；
  2. 符合高内聚，低耦合。

2.3 依赖倒转（倒置）原则

  1. 高层模块不依赖低层模块，二者都应该依赖其抽象；。
  2. 抽象不应该依赖细节，细节依赖抽象。
  3. 核心思想是面向接口编程。
  4. 设计理念：相较于细节的多变性，抽象的东西要相对稳定的多。在Java中以接口或者抽象类搭建的架构要比使用实现类为基础搭建的架构要稳定的多。
  5. 使用接口和抽象类的目的是指定规范，价值在于设计，具体的操作让实现类去完成。

案例：使用person类接收发来的信息。
方法1：

/**
 * @date 2020/8/13 15:26
 * 依赖倒置
 */
public class DependencyInversion01 {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
    }
}

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

// 方式1：
//   优势：简单
//   缺点：现在只能接收电子邮件，如果有其它的短信就需要增加类，person也增加相应的方法。
class Person{
    public void receive(Email email){
        System.out.println(email.getInfo());
    }
}

方式2：

/**
 * @date 2020/8/13 15:36
 * 依赖倒置
 */
public class DependencyInversion02 {
    public static void main(String[] args) {
        Person1 person1 = new Person1();
        person1.receiver(new Email2());
        person1.receiver(new WeiChat());
    }
}

// 接收者接口
interface IReceiver{
    String getInfo();
}

class Email2 implements IReceiver{

    public String getInfo() {
        return "电子邮件：Hello";
    }
}

class WeiChat implements IReceiver{

    public String getInfo() {
        return "微信消息：Hello";
    }
}

class Person1{
    public void receiver(IReceiver iReceiver){
        System.out.println(iReceiver.getInfo());
    }
}

显而易见，如果使用方式1，有新的业务就必须添加新的业务的类以及person类对应的方法。在方式2中，如果有新的业务就只需要添加业务类继承接口。

依赖传递的三种方式：

  1. 接口
  2. 构造方法
  3. setter

注意事项：底层模块尽量都要有抽象类或接口，变量的生命类型尽量是抽象类或接口，这样变量引用和实际对象之间有一个缓冲层，利于程序的扩展和优化。在继承时要遵守里氏替换原则。

2.4 里氏替换原则

引用基类的地方必须能够透明的引用其子类的对象。在子类中尽量不要重写父类的方法。在适当的情况下可以通过聚合，组合，依赖来解决问题。

/**
 * @date 2020/8/14 9:54
 * 里氏替换原则
 */
public class Liskov01 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println("11-3 = "+a.fun1(11, 3));
        System.out.println("1-8 = "+a.fun1(1, 8));

        System.out.println("-------------------------------");
        B b = new B();
        System.out.println("11-3 = "+b.fun1(11,3));
        System.out.println("11+4+9 = "+b.fun2(11,4));
    }
}

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

// B
class B extends A{
    @Override
    public int fun1(int num1, int num2){
        return num1+num2;
    }
    public int fun2(int a, int b){
        return fun1(a,b)+9;
    }
}

上方的代码中B继承了A类，同时也复写了A类中fun1的方法，导致想要的结果与预期不符。


/**
 * @date 2020/8/14 10:03
 * 里氏替换原则02
 */
public class Liskov02 {
    public static void main(String[] args) {
        A1 a = new A1();
        System.out.println("11-3 = "+a.fun1(11, 3));
        System.out.println("1-8 = "+a.fun1(1, 8));

        System.out.println("-------------------------------");
        B1 b = new B1();
        System.out.println("11-3 = "+b.fun1(11,3));
        System.out.println("11+4+9 = "+b.fun2(11,4));
    }
}

// 创建一个更加基础的类
class Base{
//    将基础的方法都写在这个类中
}

// A1
class A1 extends Base{
    public int fun1(int num1, int num2){
        return num1-num2;
    }
}

// B1
class B1 extends Base {
 //   B1需要使用A1的方法：
//    1. 组合
    private A1 a = new A1();
//    调用A的方法
    public int fun3(int num1, int num2){
        return a.fun1(num1,num2);
    }

    public int fun1(int num1, int num2){
        return num1+num2;
    }
    public int fun2(int a, int b){
        return fun1(a,b)+9;
    }

}

解决方案是编写一个更加基础的类Base来添加基础的方法，让AB都继承基础类Base。如果B中要使用A的方法就可以使用组合的方式：实例化A，使用实例化的对象去调用A中的方法。

2.5 开闭原则

是编程中最基础最重要的原则，一个软件实体应该对扩展开放（对提供方而言），对修改关闭（对使用方而言）。用抽象构建框架，用实现扩展细节。当软件变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码实现。遵循其它原则以及使用设计模式的目的就是遵循开闭原则。
案例：有一个绘制图形的类，根据类型绘制不同的图形。

/**
 * @date 2020/8/14 14:34
 * ocp 开闭原则
 */
public class Ocp01 {
    public static void main(String[] args) {
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Circle());
        graphicEditor.drawShape(new Triangle());
    }
}

// 绘图类
class GraphicEditor{
    public void drawShape(Shape shape){
//        接收Shape 根据类型 绘制不同的形状
        if (shape.m_type == 1){
            drawRectangle(shape);
        }
        else if(shape.m_type == 2){
            drawCircle(shape);
        }else if (shape.m_type == 3){
            drawTirRectangle(shape);
        }
    }
    public void drawRectangle(Shape r){
        System.out.println("矩形");
    }
    public void drawCircle(Shape r){
        System.out.println("圆形");
    }
    public void drawTirRectangle(Shape shape){
        System.out.println("三角形");
    }
}
class Shape{
    int m_type = 0;
}
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;
    }
}

根据上面代码来说，如果想要绘制圆柱，那么就需要添加一个圆柱类来基础Shape类，而且要修改绘制方法里面的代码。有违ocp的对提供方可扩展，对调用方不能修改的原则。
改进：

/**
 * @date 2020/8/14 14:48
 */
public class Ocp02 {
    public static void main(String[] args) {
        GraphicEditor1 graphicEditor = new GraphicEditor1();
        graphicEditor.drawShape(new Rectangle1());
        graphicEditor.drawShape(new Circle1());
        graphicEditor.drawShape(new Triangle1());
        graphicEditor.drawShape(new OtherGraphic());
    }
}

// 绘图类
class GraphicEditor1{
    public void drawShape(Shape1 shape){
        shape.draw();
    }
}
abstract class Shape1{

//    抽象方法
    public abstract void draw();
}
class Rectangle1 extends Shape1{
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}
class Circle1 extends Shape1{
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}
class Triangle1 extends Shape1{
    @Override
    public void draw() {
        System.out.println("绘制三角形");
    }
}
class OtherGraphic extends Shape1{
    @Override
    public void draw() {
        System.out.println("绘制其它图形");
    }
}

这样改进之后如果要新增图像，只需要将图形类继承shape类复写draw方法即可。遵循了ocp原则。

2.6 迪米特法则

核心是降低类之间的耦合！一个对象应该与其它对象保持最少的了解。 将实现写在自己的类中，不要将逻辑一类的写在其它的类中。
没有遵循迪米特法则：

/**
 * @date 2020/8/14 19:28
 * 迪米特法则
 */
public class Demeter01 {
    public static void main(String[] args) {
        SchoolManager schoolManager = new SchoolManager();
        schoolManager.printAllEmployee(new CollegeManager());
    }
}

// 学校总部员工
class Employee{
    private String id;

    public String getId() {
        return id;
    }

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

// 学院员
class CollegeEmployee{
    private String id;

    public String getId() {
        return id;
    }

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

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

// 管理学校总部员工
class SchoolManager{
    public List<Employee> getAllEmployee(){
        ArrayList<Employee> collegeEmployees = new ArrayList<Employee>();
        for (int i = 0; i < 5; i++) {
            Employee employee = new Employee();
            employee.setId("学校总部员工id："+i);
            collegeEmployees.add(employee);
        }
        return collegeEmployees;
    }

//   完成输出学院和学校员工。
    public void printAllEmployee(CollegeManager collegeManager){
//        这里的CollegeEmployee类并不是直接朋友，而是以成员变量的形式出现在这里。
        List<CollegeEmployee> allEmployee = collegeManager.getAllEmployee();
        System.out.println("-------学院员工-----");
        for (CollegeEmployee collegeEmployee : allEmployee) {
            System.out.println(collegeEmployee.getId());
        }
        List<Employee> allEmployee1 = this.getAllEmployee();
        System.out.println("----学校总部员工-----");
        for (Employee employee : allEmployee1) {
            System.out.println(employee.getId());
        }
    }
}

遵循迪米特法则：

/**
 * @date 2020/8/14 19:43
 * 迪米特法则02
 */
public class Demeter02 {
    public static void main(String[] args) {
        SchoolManager1 schoolManager = new SchoolManager1();
        schoolManager.printSchoolEmployee(new CollegeManager1());
    }
}

// 学校总部员工
class Employee1{
    private String id;

    public String getId() {
        return id;
    }

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

// 学院员
class CollegeEmployee1{
    private String id;

    public String getId() {
        return id;
    }

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

// 管理学院员工
class CollegeManager1{
    public List<CollegeEmployee1> getAllEmployee(){
        ArrayList<CollegeEmployee1> collegeEmployees = new ArrayList<CollegeEmployee1>();
        for (int i = 0; i < 10; i++) {
            CollegeEmployee1 collegeEmployee = new CollegeEmployee1();
            collegeEmployee.setId("学院员工id："+i);
            collegeEmployees.add(collegeEmployee);
        }
        return collegeEmployees;
    }
    public void printCollegeEmployee(){
        List<CollegeEmployee1> allEmployee = this.getAllEmployee();
        System.out.println("-------学院员工-----");
        for (CollegeEmployee1 collegeEmployee : allEmployee) {
            System.out.println(collegeEmployee.getId());
        }

    }
}

// 管理学校总部员工
class SchoolManager1{
    public List<Employee1> getAllEmployee(){
        ArrayList<Employee1> collegeEmployees = new ArrayList<Employee1>();
        for (int i = 0; i < 5; i++) {
            Employee1 employee = new Employee1();
            employee.setId("学校总部员工id："+i);
            collegeEmployees.add(employee);
        }
        return collegeEmployees;
    }

    //   完成输出学院和学校员工。
    public void printSchoolEmployee(CollegeManager1 collegeManager){
        collegeManager.printCollegeEmployee();
        List<Employee1> allEmployee1 = this.getAllEmployee();
        System.out.println("----学校总部员工-----");
        for (Employee1 employee : allEmployee1) {
            System.out.println(employee.getId());
        }
    }
}

2.7 合成复用原则

尽量使用合成/聚合的方式，而不是继承。
案例：B类需要使用A类的方法。
解决方案：

  1. 继承：可以直接复写和使用A类方法，但是B对A的耦合高！
  2. 依赖：在B类中的方法里面传递A的参数public void getA(A a){ System.out.println("依赖"); }。
  3. 聚合：在B中添加A类型的属性private A a;。
  4. 合成： 在B中添加A的对象实例A a = new A();。

to do…

2.8 总结

设计原则的核心思想：

  1. 找出应用之间可能需要变化的地方，把他们与不需要变化的地方分开；
  2. 针对接口编程；
  3. 解耦合！
江海i
关注
专栏目录
Python 程序设计——day11——文件和文件夹的操作
cumt_zhj的博客
07-17 489
本文主要介绍了 Python 中文件及文件夹操作的原理和方法，包括文件的打开、读写、关闭、备份、删除、重命名等，以及文件夹的创建、修改与删除等
Python程序设计——day4——条件判断语句与异常处理
cumt_zhj的博客
07-03 783
本文主要介绍 Python 语言中的 if 条件判断语句和异常情况处理等相关概念及用法
Java基础第七章 面向对象编程（基础）（章节练习）
a2649432564的博客
11-07 608
（1）编写类A01，定义方法max实现求某个double数组的最大值，并返回 public class Homework01{ public static void main(String[] args){ A01 m = new A01(); double[] arr = {1.2,1.5,3.6,2.5}; Double res = m.max(arr); if(res != null){ System.o
Java-反射
Leetp
04-29 345
什么是反射？通过反射可以在运行时获得程序或程序集中每一个类型的成员和成员的信息。程序中一般的对象的类型都是在编译期就确定下来的，而Java反射机制可以动态地创建对象并调用其属性，这样的对象的类型在编译期是未知的。所以我们可以通过反射机制直接创建对象，即使这个对象的类型在编译期是未知的。 反射的核心是JVM在运行时才动态加载类或调用方法/访问属性，它不需要事先（写代码的时候或编译期）知道运行对象是谁...
ParamStr 使用释义
小菜的专栏
10-15 1597
ParamStr 使用释义 比如命令行：C:/Test/MyApp.exe \- w 那么： ParamStr[0] = 'C:/Test/MyApp.exe' ParamStr[1] = '\- w' =============================
java课程实验九内容一
醉卧考场君莫笑
11-04 492
文章目录前言一.1.具体要求2.我的思路注意事项与总结 前言 记录本菜鸡写实验过程出现的问题，各路大神多指教，找出问题直接就评论，我不胜受恩感激。 一. 1.具体要求 使用Scanner类实现从键盘输入一位（或多位）同学的数学、物理、 英语三门课的成绩(用nextLine（）一次读入一行，然后用split（）方法 分解字符串)，计算并输出该同学三门课的平均成绩。 2.我的思路 首先得确定输入的是什么，输入的是同学的名字，然后三门课的成绩： 例如以下用例： 社会你超姐 100 100 100 这样.
Java之方法篇
weixin_52598191的博客
02-07 69
本博客讲的方法为Java的核心部分。务必认真体会。
设计模式——工厂模式
vincewm的博客
04-29 1956
工厂模式介绍、静态简单工厂模式、工厂方法模式、抽象工厂模式、JDK 源码分析
23种设计模式——状态模式
qq_51165184的博客
05-11 3193
状态模式本质：根据状态来分离和选择行为。状态驱动，上下文负责
JavaWeb（上）——day02.zip
08-23
在"JavaWeb（上）——day02.zip"这个压缩包中，我们很可能会看到一个初步的JavaWeb项目结构，用于教学或实践目的。下面将详细介绍这些关键知识点： 1. **MyEclipse**：MyEclipse是一款强大的集成开发环境（IDE），...
毕业设计——基于监督学习的web入侵检测系统（0day收集器）.zip
03-15
【标题】：“毕业设计——基于监督学习的web入侵检测系统（0day收集器）.zip” 这个毕业设计项目聚焦于构建一个基于监督学习的Web入侵检测系统，特别强调了0day攻击的检测能力。0day攻击是指那些还未被公开或未知的...
多线程设计模式——Pipeline(流水线)模式
热门推荐
buyoufa的博客
07-14 2万+
Pipeline(流水线)模式
JDK新特性--lambda
m0_45307937的博客
12-04 511
1.lambda表达式 1.格式: (参数类型 参数名称) ->{ 方法体; return 返回值; } 2.省略规则 小括号中的参数类型可以省略。 如果小括号中只有一个参数，那么可以省略小括号。 如果大括号中只有一条语句，那么可以同时省略大括号、return关键字及语句分号。 eg: new Thread(() ->{ System.out.println("Lambda表达式执行了"); }).start(); 方法体： 可以是表达式也可...
python中b类调用a类的方法_Python：从类B中的类A调用方法A？
weixin_35149268的博客
03-01 385
有很多问题与此类似，但没有一个答案是正确的，所以请你接受我。在我正在努力学习使用Python的OOP，但是我不断地遇到错误(比如这一个)，这让我觉得这是毫无意义的，而且只使用方法会更容易。在这是我的代码：class TheGUI(wx.Frame):def __init__(self, title, size):wx.Frame.__init__(self, None, 1, title, siz...
Prototype(原型模式)
TimerSea的博客
10-06 516
本篇介绍了原型设计模式基础与实现示例
设计模式-模版方法模式
ZSS1753936255的博客
10-04 625
模版方法模式(Template Method):定义一个操作中的算法骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重新定义算法的某些定义步骤。抽象类：负责实现一个算法的骨架，他是由一个final修饰的模版方法和若干个基本方法组成的。
设计模式-适配器模式
最新发布
m0_45164511的博客
10-06 558
适配器模式（Adapter Pattern）属于结构型设计模式，它的作用是。适配器让原本由于接口不兼容而不能一起工作的类可以协同工作。适配器模式包括三个角色：目标抽象类（Target）、适配器类（Adapter）和被适配者类（Adaptee）。适配器模式在实际开发中非常常见，比如我们经常需要连接各种不同的数据库，每种数据库都有自己独特的接口和方法。如果我们希望写出一段通用的代码，能够连接到任何一种数据库并执行相同的操作，那么适配器模式就非常适合解决这个问题。
设计模式之原型模式(通俗易懂--代码辅助理解【Java版】）
qq_45929019的博客
10-04 1117
创建型模式：工厂方法、抽象方法、建造者、原型、单例。结构型模式有：适配器、桥接、组合、装饰器、外观、享元、代理。行为型模式有：责任链、命令、解释器、迭代器、中介、备忘录、观察者、状态、策略、模板方法、访问者。常用设计模式：单例模式、工厂模式、代理模式、策略模式&模板模式、门面模式、责任链模式、装饰器模式、组合模式、builder模式。这种情况就是浅拷贝，java只拷贝你指定的对象，至于你指定的对象里面的别的对象，它不拷贝，还是把引用给你，共享变量，这是一种非常不安全的方式，需要特别注意。
设计模式-原型模式
ZSS1753936255的博客
10-02 599
设计模式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值