1.工厂模式(反射实现)
工厂模式是一种常用的设计模式,它提供了一种将对象的创建和使用分离的方式。该模式定义了一个用于创建对象的工厂类,而不是直接在客户端代码中通过new关键字来实例化对象。这样做的好处是使得客户端代码与具体对象的创建过程解耦,从而提高了代码的灵活性和可维护性。
工厂模式通常包含以下几个角色:
-
抽象产品(Abstract Product):定义了产品的接口或抽象类,它是具体产品的共同父类。
-
具体产品(Concrete Product):实现了抽象产品接口或继承了抽象产品类,是工厂方法所创建的对象。
-
抽象工厂(Abstract Factory):声明了创建产品的方法,它是工厂方法的核心接口。
-
具体工厂(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());
}
}