JAVA基础知识汇总及常见面试题

只包含 JAVA基础部分的知识点，可能不全面。

知识点涉及到：JAVA基础、循环、分支、面向对象、封装继承多态、集合、数组、异常等基础内容，不包含IO，线程，网络通信等。

废话不说，直接上干货！

1 为什么java是半编译半解释性的语言，为什么java可以跨平台?
1）因为Java语言是先由java编译器将源文件编译成计算机无法读懂的.class字节码文件，进而用JVM将字节码文件解释成计算机能读懂的机器码文件，故java是半编译半解释性的语言。
2）因为JVM来自不同平台，不同平台的JVM将字节码文件解释给所在的平台可以看懂的机器码文件，以达成java可以跨平台的特点。
2 能进行简单的进制计算，了解编码（计算机存储的是补码）
2.1 进制
2.2 编码
? 能进行简单的进制计算，了解编码（计算机存储的是补码）
? 计算机中的符号数有三种表示方法，即原码、反码和补码；
? 三种表示方法均有符号位和数值位两部分，符号位都是用0表示“正”，用1表示“负”，而数值位，三种表示方法各不相同；
? 原码：符号位加上真值的绝对值，即用第一位表示符号，其余位表示值。
? 反码：正数的反码是其本身；负数的反码是在其原码的基础上, 符号位不变，其余各个位取反.
? 补码：正数的补码就是其本身；负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)
3 简述Java的三个版本
3.1 JavaSE（Java Standard Edition）:Java标准版 ，是其他版本的核心基础，能用于开发桌面应用系统
3.2 JavaEE（Java Enterprise Edition）：Java企业版， 用于开发企业级应用
3.3 JavaME（Java Micro Edition）：Java微型版 ，可以用于嵌入式设备系统
4 解释jvm，jdk，jre，并简述它们的关系
4.1 JVM（Java Virtual Machine）称为Java虚拟机，在Java平台中有着举足轻重的地位；
4.2 JDK是Java开发工具包（Java Development Kit）的简称，是一个软件； 如果要用Java语言编写程序，就必须在计算机上安装JDK；
4.3 JRE是Java运行环境（Java Runtime Environment）的简称 ；如果要在机器上运行Java程序，就必须要有JRE；
4.4 Jdk包含java开发，编程等工具以及jre ; jre包含了今本类库以及jvm
5 能配置JDK环境变量
5.1 path值增加： C:\Program Files (x86)\Java\jdk1.7.0_79\bin;
5.2 classpath值加：.;%java_home%\lib\dt.jar;%java_home%\lib
\tools.jar;%java_home%\jre\lib\rt.jar;【.表示当前路径】
5.3 设置了path路径，就能够使用JDK提供的工具，工具都位于bin目录；
;%java_home%\bin;
5.4 设置了classpath路径，就能够运行classpath下的.class文件，后续将具体使用；
6 简述java的三种注释
6.1 单行注释：将所在行注释符号//后面的内容注释掉，编译后内容会被丢弃
6.2 多行注释：/…/，将注释符号内部的内容注释掉，编译后内容会被丢弃
6.3 文档注释：
/**

• 注释内容，通常书写成这样的格式，中间行的*起到美观和
• 起到美观和提醒注释范围的作用，对java运行的结构进行
• 说明，编译后内容不会被丢弃
  */
  第二章 变量、据类型、运算符
  1.变量和常量的使用
  局部变量（方法内定义的变量）必须先赋值再使用，否则报编译错误； 而常量（final修饰）只能赋一次值。
  2.八个基本数据类型和对应包装类型
  类型 长度 表示范围 包装类型
  byte 8位 1字节 -27~27-1 Byte
  short 16位 2字节 -215~215-1 Short
  int 32位 4字节 -231~231-1 Integer
  long 64位 8字节 -263~263-1 Long
  float 32位 4字节 -3.403E38～3.403E38 Float
  double 64位 8字节 -1.798E308～1.798E308 Double
  char 16位 2字节 表示一个字符，如(‘a’) Character
  boolean 8位 1字节 只有两个值true与false Boolean

3. 自增和自减运算符（++、－－）
   单目运算符++和–，可以放置到变量的前和后，称为先加和后加 。
   ++a：先对a进行自增1，再对自增后的a做其他运算
   a++：先对a进行其他运算，再对a进行自增1
   int a=10;
   int b;
   b = a++;//后加，b值为10，a值为11
   b = ++a;//先加，b值为12，a值为12

4. 运算符的优先级
   （ ）小括号最高，[ ]中括号其次，=赋值最低
   单目>双目>三目
   双目：算术>关系>位>逻辑
   逻辑：&& > ||
   左移位<<：1左移几位，就相当于2的几次幂
   右移位>>
   第三章、流程控制语句
   1、for，while，do while 三种循环的区别
   for，while 循环，先判断再执行，可能一次都不执行
   do while 先执行再判断，至少执行一次
   for循环适用于次数可知的
   while，do while循环适用于次数不可知的
   2、if switch 区别
   swich使用必须是多支路等值判断，具有贯穿性，可能多个支路都被执行
   if只能有一个支路被执行
   switch 1.5之前支持 int，short，char，byte
   1.5之后新增enum（枚举）
   1.7之后String
   3、break continue 区别
   break直接跳出循环
   continue跳出当次循环继续下一次循环
   第四章、数组总结
   1.一维数组定义的三种方式：第一种：数组元素类型[ ] 变量名称= new 数组元素类型[数组长度];

                      第二种：数组元素类型[ ] 变量名称= new 数组元素类型[]{用逗号隔开元素的具体值};
   
                      第三种：数组元素类型[ ] 变量名称= {用逗号隔开元素的具体值};
   

2.数组的特性：（1）在内存中连续排布，读取速度快，查找效率高；
（2）创建时确定长度，一经确定，长度不能更改；
（3）一旦有增删操作，效率大幅降低。

3.数组元素下标的范围是：0—数组长度-1。

4.二维数组：每个元素都是一维数组构成的集合，称为二维数组。
定义的三种方式：（1）指定一维、二维长度： 数组元素类型[ ][ ] 变量名称=new 数组元素类型[一维长度] [二维长度];
（2）指定一维，不指定二维： 数组元素类型[ ][ ] 变量名称=new 数组元素类型[一维长度] [];
（3）不指定长度，有｛｝内容确定： 数组元素类型[ ][ ] 变量名称=new 数组元素类型[] [] {{ , , },{ , },{ , , }};

5.数组是有默认值的，如果为基本类型，默认值为0或false；如果为引用类型，默认值为null。

6.冒泡排序：例：将数组{1,6,4,9,3,2,5}冒泡排序。
package chap4;

public class DemoSort {

public static void main(String[] args) {
	int[] arr = new int[]{1,6,4,9,3,2,5};
	for(int i=0; i<arr.length-1; i++){
		boolean isEnd = true;
		for(int j=0; j<arr.length-1-i; j++){
			if(arr[j]>arr[j+1]){
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
				isEnd = false;
			}
		}
		if(isEnd){
			break;
		}
	}
	for(int num : arr){
		System.out.println(num);
	}
}

}

				第五章、String字符串总结

字符串：

1.String StringBuffer StringBulider 的区别
A：赋值的区别：String可以像基本变量一样赋值，StringBuffer StringBulider 必须使用NEW关键字，
B：String所有操作都要生成副本，其本身不可变，因为String中的字符存在常量区 StringBulider本身可变，
StringBuffer StringBulider具有相同的API ,StringBulider被设计用作 StringBuffer 的一个简易替换，不具有线程安全性

2.常见API需要记背
static String valueOf(boolean b)
返回 boolean 参数的字符串表示形式。

String concat(String str)
将指定字符串连接到此字符串的结尾。
length()
返回此字符串的长度。
boolean equals(Object anObject)
将此字符串与指定的对象比较。
String toUpperCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
String toLowerCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
char[] toCharArray()
将此字符串转换为一个新的字符数组。

String trim()
返回字符串的副本，忽略前导空白和尾部空白。
String substring(int beginIndex)
返回一个新的字符串，它是此字符串的一个子字符串。
String substring(int beginIndex, int endIndex)
返回一个新字符串，它是此字符串的一个子字符串。
String replace(char oldChar, char newChar)
返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String[] split(String regex)
根据给定正则表达式的匹配拆分此字符串。

char charAt(int index)
返回指定索引处的 char 值。
int lastIndexOf(int ch)
返回指定字符在此字符串中最后一次出现处的索引。
int lastIndexOf(int ch, int fromIndex)
返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
int lastIndexOf(String str)
返回指定子字符串在此字符串中最右边出现处的索引。
int lastIndexOf(String str, int fromIndex)
返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。

boolean endsWith(String suffix)
测试此字符串是否以指定的后缀结束。
boolean startsWith(String prefix, int toffset)
测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
面向对象总结
1、对象-类的关系
对象是模版，类是实例
属性方法构成类，通过类创建对象
2、类的构成
属性 初始化快（实例初始化快和静态初始化快） 构造器 方法
3、main方法和公有类
一个源文件中允许定义多个类，只能有一个公有类（public修饰的类），公有类类名必须与源文件名一致
main方法只有在公有类中才能作为程序入口
4、静态成员与实例成员
静态成员所有对象共享同一个值
实例成员归属于对象 独享一个值
静态域只能访问静态成员
非静态域可以访问静态成员和实例成员
5、访问权限修饰符
private：私有权限，类的内部（包括内部类）可访问
default：默认权限，同一包可访问
protect：受保护权限，相同的包或其子类可访问
public：公开的，任何位置都可访问

			深入面向对象

·对象的属性：
·属性(对象)的生命周期：
·静态属性：在类加载时在内存中开辟空间，在程序结束后被销毁；
·实例属性：在对象创建时在内存中开辟空间，在对象被回收后被销毁。
·属性有默认值，可以在定义属性时指定初始值，也可以在初始化块和构造器中指定初始值。
·初始化块：
·静态初始化块：在类加载时被执行；
·实例初始化块：在创建对象时在构造器之前执行。
·构造器：
·1.构造器的方法名与所在的类名相同；
2.没有返回值类型部分。
·构造器可以重载。
·成员方法：
·组成部分：修饰符(无顺序要求)、返回值类型、方法名、定义参数、声明抛出异常(throws)、方法体
·方法的返回值类型和return的关系：
·如有返回值类型，则必须执行return，且return的数据类型必须与返回值的类型相同，除非在支路上有异常抛出(因为抛出异常也可以导致程序结束)；
·如返回值类型为void，则return可写可不写，写return代表在此处程序结束。

面向对象三个特征：
封装：隐藏属性，提供操作方法，怎么封装，降低访问权限，setter.getter
继承：在存在is-a前提下，子类可以继承父类所有的属性和方法，
子类可以定义自己的方法和属性，即实现了对现有的类扩展
多态：同一对象调用同一方法，调用方法的对象数据类型（运行期决定）不同而产生不同的执行过程或结果
this和super:
this表示当前对象
1.this.在非静态域中调用本类属性和方法，通常可以省略，除非属性名相同
2.this()调用本类其他重载构造器
3.super.调用父类继承下来的属性和方法,方法被重写不行,可super.父类方法再添加自己的东西
4.super()调用父类构造器
super()和this()必须在第一行且不能同时存在
方法重载与方法重写
overload：在同一各类当中，存在多个方法相同，参数（类型数量顺序）不同。
override：在子类继承父类中（实现类实现接口）子类拥有和父类声明部分相同；子类访问权限不低于父类；
返回执类型是基本类型，子类与父类一致，如果是引用类，子类可以与父类一致或是其子类；子类父类参数要一致；
父类抛出的异常，子类可以抛出的父类的子异常类。
抽象类和接口的区别
相同：
都不能创将对象，都含有抽象方法。
区别 ：
接口没有构造器，抽象类有构造器。
成员方法：接口是公开抽象方法，抽象类无要求。
继承性：接口可以多继成，抽象类单一继承
final finally finalize()
final 修饰三种类型的目标，表示最终修饰符
final 修饰变量不能被二次赋值
final 修饰方法不能被子类重写
final 修饰类不能被继承
finally 修饰 一定会被执行的语句块
finalize() object中的方法，当一个对象被垃圾回收后会触发执行finalize()，因为对象回收所以该方法被调用

内存管理和GC（垃圾回收）
GC 如果一个对象失去了所有的引用那么这个对象将被GC回收掉，当这个对象被垃圾回收时会自动调用finalize()方法
JVM在系统空闲时自动触发垃圾回收的启动
System.gc()/Runtime.gc()方法可以起到提醒的作用，调用此方法GC仍然要等到系统空闲时启用

内存泄漏
程序中创建对象时会在堆区分配内存空间，当对象不再使用时该空间需要被回收
不停地分配内存最终会将内存消耗殆尽，这种情况就是内存泄漏

内存区域
堆放 NEW出来的东西
栈放 局部变量
常量池存 常量值
静态域存 static修饰的静态成员变量
方法区存 class二进制文件

多态
三个要素 动态绑定 向上造型 方法重写
动态绑定 运行期才能确定目标
静态绑定 编译期就确定目标
含有final static private 构造器 属性是静态绑定其余都是动态绑定

包装类型：
1.如何将字符串类型转化为包装类型？
.parseInt （String->base）
.valueOf (Object->String)
2.枚举的定义
[访问权限] enum 枚举名｛
枚举值列表
｝
例如：
public enum TypeEnum{
VIDEO,AUDIO,TEXT
}

Enum还提供了values方法，这个方法使你能够方便的遍历所有的枚举值.
不能有public的构造函数.

3.内部类
成员内部类、静态内部类、局部内部类、匿名内部类

4.局部内部类，匿名内部类，Lambda表达式访问的方法局部变量必须是常量，final可省略。

5.Lambda表达式
1）用于简化匿名内部类，不会产生.class文件，不是语法糖。
2）(参数)->返回的值表达式/{方法实现}
3）Lambda只能实现函数式接口。
4）函数式接口：只有一个方法是抽象的，其他方法均有默认实现的接口。
5）方法的默认实现：
default 方法
6）@FunctionalInterface 注解，编译器如果发现你标注了这个注解的接口有多于一个抽象方法的时候会报错的：
集合
List、Map、Set的区别
List链表中可以有重复的数据，而且每个数据都有索引值。
Set中的数据不能重复，没有索引值。
Map中的数据以键值对形式存在，每一个值都有一个与之对应的键，通过键操作值；Map中的键的值不能重复，必须是唯一的，如果重复，后存入的会覆盖掉前一个。

List 接口的常用实现类 ： ArrayList：长度可变的数组，查找效率高，增删效率低。
LinkedList：增删效率高，查找效率低。
Vector：Vector与ArrayList相似，但是Vector是同步的，不具有线程安全性。

List接口必会方法

boolean add(E e)
向列表的尾部添加指定的元素（可选操作）。

void add(int index, E element)
在列表的指定位置插入指定元素（可选操作）。

E remove(int index)
移除列表中指定位置的元素（可选操作）。

boolean remove(Object o)
从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。

E set(int index, E element)
用指定元素替换列表中指定位置的元素（可选操作）。

E get(int index)
返回列表中指定位置的元素。

void clear()
从列表中移除所有元素（可选操作）。

boolean isEmpty()
如果列表不包含元素，则返回 true。

Iterator iterator()
返回按适当顺序在列表的元素上进行迭代的迭代器。

int size()
返回列表中的元素数。

List subList(int fromIndex, int toIndex)
返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。

---

Set:

set 集合没有泛型就要用迭代器（iterator）。

iterator.hasnext（）：查看集合中下一个元素是否有值。
iterator.next（）：取下一个元素的值。

---

Map:

Map接口的常用实现类：HashMap:允许null作为键和值，但是要注意键的覆盖，具有线程安全性。
Hashtable:是HashMap的简化版，不具有线程安全性，不允许键和值使用null。
LinkedHashMap:有顺序的，先存入的输出的时候先输出。

Map:接口必会方法
V put(K key, V value)
将指定的值与此映射中的指定键关联（可选操作）。

V remove(Object key)
如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。

V get(Object key)
返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。

Set keySet()
返回此映射中包含的键的 Set 视图。

boolean isEmpty()
如果此映射未包含键-值映射关系，则返回 true。

void clear()
从此映射中移除所有映射关系（可选操作）。

int size()
返回此映射中的键-值映射关系数。

异常处理：
异常指的是运行过程中的不正常事件，可以被异常机制处理，程序能够继续运行下去；
错误不能够被处理，发生错误后，程序就终止，程序员需要修改源代码才能解决错误；

API中标准异常的顶级父类是Throwable类

Throwable类有两个子类：Exception和Error；
所有异常都是Exception类的直接或间接子类；
所有错误都是Error的直接或间接子类

Exception有很多子类；这些子类又可以分为两大类；
运行时异常和非运行时异常
运行时异常：这些异常在编译期不检测，程序中可以选择处理，也可以不处理。如果不处理运行时会中断，但是编译没问题
非运行时异常：是必须进行处理的异常，如果不处理，将发生编译期错误
RuntimeException的子类都是运行时异常，其他的都是非运行时异常。

常用运行时异常类型：
ClassCastException：向下造型时 类型不匹配
IndexOutOfBoundsException : 越界
NumberFormatException ：不能转成数字
NullPointerException ：空指向异常，值为null的对象进行点操作
ArithmeticException ：算术异常

异常处理流程及语句

             ↗捕获成功→异常被处理，程序继续运行

抛出异常→捕获异常
↘捕获失败→异常未被处理，程序中断运行

Java语言中异常处理主要使用到try/catch/finally三种语句
try：把所有可能抛出异常的，或者肯定抛出异常的代码都写到try代码块中
try{
可能抛出异常的代码块;
}
catch：语句紧随try语句后，用来捕获异常并进行处理
try{
可能抛出异常的代码块;
}catch(异常类型 变量名){
处理异常的代码;
}
finally：
finally{
不管什么情况，一定被执行的代码块；
}
throws ： 声明抛出异常 方法中不一定有throw
throw ： 方法中抛出异常 就必须声明抛出异常throws