自增变量：
package com.lvym; public class Test { public static void main(String[] args) { int i=1; i=i++; //先算等号右边：把i压入栈，i=1，i自增，局部变量i=2，再算等号左边：把栈值 1 赋给i，i=1. int j=i++;// 先算等号右边：把i压入栈，i=1，i自增，局部变量i=2，再算等号左边：把栈值 1 赋给j，j=1. int k=i+ ++i*i++;// 先算等号右边：把i压入栈，i=2,i自增,i=3压入栈，i自增，局部变量i=4，再把乘号右边i=3压入栈，栈中数据有 1 3 3，先算乘法3*3=9，还没有结束，所以再把9压入栈进行计算k=9+2=11 System.out.println(i);//4 System.out.println(j);//1 System.out.println(k);//11 } }
单例模式：
package com.lvym; /** * 饿汉式 * 直接创建实例对象，不管你是否需要，这个对象都会创建。 * 1.构造器私有化，保证一个类只能有一个实例 * 2.自行创建，并且用静态变量保存 * 3.向外暴露这个实例 * 4.强调这是一个单例，用final修饰 * */ public class SingletonDemo { public static final SingletonDemo INSTANCE=new SingletonDemo(); private SingletonDemo(){ System.out.println("SingletonDemo"); } } --------------------------------------- package com.lvym; public class test { public static void main(String[] args) { SingletonDemo singletonDemo=SingletonDemo.INSTANCE; System.out.println(singletonDemo); } } 结果： SingletonDemo com.lvym.SingletonDemo@1b6d3586
/** * 饿汉式 */ public enum SingletonDemo2 { INSTANCE } -------------------------- package com.lvym; public class test { public static void main(String[] args) { SingletonDemo2 singletonDemo=SingletonDemo2.INSTANCE; System.out.println(singletonDemo); } } 结果： INSTANCE
package com.lvym; /** * 懒汉式 * 有延迟，需要就去调用创建 不安全 * 1.构造器私有化，保证一个类只能有一个实例 * 2.自行创建，并且用静态变量保存 * 3.向外暴露这个实例 * * */ public class SingletonDemo { private static SingletonDemo instance; private SingletonDemo(){} public static SingletonDemo getInstance(){ if (instance == null) { instance=new SingletonDemo(); } return instance; } }
package com.lvym; import java.util.concurrent.*; public class test { public static void main(String[] args) throws ExecutionException, InterruptedException { Callable<SingletonDemo> callable=new Callable<SingletonDemo>() { @Override public SingletonDemo call() throws Exception { return SingletonDemo.getInstance(); } }; ExecutorService executorService= Executors.newFixedThreadPool(3); Future<SingletonDemo> submit = executorService.submit(callable); Future<SingletonDemo> submit1 = executorService.submit(callable); //有时相等 System.out.println(submit.get()); System.out.println(submit1.get()); executorService.shutdown(); } }
package com.lvym; /** * 懒汉式 * 有延迟，需要就去调用创建 安全 * 1.构造器私有化，保证一个类只能有一个实例 * 2.自行创建，并且用静态变量保存 * 3.向外暴露这个实例 * * */ public class SingletonDemo { private static SingletonDemo instance; private SingletonDemo(){} public static SingletonDemo getInstance(){ if (instance==null){ synchronized (SingletonDemo.class) { if (instance == null) { instance = new SingletonDemo(); } } } return instance; } }
package com.lvym; /** * 懒汉式 * 有延迟，需要就去调用创建 安全 因为他是在内部类加载和初始化时，创建的 * 1.构造器私有化，保证一个类只能有一个实例 * 2.自行创建，并且用静态变量保存 * 3.向外暴露这个实例 * 内部类被加载和初始化时，才会创建INSTANCE实例对象， * 静态内部类不会随着外部类的加载和初始化而初始化，它是要单独加载和初始化。 * * */ public class SingletonDemo { private SingletonDemo(){} //内部类 private static class Inner{ private final static SingletonDemo INSTANCE=new SingletonDemo(); } public static SingletonDemo getInstance(){ return Inner.INSTANCE; } }
package com.lvym; class Father { private int i=test(); private static int j=method(); static { System.out.println("1"); } Father(){ System.out.println("2"); } { System.out.println("3"); } public int test(){ System.out.println("4");//子类有重写所以执行子类 return 1; } public static int method(){ System.out.println("5"); return 1; } } /** * 一个类的初始化<clinit>：由静态类变量显示赋值代码和静态代码块组成 * 先初始化父类，再初始化子类 * * 子类实例化方法<init>：由非静态类变量显示赋值代码和非静态代码块组成及构造方法 * 1.super() * 2.非静态类变量显示赋值代码或非静态代码块，谁前谁先执行 * 3.子类无参 * * * */ public class Son extends Father{ private int i=test(); private static int j=method(); static { System.out.println("6"); } Son(){ System.out.println("7"); } { System.out.println("8"); } public int test(){ System.out.println("9"); return 1; } public static int method(){ System.out.println("10"); return 1; } public static void main(String[] args) {
结果：父类静态：5 1 子类静态： 10 6 } }
public static void main(String[] args) {
Son son=new Son();
System.out.println("---------------");
Son son2=new Son();
5
1
10
6
9
3
2
9
8
7
---------------
9
3
2
9
8
7
}
}
package com.lvym; /**成员变量有默认值 * 局部变量没有默认值 * */ public class Son { static int s;//成员变量，类变量 s int i; //成员变量，实例变量 i int j;//成员变量，实例变量 j { //非静态代码块 作用域开始 int i=1; //局部变量 i i++; //i代表局部变量 i 就近原则 // this.i++; //i代表//成员变量 i j++; //j代表成员变量 j 就近原则 s++; } //作用域结束 public void test(int j){//局部变量 j 作用域开始 j++; i++; s++; } //作用域结束 public static void main(String[] args) { Son son=new Son(); Son son2=new Son(); son.test(10); son.test(20); son2.test(10);
//成员变量i 成员变量j 成员变量s System.out.println(son.i+" ,"+son.j+" ,"+son.s); //2 1 5 System.out.println(son2.i+" ,"+son2.j+" ,"+s); // 1 1 5 } }
spring传播行为：一个方法运行在一个开启事务的方法中时，当前方法是用原来事务还是开启新事物
脏读：读取别人未提交的数据 ， 不可重复读，幻读：读取别人已提交的。
事务的隔离级别：
假如 get 请求乱码：
修改server.xml
原文：https://www.cnblogs.com/lvym/p/12755571.html