第六章：数组
一、理解
1.
数组：一次性的定义多个同类型的变量，可以存储多个数据，而且可以对多个变量进行统一管理
2.
数组的重要因素：数据类型、数组的长度
3. 数组的使用：
(1)
声明数组：确定数据类型数据类型[]
数组名
; //
建议
数据类型 数组名[];
数据类型 []数组名;
int[] a;
(2)
分配空间：确定数组的长度
数组名= new 数据类型[
长度
];
a = new int[4];
4.
细节：
(1)
数组下标：从
0
开始，依次为
0
、
1
、
2
、3...数组的长度
-1
(2)
访问数组时，采用数组名
+
下标，数组名
[
下标]
(3)
操作数组时，给定的下标不在合理范围内，编译通过，运行报错，错误信息为：
java.lang.ArrayIndexOutOfBoundsException:(数组的下标越界
)
(4) //
对数组元素进行一一 ，称为数组的遍历
for(int i=0;i<5;i++){
System.out.println("i="+i+"
对应的元素为："+ages[i]);}
(5)
获取数组的长度：数组名
.length
5.
数组的默认值
整数类型：
0
小数类型：
0.0
布尔类型：
false
字符类型：空字符
引用类型：
null
6.
数组 不同定义方式：
(1)
先声明，再分配空间：
数据类型
[]
数组名
;
数组名
= new
数据类型
[
长度
];
(2) 声明的同时并分配空间：
数据类型
[]
数组名
= new
数据类型
[
长度];
(3)
显示初始化：
数据类型
[]
数组名
= new
数据类型
[]{
值1,值
2,
值
3};
(4)
显示初始化：
数据类型
[]
数组名
= {
值
1,
值
2,
值
3};
注意：数组的声明和初始化一起完成
二、数组的内存
1.
数组在内存中空间是连续的
2.
数组类型的变量，存储是数组内存在空间的首地址
3.
寻址方式：首地址
+
下标
*
数据类型字节数
三、数组的扩容
1.
思想：
(1)
创建一个更大空间的新数组，通常为原数组的2倍
(2)
将原数组的内容进行一一赋值到新的数组中
(3)
新地址覆盖旧地址
2.
扩容的实现：
(1)
第一种方式：
int[] a = {4,7,3}; //
数组的长度为
System.out.println("
数组的长度
为：
"+a.length);
for(int i=0;i<a.length;i++){ System.out.print(a[i]+" ");
}
System.out.println();
//
将数据
8
存储到
a
数组中，不够用扩容
// 1.
创建一个更大长度的数组
int[] b = new
int[a.length*2];
// 2.
将原数组的内容一一赋值新数组中
for(int i=0;i<a.length;i++){
//
新的数组中
=
原数组中内容
b[i] = a[i];
}
// 3.
新的地址覆盖旧的地址
a = b;
System.out.println("
扩容之后的
长度为：
"+a.length);
for(int i=0;i<a.length;i++){
System.out.print(a[i]+"
");
}
(2)
第二种方式：借助工具类：
java.util.Arrays.copyOf(
数组名
,
新数组的
长度
)
四、二维数组
1.
二维数组：类似于
excel
表格，有行和列构成
2.
行标和列标都是从
0
开始，访问二维数组通过行
和列进行访问：数组名
[
行下标
/
高纬
][
列下标
/
低维]
3.
二维数组的定义：数据类型
[][]
数组名
= new
数据类型[
行数
][
列数
];
int[][] a= new int[4][3];
// 4
行
3
列二维数组
五、数组的排序
1.
排序：将数组中元素按照一定的排序顺序进行存储
2.
排序方式：从小到大
(1)
冒泡排序：每次将相邻的两个元素进行一一比较，较大的值往后放
int[] a = {9,4,5,2,6,3,1,9};
/*
从小到大进行排序
冒泡排序：每次将相邻的两个元素进行一一比较，较大的值往后
下标：
0 1 2 3
元素：
9 4 5 2
---------
第一轮
---------
a0~a1 4 9 5 2
a1~a2 4 5 9 2
a2~a3 4 5 2 9(
最大值)
----------
第二轮
---------
a0~a1 4 5 2 9
a1~a2 4 2 5 9
---------
第三轮
---------
a0~a1 2 4 5 9
*/
//
第
i=1
轮：使用
a[j]
代表第一个比较项，相邻 的一项 a[j+1]
/*for(int j=0;j<3;j++){
// x = 4 - i = a.length - i
//
使用
a[j]
和
a[j+1]
进行比较
if(a[j] > a[j+1]){
//
交换：借助第三遍历
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
//
第
i=2
抡：
for(int j=0;j<2;j++){
//
使用
a[j]
和
a[j+1]
进行比较
if(a[j] > a[j+1]){
//
交换：借助第三遍历
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
//
第
i=3
抡
for(int j=0;j<1;j++){
//
使用
a[j]
和
a[j+1]
进行比较
if(a[j] > a[j+1]){
//
交换：借助第三遍历
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}*/
//
外层循环控制比较的轮数
for(int i=1;i<a.length;i++){
//
内层循环，控制每一轮具体比较的内容
for(int j=0;j< a.length
i;j++){
//
使用
a[j]
和
a[j+1]
进行比较
if(a[j] > a[j+1]){
//
交换：借助第三遍历
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
for(int i=0;i<a.length;i++){
System.out.print(a[i]+"\t");
}
(2)
第二种：借助工具类
java.util.Arrays.sort(
数组名
);
第七章：面向对象
一、编程思想
1.
面向过程：
(1)
面向过程：将问题分为第一步、第二步、第三步...
直到问题解决
(2)
问题：解决小业务相对比较简单，但是面对复杂业务时，相对不好处理
2.
面向对象：
(1)
面向对象：将一些业务过程看成一个整体，利用对象之间关系，解决问题
(2)
好处：解决业务复杂问题时，相对简单
二、对象
1.
对象：计算机中的对象：复杂的客观事物在
Java程序中的一种表现形式
一切皆对象
2.
对象的组成部分：
(1)
对象的属性：代表对象有什么特征，对应静态数据部分
(2)
对象的方法：代表对象能做什么，对应动态的行为和功能
3.
类：
(1)
计算机中，使用类进行区分不同类别对象，用于描述该类对象有哪些属性和哪些方法
(2)
类和对象的关系：
类是对象的模板
对象是类的实例
注意：一个类可以创建多个对象
三、类的组成
1.
类名：望文生义，每个单词首字母大写
2.
类的组成：
class
类名
{
// 1.
属性
// 2.
方法
}
3.
属性：
(1)
属性：也称为成员变量
(2)
位置：定义类以内，方法以外
(3)
语法：数据类型 变量名
;
数据类型 变量名
=
值
;
(4)
成员变量具有默认值：
整数类型：
0
小数类型：
0.0
布尔类型：
false
字符类型：空字符
对象类型：
null
(5)
成员变量的作用范围：至少在本类中有效
(6)
一个类中不允许成员变量命名相同，但是成员变量可以和局部变量命名冲突；局部变量在方法中被优先使用
4.
方法：
(1)
方法：也称为成员方法
(2)
位置：定义在类以内，其他的方法以外
(3)
语法：
public
返回值类型 方法名
(
形参
){
//
方法体
}
(4)
方法的定义分为方法的声明和方法实现：
a.
方法的声明：
修饰符 返回值类型 方法名
(
形参
)
异常
注意：一个方法的修饰符可以有
0~n
个
b.
方法的实现：
{}
5.
创建对象：
(1)
类名 对象名
= new
类名
();
(2)
使用：
对象名
.
属性名
对象名
.
方法名
(
实参);
四、方法的重载
(overload)
【开发
+
面试
+
考试】
1.
理解：一个类中可以定义多个同名的方法，但是
参数列表不同
2.
要求：
(1)
方法名相同
(2)
形参列表不同
(
数据类型、个数、顺序
)
(3)
返回值类型、修饰符、异常没有要求
3.
使用：根据调用时，传递的实际参数决定调用哪
一个方法
五、构造方法
1.
构造方法：是一种特殊的方法，也被称为构造器
2.
定义位置：定义类以内，方法以外
3.
特点
(
要求
)
(1)
构造方法的方法名必须和类名一致
(2)
构造方法没有返回值类型
(
连
void
都没有
)
(3)
语法：
修饰符 类名
(
形参
){}
(4)
构造方法允许重载
(
一个类中可以定义多个构造方法，但是无参数的构造方法只能一个，可以同时定义多个有参数的构造方法)
(5)
构造方法不能手动调用，在创建对象时，被调用
4.
使用：
(1)
在创建对象时，根据传递的实际参数，决定具体调用哪一个构造方法完成对象的创建
(2)
如果一个类中没有提供任何的构造方法时，jvm默认提供一个公开的无参数的构造方法；当类中提供了有参数的构造方法，则默认的构造方法不再提供(
可以自定义写出
)
5.
构造方法的作用：
(1)
用于创建对象
(2)
借助构造方法给属性赋值
6.
开发应用技巧：
实际开发一个类中通常提供两个构造方法：
(1)
一个无参数的构造方法
(2)
一个有参数的构造方法
(
参数取决于属性的个数、类型、顺序)
六、
this
的应用
1. this.
(1) this
代表当前对象，用于调用本类中属性或是方法
(2) this.
属性名
this.
方法名
(
实参
);
(3) this.
通常可以省略，但是当成员变量和局部变量命名冲突时，可以使用 this.
区分成员变量
2. this()
(1) this()
只能应用在构造方法中，调用本类其他构造方法
(2) this()
只能应用在构造方法中的第一行有效语句
七、引用
1.
引用：对象类型的变量
java
是一种强类型的语言，对应类型的数据需要
存储在对应类型的变量中：
类名 引用名
= new
类名
(
实参
);
//
引用
对象
//
引用类型
对象的类型
注意：引用的类型必须和对象的类型一致
2.
引用存储对象在堆空间中首地址
3.
每个对象在堆空间是相互独立，操作一个对象不
会影响其他对象
(1) this()
只能应用在构造方法中，调用本类其
他构造方法
(2) this()
只能应用在构造方法中的第一行有效
语句
java
是一种强类型的语言，对应类型的数据需要
存储在对应类型的变量中：
类名 引用名
= new
类名
(
实参
);
//
引用
对象
//
引用类型
对象的类型
注意：引用的类型必须和对象的类型一致
4.
可以单独的声明引用： 类名 引用名
;
5.
相同类型的引用之间可以相互赋值，传递的是对象在堆空间中首地址
6.
可以利用
null
作为引用的初始化数据，代表空地址，但是如果使用存储null
引用调用属性或是方法，编译通过，但是运行报错，错误信息为：java.lang.NullPointerException(空指针异常
)
7.
引用的应用场景：
(1)
引用应用在形式参数上：该类型的对象和引用都可以作为实际参数进行传递
(2)
引用应用在返回值类型上：该类型的对象或是引用都可以作为返回值进行返回
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
