总结个人版

一、java基础

1、面向对象

什么是面向对象？
对比面向过程，是两种不同的处理问题的角度
面向过程更注重事情的每一个步骤及顺序，面向对象更注重事情有哪些参与者（对象）、及各自需要做什么
比如：洗衣机洗衣服
面向过程会将任务拆解成一系列的步骤（函数），1、打开洗衣机----->2、放衣服----->3、放洗衣粉-----
>4、清洗----->5、烘干
面向对象会拆出人和洗衣机两个对象：
人：打开洗衣机 放衣服 放洗衣粉
洗衣机：清洗 烘干
从以上例子能看出，面向过程比较直接高效，而面向对象更易于复用、扩展和维护

面向对象
封装：封装的意义，在于明确标识出允许外部使用的所有成员函数和数据项
内部细节对外部调用透明，外部调用无需修改或者关心内部实现
1、javabean的属性私有，提供getset对外访问，因为属性的赋值或者获取逻辑只能由javabean本身决
定。而不能由外部胡乱修改

private String name;
public void setName(String name){
this.name = "tuling_"+name;
} 该name有自己的命名规则，明显不能由外部直接赋值

2、orm框架
操作数据库，我们不需要关心链接是如何建立的、sql是如何执行的，只需要引入mybatis，调方法即可

继承：继承基类的方法，并做出自己的改变和/或扩展
子类共性的方法或者属性直接使用父类的，而不需要自己再定义，只需扩展自己个性化的

多态：基于对象所属类的不同，外部对同一个方法的调用，实际执行的逻辑不同。
继承，方法重写，父类引用指向子类对象

父类类型 变量名 = new 子类对象 ;
变量名.方法名();

弊端：无法调用子类特有的功能

2、Java语言有哪些特点

1. 安全、可靠
2. 平台无关性（一次编译，到处运行）
3. 支持多线程
4. 面向对象
5. 编译与解释并存
6. 简单易学

3、java与C++的区别

相同：

• 都是面向对象的语言，都具有继承、封装和多态的特点

不同：

• Java没有指针相关操作，比c++相对简单安全；
• java对内存有自动管理机制，而c++需要手动进行关闭清理
• Java只能单继承，而c++能够多继承

4、JDK JRE JVM

JDK：
Java Develpment Kit java 开发工具
JRE：
Java Runtime Environment java运行时环境
JVM：
java Virtual Machine java 虚拟机

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NUiiYRo2-1637023656088)(C:\Users\xiaoting\AppData\Roaming\Typora\typora-user-images\image-20211101193536931.png)]

5、字符型常量和字符串常量的区别

形式上：

• 字符型常量用单引号，字符串常量用双引号

内存上：

• 字符型常量占用两个字节，字符串常量占多个字节码，随长度而变

计算上：

• 字符型常量可以看作一个整型ASCAII码，直接参与运算，而字符串常量不行

6、自动装箱和拆箱

装箱：基本类型转换相应的引用类型的过程叫装箱

int - > Integer char - > Character 剩下的都是首字母写成大写

拆箱：引用类型转换基本类型的过程

7、==和equals比较

== 对比的是栈中的值，基本数据类型是变量值，引用类型是堆中内存对象的地址
equals：object中默认也是采用==比较，通常会重写
Object

public boolean equals(Object obj) {
return (this == obj);
}

String

public boolean equals(Object anObject) {
	if (this == anObject) {
		return true;
	} if (anObject instanceof String) {
		String anotherString = (String)anObject;
		int n = value.length;
		if (n == anotherString.value.length) {
			char v1[] = value;
			char v2[] = anotherString.value;
			int i = 0;
			while (n-- != 0) {
				if (v1[i] != v2[i])
				return false;
				i++;
			} return true;
		}
	} return false;
} 

上述代码可以看出，String类中被复写的equals()方法其实是比较两个字符串的内容。

public class StringDemo {
	public static void main(String args[]) {
		String str1 = "Hello";
		String str2 = new String("Hello");
		String str3 = str2; // 引用传递
        System.out.println(str1 == str2); // false
        System.out.println(str1 == str3); // false
        System.out.println(str2 == str3); // true
        System.out.println(str1.equals(str2)); // true
        System.out.println(str1.equals(str3)); // true
        System.out.println(str2.equals(str3)); // true
	}
}

8、hashCode与equals

hashCode介绍：
hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是
确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中，Java中的任何类都包含有
hashCode() 函数。
散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用
到了散列码！（可以快速找到所需要的对象）

为什么要有hashCode：
以“HashSet如何检查重复”为例子来说明为什么要有hashCode：
对象加入HashSet时，HashSet会先计算对象的hashcode值来判断对象加入的位置，看该位置是否有
值，如果没有、HashSet会假设对象没有重复出现。但是如果发现有值，这时会调用equals（）方法来
检查两个对象是否真的相同。如果两者相同，HashSet就不会让其加入操作成功。如果不同的话，就会
重新散列到其他位置。这样就大大减少了equals的次数，相应就大大提高了执行速度。

• 如果两个对象相等，则hashcode一定也是相同的
• 两个对象相等,对两个对象分别调用equals方法都返回true
• 两个对象有相同的hashcode值，它们也不一定是相等的
• 因此，equals方法被覆盖过，则hashCode方法也必须被覆盖
• hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode()，则该class的两个
  对象无论如何都不会相等（即使这两个对象指向相同的数据）

9、final

final 类不能被继承，所有成员方法都会被隐式地指定为 final 方法，final 方法不能被重写。

final 变量表示常量，只能被赋值一次，赋值后值不再改变。

修饰基本数据类型时，该值在初始化后不能改变。
修饰引用类型时，引用指向的对象在初始化后不能改变，但该对象的内容可以发生变化。

内存语义

编译器会在 final 域的写后，构造方法的 return 前插入一个 Store Store 屏障，确保对象引用为任意线程可见前其 final 域已初始化。
编译器在读 final 域操作的前面插入一个 Load Load 屏障，确保在读一个对象的 final 域前一定会先读包含这个 final 域的对象引用。

最终的

• 修饰类：表示类不可被继承
• 修饰方法：表示方法不可被子类覆盖，但是可以重载
• 修饰变量：表示变量一旦被赋值就不可以更改它的值。

（1）修饰成员变量

• 如果final修饰的是类变量，只能在静态初始化块中指定初始值或者声明该类变量时指定初始值。
• 如果final修饰的是成员变量，可以在非静态初始化块、声明该变量或者构造器中执行初始值。

（2）修饰局部变量
系统不会为局部变量进行初始化，局部变量必须由程序员显示初始化。因此使用final修饰局部变量时，
即可以在定义时指定默认值（后面的代码不能对变量再赋值），也可以不指定默认值，而在后面的代码
中对final变量赋初值（仅一次）

public class FinalVar {
	final static int a = 0;//类变量：再声明的时候就需要赋值 或者静态代码块赋值
    /**
    static{
    a = 0;
    } *
    /
	final int b = 0;//再声明的时候就需要赋值 或者代码块中赋值 或者构造器赋值
	/*{
    b = 0;
    }*/
	public static void main(String[] args) {
		final int localA; //局部变量只声明没有初始化，不会报错,与final无关。
		localA = 0;//在使用之前一定要赋值
		//localA = 1; 但是不允许第二次赋值
	}
}

（3）修饰基本类型数据和引用类型数据

• 如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；
• 如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。但是引用的值是可变的。

public class FinalReferenceTest{
    public static void main(){
        final int[] iArr={1,2,3,4};
        iArr[2]=-3;//合法
        iArr=null;//非法，对iArr不能重新赋值
        final Person p = new Person(25);
        p.setAge(24);//合法
        p=null;//非法
    }
}

为什么局部内部类和匿名内部类只能访问局部final变量？
编译之后会生成两个class文件，Test.class Test1.class

public class Test {
    public static void main(String[] args) {
    } 
    //局部final变量a,b
	public void test(final int b) {//jdk8在这里做了优化, 不用写,但实际上也是有的，也不能修改
        final int a = 10;
        //匿名内部类
        new Thread(){
            public void run() {
                System.out.println(a);
                System.out.println(b);
            };
        }.start();
	}
} 
class OutClass {
    private int age = 12;
    public void outPrint(final int x) {
            class InClass {
                public void InPrint() {
                    System.out.println(x);
                    System.out.println(age);
                }
        	} new InClass().InPrint();
    }
}

首先需要知道的一点是: 内部类和外部类是处于同一个级别的，内部类不会因为定义在方法中就会随着
方法的执行完毕就被销毁。

这里就会产生问题：当外部类的方法结束时，局部变量就会被销毁了，但是内部类对象可能还存在(只有
没有人再引用它时，才会死亡)。这里就出现了一个矛盾：内部类对象访问了一个不存在的变量。为了解
决这个问题，就将局部变量复制了一份作为内部类的成员变量，这样当局部变量死亡后，内部类仍可以
访问它，实际访问的是局部变量的"copy"。这样就好像延长了局部变量的生命周期

将局部变量复制为内部类的成员变量时，必须保证这两个变量是一样的，也就是如果我们在内部类中修
改了成员变量，方法中的局部变量也得跟着改变，怎么解决问题呢？

就将局部变量设置为final，对它初始化后，我就不让你再去修改这个变量，就保证了内部类的成员变量
和方法的局部变量的一致性。这实际上也是一种妥协。使得局部变量与内部类内建立的拷贝保持一致。

10、String、StringBuffer、StringBuilder

String是final修饰的，不可变，每次操作都会产生新的String对象
StringBuffer和StringBuilder都是在原对象上操作
StringBuffer是线程安全的，StringBuilder线程不安全的
StringBuffer方法都是synchronized修饰的
性能：StringBuilder > StringBuffer > String

场景：经常需要改变字符串内容时使用后面两个
优先使用StringBuilder，多线程使用共享变量时使用StringBuffer

11、重载和重写的区别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MtxKeHvL-1637023656092)(file://C:\Users\xiaoting\Desktop%E5%BD%93%E5%89%8D%E9%A2%98%E7%9B%AE%E5%92%8C%E7%AD%94%E6%A1%88\images%E9%87%8D%E8%BD%BD%E5%92%8C%E9%87%8D%E5%86%99%E7%9A%84%E5%8C%BA%E5%88%AB.png?lastModify=1636424981)]

重载： 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问
修饰符可以不同，发生在编译时。
重写： 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于
等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为private则子类就不能重写该方
法。

public int add(int a,String b)
public String add(int a,String b)
//编译报错

12、接口和抽象类的区别

• 抽象类可以存在普通成员函数，而接口中只能存在public abstract 方法。
• 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的。
• 抽象类只能继承一个，接口可以实现多个。

接口的设计目的，是对类的行为进行约束（更准确的说是一种“有”约束，因为接口不能规定类不可以有什么行为），也就是提供一种机制，可以强制要求不同的类具有相同的行为。它只约束了行为的有无，但不对如何实现行为进行限制。

而抽象类的设计目的，是代码复用。当不同的类具有某些相同的行为(记为行为集合A)，且其中一部分行为的实现方式一致时（A的非真子集，记为B），可以让这些类都派生于一个抽象类。在这个抽象类中实现了B，避免让所有的子类来实现B，这就达到了代码复用的目的。而A减B的部分，留给各个子类自己实现。正是因为A-B在这里没有实现，所以抽象类不允许实例化出来（否则当调用到A-B时，无法执行）。

抽象类是对类本质的抽象，表达的是 is a 的关系，比如： BMW is a Car 。抽象类包含并实现子类的通用特性，将子类存在差异化的特性进行抽象，交由子类去实现。
而接口是对行为的抽象，表达的是 like a 的关系。比如： Bird like a Aircraft （像飞行器一样可以飞）但其本质上 is a Bird 。接口的核心是定义行为，即实现类可以做什么，至于实现类主体是谁、是如何实现的，接口并不关心。

使用场景：当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。

抽象类的功能要远超过接口，但是，定义抽象类的代价高。因为高级语言来说（从实际设计上来说也是）每个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度

13、Object 有哪些方法

• equals | 检测对象是否相等，默认使用 == 比较，可以重写该方法自定义规则。
• hashCode | 每个对象都有默认散列码，值由对象存储地址得出。字符串散列码由内容导出，值可能相同。
• toString | 默认打印表示对象值的一个字符串。
• clone | 默认声明为 protected，只能由本类对象调用，且是浅拷贝。一般重写 clone 方法需要实现 Cloneable 接口并声明为 public，如果没有实现 Cloneable 接口会抛出 CloneNotSupport 异常。
• finalize | GC 判断垃圾时，如果对象没有与 GC Roots 相连会被第一次标记，之后判断对象是否有必要执行 finalize 方法，有必要则由一条低调度优先级的 Finalizer 线程执行。虚拟机会触发该方法但不保证结束，防止方法执行缓慢或发生死循环。只要对象在 finalize 方法中重新与引用链相连，就会在第二次标记时移出回收集合。由于运行代价高且具有不确定性，在 JDK9 标记为过时方法。
• getClass | 返回对象所属类的 Class 对象。
• wait | 阻塞持有该对象锁的线程。
• notify | 唤醒持有该对象锁的线程，notify 随机唤醒一个线程，notifyAll | 唤醒全部线程

14、String有哪些方法

15、什么是字节码？采用字节码的好处是什么？

java中的编译器和解释器：
Java中引入了虚拟机的概念，即在机器和编译程序之间加入了一层抽象的虚拟的机器。这台虚拟的机器在任何平台上都提供给编译程序一个的共同的接口。
编译程序只需要面向虚拟机，生成虚拟机能够理解的代码，然后由解释器来将虚拟机代码转换为特定系统的机器码执行。在Java中，这种供虚拟机理解的代码叫做 字节码（即扩展名为 .class的文件），它不面向任何特定的处理器，只面向虚拟机。
每一种平台的解释器是不同的，但是实现的虚拟机是相同的。Java源程序经过编译器编译后变成字节码，字节码由虚拟机解释执行，虚拟机将每一条要执行的字节码送给解释器，解释器将其翻译成特定机器上的机器码，然后在特定的机器上运行。这也就是解释了Java的编译与解释并存的特点。
Java源代码---->编译器---->jvm可执行的Java字节码(即虚拟指令)---->jvm---->jvm中解释器----->机器可执行的二进制机器码---->程序运行。
采用字节码的好处：
Java语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以Java程序运行时比较高效，而且，由于字节码并不专对一种特定的机器，因此，Java程序无须重新编译便可在多种不同的计算机上运行。

16、Java类加载器

JDK自带有三个类加载器：bootstrap ClassLoader、ExtClassLoader、AppClassLoader。
BootStrapClassLoader是ExtClassLoader的父类加载器，默认负责加载%JAVA_HOME%lib下的jar包和class文件。
ExtClassLoader是AppClassLoader的父类加载器，负责加载%JAVA_HOME%/lib/ext文件夹下的jar包和class类。
AppClassLoader是自定义类加载器的父类，负责加载classpath下的类文件。系统类加载器，线程上下文加载器
继承ClassLoader实现自定义类加载器

17、双亲委托模型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q905DSl2-1637023656101)(C:\Users\xiaoting\AppData\Roaming\Typora\typora-user-images\image-20211101202656414.png)]

双亲委派模型的好处：

• 主要是为了安全性，避免用户自己编写的类动态替换 Java的一些核心类，比如 String。
• 同时也避免了类的重复加载，因为 JVM中区分不同类，不仅仅是根据类名，相同的 class文件被不
  同的 ClassLoader加载就是不同的两个类

18、泛型和泛型擦除

泛型本质是参数化类型，解决不确定对象具体类型的问题。

泛型的好处：① 类型安全，不存在 ClassCastException。② 提升可读性，编码阶段就显式知道泛型集合、泛型方法等处理的数据类型。

泛型用于编译阶段，编译后的字节码文件不包含泛型类型信息，因为虚拟机没有泛型类型对象，所有对象都属于普通类。例如定义 List