Hello again, I have a recommendation for 042_Compositions:The motivation lies in the fact that you want the system / application to have an interface for the creation of families of related objects without there being a dependency on the specific classes of these objects to promote future extensibility. For the present project, there are classes "Monitor", "Motherboard" and "Case" which are concrete classes used by a class "Computer" in its constructor. These concrete classes are families that are related to being components of a computer, and they can also have variations - cite High Range or Low Range as an example. By implementing Abstract Factory, these variations can be created to create Computers with high-end and low-end components -citing it as an example-, through a creation interface without depending on specific classes, favoring the extensibility of the system and reducing the coupling between classes .

Hi again. I was checking the code that you use for "045_BillyBurger" and I think about something you can use: Well, you want to operate with hamburgers with the class "Hamburger" where within it are different attributes of type String representing the additional ones with which to order the hamburger, be they drinks, potatoes, etc. And Hamburger's heritage branch does the same. Since being as Strings the functionality is limited, implementing the Composite pattern would be able to operate the hamburgers together with their additional ones as simple objects if desired or work them as a single as a "combo" through a recursive composition where a in turn, the client could operate with these types of objects indistinctly, citing as an example the calculation of the total to pay for all the food ordered. I add the uml class diagram to illustrate the design:

Hope you're fine and have a nice day

Hello again. I was checking something, and notice something: In the Hamburger class (where the code smell Data Clumps was reviewed) there is a method called itemisedHamburger (), which allows to calculate the total price to pay for the hamburger and its extras. The way in which the method to calculate the total to pay is implemented tends to have a method with very long code which reuses code in a bad way by having to validate each of the additional ones. You can refactor your code by ussing Substitute Algorithm. With this technique, the size of the code would be greatly reduced by not having to reuse code in a bad way through validations through if blocks for each of the additional ones, avoiding repeating the code unnecessarily. To consolidate the change in the first instance, a field is added as a list that will allow storing the additional ones and in turn the number of additional ones is deleted along with their methods to only leave the aforementioned list and an addAditional () method is added so additional ones are added to the list, thus avoiding having many methods with similar algorithms:

The field for the additionals (Don't forget to initializate it) and my proppose for the code:

  private ArrayList<HamburgerAdditional>listAdditional;
  public void addAddition(HamburgerAdditional addition) {
	if(this.listAdditional.size()>3) {
		System.out.println("The Standard Hamburguer can only have 4 additionals");
	}
	else {	
    this.listAdditional.add(addition);
	}
}

public double itemisedHamburger() {
    double subTotal = this.basePrice;
    System.out.println("Total price of "+ this.name+ " burger made from "
            + this.breadRollType+ " and "+ this.meat+ ":");
    System.out.println("base price: " + this.basePrice);
 
    for(HamburgerAdditional x: this.listAdditional) {
    	if(x != null) {
    		subTotal += x.getPrice();
            System.out.println("additional " + x.getName()+ ": "+ x.getPrice()
                    + " subtotal: "+ (double) Math.round(subTotal * 100) / 100);		
    	}  	
    }
    return Math.round(subTotal * 100)/100;

}

Have a nice day

Hello. Happy New Year. Checking the code I come up with something you can consider for the Inheritance-Challenge: You want to build a car using the “Car” class, but this can have different representations (variations according to its brand, model, etc.) as can be seen in the “Outlander” class where this is a car with certain special characteristics that inherits from "Car". Since to build a car you can use a standard creation process with variations depending on the specific type of vehicle you want to create and in order to avoid creating n classes for n representations through inheritance or calls to constructors with many parameters (scent code), the use of the Builder pattern is proposed to use the same construction process (code) to create different representations of the various cars in a more flexible way.

Hello again. I hope you're doing fine. I was checking your code again and I come up with something. In the Hamburger class there are several related fields that are repeated over and over again, such as the name of the add-on and its price. generate a kind of duplicate code, for example, the methods to define the add-ons are repeated for each add-on name-price pairs. In turn, these groups of variables always act together and without one, the other would be meaningless for the class. So, you can refactor your code by usin Extract Class. Since these groups of variables are already contained within a class, it would facilitate the understanding of the code and its organization by not having the variables dispersed throughout the class. In turn, organizing them within a class allows the size of the code to be reduced and even, if you want to perform some type of operation with groups of variables, this will be easier since the variables now belong to a class as such. Once the class is extracted, the variables are replaced by calls to the objects of the HamburgerAdditional class. Code for the new class:

    public class HamburgerAdditional {
         public String name;
         public double price;

public HamburgerAdditional(String name, double price) {
	this.name=name;
	this.price=price;
}

public String getName() {
	return this.name;
}

public double getPrice() {
	return this.price;
}

public void setName(String name){
	this.name=name;
}

public void setPrice(double price) {
	this.price=price;
}

public String toString() {
	return "Adittional: "+name+" - "+price;
}

}
Have a nice day!