Java Fundamentals

Course Goals

By the end of this course, you will be able to:

• Design Object-Oriented applications using industry-standard patterns
• Read and create UML diagrams to communicate your designs
• Implement applications in Java with confidence
• Apply OOP principles: encapsulation, inheritance, polymorphism

Course Structure Overview

The Problem: Procedural Programming

Before OOP, programs were written as sequences of procedures (functions):

// Procedural approach - data and functions are separate
String[] employeeNames = {"Alice", "Bob", "Charlie"};
double[] employeeSalaries = {50000, 60000, 55000};
String[] employeeDepartments = {"IT", "HR", "IT"};

void giveRaise(int employeeIndex, double amount) {
    employeeSalaries[employeeIndex] += amount;
}

void transferDepartment(int employeeIndex, String newDept) {
    employeeDepartments[employeeIndex] = newDept;
}

// Problems:
// - Data is scattered across multiple arrays
// - Easy to mix up indices
// - Hard to add new employee attributes
// - No way to enforce rules (e.g., salary can't be negative)

Problems with Procedural Code

• Data and behavior are separated
  • Functions operate on data they don't "own"
• No encapsulation
  • Anyone can modify any data, leading to bugs
• Code duplication
  • Similar logic must be rewritten for different data types
• Hard to maintain
  • Changing data structure requires changes everywhere
• Doesn't scale
  • Large programs become unmanageable "spaghetti code"

The Solution: Object-Oriented Programming

OOP organizes code around objects that combine data and behavior:

// Object-Oriented approach - data and behavior together
class Employee {
    String name;
    double salary;
    String department;

    void giveRaise(double amount) {
        if (amount > 0) {  // Can enforce rules!
            this.salary += amount;
        }
    }

    void transferTo(String newDepartment) {
        this.department = newDepartment;
    }
}

// Usage is intuitive:
Employee alice = new Employee("Alice", 50000, "IT");
alice.giveRaise(5000);
alice.transferTo("Management");

Benefits of OOP

• Intuitive - Objects represent real-world things
  • A Car object has properties (color, speed) and behaviors (accelerate, brake)
• Encapsulation - Data is protected inside objects
  • Objects control how their data is accessed and modified
• Reusability - Create once, use many times
  • Define an Employee class, create thousands of employees
• Maintainability - Changes are localized
  • Modify the class in one place, all objects benefit
• Scalability - Manage complexity through hierarchy
  • Build complex systems from simple, well-defined components

What is an Object?

An object is a thing that has:

• Identity - What makes it unique (e.g., this specific car)
• State - Its current properties (color: red, speed: 60 km/h)
• Behavior - What it can do (accelerate, brake, turn)

Class vs Object: Blueprint vs Instance

classDiagram
    class Car {
        -String color
        -int speed
        +accelerate()
        +brake()
    }

    class myCar["myCar : Car"] {
        color = "red"
        speed = 60
    }

    class yourCar["yourCar : Car"] {
        color = "blue"
        speed = 0
    }

    class taxiCar["taxiCar : Car"] {
        color = "yellow"
        speed = 45
    }

    Car <|.. myCar : new
    Car <|.. yourCar : new
    Car <|.. taxiCar : new
                

Properties (Attributes/Fields)

Properties describe the state of an object - what it "has" or "is":

classDiagram
    class Dog {
        -String name
        -int age
        -String breed
        -String color
    }
            

Methods (Behaviors/Operations)

Methods define what an object can do - its behaviors:

classDiagram
    class Dog {
        -String name
        -int age
        -String breed
        +bark()
        +run()
        +eat(food)
        +sleep()
    }
            

The Four Pillars of OOP

Communicating Design: Why UML?

Before coding, we need to design and communicate our ideas:

• UML (Unified Modeling Language) is a standard visual language
• Allows developers to share designs without ambiguity
• Three essential diagram types:
  • Class Diagrams - Structure of classes and relationships
  • Activity Diagrams - Flow of operations/algorithms
  • Use Case Diagrams - User interactions with the system

UML Class Diagram Basics

A class is represented as a box with three sections:

Relationships Between Classes

Objects don't exist in isolation - they interact and relate to each other:

Association and Cardinality

An association shows that two classes are connected:

classDiagram
    class Person {
        -String name
        -String address
    }
    class Account {
        -String accountNumber
        -double balance
    }
    Person "1..2" -- "0..*" Account : owns
            

Aggregation: "HAS-A" (Weak)

Aggregation means one class contains references to others, but they can exist independently:

classDiagram
    class Email {
        -String subject
        -String body
        -Date sentDate
    }
    class File {
        -String filename
        -int size
    }
    Email "1" o-- "0..*" File : attachments
            

Composition: "HAS-A" (Strong)

Composition means strong ownership - the parts cannot exist without the whole:

classDiagram
    class House {
        -String address
        -int floors
    }
    class Room {
        -String name
        -double area
    }
    House "1" *-- "1..*" Room : contains
            

Inheritance: "IS-A"

Inheritance creates a hierarchy where specialized classes inherit from general ones:

classDiagram
    class Mammal {
        -boolean warmBlooded
        +breathe()
        +nurse()
    }
    class QuadrupedMammal {
        -int legCount
        +walk()
    }
    class Wolf {
        -String packName
        +howl()
        +hunt()
    }
    class Dog {
        -String breed
        +bark()
        +fetch()
    }
    Mammal <|-- QuadrupedMammal
    QuadrupedMammal <|-- Wolf
    QuadrupedMammal <|-- Dog
            

Another Inheritance Example: Animal Kingdom

classDiagram
    Animal <|-- Duck
    Animal <|-- Fish
    Animal <|-- Zebra
    Animal : +int age
    Animal : +String gender
    Animal: +isMammal()
    Animal: +mate()
    class Duck{
      +String beakColor
      +swim()
      +quack()
    }
    class Fish{
      -int sizeInFeet
      -canEat()
    }
    class Zebra{
      +bool is_wild
      +run()
    }
        

Specialization vs Generalization

• Generalization (bottom → top): Finding common traits
  • "What do Wolf and Dog have in common? They're both QuadrupedMammals!"
• Specialization (top → bottom): Adding specific traits
  • "A Wolf is a special kind of Mammal that hunts in packs"

When you specialize, the child class:

• Inherits all properties and methods from the parent
• Adds its own specific properties and methods
• Can override inherited methods with specialized behavior

Exercise 1: Identify Objects in a System

Consider a Library Management System:

Questions:

1. What are the main objects (classes) in this system?
2. What properties would each class have?
3. What methods (behaviors) would each class have?
4. What relationships exist between the classes?

Exercise 1: Solution Discussion

Relationships:

• Member borrows Book (association, 0..*)
• Loan links Member and Book (association)
• Library has Books (composition - books belong to library)

Exercise 2: Bank System Class Diagram

Design a class diagram for a banking system:

• A bank has customers (identified by name and address)
• Customers have accounts with a balance
• Two types of accounts:
  • SavingsAccount - has an interest rate
  • InvestmentAccount - can buy stocks
• Stocks have a ticker, price, and quantity

Questions:

1. Draw the classes with their properties and methods
2. Identify the relationship types (association, aggregation, inheritance)
3. Add cardinality to each relationship

Exercise 2: Bank System Solution

classDiagram
    class Customer {
        -String name
        -String address
        +openAccount()
    }
    class Account {
        -String accountNumber
        -double balance
        +deposit(amount)
        +withdraw(amount)
    }
    class SavingsAccount {
        -double interestRate
        +calculateInterest()
    }
    class InvestmentAccount {
        +buyStock(stock, qty)
        +sellStock(stock, qty)
    }
    class Stock {
        -String ticker
        -double price
        -int quantity
    }
    Customer "1" -- "0..*" Account
    Account <|-- SavingsAccount
    Account <|-- InvestmentAccount
    InvestmentAccount "1" o-- "0..*" Stock
            

Exercise 3: Model Everyday Objects

For each object, identify properties and behaviors:

Key Takeaways

• OOP organizes code around objects that combine data (properties) and behavior (methods)
• Classes are blueprints, objects are instances created from those blueprints
• Four pillars: Encapsulation, Inheritance, Polymorphism, Abstraction
• UML helps communicate designs before writing code
• Key relationships:
  • Association - "uses" / "knows about"
  • Aggregation - "has" (weak ownership)
  • Composition - "owns" (strong ownership)
  • Inheritance - "is a" (specialization)

Next: UML Behavioral Diagrams - Use Case, Activity, and Sequence diagrams to model system behavior.