侧边栏壁纸
博主头像
小郭的学习笔记博主等级

  • 累计撰写 154 篇文章
  • 累计创建 65 个标签
  • 累计收到 1 条评论

目 录CONTENT

文章目录
期末考试

java设计模式期末复习笔记

不争
不争
2024-01-02 / 0 评论 / 0 点赞 / 65 阅读 / 34060 字

Java设计模式笔记

  1. 七大设计原则核心思想
  2. 能够以类图的说明设计原则
  3. 在项目实际开发中，你在哪里使用到了ocp原则
  4. 单例设计模式一共有几种实现方式？

设计模式常用七大原则有：

  1. 单一职责原则
  2. 接口隔离原则
  3. 依赖倒转原则
  4. 里氏替换原则
  5. 开闭原则ocp
  6. 迪米特法则
  7. 合成复用原则

单一职责原则

及一个类应该只负责一项职责

单例设计模式一共有8种写法

  1. 饿汉式 两种
  2. 懒汉式 三种
  3. 双重检查
  4. 静态内部类
  5. 枚举

依赖关系传递的三种方式

  1. 接口传递

  2. 构造方法传递

  3. setter传递

里氏替换原则

  1. 在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法
  2. 里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖 来解决问题。

开闭原则

  1. 开闭原则（Open Closed Principle）是最基础、最重要的设计原则
  2. 一个软件实体如类，模块和函数应该对扩展开放（提供方），对修改关闭（使用方）。用抽象构建框架，用实现扩展细节。
  3. 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。
  4. 编程中遵循其它原则，以及使用设计模式的目的就是遵循开闭原则

迪米特法则

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

合成复用原则

  1. 原则是尽量使用合成/聚合的方式，而不是使用继承
  2. 如果只是为了用到另一个类的方法则没有必要继承

设计原则核心思想

  1. 找出应用中可能需要变化之外，把它们独立出来，不要和那些不需要变化的代码混在一起。
  2. 针对接口变成，而不是针对实现编程。
  3. 为了交互独享之间的松耦合设计而努力。

UML基本类图

  1. 用于描述系统中的类（对象）本身的组成和类（对象）之间的各种静态关系。
  2. 类之间的关系：依赖、泛化（继承）、实现、关联、聚合与组合

image-20220404152122664

依赖 ：只要我这个类用到另一个类，就是依赖关系

泛化： 就是继承了另一个类 （依赖关系的特例）

实现： 实现关系实际上就是A类实现B类，他也是依赖关系的特例

关联：关联关系实际上就是类与类之间的联系，他是依赖关系的特例，关联具有导航性：即双向关系或单向关系，关系具有多重性：如"1"（表示有且仅有一个）,"0.."(表示0个或者多个)，“0, 1”（表示0个或者一个），“n..m”（表示n个到 m个都可以）,"m .."（表示至少m个）

聚合： 表示的是整体和部分的关系，整体与部分可以分开。聚合关系是关联关系的特例，所以他具有关联的导航性与多重性

组合： 整体与部分不可分离

设计模式类型

设计模式分为三种类型，共23种

  1. 创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。
  2. 结构性模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式
  3. 行为型模式：模板方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interperter）、状态模式、策略模式、职责链模式（责任链模式）。
不同的书籍对分类和名称略有差别

单例模式实现

懒汉式

public class Signleton {
    private static Signleton instance = null; //静态私有成员变量

    private Signleton(){ //私有构造函数

    }
    //静态公有工厂方法，返回唯一的实例
    public static Signleton getInstance(){
        if (instance == null){
            instance = new Signleton();
        }
        return instance;
    }
}

懒汉式（双重检查）

public class Signleton {
    private volatile static Signleton instance = null;

    private Signleton(){}
	
    public static Signleton getInstance(){
        if (instance == null){
            synchronized (Signleton.class){ //synchronized 同步锁
                if (instance == null){
                    instance = new Signleton();
                }
            }
        }
        return instance;
    }
}

饿汉式

public class Signleton {
    private static final Signleton instance = new Signleton(); //静态私有成员变量

    private Signleton(){}

    public static Signleton getInstance(){
        return instance;
    }
}

简单工厂

abstract class Product{
    //所有产品类的公共业务方法
    public void methodSame(){
        System.out.println("公共方法");
        //公共方法的实现
    }
    //声明抽象业务方法
    public abstract void mmethodDiff();
}

class ConcreateProductA extends Product{

    @Override
    public void mmethodDiff() {
        System.out.println("产品A");
    }
}
class ConcreateProductB extends Product{

    @Override
    public void mmethodDiff() {
        System.out.println("产品B");
    }
}

//通过if判断 用户传进来的产品，然后创建不同的对象
class Factory{
    //静态工厂方法
    public static Product getProduct(String arg){
        Product product = null;
        if (arg.equalsIgnoreCase("A")){
            product = new ConcreateProductA();
        } else if (arg.equalsIgnoreCase("B")){
            product = new ConcreateProductB();
        }
        return product;

    }
}

简单工厂（咖啡店点餐）

咖啡店点餐UML图

//定义抽象产品 咖啡
abstract class Coffee{
    //定义公共方法
    public void addMilk(){
        System.out.println("加奶");
    }
    public void addsugar(){
        System.out.println("加糖");
    }
    public abstract void getName();
}

//具体产品
class AmericanCoffee extends Coffee{

    @Override
    public void getName() {
        System.out.println("美式咖啡");
    }
}

class LatteCoffee extends Coffee{

    @Override
    public void getName() {
        System.out.println("拿铁咖啡");
    }
}

//静态工厂
class CoffeeFactory{
    //静态工厂方法
    public static Coffee createCoffee(String type){
        Coffee coffee = null;
        if (type.equalsIgnoreCase("american")){
            coffee = new AmericanCoffee();
        }else if (type.equalsIgnoreCase("latee")){
            coffee = new LatteCoffee();
        }
        return coffee;
    }
}

image-20220610181704149

工厂模式

image-20220611165105438

package com.hspedu.Test12.Factory1;
//一个工厂创建一个产品
public class Client {
    public static void main(String[] args) {
        new HaierTVFactory().produceTV().play();
        new HisenseTVFactory().produceTV().play();
        
    }
}

//定义产品接口
interface TV{
    public void play();
}
//定义产品工厂
interface TVFactory{
    public TV produceTV();
}

class HaierTV implements TV{

    @Override
    public void play() {
        System.out.println("海尔电视！");
    }
}

class HisenseTV implements TV{

    @Override
    public void play() {
        System.out.println("海信电视！");
    }
}

class HaierTVFactory implements TVFactory{

    @Override
    public TV produceTV() {
        return new HaierTV();
    }
}

class HisenseTVFactory implements TVFactory{

    @Override
    public TV produceTV() {
        return new HisenseTV();
    }
}

2、背景：小成有一间塑料加工厂（仅生产A类产品）；随着客户需求的变化，客户需要生产B类产品

package com.hspedu.Test12.Factory2;
//目前只有一个产品
public class Client {
    public static void main(String[] args) {
        new FactoryA().Factory().creat();
    }
}

//抽象产品
interface produce{
    void creat();
}
//具体产品A
class produceA implements produce{

    @Override
    public void creat() {
        System.out.println("生产A！");
    }
}
//抽象工厂
interface Factory{
    public produce Factory();
}

//具体工厂
class FactoryA implements Factory{

    @Override
    public produce Factory() {
        return new produceA();
    }
}

冲突：改变原有塑料加工厂的配置和变化非常困难，假设下一次客户需要再发生变化，再次改变将增大非常大的成本；

解决方案：小成决定置办塑料分厂B来生产B类产品；

package com.hspedu.Test12.Factory2;

public class Client {
    public static void main(String[] args) {
        new FactoryA().Factory().creat();
        new FactoryB().Factory().creat();
    }
}

//抽象产品
interface produce{
    void creat();
}
//具体产品A
class produceA implements produce{

    @Override
    public void creat() {
        System.out.println("生产A！");
    }
}
class produceB implements produce{

    @Override
    public void creat() {
        System.out.println("生产B！");
    }
}
//抽象工厂
interface Factory{
    public produce Factory();
}

//具体工厂
class FactoryA implements Factory{

    @Override
    public produce Factory() {
        return new produceA();
    }
}

class FactoryB implements Factory{

    @Override
    public produce Factory() {
        return new produceB();
    }
}

抽象工厂练习

image-20220611173508423

package com.hspedu.Test12.Factory3;

public class Client {
    public static void main(String[] args) {
        new ConcreteFactory1().product1().show();
        new ConcreteFactory1().product2().show();

        new ConcreteFactory2().product1().show();
        new ConcreteFactory2().product2().show();

    }
}

//抽象产品1
interface Product1{
    void show();
}
//抽象产品2
interface Product2{
    void show();
}
//具体产品
class ConcreteProduct11 implements Product1{

    @Override
    public void show() {
        System.out.println("产品11");
    }
}

class ConcreteProduct12 implements Product1{
    @Override
    public void show() {
        System.out.println("产品12");
    }
}
class ConcreteProduct21 implements Product2{
    @Override
    public void show() {
        System.out.println("产品21");
    }
}
class ConcreteProdu22 implements Product2{
    @Override
    public void show() {
        System.out.println("产品22");
    }
}

//抽象工厂
interface AbstractFactory {
    public Product1 product1();

    public Product2 product2();
}
//具体工厂
class ConcreteFactory1 implements AbstractFactory{

    @Override
    public Product1 product1() {
        return new ConcreteProduct11();
    }

    @Override
    public Product2 product2() {
        return new ConcreteProduct21();
    }
}
class ConcreteFactory2 implements AbstractFactory{

    @Override
    public Product1 product1() {
        return new ConcreteProduct12();
    }

    @Override
    public Product2 product2() {
        return new ConcreteProdu22();
    }
}

建造者模式

  1. 抽象建造者
  2. 具体建造者
  3. 产品
  4. 指挥者
package com.hspedu.Test12.BuilderPattern;



public class Client {
    public static void main(String[] args) {
        KFCWaiter kfcWaiter = new KFCWaiter();
        kfcWaiter.setMb(new SubMealBuilderA());
        Meal meal;
        meal = kfcWaiter.construct();
        System.out.println(meal);
    }
}

class Meal{
    private String food;
    private String drink;

    public Meal() {
    }

    public String getFood() {
        return food;
    }

    public void setFood(String food) {
        this.food = food;
    }

    public String getDrink() {
        return drink;
    }

    public void setDrink(String drink) {
        this.drink = drink;
    }

    @Override
    public String toString() {
        return "Meal{" +
                "food='" + food + '\'' +
                ", drink='" + drink + '\'' +
                '}';
    }
}
//抽象建造者
abstract class MealBuilder{
    protected Meal meal = new Meal();

    public abstract void buildFood();
    public abstract void builDrink();
    public Meal getMeal(){
        return meal;
    }
}

//具体建造者
class SubMealBuilderA extends MealBuilder{

    @Override
    public void buildFood() {
        //System.out.println("鸡腿堡");
        meal.setFood("鸡腿堡");
    }

    @Override
    public void builDrink() {
        //System.out.println("可乐");
        meal.setFood("可乐");

    }
}

class SubMealBuilderB extends MealBuilder{

    @Override
    public void buildFood() {
        //System.out.println("鸡肉卷");
        meal.setFood("鸡肉卷");

    }

    @Override
    public void builDrink() {
        //System.out.println("橙汁");
        meal.setFood("橙汁");

    }
}
//指挥者
class KFCWaiter{
    private MealBuilder mb;

    public void setMb(MealBuilder mb) {
        this.mb = mb;
    }
    public Meal construct(){
        mb.buildFood();
        mb.builDrink();
        Meal meal = mb.getMeal();
        return meal;
    }
}

待续~~~

0
设计模式
版权归属： 不争
本文链接： http://localhost:8090/archives/javashe-ji-mo-shi-qi-mo-fu-xi-bi-ji
许可协议： 本文使用《署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0)》协议授权

评论区