基础知识复习（以前抄的一篇博客的，忘记链接。如果原作者看到可以联系我给你添加链接）
基础知识复习
1. java跨平台的原理
- 什么是平台
把CPU处理器和操作系统的整体叫平台 - java跨平台原理
java虚拟机JVM将java文件编译成字节码文件（即.class文件），然后运行到不同的平台，对应的系统会将字节码文件转换成对应平台的对应机器码，产生可执行性文件。
2. 排序算法
- 冒泡排序
public static void main(String[] args) {
/**
* 用于实现冒泡排序
* N个数字两两比较较小的放在前面，最后会将最大的数字放到末尾。
* N-1次循环每次都将把数组中的最大值找出
*
* 时间复杂度为：O（n*2）
* 升序
*/
int[] array = {25,7,14,4,8,1,24,5,9,2,22};
for(int i = 0;i<array.length - 1;i++){
// 循环N-1次
for(int j = 0;j < array.length - 1 - i;j++){
if(array[j] > array[j + 1]){
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
for (int item: array) {
System.out.println(item);
}
}
- 比较排序
public static void main(String[] args) {
/**
* 用于实现比较排序
* 每次循环都会将最小的一个放在前面，和冒泡不同的是不会进行相邻的两两比较，比较的对象都是要确定数字的那个位置。
* Math.random() 返回【0-1）的浮点数
* 时间复杂度O（n*2）
*/
int[] array = new int[20];
for(int i = 0;i < 20;i++){
array[i] = (int)(Math.random()*100 + 1);
System.out.print(array[i] + "");
if(i%5 == 4){
System.out.println();
}
}
for (int i = 0;i < array.length - 1;i++){
// 循环N-1次，说明最后剩一个不用再比较了。i还表示要将哪一个索引下的值替换掉
for (int j = i + 1;j < array.length;j++){
if(array[j] < array[i]){
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
}
}
for (int item:array) {
System.out.print(item + " ");
}
}
- 插入排序
public static void main(String[] args) {
/**
* 插入排序
* 准备两个数组一个存放已经排好序的数据，一个存放要插入的数据(用一个数组也可以实现)
* 从要插入数组中取出一个值，和已经排序好的数据从小到大一一比较，如果比原来的小，就插入原来的位置，将原来的数据和
* 他后面的数据整体后移一位
*
* 时间复杂度O（n*2）
*/
// 原数组
int[] array = new int[20];
for (int i = 0; i < array.length; i++) {
array[i] = (int) (Math.random() * 100 + 1);
System.out.print(array[i] + " ");
}
for (int i = 1; i < array.length; i++) {
for (int j = 0; j < i; j++) {
if(array[i] <array[j]){
int tmp = array[j];
array[j] = array[i];
array[i] = tmp;
}
}
}
for (int item:array) {
System.out.print(item + " ");
}
}
3. for、while、do-while的区别
- 共同点
都是用循环结构来控制语句 - 区别
for和while都是先判断条件再执行语句，而do-while则是先执行语句再判断条件，所以do-while至少会被执行一次。for适用于已经明确要循环多少次的情况，while适合不明确循环次数的情况。
4. continue，break，return的异同
- 共同点
都可以用于跳出循环结构。 - 不同点
continue是跳出当前循环，进入下次的循环。break则是跳出循环，不再进行循环。return结束方法，并返回该方法要返回的数据。
5. ==与equals方法的异同
- 相同点
都是用于比较操作，基本数据类型都可以用==来比较数值，string类型小于127也可以 - 不同点
通常==是用于比较两个引用类型数据的地址，而equals则是用来比较数值。equals是Object类的一个方法，如果引用类型数据没有重写该方法那么还是比较的地址（String 已经重写）。
6. 封装
- 封装的作用
封装是面向对象的三大特性之一，并且有利于数据的安全性 - 封装的实现步骤
私有化属性，一般成员变量都是用private修饰，然后通过生成的getter和setter来进行数据的访问和设置。
JavaBean将字段封装成对象
7. 继承
- 继承的作用
继承就是子类继承父类的特征和行为，使用extends关键字。使用继承可以降低代码的冗余性，但是会提高耦合性。 - 子类能从父类继承什么
子类可以继承父类中除了构造函数之外的所有属性和方法，但是当成员和方法用private修饰的时候，子类是不能够使用的。 - java支持单继承，但是可以多重继承（即一个子类可以只可以有一个父类，但是可以有多个子类，和孙子类）
8. 多态
- 多态的作用
多态是同一个行为具有不同表现形式或形态的能力，消除类型之间的耦合性，增强代码的可替换性和可扩展性。 - 实现多态的前提
继承和实现，方法重写（向上，向下转型） - 使用方式
父类作为方法的参数或者返回值。
9. 方法重载和方法重写的异同
- 相同点
- 方法名相同
- 都提高了方法的适用范围和灵活性
- 不同点
- 出现的位置不同：重载出现在本类，重写出现在子类中
- 访问修饰符不同：重载和访问修饰符无关，重写的方法不能严于父类，即若父类的访问修饰符为protect则子类只能是protect或者public
- 返回值类型：重载无关，重写必须和父类相同
- 参数列表的数据类型或数量：重载不同，重写完全和父类一样或者是其子类类型
- 重写不能抛出比父类更多的异常，只能跑出和父类一样或者子类异常
10. 抽象类和接口的异同
- 相同点
- 都可以包含抽象方法
- 都不能实例化，即不可以用来创建对象
- 不同点
- 关键字不同：抽象类abstract，接口interface
- 属性要求不同：接口必须用public static final 修饰，且创建时必须赋值，以后不允许更改，常量必须大写。
- 方法：抽象类可以有非抽象方法，接口必须是public abstract
- 构造方法：抽象类有构造方法，接口没有
- 使用：抽象类只可以单根继承，接口可以多继承多实现。
11. final、finally、finalize的区别
- final :可以修饰类，成员，方法，变量（局部和全局），如果修饰类则表明该类永远不能被继承，修饰方法则该方法不能被重写，修饰属性时表明不可更改，是一个常量。全局变量有默认值，局部变量可以先声明在赋值（只可以赋值一次，以后不能更改）。
- finally :是异常处理时的一个关键字，try、catch、finally，finally中的方法，无论如何最终都会执行，除了使用system.exit(0)
- finalize:用于垃圾回收，类似于C++中的析构函数
12. 在java中如何最有效率的将8变成2
使用位运算完成
左移<< 右移>> 按位与& 按位或| 按位异或^ 按位非~
8 二进制1000 右移两位10 8>>2=2
13. this和super的异同
- 相同
都是用来调用属性和方法 - 不同
调用的类不同，this调用当前类，super调用父类
this可以代表当前对象，super不可以。
14. java异常处理机制
- error：程序错误，不可预见的逻辑错误。 Exception：程序异常错误，可以预见可以通过try和catch获取
try{
// 可能出现异常的语句
}catch(Exception e){
// 捕获异常并进行相应的操作
}finally{
// 无论如何最后都要执行的语句，处理System.exit(0)
}
- throw和throws
throw用于方法内部，throws用于方法上。
15. java的常见特性
- 面向对象
- 异常处理
- 垃圾回收
- 多线程
16. ArrayList与LinkedList的异同
- 相同
都属于List接口的实现类，都实现了List中的常用方法。都是有序的不唯一集合（有序：存入和取出的顺序一致，不唯一：同一个集合中的数据可以相同，不是唯一的） - 不同
ArrayList是用数组实现的，查询快删除和插入慢。LinkedList使用链表实现，所以删除和插入快，查询慢。
17. ArrayList与Vetor的异同
- 线程安全
Vetor是线程安全的，ArraryList是线程不安全的 - 执行效率
线程不安全的ArrayList执行效率高 - 扩容
vector扩容时会扩容一倍，ArrayList扩容50%，所以ArrayList更剩空间
18. HashMap与HashTable的区别
- 线程安全
HashMap线程不安全，HashTable线程安全
19. String、StringBuffer、StringBuilder的异同
- 相同点
都是用来存储字符串的 - 不同点
String不可变，另外两个都可以改变
StringBuilder是线程安全的，其他两个都不安全
StringBuilder的执行效率比StringBuffer的执行效率低
20. 反射
- 反射是什么
反射是一种半动态的代码加载和运行机制，在JVM第一次加载字节码（.class文件时），如果发现了未知的未经编译的信息，则会将位置信息和字节码文件返回给编译器，由编译器对未知信息进行二次编译，然后交由jvm翻译运行。 - 获取class对象的方式
类名.class
对象名.getClass
Class.forName()字符串
21. 序列化
- 作用
解决互联网传输时，20%平均损失率问题，保证数据完整性 - 如何实现序列化
在实体类中实现Serialable接口，然后使用ObjectOutPutStream
22. 线程的生命周期
创建（new）–>就绪（runnable）–>运行（running）–>阻塞（blocked)–>等待（waiting）–>消亡（dead）
23.线程的调度
- 优先级：setPriority
- sleep(毫秒)：调用该方法的线程将会被阻塞，但是不会释放资源
- join():在线程A中调用B.join()，那么A阻塞等待B执行完再继续执行。常用语Main线程等待子进程执行完成。
- yield（）：如果线程A.yield(),那么A线程就会放弃资源，转换到就绪状态
- wait():A.wait()线程A释放资源，并进入阻塞状态等待别的线程notify
24. 程序开发的数据安全（线程锁、线程安全）
- 造成的原因：多个线程访问同一个数据，并且对数据做出了一定的更改
- 线程同步方式：
Synchronized同步方法
Synchronized同步代码块
volatie关键字：声明域对象
创建重入锁对象，创建方式lock、unlock
使用ThreadLocal声明局部变量
25. 线程死锁
产生死锁的四个条件
- 互斥使用：A和B不可以同时访问同一个资源
- 不可抢占：不能根据优先级而抢夺线程的资源
- 请求和保持：保持自己已经请求到的资源，请求没有的资源。处于阻塞等待状态，并且不释放自己的资源。
- 循环等待：请求和保持的线程形成了一个封闭的环路
26. TCP
27. Socket
28. XML的常见解析方式
29. 单例-懒汉
package com.singleton;
/**
* 单例：通过特殊的编码格式，
* 保证该类的实例在一次程序运行过程中只有一个
* 懒汉式
*/
public class Lazy {
// 声明私有的静态属性，类型为本类类型
private static Lazy lazy;
private Lazy(){}
// 声明一个公共的取类实例静态方法，并实现同步.同一时刻只能有一个线程访问该方法
public synchronized static Lazy getInstance(){
if(lazy == null){
lazy = new Lazy();
}
return lazy;
}
}
30. 单例-饿汉
package com.singleton;
/**
* 饿汉
*/
public class Hungry {
private static Hungry hungry = new Hungry();
private Hungry(){}
public synchronized static Hungry getInstance() {
return hungry;
}
}
31. 单例-双重锁
package com.singleton;
public class DoubleLock {
/**
* 单例双重锁
*/
// 隐藏默认构造函数，通过隐藏构造函数可以使得无法通过构造函数来获取对象
private DoubleLock(){}
private volatile static DoubleLock doubleLock;
public static DoubleLock getInstance(){
if(doubleLock == null){
synchronized (DoubleLock.class){
doubleLock = new DoubleLock();
}
}
return doubleLock;
}
}
32. 写出5种java常见的设计模式（常规共23种）
- 单例模式
- 工厂模式
- 观察者模式
- 迭代器模式
- 代理模式
- 适配器模式
- 监听模式
33. ++和–
int a = 0;
for(int i = 0; i < 6; i++){
//实际：1
a = a++;
//运算：0
System.out.print(a);
}
输出的是6个0，因为每一次参与运算的a都是0
34. &和&&
&不会短路，而&&会短路。如果是A && B，那么如果A=false，那么结果为false并且B不会执行。
如果是A & B，若A=false，则结果为false，但是B还是会被执行。
int a1 = 7,
a2 = 7,
b1 = 8,
b2 = 8;
boolean flag1 = a1++ > b1-- & a1++ > b1++;
boolean flag2 = a2++ > b2-- && a2++ > b2++;
a1, b1, a2, b2和flag1和flag2的值
结果是：a1=9，b1=8，flag1=false
a2=8，b2=7，flag1=false
35. 标识符、变量
- 数字、字母(大小写)、下划线、$（64个）
- 数字不能放在开头，
- 不能使用关键字
- 不能使用保留字 goto、const
- 驼峰命名
36. API
application programing interface
37. java中48个关键字和2个保留字
- 关键字
abstract assert boolean break byte case
catch char class continue default do
double else enum extends final finally
float for if implements import int
interface instanceof long native new package
private protected public return short static
strictfp super switch synchronized this throw
throws transient try void volatile while
- 保留字
goto const