设计模式java版

1.工厂模式（反射实现）

工厂模式是一种常用的设计模式，它提供了一种将对象的创建和使用分离的方式。该模式定义了一个用于创建对象的工厂类，而不是直接在客户端代码中通过new关键字来实例化对象。这样做的好处是使得客户端代码与具体对象的创建过程解耦，从而提高了代码的灵活性和可维护性。

工厂模式通常包含以下几个角色：

1. 抽象产品（Abstract Product）：定义了产品的接口或抽象类，它是具体产品的共同父类。

2. 具体产品（Concrete Product）：实现了抽象产品接口或继承了抽象产品类，是工厂方法所创建的对象。

3. 抽象工厂（Abstract Factory）：声明了创建产品的方法，它是工厂方法的核心接口。

4. 具体工厂（Concrete Factory）：实现了抽象工厂接口，具体工厂负责实例化具体的产品对象。

import java.awt.*;
import java.util.Scanner;

public class MyTest {
    public static void main(String[] args) {
        ShapeFactory shapeFactory = new ShapeFactory();
        Shape shape = shapeFactory.getShape("Square");
        shape.draw();
    }
}

class ShapeFactory {

    public Shape getShape(String shapeName) {
        Shape shape = null;
        try {
            shape = (Shape) Class.forName(shapeName).newInstance();

        } catch (Exception e) {
            System.out.println(e);
        }
        return shape;
    }
}

interface Shape {
    public void draw();
}

class Circle implements Shape {

    @Override
    public void draw() {
        System.out.println("画Circle");
    }
}

class Square implements Shape {

    @Override
    public void draw() {
        System.out.println("画Square");
    }
}

class Rectangle implements Shape {

    @Override
    public void draw() {
        System.out.println("画Rectangle");
    }
}

2.抽象工厂模式（反射实现）

抽象类工厂模式是一种设计模式，它允许我们通过一个抽象工厂类来创建一组相关或依赖的对象，而不需要显式地指定它们的具体类。

abstract class AbstractFactory {
    public abstract Product createProduct();
}

class ConcreteFactory extends AbstractFactory {
    @Override
    public Product createProduct() {
        try {
            // 使用反射创建产品对象
            Class<?> productClass = Class.forName("ConcreteProduct");
            return (Product) productClass.getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

abstract class Product {
    public abstract void doSomething();
}

class ConcreteProduct extends Product {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProduct: doSomething");
    }
}

public class MyTest {
    public static void main(String[] args) {
        AbstractFactory factory = new ConcreteFactory();
        Product product = factory.createProduct();
        product.doSomething();
    }
}

3.单例模式（双检锁/双重校验锁，线程安全

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

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

class Singleton {

    //创建 SingleObject 的一个对象
    private static Singleton instance = new Singleton();

    //让构造函数为 private，这样该类就不会被实例化
    private Singleton(){}

    //获取唯一可用的对象
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    public void showMessage(){
        System.out.println("Hello World!");
    }
}
public class MyTest {
    public static void main(String[] args) {
        //不合法的构造函数
        //编译时错误：构造函数 SingleObject() 是不可见的
        //SingleObject object = new SingleObject();

        //获取唯一可用的对象
        Singleton object = Singleton.getInstance();

        //显示消息
        object.showMessage();
    }
}

4.建造者模式

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

import java.util.ArrayList;
import java.util.List;

interface Item {
    public String name();
    public Packing packing();
    public float price();
}
interface Packing {
    public String pack();
}
class Wrapper implements Packing {

    @Override
    public String pack() {
        return "Wrapper";
    }
}
class Bottle implements Packing {

    @Override
    public String pack() {
        return "Bottle";
    }
}
abstract class Burger implements Item {

    @Override
    public Packing packing() {
        return new Wrapper();
    }

    @Override
    public abstract float price();
}
abstract class ColdDrink implements Item {

    @Override
    public Packing packing() {
        return new Bottle();
    }

    @Override
    public abstract float price();
}
class VegBurger extends Burger {

    @Override
    public float price() {
        return 25.0f;
    }

    @Override
    public String name() {
        return "Veg Burger";
    }
}
class ChickenBurger extends Burger {

    @Override
    public float price() {
        return 50.5f;
    }

    @Override
    public String name() {
        return "Chicken Burger";
    }
}
class Coke extends ColdDrink {

    @Override
    public float price() {
        return 30.0f;
    }

    @Override
    public String name() {
        return "Coke";
    }
}
class Pepsi extends ColdDrink {

    @Override
    public float price() {
        return 35.0f;
    }

    @Override
    public String name() {
        return "Pepsi";
    }
}
class Meal {
    private List<Item> items = new ArrayList<Item>();

    public void addItem(Item item){
        items.add(item);
    }

    public float getCost(){
        float cost = 0.0f;
        for (Item item : items) {
            cost += item.price();
        }
        return cost;
    }

    public void showItems(){
        for (Item item : items) {
            System.out.print("Item : "+item.name());
            System.out.print(", Packing : "+item.packing().pack());
            System.out.println(", Price : "+item.price());
        }
    }
}
class MealBuilder {

    public Meal prepareVegMeal (){
        Meal meal = new Meal();
        meal.addItem(new VegBurger());
        meal.addItem(new Coke());
        return meal;
    }

    public Meal prepareNonVegMeal (){
        Meal meal = new Meal();
        meal.addItem(new ChickenBurger());
        meal.addItem(new Pepsi());
        return meal;
    }
}
public class MyTest {
    public static void main(String[] args) {
        MealBuilder mealBuilder = new MealBuilder();

        Meal vegMeal = mealBuilder.prepareVegMeal();
        System.out.println("Veg Meal");
        vegMeal.showItems();
        System.out.println("Total Cost: " +vegMeal.getCost());

        Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
        System.out.println("\n\nNon-Veg Meal");
        nonVegMeal.showItems();
        System.out.println("Total Cost: " +nonVegMeal.getCost());
    }
}