设计模式
装饰者模式
:在原有的基础上动态的添加新的功能,是在对象层面实现功能扩展,而不是继承的层面.
// 一个机器人
interface robot {
void doSomething();
}
//原有的功能
class Robot implements robot {
@Override
public void doSomething() {
System.out.println("dosomething");
}
}
//在原有的功能上进行动态的扩展
//定义成抽象的更加灵活
abstract class RobotDecorator implements robot {
//需要关联 原有的功能
private Robot robot;
public RobotDecorator(Robot robot) {
this.robot = robot;
}
@Override
public void doSomething() {
robot.doSomething();
}
//动态的扩展
public void moreSomething(){
System.out.println("more");
}
}
适配器模式
:是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式
主要解决 :原本接口不匹配而无法工作的两个类能够在一起工作
public class Test {
public static void main(String[] args) {
System.out.println(new Adapter(new Speaker()).translate());
}
}
class Speaker {
public String speak() {
return "演讲";
}
}
interface Translator {
String translate();
}
//Adapter属于是桥梁 将speak 和 translate 放在一起工作
class Adapter implements Translator {
private Speaker speaker;
public Adapter(Speaker speaker) {
this.speaker = speaker;
}
@Override
public String translate() {
String translate = "翻译"
String speak = speaker.speak();
return speak+translate;
}
}
观察者模式
:定义对象间的一种一对多依赖关系,当一个对象被修改时,则会自动通知依赖它的对象 观察者模式属于行为型模式。
class guanchazhe{
public static void main(String[] args) {
poor p = new poor();
rich r = new rich();
p.borrow(r);
p.notifyCreditor();
}
}
//举个例子 类似与一份合同,想要借钱就要实现这个合同。
interface Debit{
void borrow (Creditor creditor);
void notifyCreditor();
}
interface Creditor {
void repay();
}
//穷人借钱 实现接口
class poor implements Debit{
private List<Creditor> allCreditor = new ArrayList<>();
//把每个债主记录一下
@Override
public void borrow(Creditor creditor) {
allCreditor.add(creditor);
}
@Override
public void notifyCreditor() {
//通知每个债主还钱
allCreditor.forEach(Creditor::repay);
}
}
//富人借给穷人 实现接口
class rich implements Creditor{
@Override
public void repay() {
System.out.println("rich");
}
}
外观模式
:向客户端提供了一个客户端可以访问系统的接口。这种类型的设计模式属于结构型模式,它向现有的系统添加一个接口,来隐藏系统的复杂性。
**主要解决:**降低访问复杂系统的内部子系统时的复杂度,简化客户端之间的接口。
class test{
public static void main(String[] args) {
Square square = new Square();
Circle circle = new Circle();
ShapeMaker s = new ShapeMaker(square,circle);
s.squareDraw();
s.circleDraw();
}
}
interface Shape{
void draw();
}
class Square implements Shape {
@Override
public void draw() {
System.out.println("Square::draw()");
}
}
class Circle implements Shape {
@Override
public void draw() {
System.out.println("Circle::draw()");
}
}
//一个外观类
class ShapeMaker {
private Square square;
private Circle circle;
public ShapeMaker(Square square, Circle circle) {
this.square = square;
this.circle = circle;
}
public void squareDraw(){
square.draw();
}
public void circleDraw(){
circle.draw();
}
}
状态模式
类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。
//每一个类代表一种状态 会做出一种反应, 把一个类当成一种状态传递给Context类,Context类会去执行当前状态的方法
class waiguan{
public static void main(String[] args) {
Happy happy = new Happy();
Context context = new Context(happy);
context.doSomething();
}
}
abstract class State {
public abstract void doWork();
}
class Happy extends State {
@Override
public void doWork() {
System.out.println("积极");
}
}
class Sad extends State {
@Override
public void doWork() {
System.out.println("难过懊恼");
}
}
//状态类
class Context{
//传递状态
private State state;
public Context(State state) {
this.state = state;
}
public void doSomething (){
state.doWork();
}
}
代理模式
为其他对象提供一种代理以控制对这个对象的访问 这种类型的设计模式属于结构型模式。
//举个例子,员工需要找老板签字 但是不知道老板在哪儿,所以需要交给秘书,让秘书交给老板
class daili{
public static void main(String[] args) {
Boss realSubject = new Boss();
Proxy p = new Proxy(realSubject);
p.doSomething();
}
}
//目标类接口
interface Subject{
void doSomething ();
}
//老板
class Boss implements Subject{
@Override
public void doSomething() {
System.out.println("老板处理文件");
}
}
//代理类 秘书
class Proxy implements Subject{
// 和老板建立关系
private Boss boss;
public Proxy(Boss realSubject) {
this.boss = realSubject;
}
public void connect(){
System.out.println("秘书找老板");
}
@Override
public void doSomething() {
connect();
boss.doSomething();
}
}
责任链模式
是一种处理请求的模式,为请求创建了一个接收者对象的链,处理不了给下一个处理者处理。这种类型的设计模式属于行为型模式。
举个例子,类似于请假,需要一级一级的向上审批
class zerenlian{
public static void main(String[] args) {
Leader leader = new Leader();
Boss boss = new Boss();
leader.setNextHandler(bosss);
leader.process(10);
}
}
abstract class Handler {
//当当前处理者处理不了的时候发送给下一个处理者
protected Handler nextHandler;
//定义下一个处理者是谁
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
//能处理哪些
public abstract void process(int i);
}
class Leader extends Handler {
@Override
public void process(int i) {
if (i < 5) {
System.out.println("leader 处理");
} else {
//发送给下一个处理者
nextHandler.process(i);
}
}
}
class Boss extends Handler {
@Override
public void process(int i) {
System.out.println("boss处理");
}
}
模板模式
一个抽象类公开定义了执行它的方法的方式
子类不可以改变一个算法中的结构,但是可以重新定义该算法中的某些特定步骤 。这种类型的设计模式属于行为型模式。主要作用还是代码复用。
class moban{
public static void main(String[] args) {
LOL l = new LOL();
l.play();
}
}
abstract class Game {
abstract void initialize();
abstract void startPlay();
abstract void endPlay();
//模板
public final void play() {
//初始化游戏
initialize();
//开始游戏
startPlay();
//结束游戏
endPlay();
}
}
//重新定义GAME中的某些特定步骤
class LOL extends Game {
@Override
void initialize() {
System.out.println("LOL初始化");
}
@Override
void startPlay() {
System.out.println("LOL开始");
}
@Override
void endPlay() {
System.out.println("LOL结束");
}
}
class DNF extends Game{
@Override
void initialize() {
System.out.println("DNF初始化");
}
@Override
void startPlay() {
System.out.println("DNF开始");
}
@Override
void endPlay() {
System.out.println("DNF结束");
}
}
-----推荐个B站UP主 子烁爱学习