01章 入门

卸载与安装

卸载

• 删除java的安装目录
• 删除环境变量配置JAVA_HOME
• 删除环境变量中path下关于java的目录
• 命令行验证java -version 出现命令错误表示下载成功

安装

• 百度搜索jdk8，找到下载地址
• 同意协议
• 下载电脑的对应版本
• 双击安装jdk的exe安装程序
• 记住安装的路径
• 配置环境变量JAVA_HOME
• 配置path
• 命令行窗口 java -version 验证命令，出现java的版本信息，安装成功

jdk、jre、jvm

jdk包含jre，jre包含jvm

• jdk(Java Development Kit java开发者工具)：JRE的超集，包含编译器和调试器等用于程序开发的文件

• jre(Java Runtime Environment java运行环境)：Java虚拟机、库函数、运行Java应用程序和Applet所必须文件

• jvm(Java Virtual Machine)：JVM是一种规范，可以使用软件来实现，也可以使用硬件来实现，就是一个虚拟的用于执行bytecodes字节码的计算机。他也定义了指令集、寄存器集、结构栈、垃圾收集堆、内存区域。

java程序运行机制

编译型：java文件编译为class文件

解释型：解释一句运行一句

java使用编译型和解释型结合的方式运行

1.一个类中，成员变量（属性）有默认值，引用数据类型是null值，基本数据类型就是本身默认值。方法中，局部变量，没有默认值

02章 编程基础

标识符

java关键字

注意点

• 所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
• 首字符不能时数字和特殊字符
• 首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
• 不能使用关键字作为变量名或方法名。
• 标识符是大小写敏感的
• 合法标识符举例：age、$salary、_value、__1_value
• 非法标识符举例：123abc、-salary、#abc

数据类型

基本数据类型

public static void main(String[] args) {
    //长整型
    long i2=998877665544332211L;
    //浮点型
    double d1=3.5; //双精度
    float f2=3.5f; //单精度
    //布尔类型 boolean true真/false假
    boolean isPass=true;
    boolean isOk=false;
    //单字符
    char f='女';
    char m='男';
}

引用数据类型

除了基本的数据类型之外，其它的都是引用数据类型

整型拓展

十进制整数，如：99, -500, 0。

八进制整数，要求以 0 开头，如：015。

十六进制数，要求 0x 或 0X 开头，如：0x15

//整型
int i=10;
int i2=010;
int i3=0x10;
System.out.println(i); //10
System.out.println(i2); //8
System.out.println(i3); //16

进制转换：

• 二进制转换成十进制：按权相加
• 十进制转换成二进制：整数部分除2取余，倒序排列，小数部分乘2取整，正序排列

浮点型拓展

浮点类型float, double的数据不适合在不容许舍入误差的金融计算领域。

如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。

public static void main(String[] args) {
    
    float f = 0.1f;
    double d = 1.0/10;
    System.out.println(f==d); //false
    
    float d1 = 2131231231f;
    float d2 = d1+1;
    // d1==d2 true
    if(d1==d2){
    System.out.println("d1==d2");
    }else{
    System.out.println("d1!=d2");
    }
    
}

主要理由：

• 由于字长有限，浮点数能够精确表示的数是有限的，因而也是离散的。
• 浮点数一般都存在舍入误差
• 很多数字无法精确表示，其结果只能是接近，但不等于；二进制浮点数不能精确的表示0.1,0.01,0.001这样
  10的负次幂。
• 并不是所有的小数都能可以精确的用二进制浮点数表示

最好完全避免使用浮点数比较

字符型拓展

单引号用来表示字符常量。例如‘A’是一个字符，它与“A”是不同的，“A”表示一个字符串。

char 类型用来表示在Unicode编码表中的字符。

Unicode编码被设计用来处理各种语言的所有文字，它占2个字节，可允许有65536个字符；

【科普：2字节=16位 2的16次方=65536，我们用的Excel原来就只有这么多行，并不是无限的】

public static void main(String[] args) {
    char c1 = 'a';
    char c2 = '中';
    System.out.println(c1);
    System.out.println((int) c1); //97
    System.out.println(c2);
    System.out.println((int) c2); //20013
}

Unicode具有从0到65535之间的编码，他们通常用从’u0000’到’uFFFF’之间的十六进制值来表示（前缀为u表示Unicode）

// \u代表转义，将数字转义为Unicode编码的对应字符
char c3 = '\u0061';
System.out.println(c3); //a

转义字符

类型转换

低 ---------------------------------------- >高
byte,short,char—> int —> long—> float —> double

数据类型转换必须满足如下规则：

• 不能对boolean类型进行类型转换。

• 不能把对象类型转换成不相关类的对象

• 在把容量大的类型转换为容量小的类型时必须使用强制类型转换

• 转换过程中可能导致溢出或损失精度

  int i =128;
  byte b = (byte)i; // -128
  // 因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。
  

• 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入

  (int)23.7 == 23;
  (int)-45.89f == -45
  

常见错误和问题

1. 操作比较大的数时，要留意是否溢出，尤其是整数操作时；

   public static void main(String[] args) {
       int money = 1000000000; //10亿
       int years = 20;
       int total = money*years; //返回的是负数
       //返回的仍然是负数。默认是int，因此结果会转成int值，再转成long。但是已经发生了数据丢失
       long total1 = money*years; 
       //先将一个因子变成long，整个表达式发生提升。全部用long来计算。
       long total2 = money*((long)years); 
       System.out.println(total);
       System.out.println(total1);
       System.out.println(total2);
   }
   

2. L和l 的问题：

   • 不要命名名字为l的变量
   • long类型使用大写L不要用小写。

   public static void main(String[] args) {
       int l = 2;
       long a = 23451l;
       System.out.println(l+1); //3
       System.out.println(a); //23451
   }
   

JDK7扩展

JDK7新特性：下划线分隔符

在实际开发和学习中，如果遇到特别长的数字，读懂它令人头疼！JDK7为我们提供了下划线分隔符，可

以按照自己的习惯进行分割。

int b = 1_2234_5678; // 我们很容易就知道这是1亿2234万5678啦！ 非常符合国人的习惯

变量和常量

变量

变量是什么：就是可以变化的量！

我们通过变量来操纵存储空间中的数据，变量就是指代这个存储空间！空间位置是确定的，但是里面放置什么值不确定

Java是一种强类型语言，每个变量都必须声明其类型。

Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储单元

常量

常量(Constant)：初始化(initialize)后不能再改变值！不会变动的值

所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变

final 常量名=值;
final double PI=3.14; final String LOVE="hello";

运算符

• 算术运算符: +，-，*，/，%，++，--
• 赋值运算符 =
• 关系运算符: >，<，>=，<=，==，!= instanceof
• 逻辑运算符: &&，||，!
• 位运算符: &，|，^，~ ， >>，<<，>>> (了解！！！)
• 条件运算符 ？：
• 扩展赋值运算符:+=，-=，*=，/=

二元运算符

整数运算：

如果两个操作数有一个为Long(或float), 则结果也为long(或float)。没有long(或float)时，结果为int。即使操作数全为shot,byte，结果也是int.

浮点运算：

如果两个操作数有一个为double, 则结果为double。只有两个操作数都是float, 则结果才为float.

取模运算

就是我们小学的取余； 5%3 余 2

其操作数可以为浮点数,一般使用整数。如：5.9%3.9=2.000000004

要点：

负数%负数＝负数；

负数%正数＝负数；

正数%负数＝正数；

public static void main(String[] args) {
    System.out.println(9 % 4); //1
    System.out.println(-9 % -4); //-1
    System.out.println(-10 % 4); //-2
    System.out.println(9 % -4); //1
}

​ 【注：一般都是正整数运算，进行结果的判断】

一元运算符

自增（++）自减（--）运算符

++在前，先自增，在使用

++在后，先使用，在自增

--亦然

public static void main(String[] args) {
    int a = 3;
    int b = a++; //执行完后,b=3。先给b赋值，再自增。
    int c = ++a; //执行完后,c=5。先自增,再给b赋值
}

注意：java中的乘幂处理

public static void main(String[] args) {
    int a = 3^2; //java中不能这么处理， ^是异或符号。
    double b = Math.pow(3, 2);
}

Math类提供了很多科学和工程计算需要的方法和常数。特殊的运算都需要运用到方法!

逻辑运算符

逻辑与：&&，逻辑或：||，逻辑非：！

逻辑与和逻辑或采用短路的方式。从左到右计算，如果确定值则不会再计算下去

位运算符

应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。位运算符作用在所有的位上

// 可以理解成1为真0为假
A = 0011 1100
B = 0000 1101
-----------------
A&b = 0000 1100	// 都为1才是1
A | B = 0011 1101 // 都是0，才为0
A ^ B = 0011 0001 // 异或 值相同为0 不同为1
~A= 1100 0011 // 按位取反 0变1 1变0

右移一位相当于除2取商

左移一位相当于乘2

解释一下，在系统中运算是以二进制的形式进行的。相比来说俩个二进制数相乘运算比移位运算慢一些。

扩展运算符

字符串连接符

“+” 运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串然后再进行连接

三目条件运算符

public static void main(String[] args) {
    int score = 80;
    String type = score < 60 ? "不及格" : "及格";
    System.out.println("type= " + type);
}

运算符优先级

大家不需要去刻意的记住，表达式里面优先使用小括号来组织！！方便理解和使用，不建议写非常冗余的代码运算！

包机制

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

包的本质就是文件夹

JavaDoc

稍微解释一下：以 /** 开始，以 */ 结束

• @author 作者名
• @version 版本号
• @since 指明需要最早使用的jdk版本
• @param 参数名
• @return 返回值情况
• @throws 异常抛出情况

/** 这是一个Javadoc测试程序
* @author Kuangshen
* @version 1.0
* @since 1.5
* */
public class HelloWorld {
    public String name;
    /**
    * @param name 姓名
    * @return 返回name姓名
    * @throws Exception 无异常抛出
    * */
    public String function(String name) throws Exception{
    return name;
    }
}

命令行生成Doc

用户交互Scanner

Scanner对象

两者区别：

流程结构

顺序结构

JAVA的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行

顺序结构在程序流程图中的体现就是用流程线将程序框自上而地连接起来，按顺序执行算法步骤

选择结构

if单选择结构

if(布尔表达式){
	//如果布尔表达式为true将执行的语句
}

if双选择结构

if(布尔表达式){
	//如果布尔表达式的值为true
}else{
	//如果布尔表达式的值为false
}

if多选择结构

if(布尔表达式 1){
	//如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
	//如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
	//如果布尔表达式 3的值为true执行代码
}else {
	//如果以上布尔表达式都不为true执行代码，也可以忽略
}

// 只能执行一个代码块

嵌套的if结构

if(布尔表达式 1){
	////如果布尔表达式 1的值为true执行代码
	if(布尔表达式 2){
		////如果布尔表达式 2的值为true执行代码
	}
}

switch多选择结构

多选择结构还有一个实现方式就是switch case 语句

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

switch(expression){
     // break 如果没有，会发生case穿透现象
	case value :
		//语句
		break; //可选
	case value :
		//语句
		break; //可选
		...
	default : //可选
		//语句
}

switch case 语句有如下规则：

• switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型
• case 标签必须为字符串常量或字面量。
• default 分支不需要 break 语句。

循环结构

while 循环

while( 布尔表达式 ) {
	//循环内容
}

do...while 循环

do {
	//代码语句
}while(布尔表达式);

while和do-while的区别：

• while先判断后执行。dowhile是先执行后判断
• do...while总是保证循环体会被至少执行一次！这是他们的主要差别。

for循环

for(初始化; 布尔表达式; 更新) {
	//代码语句
}

public static void main(String[] args) {

    int a = 1; //初始化
    
    while(a<=100){ //条件判断
    	System.out.println(a); //循环体
    	a+=2; //迭代
    }
    
    System.out.println("while循环结束！");
    
    for(int i = 1;i<=100;i++){ //初始化//条件判断 //迭代
    	System.out.println(i); //循环体
    }
    
    System.out.println("while循环结束！");
    
}

我们发现，for循环在知道循环次数的情况下，简化了代码，提高了可读性。我们平时用到的最多的也是我们的for循环

增强for循环

Java5 引入了一种主要用于数组或集合的增强型 for 循环

for(声明语句 : 表达式){
	//代码句子
}

public static void main(String[] args) {

    int [] numbers = {10, 20, 30, 40, 50};
    for(int x : numbers ){
    	System.out.print( x );
    	System.out.print(",");
    }
    
    System.out.print("\n");
    
    String [] names ={"James", "Larry", "Tom", "Lacy"};
    for( String name : names ) {
    	System.out.print( name );
    	System.out.print(",");
    }
    
}

break & continue & goto

break关键字

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。

break 跳出最里层的循环，并且继续执行该循环下面的语句。

switch 语句中break在上面已经详细说明了，如果有疑惑可以回头看switch多选择结构小节

public static void main(String[] args) {

    int i=0;
    while (i<100){
        i++;
        System.out.println(i);
        if (i==30){
        	break;
        }   
    }
    
}

continue 关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代

在 for 循环中，continue 语句使程序立即跳转到更新语句(例如常见的i++语句)。

在 while 或者 do...while 循环中，程序立即跳转到布尔表达式的判断语句

两者区别

• break在任何循环语句的主体部分，均可用break控制循环的流程。用于强行退出循环，不执行循环中剩余的语句。
• break语句也在switch语句中使用
• continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定

goto关键字

了解即可

• goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字，但并未在语言中得到正式使用；Java没有goto。然而，在break和continue这两个关键字的身上，我们仍能看出一些goto的影子---带标签的break|continue。
• “标签”是指后面跟一个冒号的标识符，例如：label:
• 对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。

// 【看不懂没关系，只是了解一下即可，知道goto这个保留字和标签的写法】
public static void main(String[] args) {

    int count = 0;
    outer: for (int i = 101; i < 150; i ++) {
        for (int j = 2; j < i / 2; j++) {
            if (i % j == 0){
                continue outer; // 从定义的outer标签处(最外层循环处) 进行下一次循环，继续outer处定义的循环
               // break outer 跳出outer标签处定义的(最外层循环处) 循环，跳出outer处定义的循环
            }
        }
        System.out.print(i+ " ");
	}
    
}

03章 方法

何谓方法？

**设计方法的原则： **

方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的扩展。

方法的优点：

• 使程序变得更简短而清晰。
• 有利于程序维护。
• 可以提高程序开发的效率。
• 提高了代码的重用性。

方法的定义

// 方法名：是方法的实际名称。方法名和参数表共同构成方法签名
修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

方法调用

Java 支持两种调用方法的方式，根据方法是否返回值来选择

• 当方法有返回值的时候，方法调用通常被当做一个值

  int larger = max(30, 40);
  

• 如果方法返回值是void，方法调用一定是一条语句

  System.out.println("Hello,kuangshen!");
  

public static void main(String[] args) {
    int i = 5;
    int j = 2;
    int k = max(i, j);
    System.out.println( i + " 和 " + j + " 比较，最大值是：" + k);
}

main 方法是被 JVM 调用的，除此之外，main 方法和其它方法没什么区别。JAVA中只有值传递！

main 方法的头部是不变的，带修饰符 public 和 static,返回 void 类型值，方法名字是main,此外带个一个String[] 类型参数。String[] 表明参数是字符串数组。

方法的重载

• 一个类
• 两个方法拥有相同的名字
• 不同的参数列表

public static double max(double num1, double num2) {
    if (num1 > num2)
        return num1;
    else
        return num2;
}

public static int max(int num1, int num2) {
    int result;
    if (num1 > num2)
        result = num1;
    else
        result = num2;
    return result;
}

拓展命令行传参

命令行参数是在执行程序时候紧跟在程序名字后面的信息。

下面的程序打印所有的命令行参数：

package com.jjh;
public class CommandLine {

    public static void main(String args[]){
    
        for(int i=0; i<args.length; i++){
            System.out.println("args[" + i + "]: " + args[i]);
        }
    
    }
    
}

命令行：

命令：
$ javac CommandLine.java
$ java com.jjh.CommandLine this is a command line 200 -100
    
结果：    
args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100

错误: 找不到或无法加载主类，解决方法：

package com.jjh; // 此处定义了包，所以命令行带上包的路径才能运行成功

public class CommandLine {

    public static void main(String[] args) {

        for(int i=0; i<args.length; i++){
            System.out.println("args[" + i + "]: " + args[i]);
        }

    }

}

在项目输出的项目目录下(src目录)执行java命令，写完整路径即可：

$ java com.jjh.CommandLine jin jia huan

可变参数

JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法。

方法的可变参数的声明如下所示：

typeName... parameterName

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public static void main(String args[]) {
    
    // 调用可变参数的方法
    printMax(34, 3, 3, 2, 56.5);
    printMax(new double[]{1, 2, 3});
    
}

// numbers实际上就是double类型的数组
public static void printMax(double... numbers) {
    if (numbers.length == 0) {
        System.out.println("No argument passed");
        return;
    }
    double result = numbers[0];
    //排序！
    for (int i = 1; i < numbers.length; i++) {
        if (numbers[i] > result) {
            result = numbers[i];
        }
    }
    System.out.println("The max value is " + result);
}

递归

递归就是：A方法调用A方法！就是自己调用自己，因此我们在设计递归算法时，一定要指明什么时候自己不调用自己。否则，就是个死循环！

递归结构包括两个部分

• 递归头。解答：什么时候不调用自身方法。如果没有头，将陷入死循环
• 递归体。解答：什么时候需要调用自身方法。

【演示：利用代码计算5的乘阶！】

//5*4*3*2*1
public static void main(String[] args) {
    System.out.println(f(5));
}
public static int f(int n) {
    if (1 == n){
        return 1;
    } else {
        return n*f(n-1);
    }
}

此题中，按照递归的三个条件来分析：

• 边界条件：阶乘，乘到最后一个数，即1的时候，返回1，程序执行到底
• 递归前进段：当前的参数不等于1的时候，继续调用自身；
• 递归返回段：从最大的数开始乘，如果当前参数是5，那么就是5 4，即5 (5-1)，即n * (n-1)

能不用递归就不用递归，递归都可以用迭代来代替。

04章 数组

概述

数组的定义：

• 数组是相同类型数据的有序集合.
• 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
• 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们

数组声明创建

声明数组

dataType[] arrayRefVar; // 首选的方法
或
dataType arrayRefVar[]; // 效果相同，但不是首选方法

创建数组

arrayRefVar = new dataType[arraySize];

上面的语法语句做了两件事：

• 使用 dataType[arraySize] 创建了一个数组
• 把新创建的数组的引用赋值给变量 arrayRefVar

数组变量的声明，和创建数组可以用一条语句完成，如下所示：

dataType[] arrayRefVar = new dataType[arraySize];

获取数组长度：

arrays.length

内存分析

• 声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关
• 声明一个数组的时候并没有数组被真正的创建
• 构造一个数组，必须指定长度

Java内存分析 ：

三种初始化

静态初始化

除了用new关键字来产生数组以外,还可以直接在定义数组的同时就为数组元素分配空间并赋值

int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};

动态初始化

数组定义、为数组元素分配空间、赋值的操作、分开进行。

int[] a = new int[2];
a[0]=1;
a[1]=2;

数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。(值就是数据类型的默认值)

public static void main(String[] args) {
    int[] a=new int[2];
    boolean[] b = new boolean[2];
    String[] s = new String[2];
    System.out.println(a[0]+":"+a[1]); //0,0
    System.out.println(b[0]+":"+b[1]); //false,false
    System.out.println(s[0]+":"+s[1]); //null, null
}

基本特点和边界

基本特点

• 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的
• 其元素必须是相同类型,不允许出现混合类型
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型
• 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

边界

下标的合法区间：[0, length-1]，如果越界就会报错；

ArrayIndexOutOfBoundsException : 数组下标越界异常

数组使用

普通for循环

For-Each 循环

JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。

【示例】

public static void main(String[] args) {
    double[] myList = {1.9, 2.9, 3.4, 3.5};
    // 打印所有数组元素
    for (double element: myList) {
    	System.out.println(element);
    }
}

数组作方法入参

数组可以作为参数传递给方法

比如main方法

数组作返回值

public static int[] reverse(int[] list) {
    int[] result = new int[list.length];
    for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
    	result[j] = list[i];
    }
    return result;
}

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

多维数组的动态初始化（以二维数组为例）

直接为每一维分配空间，格式如下：

type[][] typeName = new type[typeLength1][typeLength2];

• type 可以为基本数据类型和复合数据类型
• arraylenght1 和 arraylenght2 必须为正整数

多维数组的引用（以二维数组为例）

对二维数组中的每个元素，引用方式为 arrayName[index1] [index2] 例如：num[1] [0];

获取数组长度：

a.length获取的二维数组第一维数组的长度，a[0].length才是获取第二维第一个数组长度。

Arrays 类

数组的工具类java.util.Arrays

具有以下常用功能：

• 给数组赋值：通过 fill 方法
• 对数组排序：通过 sort 方法,按升序
• 比较数组：通过 equals 方法比较数组中元素值是否相等。
• 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
• 数组复制：copyOf(T[] original,int newLength) 从original中复制newLength个元素，返回新数组

常见排序算法

冒泡排序

冒泡排序算法的原理：

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个
• 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数
• 针对所有的元素重复以上的步骤，除了最后一个
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

public static void main(String[] args) {
    
        // 冒泡排序（倒叙）
        int[] a = {2,4,8,1,4,2,7,1,3,5};

        // 外层循环,定义一共走几次，每次都能排出最小的数
        for (int i = 0; i < a.length-1; i++) {

            boolean flag = false; //如果已经有序了，就退出循环，此时已经排列完毕

            // 每次内层循环完毕，都能排出最小的数,所以每次内层循环完毕，就能少走一次循环
            for (int j = 0; j < a.length-i-1; j++) {
                if(a[j] < a[j+1]){
                    // 换位置
                    int b=a[j];
                    a[j]=a[j+1];
                    a[j+1]=b;

                    flag=true;

                }
            }

            if(flag==false){
                break; // 排序完毕，退出循环
            }
    
}

选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最

大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到排序序列的

末尾。以此类推，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法

package com.jjh.array;

public class SelectSort {

    public int[] sort(int arr[]) {
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            
            // 认为目前的数就是最小的, 记录最小数的下标
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[minIndex] > arr[j]) {
                    // 修改最小值的下标
                    minIndex = j;
                }
            }
            // 当退出for就找到这次的最小值,就需要交换位置了
            if (i != minIndex) {
                //交换当前值和找到的最小值的位置
                temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
        return arr;
    }

    public static void main(String[] args) {
        SelectSort selectSort = new SelectSort();
        int[] array = {2, 5, 1, 6, 4, 9, 8, 5, 3, 1, 2, 0};
        int[] sort = selectSort.sort(array);
        for (int num : sort) {
            System.out.print(num + "\t");
        }
    }

}

稀疏数组

https://blog.csdn.net/baolingye/article/details/99943083

05章 面向对象

面向对象编程(Object-OrientedProgramming, OOP)

面向对象编程的本质就是：以类的方式组织代码，以对象的方式组织(封装)数据。

初始化和创建对象

对象所占的内存大小

该对象的所有属性所占的内存大小的总和，加上而外的对象隐性数据所占的大小。引用类型变量在32位系统上占4个字节，在64位 系统上占8个字节。

new关键字：

• 分配内存空间
• 给对象进行默认的初始化(属性的初始化，基本数据类型默认值是定义的默认值，引用数据类型默认值是null)
• 调用类中的构造方法

构造器

定义有参构造器后，要显示定义无参构造器，否则无参构造器就会不存在

内存分析

this关键字

• 调用类中的属性、方法、构造方法
• 表示当前对象

代码块

• 普通代码块：方法中的代码块
• 构造块:类中定义的代码块
  • 在每一次创建对象时执行（并不是在类加载时执行），始终在构造方法前执行。
• 静态代码块：类中使用static修饰的代码块，在类加载的时候执行，并且只会执行一次
• 同步代码块（多线程中讲解）

访问修饰符

​ 同类 同包 不同包子类 其他
​ public √ √ √ √
​ protected √ √ √
​ default √ √
​ private √

创建对象

创建对象会调用构造方法，调用构造方法不一定就是创建对象（子类构造方法第一行会调用父类的构造方法，但不会创建父类的对象）

封装

白话：该露的露，该藏的藏

专业：我们程序设计要追求**“高内聚，低耦合” **。

• 高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉；
• 低耦合：仅暴露少量的方法给外部使用

封装（数据的隐藏）

记住这句话就够了：属性私有，set/get

作用和意义

• 提高程序的安全性，保护数据。
• 隐藏代码的实现细节
• 统一用户的调用接口
• 提高系统的可维护性
• 便于调用者调用。

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
• extands的意思是“扩展”。子类是父类的扩展

继承

• 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等

• 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示

• 子类和父类之间,从意义上讲应该具有"is a"的关系

  student is a person
  dog is a animal
  

• 类和类之间的继承是单继承(接口和接口之间是多继承)

• 父类中的属性和方法可以被子类继承(可以理解为私有的属性和方法无法被继承，和下面讲述的有偏差，但效果一样)

  • 子类中继承了父类中的属性和方法后,在子类中能不能直接使用这些属性和方法,是和这些属性和方法原有
    的修饰符(public protected default private)相关的。
  • 父类中的属性和方法使用public修饰,在子类中继承后"可以直接"使用
  • 父类中的属性和方法使用private修饰,在子类中继承后"不可以直接"使用

• 父类中的构造器是不能被子类继承的,但是子类的构造器中,会隐式的调用父类中的无参构造器(默认使用super)

super关键字

• super调用父类的属性、方法、构造方法，但是private修饰的不能被调用
• super调用父类构造方法，必须是子类构造方法中的第一个语句。
• super只能出现在子类的方法或者构造方法中。
• super 和 this 不能够同时调用构造方法。（因为this也是在构造方法的第一个语句）

super 和 this 的区别

• this调用本类的属性和方法，如果本类的属性和方法没有，就去找父类中对应的属性和方法(了解即可，一般不用)

• 代表的事物不一样

  • this：本类、本身调用者这个对象
  • super：父类对象的引用

• 前提

  • this：没有继承也可以使用
  • super：只能在继承条件下才可以使用

• 构造方法

  • this()：本类的构造
  • super()：父类的构造

方法重写

重写只跟非静态方法有关

静态方法：

静态属性和静态方法的调用只和变量声明的类型相关

举例：

public class Demo01 {
    public static void main(String[] args) {
        
        A a = new A();
        B b = new A(); // 向上类型转换
        
        System.out.println(a.name); // A
        System.out.println(b.name); // B
        a.test(); // A→test()
        b.test(); // B→test()
    }
    
}

class A extends B {

    public static String name="A";

    public static void test(){
        System.out.println("A→test()");
    }
}

class B{

    public static String name="B";

    public static void test(){
        System.out.println("B→test()");
    }

}

非静态方法

两个类有继承关系，子类重写父类的方法

• 方法名必须相同，参数列表必须相同(方法签名相同)，方法体不同
• 修饰符：范围可以扩大但不能缩小(子类修饰符>=父类修饰符) public>protected>default>private
• 抛出的异常范围：可以缩小但不能扩大(子类异常<=父类异常)
• 父类中的方法若使用private、static、final任意修饰符修饰，不能被子类重写
  • static 静态方法，属于类，不属于实例
  • final 常量
  • private 私有的方法

多态

认识多态

动态编译：类型 可扩展性

理解：

Student s1 = new Student(); // 学生的对象可以是个学生
Person s2 = new Student(); // 学生也是个人
Object s3 = new Student(); // 学生也是个Object
// 一个Student对象，拥有Student、Person、Object三种形态

子类能调用自己的方法和继承父类的方法

父类可以指向子类，但是不能调用子类独有的方法

多态注意事项

• 多态是多态的方法，属性 没有多态
• 父类和子类有联系 否则会有类型转换异常
• 存在条件：继承关系，方法需要重写，父类的引用指向子类的对象

多态存在的条件

• 有继承关系
• 子类重写父类方法
  • 以下三种类型的方法是没有办法表现出多态特性的
    • static方法，因为被static修饰的方法是属于类的，而不是属于实例
    • final方法，因为被final修饰的方法无法被子类重写
    • private方法，因为被private修饰的方法对子类不可见
• 父类引用指向子类对象

instanceof和类型转换

instanceof

public class Person{
	public void run(){}
}

public class Student extends Person{
}

public class Teacher extends Person{
}

main:
Object object = new Student();
// 解释：当前的这个object对象引用指向的是Student对象，对应Student→Person→Object线路，所以前三个为true
System.out.println(object instanceof Student); //true
System.out.println(object instanceof Person); //true
System.out.println(object instanceof Object); //true
System.out.println(object instanceof Teacher); //false
System.out.println(object instanceof String); //false

Person object = new Student();
System.out.println(object instanceof Student); //true
System.out.println(object instanceof Person); //true
System.out.println(object instanceof Object); //true
System.out.println(object instanceof Teacher); //false
System.out.println(object instanceof String); // 编译报错

Student object = new Student();
System.out.println(object instanceof Student); //true
System.out.println(object instanceof Person); //true
System.out.println(object instanceof Object); //true
System.out.println(object instanceof Teacher); //编译报错
System.out.println(object instanceof String); // 编译报错

类型转换

自动类型转换(低→高) 可能会丢失自己本来的一些方法

强制类型转换(高→低)

修饰符

static关键字

属于类，不属于实例对象，随着类的加载而出现，类的卸载而消失

static属性

• 可通过 类名.属性名 的方式调用

static方法

• 可通过 类名.方法名 的方式调用
• 能调用静态属性，静态方法。不能调用非静态属性、非静态方法
  • static方法出现的比非静态属性、非静态方法早，调用根本找不到
  • this和super在类中属于非静态的变量，不能在静态方法中使用

static代码块

• 随着类加载被掉用，只调用一次
• 执行顺序：静态代码块>构造块(匿名代码块)>构造器(构造方法)

静态导入

静态导包就是java包的静态导入，用import static代替import ，静态导入包是JDK1.5中的新特性

意思是导入这个类里的静态方法

import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
    public static void main(String[] args) {
        //之前是需要Math.random()调用的
        System.out.println(random());
        System.out.println(PI);
    }
}

或者

import static java.lang.System.*;
import static java.lang.Math.*;
public class Demo02 {
    public static void main(String[] args) {

        //之前是需要Math.random()调用的
        out.println(random());
        out.println(PI);

    }  

final关键字

• 声明常量：修饰属性或者修饰局部变量（最终变量），不能被修改
• 修饰方法：只能被子类继承，但是不能被子类重写
• 修饰类：fianl修饰的类无法被继承
• 方法参数中使用final，在该方法内部不能修改参数的值（在内部类中详解）

常量类

​ 1.在该类中只有常量，通常是应用程序中公共的常量或标记

抽象类

• 可以没有抽象方法，有抽象方法的类必须是抽象类
• 不能创建对象，只能被继承，不能用final修饰
• 非抽象类继承抽象类必须实现所有抽象方法
• 抽象类可以继承抽象类，可以不实现父类抽象方法。
• 抽象类可以有构造方法

接口

约束，定义一些方法，不同的实现类实现

• 接口中都是抽象方法和常量，常量默认被public static final，方法默认被public abstract修饰，
• java1.8出现static方法：static方法正常使用，不影响使用契约。
• java1.8出现default方法实现类可以不必覆写default方法。default方法的目的是，当我们需要给接口新增一个方法时，会涉及到修改全部子类。如果新增的是default方法，那么子类就不必全部修改，只需要在需要覆写的地方去覆写新增方法。
• 接口可以继承多个接口，不实现接口的方法
• 一个类可以实现多个接口，抽象类实现接口可以不实现接口的方法

总结：

• 类的关系：单继承
• 接口的关系：多继承
• 类和接口的关系：多实现

内部类（小点代码）

内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

成员内部类

package com.innerclass;

public class Outer {

    private String name="zhangsan";
    private int age=23;

    class Inner{
        private String address="hebei";
        private String phone="835473950874350";

        public void show(){
            // 访问外部类的属性
            System.out.println(name);
            System.out.println(age);
            // 访问本类的属性
            System.out.println(address);
            System.out.println(phone);
        }
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Inner inner = outer.new Inner();
        inner.show();
    }

}

• 在类的内部定义，与实例变量、实例方法同级别的类

• 成员内部类中不能写静态属性和方法，但是能包含静态常量(不能包含static final 修饰的方法)

  private static final String HOBBY="篮球";
  

• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象

  • Outer outer = new Outer();
  • Inner inner = outer.new Inner();

• 当外部类和内部类存在重名属性时，会优先访问内部类的属性

  • 如果想要访问外部类的重名属性则使用，因为外部类对象的引用地址会传递给内部类对象

    Outer.this.name
    

静态内部类：

package com.innerclass;

public class StaticInnerTest{
    public static void main(String[] args) {
        StaticOuter.Inner inner = new StaticOuter.Inner();
        inner.show();
    }
}

class StaticOuter {

    private String name="xxx";
    private int age=18;

    // 静态内部类，和外部类相同(和外部类在同一级别)
    static class Inner{
        private String address="shanghai";
        private String phone="930547215";
        // 静态变量
        private static int count=10;

        public void show(){
            // 调用外部类属性
            StaticOuter outer = new StaticOuter();
            System.out.println(outer.name);
            System.out.println(outer.age);
            // 调用本类的属性和方法
            System.out.println(address);
            System.out.println(phone);
            System.out.println(Inner.count);
        }

    }

}

static修饰的内部类就叫静态内部类。

• 和外部类在同一个级别，所以访问外部类实例成员，需要创建外部类对象

• 不依赖外部类对象，可直接创建或者通过类名访问，可声明静态成员

  • StaticOuter.Inner inner = new StaticOuter.Inner();
  • inner.show();

• 只能直接访问外部类的静态成员，访问外部类的实例成员需要实例化外部类对象

  • StaticOuter outer = new StaticOuter();
  • outer.name

局部内部类：

定义在外部类的方法当中，作用范围和创建对象范围仅限于当前方法，所以

• 要在外部类的方法当中创建对象

package com.innerclass;

public class JuBuInnerTest {
    public static void main(String[] args) {
        JuBuOuter juBuOuter = new JuBuOuter();
        juBuOuter.show();
    }
}

class JuBuOuter{
    private String name="zhangsan";
    private int age=12;

    // 外部方法
    public void show(){
        // 定义局部变量
        String address="shanghai";
        // 局部内部类：不能加任何的访问修饰符
        class Inner{
            // 局部内部类的属性
            private String phone="9543793075";
            private String email="3842@qq.com";
            // 定义静态常量
            static final int count=2000;
            // 局部内部类的方法
            public void show2(){
                // 访问外部类的属性
                System.out.println(JuBuOuter.this.name);
                System.out.println(JuBuOuter.this.age);
                System.out.println(phone);
                System.out.println(email);
                // 访问局部变量，jdk1.7要求，变量必须是常量final，jdk1.8自动添加final
                System.out.println(address);
            }
        }

        Inner inner = new Inner();
        inner.show2();

    }

}

局部内部类和成员内部类是一样的(访问外部类的属性和方法，重名机制，不能定义静态变量(但是可以定义静态常量)、方法等，要注意以下四点区别：

• 局部内部类不能有任何的访问修饰符
• 当外部类的方法是静态方法时，局部内部类不能访问外部类的非静态属性和方法
• 外部类方法定义的局部变量就是常量
  • 原因：根据上面的例子解释
  • 如果不是常量，局部变量address就会随着show方法执行完毕而消失
  • 但是局部内部类Inner所在的方法区数据和Inner对象inner指向的堆内存数据不会立刻消失
  • show2方法此时会找不到局部变量address，所以要定义为常量，放在常量池中
• 局部内部类要在外部类方法中创建对象

匿名内部类

没有名字的局部内部类(一切特征都与局部内部类相同)

package com.innerclass;

public class NiMingInnerTest {
    public static void main(String[] args) {

        // 局部内部类
        class Inner implements USB {
            @Override
            public void service() {
                System.out.println("风扇接口，风扇转起来了");
            }
        }
        // 调用局部内部类实现接口的方法
        new Inner().service();

        // 匿名内部类，可以把{...}看成接口的实现类，只是没有名字。new 实现类 就得到了对象
        USB usb=new USB(){
            @Override
            public void service() {
                System.out.println("键盘接口，键盘开始工作了");
            }
        };
        // 调用匿名内部类实现接口的方法
        usb.service();

    }
}

// 定义接口
interface USB {
    // 接口方法的默认修饰符 public abstract
    void service();
}

• 必须继承一个父类或者实现一个接口
• 定义类，实现类，创建对象的语法合并，只能创建一个该类的对象
• 优点：减少代码量
• 缺点：可读性较差

难点理解

静态变量和静态常量

为什么成员/局部内部类不能有静态变量，但是可以有静态常量

为什么不能有静态变量

静态变量是要占用内存的，在编译时只要是定义为静态变量了，系统就会自动分配内存给他。

因为系统执行：运行宿主类->静态变量内存分配->内部类

java虚拟机要求所有的静态变量在类加载过程中的初始化阶段将符号引用变为直接引用，来为其分配内存。

而static的语义，就是主类能直接通过内部类名来访问内部类中的static方法，而非static的内部类又是不会自动加载的，就会造成冲突

为什么可以有静态常量

首先理解编译期常量和非编译期常量

编译期常量：static final int num=20

非编译期常量(运行期常量)：static final int num=(int) Math.random()

编译期常量是不需要加载类的字节码文件的，会在编译阶段确定值，很多书上将这一步称之为编译期常量折叠【编译器在编译阶段通过语法分析计算出常量表达式的具体值】。

非编译期常量，对于这样的值而言编译期无法折叠，编译器只能做一些语法检查，比如该常量之是否在其他地方做了修改等。既然无法确定值，那么就会导致该常量值的确定需要类被加载时确定，所以就和静态常量是一样的。

数据是否能够访问的依据

内部类种类有多种，内部类和外部类的数据相互访问成为一个十分难理解的点。比如每一种内部类，外部类能够访问内部类的东西有什么。内部类能够访问外部类的东西有什么。我们该依据什么进行判断？？？？

判断是否能够访问的依据就是：在用到这个东西的时候，分析这个东西存在还是不存在 ，所以前提是要了解内部类加载的时机。这里的东西指的这个类或属性或方法

举例说明：

成员内部类

外部类访问内部类的东西

外部类的静态部分能不能访问内部类的东西，

分析：当在静态部分访问内部类某个东西的时候，这个东西是不存在的，因为在访问的时候，不会引起内部类的加载，这个类都没有加载进来，肯定是没有这个东西的。

外部类的实例部分能不能访问内部类的东西

分析：外部类的实例部分依赖于外部类的对象，当访问这个内部类时，这个内部类是存在的，因为会引起内部类的加载，内部类加载进来之后，就可以通过这个内部类去创建对象，调用里面的东西。当时如果直接访问内部类里面的东西，这个东西是不存在的，因为访问里面的东西，并不会引起内部类的加载，所以东西不存在。

内部类访问外部类的东西

因为内部类在使用外部类东西的时候，外部类已经被加载进来，并且还创建了外部类的对象。所以不管是外部类的静态的东西还是实例的东西，内部类都能够进行直接的访问。因为这些东西统统存在。

静态内部类

外部类访问内部类的东西

外部类的静态部分能不能访问内部类的东西

分析：外部类的静态部分如果使用到这个类，会引起内部类的加载。因为加载所以内部类会存在，外部类能使用内部类。能不能直接使用内部类静态部分和实例部分，不能，因为使用这个东西的时候，不会导致内部类加载，所以不存在。

外部类的实例部分能不能访问内部类的东西

分析：实例部分可以使用内部类，因为会导致内部类的加载，所以内部类会存在。但是不能使用内部类里面的东西，因为直接使用不会导致内部类的加载，所以这些东西不存在

内部类访问外部类的东西

内部类可以使用外部类，因为在使用的时候，外部类肯定已经加载了。因为内部类在加载之前，如果外部类没有加载，会先加载外部类，在加载内部类。所以外部类在使用的时候一定存在。内部类用外部类的静态部分，因为外部类的静态东西已经存在，能直接用。但是内部类不能直接用外部类的实例部分，因为虽然外部类已经加载进来，但是并没有创建外部类的对象，针对内部类来说，外部类的对象还不存在，不能使用实例部分。

06章 异常

概念

检查性异常

最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的，例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略

运行时异常

运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略

错误

错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的

异常体系结构

Java把异常当作对象来处理，并定义一个基类 java.lang.Throwable 作为所有异常的超类

异常之间的区别与联系

Error

Error 类对象由 Java 虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关

比如：

• Java虚拟机运行错误（ Virtual MachineError ）
• 发生在虚拟机试图执行应用时如类定义错误（ NoClassDefFoundError ）、链接错误（ LinkageError ）

对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况

Exception

在 Exception 分支中有一个重要的子类 RuntimeException （运行时异常）

• ArrayIndexOutOfBoundsException （数组下标越界）
• NullPointerException （空指针异常）
• ArithmeticException （算术异常）
• MissingResourceException （丢失资源）
• ClassNotFoundException （找不到类）

这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生

而RuntimeException 之外的异常我们统称为非运行时异常，类型上属于 Exception 类及其子类从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。

• IOException
• SQLException
• 用户自定义的 Exception 异常

Error 和 Exception 的区别：

Error 通常是灾难性的致命错误，程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程

Exception 通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常

异常处理的语法规则

• try、catch、finally语句不能单独存在，try...catch...finally、try...catch、try...finally三种结构。catch语句可以有一个或多个，finally语句最多一个。

• try、catch、finally三个代码块中变量的作用域分别独立而不能相互访问。

• 多个catch块时候，从小到大的范围去捕获异常，Java虚拟机会匹配其中一个异常类或其子类，就执行这个catch块，而不会再执行别的catch块

异常中return处理机制

try和catch中如果有return，先将返回值保存到栈内存中。执行finally语句完毕，在执行try或者catch中的return语句，将返回值返回。

• 执行try，catch ， 给返回值赋值
• 执行finally
• return

throw和thows

throw：常用在方法中手动抛出异常

throws：在方法上抛出异常

经验总结

assert关键字，表示断言。

断言语句一般用于程序不准备通过抛出异常来处理的错误。

• assert expression; expression为true，往下执行。为false，出现异常，程序退出。
• assert expression1:expression2; expression1为true，忽略expression2，往下执行。为false，运行expression2，然后退出程序。expression2是一个基本类型或者Object类型

开启断言

断言的格式

// 布尔表达式为真，则继续执行，否则，程序停止执行。
assert  布尔表达式 ：“错误说明”（错误说明可有可无，不影响）   

举例

// 如果条件为true，程序继续执行
public static void main(String[] args) {
    int i =10;
    assert i>0:"i必须是大于0的数字";
    System.out.println(i);
}
打印：
	10
	
=========================================================================================
// 如果添加为假，抛出错误，程序结束执行
public static void main(String[] args) {
    int i =-10;
    assert i>0:"i必须是大于0的数字";
    System.out.println(i);
}
打印：
	Exception in thread "main" java.lang.AssertionError: i必须是大于0的数字
	at com.mycode.jichu.Test06.main(Test06.java:7)

断言的优点

使用Assert可以避免很多的if else嵌套，比起抛出异常的方式，Aseert能更简洁。

Assert可以减少代码单侧case（案例），从而减少代码单侧代码量，还能提高代码单侧覆盖率

断言能够帮助别人或未来的你理解代码，找出程序中逻辑不对的地方。一方面，断言会提醒你某个对象应该处于何种状态

07章 常用类库

Object

超类、基类，所有类都直接或者间接的继承此类(包括数组)，位于继承树的最顶层

任何类，如果没有显示的extends继承某个类，默认继承的就是Object类，否则为间接继承Object类定义的方法，是所有对象都具备的方法

Object类型可以存储任何对象

• 作为参数，可接受任何对象
• 作为返回值，可返回任何对象

getClass

获取运行时对象所属类的类对象

public final native Class<?> getClass();

hashCode

返回该对象的哈希码值

• 哈希值根据对象的引用地址或字符串或数字使用hash算法计算出来的int类型的数值
• 一般情况下，相同对象返回相同的哈希码值

public native int hashCode();

toString

一般情况下，子类都重写此方法

public String toString() {
    // getClass().getName() 类名
    // @ 标记位
    // Integer.toHexString(hashCode()) 此对象哈希码的无符号十六进制表示组成
	return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

equals

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

重写equals方法步骤：

class Student{
    private String name;
    private String age;

    public Student() {
    }

    public Student(String name, String age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        // 判断两个对象是否是同一个引用
        if(super.equals(obj)){
            return true;
        }
        // 判断obj是否是null
        if(obj==null){
            return false;
        }
        // 判断是否是同一个类型
        if(obj instanceof Student){
            // 进行强制类型转换
            Student s=(Student)obj;
            // 比较属性
            if(this.name.equals(s.name) && this.age==s.age){
                return true;
            }
        }
        return false;
    }
}

• 判断引用地址
• 判断传入的对象是否为null
• 判断是否属于同一个类型
• 进行强制类型
• 比较属性是否相等

finalize

protected void finalize() throws Throwable { }

• 当对象被判定为垃圾对象时，有jvm自动调用此方法，用以标记垃圾对象，进入回收队列。这样的话，jvm在下一次垃圾回收动作发生时，才会真正回收对象占用的内存。
• 垃圾对象：没有任何引用的对象
• System.gc(),通知垃圾回收器该回收垃圾了，垃圾回收器会将对象放进垃圾队列，垃圾回收器到底回不回收，由自身决定

class Student{
    private String name;
    private String age;

    public Student() {
    }

    public Student(String name, String age) {
        this.name = name;
        this.age = age;
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"回收了");
    }
    
    public static void main(String[] args) {
        // 创建垃圾对象，因为在栈内存中没有任何的引用
        new Student("张三","17");
        new Student("李四","18");
        new Student("王五","18");
        new Student("赵六","18");

        // 通知垃圾回收器回收垃圾对象，只是通知
        // 垃圾回收器发现有垃圾对象，就会将对象放入回收队列，等待下次发起回收动作进行回收
        System.gc();
    }
    
}    

包装类

Java为每种基本数据类型分别设计了对应的类，称之为包装类(Wrapper Classes)，也有教材称为外覆类或数据类型类

每个包装类的对象可以封装一个相应的基本类型的数据，并提供了其它一些有用的方法。包装类对象一经创建，其内容（所封装的基本类型数据值）不可改变。

以Integer为例子

private final int value;

装箱和拆箱

基本类型和对应的包装类可以相互装换：

• 由基本类型向对应的包装类转换称为装箱，例如把 int 包装成 Integer 类的对象
• 包装类向对应的基本类型转换称为拆箱，例如把 Integer 类的对象重新简化为 int

以Integer为例：

// jdk1.5之前
// 装箱
Integer integer1=new Integer(10);
Integer integer2 = Integer.valueOf(10);
// 拆箱
int i1 = integer1.intValue();

// jdk1.5之后，自动装箱和拆箱
// 自动装箱
Integer integer3=10;
// 自动拆箱
int i3=integer3;

类型转换

类型转换需要保证类型兼容，否则就会出现类型转换异常

8种包装类提供不同类型间的转换方式

• Number父类中提供的6个共性方法
• parseXXX() 静态方法 字符串转换成基本类型
• valueOf() 静态方法 基本类型转换为包装类型

// 基本类型和字符串之间的转换

// 基本类型转换成字符串
System.out.println(10 + "");
System.out.println(Integer.toString(10));
System.out.println(Integer.toString(15, 16)); // 指定进制 16表示16进制

// 字符串转换为基本类型
int i1 = Integer.parseInt("150");

// boolean字符串转成基本类型 "true"→true，非"true"→false
System.out.println(Boolean.parseBoolean("true")); // true
System.out.println(Boolean.parseBoolean("false")); // false
System.out.println(Boolean.parseBoolean("dkjflasdjfs")); // flase

Integer缓冲区

java预先创建256个常用的整数包装类型的对象

取值范围：【-128 - 127】

// 示例1
Integer integer1 = new Integer(10);
Integer integer2 = new Integer(10);
System.out.println(integer1 == integer2); // false
// 示例2
Integer integer3 = Integer.valueOf(100);
Integer integer4 = Integer.valueOf(100);
System.out.println(integer3 == integer4); // true
// 示例3
Integer integer5 = 100;
Integer integer6= 100;
System.out.println(integer5 == integer6); // true
// 示例3
Integer integer7 = Integer.valueOf(200);
Integer integer8 = Integer.valueOf(200);
System.out.println(integer7 == integer8); // false

String

字符串是常量，创建之后不可改变

字符串字面值存储在字符串常量池中(常量池在方法区中)，目的就是为了可以实现共享

创建和内存分析

• String s = "lisi"；产生一个对象，字符串常量池存储"lisi"

String s1="lisi"; 
System.out.println(s1.hashCode()); // 3322003
// 字符串不可变性指的是在字符串常量池中并没有把"lisi"改为"zhangsan"，而是重新开辟了内存空间，新增了"zhangsan"
// 然后把变量s1的16进制引用地址改成了引用"zhangsan"的16进制地址
s1="zhangsan"; 
System.out.println(s1.hashCode()); // -1432604556
String s2="zhangsan";
System.out.println(s1.hashCode()); // -1432604556
System.out.println(s2.hashCode()); // -1432604556
System.out.println(s1 == s2); // true

• String s1 = new String("lisi")；产生两个对象，堆、池各存储一个

String s1 = new String("lisi");
String s2 = new String("lisi");
System.out.println(s1 == s2); // false

常用方法

compareTo

比较两个字符串在字典中的位置(大小)

String s1 = "abc"; // 【a：97】【b：98】【c:99】
String s2 = "xyzwerwe"; // 【x：120】【y：121】【z：122】
// 比较原则1
// s1的a先和s2的x通过字符编码集对应的数字值进行比较(减操作)，
// 如果为0(代表两个字符相等)，比较下一个字符，否则返回相减后的值
System.out.println(s1.compareTo(s2)); // -23

String s3 = "abc";
String s4 = "abcwerwe";
// 比较原则2
// 如果通过比较原则1得不到结果，就比较两个字符串的长度，返回长度相减后的值
System.out.println(s3.compareTo(s4)); // -5

StringBuffer和StringBuilder

StringBuffer：

可变长字符串，jdk1.0提供，运行效率缓慢、线程安全

StringBuilder：

可变长字符串，jdk5.0提供，运行效率快、线程不安全

以下方法通用，以StringBuffer为例：

StringBuffer stringBuffer = new StringBuffer();

// append 追加
stringBuffer.append("zhangsan "); // zhangsan
stringBuffer.append("lisi "); // zhangsan lisi
// insert 添加
stringBuffer.insert(0,"wangwu "); // wangwu zhangsan lisi
// replace 指定索引区间(左闭右开)替换，String只能替换指定的旧字符串
stringBuffer.replace(0,7,"zhaoliu "); // zhaoliu zhangsan lisi
// delete 指定索引区间(左闭右开)删除
stringBuffer.delete(0,8); // zhangsan lisi
// 清空
stringBuffer.delete(0,stringBuffer.length()-1); // 啥也没有，空字符串

BigDecimal

由于float和double使用的是近似存储，会丢失精度(无限的接近于准确值)，所以使用BigDecimal，能精确计算浮点数

double d1 = 0.3;
double d2 = 0.2;
System.out.println(d1-d2); // 0.09999999999999998
System.out.println((d1-d2)/d2); // 0.4999999999999999

BigDecimal d3 = new BigDecimal("0.3");
BigDecimal d4 = new BigDecimal("0.2");
// 减
BigDecimal subtract3 = d3.subtract(d4); // 0.1
// 加
BigDecimal add3 = d3.add(d4); // 0.5
// 乘
BigDecimal multiply3 = d3.multiply(d4); // 0.06
// 除
BigDecimal divide3 = d3.divide(d4); // 1.5
// 使用除法如果除不尽，就会产生异常，通过保留小数的形式解决
BigDecimal bigDecimal1 = new BigDecimal("10.0");
BigDecimal bigDecimal2 = new BigDecimal("3.0");
// 2 保留小数的位数 BigDecimal.ROUND_HALF_UP 采用四舍五入的方式
BigDecimal divide1 = bigDecimal1.divide(bigDecimal2,2, BigDecimal.ROUND_HALF_UP); // 3.33

Date

表示特定的瞬间，精确到毫秒。

Date类中的大部分方法都已经被Calender类中的方法所取代

时间单位：

• 1秒=1000毫秒
• 1毫秒=1000微秒
• 1微秒=1000纳秒(毫微秒)

// 今天
Date date = new Date();
System.out.println(date); // Wed May 10 23:48:19 CST 2023
System.out.println(date.toLocaleString()); // 2023-5-10 23:48:19
// 昨天
Date date2 = new Date(date.getTime()-24*60*60*1000);
System.out.println(date2.toLocaleString()); // 2023-5-9 23:48:19

// after 是否在data2之后
System.out.println(date.after(date2)); // true
// before 是否在data2之前
System.out.println(date.before(date2)); // false
// compareTo 比较两个日期的毫秒值，减操作，如果>0,返回1，<0 返回-1，=0 返回0
System.out.println(date.compareTo(date2)); // 1
// equals 比较两个时间是否相等
System.out.println(date.equals(date2)); // false
// getTime 从1970.1.1 00:00:00 时刻到date时刻的毫秒数(针对中国时区是1970.1.1 08:00:00)
System.out.println(date.getTime()); // 1683734451144
// setTime 从1970.1.1 00:00:00 时刻开始，设置的毫秒点(针对中国时区是1970.1.1 08:00:00)
date.setTime(24*60*60*1000);
System.out.println(date.toLocaleString()); // 1970-1-2 8:00:00

Calendar

提供了获取和设置各种日历字段的方法

其构造方法使用了protected修饰，因此无法直接创建对象

基本操作

Calendar calendar = Calendar.getInstance();
// getTimeInMillis 获取毫秒值(针对中国时区是1970.1.1 08:00:00)
System.out.println(calendar.getTimeInMillis()); // 1683744245628
// getTime() 转换为Date类型，设置日期(DATE,DAY_OF_MONTH)和小时(HOUR,AM,PM,HOUR_OF_DAY)的默认值
System.out.println(calendar.getTime().toLocaleString()); // 2023-5-11 2:44:05

获取时间字段

Calendar calendar = Calendar.getInstance(); // 2023-5-11 2:44:05
// YEAR 获取年
int year = calendar.get(Calendar.YEAR); // 2023
// MONTH 获取月
int month = calendar.get(Calendar.MONTH); // 4 月份从0开始(0是1月)
// DAY_OF_MONTH 获取日
int day = calendar.get(Calendar.DAY_OF_MONTH); // 11
// HOUR 获取小时 12小时制
int hour12 = calendar.get(Calendar.HOUR); // 2 HOUR_OF_DAY 24小时
// MINUTE 分钟
int minute = calendar.get(Calendar.MINUTE); // 44
// SECOND 秒
int second = calendar.get(Calendar.SECOND); // 5

修改时间

Calendar calendar2 = Calendar.getInstance();
System.out.println(calendar2.getTime().toLocaleString()); // 2023-5-11 0:40:59
calendar2.set(Calendar.MONTH,3); // 设置3，其实设置的是4月
System.out.println(calendar2.getTime().toLocaleString()); // 2023-4-10 0:40:59
calendar2.set(Calendar.DAY_OF_MONTH,10);
System.out.println(calendar2.getTime().toLocaleString()); // 2023-5-10 0:40:59

计算(运算)时间

Calendar calendar3 = Calendar.getInstance();
System.out.println(calendar3.getTime().toLocaleString()); // 2023-5-11 0:49:57
calendar3.add(Calendar.DAY_OF_MONTH,1); // 加1天
System.out.println(calendar3.getTime().toLocaleString()); // 2023-5-12 0:49:57

清空时间

Calendar calendar4 = Calendar.getInstance();
System.out.println(calendar4.getTime().toLocaleString()); // 2023-5-11 2:44:05
// 清空年
calendar4.clear(Calendar.YEAR);
System.out.println(calendar4.getTime().toLocaleString()); // 1970-5-11 2:44:05
// 清空月
calendar4.clear(Calendar.MONTH);
System.out.println(calendar4.getTime().toLocaleString()); // 1970-1-11 2:44:05
// 清空分钟
calendar4.clear(Calendar.MINUTE);
System.out.println(calendar4.getTime().toLocaleString()); // 1970-1-11 2:00:05
// 清空秒
calendar4.clear(Calendar.SECOND);
System.out.println(calendar4.getTime().toLocaleString()); // 1970-1-11 2:00:00
// 全部清空，一步到位
calendar4.clear();
System.out.println(calendar4.getTime().toLocaleString()); // 1970-1-1 0:00:00
// 此时的毫秒数为-28800000而不是0，说明开始计算时间从中国的 1970-1-1 08:00:00 时为开始时间
// 因为和标准地区的时间相差8个小时
System.out.println(calendar4.getTimeInMillis()); // -28800000

清空日期和小时(不生效)

清空时间针对日期(DATE,DAY_OF_MONTH)和小时(HOUR,AM,PM,HOUR_OF_DAY)不会生效

调用getTime()方法会设置其默认值

清空日期演示

Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString()); // 2023-5-11 3:04:45

// 清空不生效，此时的默认日期还是11号
calendar.clear(Calendar.DAY_OF_MONTH);
System.out.println(calendar.getTime().toLocaleString()); // 2023-5-11 3:04:45

// 设置日期为22号，但是默认日期仍然是11号
calendar.set(Calendar.DAY_OF_MONTH,22);  
// 清空不生效，此时的默认日期还是11号
calendar.clear(Calendar.DAY_OF_MONTH);
System.out.println(calendar.getTime().toLocaleString()); // 2023-5-11 3:04:45

// 设置日期为22号，但是默认日期仍然是11号
calendar.set(Calendar.DAY_OF_MONTH,22);
// getTime() 会将默认日期由11号改为设置的22号
System.out.println(calendar.getTime().toLocaleString()); // 2023-5-22 3:04:45
// 清空不生效，但是默认日期是22号
calendar.clear(Calendar.DAY_OF_MONTH);
System.out.println(calendar.getTime().toLocaleString()); // 2023-5-22 3:04:45

清空小时演示

Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString()); // 2023-5-11 3:16:48

// 清空不生效，此时的默认小时还是3时
calendar.clear(Calendar.HOUR_OF_DAY);
System.out.println(calendar.getTime().toLocaleString()); // 2023-5-11 3:16:48

// 设置小时为22时，但是默认小时仍然是3时
calendar.set(Calendar.HOUR_OF_DAY,22);
// 清空不生效，此时的默认小时还是3时
calendar.clear(Calendar.HOUR_OF_DAY);
System.out.println(calendar.getTime().toLocaleString()); // 2023-5-11 3:16:48

// 设置小时为22时，但是默认小时仍然是3时
calendar.set(Calendar.HOUR_OF_DAY,22);
// getTime() 会将默认小时由3时改为设置的22时
System.out.println(calendar.getTime().toLocaleString()); // 2023-5-11 22:16:48
// 清空不生效，但是默认小时是22时
calendar.clear(Calendar.HOUR_OF_DAY);
System.out.println(calendar.getTime().toLocaleString()); // 2023-5-11 22:16:48

补充方法

Calendar calendar5 = Calendar.getInstance();
System.out.println(calendar5.getTime().toLocaleString()); // 2023-5-11 2:44:05
// 获取最大值
int actualMaximum = calendar5.getActualMaximum(Calendar.DAY_OF_MONTH); // 获取本月最大值 31
// 获取最小值
int actualMinimum = calendar5.getActualMinimum(Calendar.DAY_OF_MONTH); // 获取本月最小值 1

SimpleDateFormat

进行日期格式化

• 日期→字符串
• 字符串→日期

// 字符串→日期
Date date = format.parse("1970-1-1 00:00:00");
System.out.println(date.toLocaleString()); // 1970-1-1 0:00:00
// 日期→字符串
String formatStr = format.format(date); 
System.out.println(formatStr); // 1970-01-01 00:00:00

System

// 数组复制
int[] arr = {23,432,542,31,545,867,13,654};
int[] dest = new int[8];
// arr 源数组
// srcPost 开始位置
// dest 目标数组
// destPost 目标数组开始位置
// length：复制长度
// 效率高
System.arraycopy(arr,0,dest,0,arr.length);
System.out.println(Arrays.toString(dest)); // [23, 432, 542, 31, 545, 867, 13, 654]
// 效率低
int[] copy = Arrays.copyOf(arr, arr.length);
System.out.println(Arrays.toString(copy)); // [23, 432, 542, 31, 545, 867, 13, 654]

// 获取毫秒数，经常用来计算某段逻辑代码的运行时间
long currentTimeMillis = System.currentTimeMillis();
for (int i = 0; i < 1000; i++) {
    System.out.println(i);
}
System.out.println(System.currentTimeMillis()-currentTimeMillis); // 31(毫秒)

// 告知垃圾回收器回收垃圾，会将垃圾对象放进回收队列，当jvm真正发起回收动作时，垃圾对象才被真正的回收
System.gc();

// 手动退出程序
System.exit(0);

表达式

​ 1.语法：(parameters) -> { statements; }（重写抽象方法）
​ 2.举例：TwoParameterNoReturn twoParameterNoReturn = (str1, str2) -> {System.out.println(str1 + str2);};
​ 3.匿名内部类只能使用被 final 修饰的局部变量。Lambda 表达式中使用的局部变量可以不用声明为 final，但是必须不可 被后面的代码修改，即隐性的具有 final 的语义。
​ 4.在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者变量。

08章 泛型

​ 是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型

定义规则

​ 1.泛型类：修饰符 class 类名<代表泛型的变量> { } public class GenericsClassDemo

​ 2.泛型接口：修饰符 interface接口名<代表泛型的变量> { } public interface GenericsInteface

​ 3.泛型方法：修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ } public T genercMethod(T t)

通配符

​ 1.?，可以传入任意的类型，但是只是接收输出，并不能修改

​ 2.泛型的上限，类型名称 <? extends 类 > 对象名称，能接收该类型及其子类。
​ 1.ArrayList<? extends Animal> list = new ArrayList

本栏目推荐文章
• 深入探索JVM：理解Java程序在虚拟机中的存储和管理
• 用jacoco统计JAVA项目测试代码覆盖率
• Java实现在线编辑预览office文档
• Java小细节之缩进中if 和else的对应关系
• 春眠不觉晓，Java数据类型知多少？基础牢不牢看完本文就有数了
• idea 中java代码修改后运行代码不生效
• Java日期时间处理详解
• java项目(jar包)配置为开机自启 jar包bat脚本启动和配置为开机自启
• Java中锁的解决方案
• Java学习之路1