Programming Entry Level: tutorial classes

This content originally appeared on DEV Community and was authored by DevOps Fundamental

Understanding Tutorial Classes for Beginners

So, you’re starting your programming journey – awesome! You’ve probably heard about “classes” and maybe even “tutorial classes.” They can sound intimidating, but trust me, they’re a fundamental building block of many programming languages and understanding them will unlock a lot of power. This post will break down what tutorial classes are, why they’re useful, and how to start using them. Knowing this stuff is also super helpful in technical interviews, as it shows you understand core programming concepts.

2. Understanding “tutorial classes”

Imagine you’re building with LEGOs. You could just pile bricks together randomly, but it’s much more organized (and fun!) to follow instructions to build a specific model, like a car or a house.

A “class” in programming is like those LEGO instructions. It’s a blueprint for creating objects. Think of an object as the finished LEGO model – a specific instance of the instructions.

Let’s say you want to represent a dog in your program. A class called Dog would define what a dog is – it has a name, a breed, and can bark. Each individual dog (like your pet Fido or your neighbor’s Spot) would be an object created from the Dog class. They all share the same characteristics (name, breed, bark), but each dog has its own specific values for those characteristics.

Here’s a simple way to visualize it using a diagram:

classDiagram
    class Dog {
        - name : string
        - breed : string
        + bark() : void
    }

This diagram shows the Dog class has attributes (name and breed) and a method (bark). Attributes are the data the object holds, and methods are the actions the object can perform.

3. Basic Code Example

Let’s see how this looks in Python:

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def bark(self):
        print("Woof! My name is", self.name)

Let’s break this down:

1. class Dog:: This line defines a new class named Dog. It’s like creating the blueprint.
2. def __init__(self, name, breed):: This is a special method called the constructor. It’s automatically called when you create a new Dog object. self refers to the object being created. name and breed are parameters you pass in when creating the dog.
3. self.name = name: This line assigns the value of the name parameter to the name attribute of the Dog object. self.breed = breed does the same for the breed.
4. def bark(self):: This defines a method called bark. Methods are functions that belong to the class. Again, self refers to the specific Dog object that’s barking.
5. print("Woof! My name is", self.name): This line prints a message including the dog’s name.

Now, let’s create some Dog objects:

my_dog = Dog("Fido", "Golden Retriever")
your_dog = Dog("Spot", "Dalmatian")

my_dog.bark()
your_dog.bark()

This code first creates two Dog objects, my_dog and your_dog, using the Dog class. Then, it calls the bark() method on each object. You’ll see the output:

Woof! My name is Fido
Woof! My name is Spot

4. Common Mistakes or Misunderstandings

Here are some common pitfalls beginners face when learning about classes:

Incorrect code:

def bark():
    print("Woof!")

Corrected code:

def bark(self):
    print("Woof!")

Explanation: For methods within a class, you always need to include self as the first parameter. self represents the instance of the class that the method is being called on.

Incorrect code:

my_dog = Dog() # No name or breed provided

Corrected code:

my_dog = Dog("Fido", "Golden Retriever")

Explanation: The __init__ method requires specific parameters (name and breed in our example). You need to provide those values when creating a new object.

Incorrect code:

print(my_dog.age) # Age wasn't defined in the class

Corrected code:

class Dog:
    def __init__(self, name, breed, age):
        self.name = name
        self.breed = breed
        self.age = age

my_dog = Dog("Fido", "Golden Retriever", 3)
print(my_dog.age)

Explanation: You can only access attributes that are defined within the class (either in the __init__ method or added later).

5. Real-World Use Case

Let’s imagine you’re building a simple game with different types of characters. You could use classes to represent each character type:

class Character:
    def __init__(self, name, health):
        self.name = name
        self.health = health

    def attack(self, other_character):
        print(self.name, "attacks", other_character.name)
        other_character.health -= 10

class Warrior(Character):
    def __init__(self, name):
        super().__init__(name, 100) # Call the parent class's constructor

class Mage(Character):
    def __init__(self, name):
        super().__init__(name, 70)

# Create some characters

warrior = Warrior("Arthur")
mage = Mage("Merlin")

warrior.attack(mage)
print(mage.health)

This example shows how classes can be used to create reusable components for a larger project. We have a base Character class and then specialized classes like Warrior and Mage that inherit from it.

6. Practice Ideas

Here are a few ideas to practice using classes:

1. Create a Rectangle class: It should have attributes for width and height and methods to calculate area and perimeter.
2. Build a BankAccount class: Include attributes for account number and balance, and methods for deposit, withdraw, and check balance.
3. Design a Car class: Attributes could include make, model, and year. Methods could include start, stop, and accelerate.
4. Implement a Student class: Attributes: name, student ID, courses. Methods: add_course, remove_course, display_courses.
5. Create a simple Animal class: Attributes: name, species. Methods: make_sound. Then create subclasses like Dog and Cat that override the make_sound method.

7. Summary

Congratulations! You’ve taken your first steps into the world of classes. You’ve learned what classes are, how to define them, how to create objects from them, and how to use methods. Remember, classes are blueprints for creating objects, and they’re a powerful tool for organizing and structuring your code.

Don’t be discouraged if it doesn’t click immediately. Practice is key! Next, you might want to explore concepts like inheritance (as seen in the Warrior and Mage example), polymorphism, and encapsulation. Keep coding, keep learning, and have fun!

This content originally appeared on DEV Community and was authored by DevOps Fundamental