JavaSE 基础回顾

JavaSE 基础回顾

1. 类的初始化过程
1）、一个类要创建实例需要先加载并初始化该类
——>main 方法所在的类需要先加载和初始化
2）、一个子类要初始化需要先初始化父类
3）、一个类的初始化就是执行() 方法
——>clinit() 方法由静态类变量显示赋值代码和静态代码块组成
——>类变量显示赋值代码和静态代码块代码从上到下执行
——>clinit() 方法执行一次
2. 实例初始化的过程
1）、实例初始化就是执行<init()>方法
——>init() 方法可能重载有多个，有几个构造就有几个init() 方法
——>init() 方法由非静态实例变量显示赋值代码和非静态代码块、对应构造器代码组成
——>非静态实例变量显示赋值代码和非静态代码块代码从上到下顺序执行，而对应构造器的代码最后执行
——>每次创建实例对象，调用对应构造器，执行的就是对应的init() 方法
——>init() 方法的首行是supper() 或 supper（实参列表），即对应父类的init() 方法

3. 方法的重写Override
1）、哪些方法不可以重写Override
——final 关键字修饰的方法
——静态方法
——private 等子类中不可见的方法
2）、对象的多态性
——子类如果重写父类的方法，通过子类对象调用的一定是子类重写过的代码
——非静态方法默认的调用对象是this
——this对象在构造器或者是init() 方法中就是正在创建的对象

/**
 * 
 * @author Administrator
 * 父类的初始化<clinit>
 * 	1、静态代码初始化
 * 		j = method()
 * 	2、静态代码块初始化
 * 
 * 	执行流程：
 * 		(1)supper();
 * 		(2)非静态赋值代码
 * 		(3)非静态代码块
 * 		(4)构造器
 * 		
 */
public 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 2;
	}

}
=================================================================================
/**
 * 类的初始化过程
 * 	1、子类的初始化<clinit> 先初始化父类<clinit>
 * 	2、一个子类要初始化需要先初始化父类
 * 	3、一个类的初始化就是执行<clinit>() 方法
 * 		a：clinit() 方法由静态类变量显示赋值代码和静态代码块组成
 * 		b：类变量显示赋值代码和静态代码块代码从上到下执行
 * 		c：clinit() 方法执行一次
 * 	所以先执行：父类的静态代码(5)——>父类的静态代码(1)——>子类的静态代码(10)——>子类的静态代码块(6)
 * 
 * 实例初始化过程：
 * 	1、实例初始化就是执行<init()>方法
 * 		a：init() 方法可能重载有多个，有几个构造就有几个init() 方法
 * 		b：init() 方法由非静态实例变量显示赋值代码和非静态代码块、对应构造器代码组成
 * 		c：非静态实例变量显示赋值代码和非静态代码块代码从上到下顺序执行，而对应构造器的代码最后执行
 * 		d：每次创建实例对象，调用对应构造器，执行的就是对应的init() 方法
 * 		e：init() 方法的首行是supper() 或 supper（实参列表），即对应父类的init() 方法
 * 	执行流程：
 * 		(1)supper();
 * 		(2)非静态赋值代码
 * 		(3)非静态代码块
 * 		(4)构造器
 * 
 * 	所以执行：5——1——10——6——9——3——2——9——8——7
 * 			
 * 
 */
public class Son extends Father {
	private int i = test();	//非静态赋值代码
	private static int j = method();	//静态代码
	static {	//静态代码块
		System.out.println("(6)");
	}
	public Son() {	//构造器
		//supper(); 系统会默认自动调用父类构造器①
		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 2;
	}
	
	public static void main(String[] agrc) {//main 方法所在的类需要先加载和初始化
		Son son1 = new Son();
		Son son2 = new Son();
	}

}

4. 方法参数传递/赋值操作的特性
   1）、赋值操作中
   ① 基本数据类型——传递的是变量值的副本
   ② 引用数据类型——传递的是变量的引用（特殊的类型：String、包装类型等对象存在不可变行）

String 的源码
	/** The value is used for character storage. */
    private final char value[];
Integer 的源码
	/**
     * A constant holding the minimum value an {@code int} can
     * have, -2<sup>31</sup>.
     */
    @Native public static final int   MIN_VALUE = 0x80000000;

    /**
     * A constant holding the maximum value an {@code int} can
     * have, 2<sup>31</sup>-1.
     */
    @Native public static final int   MAX_VALUE = 0x7fffffff;

5. 局部变量与成员变量的区别
   1）、声明的位置
   ① 局部变量：方法体{}中，形参，代码块{} 中
   ② 成员变量：类中方法外
   a：类变量：有static 修饰（在类加载的时候初始化）
   b：实例变量：没有static 修饰（在类被实例化的时候初始化）
   2）、修饰符
   ① 局部变量：final
   ② 成员变量：public、protected、private、final、static、volatile、transient
   3）、值存储的位置
   ① 局部变量：栈
   ② 全局变量：堆
   ③ 类变量：方法区

/**
 * 变量：
 * 	 1、局部变量(栈)——方法体{}中，形参，代码块{} 中
 * 	 2、成员变量——类中方法外
 * 		a：类变量(方法区)：有static 修饰，全类共享（在类加载的时候初始化）
 * 		b：实例变量(堆)：没有static 修饰，实例共享（在类被实例化的时候初始化）
 *
 *
 */
public class Test02 {
	
	static int s = 10;	//成员变量(类变量)
	int i = 2;	//成员变量(实例变量)
	int j = 6;	//成员变量(实例变量)
	{
		int i = 2;	//非静态代码块中i 为局部变量
		i++;
		j++;
		s++;
	}
	
	public void test(int j) {	//参数变量j 为局部变量
		j++;
		i++;
		s++;
	}

	public static void main(String[] args) {
		Test02 t1 = new Test02();	//局部变量
		Test02 t2 = new Test02();	//局部变量
		t1.test(15);
		t2.test(20);
		t2.test(30);
		System.out.println("s="+t1.s+",i="+t1.i+",j="+t1.j);
		System.out.println("s="+t2.s+",i="+t2.i+",j="+t2.j);

	}

}

6. Elasticsearch 和 solr 的区别
   背景：它们都是基于Lucene 搜索服务器基础之上开发，一款优秀的，高性能额企业级搜索服务器。【是因为他们都是基于分词技术构建的排序索引的方式进行查询】
   开发语言：java 语言开发
   诞生时间：
   solr：2004 年诞生
   Elasticsearch：2010 年诞生【功能更强大】
   区别：
   ① 当实时建立索引的时候solr会产生IO 阻塞，而es 不会，es 查询性能要高于solr。
   ② 在不断动态加数据的时候，solr 的检索会变得底下，而es 则没有什么变化。
   ③ Solr 利用zookeeper 进行分布式管理，而es 自身带有分布式系统管理功能，solr 一般都要部署到web 服务器行，比如Tomcat。启动Tomcat 的时候需要配置Tomcat 与 solr 的关联【Solr 的本质是一个动态web 项目】
   ④ Solr 支持更多的格式数据（xml、json、csv 等），而es 仅支持json 文件格式。
   ⑤ Solr 是传统搜索应用的有力解决方案，但是es 更适用与新兴的实时搜索应用。
   a）、单纯的对已有数据进行检索的时候，solr效率更好，高于es
   ⑥ Solr 官网提供的功能更多，而es 本身更注重于核心功能，高级功能多有第三方插件。

7. 单点登录
   含义：一处登录多处使用
   前提：单点登录多使用在分布式系统中
   Demo：参观动物园（检票员=认证中心模块）
   1、走到检票口被检票员拦截【是否有票】，没有则提示前去买票
   2、去买票【带着票去到检票口】检票员check【有票】Token=piao，放行进园
   3、手中有票就可以任意在各个景点进行参观
   京东：单点登录，是将token 放入到cookie中的。
   案例：将浏览器的cookie 禁用，则在登录京东失败，怎么都会登录不了，没办法拿到cookie

8. 消息队列
   产生背景：在分布式系统中处理高并发的问题
   ——由于在高并发的环境下，来不及同步处理用户发送的请求，则会导致请求发送阻塞。比如说，大量的CRUD（增删查改）之类的请求同时到达数据库MySQL，直接导致无数的行锁或表锁，甚至会导致请求堆积很多。从而触发too many connection 错误。使用消息队列可以解决【异步通信】
   1）、异步
   
   2）、并行
   
   3）、排队
   
   4）、消息队列电商中使用场景
   
   消息队列的弊端：消息的不确定性
   解决方案：延迟队列，轮询技术来解决
   推荐使用Apache公司下的activemq，它的环境是java。