"How to use" decorator mode

This paper

Using inheritance to design the behavior of subclasses , Statically determined at compile time , And all subclasses will inherit this behavior . If you use composition to extend the behavior of objects , It can be dynamically extended at runtime .

Decorator mode ： Attach responsibility to the object dynamically . To extend functionality , Decorators offer a more flexible alternative to inheritance .

OO principle ： Open to expansion , Turn off for changes .

principle

1. Component It's the father of the decorated object , It's an interface , Define the behavior of the adorned
2. Decorator It's the decorator's father , It inherited Component, It ensures that the types of decorators and decoratees are consistent
3. Decorator My sons all have one Component References to objects , Used to correct Compoment Behavior doing “ decorate ”

Realization

public interface Component {
    

    String DESCRIPTION = " I am a component";

    default String getDescription(){
    
        return DESCRIPTION;
    }

    /** *  Decorated with extended behavior  */
    String link();
}

public interface Decorator extends Component {
    

    /** *  Decorator overrides this method to add his own attribute definition , Or extend this method  * @return */
    @Override
    String getDescription();
}

public class ConcreteComponentB implements Component {
    

    @Override
    public String link() {
    
        return " I am a Component My second son is right link The implementation of the -->";
    }
}

public class ConcreteDecoratorB implements Decorator {
    

    private Component component;

    public ConcreteDecoratorB(Component component) {
    
        this.component = component;
    }

    @Override
    public String getDescription() {
    
        return component.getDescription() + "--> I am the packer B Description of ";
    }

    @Override
    public String link() {
    
        return "Decorator My second daughter is right Component Of link Made a decoration -->" + component.link();
    }
}

Test class

public class TestDrive {
    
    public static void main(String[] args) {
    
        Component componentB = new ConcreteComponentB();
        componentB = new ConcreteDecoratorA(componentB);
        componentB = new ConcreteDecoratorB(componentB);
        System.out.println("componentB.getDescription() = " + componentB.getDescription());
        System.out.println("componentB.link() = " + componentB.link());
    }
}

Output

componentB.getDescription() =  I am a component--> I am the packer A Description of --> I am the packer B Description of 
componentB.link() = Decorator My second daughter is right Component Of link Made a decoration -->
				Decorator My eldest daughter is right Component Of link Made a decoration --> I am a Component My second son is right link The implementation of the -->

summary

• Decorator mode uses a noun called “ Combine ”, In fact, its soul is “ polymorphic ”, See clearly , No “ metamorphosis ” ：）
• In fact, the idea of usage is very simple , To get a “ Decorator ” Interface inheritance “ Decorated ” also @Override to want to “ decorate ” Methods 【 Not all methods , Otherwise, this is not decoration, but demolition 】, Then different decorator implementation classes decorate this method . The premise of decoration is to hold a quotation of the decorator , That's the only way , To the method that has been realized in the decorator “ Move one's hand or one's foot ”【 Everyone is in your room , You can do whatever you want ：）】

Q&A

Q： So much Component and Decorator Implementation class of , Isn't it life “ Class blast ”？
A： Engage in “ Factory mode ” Well

PS : Xiba , Another boring day (¯﹃¯)