[Java] Object-oriented syntax --class method / argument

Class method / field

• Fields / methods that can be called directly from the class without instantiating **
• ** Also called static method / static method **
• ** Class members **
• Class methods
• Class field
• There is only one class member in the class, shared by all instances
• cf: ** Instance member **: Member to call via object
• Each has an independent value (actual condition)

Class method

• ** Just add static **
• Note
• ** This cannot be used in class methods **
• The instance itself has not been created
• Instance fields / methods cannot be referenced from class methods
• ** Class methods are not called via objects **

//Define class method getTriangleArea of Figure class
public class Figure {
  public static double getTriangleArea(double width, double height) {
    return width * height / 2;
  }
}

StaticBasic.java

public class StaticBasic {

  public static void main(String[] args) {
    System.out.println(Figure.getTriangleArea(10, 20));
//    var f = new Figure();
//    System.out.println(f.getTriangleArea(10, 20));
  }
}

Utility class

• A class that only has class members (Math class, etc.)
• Improve readability and make it easier to find features by grouping related features in one class method
• Math class bundles numerical processing
• ** Class instantiation can be prohibited by making the constructor private (cannot be called from the outside) **
• var m = new Math (); // error
• It is common to use the ** final modifier ** to explicitly prohibit class inheritance

public final class Math{
  private Math() {}
}

Class field

• Fields that can be called directly without going through an instance
• ** Just add static **
• Class fields can be accessed from class methods
• Because the class field belongs to the class
• Can be accessed from outside if the access authority is satisfied
• Note: Class fields ** affect all relevant instances if you change their contents **
• In other languages ** Global variables **: Variables that are valid throughout the program
• ** Dependencies between classes become stronger **, so use under the following conditions in principle
• Read-only
• Condition monitoring of the class itself
• ** ex: Singleton pattern ** (see below)

Figure.java

//Pi field, getCircleArea method definition in the class member of Figure class

public class Figure {
  public static double pi = 3.14;

  //Access class fields from class methods
  public static void getCircleArea(double r) {
    System.out.println("The area of the circle is" +  r * r * pi);
  }
}

StaticBasic.java

public class StaticBasic {
  public static void main(String[] args) {
    //Figure can be accessed from the outside
    System.out.println(Figure.pi); //3.14
    Figure.getCircleArea(5); //The area of the circle is 78.5
  }
}

Singleton pattern

• A type of design pattern
• Used when ** you only want / do not want to create one instance of a class **
• ** Declare the constructor private **
• Should be kept in the app ** Save only instance in class field **
• ** Instance once only for the first time of class load **, cannot be instantiated after that
• Only use ** class method ** for instance acquisition ** (= factory method for instance acquisition)
• Defined as a class member because it belongs to the management / generation class of the instance itself

public class MySingleton {

  //Save only instance in class field
  private static MySingleton instance = new MySingleton();

  //Declare the constructor private
  private MySingleton() {}
  //Instance acquisition prepared by class method
  public static MySingleton getInstance() {
    return instance;
  }
}

Class constant

• ** Constants defined directly under class {...}, read-only fields **
• ** Just add the final modifier **
• cf: constant class
• A class that combines constants used in the entire application into one class for ease of access (basically defined in the related class first)

public class MyApp {
  public static final String BOOK_TITLE = "Java master!";
}

public class ConstantBasic {
  public static void main(String[] args) {
    System.out.println(MyApp.BOOK_TITLE); //Java master!
    //Cannot be assigned to final field
    //MyApp.BOOK_TITLE = "I will be a Java master!"; //error
  }
}

static initialization block

• ** Execute when class is initialized **
• cf: Initialization block executed at instantiation
• Static Initializer
• ** Static qualifier at the beginning of the block **
• Used to initialize class members
• Constants are copied to the referencing class at compile time
• If you modify the value, the constant reference class also needs to be recompiled
• The size of the referencing class becomes a little larger
• → By initializing with the static initialization block, only ** constant values can be copied, so this is solved! ** **

public class Initializer {
  public static final String DOG;
  public static final String CAT;
  public static final String MOUSE;

  static {
    DOG = "inu";
    CAT = "neko";
    MOUSE  = "nezumi";
  }
}

Initialization execution order

** (1) Class initialization only once **

• Set default value in class field
• Class field initialization
• Static initialization block execution

** (2) Executed every time an object is created **

• Set default value in instance field
• Initialize instance field
• Initialization block execution
• Constructor execution

//Bad example
//Initialization block takes precedence over field initializer
public class Order {
  //Field initializer
  String value = "First!";
  //constructor
  public Order() {
    System.out.println(value); //Second!!
  }
  //Initialization block runs before construct
  {
    value = "Second!!";
  }
}

public class OrderBasic {

  public static void main(String[] args) {
    var o = new Order();
  }
}

Variadic method

• ** Just add ... to the argument **
• The received value is regarded as an array

public class ArgsParams {
  //As an argument...Receive variadic arguments with
  public int totalProducts(int... values) {
  // public int totalProducts(int[] values) {
    var result = 1;
    //Argument values received by extended for and applied to result
    for (var value : values) {
      result *= value;
    }
    return result;
  }
}

public class ArgsParamsBasic {

  public static void main(String[] args) {
    var v = new ArgsParams();
    System.out.println(v.totalProducts(12, 15, -1));
    System.out.println(v.totalProducts(5, 7, 8, 2, 4, 3));

    // System.out.println(v.totalProducts(new int[] {12, 15, -1}));
  }
}

• Note
• ** One method can be specified only at the end of the argument list **
• NG example * public void hoge(int... x, int y) * public void hoge(int... x, int... y)
• ** Do not combine expected arguments into variadic arguments **
• Basically normal arguments, variable length collects only the information whose number cannot be specified at the time of method definition
• ** Variadic arguments can represent one or more arguments **
• Variadic argument is an argument that requires 0 or more values
• Variadic argument can be omitted
• In case of v.totalProducts (), an array of size 0 is passed as an argument
• When requesting at least one argument The following code

//The first argument is the normal initial
//Declare the second and subsequent arguments with variable length
//Compile error with no arguments
public class ArgsParamsGood {
  public int totalProducts(int initial, int... values) {
    var result = initial;
    for (var value : values) {
      result *= value;
    }
    return result;
  }
}

public class ArgsParamsGoodClient {
  public static void main(String[] args) {
    var v = new ArgsParamsGood();
    System.out.println(v.totalProducts()); //no arguments
  }
}

Arguments and data types

• The range of influence on the value passed in the basic type and the reference type is different.

• Basic type

public class ParamPrimitive {
  public int update(int num) { //Formal argument num
    //Manipulating formal parameters
    num *= 10;
    return num;
  }
}

public class ParamPrimitiveBasic {
  public static void main(String[] args) {
    //Variable num
    var num = 2;
    var p = new ParamPrimitive();
    System.out.println(p.update(num)); //20
    //Does not affect the original variable num
    System.out.println(num); //2
  }
}

• Reference type
• ** Store memory location instead of value **

public class ParamRef {
  //Copy the reference address of the variable data to the formal argument data
  public int[] update(int[] data) { //Formal argument data
    //Manipulation of formal argument data
    data[0] = 5;
    return data;
  }
}

public class ParamRefBasic {

  public static void main(String[] args) {
    //Actual argument data
    var data = new int[] { 2, 4, 6 };
    var p = new ParamRef();
    //The same value as the actual argument and formal argument will be referenced in the method call.
    System.out.println(p.update(data)[0]); //5
    //Manipulating the formal argument data affects the original variable
    System.out.println(data[0]); //5
  }
}

• Even if it is a reference type ** If you replace the reference destination itself, it will not affect the original variable **
• ex: When replacing the array itself

public class ParamRefArray {
  //Actual argument and formal argument point to the same at the time of method call
  public int[] update(int[] data) {
    //When a new array is assigned, the reference address itself changes.
    data = new int[] { 10, 20, 30 };
    return data;
  }
}

public class ParamRefArrayBasic {
  public static void main(String[] args) {
    var data = new int[] { 2, 4, 6 };
    var p = new ParamRefArray();
    System.out.println(p.update(data)[0]); //10
    System.out.println(data[0]); //2
  }
}

Null measures

import java.util.Map;

public class BookMap {
  //ISBN code: Manage book information by title
  private Map<String, String> data;
  //Initialize book information with argument map
  public BookMap(Map<String, String> map) {
    this.data = map;
  }
  //Obtain the title using the ISBN code (argument isbn) as a key
  public String getTitleByIsbn(String isbn) {
    //Returns null if the specified key does not exist
    return this.data.get(isbn);
  }
}

Main.java

import java.util.Map;
public class Main {
  public static void main(String[] args) {
    var b = new BookMap(Map.of(
        "978-4-7981-5757-3", "philosopher's Stone",
        "978-4-7981-5202-8", "room of Secrets",
        "978-4-7981-5382-7", "Azkaban prisoner"
        ));

    var title = b.getTitleByIsbn("978-4-7981-5757-3");
    if (title == null) {
      System.out.println("Disapparition!(Not)");
    } else {
      System.out.println(title.trim()); //philosopher's Stone
    }
  }
}

Simplify the above code with the Optional class!

• Wrapping possible null values with Optinal
• ** Optional.ofNullable method **
• Generate ʻOptional ` (a value of type String that may be null) based on the given value!
• A String value that may be null
• ** optTitle.orElse method ** returns the value if the Optional object has a non-null value, otherwise the argument value
• → ** null safety ** (forced null processing)

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;


public class BookMap {
  private Map<String, String> data = new HashMap<>();

  public BookMap(Map<String, String> map) {
    this.data = map;
  }

  public Optional<String> getTitleByIsbn(String isbn) {
    return Optional.ofNullable(this.data.get(isbn));
  }
}

import java.util.HashMap;

public class OptionalNullCheck {

  public static void main(String[] args) {
    var b = new BookMap(
      new HashMap<String, String>() {
        {
          put("978-4-7981-5757-3", "philosopher's Stone");
          put("978-4-7981-5202-8", "room of Secrets");
          put("978-4-7981-5382-7", "Azkaban prisoner");
        }
      });

    var optTitle = b.getTitleByIsbn("978-4-7981-5382-7");
    var title = optTitle.orElse("×");
    System.out.println(title.trim()); //Azkaban prisoner
  }
}

• Other Optional class members
• ʻIsPresent / ʻifPresent: null check
• ** ʻorElse / ʻorElseGet: Null check to get the value **

import java.util.Optional;

public class OptionalExample {

  public static void main(String[] args) {
    //Optional object creation
    var opt1 = Optional.of("Sample 1");
    //Null allowed
    var opt2 = Optional.ofNullable(null);
    var opt3 = Optional.empty();

    //Value existence confirmation
    System.out.println(opt1.isPresent()); //true
    //Run lambda expression if value exists
    opt1.ifPresent(value -> {
      System.out.println(value); //Sample 1
    });

    //If the value of opt2 exists, its value is displayed, and if it is null, the argument is displayed.
    System.out.println(opt2.orElse("null value")); //null value

    //Lambda expression execution if opt3 is null
    System.out.println(opt3.orElseGet(() -> {
      return "null value";
    })); //null value
  }
}