1.基础回顾+面试
1.1抽象类
什么是抽象类？
答：1. 父类知道子类一定要完成某个功能，但是每个子类完成的情况是不一样的
2.子类以后也只会用自己重写的功能，那么父类的该功能就可以定义成抽象方法，子类重写调用子类自己的就行
什么是抽象方法？
答：没有方法体，只有方法签名，必须用abstract修饰。具有抽象方法的类必须定义成抽象类
抽象类的作用？
答：为了被子类继承
一个类继承了抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类、
抽象类的特征？
答：有得有失
有得：抽象类得到了具有抽象方法的能力
有失：抽象类失去了创建对象的能力(抽象类不能创建对象)
抽象类的注意事项和总结：
抽象类不能创建对象，如果创建，编译无法通过而报错
理解：假设创建了抽象类的对象，调用抽象方法，抽象方法没有方法体，无法执行
抽象类一定有而且是必须有构造器，是提供给子类创建对象时，初始化父类成员使用的
理解：子类的构造器中，有默认的super()，需要访问父类构造器
抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类
抽象类的子类，必须重写完抽象父类中的所有抽象方法，否则子类也必须定义成抽象类
抽象类存在的意义是为了被子类继承，抽象类体现的是模板思想。
1.2接口
什么是接口？
答：1.接口是更加彻底的抽象
2.在JDK1.8之前接口中只能是抽象方法和常量
3.接口体现的是规范思想，实现接口的子类必须重写完接口的全部抽象方法
接口中抽象方法和常量特征
答：接口中的抽象方法可以省略public abstract不写，默认会加上，如：
public abstract void run() == void run()
接口中常量是可以省去public static final不写，默认会加上，如：
public static final String name = "小林" == String name = "小林"
什么是常量？
答：常量指的是变量值只有一个，且在程序运行过程中不可更改值
常量一般修饰符是：public static final
接口的定义格式
修饰符 interface 接口名称{
// 在jdk1.8之前接口中只能是抽象方法和常量
}
interface 定义接口的核心关键字
1.3接口的基本实现
口诀： 子类继承父类，实现类实现接口
- 类与类是继承关系
- 类与接口是实现关系，接口是被类实现的
- 实现接口的类称为：实现类
- 一个类实现接口必须重写完接口中的全部抽象方法，否则这个类要定义成抽象类（一个类继承抽象类，必须重写完抽象类的所有抽象方法，否则这个类要定义成抽象类）
- 类实现接口的格式：
修饰符 class 实现类名称 implements 接口1,接口2,接口3,.....{
}
implements: 类实现接口的关键字
类于类是单继承关系，类与接口是多实现关系，接口与接口是多继承关系
- 一个类只能继承一个直接父类
- 一个类可以同时实现多个接口
- 一个接口可以同时继承多个接口
- 一个类实现多个接口，必须重写完全部接口中的全部抽象方法，否则这个类要定义成抽象类
1.4JDK1.9之后(了解)
JDK1.8之前，接口中只能是抽象方法和常量
JDK1.8之后接口不再纯洁，新增了三个方法
1. 默认方法：就是实例方法
-
必须用default修饰
-
默认会加public修饰
public default void run() == default void run() -
只能用接口的实现类的对象来调用
2. 静态方法
- 可以直接加static修饰
- 默认会加public修饰
public static void run() == static void run() - 接口的静态方法只能用接口的类名称本身调用
3. 私有方法(JDK1.9开始才支持)
其实就是私有的实例方法，必须加private修饰
1.5实现多个接口的使用注意事项
1. 如果实现了多个接口，多个接口中存在同名的静态方法并不会冲突
原因是只能通过各自接口名访问静态方法
2. 当一个类，既继承了一个父类，又实现了若干个接口时，父类中成员方法和接口中的默认方法重名，子类就近选择执行父类的成员方法
3. 当一个类实现多个接口时，多个接口中存在同名的默认方法，实现类必须重写这个方法
4. 接口中，没有构造器，不能创建对象
- 接口是更彻底的抽象，连构造器都没有，自然不能创建对象！
- 构造器：初始化一个类的对象并返回引用
1.6代码块
代码块按照有无static修饰分为：静态代码块，实例代码块
静态代码块
- 必须用static修饰，属于类，会与类一起优先加载，而且自动触发执行一次！
- 静态代码块可以用于执行类的方法之前进行静态资源的初始化操作
- 格式：
static{
}
实例代码块
- 必须无static修饰，属于类的每个对象，会与类的每个对象一起加载，每次创建对象的时候，实例代码块就会触发执行一次
- 实例代码块可以用于初始化实例资源
- 实例代码块的代码实际上是提取到每个构造器中去执行的(扩展和了解)
1.7final关键字
1. final修饰类： 类不能被继承了
2. final修饰方法：方法不能被重写
3. final修饰变量：变量有且仅能被赋值一次成员变量和局部变量
-
静态成员变量： 有static修饰，属于类，只加载一份
final修饰静态成员变量，变量变成了常量 -
实例成员变量： 无static修饰，属于每个对象，与对象一起加载
-
局部变量： 在方法中，构造器中，代码块中，for循环中的变量，用完作用范围就消失了
final修饰局部变量：让值被固定或者说保护起来，执行过程中防止被修改
// 1.final修饰类
final class Animal{
}
// 2.final修饰局部变量
{
final int age = 10;
}
// 3.
1.8单例（重点！！）
什么是单例？
答：单例的意思是一个类永远只存在一个对象，不能创建多个对象
为什么要用单例？
答：开发中很多类的对象我们只需要一个，对象越多占内存越多
如何实现单例？
答：单例的实现方法目前有两种方式：
饿汉单例设计模式：通过类获取单例对象的时候，对象已经提前做好了
懒汉单例设计模式：通过类获取单例对象的时候发现没有对象才会去创建一个对象
（这里需要会手写两种单例源码！！！！！！！，在下方会有源码与步骤，面试设计模式必问！）
1.9枚举类
枚举类的作用？
答：枚举用于做信息标志和信息分类
枚举类的特点
答：
枚举类是final修饰的，不能被继承
枚举类的第一行罗列的是枚举类的对象，而且使用常量存储的
所以枚举类的第一行写的都是常量名称，默认存储了枚举对象
枚举类的构造器默认是私有的
枚举类相当于是多例设计对象
public class EnumDemo01 {
public static void main(String[] args) {
Sex s1 = Sex.BOY;
Sex s2 = Sex.GIRL;
}
}
enum Sex{
BOY,GIRL;
}
2.面试
2.1抽象类
面试题：抽象类是否有构造器，抽象类是否可以创建对象？
答：1. 抽象类作为类一定有构造器，而且抽象类必须有构造器，是提供给子类创建对象调用父类构造器使用的，除此之外，类中有的成分，抽象类都具备(成员变量，成员方法，构造器，内部类，代码块)
2. 抽象类虽然有构造器但是抽象类不能创建对象
面试题：抽象类中的构造器可以私有吗？
答：从代码编译角度，抽象类中的构造器可以私有，但是子类继承默认调用父类构造器会报错
因为私有只能在本类中使用，所以抽象类中构造器私有没有意义。
// 反证法：假如抽象类可以创建对象！
public class AbstractDemo {
public static void main(String[] args){
// Animal a = new Animal(); // 报错
// a.run();抽象方法不能执行，因为它没有方法体，所以抽象类不能创建对象
}
}
abstract class Animal{
private String name;
//默认无参构造器
public Animal(){
}
//抽象方法
public abstract void run();
//实例方法
public void test(){
}
//静态方法
public static void Addr(){
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
抽象类存在的意义
答： 1. 抽象类就是为了被子类继承(就是为了派生子类)，否则抽象类毫无意义
2.抽象类体现的是模板思想，部分实现，部分抽象，可以设计模板设计模式
理解：抽象类中已经实现的是模板中确定的成员，抽象类不确定如何实现的定义成抽象方法，交给具体的子类去实现
2.2代码块
静态代码块和实例代码块的作用？
答：静态代码块有static修饰，属于类，会与类一起优先加载，而且自动触发执行一次！静态代码块可以用于执行类的方法之前进行静态资源的初始化操作
实例代码块无static修饰，属于类的对象，会与类的每个对象一起加载，每次创建对象的时候，实例代码块就会触发执行一次，实例代码块可以用于初始化实例资源
2.3final，abstract关键字
请问abstract和final的关系是什么？
答：互斥关系，不能同时出现修饰成员！
abstract 修饰类，类是抽象类，必须被继承
final 修饰类，类不能被继承
abstract 修饰方法，方法必须被重写
final 修饰方法，方法不能被重写
2.4变量
变量有几种？
答：成员变量和局部变量
-
静态成员变量： 有static修饰，属于类，只加载一份
-
实例成员变量： 无static修饰，属于每个对象，与对象一起加载
-
局部变量： 只在方法中，构造器中，代码块中，for循环中，用完作用范围就消失了
-
final修饰局部变量：让值被固定或者说保护起来，执行过程中防止被修改
2.5写一个饿汉单例设计模式
饿汉单例设计模式：通过类获取单例对象的时候，对象已经提前做好了
步骤：
- 定义一个单例类
- 把类的构造器私有
- 定义一个静态成员变量用于存储一个对象！(饿汉单例在返回对象的时候，对象要已经做好)
- 定义一个方法返回单例对象
// 定义一个单例类
class SingleInstance01{
// 2.定义一个静态成员变量用于存储一个对象
public static SingleInstance01 ins = new SingleInstance01();
// 1.把类的构造器私有，构造器只能在本类中访问
// 私有的无参构造器
private SingleInstance01(){
}
// 3.提供一个方法返回单例对象
public static SingleInstance01 getInstance(){
return ins;
}
}
2.6写一个懒汉单例设计模式
懒汉单例模式：通过类获取单例对象的时候发现没有对象才回去创建一个对象
步骤：
- 定义一个单例类
- 把类的构造器私有
- 定义一个静态成员变量用于存储一个对象(懒汉单例不能直接创建对象，必须需要的时候才去创建)
- 定义一个方法返回单例对象，判断对象不存在才创建一次，存在直接返回
// 定义一个单例类
class SingleInstance2{
//定义一个静态成员变量用于存储一个对象！
public static SingleInstance2 ins;
// 1.把类的构造器私有
private SingleInstance2(){
}
// 3.通过方法返回一个对象，第一次不存在对象才创建一个返回
public static SingleInstance2 getInstance(){
if(ins == null){
//第一次来取对象，创建一个对象
ins = new SingleInstance2();
}
return ins;
}
}
博客源于
https://blog.csdn.net/Augenstern_QXL/article/details/116209487