Class Member static

• Common to all instances of a class
• Useful to define procedures
• Useful to define (class-)global variables
• No access to instance members

Instance Member

• Each instance has own member

public class AccessModifiers {
  public int i = 1;
  public void printI() { System.out.println(i); }
  private int j = 2;
  private void printJ() { System.out.println(j); }

  public static void main(String[] args) {
    AccessModifiers oa = new AccessModifiers();
    System.out.println("oa.i = " + oa.i);
    oa.printI();
    System.out.println("oa.j = " + oa.j);
    oa.printJ();    
  }
}

• Why can main (left) access j?
• Why can main (below) not access j?

public class Outside {
  public static void main(String[] args) {
    AccessModifiers oa = new AccessModifiers();
    System.out.println("oa.i = " + oa.i);
    oa.printI();
    //System.out.println("oa.j = " + oa.j);
    //oa.printJ();
  }
}

• How to access private members?
  • Through public methods
  • Variables: getters and setters
• Benefits
  • Controlled access
  • Increased data correctness
  • Read-only, write-only

public class GetterSetter {
  private int i;
  public int getI() { return i; }
  public void setI(int i) { 
    // check contract before changing value
    this.i = i; 
  }
}

public class Outside {
  public static void main(String[] args) {
    GetterSetter oa = new GetterSetter();
    oa.setI(5);
    System.out.println("oa.getI() = " + oa.getI());
  }
}

• Initialization alternative to constructors
  • static: initialize class variables
  • non-static: initialize instance variables
• Executed before constructors
• Executed in the order of appearance in the class
• Useful for accessing resources during initialization (file, database, ...)

public class Initializer {
  private static int s;
  int a, b, c;
  static {
    System.out.println("Initializing s");
    s = 0;
  }
  {
    System.out.println("Initializing a");
    a = 1;
  }
  {
    System.out.println("Initializing b");
    b = 2;
  }
  public Initializer() {
    System.out.println("Constructor sets c");
    c = 3;
  }

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

• Class declared in the body of other class
• Inner class has access to outer class
• Improved encapsulation
• Logical grouping
• Accessible inner classes can be instantiated also from outside

public class Outer {
  private int i = 1;
  
  // nested class
  private class Inner {
    private int j = 2;
    public void print() { 
      System.out.println("i = " + ", j = " + j);
    }
  }

  public void print() {
    Inner ob = new Inner();
    ob.print();
  }

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

• Alternative to construction from scratch
• Copy constructor, cloning, serialization and deserialization
• Java does not support default copy constructors
  • Implement own copy constructor (recommended)
  • Implement Cloneable (not recommended, Josh Bloch)

public class Copyable {
  private int i;
  public Copyable(int i) { this.i = i; }
  
  // explicit copy constructor
  public Copyable(Copyable other) {
    this.i = other.i;
  }
  
  public void print() {
    System.out.println("i = " + i);
  }

  public static void main(String[] args) {
    Copyable oa = new Copyable(5);
    Copyable ob = new Copyable(oa);
    ob.print();
  }
}