Java面试

1.关于i++与++i

public static void main(String[] args) {
	int i=1;
	i=i++;  //1
	int j=i++;  //2
	int k=i+ ++i* i++;  //3
	System.out.println(i+":"+j+":"+k);
}

上面输出结果为i=4,j=1,k=11,
关于++的算法为存在局部变量表和操作数栈,操作数栈是对数字进行运算的,局部变量表的数据是进行打印的结果,++i是先把局部变量表中的变量先进行自增操作然后压入操作数栈,i++是把值压入操作数栈然后变量进行自增操作.
第一部操作先把局部变量表中的i 压入操作数栈,然后局部变量表中的i自增1变为2, 再将操作数栈的数1赋值为局部变量表中的i(此时局部变量表中的i=2,操作数栈的结果=1),因此运算结果为1
第二步和第一步相同,j=1,但是局部变量表的i已经自增为2
第三步 第一个i=2, 第二个++i的值为先将局部变量表中的i=2.自增1变为3,然后压入操作数栈,所以++i=3,局部变量表的i=3,随后i++为将局部变量表中的i压入操作数栈,局部变量表的i自增为4,随后操作数栈运算出结果为11,赋值给局部变量表中的k所以k=11,i=4,j=1
总结:每一次执行i++或者++i都会导致局部变量表中的i增长1,右边的表达式如果是++i,值会增长1,如果是i++值不变.

2.单例设计模式

1.饿汉式

1.直接实例化饿汉式

public class Singleton1{
	/**
	 * 单列设计模式:某个类在整个系统中只能有一个实例对象可以已被获取和使用的代码模式.
	 * 要点: 1.一个类只能由一个实列 ->构造器私有化
	 * 		2.它必须自行创建这个实例->含有一个该类的静态变量来保存这个唯一的实例
	 * 		3.向整个系统提供这个实例->1).直接暴露2).通过get方法
	 */
	
	//饿汉式 不管你是否需要对象
	//只有静态变量才可以不需要new 对象就可以拿到,如果不加static 需要new 对象才能拿到类变量,
	//但是构造器被私有化,无法new出实例
	public static final Singleton1 INSTANCE= new Singleton1();
	private Singleton1(){
	}
}

2.枚举

```java
public  enum Singleton2{
	//枚举类型:表示该类型的对象是有限的几个,可以限定为一个,就成为单例
	//第一行写产量对象列表,枚举类型构造器全部为私有化
	INSTANCE
}

3.静态代码块饿汉式

public class Singleton3 {
	// 与直接实例化对象的区别,如果有属性需要初始化,并且采用properties文件动态加载属性
	//从直接实例化对象的new改为比较复杂的需要读一堆初始化数据才能把对象完成创建好,这种情况比较适合静态代码块
	public static final Singleton3 INSTANCE;
	private String info;
	static {
		try {
			Properties pro = new Properties();
			pro.load(Singleton3.class.getClassLoader().getResourceAsStream("Path"));
			INSTANCE = new Singleton3(pro.getProperty("key"));
		} catch (IOException e) {
			// TODO Auto-generated catch block
			throw new RuntimeException(e);
		}

	}

	private Singleton3(String info) {
		this.info = info;
	}
}

**

2.懒汉式

1.线程安全

**
```public class Singleton4 {
	private static Singleton4 instance;

	private Singleton4() {
	}

	public static Singleton4 getInstance() {
		synchronized (Singleton4.class) {
			if (instance == null) {
				instance = new Singleton4();
			}
		}
		return instance;
	}
}

2)单线程

public class Singleton5 {
	private static Singleton5 instance;

	private Singleton5() {
	}

	public static Singleton5 getInstance() {
		
			if (instance == null) {
				instance = new Singleton5();
			}
		
		return instance;
	}
}

3)内部类形式

public class Singleton6 {
	//在内部类被加载初始化时,才会创建instance对象
	//静态内部类不会随着外部类的加载而加载,他是要单独加载和初始化的
	private Singleton6() {}
	private static class Inner{
		private static final Singleton6 INSTANCE=new Singleton6();
	}
	public Singleton6 getInstance() {
		return Inner.INSTANCE;
	}
}

总结:饿汉式 枚举最简单
懒汉式 内部类最简单

3.类的初始化时实例初始化

https://www.bilibili.com/video/BV1Eb411P7bP?p=3
类的初始化过程:
1.一个类要创建实例,需要先加载并初始化该类
main方法所在的类需要先加载和初始化
2.一个子类初始化之前先初始化父类
3.一个类初始化时执行方法 推测cl时class的缩写
该方法由静态类变量显示赋值代码和静态代码块组成
类变量显示赋值代码和静态代码块从上到下顺序执行
该方法只执行一次
实例初始化过程
1.执行init方法

1. init方法可能重载有多个,有几个构造器就有几个init方法
2. init方法由非静态实例变量显式赋值代码和非静态代码块以及对应构造器代码组成
3. 非静态实例变量显示赋值代码和非静态代码块代码从上到下依次执行,对应的构造器的代码最后执行 每次创建
4. 每次创建实例对象,调用相应构造器,执行的就是init方法
5. init方法的首行是super()或者super(实参),即对应父类的init方法

子类的实例化方法

1. super() 首先执行
   非静态变量
   非静态代码块 变量与代码块顺序执行
2. 子类的无参构造 最后执行

父类的实例化方法

1. super() 首先执行
2. 非静态变量, 非静态代码块 变量与代码块顺序执行
3. 父类的无参构造 最后执行

非静态方法前面其实有一个默认的对象this,this在构造器表示的是正在创建的对象,因为这里创建的是子类
对象,所以方法执行的是子类重写的代码,即在创建子类对象时,子类会先执行super()方法,导致父类执行super()方法,父类执行完super()方法后,执行父类的非静态变量,此时如果父类变量调用了方法,该方法在子类中重写,那么由于在该方法中有个this,this指的是正在创建的对象也就是子类对象,因此执行的是子类重写的方法

方法的重写overide

1. 哪些方法不能被重写
   $ final方法
   $ 静态方法
   $ private等子类中不可见方法
2. 对象的多态性
   $ 子类如果重写了父类的方法,通过子类对象调用的一定是子类重写过的方法
   $非静态方法默认调用对象是this
   $this对象在构造器或者说init方法中就是正在创建的对象

参数的传递机制

https://www.bilibili.com/video/BV1Eb411P7bP?p=4

```java
public class Test {
    public static void main(String[] args) {
        Integer b= 100;
        Integer a=100;
        System.out.println(a==b); //true
        Integer c=200;
        Integer d=200;
        System.out.println(c==d); //false
    }
}

此外 ,如果是-128到127之间的整数，则会使用整数缓存对象，否则就new一个整形对象。因此第一个是true，第二个是false。
**方法的参数传递机制:**
1. 形参是基本数据类型
	$  传递数据值
2. 实参是应用数据类型
	$ 传递地址值
	$特殊的类型:string 包装类等对象不可变,改变时会重新new 对象


## 走楼梯
1. 递归算法

```java
public static Integer m(Integer n) {
		if (n==1) {
			return 1;
		}
		if (n==2) {
			return 2;
		}
		
		return m(n-1)+m(n-2);
	}

2. 迭代算法

	public static Integer m(Integer n) {
		if (n==1) {
			return 1;
		}
		if (n==2) {
			return 2;
		}
		int one=1;
		int two =2;
		int sum=0;
		//到第一台阶的步数为1,到第二台阶的方法为2,到第三台阶的步数等于第一台阶步数加上第二台阶步数,第四台阶步数等于第三台阶步数加上第二台阶步数,在计算第四台阶步数时,
		for (int i = 3; i <=n; i++) {
			sum=one+two;
			one=two;
			two=sum;
		}
		return sum;
	}

成员变量与局部变量
声明的位置:局部变量:方法体{},形参,代码块{}中 成员变量:类中,方法外,静态的为类变量,否则为实例变量
修饰符:局部变量:final 成员变量:public protect,private,final,static,volatile,transient
存储的位置:局部变量:栈 实例变量:堆 类变量:方法区


变量的使用遵循就近原则,作用域中如果成员变量的this缺省,那么就遵循就近原则

linux常用服务相关命令

chkconfig --level5 服务名 off


ctl是control的缩写 firewalld d是daemon的缩写,意为守护进程后台程序
systemctl list-unit-files | grep firewalld

centos6一般设置自启动采用chkconfig方法,没有图形化界面等级是3,有图形化界面是等级5,

git分支相关命令

https://www.bilibili.com/video/BV1Eb411P7bP?p=13

redis持久化

https://www.bilibili.com/video/BV1Eb411P7bP?p=14