1.简单工厂模式
核心：提供一个创建对象的功能，不需要关心具体实现
public abstract class Product{
public abstract void method();
}
public abstract class Factory{
public abstract Product createProduct();
}
public class ConcreteProductA extends Product{
public void method(){
System.out.println("我是产品A!");
}
}
public class ConcreteProductB extends Product{
public void method(){
System.out.println("我是产品B!");
}
}
// 类的实例化在子类实现
public class MyFactory extends Factory{
public Product createProduct(){
return new ConcreteProductA();
}
}
2.外观模式
核心：隐藏了系统的复杂性，为子系统中的一组接口提供了一个统一的访问接口，实现了高内聚，低耦合
public class CPU {
public void startup(){
System.out.println("cpu startup!");
}
public void shutdown(){
System.out.println("cpu shutdown!");
}
}
public class Memory {
public void startup(){
System.out.println("memory startup!");
}
public void shutdown(){
System.out.println("memory shutdown!");
}
}
public class Computer {
private CPU cpu;
private Memory memory;
public Computer(){
cpu = new CPU();
memory = new Memory();
}
public void startup(){
System.out.println("start the computer!");
cpu.startup();
memory.startup()；
System.out.println("start computer finished!");
}
public void shutdown(){
System.out.println("begin to close the computer!");
cpu.shutdown();
memory.shutdown();
System.out.println("computer closed!");
}
}
public class User {
public static void main(String[] args) {
Computer computer = new Computer();
computer.startup();
computer.shutdown();
}
}
3.构建者模式
核心：为了分离对象的属性与创建过程
/**
* Builder.java
* 建造者
*/
abstract class Builder {
//汉堡
abstract Builder bulidA(String mes);
//饮料
abstract Builder bulidB(String mes);
//薯条
abstract Builder bulidC(String mes);
//甜品
abstract Builder bulidD(String mes);
//获取套餐
abstract Product build();
}
/**
* Product.java
* 产品（麦当劳套餐）
*/
public class Product {
private String buildA="汉堡";
private String buildB="饮料";
private String buildC="薯条";
private String buildD="甜品";
public String getBuildA() {
return buildA;
}
public void setBuildA(String buildA) {
this.buildA = buildA;
}
public String getBuildB() {
return buildB;
}
public void setBuildB(String buildB) {
this.buildB = buildB;
}
public String getBuildC() {
return buildC;
}
public void setBuildC(String buildC) {
this.buildC = buildC;
}
public String getBuildD() {
return buildD;
}
public void setBuildD(String buildD) {
this.buildD = buildD;
}
@Override
public String toString() {
return buildA+"\n"+buildB+"\n"+buildC+"\n"+buildD+"\n"+"组成套餐";
}
}
/**
* ConcreteBuilder.java
* 具体建造者(服务员)
*/
public class ConcreteBuilder extends Builder{
private Product product;
public ConcreteBuilder() {
product = new Product();
}
@Override
Product build() {
return product;
}
@Override
Builder bulidA(String mes) {
product.setBuildA(mes);
return this;
}
@Override
Builder bulidB(String mes) {
product.setBuildB(mes);
return this;
}
@Override
Builder bulidC(String mes) {
product.setBuildC(mes);
return this;
}
@Override
Builder bulidD(String mes) {
product.setBuildD(mes);
return this;
}
}
/**
* Test.java
* 测试类
*/
public class Test {
public static void main(String[] args) {
ConcreteBuilder concreteBuilder = new ConcreteBuilder();
Product build = concreteBuilder
.bulidA("牛肉煲")
// .bulidC("全家桶")
.bulidD("冰淇淋")
.build();
System.out.println(build.toString());
}
}
4.责任链模式
核心：责任链模式是将多个处理事件的行为组合成一条链，通过调用链来对事件进行批处理。与单一事件处理不同，责任链模式强调多个事件连续处理，注重事件处理的序列化。
/**
* @author Hanlin Wang
*/
public class ChainOfResponsibilityMode {
public static void main(String[] args) {
//创建
Handler master = new Handler("h1", new Handler("h2", new Handler(
"h3", new Handler("h4"))));
master.handle();
}
}
//定义处理器接口
interface Hand{
void setSubHandler(Handler subHandler);
Handler getSubHandler();
void handle();
}
//定义处理器
class Handler implements Hand{
//处理器名字
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Handler(String name){
this.name = name;
}
public Handler(String name, Handler subHandler){
this.name = name;
this.subHandler = subHandler;
}
//赋予责任的另一个同类
private Handler subHandler;
//注入当前类
public void setSubHandler(Handler subHandler){
this.subHandler = subHandler;
}
//getter方法
public Handler getSubHandler(){
return this.subHandler;
}
//处理
public void handle(){
System.out.println(this.name + " is handling");
if (this.getSubHandler()!=null) {
this.subHandler.handle();
}
}
}
5.单例模式
（1）实现不加锁的线程安全的单例模式
public class Singleton {
public Singleton()
{
System.out.println("初始化");
}
private static class Inner
{
private static Singleton s=new Singleton();
}
public static Singleton getInstance()
{
return Inner.s;
// 通过静态内部类的方式实现单例模式是线程安全的，同时静态内部类不会在Singleton类加载时就加载，而是在调用getInstance()方法时才进行加载，达到了懒加载的效果。
//但是这种方式可能会存在反射攻击或者反序列化攻击，会造成不同的实例，违背了单例模式原则
(二) 枚举实现单例
最佳的单例实现模式就是枚举模式。利用枚举的特性，让JVM来帮我们保证线程安全和单一实例的问题。除此之外，写法还特别简单
public enum Singleton {
INSTANCE;
public void doSomething() {
System.out.println("doSomething");
}
}
//方法调用
public class Main {
public static void main(String[] args) {
Singleton.INSTANCE.doSomething();
}
}
网友评论