B3.1.2 Designing Classes, Their Methods, and Behaviour Notes

Understanding Classes and Their Components

1. Attributes:
   1. These are the instance variables that define the state of an object.
   2. For example, a Car class might have attributes like color, make, and model.
2. Methods:
   1. These define the behavior of the class.
   2. They are functions that operate on the instance variables.
   3. For example, a Car class might have methods like start(), stop(), and accelerate().

Designing Classes Based on Application Requirements

1. Identify the Real-World Entity: Determine what real-world object or concept you are modeling.
2. Define Attributes: List the characteristics that are essential to the entity.
3. Define Behaviors: Identify the actions the entity can perform or the operations that can be performed on it.

Constructing a Class in Code

1. Define the Class: Use the class keyword followed by the class name.
2. Declare Attributes: Initialize instance variables, often in a constructor method.
3. Define Methods: Implement functions that operate on the attributes.

class Student:
    def __init__(self, name, age):
        self.__name = name      # private attribute
        self.__age = age

    # Accessor (Getter)
    def get_name(self):
        return self.__name

    # Mutator (Setter)
    def set_name(self, name):
        self.__name = name

    # Another Accessor
    def get_age(self):
        return self.__age

    # Another Mutator (with validation)
    def set_age(self, age):
        if age > 0:   # simple validation
            self.__age = age

public class Student {
    // Private fields (encapsulation)
    private String name;
    private int age;

    // Constructor
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Accessor (Getter)
    public String getName() {
        return name;
    }

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

    // Another Accessor
    public int getAge() {
        return age;
    }

    // Another Mutator (with validation)
    public void setAge(int age) {
        if (age > 0) {  // simple validation
            this.age = age;
        }
    }
}

Modeling Class Relationships in UML

1. Aggregation: A "has-a" relationship where the classes can exist independently.
   1. Example: A Library has Books, but Books can exist without a Library.
2. Composition: A stronger "has-a" relationship where the classes cannot exist independently.
   1. Example: A House has Rooms, and Rooms cannot exist without a House.
3. Inheritance: A "is-a" relationship where a subclass inherits attributes and methods from a superclass.
   1. Example: A Car is a Vehicle.

Designing Classes for Real-World Applications

1. Understand the Context: Research the domain to identify relevant attributes and behaviors.
2. Use UML Diagrams: Visualize the class structure and relationships before coding.
3. Iterate and Refine: Continuously improve your design based on feedback and testing.