Java试题

自增变量：

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