Breaking News: Grepper is joining You.com. Read the official announcement!

decorator design pattern

Add Answer

Amjad Saeed answered on December 29, 2022 Popularity 10/10 Helpfulness 1/10

answer decorator design pattern

related Decorator pattern

related decorator design pattern

decorator design pattern

Comment

4. Decorator:
The Decorator pattern lets you attach additional responsibilities to objects dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.

Example in ReactJS:

Imagine you have a text input component and you want to decorate it with additional features like validation.

// TextInput.js
const TextInput = ({ label, value, onChange }) => (
  <div>
    <label>{label}</label>
    <input type="text" value={value} onChange={onChange} />
  </div>
);

// Decorator for Validation
const withValidation = (WrappedComponent) => ({ label, value, onChange, validate }) => {
  const isValid = validate(value);

  return (
    <div>
      <WrappedComponent label={label} value={value} onChange={onChange} />
      <p>{isValid ? "Valid" : "Invalid"}</p>
    </div>
  );
};

// Usage
const ValidatedTextInput = withValidation(TextInput);

const App = () => (
  <ValidatedTextInput
    label="Username"
    value="user123"
    onChange={(e) => console.log(e.target.value)}
    validate={(value) => value.length >= 6}
  />
);

Popularity 10/10 Helpfulness 1/10 Language javascript

Source: Grepper

Tags: decorator javascript

Link to this answer
Share Copy Link

Contributed on Sep 04 2023

Amjad Saeed

0 Answers Avg Quality 2/10

Closely Related Answers

Decorator pattern

Comment

// Pizza interface representing the core pizza functionality
public interface IPizza
{
    string GetDescription();
    decimal GetCost();
}

// Concrete pizza class implementing the IPizza interface
public class PlainPizza : IPizza
{
    public string GetDescription()
    {
        return "Plain Pizza";
    }

    public decimal GetCost()
    {
        return 10.0M;
    }
}

// Abstract decorator class implementing the IPizza interface
public abstract class PizzaDecorator : IPizza
{
    protected IPizza pizza;

    public PizzaDecorator(IPizza pizza)
    {
        this.pizza = pizza;
    }

    public virtual string GetDescription()
    {
        return pizza.GetDescription();
    }

    public virtual decimal GetCost()
    {
        return pizza.GetCost();
    }
}

// Concrete decorator classes adding toppings to the pizza
public class CheeseDecorator : PizzaDecorator
{
    public CheeseDecorator(IPizza pizza) : base(pizza)
    {
    }

    public override string GetDescription()
    {
        return pizza.GetDescription() + ", Cheese";
    }

    public override decimal GetCost()
    {
        return pizza.GetCost() + 2.0M;
    }
}

public class TomatoDecorator : PizzaDecorator
{
    public TomatoDecorator(IPizza pizza) : base(pizza)
    {
    }

    public override string GetDescription()
    {
        return pizza.GetDescription() + ", Tomato";
    }

    public override decimal GetCost()
    {
        return pizza.GetCost() + 1.5M;
    }
}

class Program
{
    static void Main()
    {
        // Client code creates and decorates the pizza with toppings
        IPizza pizza = new TomatoDecorator(new CheeseDecorator(new PlainPizza()));

        Console.WriteLine("Pizza Description: " + pizza.GetDescription());
        Console.WriteLine("Pizza Cost: $" + pizza.GetCost());
    }
}

Popularity 10/10 Helpfulness 1/10 Language csharp

Source: chat.openai.com

Tags: c# c

Link to this answer
Share Copy Link

Contributed on Jul 30 2023

mahnaz foroutan

0 Answers Avg Quality 2/10

decorator design pattern

Comments(1)

interface Color{
    void fill();
}

//concrete component of the base interface
class Black implements Color{
    @Override
    public void fill(){
        System.out.println("Black color");
    }
}

//abstract decorator class
abstract class ColorDecorator implements Color{

    //base class object
    protected Color colored;
    
    //constructor with base class object as the parameter
    public ColorDecorator(Color colored){
        this.colored = colored;
    }
    
    public void fill(){
        colored.fill();
    }
}

//concrete decorator class extending base decorator class
class PatternDecorator extends ColorDecorator{
    public PatternDecorator(Color colored){
        super(colored);
    }
    
    public void fill(){
        colored.fill();
        addPattern(colored);
    }
    
    private void addPattern(Color colored){
        System.out.println("Pattern");
    }
}

class Demo{
    public static void main(String[] args){
    
    Color black = new Black();
    Color pattern = new PatternDecorator(new Black());
     
    System.out.println("\nStyle: Solid");
    black.fill();
    
    System.out.println("\nStyle: Pattern");
    pattern.fill();
    }
}

Popularity 10/10 Helpfulness 1/10 Language java

Source: www.scaler.com

Tags: decorator deco

Link to this answer
Share Copy Link

Contributed on Dec 29 2022

Deepika Sahu

0 Answers Avg Quality 2/10

decorator design pattern

Contents

More Related Answers

decorator design pattern

Closely Related Answers

Decorator pattern

decorator design pattern

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.