Java笔记

变量的作用域：

  全局变量：

定义方法（函数）和代码块之外的变量

局部变量：

定义在方法或者代码之间的变量

静变量

数据类型：

整型、长整形、短整型 、单精度浮点型、 双、布尔、 字节、 字符型、

数据类型转换

     Boolean类型不参与转换

char和short可以相互转换（互相强转）

小类型转换成大类型（自动转换）

强制类型转换：

当大类型数据转换成小类型需要强制转换（类型强转）

 语法：小类型 变量名 =(需要转换的类型)大类型

引用 数据类型不能与基本数据类型相互转换；两种数据类型要彼此兼容，否则不能互相转换。

引用数据类型转换需是继承关系，

任何数据类型与字符串做+运算都会变成字符串。

Java算术运算符

        1、一元运算：

                  -、++、--、（++在前，先自增再赋值）

        2、二元运算符：

                  加、减、乘、除、取余、

        3、逻辑或不论后面是真是假都会往后走。

  Java关系运算符

           1、基本类型的变量、值不能与引用类型的变量、值使用==进行作比较；

            2、

           3、

栈 通常用来存放方法

equals(obj)方法和==的区别：

          equals方法比较的是两个对象的内容是否相等

         ==比较的是两个 对象在内存中存放的地址是否为同一个；

  位移运算符

只有<<(向左位移)          >>(向右位移)   。无<<<或者>>>等符号

next()与nextLine（）方法的区别；

1.当遇到空格或者回车的时候，next（）停止读取

2.当遇到回车的时候nextLine（）方法停止读取，读取整行数据

一、int类型的直接量

在程序中直接给出的整型数值，可分为二进制、十进制、八进制和十六进制4种，其中二进制需要以0B或Ob开头，八进制需要以

0开头，十六进制需要以0x或OX开头。例如123、012(对应十进制的10)、0x12(对应十进制的18）等。

二、long 类型的直接量

在整型数值后添加 | 或 L后就变成了long 类型的直接量。例如3L、0x12L（对应十进制的18L）,

三、float 类型的直接量

在一个浮点数后添加f 或 F 就变成了 float 类型的直接量，这个浮点数可以是标准小数形式，也可以是科学计数法形式。例如

5.34F、3.14E5f。

四、double 类型的直接量

直接给出一个标准小数形式或者科学计数法形式的浮点数就是 double 类型的直接量。例如5.34、3.14E5。

五、boolean 类型的直接量

这个类型的直接量只有true 和 false。

char类型的直接量

char 类型的直接量有三种形式，分别是用单引号括起来的字符、转义字符和 Unicode 值表示的字符。例如'a'，\n'和\u0061'。

                                     Java课堂笔记

Java常量

常量是指在程序的整个运行过程中值保持不变的量。

常量值

常量值又称为字面常量，它是通过数据直接表示的，因此有很多种数据类型，像整型和字符串型等。

整型常量值

整型常量值主要有如下3种形式。

十进制数形式:如54、-67、 0。

八进制数形式: Java 中的八进制常数的表示以0开头,如0125表示十进制数85, -013 表示十进制数-11。

十六进制数形式: Java中的十六进制常数的表示以0x或0X开头，如0x100表示十进制数256, -0x16 表示十进制数-22。

整型(int) 常量默认在内存中占32位。

实型常量值

Java的实型常量值主要有如下两种形式。

十进制数形式:由数字和小数点组成，且必须有小数点，如12.34、-98.0。

科学记数法形式:如1.75e5或32&E3,中e或E之前必须有数字，且e或E之后的数字必须为整数。

Java实型常量默认在内存中占64位，是具有双精度型(double) 的值。

单精度型数值一般要在该常数后面加 F或f,如69.7f, 表示-个float型实数，它在内存中占32位。

布尔型常量值

Java的布尔型常量只有两个值，即false (假)和true (真)。

Java变量的作用域

变量的作用域规定了变量所能使用的范围，只有在作用域范围内才能被使用。根据变量的声明地点不同，变量的作用域也不同

变量又分为成员变量与局部变量

成员变量分为

1. 全局变量：无static修饰访问对象名变量名
2. 静态变量：用static修饰，访问类名变量名

局部变量分为

1. 方法参数变量：在整个方法内有下效
2. 方法局部变量：从定义这个变量开始到方法结束这一段时间内有效
3. 代码块局部变量：从定义这个变量开始到代码结束这一段时间内有效

局部变量在使用前必须被程序员主动初始化值

声明变量

首字符必须是字母、下划线、美元符号、人民币符号

标识符由数字大写字母小写字母下划线美元符号人民币符号以及所有在十六进制Oxco前的ASCLL码组成，不能吧关键字保留字作为标识符

定义常量

常量不同于常量值，它可以在程序中用符号来代替常量值使用，因此在使用前必须先定义。常量与变量类似也需要初始化，即在声明 常量的同时要赋予一个初始值。常量一旦初始化就不可以被修改。

final dataType variab1eName = value

其中，final 是定义常量的关键字，dataType 指明常量的数据类型，variableName 是变量的名称, value 是初始值。final关键字表示最终的，它可以修改很多元素，修饰变量就变成了常量。例如，以下语句使用final关键字声明常量。

Java中的数据类型：

 1、基本数据类型（八种）

byte（字节型）、short（短整型）、int（整形）、long（长整型）、float（单精度浮点型）、double（双精度浮点型）char（字符型）、boolean（布尔型）

字节型：byte by = 127;

 // System.out.println((byte) (by + 1));

 短整型：short sh = 56;

 整形： int num = 78946;

 长整型，注意: 需要早长整型末尾添加L或者l：long number = 56L;

 单精度浮点型, 注意: 需要早长整型末尾添加F或者f;float fl = 3.14F

 System.out.println(fl1);

 双精度浮点型,java中小数默认是double类型;double db = 3.14159;

 字符型, 字符型的值使用单引号引起来，当值为整形时不需要单引号

        char ch1 = 3;

        char ch2 = 'a';

        char ch3 = 97;

        System.out.println(ch1);

        System.out.println(ch3);

 布尔值类型，注意：Java中布尔值类型只有true和false两个值

        boolean bool1 = true;

        boolean bool2 = false;

2、引用数据类型

除了基本数据类型，其他全部是引用数类型，如：String、数组等

Java逻辑运算符

1. &&   短路与：a && b  (a和b同时为真时为真)

1. ||     短路或：a && b （a和b有一个为真时为真）

1. &    逻辑与：同&&
2. |     逻辑或：同||
3. ！    逻辑非：!a      (a为真时，值为假；a为假时，值为真)

短路与、短路或和逻辑与、逻辑或的区别：

1. a && b ：如果 a 为 fase，则不计算 b（因为不论 b 为何值，结果都为 fase）

1. a || b ：如果 a 为 true，则不计算 b（因为不论 b 为何值，结果都为 true）

1. a & b ：  a无论是true或fase，b都会进行计算

1. a | b ：  a无论是true或fase，b都会进行计算

创建扫描器对象

Scanner scan = new Scanner(System.in);

System.out.println("请输入您的名字：");

name = scan.next();

next()与nextLine()方法的区别：

    1、当遇到空格或者回车的时候 next()方法停止读取

2、当遇到回车的时候 nextLine()方法停止读取，读取整行数据

1.二位数组用数据类型 [][] = new 数据类型[][];

例如： int[][] arr = new int[2][3];

2.遍历二位数组；

可以用两个for-each，例如for（int i：arr[]）for(int j:arr);遍历二维数组；

3.访问二维数组的语法：arr[x][y] = 1;就是给第x + 1行第y + 1列的值赋成1；

4.二维数组的存储，大概是arr[x][y]中，x存的是二维数组的索引，也就是数组的地址，x存在栈，y存在堆区；static修饰的存在方法区；在类中，static修饰可以直接用类名访问，用对象访问会报警告；      

5.System.arraycopy,src:原数组;srcPos： 原数组起始位置（从这个位置开始复制);dest:目标数组;destPos：目标数组粘贴的起始位置;length： 复制的个数

6.方法的重载是方法名相同，参数列表不同，返回值不做要求；

7.Arrays.copyOf（arr[]，7）;即arr【】为目标数组，7为新复制的数组长度；

8.数组的扩容与缩容量，使用int aee1[] = Arrays.copyOf(arr,5);

其中arr为原来的数组，5位新数组的大小；增容的操作也类同；这里并没有销毁原来的数组，准确的应该算复制；

9.Arrays.sort能对数组进行排序，返回值为int，返回数据为目标值的下标，二分查找的使用的前提是数组必须排好序；

10,使用equals能比较两个数组是否相等；两个参数分别是一个数组和另一个数组，如果相同返回true，如果不同返回false；

if语句

if双分枝结构：为条件表达语句，当语句为ture时执行语句，当语句为false，执行else语句。

嵌套switch语句

if语句与switch语句都表示条件语句，可以使用效率与实用性两方面加以区分。

从效率上看

对同一个变量的不同值作为条件判断时，当判断条件较多时可以使用switch语句

从实用性上看

当判断条件不多时使用if语句更加方便

while循环与do...while循环的区别：

 1、while是先判断后执行，do...while循环是先执行然后再判断

  2、do...while循环至少执行一次

  while循环与do...while的特点：都是循环执行某一语句，循环次数素不固定

   while循环：

   语法：

  while (循环条件) {

   循环体}

   案例：计算1+到100的和

  1+2+3+4+5+6+7+....+100

        int num = 1;

        int sum = 0;

        while (num <= 100) {

            sum += num;

            num ++;

        }

        System.out.println(sum);

 do.while循环

      语法：

     do{

           循环体

        } while (循环条件);

    案例：计算1+到100的和

       1+2+3+4+5+6+7+....+100

        int num2 = 1;

        int sum2 = 0;

        do {

            sum2 += num2;

            num2 ++;

        } while (num2 <= 100);

        System.out.println(sum2);

  for循环嵌套

如果循环嵌套层数超过了三层，那么一定是逻辑出了问题

 数组定义：

    用来存放相同类型的一组数据

     数组下标从0开始，对数组元素进行操作是通过数组的下标（索引）

     数组一旦被创建，则数组的长度不可被修改

       语法：

          静态创建数组

           数据类型[] 数组名 = {值1，值2....}

            数据类型 数组名[] = {值1，值2....}

 数组元素必须是相同类型的，不允许出现混合类型。

数组的默认初始化、

int a2[] = new int[2];//默认值0，0

boolean[] b = new boolean[2];//默认值 false，false

String[] s = new String[2];//默认值null

随机数：

     1、Random random = new Random();

           生成指定范围内的随机数 random.nextInt(10)

     2、double random = Math.random();

             生成随机数的范围 0.0-1.0，但是永远到不了 

       动态创建数组

    数据类型[] 数组名 = new 数据类型[数组长度]

        数据类型 数组名[] = new 数据类型[数组长度]

     

    // 静态创建数组，特点：创建数组的同时给数组元素赋值

      int arr[] = {1, 2, 4, 8, 9};

   // 动态创建数组，特点创建数组时指定数组的长度

    long[] arr1 = new long[5];

 // 数组元素必须是相同类型的，不允许出现混合类型。

    // dArr[2] = "hello array"; 数组元素类型与数组类型不匹配，语法报错

     二维数组的动态初始化: .

数据类型数组名00 = new数据类型[m][n]数据类型00数组名= new数据类型[m][n]

数据类型0数据名0 = new数据类型[m]In]数组的复制:浅拷贝

System.arrarcoplarr,start,dist,index.length)

Arrays,copofrr,length)

4、Arrays类 具有以下常用的功能

1、给数组赋值:通过调用fill方法

2、对数组排序:通过sort方法

3、比较数组:通过equals方法比较数组中元素的值是否相等

5、数组的扩容于缩容

实质:就是创建一个新的数组，新数组避原来的数组(大，为扩容，小，为缩容)打印数组Arrays. toStingarr)方法的作用是将数组- -字符串的形式输出

给数组赋值:

通常用il方法

Arrays binarySercharr9);该方法的返回值为查找到的元素下标的值

Java面向对象- 0OP

一、什么是面向对象

面向过程与面向对象:

面向对象过程思想:

1、步骤清晰简单

2、面向过程合适处理一些较为简单的问题

面向对象思想的本质就是:以类的方式组织代码，以对象的组织(封装) 数据类是对象的抽象,对象是类的实例。

什么是类:类型/类别，代表-类个体

对象:真实存在的单个个体;

类中包含: 1、所有对象所共有的属性/特征-- -成员变量

2、所有对象所共有的行- -方法

一个类可以创建多个对象

同一类型所创建的对象，结构相同，数据类型不同。

类是对象的模板，对象是类的具体实例

面向对象的三大特征:

封装，继承，多态类的定义:，

修饰符class 类名{成员变量类型变量名 ;

访问对象成员变量和方法，语法:

对象名.成员变量名字/方法名字，能点出什么东西全看类有扫描东西

00A :面向对象分析法

面向对象设计

一个Java文件中只能有一个public修饰的Java类，并且这个被public修饰的Java类名必须与Java文件名字-致。

创建对象的语法:

数据类型

引用类型变量

指向

new关键字对象

Student

new

造成空指针异常的原因:是因为对象为null定义类中的方法:

class类名{

修饰符返回值类型 方法名(参数列表) {

创建并且使用对象:

使用new关键字创建对象:new的运算语法为:

new类名()

# Java面向对象——OOP

# 补充：

包机制的作用：

​为了更好的组织类，Java提供了包机制，用于区分类的命名空间，包语句的语法格式为：

```java

package  包名1.包名2.……

```

一般利用公司的域名倒置作为包名。

```java

import  完整的包名.类名；

```

**注：**

​package语句必须位于Java源文件中的第一行，否则编译不通过。

# 一、什么是面向对象

**面向过程与面向对象：**

​**面向过程思想：**

​        1、 步骤清晰简单，第一步要做什么，第二步要做什么……

​        2、 面向过程适合处理一些较为简单的问题

​        **面向对象思想：**

​        1、 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后，才对某个分类下的细节进行面向过程的思索。

​        2、 面向对象适合处理复杂的问题，适合处理需要多人协作的问题

**面向过程的结构化程序设计：**

​        结构化程序设计的弊端：

​       1、缺乏对数据的封装

​        2、数据与方法(操作数据)的分离

**什么是面向对象：**

​        面向对象的本质就是：以类的方式组织代码，以对象的组织（封装）数据。

**什么是抽象的数据类型：**

​        所谓抽象数据类型可以理解为：将不同类型的数据的集合组成一个整体，用来描述一种新的事务。如：对象类型数据

**什么是类？什么是对象？**

​        1、现实世界是由很多很多对象组成的

               基于对象抽出了类

​        2、对象:真实存在的单个的个体

​                 类:类型/类别，代表一类个体

​        3、类中可以包含:

                3.1、所有对象所共有的属性/特征------------成员变量

               3.2、所有对象所共有的行为-----------------方法

​        4、一个类可以创建多个对象

​               同一类型所创建的对象，结构相同，数据不同

​        5、类是对象的模板，对象是类的具体的实例

**面向对象的三大特征：**

​        封装、继承、多态

<b style='color: red'>补充：</b>

​        **OOA**

​        **Object-Oriented Analysis:面向对象分析法**

        指的是在一个系统的开发过程中进行了系统业务调查以后，按照面向对象的思想来分析问题。OOA与结构化分析有较大的区别。OOA所强调的是在系统调查资料的基础上，针对OO方法所需要的素材进行的归类花分析和整理，而不是对管理业务现状和方法的分析。

OOA（面向对象的分析）模型由5个层次（主题层、对象类层、结构层、属性层和服务层）和5个活动（标识对象类、标识结构、定义主题、定义属性和定义服务）组成。在这种方法中定义了两种对象类之间的结构，一种称为分类结构，一种称为组装结构。分类结构就是所谓的一般与特殊的关系。组装结构则反映了对象之间的整体与部分的关系。

​        OOA在定义属性的同时，要识别实例连接。实例连接是一个示例与另一个实例的映射关系。

​        OOA在定义服务的同时要识别消息连接。当一个对象需要向另一个对象发送消息时，它们之间就存在消息连接。

​        OOA中的5个层次和5个活动继续贯穿在OOD（面向对象设计）过程中。OOD模型由4各部分组成。它们分别是设计问题域部分、设计人机交互部分、设计任务管理部分、和设计数据管理部分。

**一、OOA的主要原则。**

​        1）**抽象：**从许多食物中舍弃个别的、非本质的特征，抽取共同的、本质性的特征，就叫做抽象。愁乡石形成概念的必须手段。

​               抽象原则有两个方面的意义：第一，尽管问题域中的事物是很复杂的，但是分析员并不需要了解和描述它们的一切，只需要分析      其中与系统目标有关的事物及其本质性特征。第二，通过舍弃个体事物在细节上的差异，抽取其共同特性而得到一批事物的抽象概      念。

​               抽象是面向对象方法中使用最为广泛的原则。抽象原则包括过程抽象和数据抽象两个方面。

​               **过程抽象**是指，任何一个完成确定功能的操作序列，其使用者都可以把它看做一个单一的实体，尽管实际上它可能是由一系列更      低级的操作完成的。

​               **数据抽象**是根据施加于数据之上的操作来定义数据类型，并限定数据的值只能由这些操作来修改和观察。数据抽象是OOA的核      心原则。它强调把数据（属性）和操作（服务）结合为一个不可分的系统单位（即对象），对象的外部只需要知道它做什么，而不必       知道它如何做。

​        2）**封装：**就是把对象的属性和服务结合为一个不可分的系统单位，并尽可能隐蔽对象的内部细节。

​        3）**继承：**特殊类的对象拥有的其一般类的全部属性与服务，称作特殊类对一般类的继承。（父子）

​        在OOA中运用继承原则，就是在每个由一般类和特殊类形成的一半----特殊结构总，把一般类的对象实例和所有特殊类的对象实        例都共同具有的属性和服务，一次性的在一般类中进行显式的定义。在特殊类中不在重复的定义一般类中已定义的东西，但是在语义        上，特殊类却自动的、隐含地拥有它的一般类（以及所有更上层的一般类）中定义的全部属性和服务。继承原则的好处是：是系统模      型比较简练也比较清晰。

​        4）**分类：**就是把具有相同属性和服务的对象划分为一类，用类作为这些对象的抽象描述。分类原则实际上是抽象原则运用于对象描      述时的一种表现形式。

​        5）**聚合：**又称组装，其原则是：把一个复杂的事物看成若干比较简单的事物组装体，从而简化对复杂事物的描述。

​        6）**关联：**是人类思考问题时经常运用的思想方法：通过一个事物联想到另外的事物。能使人发生联想的原因是事物之间确实存在着某些联系。

​        7）**消息通信：**这一原则要求对象之间只能通过消息进行通信，而不允许在对象之外直接地存取对象内部的属性。通过消息进行通信是由于封装原则而引起的。在OOA中要求消息连接表示出对象之间的动态联系。

​        8）**粒度控制：**一般来讲，人在面对一个复杂的问题域时，不可能在同一时刻既能纵观全局，又能洞察秋毫。因此需要控制自己的视野：考虑全局时，注意其大的组成部分，暂时不详查每一部分的具体的细节：考虑某部分的细节时则暂时撇开其余的部分。着就是粒度控制原则

​        9）**行为分析：**显示世界中事物的行为是复杂的。由大量的事物所构成的问题域中各种行为旺旺相互依赖交织

**二、面向对象分析产生三种模型**

​        1、**对象模型：**对用例模型进行分析，把系统分解成互相协作的分析类，通过类图\对象图描述对象\对象的属性\对象间的关系，是系统的静态模型

​        2、**动态模型：**描述系统的动态行为，通过时序图/协作图/描述对象的交互，以揭示对象间如何协作来完成每个具体的用例。单个对象的状态变化/动态行为可以通过状态图来表示。

​        3、**功能模型**（即用例模型à作为输入）

​​    ​       

​       

​        封装：也叫作信息封装，确保组件不会以不可预期的方式改变其它组件内部状态，只有在那些提供了内部状态改变方法的组建中，才可以访问其内部状态。每类组件都提供了一个与其它组件联系的接口，并规定了其它组件进行调用的方法。

​        多态性：组件的引用和类集会涉及到其它许多不同类型的组件，而且引用组件所产生的的结果得依据实际调用的类型。

​        继承性：允许在现存的组件基础上创建子类组件，着统一并强调了多态性和封装性。典型的来说就是用类来对组件进行分组，而且还可以定义新类为现存的类的扩展，这样就可以将类组织成树形或网状结构，这体现了动作的通用性。

# 二、类与对象的创建

**定义一个类：**

​        **定义类的成员变量：**

​        1、类的定义包括“成员变量”的定义和“方法”的定义，其中“成员变量”用于描述对象  共同的数据结构，“方法”则是所有对象共同的行为。

​        2、Java语言中，类的成员变量的定义可以使用如下的语法：

```java

修饰符 class  类名 {

      成员变量类型   变量名;

      ………

}

```

​        3、对象创建后，其成员变量可以按照默认的方式初始化，初始化对象成员变量时，其默认值的规则如下表所示：

| **成员变量类型**                                  | **默认初始值** |

| ------------------------------------------------- | -------------- |

| 数值类型（byte、short、int、long、float、double） | 0              |

| boolean类型                                       | false          |

| char类型                                          | /u0000         |

| 引用类型                                          | null           |

**定义类的方法：**

类中除了定义成员变量，还可以定义方法，用于描述对象的行为，封装对象的功能，Java语言中，可以按照如下方式定义类中的方法：

```java

class  类名 {

    修饰符  返回值类型   方法名(参数列表){

         方法体………

    }

    ……………

}

```

**创建并且使用对象：**

​        **使用new关键字创建对象：**

​        类定义完成之后，可以使用new关键字创建对象，创建对象的过程通常称为实例化对象，new的运算语法为：

```java

new   类名();

如：new  JFrame(); //可以创建一个窗体对象

创建对象语法：

数据类型   引用类型变量   指向  new关键字        对象

Student       zs        =    new           Student();

```

**引用类型变量：**

​    为了能够实例化对象进行访问控制，需要使用一个特殊的变量——引用。

​    引用类型变量可以存放该类对象的地址信息，通常称为“指向该类的对象”，当一个引用类型变量指向该类的对象时，就可以通过这个变量对对象实施访问。

​        除了8种基本数据类型之外，用类、接口、数组等声明的变量都称为引用类型变量，简称“引用”。

**访问对象的成员变量，调用方法:**

​        可以通过引用访问对象的成员变量或调用方法。

```java

创建cell类：

public class Cell {

    // 定义属性

    int row;

    int col;

   

    //定义方法

    public void drop() {}

    public void moveLeft(int len) {}

    public String getCellInfo() {

        return "";

    }

}

创建Cell类并访问成员变量及方法

Cell  c  =  new  Cell();

c.row  =  3;

c.col   =  2;

c.drop();

c.moveLeft(2);

String   str   =   c.getCellInfo();

```

**引用类型变量的赋值：**

​        1、引用类型变量存储的是对象的地址信息，相同类型的引用类型变量之间也可以互相赋值。

​        2、引用类型变量之间的赋值不会创建新的对象，但有可能会使两个以上的引用指向同一个对象。例如：

```java

Emp  e1  =  new  Emp();

Emp  e2  =  e1; // 将e1的值（对象地址信息）赋给e2，此时e1和e2指向相同对象

**null和NullPointerException：**

​    1、对于引用类型变量。可以对其赋值为null，null的含义为“空”，表示还没有指向任何对象，例如：

```java

Emp  emp  =  null; //emp为的值null，没有指向任何对象

emp  =  new  Emp(); //emp指向了一个Emp对象

```

​        2、当一个引用变量的值为null的时候，如果通过引用访问对象成员变量或者调用方法不符合逻辑时，会产生NullPointerException，例如：

```java

int[]  arr  =  null;

arr.length;

# 四、Java内存分析

## 1、堆、栈、方法区：

**堆:** new出来的对象(包括实例变量)

**栈:** 局部变量(包括方法的参数)

**方法区:** .class字节码文件(包括方法、静态变量)

## 2、堆，栈，方法区，常量池 的位置分布图：

<img src="06-面向对象(OOP).assets\image-20220913225751369.png" alt="image-20220913225751369" style="zoom:80%;" />

## 3、内存区域类型

​        **1.寄存器：**最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制；

​        **2. 堆：**存放所有new出来的对象；

​        **3. 栈**：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中(对象可能在常量池里)（字符串常量对象存放在常量池中。）；

​        **4. 静态域：**存放静态成员（static定义的）；

​        **5. 常量池：**存放字符串常量和基本类型常量（public static final）。有时，在嵌入式系统中，常量本身会和其他部分分割离开(由于版权等其他原因)，所以在这种情况下，可以选择将其放在ROM中 ；

​        **6. 非RAM存储：**硬盘等永久存储空间

1.内存管理:由JVM来管理的

​        **1) 堆:**

​           1.1) 存储new出来的对象(包括实例变量)

​           1.2) 垃圾: 没有任何引用所指向的对象

​            **垃圾回收器(GC)**不定时到内存中清理垃圾，

​            回收过程是透明的(看不到的)，不一定一发现垃圾就立刻回收，

​            调用System.gc()可以建议虚拟机尽快调度GC来回收

            1.3) 内存泄漏: 不再使用的内存没有被及时的回收

             建议: 对象不再使用时及时将引用设置为null

        1.4) 实例变量的生命周期:

​        在创建对象时存储在堆中，对象被回收时一并被回收

        **2) 栈:**

               2.1) 存储正在调用的方法中的所有局部变量(包括方法的参数)

                2.2) 调用方法时，会在栈中为该方法分配一块对应的栈帧，

​                          栈帧中存储方法中的局部变量(包括参数)，

​                           方法调用结束时，栈帧被清除，局部变量一并被清除

               2.3) 局部变量的生命周期:

​                           方法被调用时存储在栈中，方法结束时与栈帧一并被清除

        **3) 方法区:**

​               3.1) 存储.class字节码文件(包括静态变量、方法)

​               3.2) 方法只有一份，通过this来区分具体的调用对象

# 六、访问控制修饰符

## 1、public和private

​        private修饰的成员变量和方法仅仅只能在本类中访问调用。

​        public修饰的成员变量和方法可以在任何地方调用，public修饰的内容是对外提供可以被调用的功能，需要相对稳定，private修饰的内容是对类实现的封装，如果“公开”会增加维护的成本。

## 2、 protected和默认访问控制

​        1）用protected修饰的成员变量和方法可以被子类及同一个包中的类使用。

​        2）默认的访问控制即不书写任何访问修饰符，默认访问控制的成员变量和方法可以被同一个包中的类调用。

## 3、访问控制修饰类

​        1）对于类的修饰可以使用public和默认的方式，public修饰的类可以被任意一个类使用，默认方法控制的类只能被同包中的类使用。

​        2）protected和private可以用于修饰内部类

# 七、封装

​        封装，简单的说就是该露的露，该藏的藏。我们在设计程序是要追求“高内聚，低耦合”，其中，高内聚指的是类的内部数据操作细节由自己完成，不允许外部干涉。低耦合指的是仅暴露少量的方法给外部调用（使用get/set方法）。

​        封装（对数据的隐藏），通常来说，应禁止直接访问应该对象中数据的实际表示，而是应该通过操作接口来访问，这种称为信息隐藏。

**封装的意义：**

​        1、对外提供可调用的，稳定的功能。

​        2、封装容易变化的，具体的细节，外界不可访问，

这样封装的意义在于：

​            a. 降低代码出错的可能性，便于维护。

​          b. 当内部的实现细节改变时，只要保证对外的功能定义不变，其他的模块就不会因此而受到牵连。

# 八、继承

## 1、泛化的过程

## 2、extends关键字

​        1、通过extends关键字可以实现类的继承。

​        2、子类可以继承父类的成员变量及成员方法，同时也可以定义自己的成员变量和成员方法。

​        3、Java语言不支持多重继承，一个类只能继承一个父类，但是一个父类可以有多个子类。

例如：

<img src="06-面向对象(OOP).assets\image-20220913231357154.png" alt="image-20220913231357154" style="zoom:80%;" />

## 3、继承中的构造方法

​        1、子类的构造方法中必须通过super关键字调用父类的构造方法，这样可以妥善的初始化继承自父类的成员变量。

​        2、如果子类的构造方法中没有调用父类的构造方法，Java编译器会自动的加入对父类的无参构造方法的调用（如果父类没有无参构造方法，则会有编译错误）。

## 4、父类的引用指向子类的对象

​        1、一个子类的对象可以向上造型为父类的类型，即，定义父类型的引用可以指向子类型的对象。

​        2、 父类的引用可以指向子类的对象，但是通过父类的引用只能访问父类所定义的成员，不能访问子类扩展的部分。

例如：

# 九、super关键字

**在java里面，对于super关键字通常有两种用法：**

​        1. 用在子类的构造方法里（初始化用），主要是调用父类的默认构造方法，如果父类有不止一个构造方法，可以通过super指定具体的构造函数，比如 super(paras)。

​        2. 用在子类里调用隐藏或重写的属性或行为，比如 super.onDestroy()等等。

​        对于第1种需要注意，super表示当前类的父类对象，super()调用的是父类默认的构造方法，即这样可以对父类进行初始化。如果没有对父类进行初始化，当子类调用父类的方法时，便会从逻辑上出现错误，因为没对父类初始化，父类的方法和属性便没有内存空间。

 **关于super 与 this 关键字的对比（区别）：**

​        1. super（参数）：调用基类中的某一个构造函数（应该位于子类构造函数中的第一条语句）。

​        2. this（参数）：调用本类中的构造函数（应该位于构造函数中的第一条语句）。

​        3. super:　它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）。

​        4. this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）

​        5、调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。

​        6、super()和this()类似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它构造方法。

​        7、super()和this()均需放在构造方法内第一行。

​        8、尽管可以用this调用一个构造器，但却不能调用两个。

​        9、this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。

​        10、 this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。

​        11、 从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

# 十、方法重写

**方法的重写(Override):**

​    1、发生在父子类中，方法名称相同，参数列表相同，方法体不同

​    2、重写方法被调用时，看对象的类型

​    3、遵循"两同两小一大"原则:------------了解

​    3.1、两同:

​    3.1.1、方法名称相同

​    3.1.2、参数列表相同

3.2、两小:

​        3.2.1、派生类方法的返回值类型小于或等于超类方法的

​        a、void时，必须相同

​        b、基本数据类型时，必须相同

​        c、引用数据类型时，小于或等于

​        3.2.2、派生类方法抛出的异常小于或等于超类方法的

​               3.3、一大:

​        3.3.1、派生类方法的访问权限大于或等于超类方法的

**重写与重载的区别:**

​        1、重写(Override):

​        1.1、发生在父子类中，方法名相同，参数列表相同，方法体不同

​        1.2、"运行期绑定"，看对象的类型绑定方法

​        2、重载(Overload):

​        2.1、发生在一个类中，方法名相同，参数列表不同，方法体不同

​        2.2、"编译期绑定"，看参数/引用的类型绑定方法

<p style="color: red">补充：</p>

​        编译期:.java源文件，经过编译，生成.class字节码文件

​        运行期:JVM加载.class并运行.class

​        编译错误:只是检查语法

# 十一、多态

​        多态指的是同一方法可以根据发送对象的不同而采用多种不同的行为方式。

​        一个对象的实际类型是确定的，但是可以指向对象的引用的类型有很多。

​        多态存在的条件：

​        1、 有继承关系

​        2、 子类重写父类的方法

​        3、 父类引用指向子类对象

**多态的意义:**

​        1、行为的多态(所有抽象方法都是多态的)

​        2、对象的多态(所有对象都是多态的)

**多态的表现形式:**

​        1、重写:根据对象的不同来表现多态

​        2、重载:根据参数的不同来表现多态

注：多态是方法的多态性，属性没有多态性。

多态

• 多态： 是指同一行为，具有多个不同表现形式。
• 多态的前提：有继承关系，子类对象是可以赋值给父类类型的变量。

父类类型 变量名 = new 子类/实现类构造器;

变量名.方法名();

引用类型转换

向上转型：多态本身是子类类型向父类类型向上转换（自动转换）的过程，这个过程是默认的。当父类引用指向一个子类对象时，便是向上转型。

使用格式：

父类类型  变量名 = new 子类类型();

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

使用格式：

子类类型 变量名 = (子类类型) 父类变量名;

Final关键字

fina：  不可改变，最终的含义。可以用于修饰类、方法和变量。

1. 1. 类：被修饰的类，不能被继承。
   2. 方法：被修饰的方法，不能被重写。
   3. 变量：被修饰的变量，有且仅能被赋值一次。

1. final修饰的类，不能被继承。

格式如下：final class 类名 {

}

1. final修饰的方法，不能被重写。

格式如下：

                 修饰符 final 返回值类型 方法名(参数列表){

方法体

}

抽象类

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了(因为子类对象会调用自己重写的方法)。换句话说，父类可能知道子类应该有哪个功能，但是功能具体怎么实现父类是不清楚的（由子类自己决定），父类只需要提供一个没有方法体的定义即可，具体实现交给子类自己去实现。我们把没有方法体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

抽象方法： 没有方法体的方法。

抽象类：包含抽象方法的类。

abstract使用格式

abstract是抽象的意思，用于修饰方法方法和类，修饰的方法是抽象方法，修饰的类是抽象类。

抽象方法

使用`abstract` 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

定义格式：

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

抽象类

如果一个类包含抽象方法，那么该类必须是抽象类。注意：抽象类不一定有抽象方法，但是有抽象方法的类必须定义成抽象类。

定义格式：

                 abstract class 类名字 {    

}

接口

定义格式

//接口的定义格式：

interface 接口名称{

    // 抽象方法

}

// 接口的声明：interface

// 接口名称：首字母大写，满足“驼峰模式”

内部类

按定义的位置来分

1. 成员内部内，类定义在了成员位置 (类中方法外称为成员位置，无static修饰的内部类)

2. 静态内部类，类定义在了成员位置 (类中方法外称为成员位置，有static修饰的内部类)

3. 局部内部类，类定义在方法内

4. 匿名内部类，没有名字的内部类，可以在方法中，也可以在类中方法外。

内部类的使用格式：

外部类.内部类。 // 访问内部类的类型都是用 外部类.内部类

获取成员内部类对象的方式：

外部类.内部类 变量 = new 外部类（）.new 内部类（）;

枚举

声明枚举时必须使用 enum 关键字，然后定义枚举的名称、可访问性、基础类型和成员等。

任意两个枚举成员不能具有相同的名称，且它的常数值必须在该枚举的基础类型的范围之内，多个枚举成员之间使用逗号分隔。

例 1

下面代码定义了一个表示性别的枚举类型 SexEnum 和一个表示颜色的枚举类型 Color。

   

public enum SexEnum{

    male,female;

}

public enum Color{

    RED,BLUE,GREEN,BLACK;

}

接口（Interface）

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过实现（implements）接口的方式，从而来实现接口的抽象方法。

​              接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

​              除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

​              接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口与类相似点：

​              1）一个接口可以有多个方法。

​              2）接口文件保存在 .java 结尾的文件中，文件名使用接口名。

​              3）接口的字节码文件保存在 .class 结尾的文件中。

​              4）接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：

​              1）接口不能用于实例化对象。

​              2）接口没有构造方法。

​              3）接口中所有的方法必须是抽象方法。

​              4）接口不能包含成员变量，除了 static 和 final 变量。

​              5）接口不是被类继承了，而是要被类实现。

​              6）接口支持多继承（接口不能继承类，接口只能继承接口）。

接口特性：

​              1）接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。

​              2）接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。

​              3）接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

package com.zpark.oop.day07;

public interface  Demo05 {

//    public Demo05(); 接口中不能有构造器

    // 在接口中定义的变量默认为 public final static修饰

    public final static String NAME = "大锤";

    // 接口中的方法必须全部是抽象方法

    public abstract void a();

    int b();

}

抽象类和接口的区别：

​              1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。

​              2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。

​              3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。

​              4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

内部类

​              java内部类的几种类型：成员内部类，静态内部类，方法内部类，匿名内部类。

成员内部类：成员内部类是类内部的非静态类。成员内部类不能定义静态方法和变量（final修饰的除外）。这是因为成员内部类是非静态的，类初始化的时候先初始化静态成员，如果允许成员内部类定义静态变量，那么成员内部类的静态变量初始化顺序是有歧义的。

成员内部类的使用方法：

​              1、 Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等

​              2、 Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性a

​              3、 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );

静态内部类：

静态内部类是 static 修饰的内部类，这种内部类的特点是：

​1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问。

​2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与             内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员。

​3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

方法内部类（局部内部类）：

​              方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。

需要注意：由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。

枚举

​              枚举是一个被命名的整型常数的集合，用于声明一组带标识符的常数。类似这种当一个变量有几种固定可能的取值时，就可以将它定义为枚举类型。

声明枚举

​              声明枚举时必须使用 enum 关键字，然后定义枚举的名称、可访问性、基础类型和成员等。

       任意两个枚举成员不能具有相同的名称，且它的常数值必须在该枚举的基础类型的范围之内，多个枚举成员之间使用逗号分隔。

提示：如果没有显式地声明基础类型的枚举，那么意味着它所对应的基础类型是 int。

枚举类

Java 中的每一个枚举都继承自 java.lang.Enum 类。当定义一个枚举类型时，每一个枚举类型成员都可以看作是 Enum 类的实例，这些枚举成员默认都被 final、public, static 修饰，当使用枚举类型成员时，直接使用枚举名称调用成员即可。所有枚举实例都可以调用 Enum 类的方法。

为枚举添加方法

​           Java 为枚举类型提供了一些内置的方法，同时枚举常量也可以有自己的方法。此时要注意必须在枚举实例的最后一个成员后添加分号，而且必须先定义枚举实例。

Java 中的 enum 还可以跟 Class 类一样覆盖基类的方法。

字符串String处理：直接定义和使用String类定义；

将字符数组转为字符串：char[] ch = new char[]{‘H’,’e’,’l’,’l’,’o’}

创建建字符串

        String str = new String(ch);

分配一个新字符串，该字符串包含字符数组参数的子数组中的字符:

      offset参数是子数组第一个字符的索引，count参数指定子数组的长度。

      复制子数组的内容;字符数组的后续修改不会影响新创建的字符串。

   char[] ch1 = new char[]{'H', 'e', 'l', 'l', 'o', '，', 'w', 'o', 'r', 'l', 'd'};

   String str1 = new String(ch1, 2, 8);

   System.out.println(str1);

分配一个新字符串，该字符串包含来自Unicode码点数组参数子数组的字符:

offset参数是子数组第一个编码点的索引，count参数指定子数组的长度。

子数组的内容被转换为字符;int数组的后续修改不会影响新创建的字符串。

        int[] arr = new int[]{65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75};

        String str2 = new String(arr, 0, 5);

        System.out.println(str2);

    }

将字符串转为int类型的值前提是字符内容必须是纯数字，使用包装类进行转换。

String转换为int：

Integer.parselnt(str)

Integer.valueOf(str).intValue();

Int转换为String：

String s = String.valueOf(i);

String s = Integer.toString(i);

String s = “”+i;

将int类型数据转为String类型

        int num1 = 56;

        String str = num1 + "";

        System.out.println(str + 1);

valueOf()方法将数据的内部格式转换为可读的形式。是一种静态方法，对于所有内置的类型，在字符串被重载，以便每一种类型都能被转换成字符串。

parse（）

parseXxx（String）这种形式，是指把字符串转换为数值型；

toString（）可以把一个引用类型转换为String字符串类型。

concat（）方法：String类的concat（）方法实现了将一个字符串连接到另外一个字符串后面。语法：字符串1.concat（字符串2）；

其他类型数据直接使用“+”拼接；

获取字符串长度：

使用length（）,语法：字符串名.length();

1、获取字符串长度

2、将字符串转大小写

3、去除字符串两端的空白

String str = "Hello Java";

// 使用length()函数获取字符串长度

System.out.println(str.length());

// 将字符串转为大写

System.out.println(str.toUpperCase());

// 将字符串转小写

System.out.println(str.toLowerCase());

String str1 = "              hello                     ";

System.out.println(str1.length());

// 取出字符串两端空白

String str2 = str1.trim();

System.out.println(str2.length());

字符串截取（substring（））：

         * substring(int start): 从指定位置开始截取，start表示开始位置下标

         * substring(int start, int end)：截取指定范围内的字符串，含前不含尾

• 分割字符串（spilt()）​ String 类的 split() 方法可以按指定的分割符对目标字符串进行分割，分割后的内容存放在字符串数组中。

九、字符串的替换 1、replace() 方法​ replace() 方法用于将目标字符串中的指定字符（串）替换成新的字符（串），其语法格式如下：```java字符串.replace(String oldChar, String newChar)```​ 其中，oldChar 表示被替换的字符串；newChar 表示用于替换的字符串。replace() 方法会将字符串中所有 oldChar 替换成 newChar

十、字符串比较​ 字符串比较是常见的操作，包括比较相等、比较大小、比较前缀和后缀串等。在 Java 中，比较字符串的常用方法有 3 个：equals() 方法、equalsIgnoreCase() 方法、 compareTo() 方法。## 1、equals() 方法​ equals() 方法将逐个地比较两个字符串的每个字符是否相同。如果两个字符串具有相同的字符和长度，它返回 true，否则返回 false。

十一、1、equalsIgnoreCase() 方法​ equalsIgnoreCase() 方法的作用和语法与 equals() 方法完全相同，唯一不同的是 equalsIgnoreCase() 比较时不区分大小写。当比较两个字符串时，它会认为 A-Z 和 a-z 是一样的。

2、equals()与==的比较​ 理解 equals() 方法和`==`运算符执行的是两个不同的操作是重要的。如同刚才解释的那样，equals() 方法比较字符串对象中的字符。而`==`运算符比较两个对象引用看它们是否引用相同的实例

1. 4、compareTo() 方法​ 通常，仅仅知道两个字符串是否相同是不够的。对于排序应用来说，必须知道一个字符串是大于、等于还是小于另一个。一个字符串小于另一个指的是它在字典中先出现。而一个字符串大于另一个指的是它在字典中后出现。字符串（String）的 compareTo() 方法实现了这种功能。​ compareTo() 方法用于按字典顺序比较两个字符串的大小，该比较是基于字符串各个字符的 Unicode 值。
2. **提示：**如果两个字符串调用 equals() 方法返回 true，那么调用 compareTo() 方法会返回 0。

• 字符串查找​

 在给定的字符串中查找字符或字符串是比较常见的操作。字符串查找分为两种形式：一种是在字符串中获取匹配字符（串）的索引值，另一种是在字符串中获取指定索引位置的字符。## 1、根据字符查找​ String 类的 indexOf() 方法和 lastlndexOf() 方法用于在字符串中获取匹配字符（串）的索引值。

• 1. indexOf() 方法​ indexOf() 方法用于返回字符（串）在指定字符串中首次出现的索引位置，如果能找到，则返回索引值，否则返回 -1。
  2. fromIndex 表示查找时的起始索引，如果不指定 fromIndex，则默认从指定字符串中的开始位置（即 fromIndex 默认为 0）开始查找。
  3. lastlndexOf() 方法​ lastIndexOf() 方法用于返回字符（串）在指定字符串中最后一次出现的索引位置，如果能找到则返回索引值，否则返回 -1。
• StringBuffer 类是可变字符串类，创建 StringBuffer 类的对象后可以随意修改字符串的内容。每个 StringBuffer 类的对象都能够存储指定容量的字符串，如果字符串的长度超过了 StringBuffer 类对象的容量，则该对象的容量会自动扩大
• 删除字符串​ StringBuffer 类提供了 deleteCharAt() 和 delete() 两个删除字符串的方法，下面详细介绍。**1、deleteCharAt() 方法**​ deleteCharAt() 方法用于移除序列中指定位置的字符，该方法的语法格式如下：```javaStringBuffer 对象.deleteCharAt(int index);```​ deleteCharAt() 方法的作用是删除指定位置的字符，然后将剩余的内容形成一个新的字符串
• StringBuilder 和 StringBuffer 功能基本相似，方法也差不多。不同的是，StringBuffer 是线程安全的，而 StringBuilder 则没有实现线程安全功能，所以性能略高。因此在通常情况下，如果需要创建一个内容可变的字符串对象，则应该优先考虑使用 StringBuilder 类。

1、静态常量​ Math 类中包含 E 和 PI 两个静态常量，正如它们名字所暗示的，它们的值分别等于 e（自然对数）和 π（圆周率）。

2、生成随机数（random()和Random类）​ 在 Java 中要生成一个指定范围之内的随机数字有两种方法：一种是调用 Math 类的 random() 方法，一种是使用 Random 类。​ Random 类提供了丰富的随机数生成方法，可以产生 boolean、int、long、float、byte 数组以及 double 类型的随机数，这是它与 random() 方法最大的不同之处。random() 方法只能产生 double 类型的 0~1 的随机数。​ Random 类位于 java.util 包中，该类常用的有如下两个构造方法。​ **Random()：**该构造方法使用一个和当前系统时间对应的数字作为种子数，然后使用这个种子数构造 Random 对象。​ **Random(long seed)：**使用单个 long 类型的参数创建一个新的随机数生成器。​ Random 类提供的所有方法生成的随机数字都是均匀分布的，也就是说区间内部的数字生成的概率是均等的，在表 1 中列出了 Random 类中常用的方法

3、Math 类的 random() 方法没有参数，它默认会返回大于等于 0.0、小于 1.0 的 double 类型随机数，即 0<=随机数<1.0。对 random() 方法返回的数字稍加处理，即可实现产生任意范围随机数的功能。

4、BigInteger 类型的数字范围较 Integer 类型的数字范围要大得多。BigInteger 支持任意精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值。​ 除了基本的加、减、乘、除操作之外，BigInteger 类还封装了很多操作，像求绝对值、相反数、最大公约数以及判断是否为质数等。​ 要使用 BigInteger 类，首先要创建一个 BigInteger 对象。BigInteger 类提供了很多种构造方法，其中最直接的一种是参数以字符串形式代表要处理的数字。

5、igDecimal 类​ BigInteger 和 BigDecimal 都能实现大数字的运算，不同的是 BigDecimal 加入了小数的概念。一般的 float 和 double 类型数据只能用来做科学计算或工程计算，但由于在商业计算中要求数字精度比较高，所以要用到 BigDecimal 类。BigDecimal 类支持任何精度的浮点数，可以用来精确计算货币值。​ BigDecimal 常用的构造方法如下。​ 1、BigDecimal(double val)：实例化时将双精度型转换为 BigDecimal 类型。​ 2、BigDecimal(String val)：实例化时将字符串形式转换为 BigDecimal 类型。​ BigDecimal 类的方法可以用来做超大浮点数的运算，像加、减、乘和除等。在所有运算中，除法运算是最复杂的，因为在除不尽的情况下，末位小数的处理方式是需要考虑的。

6、Java时间日期的处理​ 在 Java 中获取当前时间，可以使用 java.util.Date 类和 java.util.Calendar 类完成。其中，Date 类主要封装了系统的日期和时间的信息，Calendar 类则会根据系统的日历来解释 Date 对象。下面详细介绍这两个类的具体使用。## 1、Date 类​ Date 类表示系统特定的时间戳，可以精确到毫秒。Date 对象表示时间的默认顺序是星期、月、日、小时、分、秒、年。#### 1.1、构造方法​ Date 类有如下两个构造方法。​ 1、Date()：此种形式表示分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒），使用该构造方法创建的对象可 以获取本地的当前时间。​ 2、Date(long date)：此种形式表示从 GMT 时间（格林尼治时间）1970 年 1 月 1 日 0 时 0 分 0 秒开始经过参数 date 指定的毫 秒数。

7、Calendar 类​ Calendar 类是一个抽象类，它为特定瞬间与 YEAR、MONTH、DAY_OF—MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（如获得下星期的日期） 提供了一些方法。​ 创建 Calendar 对象不能使用 new 关键字，因为 Calendar 类是一个抽象类，但是它提供了一个 getInstance() 方法来获得 Calendar类的对象。getInstance() 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化

十七、

1.  实现 int 和 Integer 的相互转换**​ 可以通过 Integer 类的构造方法将 int 装箱，通过 Integer 类的 intValue 方法将 Integer 拆箱。
   2、 将字符串转换为数值类型**​ 在 Integer 和 Float 类中分别提供了以下两种方法：​ ① Integer 类（String 转 int 型）```javaint parseInt(String s);```​ s 为要转换的字符串。​ ② Float 类（String 转 float 型）```javafloat parseFloat(String s)```​ **注意：**使用以上两种方法时，字符串中的数据必须由数字组成，否则转换时会出现程序错误。
   
   
   3、将整数转换为字符串**​ Integer 类有一个静态的 toString() 方法，可以将整数转换为字符串
   4、Object类​ Object 是 Java 类库中的一个特殊类，也是所有类的父类。也就是说，Java 允许把任何类型的对象赋给 Object 类型的变量。当一个类被定义后，如果没有指定继承的父类，那么默认父类就是 Object 类。因此，以下两个类表示的含义是一样的。
   
   
   5、toString() 方法​ toString() 方法返回该对象的字符串，当程序输出一个对象或者把某个对象和字符串进行连接运算时，系统会自动调用该对象的 toString() 方法返回该对象的字符串表示。​ Object 类的 toString() 方法返回“运行时类名@十六进制哈希码”格式的字符串，但很多类都重写了 Object 类的 toString() 方法，用于返回可以表述该对象信息的字符串。

6、equals() 方法​ 在前面学习字符串比较时，曾经介绍过两种比较方法，分别是`==`运算符和 equals() 方法，`==`运算符是比较两个引用变量是否指向同一个实例，equals() 方法是比较两个对象的内容是否相等，通常字符串的比较只是关心内容是否相等。


7、getClass() 方法​ getClass() 方法返回对象所属的类，是一个 Class 对象。通过 Class 对象可以获取该类的各种信息，包括类名、父类以及它所实现接口的名字等。

8、Integer类​ Integer 类在对象中包装了一个基本类型 int 的值。Integer 类对象包含一个 int 类型的字段。此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。## 1、Integer 类的构造方法​ Integer 类中的构造方法有以下两个：​ **Integer(int value)：**构造一个新分配的 Integer 对象，它表示指定的 int 值。​ **Integer(String s)：**构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。

9、Integer 类的常量​ Integer 类包含以下 4 个常量。​ **MAX_VALUE：**值为 231-1 的常量，它表示 int 类型能够表示的最大值。​ **MIN_VALUE：**值为 -231 的常量，它表示 int 类型能够表示的最小值。​ **SIZE：**用来以二进制补码形式表示 int 值的比特位数。​ **TYPE：**表示基本类型 int 的 Class 实例。


10、Float 类的构造方法​ Float 类中的构造方法有以下 3 个。​ **Float(double value)：**构造一个新分配的 Float 对象，它表示转换为 float 类型的参数。​ **Float(float value)：**构造一个新分配的 Float 对象，它表示基本的 float 参数。​ **Float(String s)：**构造一个新分配的 Float 对象，它表示 String 参数所指示的 float 值。


11、Float 类的常用常量​ 在 Float 类中包含了很多常量，其中较为常用的常量如下。​ **MAX_VALUE：**值为 1.4E38 的常量，它表示 float 类型能够表示的最大值。​ **MIN_VALUE：**值为 3.4E-45 的常量，它表示 float 类型能够表示的最小值。​ **MAX_EXPONENT: **有限 float 变量可能具有的最大指数。​ **MIN_EXPONENT：**标准化 float 变量可能具有的最小指数。​ **MIN_NORMAL：**保存 float 类型数值的最小标准值的常量，即 2-126。​ **NaN：**保存 float 类型的非数字值的常量。​ **SIZE：**用来以二进制补码形式表示 float 值的比特位数。​ **TYPE：**表示基本类型 float 的 Class 实例。


12、Double类​ Double 类在对象中包装了一个基本类型 double 的值。Double 类对象包含一个 double 类型的字段。此外，该类还提供了多个方法，可以将 double 类型与 String 类型相互转换，同时 还提供了处理 double 类型时比较常用的常量和方法。## 1、Double 类的构造方法​ Double 类中的构造方法有如下两个。​ **Double(double value)：**构造一个新分配的 Double 对象，它表示转换为 double 类型的参数。​ **Double(String s)：**构造一个新分配的 Double 对象，它表示 String 参数所指示的 double 值。

13、Number类​ Number 是一个抽象类，也是一个超类（即父类）。Number 类属于 java.lang 包，所有的包装类（如 Double、Float、Byte、Short、Integer 以及 Long）都是抽象类 Number 的子类。

14、在 validateUser() 方法中，使用 for 循环遍历用户输入的用户名、密码和年龄，对其每个字符进行验证，判断其是否符合要求。在验证的过程中，分别使用了 Character 类的 isLetter() 方法、isLetterOrDigit() 方法和 isDigit() 方法。


15、Byte 类的构造方法​ Byte 类提供了两个构造方法来创建 Byte 对象。