JavaSEDemo35常用设计模式

简介

• 本文是2021/05/08整理的笔记
• 赘述可能有点多，还请各位朋友耐心阅读
• 本人的内容和答案不一定是最好最正确的，欢迎各位朋友评论区指正改进

简单工厂设计模式:

1.接口:方法:生产什么商品 返回名称

public interface Car {
String getName();
}

2.具体商品类实现接口,重写接口的方法
1.Benz:

public class Benz implements Car {
@Override
public String getName() {
return "Benz";
}
}

2.Bm:

public class Bm implements Car{
@Override
public String getName() {
return "Bm";
}
}

3.简单工厂:用于生产商品

public class SimpleFactory {
public Car getCar(String name){
if (name.equals("Benz")){
return new Benz();
}
else if (name.equals("Bm")){
return new Bm();
}
else{
System.out.println("不好意思,本厂不生产"+name+"品牌的车");
return null;
}
}
}

4.测试类:
1.创建简单工厂对象2.调用 getCar()方法,返回 Car 对象
3.输出 car 对象的名称

public class TestSimpleFactory {
public static void main(String[] args) {
// 1.创建简单工厂对象
SimpleFactory simpleFactory = new SimpleFactory();
// 2.调用 getCar()方法,返回 Car 对象
Car car = simpleFactory.getCar("Bm");
// 3.输出 car 对象的名称
if (car!=null) {
System.out.println(car.getName());
}
}
}

2.工厂方法模式

0.Car 接口:方法:生产什么商品 返回名称

public interface Car {
String getName();
}
0.具体商品类实现接口,重写接口的方法
1.Benz:
public class Benz implements Car {
@Override
public String getName() {
return "Benz";
}
}

2.Bm:

public class Bm implements Car{
@Override
public String getName() {
return "Bm";
}
}
1.CarFactory 接口:方法:返回商品对象
public interface CarFactory {
//返回商品对象
Car getCar();
}

2.具体商品工厂:实现接口 重写接口的方法 返回 Car 对象
1.BmFactory:

public class BmFactory implements CarFactory {
@Override
public Car getCar() {return new Bm();
}
}

2.BmFactory:

public class BenzFactory implements CarFactory {
@Override
public Car getCar() {
return new Benz();
}
}

3.测试类:
1.创建具体工厂
2.调用具体工厂的生产方法
3.打印名称

public class TestFactoryMethod {
public static void main(String[] args) {
// 1.创建具体工厂
// BmFactory factory = new BmFactory();
BenzFactory factory = new BenzFactory();
// 2.调用具体工厂的生产方法
Car car = factory.getCar();
// 3.打印名称
System.out.println(car.getName());
}
}

3.抽象工厂

0.Car 接口:方法:生产什么商品 返回名称

public interface Car {
String getName();
}

0.具体商品类实现接口,重写接口的方法
1.Benz:

public class Benz implements Car {
@Override
public String getName() {
return "Benz";
}
}

2.Bm:

public class Bm implements Car{
@Override
public String getName() {
return "Bm";
}}

3.Audi:

public class Audi implements Car{
@Override
public String getName() {
return "Audi";
}
}

1.抽象工厂类
1.生产商品抽象方法:abstract Car getCar();
2.根据名称得到商品的方法

public Car getCar(String name){
if (name.equals("Bm")){
return new BmFactory().getCar();
}
else if (name.equals("Benz")){
return new BenzFactory().getCar();
}
else if (name.equals("Audi")){
return new DefaultFactory().getCar();
}
else{
System.out.println("不生产"+name+"品牌的汽车");
return null;
}
}

2.具体工厂
1.BmFactory

public class BmFactory extends AbstractFactory {
@Override
public Car getCar() {
return new Bm();
}
}

2.BenzFactory:

public class BenzFactory extends AbstractFactory {
@Override
public Car getCar() {
return new Benz();
}
}

3.DefaultFactory:

public class DefaultFactory extends AbstractFactory {
@Overridepublic Car getCar() {
return new Audi();
}
}

3.测试类

public static void main(String[] args) {
//创建工厂对象
DefaultFactory factory = new DefaultFactory();
//调用方法生产汽车
Car car = factory.getCar("Bm");
//输出名称
if (car!=null){
System.out.println(car.getName());
}
}

4.观察者模式

1.观察者 实现 Observer 接口,重写接口的 update()方法

public class SimpleObserver implements Observer {
public SimpleObserver(SimpleObserve simpleObserve) {
simpleObserve.addObserver(this);//将当前观察者对象加入到被观察者的
观察者组中
}
@Override
public void update(Observable o, Object arg) {
SimpleObserve simpleObserve = (SimpleObserve) o;
int data = simpleObserve.getData();
System.out.println("修改后的 data 的值是:"+data);
}
}

2.被观察者继承 Observable 类

public class SimpleObserve extends Observable {
private int data;//默认值是 0
public int getData() {
return data;
}
public void setData(int data) {
if (this.data!=data){
this.data=data;
setChanged();//先调用该方法返回 true
notifyObservers();//只有在 setChange()被调用后，notifyObservers()才会去调用 update()，否则什么都不干。
}
}
}

3.测试类

public static void main(String[] args) {
//创建被观察者对象
SimpleObserve simpleObserve = new SimpleObserve();
//创建观察者对象
SimpleObserver simpleObserver = new SimpleObserver(simpleObserve);
//调用被观察者对象.setData()方法改变 data 的值
simpleObserve.setData(1);
simpleObserve.setData(2);
simpleObserve.setData(2);
simpleObserve.setData(3);
}

代理

静态代理

1. 接口
2. 目标类 实现接口，重写接口的方法
3. 代理类 实现接口，重写接口的方法
4. 测试类：
   创建目标类对象
   创建代理类对象(传入目标类对象)
   调用代理类对象的方法

动态代理

1.JDK

1. 接口
2. 目标类 实现接口 重写接口的方法
3. 中间类 实现InvocationHandler接口 重写接口的invoke(Object proxy,Method method,Object[] args)方法
4. 测试类
   1. 创建目标类对象
   2. UserDao userDaoProxy = (UserDao)Proxy.newProxyInstance(userDao.getClass().getClassLoader(),userDao.getClass().getInterfaces(),new UserMiddle(userDao));
   3. 调用代理类对象的方法

2.Cglib

1. 目标类 不实现接口
2. 中间类 实现方法拦截器MethodInterceptor，重写接口的intercept(Object proxy,Method method.Object[] args,MethodProxy methodProxy)。在方法体写增强逻辑，调用父类的方法，methodProxy.invokeSuper(proxy,args);
3. 测试类:
   1. 创建目标类对象
   2. 创建Enhancer对象
   3. 设置Enhancer对象的setSuperClass(目标类的类类型)
   4. 设置Enhancer对象的setCallBack(new 方法拦截器中间类)；
   5. 使用动态字节码技术生成目标类的子类(代理)对象:enhancer.create()
   6. 调用代理对象的方法