自增变量:
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
标签:Java,试题,System,static,println,SingletonDemo,public,out From: https://blog.51cto.com/u_16253752/8190779