From daab59a99970f523d69905e670f6b28c18b9c639 Mon Sep 17 00:00:00 2001 From: "xuanyi.wang" Date: Tue, 4 Apr 2023 20:33:02 +0200 Subject: [PATCH] Update page 'Day 4 homework - Sloetjes' --- Day 4 homework - Sloetjes.md | 174 +++++++++++++++++++++++++++++++++++ 1 file changed, 174 insertions(+) create mode 100644 Day 4 homework - Sloetjes.md diff --git a/Day 4 homework - Sloetjes.md b/Day 4 homework - Sloetjes.md new file mode 100644 index 0000000..bc6a6a9 --- /dev/null +++ b/Day 4 homework - Sloetjes.md @@ -0,0 +1,174 @@ +# Xuanyi Wang\_Day-4\_Homework\_04/03/23 + + +As a recap, we've talked about how numbers work, how characters work, how characters are combined into text via lexers and parsers, and how numbers and text are combined via operators in custom classes: + +``` +Numbers ------------------------> Operators -> ? +Characters --(Lexers/Parsers) --> Operators -> ? +``` + +Today's homework is to think about how to design classes, or what the industry calls "object-oriented design." You have to be careful to minimize complexity when designing public interfaces and APIs to your code, otherwise this happens: + +https://github.com/EnterpriseQualityCoding/FizzBuzzEnterpriseEdition/blob/uinverse/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopCondition.java + +Remember fizzbuzz? This is a satirical version built using every object-oriented pattern in the book. There is an actual book on the subject, which is widely respected throughout the industry, and in some cases misused to overcomplicate code: + +https://en.wikipedia.org/wiki/Design_Patterns + +The assignment for today is to think about some everyday thing you interact with, such as an elevator, a pet, or anything which has tangible and measurable *inputs* and *outputs*. There are three files to look at in the `simulation` directory in this repository: + +* SimulationRunner: a program to run simulation classes. +* Simulation: the interface definition for a simulation. +* HotdogSimulation: a class simulating a hot dog. + +Design two versions of this object with the following shared criteria: + +* Define the start, stop, tick, get_uses, and use methods. +* Ensure that the object expires when a reasonable number of ticks have passed. + +**1. One version of the object should be very simple, such as the hot dog example.** + +#####The Simple Version of Water Bottle Object: + +``` +class WaterBottle: + def __init__(self, max_uses): + self.uses = 0 + self.max_uses = max_uses + + def start(self): + pass + + def stop(self): + pass + + def tick(self): + self.uses += 1 + if self.uses >= self.max_uses: + return False + return True + + def get_uses(self): + return self.uses + + def use(self): + return "You take a sip of water." +``` + +**2. The other version of the object should be overly complicated, with verbs such as `weigh` to get its mass, `mood` to get its mood, `price_tag` to have it return its estimated value, and `go_to_moon` to send the object to the moon (in the case of the pet, it would probably explode and `use()` should return `False`). Try to define at least 20 different verbs you could use on the object, with associated instance variables to track its state so the verbs interact correctly. For example, a `throw` verb on a hot dog should reduce its mass, because some of its condiments will end up on the target.** + +#####The complicated version of Water Bottle Object: +``` +class WaterBottle: + def __init__(self, max_uses): + self.uses = 0 + self.max_uses = max_uses + self.volume = 1000 # in milliliters + self.temperature = 20 # in celsius + self.color = "multi" + self.brand = "Takeya" + self.material = "stainless" + + def start(self): + self.temperature = 25 + + def stop(self): + pass + + def tick(self): + self.uses += 1 + if self.uses >= self.max_uses: + return False + return True + + def get_uses(self): + return self.uses + + def use(self): + if self.volume >= 100: + self.volume -= 100 + return "You take a sip of water." + else: + return "There is not enough water in the bottle." + + def weigh(self): + return self.volume * 1.0 # density of water is 1 g/cm^3 + + def set_color(self, color): + self.color = color + + def get_color(self): + return self.color + + def set_brand(self, brand): + self.brand = brand + + def get_brand(self): + return self.brand + + def set_material(self, material): + self.material = material + + def get_material(self): + return self.material + + def set_temperature(self, temperature): + self.temperature = temperature + + def get_temperature(self): + return self.temperature + + def price_tag(self): + return "$26.50" + + def BPA_Free_solution(self): + return "The water bottle is a BPA free one." + + def Insulated_Spout_Lid(self): + return "This stainless steel water bottle comes with an innovative leakproof insulated spout lid that allows for easy one-handed drinking or pouring. It features a hinge lock that keeps the cap out of your way while drinking." + + def freeze(self): + self.temperature = -5 + + def melt(self): + self.temperature = 20 + + def recycle(self): + self.material = "recycled stainless" + + def refill(self): + self.volume = 1000 + + def pour_out(self, amount): + if self.volume >= amount: + self.volume -= amount + return "You pour out {} milliliters of water.".format(amount) + else: + return "There is not enough water in the bottle." + + def add_water(self, amount): + self.volume += amount + return "You add {} milliliters of water.".format(amount) + + def add_ice(self, amount): + self.volume += amount + self.temperature = -10 + return "You add {} grams of ice.".format(amount) + + def add_lemon(self): + return "You add a slice of lemon to the water." + + def add_sugar(self, amount): + return "You add {} grams of sugar to the water.".format(amount) + + def add_salt(self, amount): + return "You add {} grams of salt to the water.".format(amount) + + def add_tea(self, amount): + return "You add {} grams of tea to the water.".format(amount) + +``` + +Although it would be preferred to create a Python file that can be run under the simulator, a text specification is also acceptable. The important thing is for the object to have a consistent model of its state which accurately represents what would happen in real life when methods (verbs) are applied to it. +Welcome to Wiki! \ No newline at end of file