Static关键字

一：static 的代码都是在类加载或者加载某一方法之前就加载了，而且只需要加载一次，现在证明 “加载某一方法之前就加载”？
说明： Collections.synchronizedList 为静态的，以它为例：

List<String> list = Collections.synchronizedList(new ArrayList<String>());
    System.out.println("list null  "+System.currentTimeMillis());
     //{548d0tq5nsnz5xqibda45dgo,izy6xvkt4tak3z7aarfj2a94}
     synchronized (this) {
         //从1这行代码执行完 到 2这行代码开始执行 是不需要花费时间的，在时间显示上可以看出！！！
       //  1：  list.add("548d0tq5nsnz5xqibda45dgo");
       //  2：  System.out.println("548  "+System.currentTimeMillis());
         list.add("izy6xvkt4tak3z7aarfj2a94");
         StringBuilder sb = new StringBuilder(list.size());
         sb.append("select u.* from epai_sys_dm.epai_sys_role u where 1=1");
         for (int i = 0; i < list.size(); i++) {
             if (i == 0) {
                 sb.append(" and");
             }
             if (i > 0) {
                 sb.append(" or");
             }
             sb.append(" u.id='");
             sb.append(list.get(i));
             sb.append("'");
         }
         List<SysRole> sysRoles = jdbcTemplate.query(sb.toString(), new BeanPropertyRowMapper<SysRole>(SysRole.class));
         List<SysRole> sysRoles1 = sysRoles.subList(0, 1);
         System.out.println("sysRoles1  "+System.currentTimeMillis());
         return sysRoles1;
     }
 }

结果：

第一次线程
list null         1574048603125
548               1574048603125
sysRoles1         1574048603192


第二次线程
list null         1574048603283
548               1574048603283
sysRoles1         1574048603329

从list null 和 548 时间相等就可以说明了,因为static之前已经加载过了，所以不需要再加载，也就不需要浪费时间

二：在java中 static 关键字若是加在实体类属性前面就变为了公共属性！！
举例：
对一个属性若是在循环中且不加static 则得多次修改属性。若是加static 则只需要修改一次就行在循环中也能多次展示。
有图：http://note.youdao.com/noteshare?id=4355135e9ffdf54e248171a5ce21ce7f

三：代码块的用处
(1):普通代码块：
指直接在方法或语句中定义的代码块：
例子：

在这里插入代码片
    public  class CodeDemo01{
      public static void main(String[]args){
         {                           //定义一个普通代码块
             int x=30;
             system.out.println("普通代码块-->x="+x);
         }
         int x=100;
         System.out.println("代码块之外-->x="+x);
      }
} 
陈序执行结果：
  普通代码块--->x=30;
  代码块之外--->x=100;

总结： 本用了普通代码块对一个方法中的结构进行了分割，这样即使定义了**重名变量* 但是由于其出于不同的范围，也不会相互影响，所以普通代码块的主要作用是进行程序分割作用。

（2)静态代码块:
引自：https://blog.csdn.net/weixin_43836046/article/details/96869635?utm_source=app 讲的最好！
加static:

@RestController
@RequestMapping("/helloResult")
@ResponseResultBody
public class HelloResultController {

    private static final HashMap<String, Object> INFO;

    static {
        INFO = new HashMap<String, Object>();
        INFO.put("name", "galaxy");
        INFO.put("age", "70");
    }

    @GetMapping("hello")
    public HashMap<String, Object> hello() {
        return INFO;
    }

    /** 测试重复包裹 */
    @GetMapping("result")
    public Result<Map<String, Object>> helloResult() {
        return Result.success(INFO);
    }

    @GetMapping("helloError")
    public HashMap<String, Object> helloError() throws Exception {
        throw new Exception("helloError");
    }

    @GetMapping("helloMyError")
    public HashMap<String, Object> helloMyError() throws Exception {
        throw new ResultException();
    }
}

总结：静态代码块优先于主方法执行，而在类中定义的静态代码块会优先于构造块
(在类中的普通代码块)，而且不管有多少个对象产生，静态代码块只执行一次。