31--设计模式、面向对象设计原则

1、设计模式

1.1 设计模式概述

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

设计模式不是一种方法和技术，而是一种思想。

设计模式和具体的语言无关，学习设计模式就是要建立面向对象的思想，尽可能的面向接口编程，低耦合，高内聚，使设计的程序可复用。

学习设计模式能够促进对面向对象思想的理解，反之亦然。它们相辅相成

简单一句话：设计模式就是经验的总结

设计模式的几个要素

名字：必须有一个简单，有意义的名字
问题描述：在何时使用模式
解决方案：描述设计的组成部分以及如何解决问题
效果：描述模式的效果以及优缺点设计模式的分类

设计模式的分类

创建型模式：对象的创建
结构型模式：对象的组成（结构）
行为型模式：对象的行为

创建型模式：简单工厂模式，工厂方法模式，抽象工厂模式，建造者模式，原型模式，单例模式。(6个)

结构型模式：外观模式、适配器模式、代理模式、装饰模式、桥接模式、组合模式、享元模式。(7个)

行为型模式：模版方法模式、观察者模式、状态模式、职责链模式、命令模式、访问者模式、策略模式、备忘录模式、迭代器模式、解释器模式。(10个)

1.2 单例模式详解

1.2.1 什么是单例设计模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

1.2.2 单例模式特点

1、单例类只能有一个实例。也就是只有一个对象

2、单例类必须自己创建自己的唯一实例。写单例构造方法是要私有的

3、单例类必须给所有其他对象提供这一实例。在该方法中，提供一个方法，用于获取该对象

1.2.3 单例设计模式实现前提条件

私有构造方法

在本类的成员位置,创建出自己类对象

提供公共方法,返回创建的对象，该方法必须是静态的

1.2.4 单例模式饿汉式

package com.suyv.singleton;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 10:46* @Description: 饿汉式单例模式*/
public class A {// 2.定义变量接收类的对象private static A a = new A();// 1.私有化构造器private A(){}// 3.定义静态方法返回类的对象public static A getInstance(){return a;}}

测试

package com.suyv.singleton;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 10:49* @Description: 饿汉式单例模式测试*/
public class ADemo01 {public static void main(String[] args) {A a1 = A.getInstance();A a2 = A.getInstance();System.out.println(a1);     // com.suyv.singleton.A@677327b6System.out.println(a2);     // com.suyv.singleton.A@677327b6System.out.println(a1 == a2);       // true}
}

1.2.5 单例模式懒汉式

package com.suyv.singleton;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 10:52* @Description: 懒汉式单例模式*/
public class B {// 2.定义静态变量接收创建的对象private static B b;// 1.私有化构造器private B(){}// 3.定义一个静态方法，第一次创建时才创建对象，后面调用都会返回这一个对象public static B getInstance(){if (b == null){b = new B();}return b;}
}

测试

package com.suyv.singleton;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 10:56* @Description: 懒汉式单例模式测试*/
public class BDemo01 {public static void main(String[] args) {B b1 = B.getInstance();B b2 = B.getInstance();System.out.println(b1);     // com.suyv.singleton.B@677327b6System.out.println(b2);     // com.suyv.singleton.B@677327b6System.out.println(b1 == b2);       // true}
}

1.2.6 单例设计模式的线程安全问题

1.2.6.1 饿汉式没有线程安全问题

饿汉式：在类初始化时就直接创建单例对象，而类初始化过程是没有线程安全问题的

1.2.6.2 懒汉式线程安全问题

问题出现：

package com.suyv.singleton;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 10:52* @Description: 懒汉式单例模式*/
public class B{// 2.定义静态变量接收创建的对象private static volatile B b;// 1.私有化构造器private B(){}// 3.定义一个静态方法，第一次创建时才创建对象，后面调用都会返回这一个对象public static B getInstance(){if (b == null){try {// 让问题暴露更加明显Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}b = new B();}return b;}
}

package com.suyv.singleton;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 10:56* @Description: 懒汉式单例模式线程安全测试*/
public class BDemo02 {static B b1 = null;static B b2 = null;public static void main(String[] args) {Thread t1 = new Thread(){@Overridepublic void run() {b1 = B.getInstance();}};Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {b2 = B.getInstance();}});t1.start();t2.start();try {t1.join();} catch (InterruptedException e) {e.printStackTrace();}try {t2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(b1);     // com.suyv.singleton.B@677327b6System.out.println(b2);     // com.suyv.singleton.B@14ae5a5System.out.println(b1 == b2);       // false}
}

解决方案：

package com.suyv.singleton;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 10:52* @Description: 懒汉式单例模式*/
public class B{// 2.定义静态变量接收创建的对象private static volatile B b;// 1.私有化构造器private B(){}// 3.定义一个静态方法，第一次创建时才创建对象，后面调用都会返回这一个对象/*public static B getInstance(){if (b == null){try {// 让问题暴露更加明显Thread.sleep(100);} catch (InterruptedException e) {throw new RuntimeException(e);}b = new B();}return b;}*/// 使用双重判断，效率更高public static B getInstance(){if (b == null){synchronized (B.class){if (b == null){b = new B();}}}return b;}
}

package com.suyv.singleton;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 10:56* @Description: 懒汉式单例模式线程安全测试*/
public class BDemo03 {static B b1 = null;static B b2 = null;public static void main(String[] args) {Thread t1 = new Thread(){@Overridepublic void run() {b1 = B.getInstance();}};Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {b2 = B.getInstance();}});t1.start();t2.start();try {t1.join();} catch (InterruptedException e) {e.printStackTrace();}try {t2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(b1);     // com.suyv.singleton.B@677327b6System.out.println(b2);     // com.suyv.singleton.B@677327b6System.out.println(b1 == b2);       // true}
}

解决程线安全问题

双层if判断的原因

方法中加入同步锁，保证线程安全
第二个线程调用方法getInstance()的时候，变量s，已经不是null，被前面的线程new过
当已经有对象了，第二个线程没有必要再进入同步了，直接return返回对象即可

单例模式的应用场景和好处

        Runtime

        任务管理器对象、获取运行时对象

        使用单例模式，可以避免资源浪费。

1.3 工厂模式

工厂设计模式，属于创建型，用于对象的创建；简单来说，就是专门生产对象的

1.3.1 简单工厂模式

package com.suyv.factory;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 11:26* @Description: 动物抽象类*/
public abstract class Animal {public abstract void eat();
}

package com.suyv.factory;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 11:27* @Description: 猫类*/
public class Cat extends Animal{@Overridepublic void eat() {System.out.println("猫吃鱼");}
}

package com.suyv.factory;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 11:28* @Description: 狗类*/
public class Dog extends Animal{@Overridepublic void eat() {System.out.println("狗吃骨头");}
}

package com.suyv.factory;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 11:29* @Description: 工厂设计类，这个类就是专门来生产对象，今后从这个工厂类中可以直接获取类对象*/
public class AnimalFactory {private AnimalFactory(){}public static Dog createDog(){return new Dog();}public static Cat creatCat(){return new Cat();}}

package com.suyv.factory;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 11:32* @Description: 工厂模式测试*/
public class AnimalTest {public static void main(String[] args) {// 工厂设计模式：//     优点：我可以直接通过工厂来获取对象//     缺点：如果要加对象，需要修改工厂类，不便于后期的维护// 使用工厂模式创建对象Cat cat = AnimalFactory.creatCat();Dog dog = AnimalFactory.createDog();// 调用方法cat.eat();dog.eat();}
}

1.3.2 实例工厂模式

package com.suyv.factory1;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 12:11* @Description: 创建一个接口*/
public interface Product {public void doSomething();
}

package com.suyv.factory1;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 12:12* @Description: 实现接口的实现类*/
public class ConcreteProduct implements Product{@Overridepublic void doSomething() {System.out.println("Doing something in ConcreteProduct");}
}

package com.suyv.factory1;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 12:14* @Description: 实例工厂类*/
public class ProductFactory {public Product createProduct(){return new ConcreteProduct();}}

package com.suyv.factory1;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 12:15* @Description: 实例工厂测试类*/
public class ProductTest {public static void main(String[] args) {ProductFactory factory = new ProductFactory();Product product = factory.createProduct();product.doSomething();}
}

1.3.3 静态工厂模式

package com.suyv.staticfactory;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 12:21* @Description: 定义一个咖啡类*/
public abstract class Coffee {public abstract String getName();//加糖public void addsugar() {System.out.println("加糖");}//加奶public void addMilk() {System.out.println("加奶");}
}

package com.suyv.staticfactory;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 12:22* @Description: 美式咖啡*/
public class AmericanCoffee extends Coffee{@Overridepublic String getName() {return "美式咖啡";}
}

package com.suyv.staticfactory;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 12:23* @Description: 拿铁咖啡*/
public class LatteCoffee extends Coffee{@Overridepublic String getName() {return "拿铁咖啡";}
}

package com.suyv.staticfactory;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 12:29* @Description: 咖啡工厂类--静态工厂*/
public class SimpleCoffeeFactory {public static Coffee createCoffee(String type) {//声明Coffee类型的变量，根据不同类型创建不同的coffee子类对象Coffee coffee = null;if("american".equals(type)) {coffee = new AmericanCoffee();} else if("latte".equals(type)) {coffee = new LatteCoffee();} else {throw new RuntimeException("对不起，您所点的咖啡没有");}return coffee;}
}

package com.suyv.staticfactory;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 12:24* @Description: 咖啡店类*/
public class CoffeeStore {public Coffee orderCoffee(String type) {Coffee coffee = SimpleCoffeeFactory.createCoffee(type);//加配料coffee.addMilk();coffee.addsugar();return coffee;}
}

package com.suyv.staticfactory;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 12:26* @Description: 静态工厂类测试*/
public class CofferTest {public static void main(String[] args) {//创建咖啡店类对象CoffeeStore store = new CoffeeStore();Coffee coffee = store.orderCoffee("latte");System.out.println(coffee.getName());}
}

1.4 模板设计模式

模版方法模式,简称为模板设计模式，它主要思想是：把通用的代码生成一个模板，可以反复的使用

package com.suyv.template;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 14:00* @Description: 创建一个模板类*/
public abstract class GetTime {/*** @description: 获取一段程序的运行时间* @author: 憨憨浩浩* @date: 2023/12/27 14:02* @param: []* @return: long**/public long getTime(){long start = System.currentTimeMillis();// 程序code();long end = System.currentTimeMillis();return end - start;}public abstract void code();}

package com.suyv.template;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 14:03* @Description: 用户使用模板类*/
public class ForDemo extends GetTime{@Overridepublic void code() {for (int i = 0; i < 100; i++) {System.out.println(i);}}
}

package com.suyv.template;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 14:04* @Description: 模板设计模式测试类*/
public class TemplateTest {public static void main(String[] args) {ForDemo forDemo = new ForDemo();System.out.println(forDemo.getTime() + "毫秒");}
}

1.5 装饰设计模式

装饰设计模式: 增强原有对象的功能

原本有一个对象，但是这个对象的功能不够强，采用装饰设计模式，对原对象中功能进行增强

回想一下我们当时讲的缓冲流，其实就是装饰设计模式

package com.suyv.decorate;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 14:09* @Description: TODO*/
public class Phone {public void call(){System.out.println("手机打电话功能！");}
}

package com.suyv.decorate;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 14:10* @Description: TODO*/
public class SendMsg {private Phone phone;public SendMsg(Phone phone) {this.phone = phone;}//增强原有手机的功能public void msg(){System.out.println("发彩信");System.out.println("发短信");phone.call();}
}

package com.suyv.decorate;/*** @Author: 憨憨浩浩* @CreateTime: 2023-12-27 14:11* @Description: TODO*/
public class PhoneTest {public static void main(String[] args) {SendMsg sendMsg = new SendMsg(new Phone());sendMsg.msg();}
}