【Java】【基础知识】【Java的基本使用】
基于jdk8
仅个人理解，或有疏漏
基于 java疯狂讲义 第三版和第四版 java核心技术卷一 第十版和第十一版 廖雪峰java课程
一、基本数据与结构
1、数据分类
数据分为两种：
基本数据类型：值存放在栈上
引用数据类型：引用数据类型被创建时，首先在栈上给其引用创建一份内存，指向堆内存的某个对象信息
基本数据类型：
数值型：
整数型：byte short int long char(无符号整数型，又叫字符型)
浮点型：float double
布尔型：boolean
引用数据类型：
类(class)、接口类型（interface）、数组类型(array)、枚举类型(enum)、注解类型(Annotation)，字符串型(String)、null类型（null）
2、数据运算
2.1、直接量
byte a = 1;
short b = 1;
int c = 1;
long d = 5L;//l或L
//注：浮点数的直接量还可以使用科学计数法
float f = 3.2F;//f或F
double g = 2.2;
char e = 'A';//字符的直接量用单引号
String s = "ss";//字符串用双引号
2.2、数据运算注意点
-浮点数的运算会产生偏差，所以不要判断浮点数的结果和某个浮点数的值相等
double a = 2.1;
double b = 3.4;
double c = b - a;
System.out.println(c);//1.2999999999999998
-除零运算
三种异常值：正无穷大（Infinity） 负无穷大（-Infinity） 非数（NAN）
0/0.0 0.0/0 0.0/0.0 结果都为 NAN
给负数开根号 NAN
整型值/0 触发除零异常
正非零数值/0.0 Infinity
负非零数值/0.0 -Infinity
2.3、进制计算与转换
2.3.1、整数型的进制展示
int a = 0b010101;// 二进制
int b = 012;// 八进制
int c = 0x12a;// 十六进制
System.out.println(a);// 21
System.out.println(b);// 10
System.out.println(c);// 298
2.3.2、进制计算
二进制：满2进1
八进制：满8进1
十六进制：满16进1 a b c d e f 分别代表 10 11 12 13 14 15
2.3.4、进制转换
1、整数
十进制----二进制
10-->2
11/2 =5 ...1
5/2 = 2 ...1
2/2 = 1 ...0
1/2 = 0 ...1
1011
2-->10
1011
1*2^0+1*2^1+0*2^2+1*2^3 = 11
下图是八进制与二进制的互转，十六进制同理，省略不写：
2、小数
10--->2
0.25
0.25*2 = 0.5 0(这个是整数位的数值)
0.5*2 = 1.0 1
0.01
2-->10
0.01
0*2^-1+1*2^-2 = 0.25
下图是八进制与二进制的互转，十六进制同理，省略不写：
2.4、运算符分类
算数运算符
++ -- 单目运算符
赋值运算符
=
三目运算符
expression?if-true-statement:if-false-statement
expression:表达式 结果只能是true和false
if-true-statement：结果是true时的执行结果
if-false-statement：结果是false时的执行结果
2.4.1、比较运算符与逻辑运算符
比较运算符
> >= < <=
== 可以比较引用类型
逻辑运算符
&& || ! & | ^
不管是比较运算符还是逻辑运算符，他们的结果都是boolean类型，
2.4.2、位运算符
原码：将一个数值转成二进制数
补码：整数的补码和原码相同，负数的补码是其反码加1 计算机以补码的形式保存所有整数
反码：对原码按位取反，符号位不变
2.5、运算符优先级
3、类型转换
3.1、类型转换的几种方式
1.通过包装类
new XXX() parseXXX()
2.自动转换（低位--->高位）
赋值 运算
3.强制转换（高位<---低位）
（基本数据类型）变量
3.2、类型转换三部曲
*****对象是不可以转换类型的*****
1>在进行类型转换时，首先我们要将数据分成三大类型，分别是数值型（包括char类型）、boolean类型和String类型，主要是这三大类型的互转难以理解。
-数值型：byte short int long float double char
-boolean类型: boolean
-String类型: String
2>类型转换的方式主要有以上三种方式，而其中的自动转换和强制转换主要是数值类型（基本数据类型）之间的转换，与boolean和String无关。
代码示例：
-自动转换：
byte a =12;
float c = a;//将a赋值给c,自动转成float类型
System.out.println(c);//12.0
byte b = 12;
byte d = b+1;//Type mismatch: cannot convert from int to byte 原因：b在运算时，类型自动提升为int
//修改 int d = b+1;
int a = 1;
float s =2;
int d = a+s;//Type mismatch: cannot convert from float to int 原因：a为int,s为float,运算时，变成范围最大的那个类型
-强制转换：
int a =128;
byte b = (byte)a;
System.out.println(b);//-128 强制转换，有数据溢出的风险
int a1 =12;
byte b1 = (byte)a1;
System.out.println(b1);//12
3>这三种类型之间的转换主要通过包装类来转换类型
注意点：
1.String类型转数值类型（char类型除外，字符串不能转换成char类型），只能是数值类型的字符串，如："123"；
2.数值类型都可以转成String类型
3.Stirng类型转成Boolean类型，只有当字符串是"true"时（不区分大小写），布尔值才能是true，其他值皆为false
示例：
-数值类型--->String类型
Double a =1.2;
String s = a.toString();//1.2
String s1 = a+"";//1.2
-String类型--->数值类型
String a = "123";
double d = new Double(a);
double d1 = Double.parseDouble(a);
System.out.println(d);//123.0
System.out.println(d1);//123.0
String a1 = "11ss";
double d2 = Double.parseDouble(a1);
System.out.println(d2);//Exception in thread "main" java.lang.NumberFormatException: For input string: "11ss"
-Stirng类型--->Boolean类型
String a = "qw";
boolean b = new Boolean(a);
boolean b1 = Boolean.parseBoolean(a);
System.out.println(b);//false
System.out.println(b1);//false
String a1 = "true";
boolean b2 = Boolean.parseBoolean(a1);
System.out.println(b2);//true
4、语句
4.1、循环语句
//dowhile循环 不管条件是否满足，至少执行一次
初始化语句
do{
//循环体
//迭代语句
}while(循环条件)
//while循环
初始化语句
while(循环条件){
//循环体
//迭代语句
}
//for循环
for(初始化语句;循环条件;迭代语句){
//循环体
}
//foreach循环
for(变量类型 变量：数组或集合){
}
//dowhile循环
int[] arr = new int[] { 1, 2, 3, 4 };
int i = 0;
do {
System.out.println(arr[i]);
i++;
} while (i<arr.length);
//while循环
int[] arr = new int[] { 1, 2, 3, 4 };
int i = 0;
while (i < arr.length) {
System.out.println(arr[i]);
i++;
}
//for循环
int[] arr = new int[] { 1, 2, 3, 4 };
for (int i = 0; i < arr.length; i++) {
int j = arr[i];
System.out.println(j);
}
//foreach循环
int[] arr = new int[] { 1, 2, 3, 4 };
for (int item : arr) {
System.out.println(item);
}
4.2、分支语句
4.2.1、if分支
if (condition) {
//内容
}
if(){}else{}
if(){}else if(){} else{}
******condition表达式的结果为boolean类型******
第一种使用最为频繁
4.2.2、switch分支
switch (key) {
case value:
break;
default:
break;
}
value可写：整型值（除了long，包括char）、枚举和字符串
4.3、break与continue
break:
主要用于循环语句的中断（结束这次循环,不再执行该循环块或者程序块），以及switch语句的结束
continue：
中断当前的这次循环,继续后面的循环
二、面向对象基础
1、类的基本结构
1.1、普通类的结构
public class Car {
private String name;// 实例变量
private static int age;// 类级变量
private static final int AMOUNT = 100;// 常量
// 对象初始化块
{
}
// 静态初始化块
static {
}
// 默认构造器
public Father() {
}
// 构造器
private Father(String name) {
this.name = name;
}
// 静态方法
private static void hello() {
System.out.println("hhhhh");
}
// 方法
public void hello1() {
System.out.println("hhhhh");
}
//枚举类
enum EE{
RED,BLUE;
}
//非静态内部类
public c-lass Lunzi{
}
//静态内部类
public static User{
}
}
1.2、接口的结构
public interface Test {
//常量
public static final double PI = 3.1415926;
public int a = 1;
public static int b = 1;
static int c = 1;
final int d = 1;
//抽象方法
void test();
//抽象方法
public void test1();
//默认方法
default void show() {
System.out.println("test");
}
//静态方法
static void show2() {
System.out.println("test");
}
}
1.3、抽象类的结构
public abstract class TestAbstractClass {
//普通类有的抽象类都可以写,所以省略不写
.....
//抽象方法
public abstract void test();
protected abstract void test1();
abstract void test2();
}
2、类的结构体解析
2.1、类
2.1.1、类的分类
类主要分为三种，普通类、抽象类和接口
抽象类：
1.抽象类需要使用abstract修饰
2.抽象类可以没有抽象方法
3.抽象类虽然有构造器，但是不能实例化
接口：
1.接口里不管是常量还是方法，都使用public修饰，Java9后才支持定义private方法
2.接口使用interface修饰
3.java8开始，支持定义default方法和static方法
4.接口可以继承多个接口，**记住是继承，而且是多个，如图2-1-1-1**
5.接口只有常量，不管static final public有没有写，最终都会自动加上去，如图2-1-1-2（这是javap反编译的结果）
普通类：
1.普通类只可以直接继承一个抽象类，而且必须实现抽象方法，否则必须声明为抽象类
2.普通类可以实现多个接口
2.1.2、类的继承、组合与实现
1.继承
类通过extends关键字继承类
继承了什么？目前有两种说法
<1>.extends在英文是扩展，而不是继承，子类扩展了父类，将可以获得所有父类的所有属性和方法，私有方法不可直接使用，值得一说的是，子类不能获得父类的构造方法。---基于java疯狂讲义与java技术核心卷1
<2>.子类只能继承父类的非私有属性和方法，如果存在跨包，则包访问权限也不可继承，且父类的构造方法不可继承.---官方规范
2.实现
类通过implements关键字实现接口，如图2-1-1-2里的TestInterface
3.组合
通过在类的内部定义一个成员变量来引用另一个类，从而拥有它的使用权，如图2-1-2-1,相比于继承，继承更多的是一种“is a”的关系，而组合则是“has a”的关系。
2.2、变量和常量
2.2.1、封装
什么是封装？就是只能通过方法来操作类的属性（成员变量），一般常用的就是getter和setter
2.2.2、初始化
变量分为成员变量和局部变量
成员变量可以不赋值（如图2-2-2-1），如果是
基本类型：则会赋给一个对应类型的初始值，比如int的默认值为0，double是0.0
引用类型：赋值null
局部变量必须赋值，不然会报错。
成员变量和局部变量每个又分为类变量(static修饰)和实例变量
局部变量使用修饰符修饰时，会自动转成final变量，一经定义便不可修改，除非什么都不写，例如：int x = 1;
2.3、方法
2.3.1、方法的结构
权限修饰符 返回值类型 方法名（形参类型 形参名）{
//内容
return 值;//返回值
}
形参列表：括号里面的
方法签名：形参列表+方法名
2.3.2、super与this
this指代的是实例化对象的引用，不可在类的静态方法里使用this
通过super可以使用父类的方法和属性，不可在类的静态方法里使用super
this的作用：
1.调用属性
2.调用方法
3.this()/this("参数") 表示自己对应重载的构造器
super的作用：
1.调用父类被覆盖的属性(一般在与子类变量同名时调用)
2.调用父类方法(一般在与子类方法同名调用)
3.super()/super("参数") 调用父类对应的构造器
2.3.3、方法的重载和重写
2.3.3.1、重载
重载针对的是本类里的方法，只和方法签名有关，即方法名相同，参数列表不同即可
和权限访问符、静态修饰符以及返回值等等无关。如图2-3-3-1：
2.3.3.2、重写
注意点：
1.针对的是父类的方法进行覆盖（重写）
2.无法重写private和final方法，如果存在跨包，子类无法重写父类的包访问权限方法
3.如果父类是静态方法，子类必须也是；反之，亦然。
条件（两同两小一大）：
-权限访问必须大于或等于父类的访问权限（一大）
-方法签名（方法名+参数列表）相同（两同）
-返回值相同，如果为引用类型，则可以写父类返回值的子类（两小之一）
-异常必须比父类的异常类更小或相等（两小之一）
2.3.4、多态
什么是多态？
以我的理解，就是父类引用指向子类对象，调用方法时会调用子类的实现，而不是父类的实现，这就是多态。
使用前提：
1.存在继承、实现关系
2.重写父类的方法
3.父类引用指向子类对象
注意点：
-使用多态时，成员变量看父类
-与静态变量和静态方法无关
-与静态变量和静态方法无关
-可以通过调用子类的方法（getter），间接的获取子类的变量（前提子类也要定义一个同名变量）
食物类
public interface Food {
/**
* 获取食物能量值
* @return
*/
public abstract int getValue();
}
子类：肉类
public class Meat implements Food {
private final int value = 8;
@Override
public int getValue() {
return this.value;
}
@Override
public String toString() {
return "Meat";
}
}
Pet类关键代码：给宠物喂不同的食物
public void eat(Food food) {//这里是父类的引用
System.out.println(food.getValue());//这里却是调用的子类的方法
}
2.3.5、结束方法
返回值为void return;
返回值类型为其他 retur （返回值类型）返回值；
2.4、构造器
2.4.1、构造器定义
方法里面有个特殊的方法叫构造方法，又叫构造器(方法是可以重载的，所以构造器也可以)
构造方法：
特点：没有返回值
方法名和类名一致
作用：一般用于初始化对象
2.4.2、构造器与继承
***对象一般会默认的隐式地创建一个无参构造器，但是如果，用户自己定义了构造器的话，就不会执行这个动作
如果存在继承，则每个子类的每个构造器的第一行都会隐式的调用父类的无参构造器，如果不存在父类的无参构造器（父类显式的定义了其他构造器，且没有显式定义无参构造器），则此时就会报错。如图2-5-1-2
2.5、初始化块
2.5.1、静态初始化块
-类第一次加载时触发
-比构造器先执行，比对象初始化块先执行，与代码位置无关
-如果存在父类静态化初始化块，则先执行父类静态初始化块
2.5.2、对象初始化块
-对象创建时触发
-比构造器先执行
-如果存在父类对象初始化块，则先执行父类对象初始化块
注意：父类的构造器比子类的对象初始化块先执行，因为先创建完父类对象的拷贝，才会执行子类对象的创建
理解：
类加载是一个过程（在此期间加载静态初始化块）
对象创建是之后的一个过程（在此期间创建对象）
执行流程：
当继承父类时，会先加载父类，执行父类的静态初始化块，之后在加载子类的静态初始化块，当类文件的加载完成后，就会执行父类的对象初始化块和构造器，最后再执行子类的对象初始化块和构造器，如图2-5-1-1：
2.6、权限修饰符与final
2.6.1、权限修饰符
1.类权限访问修饰符
public :无限制
默认不写：包访问权限修饰符
2.方法访问权限修饰符
2.6.2、final
final可以修饰变量、方法和类
变量：表示一经赋值，便不可变
实例变量：可以在声明变量的位置、对象初始化块和构造器赋值
类变量：可以在声明变量位置、静态初始化块赋值
方法：表示不可重写
类：表示不可继承
2.7、调用方式
类变量：
类里面调用：
1.直接写成员变量名
2.使用this.成员变量名（只能在类的实例方法里面使用）
3.类名.成员变量名
类外部调用（默认权限非private）：
1.类名.成员变量名
2.实例化对象名.成员变量名
静态方法：
类里面调用：
1.方法名()
2.类名.方法名（）
3.this.方法名（）（只能在类的实例方法里面使用）
类外部调用：
1.类名.方法名（）
2.实例化对象名.方法名（）
-------------------------------------------------------------------------------------------
实例变量：
类里面调用（只能在实例方法里面使用）：
1.直接写成员变量名
2.使用this.成员变量名（使用这种方式更安全）
类外部调用（默认权限private）：
1.通过getter方法获取
实例方法：
类里面调用（只能在实例方法里面使用）：
1.方法名()
2.this.方法名()
类外部调用：
1.实例化对象名.方法名（）
2.8、内部类（暂不详细了解）
拥有权限访问修饰符，和变量一样
2.8.1、静态内部类
只能定义类变量和类方法，接口里只能定义静态内部类
2.8.2、非静态内部类
只能定义实例方法和实例变量
2.8.3、局部内部类
方法里定义的类叫做局部内部类
三、异常
1、异常分类
2、异常结构
public class TestException extends Exception {
/**
*
*/
private static final long serialVersionUID = 1L;
public TestException() {//一个无参构造
super();
}
public TestException(String message) {//一个只含错误信息的
super(message);
}
public TestException(String message, Throwable throwable) {//一个含错误信息的及异常链
super(message, throwable);
}
public TestException(Throwable throwable) {//一个包含异常链的，throwable表示上一个异常实例化对象
super(throwable);
}
}
3、抛异常
throws Exception:向上抛异常，不处理，写在参数列表后，多个异常用逗号分割
throw new Exception();：抛异常
4、捕获异常
4.1、结构体
try {
//可能发生异常的代码块
} catch (Exception e) {
// TODO: handle exception
}finally {
//不管成功失败最终都会执行，一般用来收尾，做清理工作
}
4.2、注意点
try...catch...finally中的return 只要能执行，就都执行了，他们共同向同一个内存地址（假设地址是0x80）写入返回值，后执行的将覆盖先执行的数据，而真正被调用者取的返回值就是最后一次写入的
1.finally中的返回值会覆盖try...catch里的返回值
2.finally中的返回值会抑制try和catch里的异常
2.finally中的异常会覆盖try和catch里的异常
5、异常链
四、Java高级特性
1、反射
2、泛型
Java引入了“参数化类型”的概念，即允许在创建集合或其他泛型类时，指定集合或类的元素类型。而Java的参数化类型就叫泛型
2.1、泛型类与泛型方法
2.1.1、泛型类
//public class Utils<T, V extends Student & java.io.Serializable> {
public class Utils<T, V extends Student> {
private T name;
private V user;
public T getName() {
return name;
}
public void setName(T name) {
this.name = name;
}
public V getUser() {
return user;
}
public void setUser(V user) {
this.user = user;
}
public Utils(T name, V user) {
this.setName(name);
this.setUser(user);
}
// public static <W, Y> void show(Collection<? extends W > p,ArrayList<? extends Y> y) {
public static <W> void show(List<? extends W > p) {
for (W w : p) {
System.out.println(w);
}
}
}
2.1.2、泛型方法
什么是泛型方法
就是在方法修饰符和返回值类型之间使用<>定义泛型形参
方法修饰符<T,S> 返回值类型 方法名（形参列表）
{
//方法体
}
2.2、泛型形参与通配符
1.泛型形参
<T> 这个T就是泛型形参
用途：
1.定义类、接口时 类名<> 接口名<>
示例：public class Utils<T, V extends Student, K, Y>
2.定义方法(实例方法和类方法)时 方法修饰符<> 返回值类型
示例：public static <W> void show(List<? extends W > p)
方法：
设定泛型形参上限（extends） T extends W
解释：
T只能是W的子类或W
示例：
类：public class Utils<T, V extends Student, K, Y>
方法：public <W extends Y> void test(List<? extends W> p,List<W> s)
目的：
限制泛型类和泛型方法的使用范围
2.通配符
<?> 这个？就是通配符
用途：
1.调用泛型类和接口时（不建议使用）
示例：ArrayList<? super Person> arr = new ArrayList<>();
2.定义方法，设置形参范围时
示例：public static <W> void show(List<? extends W > p)
方法：
1.设定通配符上限(extends) ? extends T
解释：
？只能是T的子类和T
示例：
类和接口：省略
方法：public static <W> void show(List<? extends W > p)
2.设定通配符下限（super）? super T
解释：
？只能是T的父类和T
示例：
类和接口：省略
方法：public static <W> void show(List<? super W > p)
2.3、使用上的注意
1.继承
假设 Utils是泛型类 Utils<T>
可以这样写：
public class App extends Utils<String>
也可以这样写：
public class App extends Utils //但是这种默认为Object类型
2.通配符上限与泛型方法转换
public <W extends Person> void test(List<W> p) {
p.get(0);
}
public void test2(List<? extends Person> p) {
p.get(0);
}
3.通配符与泛型方法的优缺点
2.4、泛型和数组
Person 是 Student 的父类，
2.5、擦除
java在编译时，首先会将尖括号里的类型记录下来，然后将类里的泛型全部换成Object类型，最后在代码执行的时候，将之强制转换成我们一开始在尖括号里定义的类型。
3、集合
3.1、集合框架图
3.1.1、Collection
3.1.2、Map
3.2、集合分类
3.2.1、Hash系列
HashSet LinkedHashSet HashMap LinkedHashMap
基于hash算法实现的，根据hashCode确定存储的位置
不管是set还是map的key值，他们都是不能重复的，而他们是如何判断一个元素是否相等呢？
hashCode 和 equals,两个都要相等，不然就会产生各种问题
1.hashCode相等 equals不等
2.hashCode不等 equals相等
3.2.2、Tree系列
TreeSet TreeMap
基于红黑树算法实现的
存储值时，只需要equals相等，但是存入的值都必须实现Comparable接口，可以自然排序，也可自定义排序（重写compareTo方法）
3.2.3、Linked系列
LinkedHashSet LinkedHashMap LinkedList
通过链表维护存储顺序的
3.2.4、线程安全系列
HashSet、HashMap、ArrayList等等都是线程不安全的，所以需要Collections工具类的线程同步方法保证他们的线程安全，sysnchronizeMap\sysnchronizeList\sysnchronizeSet
3.3、集合的使用
3.3.1、Collection
1.Set
add contains remove isEmpty size
2.List
add set remove get
addAll indexOf sort
subList replaceAll
3.3.2、Map
put remove containsKey containsValue
keySet values entrySet isEmpty size
3.3.3、遍历
1.Lamba表达式
arr.forEach(obj -> System.out.println(obj.getId() + "--" + obj.getCreator() + "---" + obj.getTitle()));
2.Itertor迭代器遍历
Iterator<NewsTitle> it = arr.iterator();
while (it.hasNext()) {
NewsTitle t = it.next();
System.out.println(t.getTitle());
}
3.for循环遍历
4.foreach遍历
如果是链表，一般用迭代器遍历，如果不是，可以用其他方式遍历
4、多线程
5、注解
6、本地化
五、Java规范
1、命名规范
类名要采用大驼峰命名规则
方法名和变量名采用小驼峰命名规则（开头首字母小写，其他大写）
常量全大写并且使用下划线分割
***** 最重要的是，变量名要解释变量的作用****
2、代码结构规范
1.继承时，严格控制方法和属性的访问权限，父类提供给其他方法使用的工具性方法应使用private
2.在使用if分支语句时，应避免使用嵌套if-else语句。
3、注释规范
-类注释和变量和方法都要采用多行注释，即
/**
*
*/
-代码块里的流程示意可以使用单行注释，即
//
六、JVM
7.1、编译过程
首先将后缀名为.java的源文件进行编译，最终生成后缀名为.class的字节码文件
7.2、类加载过程
Java虚拟机将编译好的字节码文件加载到内存（这个过程被称为类加载，是由加载器完成的），然后虚拟机针对加载到内存的java类进行解释执行，显示结果。
classLoader只负责加载class文件，至于他是否可以运行，由Execution Engine决定
#流程
加载
程序运行之前jvm会把编译完成的.class二进制文件加载到内存，供程序使用，用到的就是类加载器classLoader
类加载器：负责读取字节码，并转换成java.Long.Class类的一个对象存在于方法区
连接
验证
确保类加载的正确性。一般情况由javac编译的class文件是不会有问题的，但是可能有人的class文件是自己通过其他方式编译出来 的，这就很有可能不符合jvm的编译规则，这一步就是要过滤掉这部分不合法文件
准备
为类的静态变量分配内存，将其初始化为默认值 。注意，只是为静态变量分配内存，此时是没有对象实例的
解析
将class 内的 符号引用，加载到 运行时常量池 内转化成为 直接引用 的过程
初始化
为类的静态变量赋予正确的初始值