文章目录
- 单例模式
- 工厂模式
- 建造者模式
- 原型模式
- 适配器模式
- 代理模式
- 桥接模式
- 组合模式
- 装饰模式
- 外观模式
- 享元模式
- 责任链模式
- 迭代器模式
- 中介模式
- 命令模式
- 解释器模式
- 访问者模式
- 策略模式
- 模板方法模式
- 状态模式
- 观察者模式
- 备忘录模式
单例模式
饿汉式
package singleton;
/**
* 测试饿汉式单例模式
*/
public class SingletonDemo01 {
// 类初始化时,立即加载这个对象(没有延时加载的优势).加载类时,天然的是线程安全的
private static SingletonDemo01 instance = new SingletonDemo01();
private SingletonDemo01(){
}
// 没有同步方法,调用效率高
public static SingletonDemo01 getInstance(){
return instance;
}
}
懒汉式
package singleton;
/**
* 测试懒汉式单例模式
*/
public class SingletonDemo02 {
// 类初始化时,不初始化这个对象(延时加载,真正用的时候再创建)
private static SingletonDemo02 instance;
private SingletonDemo02(){ // 私有化构造器
}
// 方法同步,调用效率低
public static synchronized SingletonDemo02 getInstance(){
if (instance==null){
instance = new SingletonDemo02();
}
return instance;
}
}
package singleton;
/**
* 测试静态内部类实现单例模式
* 这种方式: 线程安全,调用效率高,并且实现了延时加载
*/
public class SingletonDemo03 {
private static class SingletonClassInstance{
private static final SingletonDemo03 instance = new SingletonDemo03();
}
private SingletonDemo03(){ // 私有化构造器
}
public static synchronized SingletonDemo03 getInstance(){
return SingletonClassInstance.instance;
}
}
package singleton;
/**
* 测试枚举实现单例模式(没有延时加载)
*/
public enum SingletonDemo04 {
// 这个枚举元素本身就是单例
INSTANCE;
// 添加自己需要的操作
public void singletonOperation(){
}
}
测试
package singleton;
public class Client {
public static void main(String[] args) {
SingletonDemo01 s1 = SingletonDemo01.getInstance();
SingletonDemo01 s2 = SingletonDemo01.getInstance();
System.out.println(s1==s2);
SingletonDemo02 s3 = SingletonDemo02.getInstance();
SingletonDemo02 s4 = SingletonDemo02.getInstance();
System.out.println(s3==s4);
SingletonDemo03 s5 = SingletonDemo03.getInstance();
SingletonDemo03 s6 = SingletonDemo03.getInstance();
System.out.println(s5==s6);
System.out.println(SingletonDemo04.INSTANCE==SingletonDemo04.INSTANCE);
}
}
package singleton;
import java.io.ObjectStreamException;
import java.io.Serializable;
/**
* 测试饿汉式单例模式(如何防止反射和反序列化漏洞)
*/
public class SingletonDemo06 implements Serializable {
// 类初始化时,立即加载这个对象(没有延时加载的优势).加载类时,天然的是线程安全的
private static SingletonDemo06 instance = new SingletonDemo06();
private SingletonDemo06(){
// 防止反射多次调用进行初始化
if (instance!=null){
throw new RuntimeException();
}
}
// 反序列化时,如果定义了readResolve()则直接返回此方法指定的对象,而不需要再单独创建对象!
private Object readResolve() throws ObjectStreamException{
return instance;
}
// 没有同步方法,调用效率高
public static SingletonDemo06 getInstance(){
return instance;
}
}
package singleton;
import java.io.*;
import java.lang.reflect.Constructor;
/**
* 测试反射和反序列化破解单例模式
*/
public class Client2 {
public static void main(String[] args) throws Exception{
SingletonDemo06 s1 = SingletonDemo06.getInstance();
SingletonDemo06 s2 = SingletonDemo06.getInstance();
System.out.println(s1);
System.out.println(s2);
// 通过反射的方式直接调用私有构造器
/*Class clz = Class.forName("singleton.SingletonDemo06");
Constructor c = clz.getDeclaredConstructor();
c.setAccessible(true);
SingletonDemo06 s3 = (SingletonDemo06) c.newInstance();
SingletonDemo06 s4 = (SingletonDemo06) c.newInstance();
System.out.println(s3);
System.out.println(s4);
*/
// 通过反序列化的方式构造多个对象
FileOutputStream fos = new FileOutputStream("./a.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(s1);
oos.close();
fos.close();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(("./a.txt")));
SingletonDemo06 s3 = (SingletonDemo06) ois.readObject();
System.out.println(s3);
}
}
package singleton;
import java.util.concurrent.CountDownLatch;
/**
* 测试多线程环境下创建单例模式的效率
*/
public class Client3 {
public static void main(String[] args) throws Exception{
int threadNum = 10;
final CountDownLatch countDownLatch = new CountDownLatch(threadNum);
long start = System.currentTimeMillis();
for (int i = 0; i < threadNum; i++) {
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 100000; i++) {
Object o = SingletonDemo01.getInstance();
}
countDownLatch.countDown();
}
}).start();
}
countDownLatch.await(); // main线程阻塞, 直到计数器变为0,才会继续往下执行
long end = System.currentTimeMillis();
System.out.println("总耗时:" + (end-start));
}
}
工厂模式
Car
package simplefactory;
public interface Car {
void run();
}
Audi
package simplefactory;
public class Audi implements Car{
@Override
public void run() {
System.out.println("奥迪在跑!!");
}
}
Byd
package simplefactory;
public class Byd implements Car{
@Override
public void run() {
System.out.println("比亚迪在跑!!");
}
}
CarFactory
package simplefactory;
public class CarFactory {
public static Car createCar(String type){
if ("奥迪".equals(type)){
return new Audi();
}else if ("比亚迪".equals(type)){
return new Byd();
}else {
return null;
}
}
}
CarFactory02
package simplefactory;
/**
* 简单工厂类
*/
public class CarFactory02 {
public static Car createAudi(){
return new Audi();
}
public static Car createByd(){
return new Byd();
}
}
调用
package simplefactory;
/**
* 简单工厂条件下
*/
public class Client02 {
public static void main(String[] args) {
Car c1 = CarFactory.createCar("奥迪");
Car c2 = CarFactory.createCar("比亚迪");
c1.run();
c2.run();
}
}
Engine
package factory.abstractFactory;
public interface Engine {
void run();
void start();
}
class LuxuryEngine implements Engine{
@Override
public void run() {
System.out.println("转的快!");
}
@Override
public void start() {
System.out.println("启动快!可以自动启停!");
}
}
class LowerEngine implements Engine{
@Override
public void run() {
System.out.println("转的慢!");
}
@Override
public void start() {
System.out.println("启动慢!");
}
}
Seat
package factory.abstractFactory;
public interface Seat {
void massage();
}
class LuxurySeat implements Seat{
@Override
public void massage() {
System.out.println("可以自动按摩!");
}
}
class LowerSeat implements Seat{
@Override
public void massage() {
System.out.println("不可以自动按摩!");
}
}
Tyre
package factory.abstractFactory;
public interface Tyre {
void revolve();
}
class LuxuryTyre implements Tyre{
@Override
public void revolve() {
System.out.println("旋转不磨损!");
}
}
class LowerTyre implements Tyre{
@Override
public void revolve() {
System.out.println("旋转磨损快!");
}
}
CarFactory
package factory.abstractFactory;
public interface CarFactory {
Engine createEngine();
Seat createSeat();
Tyre createTyre();
}
LowerCarFactory
package factory.abstractFactory;
public class LowerCarFactory implements CarFactory {
@Override
public Engine createEngine() {
return new LowerEngine();
}
@Override
public Seat createSeat() {
return new LowerSeat();
}
@Override
public Tyre createTyre() {
return new LowerTyre();
}
}
LuxuryCarFactory
package factory.abstractFactory;
public class LuxuryCarFactory implements CarFactory {
@Override
public Engine createEngine() {
return new LuxuryEngine();
}
@Override
public Seat createSeat() {
return new LuxurySeat();
}
@Override
public Tyre createTyre() {
return new LuxuryTyre();
}
}
Client
package factory.abstractFactory;
public class Client {
public static void main(String[] args) {
CarFactory factory = new LuxuryCarFactory();
Engine e = factory.createEngine();
e.run();
e.start();
}
}
建造者模式
AirShip
package builder;
public class AirShip {
private OrbitalModule orbitalModule;
private Engine engine;
private EscapeTower escapeTower;
public void lanuch(){
System.out.println("发射");
}
public OrbitalModule getOrbitalModule() {
return orbitalModule;
}
public void setOrbitalModule(OrbitalModule orbitalModule) {
this.orbitalModule = orbitalModule;
}
public Engine getEngine() {
return engine;
}
public void setEngine(Engine engine) {
this.engine = engine;
}
public EscapeTower getEscapeTower() {
return escapeTower;
}
public void setEscapeTower(EscapeTower escapeTower) {
this.escapeTower = escapeTower;
}
}
class OrbitalModule{
private String name;
public OrbitalModule(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class Engine{
private String name;
public Engine(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class EscapeTower{
private String name;
public EscapeTower(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
AirshipBuilder
package builder;
public interface AirshipBuilder {
Engine builderEngine();
OrbitalModule builderOrbitalModule();
EscapeTower builderEscapeTower();
}
AirShipDirector
package builder;
public interface AirShipDirector {
AirShip direAirShip();
}
TestAirShipBuilder
package builder;
// StringBuilder,XML解析中--DomBuilder,SaxBuilder
public class TestAirShipBuilder implements AirshipBuilder{
@Override
public Engine builderEngine() {
System.out.println("构造发动机");
return new Engine("发动机");
}
@Override
public OrbitalModule builderOrbitalModule() {
System.out.println("构建轨道舱");
return new OrbitalModule("轨道舱");
}
@Override
public EscapeTower builderEscapeTower() {
System.out.println("构建逃逸舱");
return new EscapeTower("逃逸舱");
}
}
TestAirShipDirector
package builder;
public class TestAirShipDirector implements AirShipDirector {
private AirshipBuilder builder;
public TestAirShipDirector(AirshipBuilder builder) {
this.builder = builder;
}
@Override
public AirShip direAirShip() {
Engine e = builder.builderEngine();
OrbitalModule o = builder.builderOrbitalModule();
EscapeTower et = builder.builderEscapeTower();
// 装配成飞船对象
AirShip ship = new AirShip();
ship.setEngine(e);
ship.setEscapeTower(et);
ship.setOrbitalModule(o);
return ship;
}
}
Client
package builder;
public class Client {
public static void main(String[] args) {
AirShipDirector director = new TestAirShipDirector(new TestAirShipBuilder());
AirShip ship = director.direAirShip();
System.out.println(ship.getEngine().getName());
ship.lanuch();
}
}
原型模式
package prototype;
import java.util.Date;
public class Sheep implements Cloneable{
private String sname;
private Date birthday;
public Sheep(String sname, Date birthday) {
this.sname = sname;
this.birthday = birthday;
}
public Sheep() {
}
// 浅拷贝
// @Override
// protected Object clone() throws CloneNotSupportedException {
// Object obj = super.clone();
// return obj;
// }
// 深拷贝
@Override
protected Object clone() throws CloneNotSupportedException {
Object obj = super.clone();
// 深复制
Sheep s = (Sheep)obj;
s.birthday = (Date) this.birthday.clone();
return obj;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
package prototype;
/**
* 测试原型模型(浅拷贝/深拷贝)
*/
import java.util.Date;
public class Client {
public static void main(String[] args) throws Exception {
Date date = new Date();
Sheep s1 = new Sheep("少利", date);
Sheep s2 = (Sheep) s1.clone();
System.out.println(s1);
System.out.println(s1.getSname());
date.setTime(123123123);
System.out.println(s1.getBirthday());
System.out.println(s2);
s2.setSname("多利");
System.out.println(s2.getSname());
System.out.println(s2.getBirthday());
}
}
浅拷贝
深拷贝
Sheep 要实现Serializable接口
package prototype;
/**
* 测试原型模型(深复制,使用序列化和反序列化的方式实现深复制)
*/
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;
public class Client3 {
public static void main(String[] args) throws Exception {
Date date = new Date();
Sheep s1 = new Sheep("少利", date);
// Sheep s2 = (Sheep) s1.clone();
// 使用序列化和反序列化的方式实现深复制
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(s1);
byte[] bytes = bos.toByteArray();
ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bis);
Sheep s2 = (Sheep)ois.readObject();
System.out.println(s1);
System.out.println(s1.getSname());
date.setTime(123123123);
System.out.println(s1.getBirthday());
System.out.println(s2);
s2.setSname("多利");
System.out.println(s2.getSname());
System.out.println(s2.getBirthday());
}
}
适配器模式
Target
package adapter;
public interface Target {
void hadleReq();
}
Adapatee
package adapter;
/**
* 被适配的类
*/
public class Adapatee {
public void request(){
System.out.println("可以完成客户请求的需求功能!");
}
}
Adapter
package adapter;
/**
* 适配器(类适配器方式)
*/
public class Adapter extends Adapatee implements Target{
@Override
public void hadleReq() {
super.request();
}
}
Adapter2
package adapter;
/**
* 适配器(对象适配器方式,使用了组合的方式跟被适配对象整合)
*/
public class Adapter2 implements Target{
private Adapatee adapatee;
public Adapter2(Adapatee adapatee) {
this.adapatee = adapatee;
}
@Override
public void hadleReq() {
adapatee.request();
}
}
Client
package adapter;
/**
* 客户端类
*/
public class Client {
public void test1(Target t){
t.hadleReq();
}
public static void main(String[] args) {
Client c = new Client();
Adapatee a = new Adapatee();
// Target t = new Adapter();
Target t = new Adapter2(a);
c.test1(t);
}
}
代理模式
静态代理
Star
package staticProxy;
public interface Star {
void confer();
void signContract();
void bookTicket();
void sing();
void collectMoney();
}
RealStar
package staticProxy;
public class RealStar implements Star{
@Override
public void confer() {
System.out.println("RealStar.confer()");
}
@Override
public void signContract() {
System.out.println("RealStar.signContract()");
}
@Override
public void bookTicket() {
System.out.println("RealStar.bookTicket()");
}
@Override
public void sing() {
System.out.println("RealStar(本人).sing()");
}
@Override
public void collectMoney() {
System.out.println("RealStar.collectMoney()");
}
}
ProxyStar
package staticProxy;
public class ProxyStar implements Star{
private Star star;
public ProxyStar(Star star) {
this.star = star;
}
@Override
public void confer() {
System.out.println("ProxyStar.confer()");
}
@Override
public void signContract() {
System.out.println("ProxyStar.signContract()");
}
@Override
public void bookTicket() {
System.out.println("ProxyStar.bookTicket()");
}
@Override
public void sing() {
star.sing();
}
@Override
public void collectMoney() {
System.out.println("ProxyStar.collectMoney()");
}
}
Client
package staticProxy;
public class Client {
public static void main(String[] args) {
Star real = new RealStar();
Star proxy = new ProxyStar(real);
proxy.confer();
proxy.signContract();
proxy.bookTicket();
proxy.sing();
proxy.collectMoney();
}
}
动态代理
StarHandler
package proxy.dynamicProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class StarHandler implements InvocationHandler {
Star realStar;
public StarHandler(Star realStar) {
this.realStar = realStar;
}
@Override
public Object invoke(Object o, Method method, Object[] args) throws Throwable {
Object obj = null;
System.out.println("真正的方法执行前");
System.out.println("面谈,签合同,转付款...");
if (method.getName().equals("sing")){
obj = method.invoke(realStar, args);
}
System.out.println("真正的方法执行后!");
System.out.println("收尾款");
return obj;
}
}
Client
package proxy.dynamicProxy;
import java.lang.reflect.Proxy;
public class Client {
public static void main(String[] args) {
Star realStar = new RealStar();
StarHandler handler = new StarHandler(realStar);
Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Star.class}, handler);
proxy.sing();
}
}
桥接模式
Brand
package bridge;
/**
* 品牌
*/
public interface Brand {
void sale();
}
class Lenovo implements Brand{
@Override
public void sale() {
System.out.println("销售联想电脑");
}
}
class Dell implements Brand{
@Override
public void sale() {
System.out.println("销售戴尔电脑");
}
}
class Shenzhou implements Brand{
@Override
public void sale() {
System.out.println("销售神州电脑");
}
}
Computer
package bridge;
/**
* 电脑类型
*/
public class Computer {
protected Brand brand;
public Computer(Brand brand){
this.brand = brand;
}
public void sale(){
brand.sale();
}
}
class Desktop extends Computer{
public Desktop(Brand brand) {
super(brand);
}
@Override
public void sale() {
super.sale();
System.out.println("销售台式机");
}
}
class Laptop extends Computer{
public Laptop(Brand brand) {
super(brand);
}
@Override
public void sale() {
super.sale();
System.out.println("销售笔记本");
}
}
Client
package bridge;
public class Client {
public static void main(String[] args) {
// 销售联想笔记本
Computer c = new Laptop(new Lenovo());
c.sale();
// 销售神州台式机
Computer c2 = new Desktop(new Shenzhou());
c2.sale();
}
}
组合模式
AbstractFile
package composite;
import java.util.ArrayList;
import java.util.List;
// 抽象构建
public interface AbstractFile {
void killVirus(); // 杀毒
}
class ImageFile implements AbstractFile{
private String name;
public ImageFile(String name){
this.name = name;
}
@Override
public void killVirus() {
System.out.println("--图像文件:"+name+",进行查杀");
}
}
class TextFile implements AbstractFile{
private String name;
public TextFile(String name){
this.name = name;
}
@Override
public void killVirus() {
System.out.println("--文本文件:"+name+",进行查杀");
}
}
class VideoFile implements AbstractFile{
private String name;
public VideoFile(String name){
this.name = name;
}
@Override
public void killVirus() {
System.out.println("--视频文件:"+name+",进行查杀");
}
}
class Folder implements AbstractFile{
private String name;
// 定义容器,用来存放容器构建下的子节点
private List<AbstractFile> list = new ArrayList<>();
public Folder(String name) {
this.name = name;
}
public void add(AbstractFile file){
list.add(file);
}
public void remove(AbstractFile file){
list.remove(file);
}
public AbstractFile getChild(int index){
return list.get(index);
}
@Override
public void killVirus() {
System.out.println("--文件夹:"+name+",进行查杀");
for (AbstractFile file: list) {
file.killVirus();
}
}
}
Client
package composite;
public class Client {
public static void main(String[] args) {
AbstractFile f2,f3,f4,f5,f6;
Folder f1;
f1 = new Folder("我的收藏");
f2 = new ImageFile("图片123.jpg");
f3 = new TextFile("Hello.txt");
f1.add(f2);
f1.add(f3);
Folder f11 = new Folder("电影");
f4 = new VideoFile("1.mp4");
f5 = new VideoFile("2.mp4");
f11.add(f4);
f11.add(f5);
f1.add(f11);
f1.killVirus();
}
}
装饰模式
ICar
package decorator;
/**
* 抽象构建
*/
public interface ICar {
void move();
}
// 具体构建对象(真实对象)
class Car implements ICar{
@Override
public void move() {
System.out.println("陆地上跑");
}
}
class SuperCar implements ICar{
private ICar car;
public SuperCar(ICar car) {
this.car = car;
}
@Override
public void move() {
car.move();
}
}
// 具体装饰对象
class FlyCar extends SuperCar{
public FlyCar(ICar car) {
super(car);
}
public void fly(){
System.out.println("天上飞!");
}
@Override
public void move() {
super.move();
fly();
}
}
// 具体装饰对象
class WaterCar extends SuperCar{
public WaterCar(ICar car) {
super(car);
}
public void swim(){
System.out.println("水上游!");
}
@Override
public void move() {
super.move();
swim();
}
}
// 具体装饰对象
class AICar extends SuperCar{
public AICar(ICar car) {
super(car);
}
public void autoMove(){
System.out.println("自动驾驶!");
}
@Override
public void move() {
super.move();
autoMove();
}
}
Client
package decorator;
public class Client {
public static void main(String[] args) {
Car car = new Car();
car.move();
System.out.println("------加功能--------");
FlyCar flyCar = new FlyCar(car);
flyCar.move();
System.out.println("-----------");
WaterCar waterCar = new WaterCar(flyCar);
waterCar.move();
}
}
外观模式
享元模式
ChessFlyWeight
package flyweight;
/**
* 享元类
*/
public interface ChessFlyWeight {
void setColor(String c);
String getColor();
void display(Corrdinate c);
}
class ConcreteChess implements ChessFlyWeight{
private String color;
public ConcreteChess(String color) {
this.color = color;
}
@Override
public void setColor(String c) {
this.color = c;
}
@Override
public String getColor() {
return color;
}
@Override
public void display(Corrdinate c) {
System.out.println("棋子颜色:"+color);
System.out.println("棋子位置:"+c.getX()+"------"+c.getY());
}
}
Corrdinate
package flyweight;
/**
* 外部状态UnSharedConcreteFlyWeight
*/
public class Corrdinate {
private int x,y;
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public Corrdinate(int x, int y) {
this.x = x;
this.y = y;
}
}
ChessFlyWeightFactory
package flyweight;
import java.util.HashMap;
import java.util.Map;
public class ChessFlyWeightFactory {
// 享元池
private static Map<String, ChessFlyWeight> map = new HashMap<>();
public static ChessFlyWeight getChess(String color){
if (map.get(color)!=null){
return map.get(color);
}else {
ChessFlyWeight cfw = new ConcreteChess(color);
map.put(color,cfw);
return cfw;
}
}
}
Client
package flyweight;
public class Client {
public static void main(String[] args) {
ChessFlyWeight chess1 = ChessFlyWeightFactory.getChess("黑色");
ChessFlyWeight chess2 = ChessFlyWeightFactory.getChess("黑色");
System.out.println(chess1);
System.out.println(chess2);
chess1.display(new Corrdinate(10, 10));
chess2.display(new Corrdinate(20, 20));
}
}
责任链模式
LeaveRequest
package chainOfResp;
/**
* 封装请假的基本信息
*/
public class LeaveRequest {
private String empName;
private int leaveDays;
private String reason;
public LeaveRequest(String empName, int leaveDays, String reason) {
this.empName = empName;
this.leaveDays = leaveDays;
this.reason = reason;
}
public String getEmpName() {
return empName;
}
public void setEmpName(String empName) {
this.empName = empName;
}
public int getLeaveDays() {
return leaveDays;
}
public void setLeaveDays(int leaveDays) {
this.leaveDays = leaveDays;
}
public String getReason() {
return reason;
}
public void setReason(String reason) {
this.reason = reason;
}
}
Leader
package chainOfResp;
public abstract class Leader {
protected String name;
protected Leader nextLeader;
public Leader(String name) {
this.name = name;
}
// 设置后继对象
public void setNextLeader(Leader nextLeader) {
this.nextLeader = nextLeader;
}
/**
* 处理请求的核心业务的方法
* @param request
*/
public abstract void handleRequest(LeaveRequest request);
}
Director
package chainOfResp;
public class Director extends Leader {
public Director(String name){
super(name);
}
@Override
public void handleRequest(LeaveRequest request) {
if (request.getLeaveDays()<3){
System.out.println("员工:"+request.getEmpName()+" 天数:"+request.getLeaveDays()+" 理由:"+request.getReason());
System.out.println("主任:"+this.name+",审批通过!");
}else {
if (this.nextLeader!=null){
this.nextLeader.handleRequest(request);
}
}
}
}
Manager
package chainOfResp;
public class Manager extends Leader {
public Manager(String name){
super(name);
}
@Override
public void handleRequest(LeaveRequest request) {
if (request.getLeaveDays()<10){
System.out.println("员工:"+request.getEmpName()+" 天数:"+request.getLeaveDays()+" 理由:"+request.getReason());
System.out.println("经理:"+this.name+",审批通过!");
}else {
if (this.nextLeader!=null){
this.nextLeader.handleRequest(request);
}
}
}
}
GeneraManager
package chainOfResp;
public class GeneraManager extends Leader {
public GeneraManager(String name){
super(name);
}
@Override
public void handleRequest(LeaveRequest request) {
if (request.getLeaveDays()<30){
System.out.println("员工:"+request.getEmpName()+" 天数:"+request.getLeaveDays()+" 理由:"+request.getReason());
System.out.println("总经理:"+this.name+",审批通过!");
}else {
System.out.println("莫非"+request.getEmpName()+"想辞职,居然请假"+request.getLeaveDays()+"天");
}
}
}
Client
package chainOfResp;
public class Client {
public static void main(String[] args) {
Leader a = new Director("张三");
Leader b = new Manager("李四");
Leader c = new GeneraManager("王五");
// 组织责任链对象的关系
a.setNextLeader(b);
b.setNextLeader(c);
// 开始请假操作
LeaveRequest req1 = new LeaveRequest("TOM",1,"回家探亲");
a.handleRequest(req1);
}
}
迭代器模式
MyIterator
package iterator;
/**
* 迭代器接口
*/
public interface MyIterator {
void first();
void next();
boolean hasNext();
boolean isFirst();
boolean isLast();
Object getCurrentObj();
}
ConcreteMyAggregate
package iterator;
import java.util.ArrayList;
import java.util.List;
/**
* 自定义的集合类
*/
public class ConcreteMyAggregate {
private List<Object> list = new ArrayList<>();
public void addObject(Object obj){
this.list.add(obj);
}
public void removeObject(Object obj){
this.list.remove(obj);
}
// 获得迭代器
public MyIterator createIterator(){
return new ConcreteIterator();
}
// 使用内部类定义迭代器,可以直接使用外部类的属性
private class ConcreteIterator implements MyIterator{
private int cursor;
@Override
public void first() {
cursor = 0;
}
@Override
public void next() {
if (cursor<list.size()){
cursor++;
}
}
@Override
public boolean hasNext() {
if (cursor<list.size()){
return true;
}
return false;
}
@Override
public boolean isFirst() {
return cursor==0;
}
@Override
public boolean isLast() {
return cursor==list.size()-1;
}
@Override
public Object getCurrentObj() {
return list.get(cursor);
}
}
}
中介模式
Mediator
package mediator;
public interface Mediator {
void regesiter(String dname, Depaterment d);
void command(String name);
}
President
package mediator;
import java.util.HashMap;
import java.util.Map;
public class President implements Mediator {
private Map<String, Depaterment> map = new HashMap<>();
@Override
public void regesiter(String dname, Depaterment d) {
map.put(dname, d);
}
@Override
public void command(String dname) {
map.get(dname).selfAction();
}
}
Depaterment
package mediator;
public interface Depaterment {
void selfAction();
void outAction();
}
Development
package mediator;
public class Development implements Depaterment {
public Development(Mediator m) {
this.m = m;
m.regesiter("development", this);
}
private Mediator m; // 中介者的引用
@Override
public void selfAction() {
System.out.println("专心科研,开发项目!");
}
@Override
public void outAction() {
System.out.println("汇报工作!无钱,需支持!");
}
}
Finacial
package mediator;
public class Finacial implements Depaterment {
public Finacial(Mediator m) {
this.m = m;
m.regesiter("finacial", this);
}
private Mediator m; // 中介者的引用
@Override
public void selfAction() {
System.out.println("数钱!");
}
@Override
public void outAction() {
System.out.println("汇报工作!钱多,数不过来!");
}
}
Market
package mediator;
public class Market implements Depaterment {
public Market(Mediator m) {
this.m = m;
m.regesiter("market", this);
}
private Mediator m; // 中介者的引用
@Override
public void selfAction() {
System.out.println("跑去接项目!");
}
@Override
public void outAction() {
System.out.println("汇报工作!项目进度,需钱支持!");
m.command("finacial");
}
}
Client
package mediator;
public class Client {
public static void main(String[] args) {
Mediator m = new President();
Market market = new Market(m);
Development devp = new Development(m);
Finacial f = new Finacial(m);
market.selfAction();
market.outAction();
}
}
命令模式
解释器模式
访问者模式
策略模式
Strategy
package strategy;
public interface Strategy {
public double getPrice(double standardPrice);
}
NewCustomFewStrategy
package strategy;
public class NewCustomFewStrategy implements Strategy{
@Override
public double getPrice(double standardPrice) {
System.out.println("不打折,原价!");
return standardPrice;
}
}
OldCustomFewStrategy
package strategy;
public class OldCustomFewStrategy implements Strategy{
@Override
public double getPrice(double standardPrice) {
System.out.println("打85折");
return standardPrice * 0.85;
}
}
OldCustomManyStrategy
package strategy;
public class OldCustomManyStrategy implements Strategy{
@Override
public double getPrice(double standardPrice) {
System.out.println("打8折");
return standardPrice * 0.8;
}
}
Context
package strategy;
/**
* 负责和具体的策略类交互
* 这样的话,具体的算法和直接的客户端调用分离了,使得算法可以独立于客户端变化
* 如果使用Spring的依赖注入功能,还可以通过配置文件,动态注入不同的策略对象,动态的切换算法
*/
public class Context {
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public Strategy getStrategy() {
return strategy;
}
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public void printPrice(double s){
System.out.println("您该报价: "+strategy.getPrice(s));
}
}
Client
package strategy;
public class Client {
public static void main(String[] args) {
Strategy s1 = new OldCustomManyStrategy();
Context ctx = new Context(s1);
ctx.printPrice(998);
}
}
模板方法模式
transact()
是抽象方法,需要在子类实现,可以进行不同的实现办理不同的业务
状态模式
观察者模式
Observer
package observer;
public interface Observer {
void update(Subject subject);
}
ObserverA
package observer;
public class ObserverA implements Observer {
private int myState; // myState需要跟目标对象的state值保持一致!
@Override
public void update(Subject subject) {
myState = ((ConcreteSubject)subject).getState();
}
public int getMyState() {
return myState;
}
public void setMyState(int myState) {
this.myState = myState;
}
}
Subject
package observer;
import java.util.ArrayList;
import java.util.List;
public class Subject {
protected List<Observer> list = new ArrayList<>();
public void registerObserver(Observer obs){
list.add(obs);
}
public void removeObserver(Observer obs){
list.remove(obs);
}
// 通知所有的观察者更新状态
public void notifyAllObserver(){
for (Observer obs: list) {
obs.update(this);
}
}
}
ConcreteSubject
package observer;
public class ConcreteSubject extends Subject {
private int state;
public int getState(){
return state;
}
public void setState(int state){
this.state = state;
// 主题对象(目标对象)值发生了变化,请通知所有的观察者
this.notifyAllObserver();
}
}
Client
package observer;
public class Client {
public static void main(String[] args) {
// 目标对象
ConcreteSubject subject = new ConcreteSubject();
// 创建多个观察者
ObserverA obs1 = new ObserverA();
ObserverA obs2 = new ObserverA();
ObserverA obs3 = new ObserverA();
// 让这三个观察者添加到subject对象的观察者队伍中
subject.registerObserver(obs1);
subject.registerObserver(obs2);
subject.registerObserver(obs3);
// 改变状态态
subject.setState(3000);
System.out.println(obs1.getMyState());
System.out.println(obs2.getMyState());
System.out.println(obs3.getMyState());
}
}
ConcreteSubject
package observer2;
import java.util.Observable;
public class ConcreteSubject extends Observable {
private int state;
public void set(int s){
state = s;
setChanged(); // 表示目标对象已经做了更改
notifyObservers(state); // 通知所有观察者
}
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
}
}
ObserverA
package observer2;
import java.util.Observable;
import java.util.Observer;
public class ObserverA implements Observer {
private int myState;
@Override
public void update(Observable o, Object arg) {
myState = ((ConcreteSubject)o).getState();
}
public int getMyState() {
return myState;
}
public void setMyState(int myState) {
this.myState = myState;
}
}
Client
package observer2;
public class Client {
public static void main(String[] args) {
// 创建目标对象Obserable
ConcreteSubject subject = new ConcreteSubject();
// 创建观察者
ObserverA obs1 = new ObserverA();
ObserverA obs2 = new ObserverA();
ObserverA obs3 = new ObserverA();
// 添加到容器中
subject.addObserver(obs1);
subject.addObserver(obs2);
subject.addObserver(obs3);
// 改变状态
subject.set(3000);
System.out.println(obs1.getMyState());
System.out.println(obs2.getMyState());
System.out.println(obs3.getMyState());
}
}
备忘录模式
Emp
package memento;
/**
* 源发器类
*/
public class Emp {
private String ename;
private int age;
private double salary;
public Emp(String ename, int age, double salary) {
this.ename = ename;
this.age = age;
this.salary = salary;
}
// 进行备忘录操作,并返回备忘录对象
public EmpMemento memento(){
return new EmpMemento(this);
}
// 进行数据恢复,恢复为指定备忘录对象的值
public void recovery(EmpMemento mmt){
this.ename = mmt.getEname();
this.age = mmt.getAge();
this.salary = mmt.getSalary();
}
public String getEname() {
return ename;
}
public void setEname(String ename) {
this.ename = ename;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
EmpMemento
package memento;
/**
* 备忘录类
*/
public class EmpMemento {
private String ename;
private int age;
private double salary;
public EmpMemento(Emp e){
this.ename = e.getEname();
this.age = e.getAge();
this.salary = e.getSalary();
}
public String getEname() {
return ename;
}
public int getAge() {
return age;
}
public double getSalary() {
return salary;
}
}
CareTaker
package memento;
import java.util.ArrayList;
import java.util.List;
/**
* 负责人类
* 负责管理备忘录对象
*/
public class CareTaker {
private EmpMemento memento;
// private List<EmpMemento> list = new ArrayList<>();
public EmpMemento getMemento() {
return memento;
}
public void setMemento(EmpMemento memento) {
this.memento = memento;
}
}
Client
package memento;
public class Client {
public static void main(String[] args) {
CareTaker taker = new CareTaker();
Emp emp = new Emp("wxb", 18, 30000);
System.out.println("第一次打印对象: "+ emp.getEname()+"----"+emp.getAge()+"--"+emp.getSalary());
taker.setMemento(emp.memento()); // 备忘一次
emp.setAge(20);
emp.setEname("xiaoli");
emp.setSalary(500000);
System.out.println("第二次打印对象: "+ emp.getEname()+"----"+emp.getAge()+"--"+emp.getSalary());
emp.recovery(taker.getMemento()); // 恢复到备忘录对象保存的状态
System.out.println("第三次打印对象: "+ emp.getEname()+"----"+emp.getAge()+"--"+emp.getSalary());
}
}
更多推荐
设计模式(Java)
发布评论