format code with google plugin

Author: yennanliu

src/main/java/Advances/Annotation/MyAnnotation.java

@@ -4,5 +4,5 @@
 
 public @interface MyAnnotation {
 
-    String value() default "hello";
+  String value() default "hello";
 }

src/main/java/Advances/Annotation/MyAnnotation2.java

@@ -7,5 +7,5 @@
 
 @Retention(RetentionPolicy.RUNTIME)
 public @interface MyAnnotation2 {
-    String value() default "123";
+  String value() default "123";
 }

src/main/java/Advances/Annotation/MyAnnotation3.java

@@ -10,5 +10,5 @@
 @Target({ElementType.TYPE, ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
 public @interface MyAnnotation3 {
 
-    String value() default "hello";
+  String value() default "hello";
 }

src/main/java/Advances/Annotation/MyAnnotations.java

@@ -5,13 +5,9 @@
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Target;
 
-/**
- *  an array of Annotation for using multiple Annotations at once
- *
- */
-
+/** an array of Annotation for using multiple Annotations at once */
 @Target({ElementType.TYPE})
 public @interface MyAnnotations {
 
-    MyAnnotation3[] value();
+  MyAnnotation3[] value();
 }

src/main/java/Advances/Annotation/demo1.java

@@ -6,93 +6,78 @@
 // https://www.youtube.com/watch?v=hKzyUbQaorM&list=PLmOn9nNkQxJH0qBIrtV6otI0Ep4o2q67A&index=509
 
 /**
- *  Annotation demo 1
+ * Annotation demo 1
  *
- *  1) Annotation is a feature in JDK >= 5.0
+ * <p>1) Annotation is a feature in JDK >= 5.0
  *
- *  2) Annotation is a special `sign` of the code, these sign
- *     can be compiled, overloaded, and read during runtime.
- *     Developers can "insert" extra information to the code
- *     without any code change via Annotation
+ * <p>2) Annotation is a special `sign` of the code, these sign can be compiled, overloaded, and
+ * read during runtime. Developers can "insert" extra information to the code without any code
+ * change via Annotation
  *
- *  3) Annotation can be used  as `modifier` (e.g. public, private, static...);
- *     can be used in package, class, constructor, method, variables, parameters...
- *     (these information are stored in name=value)
+ * <p>3) Annotation can be used as `modifier` (e.g. public, private, static...); can be used in
+ * package, class, constructor, method, variables, parameters... (these information are stored in
+ * name=value)
  *
- *  4) use cases
- *     - auto documentation
- *     - check during compile ( @Override, @Deprecated, @SuppressWarnings)
- *     - track code dependency, replace some config functionalities
+ * <p>4) use cases - auto documentation - check during compile
+ * ( @Override, @Deprecated, @SuppressWarnings) - track code dependency, replace some config
+ * functionalities
  *
- *  5) how to make user-defined-Annotation
- *      - refer @SuppressWarnings
- *      - step 1) init with `public @interface`
- *      - step 2) define internal component, usually use `value` (e.g. String value();)
- *          - we can aldo give default value to it (e.g. String value() default "hello";)
- *      - step 3) if there is no arg in user-defined-Annotation, then it's just a "mark" purpose Annotation
+ * <p>5) how to make user-defined-Annotation - refer @SuppressWarnings - step 1) init with
+ * `public @interface` - step 2) define internal component, usually use `value` (e.g. String
+ * value();) - we can aldo give default value to it (e.g. String value() default "hello";) - step 3)
+ * if there is no arg in user-defined-Annotation, then it's just a "mark" purpose Annotation
  *
- *  6) JDK meta-Annotation : Annotation's Annotation
- *      - Retention : define life cycle of the Annotation
- *      - Target
- *      - Documented
- *      - Inherited
+ * <p>6) JDK meta-Annotation : Annotation's Annotation - Retention : define life cycle of the
+ * Annotation - Target - Documented - Inherited
  *
- *  7) Annotation new features since JDK 8
+ * <p>7) Annotation new features since JDK 8
  *
- *      - repeatable annotation
- *          - step 1) add @Repeatable on MyAnnotation3
- *          - step 2) use MyAnnotation3 in MyAnnotations
+ * <p>- repeatable annotation - step 1) add @Repeatable on MyAnnotation3 - step 2) use MyAnnotation3
+ * in MyAnnotations
  *
- *      - Element type annotation
- *          - ElementType.TYPE_PARAMETER
- *          - ElementType.TYPE_USE
- *          - example : https://github.com/yennanliu/JavaHelloWorld/blob/main/src/main/java/Advances/Annotation/demo2.java
+ * <p>- Element type annotation - ElementType.TYPE_PARAMETER - ElementType.TYPE_USE - example :
+ * https://github.com/yennanliu/JavaHelloWorld/blob/main/src/main/java/Advances/Annotation/demo2.java
  *
- *  8) Annotation used A LOT in framework.
- *      e.g. spring MVC, android dev ...
+ * <p>8) Annotation used A LOT in framework. e.g. spring MVC, android dev ...
  */
-
 public class demo1 {
-    public static void main(String[] args) {
-
-    }
+  public static void main(String[] args) {}
 }
 
 /** demo 1 : basic annotation usage */
-//@MyAnnotation(value="hello")  // if not default value in MyAnnotation, then we need give in a value
+// @MyAnnotation(value="hello")  // if not default value in MyAnnotation, then we need give in a
+// value
 @MyAnnotation // if there's default value in MyAnnotation
-class Person{
-    // attr
-    private String name;
-    private int age;
+class Person {
+  // attr
+  private String name;
+  private int age;
 
-    // constructor
-    @MyAnnotation
-    public Person(){
+  // constructor
+  @MyAnnotation
+  public Person() {}
 
-    }
-
-    // method
-    @MyAnnotation
-    public void myPrint(String x){
-        System.out.println(x);
-    }
+  // method
+  @MyAnnotation
+  public void myPrint(String x) {
+    System.out.println(x);
+  }
 }
 
 /** demo 2 : use multiple annotations via array */
-@MyAnnotations({@MyAnnotation3, @MyAnnotation3(value="456")}) // before JDK 8
-class Person2{
-    // attr
-    private String name;
-    private int age;
+@MyAnnotations({@MyAnnotation3, @MyAnnotation3(value = "456")}) // before JDK 8
+class Person2 {
+  // attr
+  private String name;
+  private int age;
 }
 
 /** demo 3 : use multiple annotations via repeatable annotations */
 // after JDK 8
 @MyAnnotation3()
-@MyAnnotation3(value="lol")
-class Person3{
-    // attr
-    private String name;
-    private int age;
-}
+@MyAnnotation3(value = "lol")
+class Person3 {
+  // attr
+  private String name;
+  private int age;
+}

src/main/java/Advances/Annotation/demo2.java

@@ -4,21 +4,20 @@
 
 import java.util.ArrayList;
 
-public class demo2 {
-}
-
+public class demo2 {}
 
 // T is generic type
-// we can decorate the generic type with user-defined-annotation (@MyAnnotation3) via `ElementType.TYPE_USE` in @Target({ElementType.TYPE, ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
-class Generic<@MyAnnotation3 T>{
-    // attr
+// we can decorate the generic type with user-defined-annotation (@MyAnnotation3) via
+// `ElementType.TYPE_USE` in @Target({ElementType.TYPE, ElementType.TYPE_PARAMETER,
+// ElementType.TYPE_USE})
+class Generic<@MyAnnotation3 T> {
+  // attr
 
-    // method
-    public void show() throws @MyAnnotation3 RuntimeException{
+  // method
+  public void show() throws @MyAnnotation3 RuntimeException {
 
-        ArrayList<@MyAnnotation3  String> list = new ArrayList<> ();
+    ArrayList<@MyAnnotation3 String> list = new ArrayList<>();
 
-        int num = (@MyAnnotation3  int) 10L;
-    }
-
-}
+    int num = (@MyAnnotation3 int) 10L;
+  }
+}

src/main/java/Advances/Annotation/test1.java

@@ -7,23 +7,23 @@
 import org.junit.jupiter.api.Test;
 
 public class test1 {
-    private static Object[] array;
-    private static int total;
+  private static Object[] array;
+  private static int total;
 
-    @BeforeAll
-    public static void beforeAll(){
-        System.out.println("BeforeAll ...");
-    }
+  @BeforeAll
+  public static void beforeAll() {
+    System.out.println("BeforeAll ...");
+  }
 
-    @Test
-    public void myTest1(){
-        System.out.println("myTest1 ...");
-        int int1 = 10;
-        assert (int1==10);
-    }
+  @AfterAll
+  public static void afterAll() {
+    System.out.println("AfterAll ...");
+  }
 
-    @AfterAll
-    public static void afterAll(){
-        System.out.println("AfterAll ...");
-    }
+  @Test
+  public void myTest1() {
+    System.out.println("myTest1 ...");
+    int int1 = 10;
+    assert (int1 == 10);
+  }
 }

src/main/java/Advances/BigIntegerBigDecimalDemo1.java

@@ -6,13 +6,13 @@
 import java.math.BigInteger;
 
 public class BigIntegerBigDecimalDemo1 {
-    public static void main(String[] args) {
-        BigInteger b1 = new BigInteger("342334234543543534534");
-        BigDecimal bd1 = new BigDecimal("1223423.34534");
-        BigDecimal bd2 = new BigDecimal("77");
+  public static void main(String[] args) {
+    BigInteger b1 = new BigInteger("342334234543543534534");
+    BigDecimal bd1 = new BigDecimal("1223423.34534");
+    BigDecimal bd2 = new BigDecimal("77");
 
-        System.out.println(b1);
-        System.out.println(bd1.divide(bd2, BigDecimal.ROUND_HALF_UP));
-        System.out.println(bd1.divide(bd2, 15, BigDecimal.ROUND_HALF_UP));
-    }
+    System.out.println(b1);
+    System.out.println(bd1.divide(bd2, BigDecimal.ROUND_HALF_UP));
+    System.out.println(bd1.divide(bd2, 15, BigDecimal.ROUND_HALF_UP));
+  }
 }

src/main/java/Advances/CalendarApi/demo1.java

@@ -8,9 +8,9 @@
  *  Calendar class use class intro
  */
 
-import org.junit.jupiter.api.Test;
 import java.util.Calendar;
 import java.util.Date;
+import org.junit.jupiter.api.Test;
 
 /**
  *   1) Calendar is an abstract class