常用设计模式 2018-09-15

作者: 冻死的毛毛虫 | 来源:发表于2018-09-16 09:53 被阅读0次

常用设计模式 2018-09-15
Java 常用设计模式简例
java单例模式与线程安全
知识复盘
设计模式
常用设计模式介绍
工厂模式
工厂模式
设计模式
C++常用设计模式

代理模式

/**
 * 业务接口
 */
public interface Account {
    public void queryAcconut();
    public void updateAccount();
}

/**
 * 业务实现类
 */
public class AccountImpl implements Account {

    @Override
    public void queryAcconut() {
        System.out.println("查询账单");
    }

    @Override
    public void updateAccount() {
        System.out.println("更新账单");
    }
}

静态代理

import designpattern.代理.业务类和接口.Account;

public class AccountProxy implements Account {
    private Account account;/*代理对象*/
    public AccountProxy(Account account) {/*构造方法*/
        this.account = account;
    }

    @Override
    public void queryAcconut() {
        System.out.println("代理——————开始");
        account.queryAcconut();
        System.out.println("代理——————结束");
    }

    @Override
    public void updateAccount() {
        System.out.println("代理——————开始");
        account.updateAccount();
        System.out.println("代理——————结束");
    }
}

 /**
     * 静态代理：
     * 静态代理是通过在代码中显式定义一个业务实现类一个代理，在代理类中对同名的业务方法进行包装，
     * 用户通过代理类调用被包装过的业务方法；
     *
     * 优点：可以做到在符合开闭原则的情况下对目标对象进行功能扩展。
     * 缺点：我们得为每一个服务都得创建代理类，工作量太大，不易管理。同时接口一旦发生改变，代理类也得相应修改。
     */
    @Test
    public void testStaticProxy(){
        Account account = new AccountImpl();
        AccountProxy accountProxy = new AccountProxy(account);

        account.queryAcconut();
        accountProxy.queryAcconut();
    }

动态代理

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DynamicProxyHandler implements InvocationHandler {
    private Object target;
    public DynamicProxyHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理---------开始");
        Object result = method.invoke(target, args);
        System.out.println("代理---------结束");
        return result;
    }
}

/**
     *  JDK动态代理是通过接口中的方法名，在动态生成的代理类中调用业务实现类的同名方法；
     * 虽然相对于静态代理，动态代理大大减少了我们的开发任务，同时减少了对业务接口的依赖，降低了耦合度。
     * 但是还是有一点点小小的遗憾之处，那就是它始终无法摆脱仅支持interface代理的桎梏
     */
    @Test
    public void testDynamicProxy(){
        AccountImpl account = new AccountImpl();

        Account accountProxy = (Account) Proxy.newProxyInstance(
                DynamicProxyHandler.class.getClassLoader(),/*业务实现*/
//                account.getClass().getInterfaces(),/*业务接口*/
                AccountImpl.class.getInterfaces(),/*业务接口*/
                new DynamicProxyHandler(account));/*要代理对象*/

        account.queryAcconut();
        accountProxy.queryAcconut();
    }

CGLIB代理

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibProxy implements MethodInterceptor {

 public Object getInstance(Class c){
        /*创建代理对象*/
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(c);
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("CGLIB -------- 开始");
        Object result = methodProxy.invokeSuper(o, objects);
        System.out.println("CGLIB -------- 结束");
        return result;
    }
}

/**
     *  CGlib动态代理是通过继承业务类，生成的动态代理类是业务类的子类，通过重写业务方法进行代理；
     */
    @Test
    public void testCglibProxy(){
        CglibProxy cglibProxy = new CglibProxy();
        Account accountProxy = (Account) cglibProxy.getInstance(AccountImpl.class);

        accountProxy.updateAccount();
    }

单例模式、

懒汉式synchronized代码块

public class Singleten {

    /*非线程安全*/
    private static Singleten INSTANCE;

    /*私有化构造方法*/
    private Singleten() {
    }

    /*公有化获取实例方法*/
    public static synchronized Singleten getInstance(){
        if (INSTANCE == null){
            /*使用同步代码块*/
            synchronized (Singleten.class){
                INSTANCE = new Singleten();
            }
        }
        return INSTANCE;
    }
}

懒汉式synchronized 方法


public class Singleten {

    /*线程安全，效率低*/
    private static Singleten INSTANCE;
    
    /*私有化构造方法*/
    private Singleten() {
    }

    /*公有化获取实例方法*/
    public static synchronized Singleten getInstance(){
        if (INSTANCE == null){
            INSTANCE = new Singleten();
        }
        return INSTANCE;
    }
}

懒汉式


public class Singleten {

    /*非线程安全*/
    private static Singleten INSTANCE;
    
    /*私有化构造方法*/
    private Singleten() {
    }

    /*公有化获取实例方法*/
    public static Singleten getInstance(){
        if (INSTANCE == null){
            INSTANCE = new Singleten();
        }
        return INSTANCE;
    }
}

懒汉式双重检测锁


public class Singleten {

    /*线程安全*/
    private static Singleten INSTANCE;

    /*私有化构造方法*/
    private Singleten() {
    }

    /*公有化获取实例方法*/
    public static  Singleten getInstance(){
        if (INSTANCE == null){
            /*使用同步代码块*/
            synchronized (Singleten.class){
                if (INSTANCE == null){
                    INSTANCE = new Singleten();
                }
            }
        }
        return INSTANCE;
    }
}

懒汉式静态内部类


public class Singleten {

    private Singleten() {
    }

    /*线程安全，延迟加载，效率高*/
    private static class SingletenInstance{
        private static final Singleten INSTANCE = new Singleten();
    }

    /*公有化获取实例方法*/
    public static synchronized Singleten getInstance(){
        return SingletenInstance.INSTANCE;
    }
}

枚举


public class Singleten {

    private static Singleten INSTANCE;

    private Singleten() {
    }

    public static Singleten getInstance(){
        return SingletenInstence.INSTENCE.getInstance();
    }

    /*枚举*/
    private enum SingletenInstence{
        INSTENCE;

        private Singleten instance;

        /*JVM 保证只调用一次*/
        SingletenInstence() {
            this.instance = new Singleten();
        }

        public Singleten getInstance() {
            return instance;
        }
    }
}

饿汉式静态代码块


public class Singleten {

    private static Singleten INSTANCE;

    /*在类加载时创建实例，避免了线程安全问题*/
    static {
        INSTANCE = new Singleten();
    }
    /*私有化构造方法*/
    private Singleten() {
    }

    /*公有化获取实例方法*/
    public static Singleten getInstance(){
        return INSTANCE;
    }
}

饿汉式静态常量

public class Singleten {

    /*在类加载时创建实例，避免了线程安全问题*/
    private static final Singleten INSTANCE= new Singleten();

    /*私有化构造方法*/
    private Singleten() {
    }

    /*公有化获取实例方法*/
    public static Singleten getInstance(){
        return INSTANCE;
    }
}

命令模式

receiver

/**
 * 接受者的抽象类
 */
public interface Receiver {
}

/**
 * 具体的命令执行类
 */
public class DBReceiver implements Receiver {

    public void query() {
        System.out.println("查询数据库");
    }

    public void update() {
        System.out.println("更新数据库");
    }
}

/**
 * 具体的命令执行类
 */
public class EmailReceiver implements Receiver {
    public void send() {
        System.out.println("发送邮件");
    }
}

command

/**
 * 命令的抽象类
 */
public interface Commond {
    public void execute();
}

public class QueryDBCommond implements Commond{

    private DBReceiver receiver;

    public QueryDBCommond(DBReceiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        receiver.query();
    }
}

public class SendEmailCommond implements Commond {

    private EmailReceiver receiver;

    public SendEmailCommond(EmailReceiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        receiver.send();
    }
}

public class UpdateDBCommond implements Commond{
    private DBReceiver receiver;

    public UpdateDBCommond(DBReceiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        receiver.update();
    }
}

invoker

public class Invoker {
    private Commond commond;

    public Invoker(Commond commond) {
        this.commond = commond;
    }

    public void action(){
        commond.execute();
    }
}

client

/*https://www.cnblogs.com/JsonShare/p/7206513.html*/
public class Client {
    public static void main(String[] args) {
        /*接受者*/
        DBReceiver receiver = new DBReceiver();

        /*命令*/
        Commond commond = new QueryDBCommond(receiver);

        /*执行者*/
        Invoker invoker = new Invoker(commond);

        invoker.action();
    }
}

工厂模式

简单工厂


public abstract class INoodles {

    public abstract void desc();
}

public class LzNoodles extends INoodles {

    @Override
    public void desc() {
        System.out.println("兰州拉面");
    }
}

public class PaoNoodles extends INoodles {
    @Override
    public void desc() {
        System.out.println("泡面");
    }
}

public class SimpleNoodlesFactory {

    public static INoodles getNoodle(Type type){
        switch (type){
            case LZNOODLES:
                return new LzNoodles();
            case PAONOODLES:
                return new PaoNoodles();
        }
        return null;
    }
}

@Test
    public void simpleFactory(){
        INoodles noodle = SimpleNoodlesFactory.getNoodle(Type.PAONOODLES);
        noodle.desc();
    }

工厂方法

public abstract class Project {
    public abstract void desc();
}

public class ProjectA extends Project{

    @Override
    public void desc() {
        System.out.println("产品A");
    }
}

public class ProjectB extends Project {

    @Override
    public void desc() {
        System.out.println("产品B");
    }
}

public abstract class Factory {
    public abstract Project create();
}

public class FactoryA extends Factory {
    @Override
    public Project create() {
        return new ProjectA();
    }
}

public class FactoryB extends Factory{
    @Override
    public Project create() {
        return new ProjectB();
    }
}

@Test
    public void methodFactory(){
        FactoryA factoryA = new FactoryA();
        Project project = factoryA.create();
        project.desc();
    }

抽象工厂

产品类别

public abstract class Juice {
    public abstract void use();
}

public abstract class Pie {
    public abstract void use();
}

苹果产品

public class AppleJuice extends Juice {
    @Override
    public void use() {
        System.out.println("Apple Juice");
    }
}

public class ApplePie extends Pie {
    @Override
    public void use() {
        System.out.println("Apple Pie");
    }
}

香蕉产品

public class BananaJuice extends Juice {
    @Override
    public void use() {
        System.out.println("Banana Juice");
    }
}

public class BananaPie extends Pie {
    @Override
    public void use() {
        System.out.println("Banana Pie");
    }
}

工厂

public abstract class AbstractFactory {
    public abstract Juice createJuice();
    public abstract Pie createPie();
}

public class AppleFactory extends AbstractFactory {
    @Override
    public Juice createJuice() {
        return new AppleJuice();
    }

    @Override
    public Pie createPie() {
        return new ApplePie();
    }
}

public class BananaFactory extends AbstractFactory {
    @Override
    public Juice createJuice() {
        return new BananaJuice();
    }

    @Override
    public Pie createPie() {
        return new BananaPie();
    }
}

/*https://www.cnblogs.com/my-king/p/5338603.html*/
    @Test
    public void abstractFactory(){
        AbstractFactory factory = new AppleFactory();
        Juice juice = factory.createJuice();
        Pie pie = factory.createPie();
        juice.use();
        pie.use();
    }

桥接模式

color

public interface Color {
    public void bepaint(String shape);
}

public class Black implements Color {
    @Override
    public void bepaint(String shape) {
        System.out.println("黑色的"+shape);
    }
}

public class White implements Color {

    @Override
    public void bepaint(String shape) {
        System.out.println("白色的"+ shape);
    }
}

shape

public abstract class Shape {
    protected Color color;

    public void setColor(Color color) {
        this.color = color;
    }

    public abstract void draw();
}

public class Circle extends Shape {

    private String name = "圆形";

    @Override
    public void draw() {
        color.bepaint(name);
    }
}

public class Square extends Shape {

    private String name = "正方形";

    @Override
    public void draw() {
        color.bepaint(name);
    }
}

test

@Test
    public void testBridge(){
        Shape shape = new Circle();
        Color color = new White();
        shape.setColor(color);
        shape.draw();
    }

策略模式

public interface Strategy {
    public void getPrice(double price);
}

public class NewCustomerStrategy implements Strategy {
    @Override
    public void getPrice(double price) {
        System.out.println("新用户"+price);
    }
}

public class OldCustomerStrategy implements Strategy {
    @Override
    public void getPrice(double price) {
        System.out.println("老用户打八折" + price*0.8);
    }
}

public class QuoteContext {
    private Strategy strategy;

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void getPrice(double price){
        strategy.getPrice(price);
    }
}

    /*https://www.cnblogs.com/lewis0077/p/5133812.html*/
    @Test
    public void testStrategy(){
        double price = 1000.0;

//        Strategy strategy = new NewCustomerStrategy();
        Strategy strategy = new OldCustomerStrategy();

        QuoteContext context = new QuoteContext();

        context.setStrategy(strategy);

        context.getPrice(price);
    }

装饰模式

public abstract class Pancake {

    public String name = "干饼";

    public String getName() {
        return name;
    }

    public abstract double getPrice();
}

public class Roujiamo extends Pancake {
    @Override
    public String getName() {
        return "肉夹馍";
    }

    @Override
    public double getPrice() {
        return 6;
    }
}

public class TornCake extends Pancake {

    @Override
    public String getName() {
        return "手抓饼";
    }

    @Override
    public double getPrice() {
        return 4;
    }
}

public abstract class Condiment extends Pancake {

    public Pancake pancake;

    public void setPancake(Pancake pancake) {
        this.pancake = pancake;
    }

    public abstract String getName();

    public abstract double getPrice();
}

public class Ham extends Condiment {
    @Override
    public String getName() {
        return this.pancake.getName()+"火腿";
    }

    @Override
    public double getPrice() {
        return this.pancake.getPrice() +4;
    }
}

public class FiredEgg extends Condiment {

    @Override
    public String getName() {
        return this.pancake.getName()+"煎蛋";
    }

    @Override
    public double getPrice() {
        return this.pancake.getPrice() + 2;
    }
}

public class EggAndHam extends FiredEgg {
    @Override
    public String getName() {
        return super.getName() + "火腿";
    }

    @Override
    public double getPrice() {
        return super.getPrice()+ 4;
    }
}

@Test
    public void testWarp() {

        Pancake pancake = new Roujiamo();
//        Pancake pancake = new TornCake();

//        Condiment pancake1 = new FiredEgg();
        Condiment pancake1 = new EggAndHam();


        pancake1.setPancake(pancake);

        System.out.println(pancake1.getName());
        System.out.println(pancake1.getPrice());
    }

观察者

被观察者

public abstract class Observerable {
    List<Observer> observers = new ArrayList<>();

    public void registerObserverable(Observer observer){
        observers.add(observer);
    }
    public void removeObserverable(Observer observer){
        observers.remove(observer);
    }
    public abstract void notifyAllObserverable(String message);
}

public class HeadHunter extends Observerable {
    @Override
    public void notifyAllObserverable(String message) {
        for (Observer observer : this.observers) {
            observer.refresh(message);
        }
    }
}

观察者

public interface Observer {
    public void refresh(String message);
}

public class JobSeeker1 implements Observer {
    @Override
    public void refresh(String message) {
        System.out.println(getClass().getName()+message);
    }
}

public class JobSeeker2 implements Observer {
    @Override
    public void refresh(String message) {
        System.out.println(getClass().getName()+message);
    }
}

test

/*https://blog.csdn.net/xiaoyu_93/article/details/53173920*/
    @Test
    public void testObserver(){
        Observerable observerable = new HeadHunter();
        Observer jobSeeker1 = new JobSeeker1();
        Observer jobSeeker2 = new JobSeeker2();

        observerable.registerObserverable(jobSeeker1);
        observerable.registerObserverable(jobSeeker2);

        observerable.notifyAllObserverable("有坑，快来");
    }

门面模式

children

public class CPU {

    public void start(){
        System.out.println("CPU start ...");
    }

    public void shutDown(){
        System.out.println("CPU shutdown");
    }
}

public class Disk {

    public void start(){
        System.out.println("Disk start ...");
    }

    public void shutDown(){
        System.out.println("Disk shurdown ...");
    }
}

public class Memory {

    public void start(){
        System.out.println("Memory start ...");
    }

    public void shutDown(){
        System.out.println("Memory shutDown ...");
    }
}

facade

public class Computer {

    private CPU cpu;
    private Memory memory;
    private Disk disk;

    public Computer() {
        this.cpu = new CPU();
        this.memory = new Memory();
        this.disk = new Disk();
    }

    public void start(){
        this.cpu.start();
        this.disk.start();
        this.memory.start();
    }

    public void shutDown(){
        this.memory.shutDown();
        this.disk.shutDown();
        this.cpu.shutDown();
    }
}

test

@Test
    public void testFacade(){
        Computer computer = new Computer();

        computer.start();
        System.out.println("do something");
        computer.shutDown();
    }

常用设计模式 2018-09-15
目录代理模式单例模式命令模式工厂模式桥接模式策略模式装饰模式观察者模式门面模式代理模式静态代...
Java 常用设计模式简例
简述Java常用设计模式简述Java常用设计模式及设计原则 strate---------策略模式针对接口编程，...
java单例模式与线程安全
设计模式在软件架构设计中被经常使用，掌握常用的设计模式对于设计软件系统非常重要。单例模式作为设计模式中最简单和常用...
知识复盘
1：熟练使用Android常用性能调优 2：Java常用设计模式 3：Android常用设计模式（架构） 4：An...
设计模式
常用的设计模式有，单例设计模式、观察者设计模式、工厂设计模式、装饰设计模式、代理设计模式,模板设计模式等等。单例...
常用设计模式介绍
常用设计模式介绍
工厂模式
安卓常用的设计模式工厂模式（Factory Pattern）是 Android中最常用的设计模式之一。这种类型的...
工厂模式
java设计模式-工厂模式工厂模式：工厂模式是java设计模式里最常用的设计模式之一。工厂模式属于创建型模式...
设计模式
软件开发中常用设计模式和设计原则有哪些？ ##设计模式： * 1、简单工厂模式（Factory） * 2、策略模式...
C++常用设计模式
C++常用设计模式。

常用设计模式 2018-09-15

目录

代理模式

单例模式

命令模式

工厂模式

桥接模式

策略模式

装饰模式

观察者模式

门面模式

代理模式

静态代理

动态代理

CGLIB代理

单例模式、

懒汉式synchronized代码块

懒汉式synchronized 方法

懒汉式

懒汉式双重检测锁

懒汉式静态内部类

枚举

饿汉式静态代码块

饿汉式静态常量

命令模式

receiver

command

invoker

client

工厂模式

简单工厂

工厂方法

抽象工厂

产品类别

苹果产品

香蕉产品

工厂

桥接模式

color

shape

test

策略模式

装饰模式

观察者

被观察者

观察者

test

门面模式

children

facade

test

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读