CopyAndPaste

random programming notes

Java Object Creation

Work in progress

Notes from reading “Effective Java”

Static factory method

  • advantages
    • with names
    • not required to create new object when invoked
    • can return object of any subtype of its return type
  • disadvantages
    • classes without public or protected constructors cannot be subclassed
1
2
3
4
5
6
7
8
9

public class Foo {
  private Foo() {}
  public static Foo getInstance() {
      //...
  }
  public static Foo valueOf(bool value) {
      //... 
  }
}

Builder

Used when there are many constructor parameters

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

public class Foo {
  private final int required1;
  private final int required2;
  private final int optional1;
  private final int optional2;
  
  public static class Builder {
      // required 
      private final int required1;
      private final int required2;
      // optional 
      private final int optional1;
      private final int optional2;
      
      public Builder(int required1, int required2) {
          this.required1 = required1;
          this.required2 = required2;
      }
      
      public Builder required1(int val) {
          required1 = val;
          return this;
      }
      public Builder required2(int val) {
          required2 = val;
          return this;
      }
      public Builder optional1(int val) {
          optiona1 = val;
          return this;
      }
      public Builder optional2(int val) {
          optiona2 = val;
          return this;
      }
      
      public Foo build() {
          return new Foo(this);
      }
  }
  
  private Foo(Builder builder) {
      required1 = builder.required1
      required2 = builder.required2
      optional1 = builder.optional1
      optional2 = builder.optional2
  }
}

// usage example 
Foo fooInstance = new Foo.Builder(10, 10).optional1(100).optional2(200).build();

// build should throw IllegalStateException if parameters violate rules 

// method that uses Builder 
// assume Builder is defined as: 

public interface Builder<T> {
  public T build();
}

Tree nodeMethod(Builder<? extends Node> nodeBuilder) {
  //...
}

advantages:

  • no long, unnamed list of parameters
  • can fill up optional values

  • disadvantages:

  • speed