Java常用设计模式

作者: 离别刀 | 来源:发表于2018-06-06 10:11 被阅读0次

Java 常用设计模式简例
工厂模式
java中常用的设计模式?
知识复盘
单例模式
java动态代理（JDK和cglib）(转载自http://ww
设计模式之工厂模式
设计模式-工厂模式
Java设计模式——工厂模式
2.工厂模式

180608143153.png

工厂模式

这里主要讲解静态工厂，通过静态工厂根据需要创建不同的商品；

public class KFCFactory {
    private static enum Type{
        Hamburger,
        CocaCola
    }
    private static Food deliverFood(Type type){
        Food food= null;
        switch (type){
            case Hamburger:
                food= new Hamburger();
                break;
            case CocaCola:
                food= new CocaCola();
                break;
            default:break;
        }
        return food;
    }

    private static interface Food{
         public void desc();
    }

    private static class Hamburger implements Food{
        private Double price=0d;
        Hamburger(){
            this.price= 20d;
            desc();
        }

        @Override
        public void desc() {
            System.out.println(this.getClass().getSimpleName()+" price: "+this.price);
        }
    }
    private static class CocaCola implements Food{
        private Double price=0d;
        CocaCola(){
            this.price= 6d;
            desc();
        }

        @Override
        public void desc() {
            System.out.println(this.getClass().getSimpleName()+" price: "+this.price);
        }
    }

    public static void main(String[] args) {
        KFCFactory.deliverFood(Type.Hamburger);//需要一个汉堡
        KFCFactory.deliverFood(Type.CocaCola);//需要一杯可乐
    }
}

运行结果：
Hamburger price: 20.0
CocaCola price: 6.0

单例模式

1.单例提供的对象在全局只有一个；
2.单利对象自己创建；
线程安全单例

public class Singleton {
    private static class Lazy{
        private static final Singleton instance= new Singleton();
    }
    private Singleton(){}
    public static final Singleton getInstance(){
        return Lazy.instance;
    }
}

模板模式

定义一组操作或者一组算法的模式，步骤的先后顺序是不能改变的，各个子类可以自定义自己各个步骤中的个性化部分。

public class TemplatePattern {

    private static abstract class Life{
        abstract void getup();
        abstract void work();
        abstract void eating();
        abstract void goHome();

        public void life(){
            getup();
            work();
            eating();
            goHome();
        }
    }

    private static class Farmer extends Life{

        @Override
        void getup() {
            System.out.println(this.getClass().getSimpleName()+" getup at 6:00");
        }

        @Override
        void work() {
            System.out.println(this.getClass().getSimpleName()+" work at 7:00");
        }

        @Override
        void eating() {
            System.out.println(this.getClass().getSimpleName()+" eating at 12:00");
        }

        @Override
        void goHome() {
            System.out.println(this.getClass().getSimpleName()+" goHome at 19:00");
            System.out.println("================================================");
        }
    }
    private static class Worker extends Life{

        @Override
        void getup() {
            System.out.println(this.getClass().getSimpleName()+" getup at 7:00");
        }

        @Override
        void work() {
            System.out.println(this.getClass().getSimpleName()+" work at 8:00");
        }

        @Override
        void eating() {
            System.out.println(this.getClass().getSimpleName()+" eating at 12:00");
        }

        @Override
        void goHome() {
            System.out.println(this.getClass().getSimpleName()+" goHome at 18:00");
            System.out.println("================================================");
        }
    }
    private static class Teacher extends Life{

        @Override
        void getup() {
            System.out.println(this.getClass().getSimpleName()+" getup at 7:00");
        }

        @Override
        void work() {
            System.out.println(this.getClass().getSimpleName()+" work at 8:00");
        }

        @Override
        void eating() {
            System.out.println(this.getClass().getSimpleName()+" eating at 12:00");
        }

        @Override
        void goHome() {
            System.out.println(this.getClass().getSimpleName()+" goHome at 17:00");
            System.out.println("================================================");
        }
    }

    public static void main(String[] args) {
        new Farmer().life();
        new Worker().life();
        new Teacher().life();
    }
}

运行结果：
Farmer getup at 6:00
Farmer work at 7:00
Farmer eating at 12:00
Farmer goHome at 19:00
================================================
Worker getup at 7:00
Worker work at 8:00
Worker eating at 12:00
Worker goHome at 18:00
================================================
Teacher getup at 7:00
Teacher work at 8:00
Teacher eating at 12:00
Teacher goHome at 17:00
================================================

装饰模式

一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。因此动态地给一个对象添加一些额外功能，我们可以采用包装的形式，即包装原有的类称为装饰。

public class DecoratorPattern {

    public interface PSA{
        void proLogo();
    }

    public static class Citroen implements PSA{
        private String proLogo= "Citroen";
        @Override
        public void proLogo() {
            System.out.println("proLogo: "+proLogo);
        }
        public void setProLogo(String proLogo) {
            this.proLogo = proLogo;
        }
    }

    public static class Peugeot implements PSA{
        private String proLogo= "Peugeot";
        @Override
        public void proLogo() {
            System.out.println("proLogo: "+proLogo);
        }
        public void setProLogo(String proLogo) {
            this.proLogo = proLogo;
        }
    }

    public static abstract class PSADecorator implements PSA{
        protected PSA psa;
        PSADecorator(PSA psa){
            this.psa= psa;
        }
        public void proLogo() {
            psa.proLogo();
        }
    }

    public static class DSDecorator extends PSADecorator{
        DSDecorator(PSA psa) {
            super(psa);
        }

        @Override
        public void proLogo() {
            changePreLogo();
            psa.proLogo();
        }

        private void changePreLogo(){
           if(psa instanceof Citroen){
               Citroen citroen= (Citroen) psa;
               citroen.setProLogo("DS");
           }else {
               Peugeot citroen= (Peugeot) psa;
               citroen.setProLogo("DS");
           }
        }
    }

    public static void main(String[] args) {
        DSDecorator dsDecorator0= new DSDecorator(new Citroen());
        DSDecorator dsDecorator1= new DSDecorator(new Peugeot());
        dsDecorator0.proLogo();
        dsDecorator1.proLogo();
    }
}

运行结果：
proLogo: DS
proLogo: DS

代理模式

静态代理，基于继承实现父类，并对父类方法进行扩展。

public class StaticProxy {
    public static class PeopleBeijing {
        public void like(){
            System.out.println("I like beijing.");
        }
    }

    public static class People extends PeopleBeijing {
        PeopleBeijing people;
        People(PeopleBeijing people){
            this.people= people;
        }

        public void like(){
            people.like();
            System.out.println("I like china.");
        }
    }

    public static void main(String[] args) {
        new People(new PeopleBeijing()).like();
    }
}

运行结果：
I like beijing.
I like china.

动态代理，详见 https://www.jianshu.com/p/baba5012ba10
静态代理和动态代理最大的区别是：静态代理类在运行时已经生成，而动态代理的类是在运行时候动态生成。

策略模式

1.如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。
2.一个系统需要动态地在几种算法中选择一种。
3.如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现

例如下面的超时针对不同的客户群体打折不一样：

public class StrategyPattern {
    public interface Strategy{
        void sell(BigDecimal price);
    }

    public static class CustomerVIP implements Strategy{

        @Override
        public void sell(BigDecimal price) {
            System.out.println(this.getClass().getSimpleName()+" spend "+ price.multiply(new BigDecimal(0.8)).setScale(2,BigDecimal.ROUND_HALF_UP));
        }
    }

    public static class CustomerOrdinary implements Strategy{

        @Override
        public void sell(BigDecimal price) {
            System.out.println(this.getClass().getSimpleName()+" spend "+ price.multiply(new BigDecimal(0.98)).setScale(2,BigDecimal.ROUND_HALF_UP));
        }
    }

    public static class Context{
        private Strategy strategy;
        Context(Strategy strategy){
            this.strategy= strategy;
        }
        public void exeStrategy(BigDecimal bigDecimal){
            strategy.sell(bigDecimal);
        }
    }

    public static void main(String[] args) {
        BigDecimal price= new BigDecimal(100);
        new Context(new CustomerVIP()).exeStrategy(price);
        new Context(new CustomerOrdinary()).exeStrategy(price);
    }
}

门面模式

特别适用于微服务，例如网关层提供对外接口，一般一个接口数据可能来源于多个子系统，这个时候就需要把多个接口封装成一个接口对外提供服务，既实现了子系统和客户端的解耦还提高了访问效率。

public class FacePattern {
    public static class Service1{
        public String search(){
            return "1";
        }
    }
    public static class Service2{
        public String search(){
            return "2";
        }
    }
    public static class Service3 {
        public String search(){
            return "3";
        }
    }

    public static class Service{
        public List<String> getResult(){
            Service1 service1 = new Service1();
            Service2 service2 = new Service2();
            Service3 service3 = new Service3();
            return Arrays.asList(service1.search(),service2.search(),service3.search());
        }
    }

    public static void main(String[] args) {
       System.out.println(new Service().getResult());
    }
}

运行结果：
[1, 2, 3]

观察者模式

解决对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。

public class ObserverPattern {
    
    interface Observer{
        void update(String msg);
    }

    public static class Observer1 implements Observer{
        @Override
        public void update(String msg) {
            System.out.println(this.getClass().getSimpleName()+" received : "+msg);
        }
    }

    public static class Observer2 implements Observer{
        @Override
        public void update(String msg) {
            System.out.println(this.getClass().getSimpleName()+" received : "+msg);
        }
    }

    public static class Subject{
        private List<Observer> observerList= new ArrayList<>();

        public Subject addAttach(Observer observer){
            observerList.add(observer);
            return this;
        }

        private void pub(String msg){
            for (Observer o:observerList){
                o.update(msg);
            }
        }

        public void update(String msg){
            pub(msg);
        }
    }

    public static void main(String[] args) {
        Subject subject= new Subject();
        subject.addAttach(new Observer1()).addAttach(new Observer2()).update("today is thursday.");
    }
}

运行结果：
Observer1 received : today is thursday.
Observer2 received : today is thursday.

更多设计模式请参考：http://www.runoob.com/design-pattern/design-pattern-tutorial.html

Java 常用设计模式简例
简述Java常用设计模式简述Java常用设计模式及设计原则 strate---------策略模式针对接口编程，...
工厂模式
java设计模式-工厂模式工厂模式：工厂模式是java设计模式里最常用的设计模式之一。工厂模式属于创建型模式...
java中常用的设计模式?
java中常用的设计模式?
知识复盘
1：熟练使用Android常用性能调优 2：Java常用设计模式 3：Android常用设计模式（架构） 4：An...
单例模式
JAVA设计模式之单例模式十种常用的设计模式概念： java中单例模式是一种常见的设计模式，单例模式的写法...
java动态代理（JDK和cglib）(转载自http://ww
java动态代理（JDK和cglib） JAVA的动态代理代理模式代理模式是常用的java设计模式，他的特征是...
设计模式之工厂模式
工厂模式工厂模式（Factory Pattern）是Java中最常用的设计模式之一，这种设计模式属于创建型模式，...
设计模式-工厂模式
工厂模式定义：工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式...
Java设计模式——工厂模式
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，...
2.工厂模式
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，...