Java学习笔记

前言

以下内容仅为个人学习笔记分享。
目前本人任在学习中，以下为个人学习方法。
在网上找视频自学（此笔记跟随黑马程序员Java视频），多思考模仿写出代码的思维，将自己的想法与他人想法对比，独立完成多个代码知识点相关练习，以达到熟能生巧的效果。

快捷键

alt+insert
    alt+insert+Fn
    自动生成javabean

Shift+F6
    批量更改

Alt+Enter
    改错

Ctrl+P
    查看（）内顺序

Ctrl+Alt+V
    自动生成左边

Ctrl+B
    源码查看

Ctrl+F
    控制台搜索

Ctrl+Alt+T
    将代码包果，放入循环等

Ctrl+Alt+M
    将代码包裹，变成方法

数字、数组.fori
    自动生成for循环

字符串.length.fori
    自动生成for循环

入门

CMD
    打开
        Win+R
        输入CMD
        按下回车键

    常用命令
        盘符名称+冒号
            说明：盘符切换
            举例：E：回车，表示切换到E盘

        dir
            说明：查看当前路径下的内容

        cd目录
            说明：进入单级目录
            举例：cd itheima

        cd..
            说明：回退到上一级目录

        cd 目录1\目录2\...
            说明：进入多级目录。
            举例：cd itheimaVavaSE 

        cls
            说明：清屏。

        exit
            说明：退出命令提示符窗口。

        cd\
            说明：回退到盘符目录。



JDK
    是Java开发工具包
        JVM虚拟机：Java程序运行的地方
        核心类库：Java已经写好的东西，可以直接用


JRE
    Java运行环境
    组成
        JVM，核心类库，运行工具

Java编程基础

基本语法
    键盘录入
        步骤
        第一套体系
             接收整数
                nextInt( );

            接收小数
                nextDouble( );

            接收字符串
                next( );

            遇到空格，制表符，回车就停止接受。这些符号后面的数据就不会接受了

        第二套体系
            nextLine( );
                接收字符串

            可以接收空格，制表符，遇到回车才停止接受数据

        混用弊端
             先用nextInt，再用nextLine，会导致下面的nextLine接受不到数据


    获取随机数
        导包--Random这个类在哪里
            import java.util.Random;
            导包的动作必须出现在类定义的上面

        创建对象--表示我要使用Random这个类
            Random r=new Random( );
            r是变量名，可以改变，其他的不能变

        生成随机数
            int number=r.nextInt(随机数的范围)
            范围从0开始，到这个数-1结束
            自定义范围生成方式
                尾巴+（一个数）
                    例：7-15：int number = r.nextInt( bound: 9) + 7;




    输出语句
        System.out.println（）；
        System.out.print（）；
        System.out.printf（）；
            %s，占位符


    基本格式
        格式
            class关键字：定义一个类

        分类
            结构定义语句
                声明一个类或者方法

            功能执行语句
                实现具体功能
                每条功能执行语句必须以分号（;）结束


        注意
            连续的字符串不能分成两行写
                字符串之间可以用"+"连接，在（+）处可换行

            Java语句严格区分大小写


    注释
        单行注释   格式：//注释信息
        多行注释   格式：/*注释信息 * /
        文档注释   格式：/**注释信息 */

    标识符
        由字母、数字、下划线（_）、美元符号（＄）组成
        不能以数字开头
        不能是关键字
        不能是null、true、fales

    关键字
        特定含义的英文单词
        字母全部小写
        不能用于命名标识符

    常量
        整型常量
            整数类型的数据

        浮点型常量
            单精度浮点数
                float
                以F或f结尾
                    2e3f


            双精度浮点数
                double
                以D或d结尾
                    3.84d

                若不使用后缀，则默认double类型


        字符常量
            用于表示一个字符
            要用'  '括起来
                'a'


        字符串常量
            表示一串连续的字符
            要用" "括起来
                "HelloWorld"


        布尔常量
            用于区分事物的真假
            true和flase

        null常量
            只有null一个值
            表示对象的引用为空



		变量
    		变量的数据类型
        	整数类型变量
            byte
            short
            int
            long
                所赋值的后面要加上l或L
                若长度未超过int类型，则可省


        浮点类型变量
            float
                所赋值的后面要加上f或F
                    float a=123.4f


            double
                可以在所赋值的后面要加上d或D

            可以给浮点数类型变量赋整数值

        字符类型变量
            Unicode为为每个字符制定了一个唯一的字符
                小写字母a是用97表示的（一下两式赋值的都是a）
                    char c='a';
                    char ch=97
                    所以：System.out.println(1+'a');//=98



        布尔类型变量
            使用boolean定义布尔类型变量


    变量的类型转换
        自动类型转换（隐式类型转换）
            定义
                两种数据类型在转换的过程中不需要显式声明

            条件
                两种数据类型彼此兼容
                目标类型的取值范围大于源类型的取值范围
                    byte

Java中的运算符

    算数运算符
        自增（++）和自减（——）运算
            单独使用
                ++和-- 无论是放在变量的前边还是后边，单独写一行结果是一样的
                    i++


            如果++或——在操作数之前
                先进行自增（减）运算，再进行其他运算

            如果++或——在操作数之后
                先进行其他运算，再进行自增（减）运算

            例

        除法运算
            除数与被除数都是整数时，结果一定为整数
            有小数参与，结果肯定为小数

        取模运算
            结果的正负取决于被模数（%左边）的符号


    赋值运算符
        例：a+=b→a=a+b
        将右边表达式的结果赋值给左边的变量
        一条赋值语句对多个变量进行赋值
            int  x=y=z=5;  错误


    比较运算符
        比较运算结果是一个布尔值，即true或false

    逻辑运算符
        用于对布尔类型的数据进行操作，结果是一个布尔值
        注意
            逻辑运算符可以对结果为布尔值的表达式进行运算
            &和&&区别（|与||区别相似）
                &
                    不论左边的表达式，右边的表达式都会运行

                &&
                    若左边的表达式为false，右边的表达式不运行

                例

            ^
                异或操作
                运算符两边布尔类型相同，false
                运算符两边布尔类型不同，true



    运算符的优先级

选择结构语句

    if条件语句
        如果满足某种语句，就进行某种处理
        格式
        执行流程
        if-else语句
            如果满足某种语句，就进行某种处理，否则就进行另一种处理
            格式
            执行流程

        if-else if-else语句
            执行流程


    三元运算符
        判断条件？表达式1：表达式2
            当判断条件成立时，计算表达式1的值作为整个表达式的结果，否则计算表达式2的值作为整个表达式的结果

        需赋值给一个变量
        优先级：关系、算术运算符>条件运算符>赋值运算符
        可以嵌套使用
        例

    switch条件语句
        对某个表达式的值做出判断，从而决定程序执行哪一段代码
        使用case关键字描述和表达式结果比较的目标值，当表达式的值与某个目标值匹配时，就执行对应case下的语句
        格式
        例
        switch语句将表达式的值与每个case中的目标值进行匹配
            找到匹配的值：执行对应case后的语句
            没找到匹配的值：执行default后的语句

        如果多个case条件后面的执行语句是一样的，则执行语句只需要书写一次


循环结构语句
    while循环语句
        结构
        执行语句是否执行取决于循环条件
        例题
        执行流程

    do...while循环语句
        结构
        执行语句是循环体，循环条件放在循环体后面，循环体无条件执行一次，然后再根据循环条件决定是否继续执行
        例题
        执行流程

    for循环语句
        步骤
            第一步：执行初始化表达式
            第二步：执行循环条件
                若判断结果为true，执行操作表达式
                若判断结果为false，退出循环

            第三步：执行执行语句
            第四步：执行操作表达式，重复执行循环条件
            第五步：退出循环

        例
        无限循环
            循环一直停不下来
            格式：
            注意
                无限循环下面不能写其他代码

            跳转控制语句
                continue
                    跳过本次循环，继续执行下次循环
                    例

                break
                    结束整个循环
                    例


            pass语句
                空语句，保持程序完整性

数组

  概述
    是一种容器，可以用来储存同种数据类型的多个值
        需结合隐式转换考虑
            例如：int类型的容器，可以存储byte、short，不能存储double



定义格式
    数据类型[ ] 数据名
        int [ ] array

    数据类型 数组名[ ]
        int array[ ]


静态初始化
    初始化
        在内存中，为数组容器开辟空间，并将数据存入容器的过程

    格式
        完整
            数据类型[ ]数组名=new 数据类型[ ]{元素1，元素2......}；
                int[ ] array=new int[ ]{11,12,13}


        简化（常用）
            数据类型[ ]数组名={元素1，元素2......}；
                int[ ] array={11,12,13}；



    数组一旦创建，长度就固定了，不会发生改变

地址值
    表示数组在内存中的位置
        int[] arr = [1,2,3,4,5];
        System.out.println(arr);
        地址值：//[I@6d03e736

    含义
        [ : 表示当前是一个数组
        D: 表示当前数组里面的元素都是double类型的
        @: 表示一个间隔符号。 (固定格式)
        776ec8df: 才是数组真正的地址值， (十六进制)


元素访问
    获取数组里面的元素
        格式: 数组名[索引]
            索引:也叫做下标，角标
            特点:从0开始，逐个+1增长，连续不间断

        例
            获取数组中的第一个元素，其实就是0索引上对应的元素
                 int number = arr[0];



    把数据存储到数组当中
        格式:数组名[索引] = 具体数据/变量;
            arr[0] = 100;

        一旦覆盖之后，原来的数据就不存在了


数组的遍历
    将数组中所有的内容取出来
    方法
        利用循环
        数组名.length
            数组的一个长度属性

        idea提供的自动的快速生成数组的遍历方式
            数组名.fori



动态初始化
    初始化时只指定数组长度，由系统为数组分配初始值
    数据类型[ ]数组名 = new 数据类型[数组长度];
         int[ ] arr = new int[3];

    数组默认初始化值的规律
        整数类型:默认初始化值0
        小数类型:默认初始化值0.0
        字符类型:默认初始化值 '\u0000'   空格
        布尔类型:默认初始化值 false
        引用数据类型: 默认初始化值 null  


数组的内存图

常见问题
    当访问了数组中不存在的索引，就会引发索引越界异常

常见操作
    求最值

    求和

    交换数据

    打乱数据

二维数组

应用场景
    数据分组管理

静态初始化
     数据类型 数组名 = new 数据类型[ ][ ]{{元素1,元素2},{元素1,元素2}};
         int[ ][ ]  arr = new int[ ][ ]{{1,2},{3,4}};

     数据类型 数组名 = {{元素1,元素2},{元素1,元素2}};
         int[ ][ ]  arr = {{1,2},{3,4}};

    方便观看一般写为：

int[][] arr={
                {1,2,3},
                {4,5}
        };

获取元素
    arr[i][j]
        i: 二维数组的索引，获取出来的是里面的一维数组
        j: 表示一维数组中的索引，获取出来的就是真正的元素

    例

		System.out.println(arr[0][2]);
        System.out.println(arr[1][1]);

遍历
    例

//遍历
        //外循环，获取一维数组
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+" ");
            }
            //输出一组数组后换行
            System.out.println();
        }

动态初始化
     数据类型[ ][ ] 数组名 = new 数据类型[m][n];
        m:表示这个二维数组，可以存放多少个一维数组
        n:表示每一个一维数组，可以存放多少个元素
            int[ ][ ] arr = new int[2][3];
                以存放2个一维数组，每个一维数组中可以存放3个int类型元素

方法

定义
    程序中最小的执行单元

什么时候用
    重复的代码、具有独立功能的代码可以抽取到方法中

好处
    可以提高代码的复用性
    可以提高代码的可维护性

最简单的方法定义与调用
    方法定义
        把一些代码打包在一起，该过程称为
    

    方法调用
        方法定义后并不是直接运行的，需要手动调用才能执行
        

   

带参数的方法定义与调用
    定义
        单个参数
            格式
                public static void 方法名( 参数 ){ ... ...}
                    例：public static void method(int number) { ... ...}



        多个参数
            格式
                public static void 方法名( 参数1，参数2.....）{... }
                    例：public static void getSum(int number1,int number2){...}




    调用
        单个参数
            方法名( 参数 );
                method(10) ;
                method(变量)；


        多个参数
            方法名( 参数1，参数2.....);
                getSum(10,20):
                getSum(变量1，变量2);

    
    形参和实参
        形参
            全称形式参数，是指方法定义中的参数
                public static void getSum(int num1,int num2)


        实参
            全称实际参数，方法调用中的参数
                getSum(10,20)；

带返回值方法的定义和调用
    方法的返回值其实就是方法运行的最终结果
    如果在调用处要根据方法的结果，去编写另外一段代码逻辑，为了在调用处拿到方法产生的结果，就需要定义带有返回值的方法
    
    调用
        直接调用
            方法名(实参);

        赋值调用
            整数类型 变量名 = 方法名 (实参);

        输出调用
            System.out.printIn(方法名 (实参));



方法的重载
    同一个类中，方法名相同，参数不同的方法。与返回值无关
        参数不同:个数不同、类型不同、顺序不同

    例

package black;

/*使用方法重载的思想，设计比较两个整数是否相同的方法
兼容全整数类型 (byte,short,int,long*/
public class J68 {
    public static void main(String[] args) {
        byte a=10;
        byte b=20;
        number(a,b);
        number((byte) a,(byte) b);
    }
    //未被调用的方法为灰色

    public static void number(byte a, byte b) {
        System.out.println(a ==b);

    }

    public static void number(short a, short b) {
        System.out.println(a == b);

    }

    public static void number(int a, int b) {
        System.out.println(a == b);

    }

    public static void number(long a, long b) {
        System.out.println(a == b);

    }
}

注意
    方法不调用就不执行
    方法与方法之间是平级关系，不能互相嵌套定义
    方法的编写顺序和执行顺序无关
    方法的返回值类型为void，表示该方法没有返回值没有返回值的方法可以省略return语句不写，如果要编写return，后面不能跟具体的数据
    return语句下面，不能编写代码，因为永远执行不到，属于无效的代码

面向对象

封装类和对象
    类
        是共同特征的描述(设计图);
        如何定义

        注意事项
            分类
                Javabean类
                    用来描述一类事物
                    不写main方法

                测试类
                    编写main方法


            书写规范
                类名首字母建议大写，需要见名知意，驼峰模式
                一个Java文件中可以定义多个class类，且只能一个类是public修饰，而且public修饰的类名必须为代码文件名
                实际开发中建议还是一个文件定义一个class类
                成员变量的完整定义格式
                    修饰符 数据类型 变量名称 = 初始化值;
                    一般无需指定初始化值，存在默认值




    对象
        是真实存在的具体实例
        得到类的对象
            类名 对象名 = new 类名( );
                Phone p = new Phone( );


        使用
            对象.成员变量;
            对象.成员方法(...)


    必须先设计类，才能获得对象
    例

package black2.J82;
public class Girlfriend {
    //属性
    String name;
    int age;


    //行为
    public void eat(){
        System.out.println("在吃饭");
    }
    public void sleep(){
        System.out.println("在睡觉");
    }
}

package black2.J82;

public class GirlfriendTest {
    public static void main(String[] args) {
        //创建对象
        Girlfriend gf=new Girlfriend();
        gf.name="张三";
        gf.age=18;
        System.out.println(gf.name);
        System.out.println(gf.age);

        gf.eat();
        gf.sleep();
    }
}

封装
    是什么
        如何正确设计对象的属性和方法

    原则
        对象代表什么，就得封装对应的数据，并提供数据对应的行为

    好处
        让编程变得很简单，有什么事，找对象，调方法就行
        降低我们的学习成本，可以少学、少记，或者说压根不用学，不用记对象有哪些方法，有需要时去找就行


private关键字
    是什么
        一个权限修饰符
        可以修饰成员(成员变量和成员方法)
        被private修饰的成员只能在本类中才能访问

    如果需要被其他类使用
        setXxx(参数)
            用于给成员变量赋值，方法用public修饰

        getXxx()
            用于获取成员变量的值，方法用public修饰


    例

package black2.J83;

public class GirfriendNew {
    //属性
    private String name;//成员变量
    private int age;

    //set方法:给成员变量赋值的
    //get方法：对外提供成员变量的值
    public void setName(String n){
        name=n;//局部变量
    }

    public String getName(){
        return name;
    }

    public void setAge(int a){
        if (a>=18&&a<=50){
            age=a;
        }else {
            System.out.println("非法参数");
        }
    }

    public int getAge() {
        return age;
    }

    //行为
    public void eat(){
        System.out.println("在吃饭");
    }
    public void sleep(){
        System.out.println("在睡觉");
    }
}

package black2.J83;

public class GirfriendNewTest {
    public static void main(String[] args) {
        GirfriendNew gf=new GirfriendNew();
        //赋值
        gf.setName("张三");
        gf.setAge(18);

        System.out.println(gf.getName());
        System.out.println(gf.getAge());

        gf.eat();
        gf.sleep();
    }
}

this关键字
    区别成员变量和局部变量

构造方法
    也叫作构造器、构造函数
    作用
        在创建对象的时候给成员变量进行赋值的

    格式

    特点
        方法名与类名相同，大小写也要一致
        没有返回值类型，连void都没有
        没有具体的返回值(不能由retrun带回结果数据)

    执行时机
        创建对象的时候由虚拟机调用，不能手动调用构造方法
        每创建一次对象，就会调用一次构造方法

    注意事项
        构造方法的定义
            如果没有定义构造方法，系统将给出一个默认的无参数构造方法
            如果定义了构造方法，系统将不再提供默认的构造方法

        构造方法的重载
            带参构造方法，和无参数构造方法，两者方法名相同，但是参数不同，这叫做构造方法的重载

        推荐的使用方式
            无论是否使用，都手动书写无参数构造方法，和带全部参数的构造方法
            static--静态变量
static表示静态，是Java中的一个修饰符，可以修饰成员方法，成员变量
静态变量
    被static修饰的成员变量
    特点
        被该类所有对象共享
        不属于对象，属于类
        随着类的加载而加载，优先于对象存在

    调用方式
        类名调用(推荐)
            static String teacherName;（构造时）
            Student.teacherName =“阿玮老师";

        对象名调用


静态方法
    被static修饰的成员方法
    特点
        多用在测试类和工具类中
        Javabean类中很少会用

    调用方式
        类名调用(推荐)
        对象名调用

    注意事项
        静态方法中，只能访问静态
        非静态方法可以访问所有
        静态方法中没有this关键字



工具类
帮助我们做一些事情的，但是不描述任何事物的类
注意
    类名见名知意
    私有化构造方法
    方法定义为静态

例

继承
是什么
    Java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起继承关系。

格式
    public class Student extends Person { }
    Student ：子类
    Person：父类

好处
    可以把多个子类中重复的代码抽取到父类中了，提高代码的复用性
    子类可以在父类的基础上，增加其他的功能，使子类更强大。

什么时候使用
    当类与类之间，存在相同(共性)的内容，并满足子类是父类中的一种，就可以考虑使用继承，来优化代码

特点
    java只能单继承
        一个类只能继承一个直接父类

    java不支持多继承
        子类不能同时继承多个父类

    但是支持多层继承
    java中所有的类都直接或者间接继承于Object类

成员变量访问特点
    就近原则
        先在局部位置找，本类成员位置找，父类成员位置找，逐级往上。

    重名的成员变量怎么办
        从局部位置开始往上找
            System.out.println(name);

        从本类成员位置开始往上找
            System.out.println(this.name);

        从父类成员位置开始往上找
            System.out.println(super.name);


    super
        访问父类中成员变量


方法重写
    当父类的方法不能满足子类现在的需求时，需要进行方法重写
    格式
        子类出现了和父类中一模一样的方法声明

    @Override重写注解
        放在重写后的方法上，校验子类重写时语法是否正确
        加上注解后如果有红色波浪线，表示语法错误
        建议重写方法都加

    注意事项和要求
        重写方法的名称、形参列表必须与父类中的一致。
        子类重写父类方法时，访问权限子类必须大于等于父类 (暂时了解:空着不写< protected< public)
        子类重写父类方法时，返回值类型子类必须小于等于父类
        重写的方法尽量和父类保持一致
        只有被添加到虚方法表(private、static)中的方法才能被重写


 构造方法的访问特点
    父类中的构造方法不会被子类继承
    子类中所有的构造方法默认先访问父类中的无参构造，再执行自己
    为什么
        子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据
        子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化。

    怎么调用父类构造方法
        子类构造方法的第一行语句默认都是: super()，不写也存在，且必须在第一行
        如果想调用父类有参构造，必须手动写super进行调用。

    例


多态
是什么
    对象的多种形态

前提
    有继承/实现关系
    有父类引用指向子类对象
    有方法的重写

格式
    父类类型 对象名称 = 子类对象;

好处
    使用父类型作为参数，可以接收所有子类对象
    体现多态的扩展性与便利

例
调用成员的特点
    成员变量
        编译看左边，运行也看左边
            编译看左边:javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有编译失败
            运行也看左边: java运行代码的时候，实际获取的就是左边父类中成员变量的值


    成员方法
        编译看左边，运行看右边
            编译看左边:javac编译代码的时候，会看左边的父类中有没有这个方法，如果有，编译成功，如果没有编译失败。
            运行看右边: java运行代码的时候，实际上运行的是子类中的方法。



优势
    方法中，使用父类型作为参数，可以接收所有子类对象

弊端
    不能使用子类的特有功能

解决方案
    强制类型转换
    ｜  student s = (Student)p;
        可以转换成真正的子类类型，从而调用子类独有功能
        转换类型与真实对象类型不一致会报错
        转换的时候用instanceof关键字进行判断

    类型转换
        instanceof（已包含强转）



包
作用
    包就是文件夹，用来管理各种不同功能的java类

包名书写的规则
    公司域名反写 + 包的作用 ，需要全部英文小写，见名知意

什么是全类名
    包名 + 类名

什么时候需要导包? 什么时候不需要导包?
    使用同一个包中的类时，不需要导包
    使用java.lang包中的类时，不需要导包
    其他情况都需要导包
    如果同时使用两个包中的同名类,需要用全类名


final
方法
    表明该方法是最终方法，不能被重写

类
    表明该类是最终类，不能被继承

变量
    叫做常量，只能被赋值一次
    常量
        实际开发中，常量一般作为系统的配置信息，方便维护，提高可读性
        常量的命名规范
            单个单词:全部大写
            多个单词:全部大写，单词之间用下划线隔开

        细节:
            final修饰的变量是基本类型:那么变量存储的数据值不能发生改变
            final修饰的变量是引用类型: 那么变量存储的地址值不能发生改变，对象内部的可以改变




权限修饰符
是用来控制一个成员能够被访问的范围的
可以修饰成员变量，方法，构造方法，内部类
有四种作用范围由小到大 (private <空着不写 < protected < public）


代码块
局部代码块
    提前结束变量的生命周期](已淘汰)

构造代码块
    抽取构造方法中的重复代码(不够灵活）

静态代码块
    格式
        static{ }

    特点
        需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次

    使用场景
        在类加载的时候，做一些数据初始化的时候使用。



抽象类和抽象方法
抽象方法的定义格式
    public abstract 返回值类型 方法名(参数列表);

抽象类的定义格式
    public abstract class 类名{}

注意事项
    抽象类不能实例化（创建对象）
    抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
    可以有构造方法
    抽象类的子类
        要么重写抽象类中的所有抽象方法
        要么是抽象类



接口的定义和使用
接口用关键字interface来定义
    public interface 接口名{ }

接口不能实例化
接口和类之间是实现关系，通过implements关键字表示
    public class 类名 implements 接口名{ }

接口的子类(实现类)
    要么重写接口中的所有抽象方法
    要么是抽象类

接口中成员的特点
    成员变量
        只能是常量
        默认修饰符: public static final

    构造方法
        没有

    成员方法
        只能是抽象方法
        默认修饰符:public abstract


接口和类之间的关系
    类和类的关系
        继承关系，只能单继承，不能多继承，但是可以多层继承

    类和接口的关系
        实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

    接口和接口的关系
        继承关系，可以单继承，也可以多继承
            如果实现类实现了最下面的子接口，那么就需要重写所有的抽象方法



注意
    接口和类的实现关系，可以单实现，也可以多实现。
        public class 类名 implements 接口名1，接口名2{ };

    实现类还可以在继承一个类的同时实现多个接口
        public class 类名 extends 父类implements 接口名1，接口名2{ };



内部类
概念
    是什么
        写在一个类里面的类

    什么时候用到
        内部类表示的事物是外部类的一部分
        内部类单独出现没有任何意义

    访问特点
        内部类可以直接访问外部类的成员，包括私有
        外部类要访问内部类的成员，必须创建对象


分类
    成员内部类
        写在成员位置的，属于外部类的成员
        成员内部类可以被一些修饰符所修饰，比如: private，默认，protected，public，static等
        图片

        获取成员内部类对象
            在外部类中编写方法，对外提供内部类的对象（private）
            直接创建格式:外部类名.内部类名 对象名=外部类对象内部类对象;
                Outer.Inner oi = new outer( ).new Inner( );


        外部类成员变量和内部类成员变量重名时，在内部类如何访问
            System.out.printIn(Outer.this.变量名);
            图片（J141）



    静态内部类
        静态内部类只能访问外部类中的静态变量和静态方法，如果想要访问非静态的需要创建对象
        创建静态内部类对象的格式
             外部类名.内部类名 对象名=new 外部类名.内部类名();

        调用非静态方法的格式
            先创建对象，用对象调用

        调用静态方法的格式
            外部类名.内部类名.方法名();

        J142


    局部内部类
        将内部类定义在方法里面就叫做局部内部类，类似于方法里面的局部变量
        外界是无法直接使用，需要在方法内部创建对象并使用
        该类可以直接访问外部类的成员，也可以访问方法内的局部变量

    匿名内部类
        是隐藏了名字的内部类
        格式

        细节
            包含了继承或实现，方法重写，创建对象
            整体就是一个类的子类对象或者接口的实现类对象

        使用场景
            当方法的参数是接口或者类时
                以接口为例，可以传递这个接口的实现类对象
                如果实现类只要使用一次，就可以用匿名内部类简化代码

API

是什么
目前是JDK 中提供的各种功能的Java类。这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可

API帮助文档
帮助开发人员更好的使用API和查询API的一个工具。

Math
是什么
    帮助我们进行数学计算的工具类
    里面的方法都是静态的

常用方法
    public static int abs(int a)
        获取参数绝对值

    public static double ceil(double a)
        向上取整

    public static double floor(double a)
        向下取整

    public static int round(float a)
        四舍五入

    public static int max(int a,int b)
        获取两个int值中的较大值

    public static double pow(double a,double b)
        返回a的b次幂的值

    public static double random()
        返回值为double的随机值，范围[0.0,1.0)

    示例

package black3;

public class J155 {
    public static void main(String[] args) {
        //abs 获取参数绝对值
        System.out.println(Math.abs(-88));//88

        //向上取整
        System.out.println(Math.ceil(12.11));//13
        System.out.println(Math.ceil(-12.33));//-12

        //向下取整
        System.out.println(Math.floor(12.54));//12
        System.out.println(Math.floor(-12.33));//-13

        //四舍五入
        System.out.println(Math.round(12.34));//12
        System.out.println(Math.round(12.54));//13
        System.out.println(Math.round(-12.34));//-12
        System.out.println(Math.round(-12.54));//-13

        //获取两个整数的较大值
        System.out.println(Math.max(20, 30));//30
        //获取两个整数的较小值
        System.out.println(Math.min(20, 30));//20

        //获取a的b次幂
        System.out.println(Math.pow(2, 3));

        //开平方
        System.out.println(Math.sqrt(4));//2.0
        //开立方
        System.out.println(Math.cbrt(8));//2.0

        //返回随机数
        for (int i = 0; i < 10; i++) {
            System.out.println(Math.floor(Math.random()*100)+1);
        }
    }
}

System
是什么
    一个工具类，提供了一些与系统相关的方法

常用方法
    public static void exit(int status)
        终止当前运行的 Java 虚拟机
        int status
            0: 表示当前虚拟机是正常停止
            非0: 表示当前虚拟机异常停止


    public static long currentTimeMillis()
        返回当前系统的时间毫秒值形式
            时间原点：1970年1月1日 08:00:00
            1秒 = 1000 毫秒


    public static void arraycopy(数据源数组，起始索引，目的地数组，起始索引，拷贝个数)
        数组拷贝
        细节
            如果数据源数组和目的地数组都是基本数据类型，那么两者的类型必须保持一致，否则会报错
            在拷贝的时候需要考虑数组的长度，如果超出范围也会报错
            如果数据源数组和目的地数组都是引用数据类型，那么子类类型可以赋值给父类类型
                父类类型数组强转为子类类型
                    Student stu = (Student) arr2[i]；




    示例

package black3;

public class J157 {
    public static void main(String[] args) {
        //返回当前系统的时间毫秒值形式
        long l = System.currentTimeMillis();
        System.out.println(l);


        //数组拷贝
        int[] arr1={1,2,3,4,5,6,7,8,9,10};
        int[] arr2=new int[10];
            //参数1：数据源，要拷贝的数据从哪个数组而来
            //参数2: 从数据源数组中的第几个索引开始拷贝
            //参数3:目的地，我要把数据拷贝到哪个数组中
            //参数4:目的地数组的索引
            //参数5: 拷贝的个数
        System.arraycopy(arr1,0,arr2,0,10);
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i]+" ");
        }



        //终止当前运行的 Java 虚拟机
            //状态码:
            //0:表示当前虚拟机是正常停止
            //非0: 表示当前虚拟机异常停止
        System.exit(0);
    }
}

Runtime
public staticRuntime getRuntime()
    当前系统的运行环境对象

public void exit(int status)
    停止虚拟机

public int availableProcessors()
    获得CPU的线程数

public long maxMemory()
    JVM能从系统中获取总内存大小 (单位byte)

public long totalMemory()
    JVM已经从系统中获取总内存大小 (单位bvte)

public long freeMemory()
    JVM剩余内存大小 (单位byte)

public Process exec(string command)
    运行cmd命令
        shutdown :关机
        -s : 默认在1分钟之后关机
        -s -t 指定时间s :指定关机时间
        -a : 取消关机操作
        -r: 关机并重启


示例

package black3;

import java.io.IOException;

public class J158 {
    public static void main(String[] args) throws IOException {
        //获取Runtime的对象
        Runtime r1=Runtime.getRuntime();
        //获得CPU的线程数
        System.out.println(r1.availableProcessors());
        //总内存大小,单位byte字节
        System.out.println(r1.maxMemory());
        //已经获取的总内存大小,单位byte字节
        System.out.println(r1.totalMemory());
        //剩余内存大小
        System.out.println(r1.freeMemory());
        //运行cmd命令
            //shutdown :关机
            //加上参数才能执行
            //-s : 默认在1分钟之后关机
            //-s -t 指定时间s :指定关机时间
            //-a : 取消关机操作
            //-r: 关机并重启
        r1.exec("shutdown -s -t 3600");
        //停止虚拟机
        r1.exit(0);
    }
}

Object
public Object()
    空参构造

public Stringtostring()
    返回对象的字符串表示形式
    使用方法
        如果我们打印一个对象，想要看到属性值的话，那么就重写tostring方法
        在重写的方法中，把对象的属性值进行拼接


public boolean equals(Object obj)
    比较两个对象是否相等
    使用方法
        如果没有重写eguals 方法，那么默认使用object中的方法进行比较，比较的是地址值是否相等
        重写之后比较的就是对象内部的属性值了


protected object clone(int a)
    对象克隆
        默认浅克隆
        如果需要深克隆需要重写方法或者使用第三方工具类



示例

package black3;

import java.util.Objects;

public class J159 {
    public static void main(String[] args) {
        //tostring 返回对象的字符串表示形式
        Object obj = new Object();
        String str1 = obj.toString();
        System.out.println(str1);//java.lang.Object@776ec8df

            //如果我们打印一个对象，想要看到属性值的话，那么就重写tostring方法
            //在重写的方法中，把对象的属性值进行拼接。
        Student stu = new Student("张三", 23);
        String str2 = stu.toString();
        System.out.println(str2);

        //public boolean equals(Object obj) 比较两个对象是否相等
        //如果没有重写eguals方法，那么默认使用object中的方法进行比较，比较的是地址值是否相等
        //重写之后比较的就是对象内部的属性值了
        Student s1=new Student("张三",23);
        Student s2=new Student("张三",23);

        boolean result = s1.equals(s2);
        System.out.println(result);

    }
}

class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //方法重写toString
    @Override
    public String toString() {
        return name + "," + age;
    }

    //重写之后的equais方法比较的就是对象内部的属性值
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

}

Objects
是什么
    是一个工具类，提供了一些方法去完成一些功能

成员方法
    public static boolean equals(Object a, Object b)
        先做非空判断，比较两个对象

    public static boolean isNull(Object obj)
        判断对象是否为nu11，为null返回true ,反之

    public static boolean nonNull(Object obj)
        判断对象是否为nu11，跟isNu11的结果相反


示例

package black3;

import java.util.StringJoiner;

public class J160_1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        //克隆
        int[] data={1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 11, 12, 13, 14, 15,0};
        User u1=new User(1,"zhangsan","1234567","girl",data);
        User u2= (User) u1.clone();

        System.out.println(u1);
        System.out.println(u2);
    }
}

class User implements Cloneable{
    private int id;//游戏角色
    private String username,password,path;
    private int[] data;//游戏进度

    public User() {
    }

    public User(int id, String username, String password, String path, int[] data) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.path = path;
        this.data = data;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public int[] getData() {
        return data;
    }

    public void setData(int[] data) {
        this.data = data;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public String toString(){
        return "角色编号为:" + id +",用户名:" + username +",密码"+ password + ",游戏图片:"+ path + ",进度:"+arrToString();
    }

    public String arrToString(){
        StringJoiner sj=new StringJoiner(",","[","]");
        for (int i = 0; i < data.length; i++) {
            sj.add(data[i]+"");
        }
        return sj.toString();
    }
}

BigInteger
对象一旦创建，内部记录的值不能发生改变
构造方法
    public BigInteger(int num，Random rnd)
        获取随机大整数，范围: [0 ~ 2的num次方-1]

    public BigInteger(string val)
        获取指定的大整数

    public BigInteger(String val, int radix)
        获取指定进制的大整数


静态方法
    public static BigInteger valueof(long val)
        获取BigInteger的对象，内部有优化
            能表示范围比较小，在long的取值范围之类
            在内部对常用的数字: -16 ~ 16进行了优化
            提前把-16 ~ 16 先创建好BigInteger的对象，如果多次获取不会重新创建新的



成员方法
    public BigInteger add(BigInteger val)
        加法

    public BigInteger subtract(BigInteger val)
        减法

    public BigInteger multiply(BigInteger val)
        乘法

    public BigInteger divide(BigInteger val)
        除法，获取商

    public BigInteger[ ] divideAndRemainder(BigInteger val)
        除法，获取商和余数

    publicboolean equals(Object x)
        比较是否相同

    publicBigInteger pow(int exponent)
        次幂

    publicBigInteger max/min(BigInteger val)
        返回较大值/较小值

    public int intValue(BigInteger val)
        转为int类型整数，超出范围数据有误
        int可换为其他数据类型


示例

package black3;

import java.math.BigInteger;
import java.util.Random;

public class J161 {
    public static void main(String[] args) {
        //获取一个随机的大整数
        BigInteger bd1=new BigInteger(4,new Random());

        //获取一个指定的大整数
        BigInteger bd2=new BigInteger("999999999");

        //获取指定进制的大整数
        BigInteger bd3=new BigInteger("100",2);//100是二进制，输出转回十进制

        //静态方法获取BigInteger的对象，内部有优化
            //能表示范围比较小，在long的取值范围之类
            //在内部对常用的数字: -16 ~ 16进行了优化
            //提前把-16 ~ 16 先创建好BigInteger的对象，如果多次获取不会重新创建新的
        BigInteger bd4=BigInteger.valueOf(16);
        BigInteger bd5=BigInteger.valueOf(16);

        System.out.println(bd4==bd5);//比较地址值 true
    }
}

BigDecimal
构造方法
    public BigDecimal(double val)
        通过传递double类型的小数来创建对象
        这种方式有可能是不精确的，所以不建议使用

    public BigDecimal(String val)
        通过传递字符串表示的小数来创建对象


静态方法
    public static BigDecimal valueof(double val)
        如果要表示的数字不大，没有超出double的取值范围，建议使用静态方法
        如果要表示的数字比较大，超出了double的取值范围，建议使用构造方法
        如果我们传递的是~1之间的整数，包含0，包含10，那么方法会返回已经创建好的对象，不会重新new


成员方法
    public BigDecimal add(BigDecimal val)
        加法

    public BigDecimal subtract(BigDecimal val)
        减法

    public BigDecimal multiply(BigDecimal val)
        乘法

    public BigDecimal divide(BigDecimal val)
        除法

    public BigDecimal divide(BigDecimal val，精确几位，舍入模式)
        除法
        有余数必须使用此方法
        舍入模式



示例

package black3;

import java.math.BigDecimal;

public class J162 {
    public static void main(String[] args) {
        //通过传递double类型的小数来创建对象
            //这种方式有可能是不精确的，所以不建议使用
        BigDecimal bd1=new BigDecimal(0.01);
        BigDecimal bd2=new BigDecimal(0.09);

        System.out.println(bd1);//0.01000000000000000020816681711721685132943093776702880859375
        System.out.println(bd2);//0.0899999999999999966693309261245303787291049957275390625

        //通过传递字符串表示的小数来创建对象
        BigDecimal bd3=new BigDecimal("0.01");
        BigDecimal bd4=new BigDecimal("0.04");

        System.out.println(bd3);//0.01
        System.out.println(bd4);//0.04

        //通过静态方法获取对象
            //如果要表示的数字不大，没有超出double的取值范围，建议使用静态方法
            //如果要表示的数字比较大，超出了double的取值范围，建议使用构造方法
            //如果我们传递的是~1之间的整数，包含0，包含10，那么方法会返回已经创建好的对象，不会重新new
        BigDecimal bd5=BigDecimal.valueOf(10);
        System.out.println(bd5);
    }
}

正则表达式
可在API帮助文档Pattern中查看相关规则
可使用插件

作用
    校验字符串是否满足规则
    在一段文本中查找满足要求的内容


在字符串方法中的使用
    public String[ ] matches(String regex)
        判断字符串是否满足正则表达式的规则

    public string replaceAll(String regex,String newStr)
        按照正则表达式的规则进行替换
        将满足条件的，用第二个参数去替换

    public String[ ] split(string regex)
        按照正则表达式的规则切割字符串      

分组
    捕获分组
        规则
            后续还要继续使用本组的数据
            每组是有组号的，也就是序号
            从1开始，连续不间断
            以左括号为基准，最左边的是第一组，其次为第二组，以此类推

        使用
            \ \组号
                表示把第X组的内容再出来用一次
                内部使用

            $组号
                表示把第X组的内容再出来用一次
                外部使用
    
    非捕获分组
        规则
            分组之后不需要再用本组数据，仅仅是把数据括起来
            不占用组号

        Java(?=正则)
            获取所有

        Java(?:正则)
            获取前面部分

        Java(?!正则)
            获取不是指定内容的前面部分

      
爬取（具体见示例）
    步骤（具体见示例）
        Pattern（规则）
            表示正则表达式

        Matcher（匹配器）
            文本匹配器，作用按照正则表达式的规则去读取字符串，从头开始读取。在大串中去找符合匹配规则的子串

        find()（移动匹配器）
            拿着文本匹配器从头开始读取，寻找是否有满足规则的子串
            如果没有，方法返回false
            如果有，返回true。在底层记录子串的起始索引和结束索引+1

        group()（截取）
            方法底层会根据find方法记录的索引进行字符串的截取
            会把截取的小串进行返回      

    （非）贪婪爬取
        贪婪爬取
             在爬取数据的时候尽可能的多获取数据
            只写+和*
            默认的就是贪婪爬取

        非贪婪爬取
            在爬取数据的时候尽可能的少获取数据
            如果我们在数量词+ * 的后面加上问号，那么此时就是非贪婪爬取
                +? *?
                JDK7前时间
时间的相关知识点
    世界标准时间
        格林尼治时间 /格林威治时间 (Greenwich Mean Time)简称 GMT
        目前世界标准时间(UTC) 已经替换为:原子钟

    中国标准时间
        世界标准时间+ 8小时

    时间单位换算
        1秒=1000毫秒


Date时间类
    是什么
        是一个JDK写好的Javabean类，用来描述时间，精确到毫秒

    方法
        public Date()
            创建Date对象，表示当前时间

        public Date(long date)
            创建Date对象，表示指定时间

        public void setTime(long time)
            设置/修改毫秒值

        public long getTime()
            获取时间对象的毫秒值

        示例

package black3;

import java.util.Date;

public class J169 {
    public static void main(String[] args) {
        //创建对象表示当前
        Date d1=new Date();
        System.out.println(d1);//Sat Sep 30 16:13:12 CST 2023

        //创建对象表示一个指定的时间
        Date d2=new Date(0L);//从时间原点过0ms
        System.out.println(d2);//Thu Jan 01 08:00:00 CST 1970

        //setTime 修改时间
        d2.setTime(1000L);
        System.out.println(d2);//Thu Jan 01 08:00:01 CST 1970

        //getTime获取当前时间的毫秒值
        long time = d2.getTime();
        System.out.println(time);
    }
}

SimpleDateFormat 类
    方法
        构造方法
            public SimpleDateFormat( )
                构造一个simpleDateFormat，使用默认格式

            public SimpleDateFormat(String pattern)
                构造一个simpleDateFormat，使用指定的格式


        常用方法
            public final String format(Date date)
                格式化 (日期对象 ->字符串)

            public Date parse(string sgurce)
                解析 (字符串- >日期对象)


        示例

package black3;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class J170 {
    public static void main(String[] args) throws ParseException {
        //利用空参构造创建SimpleDateFormat对象，默认格式
        SimpleDateFormat sdf1=new SimpleDateFormat();
        Date d1=new Date();
         //格式化 (日期对象 ->字符串)
        String str1 = sdf1.format(d1);
        System.out.println(str1);// 2023/9/30 下午5:27

        //利用带参构造创建simpleDateFormat对象，指定格式
        SimpleDateFormat sdf2=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //以str2的格式改变d1
        String str2 = sdf2.format(d1);
        System.out.println(str2); //2023年09月30日 17:34:20

        //解析 (字符串 >日期对象)
         //创建对象的格式要跟字符串的格式完全一致
        String str="2023-11-11 11:11:11";
        SimpleDateFormat sdf = new SimpleDateFormat(  "yyyy-MM-dd HH:mm:ss");
        Date date = sdf.parse(str);

        System.out.println(date.getTime());

    }
}

    格式化的时间形式的常用的模式对应关系
        详细见帮助文档 SimpleDateFormat

        yyyy年MM月dd日 HH:mm:ss
            除字母外其他可替换



Calendar类
    概述
        Calendar代表了系统当前时间的日历对象，可以单独修改、获取时间中的年，月，日
         Calendar是一个抽象类，不能直接创建对象
        会根据系统的不同时区来获取不同的日历对象,默认表示当前时间
        把会把时间中的纪元，年，月，日，时，分，秒，星期，等等的都放到一个数组当中
        月份的范围0~11 如果获取出来的是0.那么实际上是1月
        星期日是一周中的第一天

    方法
        获取对象的方法
            public static Calendar getInstance( )
                获取当前时间的日历对象


        常用方法
            public final Date getTime( )
                获取日期对象

            public final setTime(Date date)
                给日历设置日期对象

            public long getTimeInMillis( )
                拿到时间毫秒值

            public void setTimeInMillis(long millis)
                给日历设置时间毫秒值

            public int get(int field)
                取日历中的某个字段信息

            public void set(int field,int value)
                修改日历的某个字段信息

            public void add(int field,int amount)
                为某个字段增加/减少指定的值



    示例

package black3;

import java.util.Calendar;
import java.util.Date;

public class J171 {
    public static void main(String[] args) {
        //获取日历对象
        Calendar c = Calendar.getInstance();
        System.out.println(c);

        //修改一下日历代表的时间
        Date d=new Date(0L);
        c.setTime(d);
        System.out.println(c);

        //public int get(int field) 取日期中的某个字段信息
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int data = c.get(Calendar.DAY_OF_MONTH);
        int week = c.get(Calendar.DAY_OF_WEEK);
        System.out.println(year+" "+month+" "+data+" "+week);

        //public void set(int field,int value) 修改日历的某个字段信息
        c.set(Calendar.YEAR,2023);
        System.out.println(c);

        //public void add(int field,int amount) 为某个字段增加/减少指定的值
        c.add(Calendar.MONTH,1);
        System.out.println(c);
    }
}

JDK8时间
Date类
    Zoneld时区
        static Set getAvailableZoneIds()
            获取Java中支持的所有时区

        static ZoneId systemDefault()
            获取系统默认时区

        static ZoneId of(String zoneId)
            获取一个指定时区


    Instant时间戳
        方法
            static Instant now()
                获取当前时间的Instant对象(标准时间)

            static Instant ofXxxx(long epochMilli)
                根据(秒/毫秒/纳秒)获取Instant对象

            ZonedDateTime atZone(ZoneId zone)
                指定时区

            boolean isXxx(Instant otherInstant)
                isBefore:判断调用者代表的时间是否在参数表示时间的前面
                isAfter:判断调用者代表的时间是否在参数表示时间的后面
                判断系列的方法

            Instant minusXxx(long millisToSubtract)
                减少时间系列的方法

            Instant plusXxx(long millisToSubtract)
                增加时间系列的方法


        示例

package black3;

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class J172_2 {
    public static void main(String[] args) {
        //static Instant now() 获取当前时间的Instant对象(标准时间)
        Instant now = Instant.now();
        System.out.println(now);//2023-09-30T12:58:14.411609200Z

        //static Instant ofXxxx(long epochMilli) 根据(秒/毫秒/纳秒)获取Instant对象
        Instant instant1 = Instant.ofEpochMilli(1000L);
        System.out.println(instant1);
        Instant instant2 = Instant.ofEpochSecond(1L);
        System.out.println(instant2);
        Instant instant3 = Instant.ofEpochSecond(1L, 1000000000);
        System.out.println(instant3);

        //ZonedDateTime atZone(ZoneId zone) 指定时区
        ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
        System.out.println(time);

        //boolean isXxx(Instant otherInstant) 判断系列的方法
        Instant instant4 = Instant.ofEpochMilli(0L);
        Instant instant5 = Instant.ofEpochMilli(1000L);

        boolean result1 = instant4.isBefore(instant5);
        boolean result2 = instant4.isAfter(instant5);
        System.out.println(result1);
        System.out.println(result2);

        //Instant minusXxx(long millisToSubtract) 减少时间系列的方法
        Instant instant6 = instant5.minusMillis(1000L);
        System.out.println(instant6);


    }
}

    ZoneDateTime带时区的时间
        方法
            static ZonedDateTime now()
                获取当前时间的ZonedDateTime对象

            static ZonedDateTime ofXxxx(...)
                获取指定时间的ZonedDateTime对象

            ZonedDateTime withXxx(时间)
                修改时间系列的方法

            ZonedDateTime minusxxx(时间)
                减少时间系列的方法

            ZonedDateTime plusXxx(时间)
                增加时间系列的方法


        示例

package black3;

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class J172_3 {
    public static void main(String[] args) {
        //获取当前时间对象(带时区)
        ZonedDateTime now = ZonedDateTime.now();
        System.out.println(now);

        //获取指定的时间对象(带时区)
        //年月日时分秒纳秒方式指定
        ZonedDateTime time1 = ZonedDateTime.of(2023, 9, 30, 21, 27, 32, 0, ZoneId.of("Asia/Shanghai"));
        System.out.println(time1);

        //通过 Instant + 时区 的方式指定获取时间对象
        ZonedDateTime time2 = ZonedDateTime.ofInstant(Instant.ofEpochMilli(0L), ZoneId.of("Asia/Shanghai"));
        System.out.println(time2);

        //withxxx 修改时间系列的方法
        ZonedDateTime time3 = ZonedDateTime.now().withYear(2000);
        System.out.println(time3);

        //减少时间
        ZonedDateTime time4 = time3.minusYears(1L);
        System.out.println(time4);

        //增加时间
        ZonedDateTime time5 = time4.plusYears(5);
        System.out.println(time5);

    }
}

SimpleDateFormat日期格式化类
    DateTimeFormatten用于时间的格式化和解析
        方法
            static DateTimeFormatter ofPattern(格式)
                获取格式对象

            String format(时间对象)
                按照指定方式格式化


        示例

package black3;

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

public class J172_4 {
    public static void main(String[] args) {
        //解析/格式化器
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss EE a");
        //获取时间对象
        ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
        //格式化
        System.out.println(dtf.format(time));
    }
}

集合

概念
集合长度可变
可以存引用数据类型
基本数据类型→包装类

使用
ArrayList list = new ArrayList<>();
    E：泛型: 限定集合中存储数据的类型


方法
boolean add(E e)
    添加元素，返回值表示是否添加成功

boolean remove(E e)
    删除指定元素,返回值表示是否删除成功

E remove(int index)
    删除指定索引的元素,返回被删除元素

E set(int index,E e)
    修改指定索引下的元素,返回原来的元素

E get(int index)
    获取指定索引的元素

int size()
    集合的长度，也就是集合中元素的个数


基本数据类型对应的包装类(J112x2)
byte→Byte
short→Short
char→Character
int→Integer
long→Long
float→Float
double→Double
boolean→Boolean
示例

package black3;

import java.util.ArrayList;

public class J112x2 {
    public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList<>();

        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        System.out.print("[");
        for (int i = 0; i < list.size(); i++) {
            if (i==list.size()-1){
                System.out.print(list.get(i));
            }
            else {
                System.out.print(list.get(i)+",");
            }
        }
        System.out.println("]");
    }
}

字符串

字符串
String
    String
        Java定义好的一个类
        Java 程序中的所有字符串文字都被实为此类的对象
        字符串不可变，它们的值在创建后不能被更改

    创建String对象的两种方式(J98)
        直接赋值
            String name ="哒哒哒";

        new
            public String( )
                创建空白字符串，不含任何内容

            public String(string origina[ ])
                根据传入的字符串，创建字符串对象

            public String(char[ ] chs)
                根据字符数组，创建字符串对象

            public String(byte[ ] chs)
                根据字节数组，创建字符串对象

            public String toCharArray( )
                将字符串变成数组


        示例

package black3;

public class J98 {
    public static void main(String[] args) {
        //使用直接赋值的方式获取一个字符串对象
        String s1="abc";
        System.out.println(s1);//abc

        //使用new的方式来获取一个字符串对象
        //空参构造: 可以获取一个空白的字符串对象
        String s2=new String();
        System.out.println(s2);//""

        //传递一个字符串，根据传递的字符串内容再创建一个新的字符串对象
        String s3=new String("abc");
        System.out.println(s3);//abc

        //传递一个字符数组，根据字符数组的内容再创建一个新的字符串对象
        //需求:我要修改字符串的内容
        char[] chs={'a','b','c'};
        String s4=new String(chs);
        System.out.println(s4);//abcd

        //传递一个字节数组，根据字节数组的内容再创建一个新的字符串对象
        //应用场景: 以后在网络当中传输的数据其实都是字节信息
        //我们一般要把字节信息进行转换，转成字符串，此时就要用到这个构造了。
        byte[] bytes={97,98,99,100};
        String s5=new String(bytes);
        System.out.println(s5);//abcd
    }
}

    字符串的比较
        equals（要比较的字符串）
            结果完全一样是true

        equalsIgnoreCase（要比较的字符串）
            忽略大小写

      


    字符串的遍历
        public char charAt(int index)
            根据索引返回字符

        public int length()
            返回此字符串的长度

        实例
            基础

            字符串的拼接

            字符串的反转



    字符串的截取
        String substring(int beginlndex, int endindex)
            包头不包尾，包左不包右
            只有返回值才是截取的小串

        String substring(int beginindex)
            截取到末尾



StringBuilder
    概述
         可以看成是一个容器，创建之后里面的内容是可变的

    构造方法
        public StringBuilder( )
            创建一个空白可变字符

        public StringBuilder(String str)
            根据字符串内容，创建可变字符串对象

        public StringBuilder  append(任意类型)
            添加数据，并返回对象本身

        public StringBuilder reverse( )
            反转容器中的内容

        public int length（）
            返回长度(字符出现的个数)

        public String toString（）
            通过toString0就可以实现把StringBuilder转换为String

       


    链式编程
        当我们在调用一个方法的时候，不需要用变量接收他的结果，可以继续调用其他方法



StringJoiner
    概述
        可以看成是一个容器，创建之后里面的内容是可变的

    作用
        提高字符串的操作效率，而且代码编写特别简洁

    构造方法
        public StringJoiner (间隔符号)
            创建一个StringJoiner对象，指定拼接时的间隔符号

        public StringJoiner (间隔符号，开始符号，结束符号)
            创建一个StringJoiner对象，指定拼接时的间隔符号开始符号、结束符号

        public StringJoiner add (添加的内容）
            添加数据，并返回对象本身

        public int length()
            返回长度( 字符出现的个数)

        public String toString( )
            返回一个字符串(该字符串就是拼接之后的结果）