Java的设计模式
2021-06-16 13:04
标签：oldboy str vol class 等等 invoke 时间 情况下 有一个
工厂模式 builder模式我 们称为构建器模式，通过方法方式编程，本质上是突破了标志的javabean规范。 适配器模式主要针对接口的情况下，进行预实现，具体使用时就不需要对所有方法将那些实现了。比较典型的swing中的WindowAdpator. 装饰模式比较典型的是java中的IO流，缓冲区流、压缩流都是装饰模式的体现。即在原有组件的功能基础上，增加或增强部分功能。java IO中装饰模式的根类是FilterInputStream。装饰模式的设计原则是： 观察者模式jdk给出的固定编程场景，当某个事物发生时，对其进行观察的主体就会做出响应的工作。但要注意观察者模式也成为等待通知模式，不过和多线程中的等待通知模型没有任何关系。警察与小偷的这个行为关系可以比较典型用观察者模式来实现。这里警察是观察者，观察小偷的行为，小偷是被观察者，小偷一旦进行偷窃行为，所有的警察都一拥而上，完成个自己的任务。因此设计的类如下： 责任链模式可以理解为流水线上的工人，每个工作做完自己的工作后交给下一个工作继续处理。因此类似于java中链表数据结构的概念。比如生产一辆汽车需要上轮胎、安装发动机、方向盘安装、座椅、喷漆等一序列工作，均有不同的工人完成，就可以采用责任链编程模式。代码如下： 代理模式是通过jdk提供的Proxy类实现的，其能类似于装饰模式，不同之处是可以将装饰模式理解为静态的增强实现，通常是对某些特定功能或某方面固定需求进行的实现，比如缓冲区、压缩等等。代理是一种动态的机制，在内存中动态产生对象对并对其方法进行增强，具有更加强大的功能。例如对方法执行时间进行计时统计，就可以通过代理模式来时先： Java的设计模式 标签：oldboy str vol class 等等 invoke 时间 情况下 有一个 原文地址：https://www.cnblogs.com/SteveDZC/p/9726295.htmlJava设计模式
介绍
GOF是Gang of four（四人帮）的简称，是由四位java业界的专家编写的针对特定场景下问题的专家级解决方案。大概包含23中设计模式，设计模式本身与技术没有太大关系，主要是设计思想的运用，比较著名的像单例模式、工厂模式等。本文不打算给出所有设计模式的说明，主要给出实际应用较普遍的几种且比较经典的设计
高内聚和低耦合
内聚 ：事物内部的联系程度，高内聚。
耦合 ：事物之间的联系程度，低耦合。1.单例模式
1.singleton 单例 : 类有且只有一个实例。
package com.oldboy.java.gof.singleton;
/**
* 回收站
*/
public class Trash {
//静态执行自身的引用
private static Trash instance ;
//懒汉式
public static Trash getInstance(){
if(instance != null){
return instance ;
}
//安全性控制
synchronized (Trash.class){
//需要增强该项控制
if(instance == null){
instance = new Trash() ;
}
}
return instance ;
}
//构造私有
private Trash(){
}
public static void main(String[] args) {
//多线程场景实现
new Thread() {
public void run() {
Trash t = Trash.getInstance();
System.out.println(t);
}
}.start();
new Thread() {
public void run() {
Trash t = Trash.getInstance();
System.out.println(t);
}
}.start();
}
}
- package com.oldboy.java.gof.singleton;
/**
回收站
*/
public class Trash {
//静态指向自身的引用
private static Trash instance = new Trash();
//
public static Trash getInstance(){
return instance ;
}
private Trash(){
}
public static void main(String[] args) {
//多线程场景实现
new Thread() {
public void run() {
Trash t = Trash.getInstance();
System.out.println(t);
}
}.start();
new Thread() {
public void run() {
Trash t = Trash.getInstance();
System.out.println(t);
}
- [ ] }.start();
}
}2.工厂模式
静态工厂
public class Factory1 {
/**
* 静态工厂
*/
public static TVSet newTVSet(){
TVSet tv = new TVSet();
tv.setBrand("songxia");
tv.setColor("red");
tv.setSize(120);
return tv ;
}
}非静态工厂
public class Factory2 {
/**
* 非静态工厂
*/
public TVSet newTVSet(){
TVSet tv = new TVSet();
tv.setBrand("songxia");
tv.setColor("red");
tv.setSize(120);
return tv ;
}
}3.装饰模式
class A{
}
class WrappedA extends A{
private A a ;
public WrappedA(A a){
this.a = a ;
}
public void aa(){
...
//增强A的能力
a.aa() ;
...
}
}
java中FilterInputStream的装饰流的根类。4.Builder模式
package com.oldboy.java.gof.builder; /**
* 电脑
*/
public class Computer {
private String cpu;
private String memory ;
private String hardDisk ;
public String getCpu() {
return cpu;
}
public void setCpu(String cpu) {
this.cpu = cpu;
}
public String getMemory() {
return memory;
}
public void setMemory(String memory) {
this.memory = memory;
}
public String getHardDisk() {
return hardDisk;
}
public void setHardDisk(String hardDisk) {
this.hardDisk = hardDisk;
}
/**
* 内部构建器
*/
public static class Builder{
private Computer computer = new Computer() ;
public Builder setCpu(String cpu){
computer.setCpu(cpu);
return this ;
}
public Builder setMemory(String mem){
computer.setMemory(mem);
return this ;
}
public Builder setHardDisk(String disk){
computer.setHardDisk(disk);
return this ;
}
public Computer build(){
return computer ;
}
}
}
class App{
public static void main(String[] args){
//链式编程
Computer c=new Computer.Builder()
.setCpu("intel")
.setMemory("sanxing")
.setHardDisk("xishu")
.build();
}
}5.适配器模式
5.适配
GUI : graphic user interface,图形用户接口。
适配器模式就是预实现（空实现）。
/**
窗口适配器
*/
package java.awt.event;
public abstract class WindowAdapter
implements WindowListener, WindowStateListener, WindowFocusListener
{
public void windowOpened(WindowEvent e) {}
public void windowClosing(WindowEvent e) {}
public void windowClosed(WindowEvent e) {}
public void windowIconified(WindowEvent e) {}
public void windowDeiconified(WindowEvent e) {}
public void windowActivated(WindowEvent e) {}
public void windowDeactivated(WindowEvent e) {}
...
}
public class App {
public static void main(String[] args) {
JFrame f = new JFrame() ;
f.setBounds(0 ,0 , 1366 , 768);
f.setTitle("标题栏");
//适配器模式应用
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(-1);
}
});
f.setVisible(true);
}
}6.装饰模式
class A{
public void aa(){
..
}
}
class WrappedA extends A{
private A a ;
public WrappedA(A a){
this.a = a ;
}
public void aa(){
..
a.aa() ;
..
}
}
FilterInputStream的类如下：
public
class FilterInputStream extends InputStream {
protected volatile InputStream in;
protected FilterInputStream(InputStream in) {
this.in = in;
}
public int read() throws IOException {
return in.read();
}
...
}7、观察者模式
/**
* 小偷，可被观察，因此集成java.util.Observable类。
*/
class Thief extends Observable{
public void stealOneThing(String thing){
//
System.out.println("偷了一个东西 : " + thing);
//设置改变标记
setChanged();
//通知所有观察者
notifyObservers();
}
}
/*
* 警察1-观察者
*/
class Police1 implements Observer{
public void update(Observable o, Object arg) {
System.out.println("行动1");
}
}
/**
* 警察2-观察者
*/
class Police2 implements Observer {
public void update(Observable o, Object arg) {
System.out.println("行动2");
}
}
class App{
public static void main(String[] args) {
//创建被观察者，
Thief a = new Thief();
//添加观察者
a.addObserver(new Police1());
a.addObserver(new Police2());
//让小偷开始行动
a.stealOneThing("iphone 6 plus");
}
}8、责任链模式
/**
* 工人抽象类
*/
public abstract class Worker {
//下一个工人
private Worker nextWorker ;
public Worker(){
}
public Worker(Worker nextWorker){
this.nextWorker = nextWorker ;
}
public void setNextWorker(Worker nextWorker) {
this.nextWorker = nextWorker;
}
public void work(){
doWork();
if(nextWorker != null){
nextWorker.work();
}
}
public abstract void doWork() ;
}
/**
* 轮胎工
*/
public class TireWorker extends Worker{
public void doWork() {
System.out.println("上轮胎");
}
}
/**
* 上发动机
*/
public class EngineWorker extends Worker{
public void doWork() {
System.out.println("上发动机");
}
}
/**
* 喷漆工
*/
public class PaintWorker extends Worker{
public void doWork() {
System.out.println("喷漆");
}
}
/**
* 汽车类
*/
public class Car {
public void handledBy(Worker worker){
worker.work();
}
}
/**
* App访问方式
*/
class App {
public static void main(String[] args) {
TireWorker w1 = new TireWorker();
EngineWorker w2 = new EngineWorker();
PaintWorker w3 = new PaintWorker();
w1.setNextWorker(w2);
w2.setNextWorker(w3);
Car car = new Car();
car.handledBy(w1);
}
}9、代理模式
/**
* 接口
*/
static interface WelcomeService{
public void sayHello() ;
}
/**
* 实习类
*/
class WelcomeServiceImpl implements WelcomeService{
public void sayHello() {
System.out.println("hello world");
}
}
//主函数
public static void main(String[] args) {
final WelcomeService ws = new WelcomeServiceImpl() ;
//处理器
InvocationHandler h = new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long start = System.nanoTime() ;
Object obj = method.invoke(ws , args) ;
System.out.println("执行耗时 ： " + (System.nanoTime() - start));
return obj;
}
} ;
ClassLoader loader = ClassLoader.getSystemClassLoader() ;
//创建代理对象
WelcomeService proxy = (WelcomeService) Proxy.newProxyInstance(loader ,new Class[]{WelcomeService.class} , h);
proxy.sayHello();
}