Crash Course — Unit 3: Class Creation

• Class — The blueprint or template for an object (e.g., the Car class defines what all cars have).
• Object — A specific, concrete instance of a class, created from the blueprint (e.g., your family's specific Toyota Camry).
• Abstraction — Hiding the complex inner workings of a class and providing a simple public interface. Think of it like driving a car; you only need to know the steering wheel and pedals, not the engine's combustion cycle.
• Instance Variables (private) — The data or attributes that belong to a single object, defining its state (e.g., a Car object's color or currentSpeed). They are almost always private to protect the data.
• Methods (public) — The behaviors or actions an object can perform (e.g., a Car object's startEngine() or accelerate() methods). They are usually public.
• Constructor — A special method that "constructs" a new object, initializing its instance variables. It has the same name as the class and no return type.
• Encapsulation — Bundling an object's data (instance variables) and methods together in a class, and protecting the data by making it private.
• static Variable — A single variable shared by all objects of a class. Think of it as a shared whiteboard for the entire class, like a counter for how many Car objects have been created.
• static Method — A method that belongs to the class itself, not a specific object. You call it using the class name (e.g., Math.random()).
• this Keyword — A reference an object uses to refer to itself, mainly to distinguish between instance variables and method parameters with the same name.
• Object Reference — A variable that stores the memory address of an object, not the object itself. It's like having a friend's address on a piece of paper, not their entire house in your pocket.

Key Formulas / Terms

• Standard Class Structure: This is the pattern you'll use for almost every FRQ. Memorize it.

  public class ClassName {
      // 1. Private instance variables
      private type variableName;
      // ... more variables
  
      // 2. Constructor(s)
      public ClassName(type parameterName) {
          this.variableName = parameterName;
          // ... initialize other variables
      }
  
      // 3. Public methods (getters, setters, etc.)
      public returnType getVariableName() {
          return this.variableName;
      }
  
      public void setVariableName(type newName) {
          this.variableName = newName;
      }
  }

• The this Keyword Pattern: Use this inside a constructor or setter to avoid "shadowing," where a parameter hides an instance variable of the same name.

  // "this.make" is the instance variable.
  // "make" is the parameter coming into the method.
  this.make = make;

• Calling a static Method: You use the Class Name, not an object variable.

  // Correct:
  double result = Math.sqrt(25.0);
  
  // Incorrect (Math is a class, not an object you create):
  // Math myMath = new Math();
  // double result = myMath.sqrt(25.0);

Exam Traps

• Trap
  The Phantom Constructor. You write a constructor that takes parameters (e.g., public Student(String name)), but then try to create a Student object with new Student(). This will fail. · Counter: The moment you write any constructor, Java stops providing the free, no-argument default constructor. If you need both, you must write both explicitly.
• Trap
  The Copied Address. Believing that Car car2 = car1; creates a new, independent copy of the car1 object. It does not. It creates a copy of the memory address. · Counter: Draw it out! You now have two variables (car1 and car2) pointing to the exact same object in memory. If you call car2.setColor("blue"), car1.getColor() will also return "blue".
• Trap
  Forgetting this. Writing a constructor where the parameter and instance variable have the same name (e.g., String color) and just writing color = color;. · Counter: This line does nothing! You're just assigning the parameter's value to itself. The instance variable remains uninitialized (e.g., null). Always, always use the pattern this.color = color; to be safe.
• Trap
  static vs. Instance Confusion. Trying to access an instance variable (like studentName) from within a static method. · Counter: Remember, a static method belongs to the whole class, not one specific object. It has no idea which student's name you want. Think: static methods are like the school's PA system; they can't know what's in one student's private backpack (the instance variable).
• Trap
  Violating Privacy. Trying to access a private instance variable from a different class, like myCar.speed = 50;. · Counter: The compiler will stop you. private means "for this class's eyes only." To change or view that data from the outside, you must go through a public method, like myCar.setSpeed(50); or int s = myCar.getSpeed();. This is the core of encapsulation.