[Java知识库]Java基础学习

第一章：Java语言概述

一、Java编译运行过程与跨平台

二、JDK JRE JVM解释

JDK(Java Development Kit) — Java开发工具包 — JRE+开发工具

开发java程序最小的环境为JDK,所以JDK是JAVA语言的核心

JRE(Java Runtime Environment) — Java运行时环境 — JVM+运行java程序所必需的环境

运行java程序最小的环境为JRE

JVM(Java Virtual Machine)—负责加载.class并运行.class文件

JVM(JAVA虚拟机)将JAVA代码转换为对应的操作系统可以理解的指令,不同的操作系统有不同虚拟机与之对应,同一段代码交给虚拟机之后,虚拟机再转化给操作系统

什么是将java代码翻译成当前操作系统所理解的指令?

这指的就是编译的过程,将.java文件编译成.class字节码文件.编译完成会产生一个.class文件,这个文件称为字节码文件,操作系统看的指令文件就是字节码文件.

第二章：基本语法

标识符

标识符可以简单的理解成一个名字。在Java中，我们需要标识代码的很多元素，包括类名、方法、字段、变量、包名等等。我们选择的那个名称就称为标识符，一个正确的标识符需要遵循以下规则：

1. 标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符

2. 不能以数字开头。如:123name不合法

3. 标识符严格区分大小写。如:tmooc 和 Tmooc是两个不同的标识符

4. 标识符的命名最好能反映出其作用，做到见名知意。

5. 标识符不能是Java的关键字

ASCII编码表

ASCII(American Standard Code for Information Interchange)编码表，美国标准信息交换代码。

在计算机中，所有的数据在存储和运算时都要使用二进制数表示。

a、b、c、d这样的52个字母（包括大写）、以及0、1等数字还有一些常用的符号, 在计算机中存储时也要使用二进制数来表示，而具体用哪些二进制数字表示哪个符号，当然每个人都可以约定自己的一套（这就叫编码），而大家如果要想互相通信而不造成混乱，那么大家就必须使用相同的编码规则。

于是美国有关的标准化组织就出台了ASCII编码，统一规定了上述常用符号用哪些二进制数来表示。

中国 gb2312【字少】 àgbk【识别4万+汉字】à万国码表unicode【ISO制定】

所有码表都兼容ASCALL

附:ASCII码表

关键字

在Java中,有一些单词被赋予了特定的意义,一共有53个关键字。这53个单词都是全小写,其中有两个保留字:const和goto。

注释

几乎所有编程语言都允许程序员在代码中输入注释,因为编译器会忽略注释,所以注释并不会影响程序的运行结果。

注释的真正作用是： 它可以向任何阅读代码的人描述或者解释程序的实现思路,如何使用以及其它任何相关信息，提高代码的可读性,方便后期的维护与复用。Java的注释有3种:

1. 单行注释: 注释单行内容.

格式: 每行都以”//”开头.

快捷方式:Ctrl+/添加注释,同样的快捷键,再按一次,取消注释

2. 多行注释：注释多行内容,虽然叫多行注释,也可注释单行内容.

格式: 以/* 开头，以*/ 结束.

快捷方式:Ctrl+Shift+/添加注释,Ctrl+Shift+\取消注释,也可以输入”/*”之后按回车添加注释

3. 文档注释: 一般用来注释类和方法,通过注释内容来记录类或者方法的信息.

格式: 以 /** 开头。 以 */ 结尾.

快捷方式:输入 /** 之后按回车添加注释

变量

在JAVA中，我们需要记录一些数据,但这些数据的值是不固定的，总在变，我们可以把这些数据理解为变量。

我们通过三个元素来描述变量：变量类型 变量名以及变量值。

int age = 18; //声明int类型的变量并赋值

String tel ; //声明String类型的变量

数据类型

1、基本类型介绍（八种）

变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。

java是一个强类型的语言,会把日常见到的数据,分成好多类型.

内存管理系统根据变量类型来分配存储空间，分配的空间只能用来储存该类型数据。

位 bit,来自英文bit,音译为”比特”,表示二进制位

1Byte = 8 bits (1字节 = 8 位)

1KB = 1024Bytes 1MB = 1024KB 1GB=1024M

变量交换

      int t ;

      //t = 1;//把数字1交给变量t保存

      t = a;//把变量a中保存的值交给变量t来保存

      a = b;//把变量b中保存的值交给变量a来保存

      b = t;//把变量t中保存的值交给变量b来保存

2、 引用类型

引用类型是一个对象类型，值是什么呢？它的值是指向内存空间的引用，就是地址，所指向的内存中保存着变量所表示的一个值或一组值。如：类，接口，数组

3、基本类型的字面值

3.1整数字面值是int类型（byte1 short2 int4 long8 float4 double8）

int x = 99999;//对，右面数据的字面值是int类型

int x = 99999999999;//错，右面数据的字面值是int类型，但是已经超出int的取值范围。

3.2 byte，short，char三种比int小的整数可以用范围内的值直接赋值

byte b1=127;//对,可以用范围内的值直接赋值

byte b2=128;//错，超出byte范围

3.3浮点数的字面值是double类型

double r =3.14;//对，小数字面值类型就是double

float r =3.14;//错，右面的数据字面值是double，float是4字节存不下double类型的数据

3.4字面值后缀L D F

long x =99999999999L;//字面值是int类型,需转成long类型的数据,加字面值后缀L即可

float b = 3.0F;//3.0字面值是double类型，加后缀F会变成float类型

double d = 3D;//3字面值是int类型，加后缀D，会变成double类型

3.5进制前缀
0b - 标识这是2进制 ,如:0b0101

0 - 标识这是8进制, 8进制是三位,如: 023

0x - 标识这是16进制,如: 0x0001

\u -标识这是char类型，属于16进制

4 、 基本类型的类型转换

箭头开始的地方是小类型,箭头指向的地方是大类型
4.1 小到大(隐式转换)

byte m = 120;

int n = m;//小转大,右面的m是小类型,给左面的n大类型赋值,可以直接使用

 

float  f = 3.2f; double d = f; -->可以执行

4.2 大到小(显示转换)

int x = 999;

byte y =(byte)x;//大转小,右面x给左面的y小类型赋值,不可以,需要强制类型转换

注意：
容量大的类型转换为容量小的类型时必须使用强制类型转换。

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

例如：int i =128; byte b = (byte)i; //打印的结果是-128

因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。

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

例如：float f = 32.7f; int a2 =(int) f; //打印的结果是32

3. 不能对boolean类型进行类型转换。

4.3 口诀:
小到大，直接转 大到小，强制转 浮变整,小数没

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

5、 运算规则

5.1 计算结果的数据类型，与最大数据类型一致

System.out.println(3/2);//1，int/int,得到的结果类型还是int

System.out.println(3/2d);//1.5，int/double。得到的结果是double

5.2 byte,short,char三种比int小的整数，运算时会先自动转换成int

byte a = 1;

byte b = 2;

byte c = (byte)(a+b);

//a+b会自动提升成int类型，右面得运算结果就是int大类型

//给左面的byte小类型赋值，不可以，需要强转。

5.3 整数运算溢出
整数运算，类似于一个钟表，转到最大时，再转会回到最小。

计算：光速运行一年的长度是多少米？3亿m/s

//溢出的现象：

//因为做了大的整型数据的运算，会超出int取值范围。解决方法：把整数提升成long类型。

System.out.println(300000000L*60*60*24*365);

5.4 浮点数运算不精确
使用Java 的 BigDecimal

 public static void main(String[] args){
        BigDecimal a = new BigDecimal("4.5");
        BigDecimal b = new BigDecimal("1.5");
 
        System.out.println("a + b =" + a.add(b));
        System.out.println("a - b =" + a.subtract(b));
        System.out.println("a * b =" + a.multiply(b));
        System.out.println("a / b =" + a.divide(b));
    }

5.5浮点数的特殊值

 System.out.println(3.14/0);//Infinity--无穷大

      System.out.println(0/0.0);//NaN-Not a Number

      System.out.println(0.0/0);//NaN-Not a Number

运算符

1.1 概述

运算符 用于连接 表达式 的 操作数，并对操作数执行运算。

例如，表达式num1+num2，其操作数是num1和num2，运算符是”+”。

在java语言中，运算符可分为5种类型：

算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符。

根据操作数的不同，运算符又分为单目运算符、双目运算符和三目运算符。

单目运算符只有一个操作数，双目运算符有两个操作数，三目运算符则有三个操作数。

位运算符涉及到二进制位的运算，在java 程序中运用不是很多。

1.2 运算符速查表

a是操作数，++是自增运算符，–是自减运算符，自增和自减运算符即可以放在变量的前面，也可以放在变量的后面，例如：a++、++a、a–、–a等。
自增（++）：将变量的值加1
分前缀式（如++a）和后缀式（如a++）。前缀式是先加1再使用；后缀式是先使用再加1。
自减（–）：将变量的值减1
分前缀式（如–a）和后缀式（如a–）。前缀式是先减1再使用；后缀式是先使用再减1。

逻辑运算符连接两个关系表达式或布尔变量，用于解决多个关系表达式的组合判断问题
注意逻辑运算符返回的运算结果为布尔类型
通常，我们用0表示false，用1表示true
与：表示并且的关系
&单与： 1 & 2 ，结果想要是true，要求1和2都必须是true
&&双与(短路与)：1 && 2 ，当1是false时，2会被短路，提高程序的效率
或：表示或者的关系
|单或： 1 | 2，结果想要是true，要求1和2只要有一个为true就可以
||双或(短路或)：1 || 2，当1是true时，2会被短路，提高程序效率
TIPS:当一个表达式包含多个运算符时，就需要考虑运算符的优先级，优先级高的运算符先参与运算，优先级低的运算符后参与运算。在实际的开发中，不需要特别去记忆运算符的优先级别，也不要刻意的使用运算符的优先级别，对于不清楚优先级的地方使用小括号辅助进行优先级管理。

  //定义变量max来保存比较的最大值

        int max = a > b ? a : b;

分支结构

       //判断用户的打折段位并打折

        if(price >= 5000) {//满5000

            count = price *0.5;//打5折

        }else if(price >= 2000) {//满2000

            count = price * 0.8;//打折8折

        }else if(price >= 1000) {//满1000

            count = price *0.9;//打9折

        }

switch结构

1、概述：

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

当一个case成立，从这个case向后穿透所有case，包括default，直到程序结束或者遇到break程序才结束

			 int a = 5;
        /**总结1:a 可以支持5种数据类型:byte short char int
         * jdk1.5以后支持String*/
        switch(a) {
            case 1 : System.out.println(1);break;
            case 2 : System.out.println(2);break;
            /**总结2:break表示结束当前的case,如果不加break,
             * 会向后穿透所有的case,包括default*/
            case 3 : System.out.println(3);break;
            case 4 : System.out.println(4);break; 
            /**总结3:default是保底选项,可加可不加
             * default是如果没有case被匹配到时执行的默认选项
             * 如果在default之前遇到了break,default才不会执行*/
            default : System.out.println(0);
        }

2、switch结构的注意事项

1. switch 语句中的变量类型可以是： byte、short、int 、char、String(jdk1.5以后支持)
2. switch 语句可以拥有多个 case 语句
3. 每个 case 后面跟一个要比较的值和冒号,且此值的数据类型必须与变量的数据类型一致
4. 当变量值与 case 语句值相等时，开始执行此case 语句的内容,执行完会判断此行代码是否有break,如果有,结束执行,如果没有,会继续向后执行穿透所有case,包括default
5. switch 语句可以包含一个 default 分支，该分支一般是写在switch 语句的最后
   6)如果在default之前的case有break,则default不会执行

循环结构

for

for(开始条件;循环条件;更改条件){
syso循环体;
} 

//需求:打印0到10
        //for(开始条件;循环条件;更改条件){循环体;}
        //0 1 2 3 4 5 6 7 8 9 10
        //从哪开始：0
        //到哪结束：10
        //怎么变化：+1 ++
        for(int i = 0;i<=10;i++) {
            System.out.println(i);
        }
        System.out.println("**********************");
        //需求:打印10到0
        //10 9 8 7 6 5 4 3 2 1 0
        //从哪开始：10
        //到哪结束：0
        //怎么变化：-1  --
        //for(开始条件;循环条件;更改条件){循环体}
        for(int i = 10 ;i >= 0;i--) {
            System.out.println(i);
        }
        //需求：打印8，88，888，8888,
        //8 88 888 8888
        //从何开始：8
        //到哪结束：8888
        //如何变化：*10+8
        for(int i =8 ; i <= 8888 ; i=i*10+8) {
            System.out.print(i+",");//使用的是print(),打印后不换行
        }

嵌套for循环

概述:

存在至少2层for循环,根据外层的条件，判断里层能否执行
如果能执行，就把里层代码都循环完毕后，再继续判断是否执行外层循环的下一轮循环

for(开始条件;循环条件;更改条件){ //外层循环
	for(开始条件;循环条件;更改条件){ //内层循环
		循环体;
	} 
} 

//需求:打印矩形(3*5)
        //*****
        //*****
        //*****
        for(int i = 1; i<=3 ; i++) {//外循环--行数
            for(int j = 1; j<=5;j++) {//内循环--列数
                System.out.print("*");
            }
            System.out.println();//空白行用来换行
        }

增强for

  public static void print(Integer[] a) {
      //使用普通循环遍历数组比较复杂,引入高效for循环
      //普通循环的好处是可以控制循环的步长(怎么变化)
      for (int i = 0; i < a.length; i=i+2) {
          System.out.println(a[i]);
      }
      /**
      * 高效for/foreach循环--如果只是单纯的从头到尾的遍历,使用增强for循环
      * 好处:比普通的for循环写法简便,而且效率高
      * 坏处:没有办法按照下标来操作值,只能从头到尾依次遍历
      * 语法:for(1 2 : 3){代码块} 3是要遍历的数据  1是遍历后得到的数据的类型 2是遍历起的数据名
      */
      for(Integer i : a) {
         System.out.print(i);
      }
  }

break与continue

break: 直接结束当前循环,跳出循环体,简单粗暴
TIPS: break以后的循环体中的语句不会继续执行,循环体外的会执行
continue: 跳出本轮循环,继续下一轮循环
TIPS:continue后本轮循环体中的语句不会继续执行,但是会继续执行下轮循环,循环体外的也会执行

for(){
代码1
if(条件){
       代码3…
       break;//如果成立，直接跳出这个for循环
}
代码2…
}
continue：跳出本次循环，进入下一轮
for(){
   代码1
if(条件){
        代码3…
        continue;//如果成立，跳出本次for循环，进入下一轮
}
代码2…
}

while

形式(先判断,再执行)

while(执行条件){
循环体;
} 

do-while

形式(先执行,再判断,循环体代码保证最少执行一次)

do{
循环体;
} while (执行条件);

三种循环的区别:

三种循环都可以互相代替
1、 for：知道循环次数
2、 while/do while：当循环次数不确定时
3、 while：先判断，不符合规则，不执行代码
4、 do while：代码最少被执行一次，再去判断，符合规则，再次执行代码

变量

概念:
可以改变的数，称为变量。在Java语言中，所有的变量在使用前必须声明。
一般通过“变量类型 变量名 = 变量值 ;”这三部分来描述一个变量。如:int a = 3 ;
变量的使用原则：就近原则,即尽量控制变量的使用范围到最小

局部变量

位置:定义在方法里或者局部代码块中

注意:必须手动初始化来分配内存.如:int i = 5;或者int i; i = 5;
作用域:也就是方法里或者局部代码块中,方法运行完内存就释放了

成员变量

位置:定义在类里方法外
注意:不用初始化,也会自动被初始化成默认值
作用域:整个类中,类消失了,变量才会释放

方法

概述: 被命名的代码块,方法可以含参数可以不含参数,可以提高代码的复用性。
形式:

方法的修饰符 方法的返回值 方法名([参数列表…]){方法体;}
public static void main(String[] args){   ….   }

方法调用顺序图:

顺序执行代码,调用指定方法,执行完毕,返回调用位置

方法的重载

方法的重载是指在一个类中定义多个同名的方法,但是每个方法的参数列表不同(也就是指参数的个数和类型不同),程序在调用方法时,可以通过传递给他们的不同个数和类型的参数来决定具体调用哪个方法.

public static void main(String[] args) {
        //重载:在一个类中有多个同名的方法&方法的参数列表不同(个数不同/类型不同)
        //参数列表指的是参数的类型顺序和个数,而不是参数名
        //(int a,int b)和(int b,int a)—不属于重载
        //(int a,String b)和(String b,int a)—属于重载
        //方法的调用是根据方法名+参数列表来调用的
        method();
        method(20);
        method("海绵宝宝",3);
        method(100,100);
    }
    //创建method(int i,int j)
    public static void method(int i, int j) {
        System.out.println(i+j);
    }
    //创建method(String s,int i)
    public static void method(String s, int i) {
        System.out.println(s+"今年"+i+"岁啦");
    }
   //创建method()
    public static void method() {
        System.out.println("哈哈哈哈我没有参数");
    }
    //创建method(int num)
    public static void method(int num) {
        System.out.println(num*num);
    }

第三章：数组

概念：

数组Array，标志是[ ] ,用于储存多个相同类型数据的集合
想要获取数组中的元素值，可以通过脚标（下标）来获取
数组下标是从0开始的,下标的最大值是数组的长度减1

创建数组

数组的创建方式一般分为动态初始化和静态初始化

//1. 动态初始化
        int[] a = new int[5];
//2. 静态初始化
        int[] b = new int[]{1,2,3,4,5};
        int[] c = {1,2,3,4,5};

创建数组过程分析

程序创建数组 int[] a = new int[5]; 时发生了什么?

1. 在内存中开辟连续的空间,用来存放数据,长度是5
   

2. 给数组完成初始化过程,给每个元素赋予默认值,int类型默认值是0
   

3. 数组完成初始化会分配一个唯一的地址值
   

4. 把唯一的地址值交给引用类型的变量a去保存
   

TIPS: 数组名是个引用类型的变量,它保存着的是数组的地址,不是数组中的数据

向数组中存入数据hello

数组的长度

数组的长度用 length属性来表示,数组一旦创建，长度不可改变,数组的长度允许为0

数组的遍历

遍历:从头到尾,依次访问数组每一个位置,获取每一个位置的元素.形式如下:

我们通过数组的下标操作数组,所以for循环变量操作的也是数组下标
开始:开始下标0  结束:结束下标length-1 如何变化:++
for(从下标为0的位置开始;下标的取值<=数组的长度-1;下标++){
    循环体;
}

冒泡排序

概念：

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

形式：

相邻比较,从小到大排序,如果小的就往前换一 代表了从头到尾遍历循环数据

实现冒泡排序

//1.外层循环,控制比较的轮数,假设有n个数,最多比较n-1次
        //开始值:1 结束值:<= a.length-1 变化:++
        //控制的是循环执行的次数,比如5个数,最多比较4轮,<= a.length-1,最多取到4,也就是[1,4]4次
        for(int i = 1 ; i <= a.length-1 ; i++) {
            System.out.println("第"+i+"轮:");
            //2.内层循环:相邻比较+互换位置
            for(int j=0; j < a.length-1 ; j++) {
                //相邻比较,a[j]代表的就是前一个元素,a[j+1]代表的就是后一个元素
                if(a[j] > a[j+1]) {
                    //交换数据
                    int t = a[j];
                    a[j] = a[j+1];
                    a[j+1] = t;
                    System.out.println("第"+(j+1)+"次比较交换后:"+Arrays.toString(a));
                }
            }
            System.out.println("第"+i+"轮的结果:"+Arrays.toString(a));
        }

冒泡排序优化

//1.外层循环,控制比较的轮数,假设有n个数,最多比较n-1次
        //开始值:1 结束值:<= a.length-1 变化:++
        //控制的是循环执行的次数,比如5个数,最多比较4轮,<= a.length-1,最多取到4,也就是[1,4]4次
        for(int i = 1 ; i <= a.length-1 ; i++) {
            boolean flag = false;//优化2
            System.out.println("第"+i+"轮:");
            //2.内层循环:相邻比较+互换位置
            //结束值:a.length-i -i是因为之前轮中找到的最大值无序参与比较,i轮会产生i个最大值,所以需要
            for(int j=0; j < a.length-i ; j++) {//优化1
                //相邻比较,a[j]代表的就是前一个元素,a[j+1]代表的就是后一个元素
                if(a[j] > a[j+1]) {
                    //交换数据
                    int t = a[j];
                    a[j] = a[j+1];
                    a[j+1] = t;
                    flag = true;
                    //System.out.println("第"+(j+1)+"次比较交换后:"+Arrays.toString(a));
                }
            }
            if(flag == false) {
                return a;
            }
            System.out.println("第"+i+"轮的结果:"+Arrays.toString(a));
        }

优化的点有2个 ：
第1个就是前面几轮排序产生的最大值不需要参与后面轮的比较，执行过几轮就会产生几个值不参与比较,i轮i个,所以需要-i
第2个优化的点就是我们要设置一个量，这个量用来检测在当前这一轮的相互比较中究竟有没有发生元素的互换位置,如果发生了互换,说明顺序还没排好,flag就改成true,进行下一轮比较,但是如果在当前轮,所有元素都进行了相互比较,并没有互换位置,这就说明顺序已经排好序了,无需下一轮比较,直接return结束方法即可

数组工具类Arrays

Arrays.toString(数组)
把数组里的数据,用逗号连接成一个字符串[值1,值2]

Arrays.sort(数组)
对数组进行排序,对于基本类型的数组使用的是优化后的快速排序算法,效率高
对引用类型数组,使用的是优化后的合并排序算法

Arrays.copyOf(数组，新的长度)
把数组赋值成一个指定长度的新数组
新数组的长度 大于 原数组, 相当于复制,并增加位置
新数组的长度 小于 原数组, 相当于截取一部分数据

二维数组

概念：存放数组的数组，也就是说数组里存的还是数组的数据形式。

创建二维数组

int[][] a = {{3,5},{7,9},{1,2}};
--创建外部数组,长度是3
--给每个外部数组的位置创建内部数组,每个内部数组的长度是2
--给每个内部数组进行数据初始化
--二维数组生成唯一的地址值
--把地址值交给引用类型变量a来保存

遍历二维数组

for (int i = 0; i < a.length; i++) {//遍历外部数组
            for (int j = 0; j < a[i].length; j++) {//遍历内部数组
                System.out.println(a[i][j]);//依次打印二维数组中每个元素的值
            }
        }

第四章：面向对象

概念：

面向对象其实是一种编程思想，通过它可以把生活中复杂的事情变得简单化，从原来的执行者变成了指挥者。
面向对象是基于面向过程而言的。

• 面向过程强调的是过程,比如:
  1. 打开冰箱门 2. 把大象放进去 3. 关上冰箱门
• 面向对象强调的是结果,比如:
  什么样的冰箱?什么样的大象?谁负责把大象装进去? 而不是关注那个负责的人怎么把大象装冰箱里.
  衣服脏了，直接让女盆友去处理,等着穿干净的就可以了。你不关注中间的过程,只要找好对象就可以了~
  再比如.我们想吃一道菜,无需考虑是怎么传菜,怎么做菜的,只需点菜即可.传菜和做菜都有具体的对象来帮我们完成具体的功能.我们不需要关注实现的过程,只需要关注结果就好
  这就是我们所说的面向对象的编程实现（OOP，Object Oriented Programming）
  

面向对象的三大特征

1. 封装性，把相关的数据封装成一个“类”组件
2. 继承性，是子类自动共享父类属性和方法，这是类之间的一种关系
3. 多态，增强软件的灵活性和重用性

封装

概述：
封装是隐藏对象的属性和实现细节,仅仅对外提供公共的访问方式,比如类和方法
好处:

1. 提高安全性
   

2. 提高重用性
   

private关键字：
是一个权限修饰符 ,可以用来修饰成员变量和成员方法.被私有化的成员只能在本类中访问

/**本类用于测试封装*/
public class Test4_Private 函数main
    public static void main(String[] args) {
       //5.创建学生类对象--通过new关键字创建学生类对象
       Student s = new Student();
       //6.初步测试Student类对象s
       System.out.println(s.name);//可以通过"."来调用s对象的name属性,查看它的值
       s.study();//可以通过"."来调用s对象的study()
       //7.给s对象的属性赋值
       s.name = "程序猿";
       s.sno = 666;
       //s.subject = "Java培优";
       //8.查看赋值后的属性值
       System.out.println(s.name);
       System.out.println(s.sno);
       //System.out.println(s.subject);
       //10.通过Student类中提供 的公共的subject属性的设置与访问方法来给subject属性赋值并查看
       s.setSubject("JavaCGB");
       System.out.println(s.getSubject());
       //eat();
       s.study();
    }
}
//1.通过class关键字创建学生类--用来描述学生这一类型--属性+行为
/***
 * 封装:通过private关键字(权限修饰符)来修饰成员变量/成员方法
 * 被修饰的成员就实现了私有化,访问权限只能在本类中访问
 */
class Student{
    //2.定义属性--成员变量
    String name;//姓名
    int sno;//学号
    //9.对成员变量进行封装
    private String subject;//科目
    /**对外提供公共的属性值设置方式*/
    public void setSubject(String s) {
       subject = s;
    }
    /**对外提供公共的属性值查看方式*/
    public String getSubject() {
       return subject;
    }
    //3.定义行为--方法
    public void study() {
       System.out.println("正在学习JAVA");
       /**我们可以在公共的方法里调用私有方法*/
       eat();
    }
    //11.封装方法
    private void eat() {
       System.out.println("干饭人 干饭魂");
    }
}

TIPS:如何封装?封装后的资源如何访问?
我们可以使用private关键字来封装成员变量与方法
如何访问私有资源?
关于成员变量:

1. setXxx – 对外提供公共的设置值方式
2. getXxx – 对外提供公共的获取值方式
   关于成员方法:
   把私有方法放在公共方法里供外界调用即可

继承

概念：
继承是面向对象最显著的一个特征
继承是从已有的类中派生出新的类,新的类能吸收已有类的数据属性和行为,并扩展新的能力.
Java继承是会用已存在的类的定义作为基础建立新类的技术
新类的定义可以增加新的数据或者新的功能,也可以使用父类的功能,但不能选择性的继承父类(超类/基类)
这种继承使得复用以前的代码非常容易,能够大大的缩短开发的周期,降低开发费用.

特点：

1. 使用extends关键字来表示继承关系
2. 相当于子类把父类的功能复制了一份
3. Java只支持单继承
4. 继承可以传递(爷爷/儿子/孙子这样的关系)
5. 不能继承父类的私有成员
6. 继承多用于功能的修改,子类可以在拥有父类功能的同时,进行功能拓展
7. 像是is a的关系

/**本类是继承的入门案例*/
public class Demo {
    //5.创建入口函数main()
    public static void main(String[] args) {
        //6.创建Cat类对象进行测试
        Cat c = new Cat();
        c.eat();
        //7.创建DingDang类对象进行测试
        DingDang d = new DingDang();
        d.eat();
        System.out.println(d.a);
        //System.out.println(d.b);//子类不能继承父类的私有资源
    }
}
//1.创建动物类Animal--爷爷类
class Animal{
    //4.定义父类中的普通方法
    public void eat() {
        System.out.println("吃啥都行~");
    }
}
//2.创建小猫类Cat--爸爸类
class Cat extends Animal{
    //8.定义属性
    int a = 10;
    private int b = 200;/**5.父类的私有资源,子类不能继承*/
}
//3.创建DingDang类--子类
class DingDang extends Cat{
}

super

可以通过这个关键字使用父类的内容,Super代表的是父类的一个引用对象
注意:在构造方法里,出现的调用位置必须是第一行

方法重写Override

1. 继承以后,子类就拥有了父类的功能
2. 在子类中,可以添加子类特有的功能,也可以修改父类的原有功能
3. 子类中方法的签名与父类完全一样时,会发生覆盖/复写的现象
4. 格式要求:方法的返回值 方法名 参数列表 要完全一致,就方法体是重写的
   TIPS: 父类的私有方法不能被重写,子类在重写父类方法时,修饰符
   子类重写父类方法时,子类修饰符要大于等于父类修饰符的权限

重载Overload 与重写Override的区别

1. 重载: 是指在一个类中的现象,是指一个类中有很多同名的方法,但是方法的参数列表不同
2. 重写: 是指发生了继承关系以后(两个类),子类去修改父类原有的功能,子类中有一个方法签名(返回值类型 方法名(参数列表) )和父类的一模一样
3. 重载的意义: 是为了方便外界对方法进行调用,什么样的参数程序都可以找到对应的方法来执行,体现的是程序的灵活性
4. 重写的意义:是在不修改源码的前提下,进行功能的修改和拓展
   (OCP原则:面向修改关闭,面向拓展开放)
5. 重写要求方法的修饰符: 子类权限 >= 父类的权限

继承的用法

成员变量的使用

/**本类用于测试继承中成员变量的使用*/
public class Test6_Extends1 {
    //5.创建入口函数
    public static void main(String[] args) {
        //6.创建子类对象进行测试
        Son s = new Son();
        s.eat();
    }
}
//1.创建父类
class Father{
    //7.在父类中定义两个属性
    int count = 0;
    int sum = 300;
}
//2.创建子类
class Son extends Father{
    //4.2定义子类的成员变量
    int sum = 100;
    //3.创建子类的普通方法
    public void eat() {
        //4.1定义子类的局部变量
        int sum = 10;
        /**
         * 在子类中使用父类的资源sum,需要使用关键字super指定
         * super是表示父类的一个引用,可以理解成:
         * Father super = new Father();
         * */
        System.out.println(sum);//打印局部变量
        System.out.println(this.sum);//打印成员变量
        System.out.println(count);
        System.out.println(super.sum);
    }
}

成员方法的使用

/**本类用于测试继承中成员方法的使用*/
public class Test7_Extends2 {
    public static void main(String[] args) {
        //4.创建子类对象进行测试
        Son2 s = new Son2();
        s.eat();//调用重写后子类的eat()
        //6.创建父类对象进行测试
        Father2 f = new Father2();
        f.eat();//代用父类的功能
        s.study();//调用子类特有的功能
    }
}
//1.创建父类
class Father2{
    //3.创建父类的方法
    public void eat() {
        System.out.println("爸爸爱吃肉");
    }
}
//2.创建子类Son2
class Son2 extends Father2{
/**OCP原则:面向功能修改关闭,面向功能拓展开放
 * --只允许拓展,不允许修改原来的代码*/
/**重写的规则:和父类的方法签名保持一致
       [返回值类型&方法名&参数列表]
       子类的权限修饰符必须大于等于父类的权限修饰符
   void eat()一模一样,改的是方法体
       */
    //5.重写父类的eat()
    public void eat() {
        System.out.println("儿子爱吃饺子");
    }
    //7.子类还可以拥有自己特有的功能
    public void study() {
        System.out.println("来学习JAVA");
    }
}

构造方法的使用

/**本类用于测试继承中构造方法的使用*/
//总结:
//1.子类创建对象时,默认会访问父类的无参构造
//2.在构造方法的第一行,都有一条默认语句super();--代表的是调用父类的无参构造
//3.当父类没有无参构造时,可以通super调用父类的其他构造方法
/**本类用于测试继承中构造方法的使用*/
public class Test8_Extends3 {
    //5.创建程序的入口函数main
    public static void main(String[] args) {
        //6.创建子类对象进行测试
        Son3 s = new Son3();
    }
}
//1.创建父类
class Father3{
    //3.创建父类的无参与含参构造
    public Father3() {
        System.out.println("我是父类的无参构造");
    }
    public Father3(String s) {
        System.out.println("我是父类的含参构造"+s);
    }
}
//2.创建子类
class Son3 extends Father3{
    /**1.构造方法可以被继承吗?--不可以!!!
     * 语法要求天然就不符合:构造方法需要与类名同名
     * */
//  public Father3() {
//      System.out.println("我是父类的无参构造");
//  }
    //4.创建子类的无参构造
    public Son3() {
        /**2.子类的构造方法中,默认存在super()
         * 所以创建子类对象调用子类的构造方法时,默认先去调用父类的无参构造
         * 3.在子类创建对象时,会自动调用子类的无参构造,
         * 但是继承后会先去调用父类的无参构造
         * */
        super("噜噜噜");
        System.out.println("我是子类的无参构造");
    }
}

多态

概念：
多态指同一个实体同时具有多种形式
它是面向对象程序设计（OOP）的一个重要特征。
主要是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。
好处是：可以把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。
水果有两种形态：水果和苹果,不关心买回来的是苹果还是西瓜,只要是水果就行

class Animal{//1.定义父类Animal
     ....eat(){syso("吃啥都行")}
}
class Cat extends Animal{//2.1定义子类Cat
      ....eat(){syso("吃小鱼干")}
}
class Dog extends Animal{//2.2定义子类Dog
      ....eat(){syso("吃肉骨头")}
}
class Pig extends Animal{//2.3定义子类Pig
      ....eat(){syso("吃菜叶子")}
}
main(){
      //3.创建子类对象
      Cat c = new Cat();//小猫是小猫
      Dog d = new Dog();//小狗是小狗
      Pig p = new Pig();//小猪是小猪
      //4.创建多态对象(父类引用指向子类对象/编译看左边,运行看右边)
      Animal a1 = new Cat();//小猫是小动物
      Animal a2 = new Dog();//小狗是小动物
      Animal a3 = new Pig();//小猪是小动物
}

特点：

1. 多态的前提1：是继承
2. 多态的前提2：要有方法的重写
3. 父类引用指向子类对象,如：Animal a = new Cat();
4. 多态中，编译(保存)看左边,运行(测试)看右边
   
   多态的好处：
5. 多态可以让我们不用关心某个对象到底具体是什么类型,就可以使用该对象的某些方法------可以写出更加通用的代码
6. 提高了程序的可扩展性和可维护性

多态的使用

特点：
1) 成员变量: 使用的是父类的
2) 成员方法: 由于存在重写现象,所以使用的是子类的（成员方法使用的是父类的声明,子类的实现）
3) 静态成员: 随着类的加载而加载,谁调用就返回谁的
4）如果父子类都有静态方法,使用的是父类的

/**本类用于多态中的元素测试*/
public class DuoTai {
    public static void main(String[] args) {
        //7.创建子类对象进行测试
        Dog2 d = new Dog2();
        System.out.println(d.sum);//20
        d.eat();//小狗要吃肉骨头
        d.play();//小狗爱打滚儿~~~
        //10.创建多态对象进行测试
        /**口诀1:父类引用指向子类对象*/
        /**口诀2:编译(保存)看左边,运行(测试)看右边*/
        Animal2 a = new Dog2();
        /**2.多态中,成员变量使用的都是父类的*/
        System.out.println(a.sum);//10
        /**3.多态中,成员方法使用的是父类的声明,子类的实现*/
        a.eat();
        /**4.多态中,如果父子类都有静态方法,使用的是父类的*/
        a.play();//玩啥都行
    }
}
//1.创建父类
class Animal2{
    //2.创建成员变量
    int sum = 10;
    //3.创建成员方法
    public void eat() {
        System.out.println("吃啥都行");
    }
    //8.父类中定义静态方法play()
    public static void play() {
        System.out.println("玩啥都行");
   }
}
/**1.多态的前提:继承+重写*/
//4.定义子类Dog2
class Dog2 extends Animal2{
    //5.定义子类的成员变量
    int sum = 20;
    //6.重写父类的eat()
    /**@Override 这个注解加在方法上,表示这是一个重写的方法*/
    @Override //注解--标签
    public void eat() {
        System.out.println("小狗要吃肉骨头");
    }
    //9.定义子类的静态方法play()
    //@Override --不是重写,不能加这个注解
    public static void play() {
        System.out.println("小狗爱打滚儿~~~");
    }
}

注意!!!静态资源属于类,不存在重写现象,只是两个类中有同样声明的方法而已,不属于重写

向上转型和向下转型

在JAVA中，继承是一个重要的特征，通过extends关键字，子类可以复用父类的功能，如果父类不能满足当前子类的需求，则子类可以重写父类中的方法来加以扩展。
在应用中就存在着两种转型方式，分别是：向上转型和向下转型。
比如：父类Parent,子类Child
向上转型：父类的引用指向子类对象Parent p=new Child();
说明：向上转型时，子类对象当成父类对象，只能调用父类的功能，如果子类重写了父类的方法就根据这个引用指向调用子类重写方法。
向下转型(较少)：子类的引用的指向子类对象，过程中必须要采取到强制转型。
Parent p = new Child();//向上转型，此时，p是Parent类型
Child c = (Child)p;//此时，把Parent类型的p转成小类型Child
//其实，相当于创建了一个子类对象一样，可以用父类的，也可以用自己的
说明：向下转型时，是为了方便使用子类的特殊方法，也就是说当子类方法做了功能拓展，就可以直接使用子类功能。

类和对象

1. 类：

1. Java语言最基本单位就是类，类似于类型。
2. 类是一类事物的抽象。
3. 可以理解为模板或者设计图纸。

2. 对象：
   每个对象具有三个特点：对象的状态，对象的行为和对象的标识。

1. 对象的状态用来描述对象的基本特征。
2. 对象的行为用来描述对象的功能。
3. 对象的标识是指对象在内存中都有一个唯一的地址值用来和其他对象区分开来。
4. 类是一类事物的抽象，对象是具体的实现。

3. 类和对象的关系：

1. 计算机语言来怎么描述现实世界中的事物的? 属性 + 行为
2. 那怎么通过java语言来描述呢?通过类来描述一类事物,把事物的属性当做成员变量,把行为当做方法

类的创建使用

分析手机事物：
属性：颜色，尺寸，品牌，价格
功能：打电话，发短信，听音乐
类：手机类，抽取相同的属性和行为
对象：可以按照模板生产很多个手机，比如1号手机对象，包含特有的成员变量和方法
通过class关键字创建类，通过new关键字创建对象。

//在一个java文件中可以写多个class,但是被public修饰的只能有一个,而且这个类的名字就是文件名
public class Test3_ClassExec {
    public static void main(String[] args) {
       //2.在main()中通过new关键字来创建对应类的对象
       Phone p = new Phone();
       //3.通过.来完成对象功能的调用
       p.call();
       p.message();
       p.learn();
       //4.通过.来查看对象的属性值
       System.out.println(p.brand);
       System.out.println(p.price);
       System.out.println(p.size);
       System.out.println(p.color);
    }
}
//1.通过class关键字创建手机类--用来描述手机这一类事物--特征+行为
//类是一类事物的抽象,只抽象的规定这一类事物的特征和行为
class Phone{
    //特征(属性)--类的成员变量来描述--位置:类里方法外
    String brand;//品牌
    double price;//价格
    double size;//尺寸
    String color;//颜色
    //行为(功能)--类的方法来描述--修饰符 返回值类型 方法名(参数列表){方法体}
    public void call() {
       System.out.println("正在打电话");
    }
    public void message() {
       System.out.println("正在发短信");
    }
    public void learn() {
       System.out.println("正在看直播");
    }
}

对象在内存中的存储

创建对象的流程

Person p = new Person();//短短这行代码发生了很多事情

1. 把Person.class文件加载进内存
   

2. 在栈内存中，开辟空间，存放引用变量p
   

3. 在堆内存中，开辟空间，存放Person对象
   

4. 对成员变量进行默认的初始化
   

5. 对成员变量进行显示初始化
   

6. 执行构造方法（如果有构造代码块，就先执行构造代码块再执行构造方法）
   

7. 堆内存完成
   

8. 把堆内存的地址值赋值给变量p ，p就是一个引用变量，引用了Person对象的地址值
   

Java把内存分成5大区域，我们重点关注栈和堆。

1. 一般来讲局部变量存在栈中，方法执行完毕内存就被释放
2. 对象(new出来的东西)存在堆中，对象不再被使用时，内存才会被释放
3. 每个堆内存的元素都有地址值
4. 对象中的属性都是有默认值的
   TIPS: 栈与队列指的是一种数据的结构。
   栈：先进后出（FILO – First In Last Out）
   队列：先进先出（FIFO – First In First Out）

创建多个对象

p2.brand = “HUAWEI”;
就是先到栈内存中找到p2中保存的唯一的地址值
然后根据地址值找到Phone对象,并对其对应的属性值进行修改

p2.learn();
也是先到栈内存中找到p2中保存的唯一的地址值
然后根据地址值找到Phone对象,执行Phone对象的lean()方法

匿名对象

没有名字的对象，是对象的简化表示形式。
使用场景：
当被调用的对象只调用一次时（多次会创建多个对象浪费内存）

Demo d = new Demo();
d.sleep();
d.game();
//这个d就是对象的名字。
//也可以写成：
new Demo().show();//创建了一个对象调方法
new Demo().game();//又创建了一个对象调方法

访问控制符

用来控制一个类，或者类中的成员的访问范围。

TIPS:default是表示不写修饰符,默认,如果写default单词来修饰会报错

构造方法

概念:

构造方法是一种特殊的方法,它是一个与类同名且没有返回值类型的方法
对象创建就是通过构造方法完成的,主要功能是完成对象的创建或者对象的初始化
当类创建对象(实例化)时,会自动调用构造方法
构造方法与普通方法一样也可以重载.

形式:

   与类同名,且没有返回值类型,可以含参也可以不含参

修饰符 方法名([参数列表]){ 注意:方法名与类名一样
代码……
}

TIPS:关于构造函数怎么记忆
特点:方法名与类名相同,且没有返回值类型
执行时机:创建对象时立即执行
默认会创建无参构造,但是,如果自定了含参构造,默认的无参构造会被覆盖,注意要手动添加哦

构造代码块与局部代码块

构造代码块的特点

1. 位置: 在类的内部,在方法的外部
2. 作用: 用于抽取构造方法中的共性代码
3. 执行时机: 每次调用构造方法前都会调用构造代码块
4. 注意事项: 构造代码块优先于构造方法加载

局部代码块

1. 位置: 在方法里面的代码块
2. 作用: 通常用于控制变量的作用范围,出了花括号就失效
3. 注意事项: 变量的作用范围越小越好,成员变量会存在线程安全的问题

代码块的加载顺序

/**
 * 总结:
 * 1.当创建对象时,程序会自动调动构造方法,但是如果有构造代码块,会先去执行构造代码块,再执行构造方法
 * 2.当通过对象调用方法时,会执行方法中的功能,如果方法中有局部代码块,就会执行局部代码块
 * 3.执行顺序: 构造代码块-->构造方法-->局部代码块[前提:调用方法(如果方法有局部代码块,局部代码块才会执行)]
 * 4.构造代码块的功能: 用于提取构造方法中的共性
 * 5.局部代码块的功能:控制变量的作用范围
 * */
/**本类用来测试构造代码块与局部代码块*/
public class Test3_Block {
    //5.创建main并创建对象测试
    public static void main(String[] args) {
        /**每次创建对象时,都会调用对应的构造方法*/
        Teacher t = new Teacher();//通过调用无参构造创建对象
        Teacher t2 = new Teacher("12312","JAVA");//通过调用全参构造创建对象
        System.out.println(t2.name);
        System.out.println(t2.subject);
        t.teach();
        t.study();
    }
}
//1.定义Teacher类用于测试
class Teacher{
    //2.定义属性--成员变量--全局生效
    String name;//名字
    String subject;//科目
    //7.构造代码块
    //1)位置:类里方法外
    //2)作用:用来提取构造方法的共性功能
    //3)执行时机:在调用构造方法之前调用
    {
        subject = "JAVA";
       System.out.println("哈哈哈哈要调用构造方法啦");
    }
    //构造方法的定义:修饰符 方法名(参数列表){方法体}
    //4.1创建无参构造方法
    public Teacher() {
        System.out.println("无参构造"+subject);
    }
    //4.2创建全参构造方法
    public Teacher(String n,String s) {
        name = n;
        subject = s;
        System.out.println("全参构造"+subject);
    }
    //3.定义普通方法
    //方法的定义:修饰符 返回值类型 方法名(参数列表){方法体}
    public void study() {//备课方法
        //6.创建局部代码块
        //1)位置:方法里
        //2)作用:用来控制变量的作用范围(作用范围越小越好,因为越小越安全)
        //3)执行时机:调用本方法时
        {
            int i =10;
            System.out.println(i);
        }
        System.out.println("正在备课ing");
    }
    public void teach() {//上课方法
        System.out.println("正在上课ing");
    }
}

this

概念:
this 代表本类对象的一个引用对象
形式:
this.name = name ;

/**
 * this可以用来进行构造方法之间的调用\
 * 但是注意!!!!!调用是单向的,不是双向来回调用,会死循环
 * */
//1.创建类Dog
class Dog{
    //2.定义属性name
    String name;
    //3.提供无参构造
    public Dog() {
        /**在无参构造中调用含参构造的功能*/
        /**规定:this关键字必须在构造方法中的第一行*/
        this("拉拉");
        System.out.println("无参构造");
    }
    //4.提供含参构造
    public Dog(String s) {
        /**在含参构造中调用无参构造的功能*/
        /**规定:this关键字必须在构造方法中的第一行*/
        //this();
        System.out.println("含参构造"+s);
    }
}

this与super的区别

1. this代表本类对象的引用
   class Father3{ this.XXX } //this – Father3 this = new Father3();
2. super代表父类对象的引用
   class Father3{ super.XXX } //this – Father3 super = new Father3();
   就相当于创建了一个父类对象
3. this可以在两个变量名相同时,用于区分成员变量和局部变量
4. this 可以在本类的构造方法之间调用,位置必须是第一条语句,注意,不能相互调用,会死循环
5. super是发生了继承关系以后,子类如果想用父类的功能,可以通过super调用
6. 如果发生了重写,还想用父类的功能,需要使用super来调用
7. Super在调用父类构造方法时,必须出现在子类构造方法的第一条语句,而且如果父类中没有提供无参构造,子类可以通过super来调用父类其他的含参构造

static

概念：
是java中的一个关键字，用于修饰成员（成员变量和成员方法）

特点：

1. 可以修饰成员变量与成员方法
2. 随着类的加载而加载，优先于对象加载
3. 只加载一次，就会一直存在，不再开辟新空间, 直到类消失才一起消失
4. 静态资源也叫做类资源,全局唯一,被全局所有对象共享
5. 可以直接被类名调用
6. 静态只能调用静态，非静态可以随意调用
7. static不能和this或者super共用，因为有static时可能还没有对象

/**本类用于测试静态的入门案例*/
public class Test_Static1 {
    //4.创建程序的入口函数main()
    public static void main(String[] args) {
        /**3.静态资源可以通过类名直接调用*/
        /**4.静态资源是优先于对象进行加载的,随着类的加载而加载
         * 比对象先加载进入内存,没对象时也可以被类名直接调用
         * */
        //9.通过类名直接调用静态资源进行测试
        System.out.println(Student.name);
        Student.study();
        //5.创建Student类对象进行测试
        Student s = new Student();
        //6.更改并查看name属性的值
        s.name = "黄桃罐头";
        System.out.println(s.name);
        //7.调用学生类的方法
        s.study();
        s.speak();
        //8.创建多个对象进行测试
        Student s2 = new Student();
        /**5.静态全局共享*/
        System.out.println(s2.name);
        System.out.println(Student.name);
    }
}
//1.创建学生类
class Student{
    /**1.可以通过static关键字将普通资源修饰成静态资源*/
    /**2.static可以用来修饰成员变量和方法,一般写在权限修饰符之后*/
    //2.定义属性--成员变量--无需手动初始化
    int sno;
    static String name;
    //3.定义方法--修饰符 返回值类型 方法名(参数列表){方法体}
    public static void study() {
        System.out.println("别闹~学JAVA呢~");
    }
    public void speak() {
        System.out.println("大声说出来~");
    }
}

static静态调用关系

1.静态资源只能调用静态资源
2.非静态资源既可以调用静态资源,也可以调用非静态资源

静态代码块、构造代码块、局部代码块

静态代码块格式：
static {}
静态资源随着类的加载而加载，并且只被加载一次，一般用于项目的初始化
特点: 被static修饰,位置在类里方法外

三种代码块的比较

1. 静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化
2. 构造代码块：在创建对象时会自动调用，每次创建对象都会被调用,提取构造共性
3. 局部代码块：方法里的代码块,限制局部变量的范围

几种代码块的关系：
1.代码之间的执行顺序:
静态代码块–>构造代码块–>构造方法–>局部代码块
2.为什么是这样的顺序呢?
静态代码块要优先于对象进行加载
是随着类的加载而加载到内存中的
只加载一次,并且一直存在,直到类消失,它才会消失
3.每个元素的作用:
1)静态代码块:专门用来完成一些需要第一时间加载并且只加载一次的资源
2)构造代码块:创建对象时才会触发,用来提取构造方法中的共性内容
3)构造方法:创建对象时调用,用来创建对象,在构造代码块执行后执行
4)局部代码块:调用所在的方法时才会调用,用来控制变量的作用范围

静态变量和实例变量的区别

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。
在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

final

概念：

1. 是java提供的一个关键字
2. final是最终的意思
3. final可以修饰类，方法，成员变量
   初衷：java出现继承后，子类可以更改父类的功能，当父类功能不许子类改变时,可以利用final关键字修饰父类。

特点：

1. 被final修饰的类，不能被继承
2. 被final修饰的方法，不能被重写
3. 被final修饰的变量是个常量，值不能被改变
4. 常量的定义形式：final 数据类型 常量名 = 值

/**本类用于测试final的入门案例*/
public class Demo {
    public static void main(String[] args) {
        //5.创建子类对象进行测试
        Son4 s = new Son4();
        s.work();
//      s.name = "干饭人";//报错:常量的值不可以被修改
    }
}
/**1.final表示最终,可以用来修饰类
 * 但是被final修饰的类无法被继承
 * 也就是没有子类,它自己就是最终类
 * */
//1.创建父类
//final class Father4{//报错:Son4类不能是final修饰的Father4的子类
class Father4{
    //3.创建成员变量并赋值
    /**2.final可以用来修饰成员变量,被final修饰的变量值不可以被修改--常量*/
    final String name = "打工人";
    //4.创建成员方法
    /**3.final可以用来修饰成员方法,但是被final修饰的方法是最终实现,子类无法重写*/
    final public void work() {
        System.out.println("Father4...打工人,打工魂");
    }
}
//2.创建子类
class Son4 extends Father4{
    //子类重写父类的work方法   //父类方法为final  报错
//  public void work() {
//      System.out.println("Son4...打工人要用计算机打工~");
//  }
}

抽象类

概念：

Java中可以定义被abstract关键字修饰的方法,这种方法只有声明,没有方法体,叫做抽象方法.
Java中可以定义被abstract关键字修饰的类,被abstract关键字修饰的类叫做抽象类
如果一个类含有抽象方法,那么它一定是抽象类
抽象类中的方法实现交给子类来完成

抽象方法的格式：

权限修饰符 abstract 返回值类型 方法名(参数列表);

特点：

1. abstract 可以修饰方法或者类
2. 被abstarct修饰的类叫做抽象类,被abstract修饰的方法叫做抽象方法
3. 抽象类中可以没有抽象方法
4. 如果类中有抽象方法,那么该类必须定义为一个抽象类
5. 子类继承了抽象类以后,要么还是一个抽象类,要么就把父类的所有抽象方法都重写
6. 多用于多态中
7. 抽象类不可以被实例化

抽象类中的构造函数通常在子类对象实例化时使用

/**本类用于测试抽象类中的成员*/
public class Test4_Abstract3 {
    public static void main(String[] args) {
        //7.创建多态对象进行测试
        Fruit f = new Apple();
        System.out.println(f.sum);//10
        //f.name = "lemon";//常量的值不可以被修改The final field Fruit.name can not be assigned
        System.out.println(f.name);
        f.eat();//父类的功能
        f.eat2();//子类实现的功能
        f.clean();//子类实现的功能
    }
}
//1.创建抽象父类--水果类
abstract class Fruit{
    /**1.抽象类中可以有成员变量吗?--可以!!!*/
    //3.1创建抽象父类的成员变量
    int sum = 10;
    /**2.抽象类中可以有成员常量吗?--可以!!!*/
    //3.2创建抽象父类的成员常量,注意初始化
    final String name ="banana";
    /**3.抽象类中可以有普通方法吗?--可以!!!
     * 抽象类中可以都是普通方法吗?--可以!!!
     * */
    /**4.如果一个类中都是普通方法,为啥还要被声明成抽象类呢?
     * 原因:抽象类不可以创建对象
     * 如果不想让外界创建本类对象,可以把普通类声明成抽象类
     * */
    //4.创建抽象父类的普通方法
    public void eat() {
        System.out.println("吃啥水果都行");
    }
    //5.创建抽象父类中的抽象方法
    /**5.抽象类中可以有抽象方法
     * 一旦类中有抽象方法,这个类必须被声明成一个抽象类*/
    public abstract void eat2() ;
    public abstract void clean();
}
/**
 * 6.当一个类继承了父类,并且父类是抽象父类时
 * 子类需要重写(实现)父类中的所有抽象方法或者把自己变成抽象子类
 * */
//2.创建子类--苹果类
//6.1解决方案一:把自己变成一个抽象子类
//abstract class Apple extends Fruit{
//6.2解决方案二:重写抽象父类中的所有抽象方法
class Apple extends Fruit{
    @Override
    public void eat2() {
        System.out.println("水果中最爱吃苹果");
    }
    @Override //注解,相当于标记,标记了这个方法是一个重写的方法
    public void clean() {
        System.out.println("苹果还是要好好洗洗再吃的");
    }
}

abstract注意事项

抽象方法要求子类继承后必须重写。
那么，abstract关键字不可以和哪些关键字一起使用呢？以下关键字，在抽象类中。用是可以用的，只是没有意义了。

1. private：被私有化后，子类无法重写，与abstract相违背。
2. static：静态优先于对象存在。而abstract是对象间的关系，存在加载顺序问题。
3. final：被final修饰后，无法重写，与abstract相违背。

拓展：

递归案例：

//需求:求用户输入数字的阶乘结果
//f(int n)--用来求阶乘
//规律：
//f(n)= n*f(n-1)
//f(5)= 5*4*3*2*1 = 5*f(4)
//f(4)= 4*3*2*1 = 4*f(3)
//f(3)= 3*2*1 = 3*f(2)
//f(2)= 2*1 = 2*f(1)
//f(1)= 1
//
//5!=5*4*3*2*1=120
//4!=4*3*2*1
//3!=3*2*1
//2!=2*1
//1!=1

接口

概念：

Java里面由于不允许多重继承,所以如果要实现多个类的功能,则可以通过实现多个接口来实现,Java接口和Java抽象类代表的就是抽象类型,就是我们需要提出的抽象层的具体表现
OOP面向对象编程,如果要提高程序的复用率,增加程序的可维护性,可扩展性,就必须是面向接口编程,面向抽象的变成,正确的使用接口/抽象类这些抽象类型作为java结构层次上的顶层.

接口格式：

 interface 接口名{ 代码… }

接口的特点:

1. 接口中都是抽象方法
2. 通过interface关键字来定义接口
3. 通过implements让子类来实现接口
4. 可以理解成,接口是一个特殊的抽象类(接口里的方法都是抽象方法)
   .在JDK1.8以后不仅仅只有常量和抽象方法,还有默认方法和静态方法
   默认方法用来直接给子类使用,如果子类想重写也可以自行根据需求重写,不会强制重写
   静态方法用来直接通过接口名访问
5. 接口突破了java单继承的局限性
6. 接口和类之间可以多实现,接口与接口之间可以多继承
7. 接口是对外暴露的规则,是一套开发规范
8. 接口提高了程序的功能拓展,降低了耦合性
   9）常量: 默认使用 public static final 方法: 默认使用 public abstract修饰

/**本接口是创建接口测试*/
/**1.通过interface关键字来定义接口*/
public interface Inter {
      /**2.接口中可以有普通方法吗?--不可以!!*/
      //public void eat() {}
      /**3.接口中可以有抽象方法吗?--可以,接口中的方法都是抽象方法!!!*/
      public abstract void eat();
      public abstract void play();
}

/**本类作为Inter接口的实现类*/
/**1.实现类如果想用接口的功能,要和接口建立实现关系,通过关键字implements来实现*/
/**2.1 方案一:如果实现类与接口建立关系以后,可以选择不实现接口中的抽象方法,而是把自己变成一个抽象子类*/
//abstract public class InterImpl implements Inter{
/**2.2 方案二:如果实现类实现了接口以后,可以重写接口中的所有抽象方法*/
public class InterImpl implements Inter{
      @Override //作为标记,表示实现了父接口的抽象方法
      public void eat() {
           System.out.println("吃火锅");
      }
      @Override//作为标记,表示实现了父接口的抽象方法
      public void play() {
           System.out.println("玩代码");
      }
}

/**本类用于测试接口的实现类*/
public class InterTests {
    //6.创建入口函数main()
    public static void main(String[] args) {
        //7.测试接口创建对象
        /**接口可以创建对象吗?--不可以!!!*/
        //Inter i = new Inter();
        //8.创建多态对象进行测试
        Inter i = new InterImpl();
        //9.通过对象调用方法测试
        i.eat();
        i.play();
        //10.创建子类对象并进行测试
        InterImpl i2 = new InterImpl();
        i2.eat();
        i2.play();
    }
}

接口的用法

/**本类用于进一步测试接口的使用*/
public class UserInter {
     //5.创建入口函数main()
    public static void main(String[] args) {
        //6.创建多态对象进行测试
        /**问题:子类创建对象时,默认会调用父类的构造方法
         * 目前接口实现类的父级是一个接口,而接口没有构造方法
         * 那实现类构造方法中的super()调用的是谁呢?
         * 结论1:如果一个类没有明确指定父类,那么默认继承顶级父类Object
         * 所以super()会自动调用Object类中的无参构造
         * */
        /**查看类的继承结构:Ctrl+T*/
        Inter2 i = new Inter2Impl();
        /**结论2:接口中的变量实际上都是静态常量,可以通过类名直接调用*/
        System.out.println(Inter2.age);
        /**结论3:接口中的变量实际上都是静态常量,值不可以被修改*/
        //Inter2.age = 200;
    }
}
//1.创建接口
interface Inter2{
    /**1.接口中有构造方法吗?--不可以!!!*/
    //2.测试接口是否可以有构造方法
//  public Inter2() {}
    /**2.接口里可以有成员变量吗?--没有!!!
     * 是一个静态常量,实际上的写法是public static final int age = 10;
     * 只不过在接口中可以省略不写
     * */
    int age  = 10;
     /**3.接口中可以有抽象方法吗?--可以!!!*/
      abstract public void eat2();
      void eat();//可以简写--会自动拼接public abstarct
}
//3.创建接口的实现类
//class Inter2Impl extends Object implements Inter2{
class Inter2Impl implements Inter2{
    //4.创建实现类的构造函数
    public Inter2Impl() {
        super();//默认先调用顶级父类Object的无参构造方法
        System.out.println("我是Inter2Impl的无参构造");
    }
     /**4.如果接口中添加了抽象方法,实现类中需要实现所有未实现的抽象方法*/
      @Override
      public void eat2() {
      }
      @Override
      public void eat() {
      }
}

总结:
接口里是没有构造方法的。在创建实现类的对象时默认的super()，是调用的默认Object的无参构造。
接口里没有成员变量，都是常量。所以，你定义一个变量没有写修饰符时，默认会加上：public static final
接口里的方法，默认就都是抽象的，如果你不写明是abstract的，那会自动补齐。例如：public abstract void save

接口的多继承多实现

public class Test4 {
    //5.创建入口函数
    public static void main(String[] args) {
        //6.创建实现类对象进行测试
        Inter3Impl i3 = new Inter3Impl();
        i3.update();
        //7.创建多态对象进行测试
        Inter3 i4 = new Inter3Impl();
        i4.find();
    }
}
//1.创建接口1
interface Inter1{
    void save();//保存功能
    void delete();//删除功能
}
//2.创建接口2
interface Inter2{
    void update();//更新功能
    void find();//查询功能
}
//3.创建接口3用来测试接口与接口的继承关系
/**1.接口之间可以建立继承关系,而且还可以多继承
 * 接口与接口之间用逗号隔开
 * */
interface Inter3 extends Inter1,Inter2{
}
//4.创建Inter3接口的实现类并添加未实现的方法
/**2.接口和实现类之间可以建立实现关系,通过implments关键字来完成
 * 注意,java类是单继承,而接口不限,写接口时,我们一般先继承再实现
 * */
class Inter3Impl implements Inter3{
    @Override
    public void save() {
        System.out.println("稍等...正在保存中...");
    }
    @Override
    public void delete() {
        System.out.println("稍等...正在删除中....");
    }
    @Override
    public void update() {
        System.out.println("客官，马上就更新好啦~~");
    }
    @Override
    public void find() {
        System.out.println("小二正在马不停蹄的查询~~~");
    }
}

总结

1.类与类的关系

–继承关系,只支持单继承
–比如,A是子类 B是父类,A具备B所有的功能(除了父类的私有资源和构造方法)
–子类如果要修改原有功能,需要重写(方法签名与父类一致 + 权限修饰符>=父类修饰符)

2.类和接口的关系
–实现关系.可以单实现,也可以多实现
–class A implements B,C{}
–其中A是实现类,B和C是接口,A拥有BC接口的所有功能,只是需要进行方法的重写,否则A就是抽象类

3.接口与接口的关系
–是继承关系,可以单继承,也可以多继承
–interface A extends B,C{}
–其中ABC都是接口,A是子接口,具有BC接口的所有功能(抽象方法)
–class X implements A{}
–X实现类需要重写ABC接口的所有方法,否则就是抽象类
–class A extends B implements C,D{}
–其中A是实现类,也是B的子类,同时拥有CD接口的所有功能
–这时A需要重写CD接口里的所有抽象方法

4.抽象类与接口的区别

1. 抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
2. 抽象类要被子类继承，接口要被子类实现。
3. 接口只能做方法声明，抽象类中可以做方法声明，也可以做方法实现
4. 接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
5. 抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
6. 抽象方法只能声明，不能实现，接口是设计的结果 ，抽象类是重构的结果
7. 抽象类里可以没有抽象方法
8. 如果一个类里有抽象方法，那么这个类只能是抽象类
9. 抽象方法要被实现，所以不能是静态的，也不能是私有的。
10. 接口可继承接口，并可多继承接口，但类只能单继承。

拓展

类：
对事物/算法/逻辑/概念等等的抽象,可以把它理解成”模板/图纸”
封装:相关的数据/运算代码封装成一个”类”组件

对象:
从”类”出发创建具体的”实例”
每个对象,占用独立的内存空间,保存各自的属性数据
可以独立控制一个对象,来执行指定的方法代码

软件设计的开闭原则OCP:

开放功能扩展，关闭源码修改。等
开闭原则的英文全称是Open Close Principle，缩写是OCP，它是Java世界里最基础的设计原则，它指导我们如何建立一个稳定的、灵活的系统。
开闭原则的定义是：软件中的对象（类、模块、函数等）应该对于扩展是开放的，但是对于修改是封闭的。
开闭原则，是一种设计模式，随着面向对象程序设计的思想，应运而生。
开，指的是可以在源代码的基础上进行扩展，比如继承，接口，抽象类等。在JAVA中，之所以用继承，是在可以直接调用类库的前提下，对其功能进行扩展。不需要应用者去了解封装类的内部逻辑就可以做开发。
闭：指不允许对原有的代码进行修改。以免影响其他现有功能，造成功能瘫痪。

第五章：异常

概述： 用来封装错误信息的对象

异常的继承结构：

   Throwable : 顶级父类
           --Error : 系统错误,无法修复
           --Exception : 可以修复的错误
                 -- RunTimeException
                       -- ClassCastException
                       -- ClassNotFoundException
                       -- ...

异常处理

当程序中遇到了异常,通常有两种处理方式:捕获或者向上抛出
当一个方法抛出异常,调用位置可以不做处理继续向上抛出,也可以捕获处理异常

1. 捕获方式：
   try{
   需要捕获的代码
   }catch(异常类型 异常名){
   处理方案
   }
2. 抛出方式：
   在会发生异常的方法上添加代码：throws 异常类型
   例如：public static void main(String[] args) throws Exception{

/**本类用于测试异常的入门案例*/
/**
 * 总结8:
 * 如果方法抛出异常,那么谁调用,谁需要解决(继续抛出/捕获解决)
 * 所以main()调用了method2(),如果main()不捕获处理,就也需要抛出异常
 * 注意:我们一般在main()调用之前捕获解决异常,而不是把问题抛给main()
 * 因为没人解决了
 * */
public class ExceptionDemo {
    //1.创建入口函数main()
    public static void main(String[] args) throws Exception {
        //method();//调用method()--暴露异常
        //method1();//调用method1()--异常捕获
        method2();//调用method2()--异常抛出
    }
    //4.创建method2(),练习BUG解决方案二
    /**抛出的语法规则:
     * 在可能会出现异常的方法上加 throws 异常类型
     * 在抛出时,也可以使用多态,不管是发生了什么异常,通通被Exception抛出去
     * */
    //  public static void method2() throws InputMismatchException
    //  ,ArithmeticException,Exception{
    public static void method2() throws Exception{
        //4.复写刚刚可能会发生异常的代码
        System.out.println("请输入您要计算的第一个数:");
        int a = new Scanner(System.in).nextInt();
        System.out.println("请输入您要计算的第二个数:");
        int b = new Scanner(System.in).nextInt();
        System.out.println( a / b );
    }
    /**捕获的语法规则:
     * try{
     *      可能会出现异常的代码
     * }catch(异常类型 异常参数名){
     *      如果捕获到异常的对应解决方案
     * }
     * */
    //3.创建method1(),练习BUG解决方案一
    public static void method1() {//11:15继续~,代码已上传至code网站
        //3.1按照学习的捕获语法编写try-catch结构
        /**总结4:try中放着的是可能会出现异常的代码*/
        try {
            //3.2复写刚刚可能会发生异常的代码
            System.out.println("请输入您要计算的第一个数:");
            int a = new Scanner(System.in).nextInt();
            System.out.println("请输入您要计算的第二个数:");
            int b = new Scanner(System.in).nextInt();
            System.out.println( a / b );
            /**总结5:如果发生异常被捕获,就执行此处被匹配到的解决方案*/
        }catch(InputMismatchException e) {//3.3异常捕获1
            System.out.println("输入的类型不正确,请输入正确的整数类型");
            /**总结6:由于程序中可能出现多种异常,所以catch可以配合多次使用*/
        }catch(ArithmeticException e) {//3.4异常捕获2
            System.out.println("除数不能为0!!");
            /**总结7:如果还有上述两种异常之外的异常,用Exception匹配捕获
             * 这个就是多态最为经典的一种用法,我们不关心子类的子类
             * 只要是可解决的异常,都是Exception的子类,多态会把这些异常当做父类型来看
             * 进而捕获,使用通用异常解决方案来解决
             * */
        }catch(Exception e) {
            System.out.println("请输入正确的整数~");
        }
    }
    //2.创建method()用来人为的暴露异常
    public static void method() {
        //2.1提示并接收用户输入的两个整数
        System.out.println("请输入您要计算的第一个数:");
        int a = new Scanner(System.in).nextInt();
        System.out.println("请输入您要计算的第二个数:");
        int b = new Scanner(System.in).nextInt();
        //2.2 输出除法运算的结果
        //输入8和2.2,报错:InputMismatchException[输入不匹配异常]
        //输入9和0,报错:ArithmeticException: / by zero[算数异常,除数不能为0]
        System.out.println( a / b );
        /**1.不要害怕BUG,真正的勇士敢于直面自己写的BUG*/
        /**2.学会看报错信息的错误提示,确定自己错误的方向*/
        /**3.学会看报错信息的行号提示,哪里报错点哪里
         * 源码不会错,要看的是自己写的代码*/
    }
}

第六章 ：常用API

概念：

API（Application Programming Interface，应用程序接口）是一些预先定义的函数。目的是提供应用程序与开发人员基于某软件可以访问的一些功能集，但又无需访问源码或理解内部工作机制的细节.
API是一种通用功能集,有时公司会将API作为其公共开放系统,也就是公司制定自己的系统接口标准,当需要进行系统整合,自定义和程序应用等操作时,公司所有成员都可以通过该接口标准调用源代码.

Java.util包是java中的工具包,包含各种实用工具类/集合类/日期时间工具等各种常用工具包
import java.util.Scanner;
import java.util.Arrays;

java.lang包是java的核心,包含了java基础类,包括基本Object类/Class类/String类/基本数学类等最基本的类
这个包无需导入,默认会自动导入
import java.lang.Object;
import java.lang.String;
import java.lang.StringBuilder/StringBuffer;
正则表达式
包装类等等

Object

概念：

Object类是所有Java类的祖先,也就是说我们所说的”顶级父类”
存在于java.lang.Object,这个包不需要我们手动导包
每个类都使用Object作为超类.所有对象(包括数组)都实现这个类的方法.在不明确给出超类的情况下,Java会自动把Object类作为要定义类的超类.

常用方法介绍：

toString()

本方法用于返回对应对象的字符串表示.

hashCode()

本方法用于返回对应对象的哈希码值
TIPS:哈希码是一种算法,使不同的对象有不同的哈希码值,但是也有相同的情况,我们称之为”哈希碰撞”

equals()

本方法用于指示其他某个对象是否与当前对象”相等”

String

特点：

String是一个封装char[]数组的对象,字符串不可变
通过下图中的底层实现可以看出:被final修饰,是常量
String str = “abc”; 等效于：char data[] = {‘a’, ‘b’, ‘c’};

创建String对象的方式

方式一:
String(char[] value) 分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
方式二: String str = “abc”;

1. 如果是第一次使用字符串，java会在字符串常量池创建一个对象。
2. 再次使用相同的内容时，会直接访问常量池中存在的对象。

常见方法

length()-查看字符串的长度
charAt()—定位某个字符,返回它的位置
lastIndexOf()-某个字符最后一次出现的位置
substring()-截取子串,如果参数有两个左闭右开[1,5)
equals()-判断两个串是否相等,注意String重写了Object的此方法,所以内容相同就返回true
startsWith()-判断是不是以参数开头
endsWith()--判断是不是以参数结尾
split()—以指定字符分割
trim()-去掉首尾两端的空格
getBytes()-把串转换成数组
toUpperCase()-变成全大写
toLowerCase()-变成全小写
String.valueOf(10)-把int类型的10转换成String类型

StringBuilder/StringBuffer

特点：

1. 封装了char[]数组
2. 是可变的字符序列
3. 提供了一组可以对字符内容修改的方法
4. 常用append()来代替字符串做字符串连接”+”
5. 内部字符数组默认初始容量是16：super(str.length() + 16);
6. 如果大于16会尝试将扩容，新数组大小原来的变成2倍+2，容量如果还不够，直接扩充到需要的容量大小。int newCapacity = value.length * 2 + 2;
7. StringBuffer 线程安全，StringBuilder线程不安全

StringBuilder和StringBuffer的区别

1.在线程安全上 :
–StringBuffer是旧版本就提供的，线程安全的。@since JDK1.0
–StringBuilder是jdk1.5后产生，线程不安全的。@since 1.5
2. 在执行效率上，StringBuilder > StringBuffer > String
3.源码体现：本质上都是在调用父类抽象类AbstractStringBuilder来干活，只不过Buffer把代码加了同步关键字，使得程序可以保证线程安全问题。
abstract class AbstractStringBuilder implements Appendable, CharSequence {

正则表达式Regex

概述：

正确的字符串格式规则。
常用来判断用户输入的内容是否符合格式的要求，注意是严格区分大小写的。

String提供了支持正则表达式的方法

Matches(正则) : 当前字符串能否匹配正则表达式
replaceAll(正则,子串) : 替换子串
split(正则) : 拆分字符串

/**本类用于测试正则表达式
 * 需求:测试输入身份证号,测试用户输入是否正确
 * */
public class Test4_Regex {
    public static void main(String[] args) {
        //1.提示并接收用户输入的身份证号:
        System.out.println("请您输入您的身份证号:");
        String input = new Scanner(System.in).nextLine();
        //2.编辑正则表达式
        //身份证号的规律:一般都是18位,前17位都是数字,最后一位可能是数字,也有可能是xX
        String regex = "[0-9]{17}[0-9xX]";
        //3.判断,是否符合正则表达式的规则(也就是输入的是正确的身份证号吗?)
        if( input.matches(regex) ) {//matches()是String类提供的功能,可以用来判断字符串是否符合正则表达式的要求
            System.out.println("输入正确!");
        }else {
            System.out.println("输入不正确,请重新输入!");
        }
    }
}

BigDecimal/BigInteger

概述:

BigDecimal：常用来解决精确的浮点数运算
BigInteger： 常用来解决超大的整数运算

创建对象:

BigDecimal(double val)
将double转换为BigDecimal,后者是double的二进制浮点值十进制表示形式,有坑!
BigDecimal(String val)
将String类型字符串的形式转换为BigDecimal

常用方法

Add(BigDecimal bd) : 做加法运算
Subtract(BigDecimal bd) : 做减法运算
Multiply(BigDecimal bd) : 做乘法运算
Divide(BigDecimal bd) : 做除法运算,除不尽时会抛异常
Divide(BigDecimal bd,保留位数,舍入方式) : 除不尽时使用
setScale(保留位数,舍入方式) : 同上
pow(int n) : 求数据的几次幂

 public static void main(String[] args) {
      method2();//使用BigDecimal来解决浮点数运算不精确的现象
   }
   public static void method2() {
      //1.提示并接收用户输入的两个小数
      System.out.println("请输入您要计算的两个小数:");
      double a = new Scanner(System.in).nextDouble();
      double b = new Scanner(System.in).nextDouble();
      //2.创建工具类对象,把基本类型的a和b交给工具类对象BigDecimal来保存
      /**1.最好不要使用double作为构造函数的参数,不然还会产生不精确的现象,有坑!!!!*/
      /**2.最好使用重载的,参数类型是String的构造函数,double转String,直接拼个空串就可以*/
      BigDecimal bd1 = new BigDecimal(a+"");
      BigDecimal bd2 = new BigDecimal(b+"");
      //3.通过BigDecimal上的方法,做精确运算
      //3.1定义对象来保存结果
      BigDecimal bd3;
      //3.2 add(BigDecimal bd) : 做加法运算
      bd3 = bd1.add(bd2);
      System.out.println(bd3);
      //3.3 subtract(BigDecimal bd) : 做减法运算
      bd3 = bd1.subtract(bd2);
      System.out.println(bd3);
      //3.4 multiply(BigDecimal bd) : 做乘法运算
      bd3 = bd1.multiply(bd2);
      System.out.println(bd3);
      //3.5 add(BigDecimal bd) : 做除法运算
      /**java.lang.ArithmeticException,除法运算,除不尽时会抛异常*/
      //bd3 = bd1.divide(bd2);--方案一
      /**divide(m,n,o) --m是要除以哪个对象保存的值,n要保留几位,o是摄入方式,最常使用的是四舍五入*/
      bd3 = bd1.divide(bd2, 3, BigDecimal.ROUND_HALF_UP);//方案二:
      System.out.println(bd3);
   }

包装类

把基本类型进行包装，提供更加完善的功能。
基本类型是没有任何功能的,只是一个变量,记录值,而包装类可以有更加丰富的功能

Integer

创建对象

1. new Integer(5);
2. Integer.valueOf(5);
在Integer类中，包含256个Integer缓存对象，范围是 -128到127。
使用valueOf()时，如果指定范围内的值，访问缓存对象，而不新建；如果指定范围外的值，直接新建对象。

public static void main(String[] args) {
        //1.创建int基本类型的包装类Integer的对象方式1
        /**1.Integer包装类的默认值是null*/
        Integer i0;
        Integer i1 = new Integer(5);
        //2.创建int基本类型的包装类Integer的对象方式2
        /**2.Integer有一个高效的效果(-128~127)
         * 因为静态的valueOf(),相同的数据只会存一次,后续再存都会使用已经存过的数据
         * */
        Integer i2 = Integer.valueOf(127);
        Integer i3 = Integer.valueOf(127);
        Integer i4 = Integer.valueOf(300);
        Integer i5 = Integer.valueOf(300);
        System.out.println(i1==i2);//false,==比较的是地址值
        System.out.println(i2==i3);//true,是Integer,并且是在(-128~127)范围内,相同数据只存一次
        System.out.println(i4==i5);//false,是Integer,但是不在(-128~127)范围内,所以存了两次,两个对象
    }

Double

创建对象

1. new Double(3.14)
2. Double.valueOf(3.14)//和 new 没有区别

 //3.创建Double对象
        Double d1 = new Double(3.4);
        Double d2 = Double.valueOf(3.4);
        Double d3 = Double.valueOf(3.4);
        System.out.println(d2==d3);//false,只有Integer包装类有高效的效果
        //4.测试常用方法
        //原因:parseInt()已经把字符串8000转换成了int类型的数字8000,可以参与运算
        System.out.println(i1.parseInt("8000")+10);//8010,执行了加法运算
        System.out.println(d1.parseDouble("2.2")+1);//3.2,执行了加法运算

自动装箱和自动拆箱

概述：

自动装箱：把 基本类型 包装成对应的 包装类型 的过程
Integer a = 5;//a是引用类型，引用了包装对象的地址。
编译器会完成对象的自动装箱：Integer a = Integer.valueOf(5);

自动拆箱：从包装类型的值，自动变成 基本类型的值
int i = a;//a现在是包装类型，没法给变量赋值，需要把5取出来。
编译器会完成自动拆箱：int i = a.intValue();

 public static void main(String[] args) {
        //1.定义包装类型的数据
        //之前的方式:创建包装类型的两种方式:
        Integer i11 = new Integer(127);
        Integer i22 = Integer.valueOf(127);
        //现在的方式:
        /**1.自动装箱:编译器会自动把基本类型int数据5,包装成包装类型Integer,然后交给i1保存
         * 自动装箱底层发生的代码:Integer.valueOf(5);
         * valueOf()的方向:int --> Interger
         * */
        Integer i1 = 5;//不会报错,这个现象就是自动装箱
        /**2.自动拆箱:编译器会自动把包装类型的5,拆掉箱子,变回到基本类型数据5
         * 自动拆箱底层发生的代码:i1.intValue()
         * intValue()的方向:Integer --> int
         * */
        int i2 = i1;//不会报错,这个现象就是自动拆箱
    }

拓展：

==和equals的区别

1.当使用 = = 比较时，如果相比较的两个变量是引用类型，那么比较的是两者的物理地值（内存地址），如果相比较的两个变量都是数值类型，那么比较的是具体数值是否相等。
2.当使用equals()方法进行比较时，比较的结果实际上取决于equals()方法的具体实现
众所周知，任何类都继承自Object类，因此所有的类均具有Object类的特性，比如String、integer等，他们在自己的类中重写了equals()方法，此时他们进行的是数值的比较，而在Object类的默认实现中，equals()方法的底层是通过 = =来实现的。
System.out.println(p1.name = = p2.name);//true,name是String类型,保存在常量池中,值是同一个

/**本类用于测试==与equlas的区别*/
public class Test7 {
    public static void main(String[] args) {
        Person p1 = new Person("凹凸曼",16);
        Person p2 = new Person("凹凸曼",16);
        System.out.println(p1 == p2);//false,new了两个对象,p1和p2保存的地址值不同

        System.out.println(p1.name == p2.name);//true,name是String类型,保存在常量池中,值是同一个

        System.out.println(p1.age == p2.age);//true,age是int基本类型,保存的值都是18
        //第一次测试:结果false,使用的是Object默认的逻辑,也是用==来比较的
        //第二次测试:结果true,重写equals()后,就会使用子类重写后的功能,也就是说此时比较的不再是地址,而是类型&属性值
        System.out.println(p1.equals(p2));
    }
}
//1.创建Person类
class Person {
    String name;
    int age;
    public Person() {
        System.out.println("我是手动添加的无参构造");
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    //需求:比较两个对象的属性值,如果属性值都一样,就是"同一个对象",要求equals返回true
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
}

第七章：IO

继承结构

In/out 相对于程序而言的输入(读取)/输出(写出)的过程.
在java中,根据处理的数据单位不同,分为字节流和字符流
字节流 : 针对二进制文件
字符流 : 针对文本文件,读写容易出现乱码的现象,在读写时,最好指定编码集为UTF-8

  Java.io包下:
   File
字节流:针对二进制文件
   InputStream
      --FileInputStream
      --BufferedInputStream
      --ObjectInputStream
   OutputStream
      --FileOutputStream
      --BufferedOutputStream
      --ObjectOutputStream
字符流:针对文本文件
Reader
   --FileReader
   --BufferedReader
   --InputStreamReader
Writer
   --FileWriter
   --BufferedWriter
   --OutputStreamWriter
   --PrintWriter一行行写出

Stream流的概念

数据的读写可以抽象成数据在管道中流动

• 流只能单方向流动
• 输入流用来读取à in
• 输出流用来写出 àout
• 数据只能从头到尾顺序的读写一次

File文件流

概述:

封装一个磁盘路径字符串,对这个路径可以执行一次操作
可以封装文件路径、文件夹路径、不存在的路径

创建对象:

 File(String pathname)通过将给定路径名字符串转换为抽象路径名来创建一个新的File实例
new File(“d:/abc/a.txt”); 
new File(“d:/abc”,”a.txt”);

常用方法:

 //1.创建File对象
      //参数是具体的路径,可以是文件的路径,也可以是文件夹的路径
      //注意:需要手动在windows中创建D:\ready\1.txt并添加内容
      /**1.\在代码中具有特殊的意义,转义的作用,
       * 所以表示这个是一个真正的斜杠,需要转义一下*/
      File file = new File("D:\\ready\\1.txt");//创建的是java对象
      //2.测试常用方法
      //2.1文件与文件夹属性
      System.out.println(file.length());//15,获取指定文件的字节量
      System.out.println(file.exists());//true,判断指定文件是否存在
      System.out.println(file.isFile());//true,判断指定内容是否是文件
      System.out.println(file.isDirectory());//false,判断指定内容是否是文件夹
      System.out.println(file.getName());//1.txt,获取文件名
      System.out.println(file.getParent());//D:\ready,获取父级目录
      System.out.println(file.getAbsolutePath());//D:\ready\1.txt,获取绝对路径

 //2.2创建与删除
      file = new File("D:\\\\ready\\\\2.txt");
      /**如果指定创建文件的文件夹不存在
       * 会抛出异常:java.io.IOException:系统找不到指定的路径
       * 所以需要处理,目前的方式是抛出异常*/
      System.out.println(file.createNewFile());//在win中创建不存在的文件2.txt
      file = new File("D:\\ready\\m");
      System.out.println(file.mkdir());//在win中创建不存在的单级目录
      file = new File("D:\\ready\\a\\b\\c");
      System.out.println(file.mkdirs());//在win中创建不存在的多级目录
      System.out.println(file.delete());//删除文件或者空文件夹,c文件夹被删除
      file = new File("D:\\ready\\a");
      System.out.println(file.delete());//由于a目录里还有b目录,所以删除不了

 //2.3文件列表
      file = new File("D:\\ready");
      //查看文件夹下所有文件的名称,返回值类型是String[]
      String[] list = file.list();
      System.out.println(Arrays.toString(list));
      /**列出文件夹中所有的文件夹和文件对象,返回值是File[]
       * 数组的每个元素都是File对象,可进一步操作
       * */
      File[] listFiles = file.listFiles();
      System.out.println(Arrays.toString(listFiles));
      System.out.println(listFiles[0].length());

递归求目录总大小

需求:递归求目录的总大小 D:\\ready,步骤分析如下:
1.列出文件夹中的所有资源--listFiles()-->File[]
2.判断,当前资源是文件还是文件夹--文件夹大小为0,文件大小需要累加
      --是文件,求文件的字节量大小length(),累加就行
      --是文件夹,继续列出文件夹下的所有资源--listFiles()-->File[]
           --判断,是文件,求文件的字节量大小length(),累加就行
           --判断,是文件夹,再一次列出文件夹下的所有资源
                 --......重复操作
也就是说,规律就是:只要是文件夹,就需要重复步骤1 2

 private static long size(File file) {
        //1.列出文件夹中的所有资源--listFiles()-->File[]
        File[] fs = file.listFiles();
        //2.遍历数组,获取每file对象
        //2.1定义变量,记录总和
        long sum = 0;
        for(int i = 0;i < fs.length ; i++) {
            //2.2通过下标操作当前遍历到的资源
            File f = fs[i];
            //2.3判断,当前资源是文件还是文件夹--文件夹大小为0,文件大小需要累加
            if(f.isFile()) {
                //--是文件,求文件的字节量大小length(),累加就行
                sum += f.length();//相当于:sum = sum + f.length();
            }else if(f.isDirectory()) {
                //--是文件夹,继续列出文件夹下的所有资源,1 2步骤--listFiles()-->File[]
                /**方法的递归,递归现象,就是在方法的内部调用方法自身*/
                sum += size(f);
            }
        }
        return sum;//把sum记录的值返回调用位置
    }

字节流读取

字节流是由字节组成的,字符流是由字符组成的.
Java里字符由两个字节组成.字节流是基本，主要用在处理二进制数据。
流式传输主要指将整个音频和视频及三维媒体等多媒体文件经过特定的压缩方式解析成一个个压缩包，由视频服务器向用户计算机顺序或实时传送。在采用流式传输方式的系统中，用户不必像采用下载方式那样等到整个文件全部下载完毕，而是只需经过几秒或几十秒的启动延时即可在用户的计算机上利用解压设备对压缩的A/V、3D等多媒体文件解压后进行播放和观看。此时多媒体文件的剩余部分将在后台的服务器内继续下载。

InputStream抽象类

此抽象类是表示字节输入流的所有类的超类/抽象类,不可创建对象
常用方法：

abstract  int read() 从输入流中读取数据的下一个字节
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
int read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组,off表示存时的偏移量
void close() 关闭此输入流并释放与该流关联的所有系统资源

FileInputStream子类

直接插在文件上，直接读取文件数据
创建对象
FileInputStream(File file)—直接传文件对象
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定FileInputStream(String pathname)—传路径
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定

BufferedInputStream子类

BufferedInputStream 为另一个输入流添加一些功能，即缓冲输入以及支持 mark 和 reset 方法的能力。在创建 BufferedInputStream 时，会创建一个内部缓冲区数组(默认8k大小)。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。
创建对象
BufferedInputStream(InputStream in)
创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

 public static void main(String[] args) {
      method();//字节流的读取
      method2();//高效字节流的读取
   }

public static void method() {
      InputStream in = null;
      try {
         //1.创建字节流读取对象
         //new InputStream();//报错:抽象父类不可以创建对象
         //FIS传入的参数是一个File对象
         //InputStream in2 = new FileInputStream(new File("D:\\ready\\4.txt"));
         //FIS传入的参数是一个路径,保证此路径下的文件是存在且有内容的
         in = new FileInputStream("D:\\ready\\4.txt");
         //2.开始读取,read()每次读取1个字节，如果读到了数据的末尾，返回-1
         //          System.out.println(in.read());//97
         //          System.out.println(in.read());//98
         //          System.out.println(in.read());//99
         //          System.out.println(in.read());//-1
         //3.1定义变量，记录读到的数据
         int b;
         while((b = in.read()) != -1) {//3.2返回值为-1的时候表示没有数据了,循环结束
            //3.3打印每次读取到的内容
            System.out.println(b);
         }
      } catch (IOException e) {
         e.printStackTrace();//打印错误信息到控制台
      } finally {//try-catch-finally,finally中的代码一定会被执行,常用于关流
         try {
            //4.释放资源
            in.close();
         } catch (IOException e) {
            e.printStackTrace();
         }
      }
   }

public static void method2() {
      BufferedInputStream in = null;
      try {
         //1.创建高效字节流读取对象
         //new InputStream();//报错:抽象父类不可以创建对象
         //BIS是高效的读取流
//       in2 = new BufferedInputStream(
//             new FileInputStream(new File("D:\\ready\\4.txt")));
         in = new BufferedInputStream(
                new FileInputStream("D:\\ready\\4.txt"));
         //2.开始读取,read()每次读取1个字节，如果读到了数据的末尾，返回-1
         //          System.out.println(in.read());//97
         //          System.out.println(in.read());//98
         //          System.out.println(in.read());//99
         //          System.out.println(in.read());//-1
         //3.1定义变量，记录读到的数据
         int b;
         while((b = in.read()) != -1) {//3.2返回值为-1的时候表示没有数据了,循环结束
            //3.3打印每次读取到的内容
            System.out.println(b);
         }
      } catch (IOException e) {
         e.printStackTrace();//打印错误信息到控制台
      } finally {//try-catch-finally,finally中的代码一定会被执行,常用于关流
         try {
            //4.释放资源
            in.close();
         } catch (IOException e) {
            e.printStackTrace();
         }
      }
   }

字符流读取

常用于处理纯文本数据

Reader抽象类

用于读取字符流的抽象类。
常用方法：

int read() 读取单个字符
int read(char[] cbuf) 将字符读入数组
abstract  int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分
int read(CharBuffer target) 试图将字符读入指定的字符缓冲区
abstract  void close() 关闭该流并释放与之关联的所有资源

FileReader子类

用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。

创建对象
FileReader(String fileName) 在给定从中读取数据的文件名的情况下创建一个新 FileReader
FileReader(File file) 在给定从中读取数据的 File 的情况下创建一个新 FileReader

BufferedReader子类

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

创建对象
BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流

 public static void main(String[] args) {
        //method();//普通字符流读取
        method2();//高效字符流读取
    }

 public static void method() {
        try {
            //1.创建字符流的读取对象
            //Reader in = new Reader();//Reader是字符流读取的父类,而且是一个抽象类,不能new
            //Reader in = new FileReader(new File("D:\\ready\\1.txt"));//传入的是file对象
            Reader in = new FileReader("D:\\ready\\1.txt");//传入的是路径
            //2.开始读取,read()每次读取一个字符,如果读取到了数据的末尾,返回-1
//          System.out.println(in.read());//97
//          System.out.println(in.read());//98
//          System.out.println(in.read());//99
//          System.out.println(in.read());//100
//          System.out.println(in.read());//-1
            //3.需求:重复的读取文件中的所有内容
            //3.1定义变量,记录读取到的数据
            int b;
            //3.2循环读取文件中所有内容,只要不是-1,就表示还有数据,继续循环
            while( (b = in.read()) != -1) {
                System.out.println(b);
            }
            //4.释放资源
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 public static void method2() {
        try {
            //1.创建高效的字符流的读取对象
            //Reader in = new Reader();//Reader是字符流读取的父类,而且是一个抽象类,不能new
            //BufferedReader是高效的字符读取流,原因是底层维护了一个char[],默认的容量也是8*1024字节8k
            Reader in = new BufferedReader(new FileReader("D:\\ready\\1.txt"));//传入的是路径
            //2.开始读取,read()每次读取一个字符,如果读取到了数据的末尾,返回-1
//          System.out.println(in.read());//97
//          System.out.println(in.read());//98
//          System.out.println(in.read());//99
//          System.out.println(in.read());//100
//          System.out.println(in.read());//-1
            //3.需求:重复的读取文件中的所有内容
            //3.1定义变量,记录读取到的数据
            int b;
            //3.2循环读取文件中所有内容,只要不是-1,就表示还有数据,继续循环
            while( (b = in.read()) != -1) {
                System.out.println(b);
            }
            //4.释放资源
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

字节流写出

OutputStream抽象类

此抽象类是表示输出字节流的所有类的超类.输出流接受输出字节并将这些字节发送到某个接收器.

常用方法:
Void close() 关闭此输出流并释放与此流相关的所有系统资源
Void flush() 刷新此输出流并强制写出所有缓冲的输出字节
Void write(byte[ ] b) 将b.length个字节从指定的byte数组写入此输出流
Void write(byte[ ] b,int off ,int len) 将指定byte数组中从偏移量off开始的len个字节写入输出流
Abstract void write(int b) 将指定的字节写入此输出流

FileOutputStream 子类

直接插在文件上,直接写出文件数据
构造方法(创建对象):
FileOutputStream(String name)
创建一个向具有指定名称的文件中写入数据的文件输出流
FileOutStream(File file)
创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutStream(File file,boolean append)—如果第二个参数为true,表示追加,不覆盖
创建一个向指定File对象表示的文件中写入数据的文件输出流,后面的参数是指是否覆盖原文件内容

BufferedOutputstream 子类

该类实现缓冲的输出流,通过设置这种输出流,应用程序就可以将各个字节写入底层输出流中,而不必每次针对字节写出调用底层系统
构造方法(创建对象):
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流,用以将数据写入指定的底层输出流

 public static void main(String[] args) {
        //method();//1.创建使用普通字节输出流对象输出数据
        method2();//2.创建使用高效字节输出流对象输出数据
    }

 public static void method2() {
        //5.声明在此方法内部都生效的局部变量,并且局部变量需要初始化,对象的默认值是null
        OutputStream out = null;
        try {
            //0.用来测试的路径必须是文件路径,不是文件夹路径,而且文件得存在
            //1.创建高效字节输出流对象
            //OutputStream out =new BufferedOutputStream(new FileOutputStream(new File("D:\\ready\\out.txt")));
            out =new BufferedOutputStream(new FileOutputStream("D:\\ready\\out.txt"));
            //2.开始写出数据
            out.write(100);//ascii码表存在对应关系:100-d
            out.write(100);//ascii码表存在对应关系:100-d
            out.write(100);//ascii码表存在对应关系:100-d
            out.write(100);//ascii码表存在对应关系:100-d
        } catch (IOException e) {
            e.printStackTrace();
        } finally {/**3.要保证代码一定会被执行,就通通放在finally代码块中*/
            //4.释放资源
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

  public static void method() {
        //4.声明在此方法内部都生效的局部变量,并且局部变量必须初始化,对象的默认值是null
        OutputStream out=null;
        try {
            //0.需要在windows环境下创建一个文件,路径:D:\ready\out.txt用来查看输出的数据
            /**注意:指定的路径是文件路径,不是文件夹路径,而且文件得存在*/
            //1.创建字节输出流对象
            //new OutputStream();//报错:原因:OutputStream是字节输出流的抽象父类,不能实例化
            //OutputStream out = new FileOutputStream(new File("D:\\ready\\out.txt"));
            out = new FileOutputStream("D:\\ready\\out.txt");
            //2.开始写出数据
            out.write(97);//ascii码表对应的关系:97--a
            out.write(98);//ascii码表对应的关系:98--b
            out.write(99);//ascii码表对应的关系:99--c
        } catch (IOException e) {
            e.printStackTrace();
        } finally {/**如果要保证代码一定会执行,就通通放在finally代码块中*/
            //3.释放资源
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

字符流写出

Writer 抽象类

写入字符流的抽象类
常用方法:

Abstract void close() 关闭此流,但要先刷新它
Void write(char[ ] cbuf) 写入字符数组
Void write(int c) 写入单个字符
Void write(String str) 写入字符串
Void write(String str,int off,int len) 写入字符串的某一部分
Abstract void write(char[] cbuf,int off,int len)写入字符数组的某一部分

FileWriter 子类

用来写入字符文件的便捷类,此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的.如果需要自己自定义这些值,可以先在FileOutputStream上构造一个OutputStreamWriter.

构造方法(创建对象):
FileWriter(String filename)
根据给定的文件名构造一个FileWriter对象
FileWriter(String filename,boolean append)
根据给定的文件名以及指示是否附加写入数据的boolean值来构造FileWriter

BufferedWriter子类

将文本写入字符输出流,缓冲各个字符,从而提供单个字符,数组和字符串的高效写入.可以指定缓冲区的大小,或者接受默认的大小,在大多数情况下,默认值就足够大了

构造方法(创建对象):
BufferedWriter(Writer out)
创建一个使用默认大小输出缓冲区的缓冲字符输出流

public static void main(String[] args) {
      method1();//普通字符输出流
      method2();//高效字符输出流
   }

/**高效字符输出流*/
   public static void method2() {
      Writer out = null;
      try {
         //1.创建高效字符输出流对象,并且数据输出的方式是追加
         //默认状态是不追加,也就是覆盖原有数据
         //out2 = new BufferedWriter(new FileWriter(new File("D:\\ready\\out.txt")));
   out = new BufferedWriter(new FileWriter("D:\\ready\\out.txt",true));
         //2.输出数据
         out.write(97);
         out.write("hello");
         out.write("io");
      } catch (IOException e) {
         e.printStackTrace();
      }finally {
         //3.释放资源
         try {
            out.close();
         } catch (IOException e) {
            e.printStackTrace();
         }
      }
   }

 /**普通字符输出流*/
   public static void method1() {
      Writer out = null;
      try {
         //0.在路径D:\\ready\\out.txt下创建对应的文件.查看输出的数据
         //1.创建流对象
         //new Writer();//报错:Writer是抽象父类,不可以创建对象
         //Writer out2 = new FileWriter(new File("D:\\ready\\out.txt"));
         //out = new FileWriter("D:\\ready\\out.txt");//默认覆盖
         /**需求:保持原有的数据
          * 在不改变原数据的基础上,在它的末尾添加新数据*/
         /**
          * 此构造函数的第二个参数表示,是否覆盖写出文件中的原有数据
          * 默认覆盖,如果不想覆盖,就把这个参数的值设置为true
          * */
         out = new FileWriter("D:\\ready\\out.txt",true);
         //2.输出数据
         out.write(97);
         out.write(98);
         out.write(99);
         out.write(100);
      } catch (IOException e) {
         e.printStackTrace();
      }finally {
         //3.释放资源
         try {
            out.close();
         } catch (IOException e) {
            e.printStackTrace();
         }
      }
   }

文件复制测试

 public static void main(String[] args) {
      //1.提示并接收用户输入要复制的原文件的路径--复制啥
      System.out.println("请输入原文件路径:");
      String f = new Scanner(System.in).nextLine();
      //2.提示并接收用户输入的目标文件所在的路径--复制到哪
      System.out.println("请输入目标文件路径:");
      String t = new Scanner(System.in).nextLine();
      //3.根据原文件路径封装File对象from
      File from = new File(f);
      //4.根据目标文件路径封装File对象to
      File to = new File(t);
      //5.根据用户提供的路径完成文件的复制操作
      //5.1自定义字符流文件复制方法
      //ZFCopy(from,to);//字符流--只能操作字符相关文件
      ZJCopy(from,to);//字节流--什么文件都能操作
   }

/**自定义字节复制文件的方法*/
   public static void ZJCopy(File from, File to) {
      //1.定义整个方法都生效的局部变量,需要手动初始化,默认值null
      InputStream in = null;//字节输入流--抽象父类
      OutputStream out = null;//字节输出流--抽象父类
      try {
         //2.1创建字节输入流对象
         in = new BufferedInputStream(new FileInputStream(from));
         //2.2创建字节输出流对象
         out = new BufferedOutputStream(new FileOutputStream(to));
         //3.完成复制操作--边读边写
         int b ;
         while((b=in.read()) != -1) {
            out.write(b);
         }
         System.out.println("恭喜您!复制成功!");
      } catch (IOException e) {
         System.out.println("很抱歉!复制失败!");
         e.printStackTrace();
      }finally {
         //4.释放资源
         /**1.流资源必须释放,释放的是之前使用过程中的所有流对象
          * 2.关流是有顺序的,注意,后面出现的流先释放,为了不影响代码* */
         try {
            out.close();//用来关闭字符输出流
         } catch (IOException e) {
            e.printStackTrace();
         }
         try {
            in.close();//用来关闭字符输入流
         } catch (IOException e) {
            e.printStackTrace();
         } 
      }
   }