Java设计七大原则以及23种设计模式简单介绍

更新时间:2021-09-30 10:11:06 点击次数:926次
七大原则
1、单一原则:一个类只负责一个职责
2、开闭原则:对修改关闭,对扩展开放
3、里氏替换原则:不要破坏继承关系
4、接口隔离原则:暴露最小接口,避免接口过于臃肿
5、依赖倒置原则:面向抽象编程
6、迪米特法则:尽量不跟陌生人讲话
7、合成复用原则:多使用组合、聚合、少用继承

1、单一原则
一个方法 一个类只负责一个职责,各个职责的程序改动,不影响其它程序,实现 高内聚,低耦合

优点:降低耦合,提高可维护性,对一个类进行单独处理并且不影响其他类

2、开闭原则
对修改关闭,对扩展开放,核心是:抽象化,多态使用
优点:提高可扩展性,提高可维护性,提高可复用性

3、里氏替换原则
所有使用父类的地方,必须能够透明的使用子类对象

例如:父类Animal;子类Dog继承父类Animal,子类Cat继承父类Animal。

Animal animal=new Dog();
//同样可以透明的使用
Animal animal=new Cat();
当子类重写父类的方法时,则不适合使用里氏替换原则。

4、接口隔离原则
每一个接口承担独立的角色,只干自己该干的事情。
只暴露最小接口,实现类不需要用到实现的方法不要放在接口。

5、依赖倒置原则
指的是面向抽象编程,对抽象类或接口进行依赖,比较灵活。
比如:有抽象类Animal,子类Dog继承父类Animal,子类Cat继承父类Animal。在依赖的时候用抽象类,在使用的时候指定子类

//抽象类和子类
abstract class  Animal{
abstract void hello();
}
class Dog extends Animal{
@Override
void hello() {
System.out.println("hello ,I am dog");
}
}
class Cat extends Animal{
@Override
void hello() {
System.out.println("hello ,I am cat");
}
}

//依赖到抽象类
class Client{
Animal a;
public Client(Animal a){
this.a=a;
}
public void hello(){
a.hello();
}
}
//测试类进行使用
public class Test {

    public static void main(String args[]) {
   //在使用到Animal的使用,需要定义它的子类
    Client c=new Client(new Dog());
    c.hello();//打印指定的方法
    }
}
6、迪米特法则
尽量不要跟陌生人说话。
不是陌生人的情况:

当前对象本身(this)
方法参数
对象的成员对象
对象所创建的对象
目的:降低耦合,高内聚

7、合成复用原则
尽量使用组合、聚合的方式,少使用继承。
原因:继承会导致耦合度变高。
聚合方式的使用案例:

class A{}
class Test{
A a;
public void useA(A a){
this.a=a;
}
}
组合方式的使用案例:
class A{}
class Test{
A a=new A();
}
组合和聚合的区别 : 组合方式在使用Test对象的时候会立即开辟A对象的空间,而聚合的方式是在使用到A对象的时候才会开辟A对象的空间。

三、23种设计模式

创建型模式:主要关注点是“怎样创建对象”

1、单例模式(Singleton)
特点:当需求是一个类只需要一个实例
单例模式有:1、饿汉模式;2、懒汉模式;3、双重检查模式;4、枚举模式

饿汉模式(推荐使用)

特点: 当类加载时创建好对象,并且在外部不能通过new创建该对象,只能调用这个类的的方法进行调用。线程安全,在实际开发中用的最多
案例:
方式一

/**
 * 饿汉方式一
 * @Author:小庄
 */
public class Singleton {
    //private不允许外部调用new创建对象
    private Singleton(){}
    //使用静态关键字”static“保证只有一次
    private static Singleton instance=new Singleton();
    //外部可直接通过类进行调用静态方法
    public static Singleton getInstance(){
        return instance;
    }
}
/**
 * 饿汉方式二
 * @Author:小庄
 */
class Singleton2 {
    private static Singleton2 instance;
    private Singleton2(){
        instance=new Singleton2();
    }
    //外部可直接通过类进行调用静态方法
    public static Singleton2 getInstance(){
        return instance;
    }
}
/**
 * 饿汉方式三
 * @Author:小庄
 */
class Singleton3 {
    private static Singleton3 instance;
    static {
        instance=new Singleton3();
    }
    private Singleton3(){}
    //外部可直接通过类进行调用静态方法
    public static Singleton3 getInstance(){
        return instance;
    }
}
懒汉模式(不推荐使用)

特点: 等需要该类的时候再加载,会考虑线程安全问题
1、不安全的懒汉模式

/**
 * 线程不安全的懒汉模式
 * @Author:小庄
 */
class Singleton{
    private static Singleton instance;
    private Singleton(){}
    public static Singleton getInstance(){
    instance=new Singleton();
        return instance;
    }
}
class Singleton2{
    private static Singleton2 instance;
    private Singleton2(){}
    public static  Singleton2 getInstance(){
    if(instance!=null){
    synchronized(Singleton2.class){
    instance=new Singleton2();
    }
    }
        return instance;
    }
}
以上代码线程不安全的原因:当几个线程同时访问的时候,就有可能创建多个对象实例。

2、线程安全的懒汉模式

/**
 * 线程安全的懒汉模式
 * @Author:小庄
 */
class Singleton{
    private static Singleton instance;
    private Singleton(){}
    public static synchronized Singleton getInstance(){
    if(instance!=null){
    instance=new Singleton();
    }
        return instance;
    }
}

以上代码缺点:当getInstance()方法里面的逻辑代码很复杂时,所有的代码都被加锁,会大大的消耗性能

双重检查懒汉模式(线程安全)

/**
 * 线程安全的懒汉模式
 * @Author:小庄
 */
class Singleton{
    private static Singleton instance;
    private Singleton(){}
    public static  Singleton getInstance(){
    if(instance!=null){
    //进行加锁
    synchronized(Singleton.class){
    //再进行一次判断类是否为空
if(instance!=null){
instance=new Singleton();
}
}
    }
        return instance;
    }
}
静态内部类实现单例

/**
 *内部类实现单例
 * @Author:小庄
 */
class Singleton{
    //设置为private
    private Singleton(){}
    //内部类的特性,外部类不能直接访问
    private static class GetSingleton{
       private static final Singleton instance=new Singleton();
    }
    public Singleton getInstance(){
        return GetSingleton.instance;
    }
}
运用枚举实现单例(推荐使用)

enum Singleton2{
    ONE,TWO,THREE;//一个属性代表一个实例,这里有三个实例
}

小结

推荐使用饿汉模式和枚举模式实现单例的原因是线程安全,而且简单明了
不推荐使用懒汉模式的原因是:1、部分的懒汉模式不安全 ;2、过于繁琐 ;3、有可能会对性能造成额外消耗

2、工厂模式(Factoy)
特点:对类的创建用一个工厂类进行管理。

工厂模式分为:简单工厂,工厂方法和抽象工厂,这节内容主要讲简单工厂和工厂方法。

简单工厂

由一个工厂对象决定创建出哪一种产品类的实例
简单工厂的类图:


具体代码实现:

public class SimpleFactory{
public createProduct(int i){
switch (i){
            case 0: new Product1();break;
            case 1: new Product2();break;
            case 2: new Product3();break;
            default: System.out.println("没有该产品");
        }
}
//具体的使用者
public static void main(String[] args){
SimpleFactory factory=new SimpleFactory();
//通过工厂进行创建类
factory.createProduct(1);
}
}
class Product1{}
class Product2{}
class Product3{}
工厂方法
//抽象类
abstract class FactoryMethod {
//生产方法
public abstract void production(String productName);
}
class Product1 extends FactoryMethod {
//实现抽象方法
@Override
public void production(String productName) {
System.out.println("Product1生产了"+productName+"产品");

}
}
class Product2 extends FactoryMethod {
//实现抽象方法
@Override
public void production(String productName) {
System.out.println("Product2生产了"+productName+"产品");

}
}
//使用者
public class Client{
public static void main(String[] args) {
FactoryMethod factory=new Product1();
factory.production("x");
}
}
3、抽象工厂模式(AbstractFactory)
角色:

AbstractProduct (抽象产品)
AbstractFactory (抽象工厂)
Client (委托者)

具体实现如下,为了保证代码的阅读,这里不对类的具体操作进行展开

//定义抽象工厂类
abstract class AbstractFactory {
//定义抽象方法,返回值是抽象产品类对象
abstract AbstractClass1 createClass1();
abstract AbstractClass2 createClass2();
abstract AbstractClass3 createClass3();
}
//把抽象产品类全部定义完
abstract class AbstractClass1 {}
abstract class AbstractClass2 {}
abstract class AbstractClass3 {}
//定义具体产品类,分别继承对应的抽象产品类
class Class1 extends AbstractClass1{}
class Class2 extends AbstractClass2{}
class Class3 extends AbstractClass3{}
//定义具体工厂类,实现抽象方法,具体工厂类1
class Factory1 extends AbstractFactory{
@Override
AbstractClass1 createClass1() {
// TODO Auto-generated method stub
return new Class1();
}
@Override
AbstractClass2 createClass2() {
// TODO Auto-generated method stub
return new Class2();
}
@Override
AbstractClass3 createClass3() {
// TODO Auto-generated method stub
return new Class3();
}
}
//具体工厂类2
class Factory2 extends AbstractFactory{
@Override
AbstractClass1 createClass1() {
// TODO Auto-generated method stub
return new Class1();
}
@Override
AbstractClass2 createClass2() {
// TODO Auto-generated method stub
return new Class2();
}
@Override
AbstractClass3 createClass3() {
// TODO Auto-generated method stub
return new Class3();
}
}
分析

从上面代码中,我们可以发现,抽象工厂处理的是产品一族,它们和工厂方法的区别在于:工厂方法有利于处理一个产品的部件扩展维度,而抽象工厂有利于扩展产品一族维度。

4、原型模式(Prototype)
特点:必须实现Cloneable接口,并且重写clone方法,否则会报错
应用场景:一个对象属性特别多,同时指定很麻烦,实际工作中用的很少

角色:

Prototype(原型)
ConcretePrototype(具体原型)
Client(使用者)
浅克隆

//原型接口继承Cloneable接口,或者抽象类实现Cloneable接口
interface Prototype extends Cloneable{
}
//具体原型类实现原型接口,重写方法
public class ConcretePrototype implements Prototype {
    @Override
    protected Object clone() throws CloneNotSupportedException {
       //通过克隆自身对象
        ConcretePrototype p=(ConcretePrototype)this.clone();
        //返回克隆后的值
        return p;
    }
}
通过clone实现深拷贝

//原型接口继承Cloneable接口,或者抽象类实现Cloneable接口
interface Prototype extends Cloneable{
}
//具体原型类实现原型接口,重写方法
public class ConcretePrototype implements Prototype {
    //假设有一个对象属性,需要克隆这个对象属性
    public Book book;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        //对基本属性进行克隆
        Object deep=null;
        deep=super.clone();
        //对引用类型的数据进行单独处理
        ConcretePrototype c=(ConcretePrototype )deep;
        c.book= (Book)book.clone();
        //返回克隆后的值
        return deep;
    }
}
缺点:繁琐
通过序列化实现深拷贝

public class Book implements Serializable{
  
    //浅克隆,使用默认的clone方法
    public Object deepClone() {

        ByteArrayInputStream bis=null;
        ByteArrayOutputStream bos=null;
        ObjectOutputStream oos=null;
        ObjectInputStream ois=null;
        try{
            bos=new ByteArrayOutputStream();
            oos=new ObjectOutputStream(bos);
            oos.writeObject(this);
            //反序列化
            bis=new ByteArrayInputStream(bos.toByteArray());
            ois=new ObjectInputStream(bis);
             Book book=(Book)ois.readObject();
            return book;
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }finally {
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
5、建造者模式(Builder)
特点:处理复杂对象的创建,在使用时只需要用想要的属性时,不需要设置所有参数;这个建造者模式和模板方法特别像

角色:

Builder(建造者)
ConcreteBuilder(具体建造者)
Director(监工)
Client(使用者)
//建造者接口或抽象类
interface Builder {
//具体步骤
Builder creteBuilder();
Builder creteBuilder2();
Builder creteBuilder3();
}
//具体建造类
class ConcreteBuilder implements Builder{
//实现具体步骤,返回值为当前对象,便于链式编程
@Override
public Builder creteBuilder() {
System.out.println("建造第一层");
return this;
}
@Override
public Builder creteBuilder2() {
System.out.println("建造第二层");
return this;
}
@Override
public Builder creteBuilder3() {
System.out.println("建造第三层");
return this;
}
}
//监工
class Director {
//将抽象类(接口)聚合,然后对抽象方法进行调用,会指向子类实现的方法
Builder builder;
public Director(Builder builder) {
this.builder=builder;
}
public void toBuilder() {
builder.creteBuilder().creteBuilder2().creteBuilder3();
}
}
//使用者
public class Client {
public static void main(String[] args) {
//通过监工直接建造
Director d=new Director(new ConcreteBuilder());
d.toBuilder();
}
}
比较常用的使用方式

//模拟建造者模式的具体使用
public class Person {
//这里定义了很多的属性,但是有时候只需要部分的属性
int id;
String name;
int age;
double weight;
int score;
//将构造函数设置为私有属性,不让外部进行访问
private Person() {}
//定义内部类,通过内部类对类的成员变量进行操作,可以叫它为静态工厂
public static class PersonBuilder{
Person p=new Person();
//每次方法返回值不为void,而是直接返回当前的对象,有利于链式方程
public PersonBuilder basicInfo(int id,String name,int age) {
p.id=id;
p.name=name;
p.age=age;
return this;
}
public PersonBuilder weight(double weight) {
p.weight=weight;
return this;
}
public PersonBuilder score(int score) {
p.score=score;
return this;
}
//通过下面方法返回外部类对象
public Person build() {return p;}
}
//打印
public static void main(String[] args) {
//采用链式编程,直观
Person p=new Person.PersonBuilder().basicInfo(1, "张三", 18).weight(65.0).build();
}
}
6、适配者模式(Adapte)
角色:

Target(对象)
Adaptee(被适配)
Adapter(适配)
1、类适配器模式


//目标接口
interface Target {
public int open110V();
}
//被适配类
class ClassAdaptee{
public int open220V(){
return 200;
}
}
//适配类
public class ClassAdapte extends ClassAdapteeimplements Target{
@Override
public int open110V() {
int voltage=open220V();
return voltage/2;
}
}
2、对象适配器


和类适配器的区别,适配器和被适配者之间没有继承关系,通过聚合实现(合成复用)

//目标类,可以用抽象类代替
abstract Target {
public abstract int open110V();
}
//被适配类
class ClassAdaptee{
public int open220V(){
return 200;
}
}
//适配类
public class ClassAdapte extends Target{
public ClassAdaptee adaptee;
public ClassAdapte(ClassAdaptee e){
this.adaptee=e;
}
@Override
public int open110V() {
int voltage=e.open220V();
return voltage/2;
}
}

7、桥连模式(Bridge)了解
特点:
双维度扩展
分离抽象和具体
用聚合的方式连接抽象和具体

类图


abstract class AbstractBridge {
//聚合实现者
Implementor imt;
}
//具体桥连者
class ConcreteBride extends AbstractBridge{
//把实现者作为参数
public ConcreteBride(Implementor imt) {
this.imt=imt;
}
}
//抽象化实现者
interface Implementor {
}
//具体实现者
public class ConcreteImplementor implements Implementor{
}
8、装饰者模式(Decorator)
特点:对类进行扩展时不修改原有的代码

类图:


案例应用:


//定义Drink抽象类,并设定好抽象方法
 abstract class Drink {
private String des;//描述
private float price=0.0f;//价格
public String getDes() {
return des+"价格:"+price;
}
public void setDes(String des) {
this.des = des;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}
//计算费用的抽象方法
protected abstract float cost();
}

//Coffee类继承Drink抽象类,因为Coffee只是一种饮料
abstract class Coffee extends Drink{
}
//定义具体咖啡,并设置好属性
class Cafe_Latte extends Coffee{

public Cafe_Latte() {
super.setDes("拿铁咖啡");
super.setPrice(18.80f);
}
@Override
protected float cost() {
//获取价格
return super.getPrice();
}
}
//咖啡的具体实现类
class Instant_Coffee extends Coffee{

public Instant_Coffee(int shuliang) {
super.setDes("速溶咖啡");
super.setPrice(14.00f);
}
@Override
protected float cost() {
return super.getPrice();
}
}
class Cafe_Latte extends Coffee{

public Cafe_Latte() {
super.setDes("拿铁咖啡");
super.setPrice(18.80f);
}
@Override
protected float cost() {
return super.getPrice();
}
}
//通过继承Drink方便进行装饰类
 class DeCorator extends Drink{
private Drink drink;
private String des;//描述
private float price=0.0f;//价格
private int shuliang=1;//数量
public DeCorator(Drink drink) {
this.drink=drink;
}
public DeCorator(Drink drink,int shuliang) {
this.drink=drink;
this.shuliang=shuliang;
}
public String getDes() {
return drink.getDes()+" "+" 加入"+shuliang+"份"+des+" "+des+"单价:"+price;
}
public void setDes(String des) {
this.des = des;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}
protected float cost() {
float material_price=this.price*this.shuliang;
return material_price+drink.cost();
}
}
//装饰者的具体实现类
class Milk extends DeCorator{
public Milk(Drink drink) {
super(drink);
super.setDes("牛奶");
super.setPrice(2f);
}
public Milk(Drink drink, int shuliang) {
super(drink, shuliang);
super.setDes("牛奶");
super.setPrice(2f);
}
}
//装饰者的具体实现类
class Sugar extends DeCorator{
public Sugar(Drink drink) {
super(drink);
super.setDes("糖");
super.setPrice(1f);
}
public Sugar(Drink drink, int shuliang) {
super(drink, shuliang);
super.setDes("糖");
super.setPrice(1f);
}
}
//使用者测试类
public class Client {
public static void main(String[] args) {
Drink order=new Cafe_Latte();
System.out.println("费用:"+order.cost());
System.out.println(order.getDes());
order=new Milk(order);
System.out.println("加入一份牛奶的费用:"+order.cost());
System.out.println(order.getDes());
}
}
9、享元模式(Flyweight)
特点:共享数据,重复利用对象

应用场景:数据库连接池

类图:

角色:

抽象化享元对象
享元对象
享元池
下面是图书馆案例,图书馆作为享元池,书架作为抽象化享元对象,书籍作为享元对象。

来看类图


//抽象化享元对象
abstract class Book {
HashMap<String,Boolean> start=new HashMap<>();
abstract void borrow(Lender lender);
abstract void setBookStart(String bookName,boolean bookStart);
abstract boolean getBookStart(String bookName);
}
//具体享元对象
class MixBook extends Book{
private String bookName="";//书名
private boolean bookStart;
public MixBook(String bookName) {
this.bookName=bookName;
}
@Override
public void borrow(Lender lender) {
System.out.println(lender.getName()+"向图书馆借出一本"+bookName);
}
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
public boolean getBookStart(String bookName) {
if(start.get(bookName)) return true;
else return false;
}
public void setBookStart(String bookName,boolean bookStart) {
start.put(bookName, bookStart);
}
}
//外部状态
class Lender {
private String name;
public Lender(String name) {
this.name = name;

}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
import java.util.HashMap;
//享元池
class Library {
//设置图书馆为单例,只能生成一个实例对象
private static Library library=new Library();
//防止外部通过new生成实例
private Library(){};
//书架
HashMap<String,Book> pool=new HashMap<>();

public static Library getInstance() {
return library;
}
public Book toBorrow(String bookName,Lender lender) {
Book book=null;
if(pool.isEmpty()) {
System.out.println("图书馆目前没有书,请添加书籍");
}
else if(!pool.containsKey(bookName)) {
//如果没有,提示图书馆没有这本书,请联系图书管理员
System.out.println("图书馆没有"+bookName+",请联系图书管理员");

}else {
book=pool.get(bookName);
if(!book.getBookStart(bookName)){
System.out.println("你好"+lender.getName()+":"+bookName+"已经被借走了");
book=null;
}
else {
book.start.put(bookName, false);
book.borrow(lender);
}
}
return book;
}
public void shelveBook(String bookName,Book book) {
book.setBookStart(bookName,true);
pool.put(bookName, book);
}
public int poolSize() {
return pool.size();
}
}
//使用享元池
public class Student {
public static void main(String[] args) {
//通过单例模式进行创建图书馆享元池
Library library=Library.getInstance();
library.shelveBook("《Java编程思想》", new MixBook("《Java编程思想》"));
library.shelveBook("《Mysql必会知识》", new MixBook("《Mysql必会知识》"));
//设置借阅人
Lender lender=new Lender("小庄");
Book book1=library.toBorrow("《Java编程思想》",lender);
Book book2=library.toBorrow("《Java编程思想》",lender);
Book book3=library.toBorrow("《Mysql必会知识》",lender);
//查看享元池借出的书籍
System.out.println("图书馆借出书籍共:"+library.poolSize()+"个");
}
}
10、代理模式(Proxy)
代理模式分为:静态代理,动态代理
本篇内容只对动态代理的jdk代理和cglib代理介绍

静态代理


角色:

代理类
被代理类
抽象化被代理类
使用者
//抽象化被代理类
interface IBoard {
void draw();
}
//具体被代理类
class Board implements IBoard{
@Override
public void draw() {
System.out.println("被代理类画画操作执行");
}
}
//静态代理类
class StaticProxy implements IBoard{
//聚合抽象化被代理类
private IBoard board;
public StaticProxy(IBoard board) {
this.board=board;
}
//通过代理类执行被代理类的方法
@Override
public void draw() {
System.out.println("代理类执行自己操作");
System.out.print("============");
board.draw();//调用被代理类执行的方法
System.out.print("============");
System.out.println("代理类执行结束");
}
}
//使用者
public class Client {
public static void main(String[] args) {
//通过静态代理类进行调用被代理类的方法
new StaticProxy(new Board()).draw();
}
}
动态代理模式之JDK代理


jdk代理主要通过反射的方式进行代理,JDK代理本身就继承了Proxy类,由于Java不支持多继承,所以不支持对类的代理,只支持对接口的代理。
具体案例如下:

//接口1
interface IBoard {
void draw();
}
//接口2
interface IComputer {
void open();
void complete();
}
//接口1的实现类
class Board implements IBoard{
@Override
public void draw() {
System.out.println("被代理类画画操作执行");
}
}
//接口2的实现类
class Computer implements IComputer{
@Override
public void open() {
System.out.println("电脑正在启动....");
}
@Override
public void complete() {
System.out.println("电脑启动完成");
}
}
//代理类
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

class JDKProxy {
//设置被代理对象
private Object target;
//通过构造函数设置被代理对象
public JDKProxy(Object target) {
this.target=target;
}
//被代理对象生成
public Object getProxyInstance() {
//返回一个JDK代理类对象
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),new InvocationHandler() {

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("=================");
System.out.println("代理开始");
Object object=method.invoke(target, args);
System.out.println("被代理的方法名:"+method.getName());
if("open"==method.getName()) {
Method complete=target.getClass().getMethod("complete");
if(null!=complete){
System.out.println("complete方法被代理对象自动调用");
Thread.sleep(1000);
complete.invoke(target, args);
}
}
System.out.println("代理结束");
System.out.println("=================");
System.out.println();
return object;
}
});
}
}
//使用者
public class Client {
public static void main(String[] args) {
//代理画板对象
JDKProxy board=new JDKProxy(new Board());
IBoard iBoard=(IBoard)board.getProxyInstance();
//调用画板的draw()方法
iBoard.draw();
//代理电脑对象
JDKProxy computer=new JDKProxy(new Computer());
IComputer iComputer=(IComputer) computer.getProxyInstance();
//这里只调用了open()方法,但是complete会被代理对象自动调用
iComputer.open();
}
}
动态代理之cglib代理


我们知道,使用Jdk代理的不足之处是不能对类进行代理,而Cglib代理刚好解决了这个问题。
Cglib可以对无接口的类进行代理,需要实现MethodInterceptor接口

具体案例:

//没有实现接口的类1
class Board{
public void draw() {
System.out.println("被代理类画画操作执行");
}
}
//没有实现接口的类2
class Computer{
public void open() {
System.out.println("电脑正在启动....");
}
public void complete() {
System.out.println("电脑启动完成");
}
}
//Cglib代理
import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
//实现MethodInterceptor接口,重写intercept方法(实现代理功能)
class CglibProxy implements MethodInterceptor{
//设置被代理类
public Object target;
//通过构造函数进行设置
public CglibProxy(Object target) {
this.target=target;
}
/**
*实现代理的关键:
*1.创建工具类Enhancer
*2.设置它的父类,会在虚拟机生成一个父类
*3.设置回调函数
*4.创建子类对象,作为代理对象
*/
public Object getProxyInstance() {
//创建工具类
Enhancer e=new Enhancer();
//设置父类
e.setSuperclass(target.getClass());
//设置回调函数
e.setCallback(this);
//创建子类对象,作为代理对象
return e.create();
}
@Override
public Object intercept(Object arg0, Method method, Object[] args, MethodProxy arg3) throws Throwable {
System.out.println("===============");
//代理模式底层使用反射
System.out.println("Cglib代理模式开始");
//invoke激活,和jdk代理功能类似
Object object=method.invoke(target, args);
System.out.println("被代理的方法名:"+method.getName());
//在代理类实现自己的功能
if("open"==method.getName()) {
Method complete=target.getClass().getMethod("complete");
if(null!=complete){
System.out.println("complete方法被代理对象自动调用");
Thread.sleep(1000);
complete.invoke(target, args);
}
}
System.out.println("代理结束");
System.out.println("=================");
System.out.println();
return object;
}
}
11、组合模式(Composite)
一般适用于树状结构的场景,比如文件结构,比如层级结构


实现代码如下:

//结点
abstract class Node {
public abstract void printNode();
}
//导入相关的包
import java.util.ArrayList;
import java.util.List;
//根结点/子结点
class BranchNode extends Node{
//给结点起个名字
String nodeName;
//将它以下结点进行收集
public List<Node> nodes=new ArrayList<>();
public BranchNode(String nodeName) {
this.nodeName=nodeName;
}
public void addNode(Node node) {
nodes.add(node);
}
//打印结点
@Override
public void printNode() {
System.out.println(nodeName);
}
}
//叶子结点
class LeafNode extends Node{
//给结点起个名字
String nodeName;
public LeafNode(String nodeName) {
this.nodeName=nodeName;
}
//打印叶子结点信息
@Override
public void printNode() {
System.out.println(nodeName);
}
}
//使用者
public class Client {
public static void main(String[] args) {
BranchNode root=new BranchNode("根结点");
BranchNode node1=new BranchNode("结点1");
Node c1=new LeafNode("叶子结点1");
Node c2=new LeafNode("叶子结点2");
//添加结点
root.addNode(node1);
//添加叶子结点
node1.addNode(c1);
node1.addNode(c2);
//使用递归遍历
tree(root,0);
}
public static void tree(Node node,int depth) {
for(int i=0;i<depth;i++) {
System.out.print("--");
}
node.printNode();
//判断是否是根结点
if(node instanceof BranchNode) {
//递归遍历结点
for(Node n:((BranchNode) node).nodes){
tree(n,depth+1);
}
}
}
}
生活中用到组合模式的例子:学校,学院(系)和专业


//结点
abstract class Composite {
private String des;
private String name;
public Composite(String name,String des) {
this.name=name;
this.des=des;
}
protected void add(Composite composite) {
}
protected void remove(Composite composite) {}
protected abstract void print();
public String getDes() {
return des;
}
public void setDes(String des) {
this.des = des;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
//学院(系)
import java.util.HashSet;

class College extends Composite{
HashSet<Major> majors=new HashSet<>();
public College(String name,String des) {
super(name,des);
}
@Override
protected void add(Composite composite) {
majors.add((Major)composite);
}
@Override
protected void remove(Composite composite) {
majors.remove((Major)composite);
}
@Override
public String getName() {
return super.getName();
}
@Override
public String getDes() {
return super.getDes();
}
@Override
protected void print() {
System.out.println("学院:"+getName());
System.out.println();
for(Major major:majors) {
System.out.println("专业:"+major.getName()+"\t专业详情:"+major.getDes());
}
System.out.println("=====================");
}
}
//导入相关包

import java.util.Set;
//学校
class University extends Composite{
//学校由多个学院(系)组成
Set<College> colleges=new HashSet<>();

public University(String name,String des) {
super(name,des);
}
@Override
protected void add(Composite composite) {
colleges.add((College)composite);
}
@Override
protected void remove(Composite composite) {
colleges.remove((College)composite);
}
@Override
public String getName() {
return super.getName();
}
@Override
public String getDes() {
return super.getDes();
}
@Override
protected void print() {
System.out.println("========"+getName()+"========");
System.out.println("简介:"+getDes());
System.out.println();
for(College college:colleges) {
System.out.println("学院:"+college.getName()+"\t学院详情:"+college.getDes());
}
System.out.println("=====================");
}
}
//专业,对于叶子结点
public class Major extends Composite{
public Major(String name,String des) {
super(name,des);
}
@Override
protected void print() {
System.out.println(super.getName()+super.getDes());
}
}
//使用者
public class Client {
public static void main(String[] args) {
University university=new University("清华大学", "中国顶尖学府");
College c=new College("计算机学院","培养软件+硬件高级人才");
university.add(c);
university.add(new College("金融学院", "培养金融行业高级人才"));
university.print();
c.add(new Major("计算机科学与技术","老牌的计算机专业"));
c.print();
}
}
12、外观模式(Facade)
外观模式又称为门面模式,通常和责任链模式结合使用
使用场景:解决多个类之间的复杂关系,只需要通过一个类就可以直接和其他类进行交互,具体使用:中间件

通过案例进行讲解:


//经纪人,门面
class Agent {
private static Agent agent=new Agent();
//通过单例模式获取类对象
protected Star star=Star.getInstance();;
protected Fans fans=Fans.getInstance();
protected Company company=Company.getInstance();
private Agent() {}
//见面机会方法
protected void meeting() {
System.out.println("粉丝"+fans.getName()+"与"+star.getName()+"获得一次见面机会");
}
//签约方法
protected void contract() {
System.out.println("明星"+star.getName()+"与"+company.getName()+"进行了签约");
}
public static Agent getInstance() {
return agent;
}
}
//明星类
class Star {
private static Star star=new Star();
protected volatile String name="";
private Star() {}
public String getName() {
return name;
}
public synchronized void setName(String name) {
this.name = name;
}
protected static Star getInstance() {
return star;
}
}
//粉丝
class Fans {
private static Fans fans=new Fans();
private volatile String name="";
private Fans() {}
public String getName() {
return name;
}

public synchronized void setName(String name) {
this.name = name;
}
public static Fans getInstance() {
return fans;
}
}
//签约公司
class Company {
private volatile String  name="";
private static Company company=new Company();
private Company() {}
public String getName() {
return name;
}
public synchronized void setName(String name) {
this.name = name;
}
public static Company getInstance() {
return  company;
}
}
//用户测试
public class Client {
public static void main(String[] args) {
//直接跟经纪人打交道
Agent agent=Agent.getInstance();
agent.company.setName("公司x");
agent.fans.setName("张三");
agent.star.setName("吴签");
agent.meeting();
agent.contract();
System.out.println("============");
agent.fans.setName("李四");
agent.meeting();
agent.contract();
}
}
我们可以看到,经纪人就是一个门面,其他人都是通过经纪人来处理事情。粉丝想要见明星,首先要通过经纪人。再由经纪人和明星打交道。

13、状态模式(State)
如果一个类有很多个复杂状态的时候,可以把状态抽象出来,具体状态实现这个抽象类,

角色:

State(状态)
ConcreteState(具体状态)
Context(状况)
//设置抽象化状态类
abstract class State {
public abstract void simle();
public abstract void cry();
}
//开心状态
class HappyState extends State{
@Override
public void simle() {
System.out.println("开心的笑");
}
@Override
public void cry() {
System.out.println("开心的哭了");
}
}
//不开心状态
class SadState extends State{
@Override
public void simle() {
System.out.println("沮丧的笑着");
}
@Override
public void cry() {
System.out.println("笑哭了");
}
}
//状况
public class Context{
//聚合状态
private State state;
//设置状态
public Context(State state) {
this.state=state;
}
//根据状态判断
public void simle() {
state.simle();
}
//根据状态判断
public void cry() {
state.cry();
}
}
我们不难发现,抽象类的状态(抽象方法)是固定的,具体是怎样的状态,由子类实现。如果抽象类的状态(抽象方法)变化的很频繁,会对所有子类产生影响,那么就不建议使用这个模式

14、责任链模式(Responsibility)
是一种链式的结构的模式,通常使用在审批流,过滤器



//设置责任链的抽象类(接口)
abstract class Approve {
private Approve approve;
//设置下一个审批人
public void setApprove(Approve approve) {
this.approve=approve;
}
//审批人的具体审批内容
public abstract void toApprove();
public abstract void chain(Approve approve);
}
//责任链的内容
//审批人1
class Approve1 extends Approve{
//写入审批人的审批内容
@Override
public void toApprove() {
System.out.println("我是审批人1,我审批完之后交给审批人2");
//设置它的下一个审批人
chain(new Approve2());
}
//设置它的下一个审批人
@Override
public void chain(Approve approve) {
approve.toApprove();
}
}
class Approve2 extends Approve {
@Override
public void toApprove() {
System.out.println("我是审批人2,我审批完之后交给审批人3");
chain(new Approve3());
}
@Override
public void chain(Approve approve) {
approve.toApprove();
}
}
class Approve3 extends Approve {
@Override
public void toApprove() {
System.out.println("我是审批人3,审批完成");

}
@Override
public void chain(Approve approve) {
approve.toApprove();
}
}
//请求访问责任链
public class Request {
public static void main(String[] args) {
Approve approve=new Approve1();
approve.toApprove();
}
}
换一种思路,我们把每一个子类存到容器中,然后对容器进行遍历,然后执行方法,也类似这种链式的执行流程。
我们来通过代码来看看

abstract class Approve {
//审批人的具体审批内容
public abstract void toApprove();
}
//审批人1
class Approve1 extends Approve{
//写入审批人的审批内容
@Override
public void toApprove() {
System.out.println("我是审批人1,我审批完之后交给审批人2");
}
}
//审批人2
class Approve2 extends Approve {
@Override
public void toApprove() {
System.out.println("我是审批人2,我审批完之后交给审批人3");
}
}
//审批人3
class Approve3 extends Approve {
@Override
public void toApprove() {
System.out.println("我是审批人3,审批完成");
}
}
//导入集合
import java.util.ArrayList;
//责任链管理类
class ApproveChain {
//聚合了内容
ArrayList<Approve> approves=new ArrayList<>();
public ApproveChain addChain(Approve approve) {
approves.add(approve);
return this;
}
//通过调用这个方法,遍历容器中的类执行方法
public void chain() {
for(Approve a:approves) {
a.toApprove();
}
}
}
//请求着使用
public class Request {
public static void main(String[] args) {
//定义责任链管理类
ApproveChain ac=new ApproveChain();
//需要设置它的下一个
ac.addChain(new Approve1()).addChain(new Approve2()).addChain(new Approve3());
ac.chain();
}
}
上面代码很类似享元模式吧,哈哈。

15、迭代器模式(Iterator)
角色:

Iterator(迭代器)
ConcreteIterator(具体的迭代器)
Aggregate(集合)
CocreteAggreagete(具体集合)
类图:

Iterator(迭代器)

public interface Iterator_ {
boolean hashNext();
Object next();
}
1
2
3
4
ConcreteIterator(具体的迭代器)

public class ArrayListIterator implements Iterator_{
//单例模式创建类
private static ArrayListAggregate alat=new ArrayListAggregate();
@Override
public boolean hashNext() {
if(alat.currentIndex>=alat.size()) return true;
return false;
}
@Override
public Object next() {
Object o=alat.list.get(alat.currentIndex);
alat.currentIndex++;
return o;
}
}
Aggregate(集合接口)

public interface Aggregate {
public abstract Iterator_ iterator();
}
CocreteAggreagete(具体集合)

import java.util.ArrayList;

public class ArrayListAggregate implements Aggregate{
ArrayList<Object> list=new ArrayList<>();
int index=0;
int currentIndex=0;
@Override
public Iterator_ iterator() {
// TODO Auto-generated method stub
return new ArrayListIterator();
}
public int size() {

return index;
}
public void add(Object o) {
list.add(o);
index++;
}
}
16、观察者模式(Observer)重要
我们开发中,使用到观察者模式很多,这个知识点要重点把握

角色:

Source:事件源对象
Observer:观察者
Event:事件


//事件,可定义为抽象化类(接口)
class Event {
String loc;
public Event(String loc) {
this.loc=loc;
}
}
//抽象化观察者
abstract class Observer {
public abstract void actionEvent(Event event);
}
//具体观察者1
class Observer1 extends Observer{
@Override
public void actionEvent(Event event) {
//打印
System.out.println(event.loc);
System.out.println("观察者1做出了行为");
//执行相关的方法
}
}
//具体观察者2
class Observer2 extends Observer{
@Override
public void actionEvent(Event event) {
System.out.println("============");
System.out.println("观察者2做出了行为");
//执行相关的操作
}
}

import java.util.ArrayList;
import java.util.List;
//由事件源发出事件,观察者进行处理事件
public class Source {
private List<Observer> observers=new ArrayList<>();
{
//注册观察者
observers.add(new Observer1());
observers.add(new Observer2());
}
//执行这个方法会触发所有观察者
public void wakeUp() {
for(Observer o:observers) {
o.actionEvent(new Event("bed"));
}
}
}
//测试
class Test {
public static void main(String[] args) {
new Source().wakeUp();
}
}
17、策略模式(Strategy)

角色:

抽象化策略
具体策略
聚合策略类
使用者
封装的是不同的执行方式,比如对排序选择不同的排序算法(策略)
代码如下

//抽象化策略类(接口)
interface Sorter{
public abstract void sort(Comparable[] data);
}
//具体策略,这里采用选择排序算法
class SelectSorter implements Sorter{
@Override
public void sort(Comparable[] data) {
for(int i=0;i<data.length-1;i++) {
int min=i;
for(int j=i+1;j<data.length;j++) {
if(data[min].compareTo(data[j])>0) {
min=j;
}
}
swap(data,i,min);
}
}
public void swap(Comparable[] data,int i,int min) {
Comparable temp=data[i];
data[i]=data[min];
data[min]=temp;
}
}
//具体策略类,这里采用冒泡排序
class BubbleSorter implements Sorter{
@Override
public void sort(Comparable[] data) {
//进行排序
for(int i=1;i<data.length;i++) {
for(int j=0;j<data.length-i;j++) {
if(data[j].compareTo(data[j+1])>0) {
Comparable temp=data[j+1];
data[j+1]=data[j];
data[j]=temp;
}
}
}
}
}
//聚合策略类,可以选择不同的策略
class SortAndPrint{
Comparable[] data;
Sorter sorter;
public SortAndPrint(Comparable[] data,Sorter sorter) {
this.data=data;
this.sorter=sorter;
}
public void sort() {
System.out.println("====排序前====");
print();
sorter.sort(data);
System.out.println();
System.out.println("====排序后====");
print();
}
public void print() {
for(int i=0;i<data.length;i++) {
System.out.print(data[i]+",");
}
System.out.println(" ");
}
}
//测试
public class Client {

public static void main(String[] args) {
//定义一个需要排序的数据
String[] data= {"Dumpty","Bowman","Carroll"};
SortAndPrint sap=new SortAndPrint(data, new BubbleSorter());
sap.sort();
}
}
18、模板方法模式(Temlapte Method)
具体实现交给子类
角色:

AbstractClass
concreteClass
类图:


具体使用:

public abstract class AbstractDisplay {
//定义抽象方法,由子类去实现
public abstract void open();
public abstract void print();
public abstract void close();
//对这个方法设定为final类型。表示子类不能重写
public final void display() {
open();
print();
close();
}
//使用
public static void main(String[] args){
CharDisplay chars=new CharDisplay();
chars.display();
}
}
//子类继承
class CharDisplay extends AbstractDisplay{
@Override
public void open() {
System.out.println("打开CharDisplay");
}
@Override
public void print() {
System.out.println("在CharDisplay进行打印");
}
@Override
public void close() {
System.out.println("关闭CharDisplay");
}
}
//子类继承
class StringDisplay extends AbstractDisplay{

@Override
public void open() {
System.out.println("打开StringDisplay");
}

@Override
public void print() {
System.out.println("在StringDisplay进行打印");
}

@Override
public void close() {
System.out.println("关闭StringDisplay");
}
  public void printLine() {
System.out.println("StringDisplay自定义的方法");
}
}
应用场景:

算法的整体步骤很固定,但其中个别部分易变,将易变部分交给子类实现。
多个子类存在公共行为,可以将其提取出并集中到一个公共父类以避免代码重复
需要控制子类的扩展时,模板方法只在特定点调用钩子函数操作,这样就只允许在这些点进行扩展。
19、中介者模式(Mediator)
中介这个角色在生活中的理解是:比如租房者找中介,再由中介跟相关的房东沟通,房东也是通过中介和租房者沟通。中介是中间的桥梁。
在中介者模式中的理解和生活中的理解基本一致

角色:

Mediator 抽象化中介者
ConcentrateMediator 具体中介者
College 抽象化同事类
ConcentrateCollege 具体同事类(租房者、房东)


//抽象化中介者
pabstract class Mediator {
//沟通的方法
public abstract void constact(String msg,Colleague c);
}
//具体中介类
class ConcreteMediator extends Mediator{
//聚合同事类
private ConcreteColleague1 c1;
private ConcreteColleague2 c2;
//设置get和set方法
public ConcreteColleague1 getC1() {
return c1;
}
public void setC1(ConcreteColleague1 c1) {
this.c1 = c1;
}
public ConcreteColleague2 getC2() {
return c2;
}
public void setC2(ConcreteColleague2 c2) {
this.c2 = c2;
}
//具体的沟通方法,核心
@Override
public void constact(String msg, Colleague c) {
//判断是哪个同事,进行处理事件
if(c==c1) {
c2.getMessage(msg);
}else {
c1.getMessage(msg);
}
}
}
//同事类
abstract class Colleague {
//给同事类命名
protected String name;
//设置中介
protected Mediator mediator;
public Colleague(String name,Mediator mediator) {
this.name=name;
this.mediator=mediator;
}
//沟通的方法
public abstract void constact(String msg);
//获取信息
public abstract void getMessage(String msg);
}
//具体的同事类,这个类表示租房
class ConcreteColleague1 extends Colleague{

//在构造函数让该类被创建的时候同时命名
public ConcreteColleague1(String name,Mediator mediator) {
super(name, mediator);
}
@Override
public void constact(String msg) {
mediator.constact(msg, this);
}
@Override
public void getMessage(String msg) {
System.out.println();
System.out.println("租房者姓名:"+name+"。收到的信息:"+msg);
}
}
//具体的同事类,这里表示房东
class ConcreteColleague2 extends Colleague{

//在构造函数让该类被创建的时候同时命名
public ConcreteColleague2(String name,Mediator mediator) {
super(name,mediator);
}
@Override
public void constact(String msg) {
mediator.constact(msg, this);
}
@Override
public void getMessage(String msg) {
System.out.println("房东姓名:"+name+"。收到的信息:"+msg);
}
}
//测试类
public class Client {
public static void main(String[] args) {
//创建中介者
ConcreteMediator cm=new ConcreteMediator();
//创建同事类
ConcreteColleague1 c1=new ConcreteColleague1("张三",cm);
ConcreteColleague2 c2=new ConcreteColleague2("李四",cm);
//房东需要知道具体的租房者和房东
cm.setC1(c1);
cm.setC2(c2);
c1.constact("我想租两房一厅的房子");
c2.constact("我这有,而且非常便宜");
}
}
20、备忘录模式(Memento)
记录状态,便于回滚,经常和命令模式结合使用

角色:

Memento 备忘录,记录状态
Originator 创建者:创建备忘录
Caretaker 管理者:管理备忘录
//备忘录,需要存的内容
class Memento {
private String state;
public Memento(String state) {
this.state=state;
}
public String getState() {
return state;
}
}
//创建者,创建备忘录
class Originator {
private String state;
public void setState(String state) {
this.state=state;
//打印状态
System.out.println("现在的状态为:"+state);
}
public String getState() {
return state;
}
//创建备忘录,并存储数据
public Memento saveMemento() {
return new Memento(state);
}
//获取备忘录的数据,恢复备忘录时的状态
public void getStateFromMemento(Memento memento) {
this.state=memento.getState();
}
}
//管理者,备忘录的管理
import java.util.ArrayList;
class Caretaker {
//聚合备忘录
private ArrayList<Memento> mementos=new ArrayList<>();
//添加备忘录
public void addMemento(Memento memento) {
mementos.add(memento);
}
public Memento getMemento(int index) {
return mementos.get(index);
}
}
//测试类
public class Client {
public static void main(String[] args) {
//定义创建类,管理类
Originator o=new Originator();
Caretaker c=new Caretaker();
//设置当时的状态
o.setState("状态1:攻击力:1000");
c.addMemento(o.saveMemento());
o.setState("状态2:攻击力:800");
c.addMemento(o.saveMemento());
String state=c.getMemento(0).getState();
System.out.println("恢复后的状态为:"+state);
}
}
备忘录模式能够随时恢复到备忘录保存的状态,而命令模式需要多个撤销恢复上一个状态。备忘录模也会用在存盘功能,将会使用到序列化和反序化,对于序列化和反序列化的相关使用可以查看这里:

序列化和反序列化的相关知识

可以尝试实现这个功能,这里就不展开介绍了。

21、命令模式(Command)
需要回退(撤销,Undo)状态的时候通常会使用到命令模式
多次撤销,需要结合责任链模式
宏命令,需要树状结构的组合模式结合使用

命令的调用者和命令的接收者进行了解耦

角色:

invok 调用者
Command 命令
Receive 接收者

下面代码是对单个命令的执行和撤销作用

//抽象化命令接口
interface Command {
void execute();
void undo();
}
//具体命令
class Command1 implements Command{
private Receive receive; 
String str="https://blog.csdn.net/weixin_44715643?spm=1000.2115.3001.5343";
public Command1(Receive receive) {
this.receive=receive;
}
@Override
public void execute() {
System.out.println("接收者的内容:"+receive.msg);
receive.msg+=str;
System.out.println("接收者的内容发生了改变:"+receive.msg);
}
@Override
public void undo() {
//回退到原来的状态
receive.msg=receive.msg.substring(0, receive.msg.length()-str.length());
System.out.println("恢复回上一步的操作时的接收者的内容:"+receive.msg);
}
}
//接收者,对命令做出相应的动作
class Receive {
String msg=new String("hello everybody ");
}
//调用者,聚合了命令
class Invok {
private Command command;
public Invok(Command command) {
this.command=command;
}
public void executeCommand() {
command.execute();
}
public void undoCommand() {
command.undo();
}
}
//使用命令者
public class Client {
public static void main(String[] args) {
Invok invok=new Invok(new Command1(new Receive()));
//执行操作
invok.executeCommand();
//撤销操作
System.out.println("下面进行撤销操作");
invok.undoCommand();
}
}
多个命令的执行和撤销

//抽象化命令接口
abstract class Command {
abstract int getIndex();
abstract void execute();
abstract Command undo();
}
//命令1
import java.util.ArrayList;
class Command1 extends Command{
private ArrayList<String> alist=new ArrayList<>();
private int index=-1;
private Receive receive; 
//增加的内容
String str="xxx ";
public Command1(Receive receive) {
this.receive=receive;
}
@Override
public void execute() {
System.out.println("接收者的内容:"+receive.msg);
receive.msg+=str;
System.out.println("接收者的内容发生了改变:"+receive.msg);
alist.add(receive.msg);
index++;
}
@Override
public Command1 undo() {
if(index>=0) {
if(index==0) {
receive.msg=receive.msg.substring(0,receive.chushizhi.length());
alist.remove(index);
index--;
System.out.println("初始值为:"+receive.msg);
}else {
//回退到上一步的状态
alist.remove(index);
//下标往前面移动一位
String s=alist.get(--index);
receive.msg=receive.msg.substring(0, s.length());
System.out.println("恢复回上一步的操作时的接收者的内容:"+receive.msg);
}
}else {
System.out.println("到底了,不能再撤销了");
}
return this;
}
//记录当前的状态
@Override
public int getIndex() {
// TODO Auto-generated method stub
return index;
}
}
//接收者,对命令做出相应的动作
class Receive {
String msg="hello everybody ";
//记录初始值
String chushizhi=msg;
}
//调用者,可以作为使用者Client
class Invok {
private Command command;
public Invok(Command command) {
this.command=command;
}
public void executeCommand() {
command.execute();
}
public Invok undoCommand() {
command.undo();
return this;
}
}
//使用命令者
public class Client {
public static void main(String[] args) {
Invok invok=new Invok(new Command1(new Receive()));
//执行操作
invok.executeCommand();
invok.executeCommand();
invok.executeCommand();
//撤销操作
System.out.println("下面进行撤销操作");
invok.undoCommand();
invok.undoCommand();
invok.undoCommand();
invok.undoCommand();
}
}
22、访问者模式(Visitor)
数据结构和数据分离

角色:

Visitor 访问者抽象类 - Element 具体元素
Struct 结构,由多个元素组成
具体元素


//抽象化接口
interface Visitor {
void visitCpu(Cpu cpu);
void visitMemory(Memory memory);
void visitBoard(Board board);
}
//具体访问者
class Woman implements Visitor{
//全程七折半
double totalPrice=0.0;
@Override
public void visitCpu(Cpu cpu) {
//打折活动
totalPrice+=cpu.getPrice()*0.75;
}
@Override
public void visitMemory(Memory memory) {
//打折活动
totalPrice+=memory.getPrice()*0.75;
}

@Override
public void visitBoard(Board board) {
//打折活动
totalPrice+=board.getPrice()*0.75;
}
//获取价钱
public double getPrice() {
return totalPrice;
}
}
//具体访问者
class Man implements Visitor{
//购买需要花费的总价钱,全场八折!
double totalPrice=0.0;
@Override
public void visitCpu(Cpu cpu) {
//打折活动
totalPrice+=cpu.getPrice()*0.8;
}
@Override
public void visitMemory(Memory memory) {
totalPrice+=memory.getPrice()*0.8;
}
@Override
public void visitBoard(Board board) {
totalPrice+=board.getPrice()*0.8;
}
//获取价钱
public double getPrice() {
return totalPrice;
}
}
//结构
interface ComputerPart {
void accept(Visitor visitor);
}
class Board implements ComputerPart{
//接待指定的访问人,调用指定的方法
@Override
public void accept(Visitor visitor) {
visitor.visitBoard(this);
}
//设置Board的单价
public double getPrice() {
return 1000.00;
}
}
class Cpu implements ComputerPart{
//接待指定的访问人,调用指定的方法
@Override
public void accept(Visitor visitor) {
visitor.visitCpu(this);
}
//设置Cpu的单价
public double getPrice() {
return 800.0;
}
}
class Memory implements ComputerPart{
//接待指定的访问人,调用指定的方法
@Override
public void accept(Visitor visitor) {
visitor.visitMemory(this);
}
//设置Memory的单价
public double getPrice() {
return 400.00;
}
}
//结构类,根据不同的访问者设定标配的电脑配件
public class Computer {
Cpu cpu=new Cpu();
Memory memory=new Memory();
Board board=new Board();
//给访问者设置标配
public void accept(Visitor visitor) {
this.cpu.accept(visitor);
this.memory.accept(visitor);
this.board.accept(visitor);
}
}
//测试类
public class Test {
public static void main(String[] args) {
//定义相关类
Computer computer=new Computer();
Man man=new Man();
Woman woman=new Woman();
//通过访问者模式进行使用
//一个男人过来购买电脑
computer.accept(man);
System.out.println("男人过来买需要花费:"+man.getPrice());
//一个女人过来购买电脑
computer.accept(woman);
System.out.println("女人过来买需要花费:"+woman.getPrice());
}
}
23、解释器模式(Interpreter)
对于一些固定文法构建一个解释句子的解释器。在实际开发中,我们很少会去开发一个解释器,因为涉及到的知识点比较复杂。所以我们只需要了解即可,我们通过加减法的例子去了解它

角色:

Expression 抽象化解释器
Context 上下文,用于存放变量和值
Addition 加法解释器(具体解释器)
Minus 减法解释器(具体解释器)
Variable 变量解释器 (具体解释器),它主要和上下文打交道(获取变量指定的值)


//抽象化解释器
abstract class Expression {
//解释方法
public abstract int interpret(Context context);
}
//导入相关的包
import java.util.HashMap;
//上下文
class Context {
//定义一个键值对的容器
private HashMap<Variable,Integer> map=new HashMap<>();
//把变量名和值存放到容器中
public void addVariable(Variable v,Integer x) {
map.put(v, x);
}
//通过变量名获取值
public int getVlaue(Variable v) {
return map.get(v);
}
}
//变量类,继承解释器
class Variable extends Expression{
//给每个变量定义一个名字
String name;
//通过构造方法给变量名赋值
public Variable(String name) {
this.name=name;
}
//变量解释方法,通过变量获取值
@Override
public int interpret(Context context) {
//通过变量名获取上下文的容器中对应的值
return context.getVlaue(this);
}
//重写toString()方法
@Override
public String toString() {
return name;
}
}
//具体解释器,加法器
class Addition extends Expression{
//定义两个解释器的类,表示传进来的变量
private Expression left;
private Expression right;
//存放进去的是变量
public Addition(Expression left,Expression right) {
this.left=left;
this.right=right;
}
//进行加法运算
@Override
public int interpret(Context context) {
//通过变量的解释器,获取对于的值,进行运算
return left.interpret(context)+right.interpret(context);
}
@Override
public String toString() {
//重写toString方法
return "("+left.toString()+"+"+right.toString()+")";
}
}
//具体解释器,模拟减法器
class Minus extends Expression{
//定义两个解释器变量
private Expression left;
private Expression right;
//通过构造函数的方式传入两个变量
public Minus(Expression left,Expression right) {
this.left=left;
this.right=right;
}
//解释方法
@Override
public int interpret(Context context) {
//通过变量的解释器,获取对于的值,进行运算
return left.interpret(context)-right.interpret(context);
}
@Override
public String toString() {
//重写toString()方法
return "("+left.toString()+"-"+right.toString()+")";
}
}
//测试类
public class Client {
public static void main(String[] args) {
//创建上下文
Context context=new Context();
//创建变量
Variable a=new Variable("a");
Variable b=new Variable("b");
Variable c=new Variable("c");
Variable d=new Variable("d");
//将变量赋予值,并保存到上下文
context.addVariable(a, 1);
context.addVariable(b, 2);
context.addVariable(c, 3);
context.addVariable(d, 4);
//设置表达式
Expression expression=new Addition(a,new Minus(b,new Addition(c,d)));
//对表达式进行解释
int result=expression.interpret(context);
//打印输出结果
System.out.println(expression.toString()+"="+result);
}
}

本站文章版权归原作者及原出处所有 。内容为作者个人观点, 并不代表本站赞同其观点和对其真实性负责,本站只提供参考并不构成任何投资及应用建议。本站是一个个人学习交流的平台,网站上部分文章为转载,并不用于任何商业目的,我们已经尽可能的对作者和来源进行了通告,但是能力有限或疏忽,造成漏登,请及时联系我们,我们将根据著作权人的要求,立即更正或者删除有关内容。本站拥有对此声明的最终解释权。

回到顶部
嘿,我来帮您!