Java语言学习基础笔记

本文为Java学习基础知识总览，适合正在学习Java的同学们进行查缺补漏。

基础知识：

.java文件->编译->.class文件->运行
编译用javac.exe，运行用java.exe
.class文件也叫字节码文件
JDK = JRE + Java开发工具（ javac.exe , java.exe , javadoc.exe )
JRE = JVM + Java核心类库

数据类型和变量：

int和double为常用类型。

long类型需要在数值末尾加上l或L，不加l或L就自动变成了int型。
float类型需要在数值末尾加上f或F，不加f或F就自动变成了double型，会报错。

int(4字节)能表示-2^31~231-1的范围，约-21亿~21亿。
long(8字节)能表示-2^63~263-1的范围。

float精确到7位有效数字。
double精确到14位有效数字。

float就已经可以表示-E38~E38的数值大小，比long还要大，但是缺点是精度只有有效数字7位。

变量运算：

自动提升类型：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升。
备注：此时的容量大小指的是，表示数的范围的大和小，比如：float容量要大于long的容量。
byte/short/char -> int -> long -> float -> double
备注：当byte、char、short三种类型互相做运算时(包括同种类型的运算，如byte+byte)，结果为int型。
强制类型转换：自动类型提升的逆过程。

与String相连的“+”代表：连接运算。
与其他相连的“+”代表：数值运算。

String用双引号，char用单引号。

String不能进行强制转换。

小知识：

&前false时执行后面
&&前false时不执行后面

| 前true时执行后面
|| 前true时不执行后面

键盘输入：

import java.util.Scanner
Scanner scan = new Scanner(System.in);
int a = scan.nextInt();

String str1 = "Hello";
String str2 = scan.next();
char c1 = str1.charAt(1); //c1 = 'e'

小知识：

获取当前时间距离1970-01-01 00:00:00的毫秒数：
long start = System.currentTimeMillis();

对i开方：Math.sqrt(i);

break和continue后面不可以直接有执行语句。

结束指定标识的break，在for前面可以加一个标识，例如"lable:"

数组初始化：

整形(byte,short,int)：0
浮点型(float,double)：0.0
char:ASCII码为0的字符类似空格不是空格
String:null（注意不是“null”）

二维数组时，外层数组初始化值为地址值，内层与一维数组相同。
注：当二维数组用 int[][] arr = new int[4][] 方式定义时，外层初始化值为null。

面试题："=="和"equals()"的区别？

面试题：重载与重写的区别？

重载、重写、继承、多态：

重载（overload）：
方法名相同，参数列表不同，在编译期就确定了调用地址。
是一种编译时行为，是一种“静态绑定”或“早绑定”。

重写（override，overwrite）：
1.子类重写的方法名、参数列表要与父类方法完全一样。
2.子类重写的权限不小于父类方法。（private方法不能被重写）
3.返回值若是void和基本数据类型，则不变。
4.返回值若是类，则重写的方法的返回值只能是此类或此类的子类。
5.子类重写方法抛出的异常不大于父类被重写方法抛出的异常。
6.子类和父类的同名同参数的方法要么都是非static（考虑是重写），要么都是static（不是重写）。

继承：extends 将包括private在内的所有属性和方法都继承。

注：当子类和父类的同名同参数的方法（包括属性）都是static时，子类和父类中同名的static属性和方法都是相互独立的，并不存在任何的重写的关系。因为子类不继承父类的static属性和方法，static属性和方法属于类本身。
例如：Animal dog1 = new Dog();
dog1.shout();//调用的是Animal中的static void shout()方法。
Dog dog2 = new Dog();
dog2.shout();//调用的是Dog中的static void shout()方法。

多态：父类的引用指向子类的对象。（ 例：Animal a = new Dog(); ）
多态的使用：虚拟方法调用。
在编译期，只能调用父类中声明的方法，但在运行期，执行的是子类重写的方法。
是一种运行时行为，是一种“动态绑定”或“晚绑定”。
只适用于方法，不适用于属性。

数据类型转化：

基本数据类型、包装类、String型的转化：
基本数据类型—>包装类 ：直接转即可，称作自动装箱
包装类—>基本数据类型 ：直接转即可，称作自动拆箱
基本数据类型—>String ： + “”
包装类—>String ：使用String.valueof()方法,例如String s1 = String.valueof(in1);
String—>基本数据类型&&包装类 ：使用包装类的parseXxx()方法，例如

int i1 = Integer.parseInt(s1);
Integer in1 = Integer.parseInt(s1);

Integer内部有一个IntegerCache缓存数组，是从-128~127范围的数字，从这个范围取数就不用新new对象。

单例模式：

就是采取一定的方法保证在整个的系统软件中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。做法：首先必须将类的构造器的访问权限设置为private，这样就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。
变量初始化顺序：
①默认初始化
↓
②显式初始化 / ③代码块初始化（注：②和③的执行顺序由书写顺序决定）
↓
④构造器初始化
↓
⑤创建对象以后通过“对象.属性”或“对象.方法”进行的初始化

对于代码块和构造器初始化的总结：由父及子，静态先行。

小知识：

抽象abstract不能用来修饰：私有private方法、静态static方法、final方法、final类。

总结：
static可以修饰：属性、方法、代码块、内部类
final可以修饰：类、变量（属性+局部变量）、方法
abstract可以修饰：类、方法

接口：

接口interface里面可以写：
全局常量：public static final的常量，但是书写时可以省略。
抽象方法：public abstract的方法，但是书写时可以省略。
在Java1.8中，新添加了接口interface里面可以写：
静态方法：public static的方法，注意此方法只能通过接口调用，实现类看不到此方法。
默认方法：public default的方法，注意此方法可以由实现类的对象调用，由于不是静态，不可以由接口直接调用。
如果实现类重写的此默认方法，则调用时调用的是重写以后的方法。
注1：如果子类（或实现类）继承的父类和实现的接口中声明了同名的属性，则此属性无法在子类（或实现类）中调用。只能用“super.属性”代指父类中的属性，用“接口.属性”代指接口中的属性。
注2：如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法，那么子类（或实现类）在没有重写此方法的情况下，默认调用的是父类中的此方法。（类优先原则）
注3：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，会报错。（接口冲突）
注4：调用接口中的默认方法除了用实现类的对象调用以外（尤其是此方法在父类中有同名同参数方法存在时），可以用“接口.super.方法”来调用此方法。

面试题：抽象类和接口的共同点和区别？
共同点：①都不能实例化 ②都可以包含抽象的方法
不同点：①抽象类有构造器，接口没有 ②抽象类只能单继承，接口可以多实现，接口与接口也可以多继承 ③各自的内部结构不同

异常：

异常的结构：
java.lang.Throwable
–|-----java.lang.Error:一般不编写针对性的代码进行处理。
----|-----java.lang.Exception:可以进行异常的处理
-------|------编译时异常(checked)
----------|-----IOException
-------------|-----FileNotFoundException
----------|-----ClassNotFoundException
-------|------运行时异常(unchecked,RuntimeException)
----------|-----NullPointerException（空指针异常）
----------|-----ArrayIndexOutOfBoundsException（数组角标越界异常）
----------|-----ClassCastException
举例：{
Object obj = new Date();
String str = (String)obj;
}
|-----NumberFormatException
举例：{
String str = “abc”;
int num = Integer.parseInt(str);
}
|-----InputMismatchException（输入不匹配异常）
举例：{ 代码为scan.nextInt()实际却输入"abc"字符串 }
|-----ArithmeticException（算数异常）
举例：{ 除数为0 }

常用的异常对象处理的方式： ① String getMessage() ② void printStackTrace()

try-catch-finally语句体会：
体会1：使用try-catch-finally处理编译时异常，使得程序在编译时就不再报错，但是运行时仍可能报错。
相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。
体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。
针对于编译时异常，我们说一定要考虑异常的处理。

throws语句：
"throws + 异常类型"写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。
一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时，就会被抛出。异常代码后续的代码，就不再执行了。

开发中如何选择使用try-catch-finally 还是使用throws？
① 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws（因为throws异常时父类的异常必须大于子类的异常），意味着如果子类重写的方法中有异常，必须使用try-catch-finally方式处理。
② 执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。

手动抛出异常用throw，例如：throw RunTimeException(“异常信息”);

自定义异常类的写法：
① 继承于现有的异常结构：RuntimeException && Exception
② 提供全局常量：serialVersionUID
③ 提供重载的构造器

面试题：final、finally、finalize的区别？
final：关键字，修饰类时表示不能被继承，修饰方法时表示不能被重写，修饰变量时表示常量，保存在常量池中且不可以被修改。
finally：关键字，在try-catch-finally体系中，无论是否catch都必然会被执行的代码部分。
finalize：方法名，Java的垃圾回收机制，用jvm会自动用"对象.finalize"来回收成为垃圾的对象。

面试题：throw和throws的区别？
throw用于生成异常对象，声明在方法体内，手动抛出此异常类生成的对象。
throws用于处理异常，声明在方法声明处，将异常向上抛给此方法调用处。

面试题总结：

类似：
重载 & 重写
throw & throws
Collection & Collections
String & StringBuffer & StringBuilder
ArrayList & LinkedList
HashMap & LinkedHashMap

不类似：
抽象类 & 接口
== & equals()
sleep() & wait()