• Classes and objects
• Inheritance
• Encapsulation
• Access modifiers
• Getters and setters
• Generics

• Abstraction, interfaces, mixins
• Polymorphism
• Constructors, destructors
• Association, aggregation, composition
• Static classes, static methods
• Delegates
• Methods, attributes

Class

• Group of objects with common properties
• User-defined datatypes
• Specifies methods and attributes
• Code reusability, maintenance

Object

• Instance of a class
• Every object has 3 characteristics
  • Identity (memory address)
  • State (attributes)
  • Behavior (methods)

Class

• Logical entity
• How to create a class?
  

  public class Cat {
    private int weight;
    public Cat(int weight) { 
      this.weight = weight; 
    }
    public String sound() { 
      return "Meow"; 
    }
  }
  

Object

• Physical entity
• How to create an object?

  Cat c = new Cat(3);
  

  • Declaration: Cat c;
  • Instantiation: new Cat(...)
  • Initialization: new Cat(3)

Attributes

• State of an object
• Also called properties, fields, or instance variables
• Each object has own copy in memory

Methods

• Behavior of an object
• Return or update attributes
• Method parameters: pass data to object
• Method overloading: reuse method name with different parameters

• Constructor
  • Initializes a new object
  • Can be overloaded
  • No return type
  • Default constructor: non-parameterized
  • Parameterized constructor: takes arguments
• Destructor
  • Clean up object resources
  • Not in Java (automated garbage collection)

Example

class Date {
  private int day;
  private int month;
  private int year;
  public Date() { 
    // default constructor
    day = 0;
    month = 0;
    year = 0;
  }
  public Date(int d, int m, int y) {
    // parameterized constructor
    day = d;
    month = m;
    year = y;
  }
}

public class Example1 {
  // a public field with optional initialization
  public int i = 1;
  // example usage
  public static void main(String[] args) {
    System.out.println("Example 1");
    Example1 oa = new Example1();
    Example1 ob = new Example1();
    System.out.println("oa.i = " + oa.i);
    System.out.println("ob.i = " + ob.i);
    oa.i = 2;
    System.out.println("oa.i = " + oa.i);
    System.out.println("ob.i = " + ob.i);
  }
}

• When is the field i being initialized?
• What is the value of i if we omit initialization?
• Where is the constructor Example1()?
• Constructors do not have a return type. Is it void?
• Is it bad practice to have public fields?

public class Example2 {
  int i;
  // a parameterized constructor
  public Example2(int i) { this.i = i; }

  public static void main(String[] args) {
    Example2 oa = new Example2();
  }
}

• Does it compile? Why or why not?
• If it does not compile: how to fix the code?
• What is the meaning of this?

public class Example3 {
  int i;
  public Example3()      { this.i = 5; }
  public Example3(int i) { this.i = i; }

  public static void main(String[] args) {
    Example3 oa = new Example3();
    Example3 ob = new Example3(1);
  }
}

• Constructor overloading: how does Java distinguish between constructors?
• When can this be omitted?
• What is the difference between a local variable and an instance variable?

public class Example4 {
  public int sum(int... values) {
    int total = 0;
    for (int i : values) total = total + i;
    return total;
  }

  public static void main(String[] args) {
    Example4 oa = new Example4();
    System.out.println(oa.sum(1, 2));
    System.out.println(oa.sum(1, 2, 3, 4));
  }
}

• Variable argument lists with ...
• What is bad practice about the example?