Hello friends!
Welcome to this week’s Sloth Bytes.
Hope you had a great week!
Sloths spend up to 90% of their lives upside down
Studies show this is possible because their organs are attached to their rib cage, so they don’t weigh down on their lungs.
Unlike us, a sloth can hang upside down without affecting their breathing.
OOP Pillar #3: Inheritance
What is Inheritance?
Inheritance is when a new class takes on or you know… INHERITS the properties and methods of an existing class. This helps in reusing code and building a structure where classes are related to each other.
Why Inheritance Matters
Code reusability
Establishes a clear hierarchy
Allows polymorphism (I’ll talk about that next week 😁)
Reduces redundant code
Key Concepts:
Superclass (Parent class): The class being inherited from
Subclass (Child class): The class that inherits
Override: Redefining a method in a subclass
Extend: Adding new methods or properties in a subclass
Python Example:
class Animal:
def __init__(self, name, age):
self.name = name
self.age = age
def speak(self):
return f"{self.name} is an animal."
class Dog(Animal):
def speak_dog(self):
return f"{self.name} is a dog."
#inherited the self.name from the Animal class
class Cat(Animal):
def speak_cat(self):
return f"{self.name} is a cat."
#inherited the self.name from the Animal class
# Usage
dog = Dog("Buddy", 10)
cat = Cat("Whiskers", 5)
print(dog.speak_dog()) # Output: Buddy is a dog.
print(cat.speak_cat()) # Output: Whiskers is a cat.
print(dog.speak()) # Output: Buddy is an animal.
print(cat.speak()) # Output: Whiskers is an animal.Java Example:
// superclass/Parent class
class Animal {
String name;
int age;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public String speak() {
return name + " is an animal.";
}
}
// Subclass/Child class
class Dog extends Animal {
public Dog(String name, int age) {
super(name, age); //Allows us to access parent class info.
}
// Method specific to Dog
public String speakDog() {
return name + " is a dog.";
}
}
// Subclass/Child class
class Cat extends Animal {
public Cat(String name, int age) {
super(name, age); //Allows us to access parent class info.
}
public String speakCat() {
return name + " is a cat.";
}
}
// Usage
public class Main {
public static void main(String[] args) {
// Usage
Dog dog = new Dog("Buddy", 10);
Cat cat = new Cat("Whiskers", 5);
System.out.println(dog.speakDog());
// Output: Buddy is a dog.
System.out.println(cat.speakCat());
// Output: Whiskers is a cat.
System.out.println(dog.speak());
// Output: Buddy is an animal.
System.out.println(cat.speak());
// Output: Whiskers is an animal.
}
}Benefits of Inheritance:
Code reusability
Logical organization of code
Runtime polymorphism
Easier maintenance and updates
Best Practices:
Use inheritance when one thing "is a" type of another thing. ("is-a" relationships)
Keep inheritance hierarchies shallow.
Override methods carefully
Use composition instead of inheritance when it makes sense.
Composition = “has-a”.
Inheritance = “is-a”.
ex: A building IS A house, but a bathroom is NOT a building or a house. However, a house HAS A bathroom.
Common Pitfalls:
Overuse leading to complex hierarchies
Tight coupling between classes
Breaking encapsulation in subclasses
Real-World Analogy: Think of a family tree. Children inherit traits from their parents, but may also have unique characteristics.
Remember: Inheritance is powerful, but use it wisely. Not every relationship between classes needs to be an inheritance relationship.
Quick Tip: When deciding whether to use inheritance, ask: "Does this new class need everything from the parent class, or just some things?" If it's the latter, consider composition instead.
If you want to keep learning OOP
Object-oriented programming explained — the main OOP guide covering classes, objects, and all four pillars.
Abstraction — how OOP hides unnecessary implementation details.
Encapsulation — how objects control access to internal state.
Polymorphism — how inherited interfaces can behave differently across classes.
Thank you to everyone who submitted last week!
Love to see more people submitting.
ChicIceCream, ddat828, FragileBranch, kwame-Owusu, afiqzudinhadi, DevonKirby, Dupamin, tobiaoy, sloprope, ravener, RelyingEarth87, JSivic25, Neko0kami, VSparl, sarolta-nemeth, and last one:
Let’s do some practice with 2d arrays 😁
Where’s Waldo
Return the coordinates ([row, col]) of the element that differs from the rest.
Examples
whereIsWaldo([
["A", "A", "A"],
["A", "A", "A"],
["A", "B", "A"]
])
output = [3, 2] #B is different from the rest.
whereIsWaldo([
["c", "c", "c", "c"],
["c", "c", "c", "d"]
])
output = [2, 4] # D is different from the rest.
whereIsWaldo([
["O", "O", "O", "O"],
["O", "O", "O", "O"],
["O", "O", "O", "O"],
["O", "O", "O", "O"],
["P", "O", "O", "O"],
["O", "O", "O", "O"]
])
output = [5, 1] #P is different from the rest.Notes
The given array will always be a square or rectangle.
Rows and columns are 1-indexed (not zero-indexed).
How To Submit Answers
Reply with
A link to your solution (github, twitter, personal blog, portfolio, replit, etc)
or if you’re on the web version leave a comment!
Video finally got posted
If you haven’t already check out the new video 😄
Working on the next video!
Next video is how to use AI to program better/faster and how to use it to learn faster. So stay tuned!
That’s all from me!
Have a great week, be safe, make good choices, and have fun coding.
See you all next week.
