JavaSE@拓展补遗@笔记20@java中的几种常用设计模式

开发的原则

开发尽量要：
    高内聚，低耦合
    耦合：各个代码之间互相的联系。
    内聚：代码自己内部解决问题的能力。

继承：
    优点：
        提高代码的复用性。是多态的前提。
    缺点：
        提高了耦合。

一、单例设计模式

1、作用

如果一个类只允许创建一个对象，那么就可以使用单例设计模式。

2、实现步骤

1. 把构造方法私有化

2. 类的内部自己创建一个对象

3. 提供一个公共的方法获取这个对象

3、代码实现

饿汉式

饿的意思就是饥饿，不管有没有人获取，都提前创建对象。

浪费内存空间，获取对象速度快

public class Student {
    //把构造方法私有化
    private Student(){}
​
    //类的内部自己创建一个对象
    private static Student s = new Student();
​
    //提供一个公共的方法获取这个对象
    public static Student getInstance() {
        return s;
    }
}

懒汉式

懒就是懒惰，什么时候获取对象，什么时候再创建。

节约内存空间，减慢对象获取速度

public class Student2 {
​
    //构造方法私有化
    private Student2(){}
​
    //定义学生对象
    private static Student2 s = null;
​
    //获取的方法
    //静态同步方法的锁对象是当前类的.class字节码对象
    public static synchronized Student2 getInstance(){
        //做判断,判断对象是否已经创建
        if(s == null){
            s = new Student2();
        }
​
        return s;
    }
}

测试类

public class Test01 {
    public static void main(String[] args) {
​
        //获取学生对象
        Student s1 = Student.getInstance();
        Student s2 = Student.getInstance();
        Student s3 = Student.getInstance();
​
        //不管获取多少次获取的都是同一个对象
    }
}

二、多例设计模式

1、作用

一个类要创建指定固定个数的多个对象。

2、代码演示

import java.util.ArrayList;
import java.util.Random;
//多例模式
public class Student3 {
    //构造方法私有化
    private Student3(){}
​
    //定义集合存储多个对象
    private static ArrayList<Student3> list = new ArrayList<>();
​
    //静态代码块 只会执行一次
    static{
        //创建对象放在集合中
        list.add(new Student3());
        list.add(new Student3());
        list.add(new Student3());
    }
​
    //定义获取对象的方法
    public static Student3 getInstance(){
        //随机获取集合中的一个对象返回
        Random r = new Random();
        //获取随机索引
        int i = r.nextInt(list.size());
        //返回获取到的对象
        return list.get(i);
    }
}
​
​

public class Test02 {
    public static void main(String[] args) {
​
        //获取10次学生对象
        for (int i = 0; i < 10; i++) {
            Student3 s = Student3.getInstance();
            System.out.println(s);
        }
        //效果：打印的10个对象地址值一共只有3个。
    }
}

三、工厂设计模式

工厂模式 | 菜鸟教程 (runoob.com)

1、介绍：

工厂模式定义:提供创建对象的接口

工厂是专门来创造东西的，工厂的作用就是专业的人来干专业的事儿，提高管理效率。

2、代码演示

​

//父类
public class Car{
}
//一堆子类
public class BenZ extends Car{
}
public class BWM extends Car{
}
public class QQ extends Car{
}


//工厂类
public class Factory {
​
    //获取汽车的方法
    public static Car getCar(String name){
        //定义汽车变量
        Car c = null;
​
        if(name.equals("BenZ")){
            c =  new BenZ();
        }else if(name.equals("BWM")){
            c =  new BWM();
        }else if(name.equals("QQ")){
            c =  new QQ();
        }
​
        return c;
    }
}
​
​//测试类
public class Test01 {
    public static void main(String[] args) {
        //使用工厂创建对象
        Car c1 = Factory.getCar("BenZ");
​
        Car c2 = Factory.getCar("BWM");
    }
}
​

四、装饰设计模式

装饰器模式 | 菜鸟教程 (runoob.com)

1、概述

设计模式是程序开发的经验的总结。装饰模式就是对类型进行装饰，装饰的意思就是增强，在不改变原类的情况下，对一个类进行功能的增强。

装饰设计模式的使用前提是必须要有接口。

i/o流就是典型的装饰着模式，除了最底层功能，在基础上，封装了不同的流，都可以用最基本的对象接受new出来的不同的对象（多态）

2、装饰设计模式写法

1. 装饰类和被装饰类实现相同的接口
2. 装饰类中要定义被装饰类的对象，通过构造方法传入对象
3. 需要增强的方法自己完成
4. 不需要增强的方法调用原有的方法

3、代码演示

//明星
public interface Star {
    //方法
    public abstract void rap();
    //方法
    public abstract void playbasketball();
}
​
​
//被装饰类
public class StarCai implements Star {
    @Override
    public void rap() {
        System.out.println("鸡你太美~");
    }
​
    @Override
    public void playbasketball() {
        System.out.println("非常帅~~");
    }
}
​
​
//装饰类
public class BufferedCai implements Star {
​
    //成员变量
    private StarCai cai;
​
    //构造方法
    public BufferedCai(StarCai cai) {
        this.cai = cai;
    }
​
    //不需要增强的方法调用原来的方法
    @Override
    public void rap() {
        cai.rap();
    }
​
    //自己增强的方法
    @Override
    public void playbasketball() {
        System.out.println("啥也不是~~");
    }
}
​
​
public class Test {
    public static void main(String[] args) throws IOException {
        //创建增强类的对象
        BufferedCai bc = new BufferedCai(new StarCai());
        //调用方法
        bc.playbasketball();
        bc.rap();
        //缓冲流
        //讲装饰设计模式的目的是告诉你,缓冲流的底层用的就是装饰设计模式
        BufferedWriter bw = new BufferedWriter(new FileWriter("abc.txt"));
​
    }
}

五、适配器设计模式

适配器模式 | 菜鸟教程 (runoob.com)

1、概述

适配器模式定义: 将两个不兼容的类纠合在一起使用，属于结构型模式,需要有 Adaptee(被适配者)和 Adaptor(适配器)两个身份

2、适配器设计模式写法

我们经常碰到要将两个没有关系的类组合在一起使用,第一解决方案是：修改各自类的接口，但是如果我们没有源代码，或者，我们不愿意为了一个应用而修改各自的接口。

 使用Adapter，在这两种接口之间创建一个混合接口(混血儿).

3、代码演示

六、策略设计模式

策略模式 | 菜鸟教程 (runoob.com)

1、概述

在策略模式（Strategy Pattern）中一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。

在策略模式定义了一系列算法或策略，并将每个算法封装在独立的类中，使得它们可以互相替换。通过使用策略模式，可以在运行时根据需要选择不同的算法，而不需要修改客户端代码。

在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。

2、策略设计模式写法

我们经常碰到要将两个没有关系的类组合在一起使用,第一解决方案是：修改各自类的接口，但是如果我们没有源代码，或者，我们不愿意为了一个应用而修改各自的接口。

 使用Adapter，在这两种接口之间创建一个混合接口(混血儿).

3、代码演示

七、模板设计模式

模板模式 | 菜鸟教程 (runoob.com)

1、概述

在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。

2、模板设计模式写法

3、代码演示

八、代理设计模式

代理模式 | 菜鸟教程 (runoob.com)

Java设计模式（六）装饰器模式-与代理模式的区别-项目实战应用_代理模式和装饰器模式的区别-CSDN博客

1、概述

代理模式指给一个对象提供一个代理对象，并由代理对象控制对原对象的引用。代理可以分为静态代理和动态代理。

通过代理模式，可以利用代理对象为被代理对象添加额外的功能，以此来拓展被代理对象的功能。可以用于计算某个方法执行时间，在某个方法执行前后记录日志等操作。

1. 静态代理

静态代理需要我们写出代理类和被代理类，而且一个代理类和一个被代理类一一对应。代理类和被代理类需要实现同一个接口，通过聚合使得代理对象中有被代理对象的引用，以此实现代理对象控制被代理对象的目的。

2. 动态代理

JDK 1.3 之后，Java通过java.lang.reflect包中的三个类Proxy、InvocationHandler、Method来支持动态代理。动态代理常用于有若干个被代理的对象，且为每个被代理对象添加的功能是相同的（例如在每个方法运行前后记录日志）。

动态代理的代理类不需要我们编写，由Java自动产生代理类源代码并进行编译最后生成代理对象。

创建动态代理对象的步骤：

1. 指明一系列的接口来创建一个代理对象

2. 创建一个调用处理器（InvocationHandler）对象

3. 将这个代理指定为某个其他对象的代理对象

4. 在调用处理器的invoke（）方法中采取代理，一方面将调用传递给真实对象，另一方面执行各种需要的操作