【JavaSE 第七天】

一、数组总结

1. 数组与集合

	一维数组	二维数组	集合
声明变量
创建对象
存入数据
读取数据
遍历全体
工具类
底层原理

实际开发中应用数组较少，大多数都是使用集合，集合更加灵活。

2. Arrays 工具类的使用

java.util.Arrays 类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法

名称	作用
boolean equals(int[] a,int[] b)	判断两个数组是否相等
String toString(int[] a)	输出数组信息
void sort(int[] a)	对数组进行排序
void fill(int[] a,int vall)	将指定值填充到数组之中
int binarySearch(int[] a,int key)	对排序后的数组进行二分法检索指定的值

数组工具类的使用
排序的使用：

        // 1.创建一个数组对象int[] toBeSortedArr={22,33,5,7,2,13,-85,-5,6};// 2.调用工具类的工具方法对上面数组进行排序// 类名.方法名(传入参数)Arrays.sort(toBeSortedArr); // 返回值是void// 3.遍历数组for (int i = 0; i < toBeSortedArr.length; i++) {int value=toBeSortedArr[i];System.out.println("value = " + value);}

3. 数组使用中常见的异常

（1）数组脚标越界异常

        // 1.数组下标越界异常int[] intArr=new int[5];intArr[80]=5;System.out.println("intArr = " + intArr[5]);

（2）空指针异常

        // 2.空指针异常int[] arr=null;System.out.println("arr = " + arr[0]);char[] charArr=null;System.out.println("charArr = " + charArr[0]);

arr 引用没有指向实体，却在操作实体中的元素时：导致空指针异常
这两种异常只会编译时报错异常

二、面向对象思想

1. 面向过程

在顺序，分支，循环结构中，操作变量中存储的数据
起点——> 初始化——> 判断——> 操作…

（1）面向过程思想对应的问题

面向过程这种操作程序的设计理念，对应现实生活中某一个点上具体的问题，特别是对应解决问题过程中具体的操作步骤。

（2）面向过程程序的不足

最大的不足：整个系统各个组成部分之间【耦合】太严重

从开发角度来说：对任何一个细微的地方做修改，调整，升级都会不可避免地影响到其他部分（牵一发而动全身）。
从运行的角度来说：整个系统中有任何一个数据发生了变化，相关的很多部分都要重新运算，非常浪费性能

（3）本质

从面向过程的思想发展到面向对象的思想的根本原因就是因为随着时代，市场等方方面面的发展，要求编写更复杂的程序，设计更加庞大的系统。
由非常多组成部分有机的结合在一起的系统是面向过程的代码无法容纳的。

2. 面向对象

（1）关键

面向对象的设计理念，编程思想非常贴合人平常认识世界，思考问题时的思维方式。
一切皆对象：现实世界中所谓的“东西”，投射到代码中就是“对象”。
所以有了面向对象的设计理念和编程思想，我们就可以在开发过程中，大致保持和平常一样的思维方式来设计系统，编写代码。

（2）类

相关的事物分门别类（由一般到特殊再由特殊到一般）
汽车（卡车，轿车，赛车）
船只（货轮，游艇，帆船）
轨道交通（火车，高铁，地铁）
它们又都属于交通工具
程序中的【类】对应到生活中就是对同一类事物的一个统一的【分类名称】

（3）类和对象的关系

从抽象和具体的角度来说：
1. 类：抽象描述
2. 对象：具体实体，所以对象也被称作：【类的实例】
从设计图和产品的角度来说：
1. 类：生产产品的设计图
2. 对象：按照设计图生产出来的一个具体的产品

例如：使用汽车的设计图可以生产出汽车产品，使用汽车的类可以创建汽车的对象

小结：

面向对象的思想最根本的目的就是为了让程序能够更好的描述现实世界，程序只有做到了尽量逼真的描述现实世界，才能让程序解决现实生活中真实存在的问题。

作用与优势：

更好的描述现实世界
更符合人平时的思维方式

三、创建类和对象

1. 类的组成部分

解释：Java 类及类的成员

现实世界中的生物体大到鲸鱼小到蚂蚁都是由最基本的细胞构成的。同时，Java 代码世界是由诸多个不同功能的类构成的
显示生物世界中的细胞又是由细胞核，细胞质等构成的。那么 Java 中用类 class 来描述实物也是如此，常见的类的成员有：
1. 属性：对应类中的成员变量
2. 行为：对应类中的成员方法

Field = 属性 = 成员变量， Method = (成员)方法 = 函数

英文名	面向过程的角度	面向对象的角度
Filed	成员变量	属性
Method	成员函数	方法

（1）属性（对应程序中的数据）

通过程序中的各种数据类型，来描述一个类的【特征】，例如：汽车的颜色，汽车的大小…

（2）行为（对应程序中的操作）

通过程序中的方法（也就是面向过程视角中的函数），来执行这个类的对象能够做的操作，例如：汽车的行驶，汽车的鸣笛，汽车的启动…

2. 类的语法格式

修饰符 class 类名{属性声明:方法声明://说明：修饰符 public：类可以被任意访问，类的正文要用 {} 括起来
}

（1）声明一个类（有属性，有方法）

public class Person {// 属性/成员变量// 暂时不管声明属性的具体规则，像以前一样声明变量使用// 这个成员变量即使没有初始化，系统也会为它分配初始值// int 类型的初始值是 0int weight;// 方法/成员函数// 暂时不管声明方法的具体规则，先声明一个最简单的发放// public 表示这个方法可以在任何地方被调用// void 表示之人格方法没有任何返回值// (int food) 声明这个方法在被调用时可以传入的参数public void eat(int food){weight=weight+food;}public void say(){System.out.println("我现在的体重是："+weight);}
}

这个类并不能单独运行使用（需要以 main 方法为入口执行程序）

（2）声明一个对 Person 进行测试的类

public class PersonTest {public static void main(String[] args) {// 1.先创建对象// 第一步：声明一个 Person 类这个类型的变量// 第二步：使用 new 关键字创建 Person 类的对象，对象赋值给第一步声明的变量// new 关键字之后是 Person 类的构造器Person person=new Person(); // 类名()  构造器    可以先按照这个格式写// 2.调用 Person 对象 eat() 方法// 调用有参数方法的格式：指向对象的那个变量.方法名(参数)person.eat(5);// 3.调用Person对象的 say() 方法，让这个人说他的体重// 调用无参数方法的格式：指向对象的那个变量.方法名()person.say();// 4.直接修改 weight 的属性// 在类之外的其他地方是否可以操作类的属性，取决于属性的修饰符// 在将来学习了面向对象的【封装】，在类的外部不建议直接操作类的属性person.weight=20;person.say();}
}

四、包

1. 包的作用

（1）区分同名的类

如果直接写在（src）下，自己写的类运行没有问题，但是添加或引用他人的类就会很可能导致重名的现象，需要用到（包）来区分
包最重要的作用，就是为了区分同名的类

（2）将不同的类放在不同包中（便于使用与查找）

2. 简单类名与全类名

简单类名：不带有包名的类名
全类名：包名.类名

五、类中的属性

1. 声明属性的语法格式

修饰符 数据类型 属性名 = 初始化值;
// （初始化值可以不写，系统会取默认值）

（1）修饰符：
常用的权限修饰名有：private(私有的)、缺省(default)、protected(受保护的)、public(公共的)
其他修饰符：static、final（暂不考虑）
（2）数据类型
任何基本数据类型（如：int、Boolean）或任何引用数据类型
（3）属性名
属于标识符，符合命名规则和规范即可

2. 初始化值

声明一个属性时，如果没有明确的对这个属性进行初始化值的设置，那么系统就会给这个属性设置默认值。所以如果有确定的需要可以设置属性的默认值，如果没有特殊需要，不设置也行。

成员变量	初始值
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0
char	0 或写为:‘\u0000’(表现为空)
boolean	false
引用类型	null

3. 数据类型

基本数据类型
引用数据类型

4. 权限修饰符

权限修饰符不仅对类的属性有要求，对类中的方法的要求是完全一样的

修饰符名称	含义	本类	同包其他类	子类	同工程其他类
private	私有	可以使用	不可使用	不可使用	不可使用
default	缺省	可以使用	可以使用	不可使用	不可使用
protected	受保护	可以使用	可以使用	可以使用	不可使用
public	公共	可以使用	可以使用	可以使用	可以使用

5. 属性名

属性也叫成员变量，所以属性名作为标识符适用变量的标识符规则和规范。
解释：变量的分类：成员变量与局部变量

在方法体外，类体内声明的变量称为成员变量
在方法体内部声明的变量称为局部变量

变量包含（成员变量和局部变量）
成员变量包含（①实例变量（不以static修饰）和 ②类变量（以static修饰））
局部变量包含（①形参（方法、构造器中定义的变量）和 ②方法局部变量（在方法内定义）和 ③代码块局部i变量（在代码块内定义））

注意：二者在初始化值方面的异同

同：都有生命周期
异：局部变量除形参外，均需显式初始化

成员变量和局部变量的区别：

	成员变量	局部变量
声明的位置	直接声明在类中	方法形参或内部，代码块，构造器等
修饰符	private，public，static，final 等	不能用权限修饰符修饰，可以用 final 修饰
初始化值	有默认初始化值	没有默认初始化值，必须显式赋值，方可使用
内存加载位置	堆空间或静态域内	栈空间

6. 对象的内存分析

public class Cat {private String catName="dingdang"; // 成员变量int weight;                        // 成员变量public void say(String master){boolean emotion=true;          // 局部变量if(emotion){int food=5;                // 局部变量System.out.println("我名字是"+catName+"我想要"+food);}}
}

① 基本情况

在 main 方法中，执行如下操作

Ⅰ、声明变量

        // 1.声明Cat类型的变量Cat cat;

栈内存

变量名	变量值
cat	未初始化

Ⅱ、创建对象

new 关键词表示一定在堆内存中开辟了新的空间，一定创建了新的对象

        // 2.给 Cat 类型的变量赋值一个 Cat 类型的对象cat= new Cat();

Ⅲ、调用方法

        // 3.调用 Cat 对象的方法cat.say("tom");

Ⅳ、 `say()` 方法执行完成后

方法中的局部变量，方法一结束这些变量都会释放掉（栈内存中就会看不到）

Ⅴ、 `main()` 方法执行完成后

main() 方法中的 cat 局部变量也会被释放掉（只剩下堆内存，之后会被垃圾回收机制回收掉）

② 创建两个对象

证明：两个对象在堆内存中分别有自己的副本，分别进行时互不影响

Ⅰ、创建对象

        // 第一个对象Cat cat01=new Cat();// 第二个对象Cat cat02=new Cat();

Ⅱ、变量设置属性

        cat01.weight=10;cat02.weight=20;

③ 两个变量指向同一对象

        Cat cat03=new Cat();Cat cat04=cat03;

将变量 cat03 赋值给 cat04 （就是赋值地址值）
分别用两个变量修改 weight 的属性

        cat03.weight = 66;cat04.weight = 88;

最后结果会有覆盖
最终 weight 的属性值为 88

④ 变量置空

将变量 cat04 置空

cat04 = null;

如果再将变量 cat03 置空
堆内存将会因为没有变量引用，成为垃圾，被垃圾回收装置回收

④ 匿名对象

我们也可以不定义对象的句柄，直接调用这个对象的方法，这样的对象叫做匿名对象。

例如:

new Person().shout();

使用情况

如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象
我们经常将匿名对象作为实参传递给一个方法调用

六、类中的方法

1. 概念

方法是类或对象行为特征的抽象，用来完成某个功能的操作。在某些语言中也称为函数或过程。
将功能封装为方法的目的是，它可以实现代码的重用，简化代码。
Java 里的方法不能独立存在，所有的方法必须定义在类里。

① 实现代码复用

一个专门做×××的方法

② 参数和返回值

方法参数
作为数据进入
↓
方法中的特定操作
↓
传出数据
最后数据作为方法返回值

（1.有的方法没有返回值，单执行某一个操作。 2.有的方法没有参数，直接执行操作最后返回数据。）

方法的参数：给方法提供的一些数据。

形式参数声明方法时指定的参数，用来说明这个方法可以接受哪些参数（简称形参）
实际参数调用方法时实际传入的参数，用于方法执行过程中实际的运算（简称实参）

方法的返回值：方法执行完成后，给方法的调用者返回的结果数据。
（有的叫法不同：实际参数叫做入参，返回值叫做出参。）

2. 方法的声明和调用

① 声明方法

方法的声明格式：

修饰符 返回值类型 方法名(参数类型 形参1,参数类型 形参2,...){方法体程序代码;return 返回值;
}

修饰符：public、缺省、private、protected 等
返回值类型：（返回值：方法在执行完毕后返还给调用它的程序的数据。）
1. 没有返回值：void（单纯执行某一个操作）
2. 有返回值：声明出返回值的类型。与方法体中“return 返回”搭配使用
方法名：属于标识符，命名时遵循标识符命名规则和规范
形参列表：可以包含零个，一个或多个参数。多个参数时，中间用英文逗号隔开

	无返回值	有返回值
有形参	void 方法名(){}	返回值的类型方法名(){}
有形参	void 方法名(形参列表){}	返回值的类型方法名(形参列表){}

     public int add(int a,int b){// 声明一个方法，求两个整数的和// int a，int b 声明方法的参数，形式参数// public int; 表示方法的访问权限是public，返回值是 int 类型// 方法名：addint addResult=a+b;// 计算 a+b 的和return addResult;// 使用 return 关键字将 a+b 的和返回给方法的调用者}

② 调用方法

     public static void main(String[] args) {// 1.要调用一个方法，需要创建方法所在的类的对象Calculator calculator=new Calculator();// 2.通过对象调用方法// 这里传入给方法的 5，11 叫做实际参数int addResult=calculator.add(5,11);System.out.println("addResult = " + addResult);}

③ 方法相关的规则

方法调用一次就会执行一次
方法如果没有返回值，返回值类型用关键字 void 表示，方法体内可以没有 return；如果写了 return，那么表示方法结束。
方法声明的返回值类型必须和实际返回的数据类型一致。
方法中只能调用方法或属性，方法内部不能再声明定义方法。
定义方法时，方法的结果应该返回给调用者，交由调用者处理。

3. 方法的练习

定义类 Student，包含三个属性：学号 number(int)，年级 state(int)，成绩 score(int) 。创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出 3 年级(state 值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息

提示：

生成随机数：Math.random()，返回值类型 double；
四舍五入取整：Math.round(double d)，返回值类型 long。

（1）声明 Student 类

public class Student {int number;int state;int score;// 用于每次打印 Student 对象的信息，代码复用public void showMyInfo(){System.out.println("number="+number+"\tstate="+state+"\tscore="+score);}
}

（2）创建 Student 数组

// 声明一个 Student 的类型的数组，来存储循环创建的20个 Student 对象Student[] studentArr = new Student[20];

内存分析：

（3）循环创建 Student 对象并存入数组

        // 循环20次创建20个对象，存储进 Student 数组for (int i = 0; i < 20; i++) {Student student = new Student();studentArr[i] = student;}

内存分析：

（4）在循环创建 Student 时设置属性

        // 循环20次创建20个对象，存储进 Student 数组for (int i = 0; i < 20; i++) {// 创建 Student 对象Student student = new Student();// 给 Student 对象设置 number 属性student.number = i+1;// 给 Student 对象设置 state 属性student.state = (int)(Math.random()*10)+1;// 给 Student 对象设置 score 属性student.score = (int)(Math.random()*100);// 把对象存入数组studentArr[i] = student;}

内存分析：

（5）在循环中打印数据

     public static void main(String[] args) {// 声明一个 Student 的类型的数组，来存储循环创建的20个 Student 对象Student[] studentArr=new Student[20];// 循环20次创建20个对象，存储进 Student 数组for (int i = 0; i < 20; i++) {// 创建 Student 对象Student student=new Student();// 给 Student 对象设置 number 属性student.number=i+1;// 给 Student 对象设置 state 属性student.state=(int)(Math.random()*10)+1;// 给 Student 对象设置 score 属性student.score=(int)(Math.random()*100);// 把对象存入数组studentArr[i]=student;// 判断当前 Student 对象的 state 是否相符if(student.state==3){student.showMyInfo();}}}

（6）根据成绩冒泡排序

① 冒泡排序法

外层循环：数组的长度是多少，外层就循环多少次（0 ~ length-1）
内层循环：
1. 执行范围：
（1）当前元素：0 ~ 数组长度 - i - 1（减 i 是因为外层每执行一次，最后一个元素就不用考虑了；减1是为了避免 j+1 造成数组下标越界）
（2）下一个元素：1 ~ 数组长度 - i
2. 拿当前元素和下一个元素进行比较
3. 如果当前元素比下一个元素要大，那就两个元素交换位置
4. 内层循环执行完成能够把最大的元素移动到数组的末尾

② 代码

        // 对数组中的元素进行冒泡排序// 外层循环：控制冒泡的次数for (int i = 0; i < studentArr.length; i++) {// 内层循环：负责执行冒泡for (int j = 0; j < (20-i-1); j++) {// 将当前学生分数与下一个学生分数进行比较if(studentArr[j].score>studentArr[j+1].score){Student swap=studentArr[j];studentArr[j]=studentArr[j+1];studentArr[j+1]=swap;}}}

（7）遍历排序后的数组

        // 遍历 Student 数组for (int i = 0; i < studentArr.length; i++) {Student student=studentArr[i];student.showMyInfo();}

总的代码：

    public static void main(String[] args) {// 声明一个 Student 的类型的数组，来存储循环创建的20个 Student 对象Student[] studentArr=new Student[20];// 循环20次创建20个对象，存储进 Student 数组for (int i = 0; i < 20; i++) {// 创建Student对象Student student=new Student();// 给Student对象设置number属性student.number=i+1;// 给Student对象设置state属性student.state=(int)(Math.random()*10)+1;// 给Student对象设置score属性student.score=(int)(Math.random()*100);// 把对象存入数组studentArr[i]=student;// 判断当前Student对象的state是否相符if(student.state==3){student.showMyInfo();}}// 对数组中的元素进行冒泡排序// 外层循环：控制冒泡的次数for (int i = 0; i < studentArr.length; i++) {// 内层循环：负责执行冒泡for (int j = 0; j < (20-i-1); j++) {// 将 当前学生分数 与 下一个学生分数 进行比较if(studentArr[j].score>studentArr[j+1].score){Student swap=studentArr[j];studentArr[j]=studentArr[j+1];studentArr[j+1]=swap;}}}System.out.println("====================");// 遍历 Student 数组for (int i = 0; i < studentArr.length; i++) {Student student=studentArr[i];student.showMyInfo();}}