public class ConstructTest {
      private static final Logger LOG = LoggerFactory.getLogger(ConstructTest.class);
      @Test
      public void processConst(){
          LOG.info(">>> start");
          Person person = new Person();
          LOG.info(">>> end");
      }
  }

  class Person{
      private static final Logger logger = LoggerFactory.getLogger(Person.class);
      private String name;
      private Integer age;

      public Person() {
          logger.info("default Constructor");
      }

      public String getName() {
          return name;
      }

      public void setName(String name) {
          this.name = name;
      }

      public Integer getAge() {
          return age;
      }

      public void setAge(Integer age) {
          this.age = age;
      }
  }

const 与 static final

• go
  go的静态(也可叫静态常量，主要用于基本数据类型)，使用关键字const指定。
  使用const定义的静态变量是不可用修改或赋值的。

    const name int = 11
  
    const (
        a = "hello"
        b = true
        c = 99
    )
  
    func main() {
        fmt.Println(name)
        fmt.Println(a)
        fmt.Println(b)
        fmt.Println(c)
    }
  

• java
  java的常量需要用两个关键字修饰 static 和 final ,前者表示静态的意思，但这个静态是可以被修改的，
  修改的前提是类型不变，而第二个关键字表示最终的意思，一旦变量被这个关键字修饰则不可重新修改变量。
  但是对于复合对象，比如List、Map、自定义对象等，又是可以被修改的,对于这点个人觉得 java 的常量的定义
  并不够严谨。

  public class staticFinalTest {
      private static final Logger LOG = LoggerFactory.getLogger(staticFinalTest.class);
      private static final String name = "Tom";
  
      private static String item = "first item";
  
      private static final List<String> initArr = new ArrayList<String>(){{
          add("A");
          add("B");
          add("C");
      }};
  
      @Test
      public void process(){
          LOG.info(name);
  
          item = "youth!";
  
          LOG.info(item);
  
          initArr.add("hello");
  
          LOG.info(initArr.toString());
      }
  }
  

参数或方法访问属性

• go
  go 的方法或参数需要被外部访问，需要使用大写开头参数名或函数名(go文件大小写是与与否与是否私有无关)

    // 可被文件外函数访问
    var Name string = "John"
  
    func main() {
        fmt.Println(Name)
        Process()
    }
  
    // 可被文件外函数调用
    func Process() {
        fmt.Println("Process()")
    }
  

• java
  java的参数或方法属性不同于go，大致分为三类：

  • private 仅当前类内访问
  • public 可公共访问
  • protect 仅可同包内访问

    public class ObjectTypeTest {
        private static final Logger LOG = LoggerFactory.getLogger(ObjectTypeTest.class);
  
        //私有访问（仅可同一类中）
        private String name1 = "name01";
        // 保护访问（仅可同一包内）
        protected String name2 = "name01";
        // 公共访问 (任何类均可访问)
        public String name3 = "name01";
  
        @Test
        public void process(){
            LOG.info(this.doSomeThing());
            LOG.info(name1);
            LOG.info(name2);
            LOG.info(name3);
  
        }
  
        public String doSomeThing(){
            return "hello";
        }
  
    }