装饰者模式 && 门面设计模式 && 工厂方法模式

一、装饰者模式定义：
在不改变原有对象的基础上，将功能附加到对象上

public class DecoratorTest {
    public static void main(String[] args) {
        // 就拿一个拍照更能举例说明，他可以有美颜 和 滤镜功能，但是不能影响之前的拍照功能
        // 设计模式遵循开闭原则 和 职责单一原则
        //先拍照然后 美颜 最后滤镜 这三个功能互不牵扯
        Component concreate = new ConcreteDecortor2(new ConcreteDecortor1(new Concreate()));
        concreate.opration();
    }

    public interface Component{
        void opration();
    }

    static class Concreate implements Component{
        @Override
        public void opration() {
            System.out.println("拍照");
        }
    }

    static abstract class Decorator implements Component{
        protected Component mComponent;
        public Decorator(Component component){
            this.mComponent = component;
        }
    }
    
    static class ConcreteDecortor1 extends Decorator{
        public ConcreteDecortor1(Component component) {
            super(component);
        }
        @Override
        public void opration() {
            mComponent.opration();
            System.out.println("美颜。。。");
        }
    }

    static class ConcreteDecortor2 extends Decorator{
        public ConcreteDecortor2(Component component) {
            super(component);
        }
        @Override
        public void opration() {
            mComponent.opration();
            System.out.println("滤镜。。。");
        }
    }
}

应用场景：扩展一个类的功能或给一个类添加附加职责
有点：
1.不改变原有对象的情况下给一个对象扩展功能
2.使用不同组合可以实现不同的效果
3.符合开闭原则，对修改进行关闭对拓展进行开放

二、门面设计模式定义：
为子系统的一组接口提供一个一致的接口，facade [fəˈsɑːd]（表面的意思）模式定义了一个高层接口，这个接使得这一子系统更加容易使用。

public class FacadeTest {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.doSomethingFacade();
    }

    // 门面角色，客户端可以调用此方法来和其他子系统打交道
    static class Facade {
        public void doSomethingFacade() {
            SubSystem1 subSystem1 = new SubSystem1();
            SubSystem2 subSystem2 = new SubSystem2();
            SubSystem3 subSystem3 = new SubSystem3();
            subSystem1.method1();
            subSystem2.method2();
            subSystem3.method3();
        }
    }

    // 子系统角色
    static class SubSystem1 {
        public void method1() {
            System.out.println("method1method1method1");
        }
    }

    static class SubSystem2 {
        public void method2() {
            System.out.println("method2method2method2");
        }
    }

    static class SubSystem3 {
        public void method3() {
            System.out.println("method3method3method3");
        }
    }
}

三、工厂方法模式定义：
定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory method 使得一个类的实例化延迟到子类

修改前

public class FactoryTest {
    public static void main(String[] args) {
        Application application = new Application();
        ProductA object = application.getObject();
        object.method1();
    }
   static class ProductA{
        public void method1(){
            System.out.println("ProductA.mehotd1 executed ");
        }
   }
   static class Application{
        private ProductA createProduct(){
            // ... init
            return new ProductA();
        }
       ProductA getObject(){
           ProductA product = createProduct();
           return product;
       }
   }
}

修改后

public class FactoryTest2 {
    public static void main(String[] args) {
        Application application = new ConcreteProductA();
        Product object = application.getObject();
        object.method1();
    }

    public interface Product {
        void method1();
    }
    static class ProductA implements Product {
        // 假设 method1 是不变的，每个产品是变化的，但是唯一不变的就是method1
        public void method1() {
            System.out.println("ProductA.mehotd1 executed ");
        }
    }
    static class ProductB implements Product {
        // 假设 method1 是不变的，每个产品是变化的，但是唯一不变的就是method1
        public void method1() {
            System.out.println("ProductA.mehotd1 executed ");
        }
    }
    abstract static class Application {
        // 这个是变化的，交给子类去处理
        // 这个就是一个工厂方法，让product的实现延迟到子类
        abstract Product createProduct();

        Product getObject() {
            Product product = createProduct();
            return product;
        }
    }
    // 实例化的过程已经到我们具体的实现里面
    static class ConcreteProductA extends Application{
        @Override
        Product createProduct() {

            return new ProductA();
        }
    }
    static class ConcreteProductB extends Application{
        @Override
        Product createProduct() {
            return new ProductB();
        }
    }
}

应用场景：
1.当你不知道该使用对象的确切类型的时候
2.当你希望为库或者框架提供扩展其内部组件的方法时

主要优点：
1.将具体产品和创建者解耦
2.符合单一职责原则
3.符合开闭原则

四、在main（）方法中不能创建非静态内部类的实例：

public class OuterClass {
 
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        InnerClass innerClass = outerClass.new InnerClass();
        StaticInnerClass staticInnerClass = new StaticInnerClass();
    }
 
    public void foo() {
        InnerClass innerClass = new InnerClass();
        StaticInnerClass staticInnerClass = new StaticInnerClass();
    }
 
    public class InnerClass {
 
    }
 
    public static class StaticInnerClass {
 
    }
}

1：非静态内部类，必须有一个外部类的引用才能创建。
2：在外部类的非静态方法中，因为有隐含的外部类引用this，所以可以直接创建非静态内部类。
3：在外部类的静态方法中，因为没有this，所以必须先获得外部类引用，然后创建非静态内部类。
4：静态内部类，不需要外部类引用就可以直接创建。
5：同时静态的内部类，也不能直接访问外部类的非静态方法。
6：由此可以推测，非静态内部类之所以可以直接访问外部类的方法，是因为创建非静态内部类时，有一个隐含的外部类引用被传递进来。