[Java] Object-oriented syntax-Constructor

constructor

• Method called at the timing of instantiation (object creation) with ** new operator when using class **
• Used to describe field initialization and preparation of external resources used in the class
• ** Access modifiers available ** * public, protected, private
• ** No return value **
• The return value is not void and ** the type itself cannot be described **
• The return command cannot be used either
• ** Cannot be named freely **
• Make the name the same as the class name
• Set the argument to the corresponding field in the constructor
• Arguments and fields have the same name
• this. field name = argument;
• If there are both field initializer and constructor, constructor initialization has priority

//Argument name in the constructor/Set age to the corresponding field
public class Person {
  public String name;
  public int age;

  //constructor
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }

  public String show() {
    return String.format("%s（%d).", this.name, this.age);
  }
}

ConstBasic.java

public class ConstBasic {
  public static void main(String[] args) {
    var p = new Person("Yamada Taro", 30);
    System.out.println(p.show()); //I'm Taro Yamada (30 years old).
  }
}

Default constructor

• An empty constructor with no arguments that is implicitly generated when the definition is omitted **
• The following is the same
• Note that an error will occur when adding a constructor with arguments.

public class MyClass{
}

public class MyClass{
    public MyClass(){
    }
}

Overload

• Constructor can have multiple signatures *　StringBuilder()
• StringBuilder (String str): Generate StringBuilder object with a character string
• StringBuilder (int capacity): Generate StringBuilder object with character string and capacity
• Use this to call an overload with matching arguments
• ** This call is at the beginning of the constructor! ** **

Person.java

public class Person {
  public String name;
  public int age;

  //constructor
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }

  public Person() {
    //Constructor call
    this("Hello Kitty", 46);
  }

  public void show() {
    System.out.printf("%s（%d).\n", this.name, this.age);
  }
}

ConstructorBasic.java

public class ConstructorBasic {

  public static void main(String[] args) {
    var p = new Person();
    p.show(); //Hello Kitty (46 years old).
  }
}

Initialization block

• ** Anonymous block directly under class {...} **
• ** Execute before constructor when instantiating **
• ** Cut out code common to multiple constructors ** Role
• First, give priority to the constructor
• Overload that represents the default value of initialization is not the initialization block but this call priority

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Period;

public class Person {
  public String name;
  public int age;
  public LocalDateTime updated;

  //Initialization block
  {
    this.updated = LocalDateTime.now();
  }
  //First and last name,Initialize from birthday
  public Person(String firstName, String lastName, LocalDate birth) {
    this.name = lastName + " " + firstName;
    this.age = Period.between(birth, LocalDate.now()).getYears();
  }
  //name,Initialize from age
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
}

Factory method

• ** Method for instantiation **
• Only instantiate and return with return value
• Make the constructor private so that it can only be instantiated via factory methods
• var fc = FactoryClass.getInstance();
• merit
• ** Freely named **
• cf: Constructor not allowed
• ** You don't have to create an instance **
• Reusable cached instances (such as the singleton pattern)
• ** Return type can be abstract / interface type **
• Since it is a method, the return value can return any derived / implementation class.
• Dependence on implementation class can be limited to factory class only

public class FactoryClass {
  //private constructor
  private FactoryClass() {
    System.out.println("Factory!!");
  }
  //Factory method
  public static FactoryClass getInstance() {
    return new FactoryClass();
  }
}