java基础问题101问(javaSE阶段知识汇总)

1.JDK、JRE、JVM的关系

2.为什么配置path环境变量？

path环境变量：windows操作系统执行命令时所要搜寻的路径
为什么要配置path:希望java的开发工具（javac.exe,java.exe)在任何的文件路径下都可以执行成功。

3.标识符命名规则

4.标识符命名规范

5.变量的分类

声明long型变量，必须以"l"或"L"结尾
定义float类型变量时，变量要以"f"或"F"结尾

6.break和continue的区别

7.数组的理解：

数组(Array)，是多个相同类型数据一定顺序排列的集合，并使用一个名字命名，并通过下标索引的方式对这些数据进行统一管理。

8.数组的特点：

• 1数组是序排列的
• 2数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
• 3创建数组对象会在内存中开辟一整块连续的空间
• 4数组的长度一旦确定，就不能修改。

9.写出创建数组的三种方式

数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};
数据类型[] 数组名 = {元素1,元素2,元素3…};

10.面向对象与面向过程（理解）

1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

11.类和对象

类：对一类事物的描述，是抽象的、概念上的定义
对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)

12.匿名对象

我们创建的对象，没显式的赋给一个变量名。即为匿名对象
特点：匿名对象只能调用一次。

13.成员变量和局部变量的区别

在类中的位置不同

• 成员变量：类中，方法外
  

• 局部变量：方法中
  

作用范围不一样

• 成员变量：类中
  

• 局部变量：方法中
  

初始化值的不同

• 成员变量：有默认值
  

• 局部变量：没有默认值。必须先定义，赋值，最后使用
  

关于权限修饰符的不同

• 成员变量：可以使用权限修饰符。
  

• 局部变量：不可以使用权限修饰符。
  

  在内存中加载的位置：

•  属性：加载到堆空间中   （非static）
  

•  局部变量：加载到栈空间
  

14. 请简要说明什么是方法重载，如何判断多个方法是否为方法的重载

重载：指在同一个类中，允许存在一个以上的同名方法。
严格按照定义判断：两同一不同（同一类，同一方法名，参数列表不同）。个数不同，数据类型不同，顺序不同。
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系！

15.可变形参具体使用：

• 可变个数形参的格式：数据类型 … 变量名
• 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
• 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
• 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
• 可变个数形参在方法的形参中，必须声明在末尾
• 可变个数形参在方法的形参中,最多只能声明一个可变形参。

 public void show(int i){
		
	}
	
	public void show(String s){
		System.out.println("show(String)");
	}
	
	public void show(String ... strs){
		System.out.println("show(String ... strs)");
		
		for(int i = 0;i < strs.length;i++){
			System.out.println(strs[i]);
		}
	}
	//不能与上一个方法同时存在
//	public void show(String[] strs){
//		
//	}

16.值传递和引用传递

如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

17.什么是封装、

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

18.封装有哪些好处

隐藏了类的具体实现
操作简单
提高对象数据的安全性

19.Java规定的四种权限修饰符

权限从小到大顺序为：private < 缺省 < protected < public
4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
修饰类的话，只能使用：缺省、public

20.构造器的作用：

• 1.创建对象
• 2.初始化对象的信息

21.构造器使用说明：

• 1.如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器
• 2.定义构造器的格式：权限修饰符 类名(形参列表){}
• 3.一个类中定义的多个构造器，彼此构成重载
• 4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
• 5.一个类中，至少会有一个构造器。

22.属性赋值顺序

• ① 默认初始化
• ② 显式初始化
• ③ 构造器中初始化
• ④ 通过"对象.方法" 或 "对象.属性"的方式，赋值
• 以上操作的先后顺序：① - ② - ③ - ④

23.所谓JavaBean，是指符合如下标准的Java类：

	>类是公共的
	>一个无参的公共的构造器
	>属性，且对应的get、set方法

24.this理解

理解为：当前对象 或 当前正在创建的对象

25.this作用

• this调用变量：
  如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

• this调用构造器：
  ① 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
  ② 构造器中不能通过"this(形参列表)“方式调用自己
  ③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)”
  ④ 规定："this(形参列表)“必须声明在当前构造器的首行
  ⑤ 构造器内部，最多只能声明一个"this(形参列表)”，用来调用其他的构造器

26.什么是继承

就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

27.static中是否可以使用this关键字，说明为什么

静态方法中不能使用this关键字，static优于对象创建之前就已经存在，this表示当前对象的地址 所以不能使用this

28.为什么要有类的继承性？(继承性的好处）

• ① 减少了代码的冗余，提高了代码的复用性
• ② 便于功能的扩展
• ③ 为之后多态性的使用，提供了前提

29.Java中继承性的说明

1.一个类可以被多个子类继承。
2.Java中类的单继承性：一个类只能有一个父类
3.子父类是相对的概念。
4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
5.子类继承父类以后，就获取了直接父类以及所间接父类中声明的属性和方法

30.接口和抽象类有什么区别

• 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的。
• 接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法。
• 接口中不能含有普通方法，而抽象类中可以存在普通方法。
• 一个类只能继承一个抽象类，而一个类却可以实现多个接口，接口与接口可以多继承。

31.java.lang.Object类的理解

1. 如果我们没显式的声明一个类的父类的话，则此类继承于java.lang.Object类
2. 所有的java类（除java.lang.Object类之外都直接或间接的继承于java.lang.Object类
3. 意味着，所的java类具有java.lang.Object类声明的功能。

32.什么是方法的重写(override 或 overwrite)？

子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作.

33.重写的应用：

重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。

34.super调用属性、方法：

理解为父类的，可以调用属性、方法、构造器

• 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
• 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
• 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。

35.什么是方法的重写（Overried）？与重载（Overload）有什么区别？

• 重写：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。
• 重载：是指在同一个类中可以出现多个重名的方法，重载只与参数列表相关，而重写是指父子类中存在同名的方法，子类的重写的方需要返回值类型，方法名和参数列表都与父类相同

36.super调用构造器：

• 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
• "super(形参列表)"的使用，必须声明在子类构造器的首行！
• 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二一，不能同时出现
• 在构造器的首行，没显式的声明"this(形参列表)“或"super(形参列表)”，则默认调用的是父类中空参的构造器：super()
• 在类的多个构造器中，至少一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器

37.多态性的理解

可以理解为一个事物的多种形态。

38.何为多态性：

对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
Person p = new Man();
有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。

39.多态是编译时行为还是运行时行为？

运行时行为，因为编译时不知道父类对象指向哪个子类，只有当运行时，才能看出来。

40.写出多态的格式，并且说明在什么情况下才能使用父类的引用调用子类的实现

父类 f = new 子类()
当子类重写父类中的方法的时候

41.需要掌握的类型间的转换：（基本数据类型、包装类、String）

简易版：
基本数据类型<—>包装类：JDK 5.0 新特性：自动装箱 与自动拆箱
基本数据类型、包装类—>String:调用String重载的valueOf(Xxx xxx)
String—>基本数据类型、包装类:调用包装类的parseXxx(String s)
注意：转换时，可能会报NumberFormatException

42.静态属性 vs 非静态属性(实例变量)

• 实例变量：我们创建了类的多个对象，每个对象都独立的拥一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
• 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。

43.静态变量的特点

• ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
• ② 静态变量的加载要早于对象的创建。
• ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。

44.内存解析

45.常用设计模式 — 23种经典的设计模式 GOF

• 创建型模式，共5种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
• 结构型模式，共7种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
• 行为型模式，共11种：策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

46.单例模式

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。

饿汉式1：
class Bank{
	
	//1.私化类的构造器
	private Bank(){
		
	}
	
	//2.内部创建类的对象
	//4.要求此对象也必须声明为静态的
	private static Bank instance = new Bank();
	
	//3.提供公共的静态的方法，返回类的对象
	public static Bank getInstance(){
		return instance;
	}
}

懒汉式：
class Order{
	
	//1.私化类的构造器
	private Order(){
		
	}
	
	//2.声明当前类对象，没初始化
	//4.此对象也必须声明为static的
	private static Order instance = null;
	
	//3.声明public、static的返回当前类对象的方法
	public static Order getInstance(){
		
		if(instance == null){
			
			instance = new Order();
			
		}
		return instance;
	}
	
}

47.单例模式的两种方式对比：

• 饿汉式：

•  坏处：对象加载时间过长。
  

•  好处：饿汉式是线程安全的
  

• 懒汉式：

•    好处：延迟对象的创建。
  

•    目前的写法坏处：线程不安全。--->到多线程内容时，再修改
  

48.实现单例模式的三个步骤

a.将构造方法私有化
b.在类中创建一个私有、静态的本类对象
c.提供一个用类名调用的公有静态方法获取该对象

49.静态代码块 vs 非静态代码块

静态代码块：

内部可以输出语句
随着类的加载而执行,而且只执行一次
作用：初始化类的信息
如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
静态代码块的执行要优先于非静态代码块的执行
静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

非静态代码块：

内部可以输出语句
随着对象的创建而执行
每创建一个对象，就执行一次非静态代码块
作用：可以在创建对象时，对对象的属性等进行初始化
如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

50.final关键字可以修饰哪些对象，修饰后有哪些特点

final可以修饰变量，方法，类，方法参数。
变量：不能被改变
方法：不能被重写
类：不能被继承
方法参数：不能被改变

51.请写出五种常见的内部类

a.匿名内部类
b.普通成员内部类
c.私有成员内部类
d.静态成员内部类
e.局部内部类

52.String和StringBuilder的相互转换

String转成StringBuilder
a、StringBuilder的构造方法
b、append方法
StringBuilder转成String类型
a、toString的方法
b、使用String的构造方法 new String(stringbuilder)

53.String、StringBuffer、StringBuilder三者的对比

• String:不可变的字符序列；底层使用char[]存储
• StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储
• StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储

54.StringBuffer、StringBuilder扩容问题:

如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
默认情况下，扩容为原来容量的2倍 + 2，同时将原数组中的元素复制到新的数组中。

55.对比String、StringBuffer、StringBuilder三者的执行效率

从高到低排列：StringBuilder > StringBuffer > String

56.String概述

1.String声明为final的，不可被继承
2.String实现了Serializable接口：表示字符串是支持序列化的。
实现了Comparable接口：表示String可以比较大小
3.String内部定义了final char[] value用于存储字符串数据
4.通过字面量的方式（区别于new给一个字符串赋值，此时的字符串值声明在字符串常量池中)。
5.字符串常量池中是不会存储相同内容(使用String类的equals()比较，返回true)的字符串的。

57.字符串通过字面量赋值

1.当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
2.当对现的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
3.当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。

58.字符串赋值方式

• 通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中。
• 通过new + 构造器的方式:此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。

59.String s = new String(“abc”);方式创建对象，在内存中创建了几个对象？

两个:一个是堆空间中new结构，另一个是char[]对应的常量池中的数据：“abc”

60.字符串拼接方式赋值的对比

1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
2.只要其中一个是变量，结果就在堆中。
3.如果拼接的结果调用intern()方法，返回值就在常量池中

61.String在拼接字符串的时候底层是如何实现的

您的回答：常量拼接时，在常量池中查找拼接后的字符串，找到返回给引用，没找到就新建一个字符串返回给引用。
有变量拼接时，在堆中拼接，底层转换成StringBuilder进行append拼接操作，StringBuilder.toString()返回新的字符串。

62.什么是自动拆装箱

您的回答：基本数据类型无法实现面向对象，java中提供了其包装类实现面向对象特征。
基本类型转向其包装类是自动装箱
包装类转向基本数据类型是自动拆箱
不用调用方法，直接=即可，自动拆装箱。

63.简述常量池

您的回答：jvm中单独划分的一块区域，用来存储字符串字面值，叫做字符串常量池。常量池中不能存在相同的字符串，需要字符串字面值时，在常量池中查找该字面值是否已经存在，存在就将常量池中的值返回给该字符串引用，不存在就创建新的字面值，返回给该字符串引用。

64. 异常的体系结构

• java.lang.Throwable

•  |-----java.lang.Error:一般不编写针对性的代码进行处理。
  

•  |-----java.lang.Exception:可以进行异常的处理
  

•  	|------编译时异常(checked)需要处理
  

•  			|-----IOException
  

•  			|-----FileNotFoundException
  

•  			|-----ClassNotFoundException
  

•  			|-----parseException
  

•  	|------运行时异常(unchecked,RuntimeException)不用处理，修改代码即可
  

•  			|-----NullPointerException
  

•  			|-----ArrayIndexOutOfBoundsException
  

•  			|-----ClassCastException
  

•  			|-----NumberFormatException
  

•  			|-----InputMismatchException
  

•  			|-----ArithmeticException
  

65.关于异常对象的产生：

① 系统自动生成的异常对象
② 手动的生成一个异常对象

66.throw 和 throws区别：

throw 表示手动抛出一个异常类的对象，生成异常对象的过程。声明在方法体内。
throws 属于异常处理的一种方式，声明在方法的声明处。

67.自定义异常

可以继承的父类有Exception、RuntimeException

public class MyException extends Exception {
    public MyException(){}
    public MyException(String msg){
        super(msg);
    }
}

可以try-catch或者throws处理产生的异常

public class Test {
    public static void main(String[] args) {
        try {
            throw  new MyException("自定义异常");
        } catch (MyException e) {
            e.printStackTrace();
        }

    }
}

68.java数组、集合、集合工具类总结

69.TreeSet是否可以对自定义对象Student进行排序 如何排序

可以,需要确定如何对自定义对象Student排序,可采用Comparable和Comparator比较器,重写比较器内部的比较方法,按照指定属性进行排序。

70.Comparable和Comparator比较器的使用区别

Comparable需要当前类实现Comparable接口,重写compareTo方法。
Comparator需要当前类实现Comparator接口,重写compare方法,并将该接口的子类对象作为参数传递给当前集合的构造方法。
当两种比较方式同时存在时,以Comparator比较方式为主。

71.Arraylist和LinkedList的区别

Arraylist底层是数组,查找快,增删慢。
LinkedList底层是链表,查找慢,增删快。

72.Collections和Collection的区别

Collections是工具类,可通过类名.方法调用其方法来操作集合。
Collection是单列集合,通过实例化其子类集合来存储数据。

73.HashMap和Hashtable的区别

HashMap线程不安全,允许null键值对
HashTable线程安全,不允许null键值对。

74.比较器用法心得

list不会去重，对自定义对象排序，使用Collections.sort(list,new comparator)，重写比较器进行排序，sort方法默认对基本数据类型升序排序。
hashset，hashmap，不存储重复的数据，所以需要对自定义对象重写hashcode,equals方法。
treeset,treemap，不存储重复数据，所以需要对自定义对象重写hashcode,equals方法。默认对基本数据类型升序排序，对自定义对象，需要重写比较器，告知集合以什么方式进行排序。

75.什么是泛型

广泛的类型，在定义一个类的时候，类型中有些方法参数、返回值类型不确定，就使用一个符号，来表示那些尚未确定的类型，这个符号，就称为泛型。

76.泛型的好处

1、提高了数据的安全性，将运行时的问题，提前暴露在编译时期
2、避免了强转的麻烦

77.为什么要在程序中使用泛型？

当在类中或接口中，对其中的方法类型，返回值类型，参数类型不确定时，使用泛型代替，当使用类，接口，方法时，可根据需要给出具体类型，增强了代码的可扩展性。
1、提高了数据的安全性，将运行时的类型转换异常，提前暴露在编译时期
2、避免了强转的麻烦

78.泛型分类

• 泛型类
  class 类名<泛型类型1,泛型类型2,…>{

  }

  1、类名后面跟着的泛型类型，是泛型的声明，一旦泛型声明出来，就相当于这个类型成为了已知类型，这个类型就可以在整个类中使用
  2、泛型的声明名称，只需要是一个合法的标识符即可，但是通常我们使用单个大写字母来表示，常用字母：T、W、Q、K、V、E
  3、泛型确定的时机：将来在使用和这个类，创建对象的时候

• 泛型方法
  修饰符 <泛型声明1, 泛型声明2,…> 返回值类型 方法名称(参数列表) {
  }

  1、在方法上声明的泛型，可以在整个方法中，当做已知类型来使用
  2、如果【非静态】方法上没有任何泛型的声明，那么可以使用类中定义的泛型
  3、如果【静态】方法上没有任何的泛型声明，那么就不能使用泛型，连类中定义的泛型，也不能使用，因为类中的泛型需要在创建对象的时候才能确定。所以【静态】方法想使用泛型，就必须在自己的方法上单独声明。

• 泛型接口
  interface 接口名称<泛型类型1, 泛型类型2,…> {
  }

  1、在接口声明上，定义好的泛型，可以在整个接口中当做已知类型来使用
  2、泛型接口被其他类实现的时候，有两种实现方式：
  1、声明的类不再是一个泛型类，而是一个确定了泛型的类，格式如下：
  class 实现类类名 implements 接口名<具体类型> {
  所有的泛型类型都已经被确定
  }
  2、声明的类还是一个泛型类，泛型的类型和接口的泛型一致，格式如下：
  class 实现类类名<泛型标识符1> implements 接口名<泛型标识符1> {
  所有的方法还都是可以使用泛型标识符的方法。
  }

• 泛型通配符

  ？extends E: 接收E类型或者E的子类型。
  ? super E: 接收E类型或者E的父类型。
  正确：Vector<? extends Number> x = new Vector();
  错误：Vector<? extends Number> x = new Vector();

79.说出泛型类，泛型方法，和泛型接口确定的时机

泛型类:实例化对象时确定
泛型方法:调用方法时
泛型接口:被实现时

80.说出三种泛型通配符及各自的含义

?:表示可以是任意类型。
? extends E:表示必须是某个泛型类型或该泛型的子类。
? super E:表示必须是某个泛型类型或该泛型类型的父类。

81.final，finally，finalize的区别

fianl是常量关键字，被fianl修饰的常量不可二次赋值，方法不能被重写，类不能被继承。
finally是处理异常时，finally中的代码一定会被执行。
finalize是垃圾回收无用的对象时，首先执行该对象的finalize()方法，该方法中可写 在垃圾回收之前，我们想让它执行的操作。

82.文件和io流

83.多线程知识汇总，看这一遍就够了

84.枚举类

85.什么是序列化什么是反序列化，如何解决版本号冲突

对象的序列化:将内存中的对象直接写入到文件设备中或在网络中传输。
对象的反序列化:从硬盘中读取对象数据到内存.
如何解决:手动给定一个序列化版本ID

86.并发和并行的区别

并行:多个任务(进程,线程)同时运行,有多个cpu,多核编程。
并发:多个任务(进程,线程)同时发起,但不能同时执行，每个任务分配一个时间片，执行完时间片后等待下一次cpu执行,一个cpu在不同任务之间来回进行切换。

87.实现多线程的两种方式有什么区别

继承方式:java是单继承的,继承了Thread类就不能继承其他类了。
实现接口方式:可以多实现,且比Thread类更能体现数据共享的概念。

88.描述线程阻塞的三种情况

io阻塞
sleep()
wait()

89.如何停止一个正在运行的线程

1.调用stop方法(已过时)。
2.使用定义标识的方法。

90.有三个线程 A线程优先级设置为1 B线程设置为优先级5 C线程设置为优先级10 那么线程执行的顺序就为CBA 这句话对吗？为什么？

不对,设置优先级只是增大了优先级高的率先抢占cpu被执行的概率,但不一定就先执行优先级高的。

91.什么是守护线程 有什么特点

守护其他线程运行，保证其他线程能正常运行的线程，只有在别的非守护线程运行时才有意义。
后台线程的特征： 当所有前台线程都运行完成后，无论后台线程是否运行完成都要结束。（注意：是在一段时间内结束，并不会立即结束）
实现：
setDaemon(boolean on)
必须在启动线程之前（调用start方法之前）调用setDaemon（true）方法，才可以把该线程设置为后台线程。

92.yield方法会进入阻塞状态还是就绪状态

就绪状态 使当前被执行的线程释放cpu的执行权。

93.描述一下线程安全问题产生的原因

多个线程同时操作共享同一块数据,导致的数据共享不一致。

94.说明解决线程安全的方式

(1) 使用synchronized同步代码块
(2) 使用同步方法
(3) 使用同步锁

95.什么是死锁问题 怎么解决死锁问题

多个线程互相等待对方释放资源。
转变程序逻辑,修改代码。

96.什么是线程协作，怎么让两个线程处于协作状态

多个线程相互配合协作完成功能。
通过线程之间的握手来实现,可以通过Object中的wait()和notify()或nofityAll()来安全的实现握手。

97.和sleep方法区别

1.声明位置不同,thread类中声明sleep(),object()类中声明wait()
2.调用要求不同,sleep在任何需要的场景下都能调用,wait()必须在同步代码块或同步方法中使用。
3.是否释放锁,如果两个方法都使用在同步代码块或同步方法中,sleep()不会释放锁,wait()会释放锁。

98.notify和notifyall的区别

notify唤醒一个被wait的线程,有多个线程被wait,唤醒优先级高的（wait的先后顺序）。
notifyAll唤醒所有被wait的线程。

99.为什么要使用到线程池，可以为我们解决什么问题

系统创建和销毁线程的成本比较高,尤其需要创建大量生存期很短的线程时,使用线程池可以很好的提高性能。
在没有任务的时候,先把线程对象创建好,有任务时线程就执行,且这个线程对象一般可以回收利用。

如果任务破坏力较大，任务会把线程搞死，线程池会继续提供下一个线程，继续完成这个任务。

100.Callable接口的任务和Runnable接口的任务有什么区别

callable接口是对runnable接口的增强,提供了一个call()方法,比run()方法功能强大,可以有返回值,可以抛出异常。

101.简单描述什么是垃圾回收机制

在程序的运行时环境中，Java虚拟机提供了一个系统级的垃圾回收器线程，它负责自动回收那些无用对象所占用的内存，这种内存回收的过程被称为垃圾回收（Garbage Collection）。