数组和面向对象(封装)

(一):数组
(1);数组的概念和格式
A:为什么要有数组(容器)

* 为了存储同种数据类型的多个值

* B:数组概念

* 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。

* 数组既可以存储基本数据类型，也可以存储引用数据类型。

* C:数组定义格式

数据类型[] 数组名 = new 数据类型[数组的长度];A:为什么要有数组(容器)
* 为了存储同种数据类型的多个值

* B:数组概念

* 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。

* 数组既可以存储基本数据类型，也可以存储引用数据类型。

* C:数组定义格式

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

(2);数组初始化
A:什么是数组的初始化

* 就是为数组开辟连续的内存空间，并为每个数组元素赋予值

* B:如何对数组进行初始化

* a:动态初始化 只指定长度，由系统给出初始化值

* int[] arr = new int[5];

* b:静态初始化给出初始化值，由系统决定长度

* C:动态初始化的格式：

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

* D:案例演示

* 输出数组名称和数组元素
(2);数组案列举例 (案列只演示相关重要代码)
A,数组获取最值(获取数组中的最大值最小值)
class Demo{
public static int getMax(int[] arr) {

int max = arr[0];

for (int i = 1;i < arr.length ;i++ ) { //从数组的第二个元素开始遍历

if (max < arr[i]) { //如果max记录的值小于的数组中的元素

max = arr[i]; //max记录住较大的

}

}

return max;
}
}
B,数组元素翻转

public static void reverseArray(int[] arr) {
for (int i = 0;i < arr.length / 2 ; i++) {
//arr[0]和arr[arr.length-1-0]交换
//arr[1]和arr[arr.length-1-1]交换
//arr[2]和arr[arr.lentth-1-2]
//...
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
}

(3);二维数组的概念和格式
A:二维数组概述

* B:二维数组格式1

* int[][] arr = new int[3][2];

* C:二维数组格式1的解释

* D:注意事项

* a:以下格式也可以表示二维数组

* 1:数据类型 数组名[][] = new 数据类型[m]
;

* 2:数据类型[] 数组名[] = new 数据类型[m]
;

* B:注意下面定义的区别

*

int x;

int y;

int x,y;

int[] x;

int[] y[];

int[] x,y[]; x是一维数组,y是二维数组

* E:案例演示

* 定义二维数组，输出二维数组名称，一维数组名称，一个元素

(3);二维数组的遍历和案例
A遍历(外循环控制的是二维数组的长度，其实就是一维数组的个数。
* 内循环控制的是一维数组的长度)
int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

for (int i = 0;i < arr.length ;i++ ) { //获取到每个二维数组中的一维数组

for (int j = 0;j < arr[i].length ;j++ ) { //获取每个一维数组中的元素

System.out.print(arr[i][j] + " ");

}

System.out.println();

}

B案例
需求：公司年销售额求和

某公司按照季度和月份统计的数据如下：单位(万元)

第一季度：22,66,44

第二季度：77,33,88

第三季度：25,45,65

第四季度：11,66,99
相关代码如下
int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

int sum = 0; //定义变量,记录每次相加的结果

for (int i = 0;i < arr.length ;i++ ) { //获取每一个一维数组

for (int j = 0;j < arr[i].length ;j++ ) { //获取每一个一维数组中的元素

sum = sum + arr[i][j]; //累加

}

}

System.out.println(sum);

(二):面向对象
(1)面向对象思想
A:面向过程思想概述

* 第一步

* 第二步

B:面向对象思想概述

* 找对象(第一步,第二步)
C:面向对象思想特点

* a:是一种更符合我们思想习惯的思想

* b:可以将复杂的事情简单化

* c:将我们从执行者变成了指挥者

* 角色发生了转换

(2) 面向对象类和对象的简单概述
A:类：是一组相关的属性和行为的集合
B:对象：是该类事物的具体体现

(3)面向对象成员变量和局部变量的区别
A:在类中的位置不同
* 成员变量：在类中方法外

* 局部变量：在方法定义中或者方法声明上

* B:在内存中的位置不同

* 成员变量：在堆内存(成员变量属于对象,对象进堆内存)

* 局部变量：在栈内存(局部变量属于方法,方法进栈内存)

* C:生命周期不同

* 成员变量：随着对象的创建而存在，随着对象的消失而消失

* 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

* D:初始化值不同

* 成员变量：有默认初始化值

* 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

* 注意事项：

* 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

* 基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char

* 引用数据类型变量包括哪些:数组,类,接口,枚举

(二):面向对象 (封装)
(1)面向对象重要特征---封装的概述
A:封装概述

* 把同一类型的对象的共同的属性和行为放到一个类里面，就是封装的过程。具体实现方式是隐藏对象的属性和实现细节，仅对外提供公共访问方式。

* B:封装好处

* 隐藏实现细节，提供公共的访问方式

* 提高了代码的复用性

* 提高安全性。

* C:封装原则

* 将不需要对外提供的内容都隐藏起来。

* 把属性隐藏，提供公共方法对其访问。

(2)面向对象(private 和 this关键字的特点和使用)
A,private关键字特点
* a:是一个权限修饰符

* b:可以修饰成员变量和成员方法

* c:被其修饰的成员只能在本类中被访问
B, this关键字特点

* 代表当前对象的引用（代表本来对象的引用/指代）

* this的本质是一个对象

* 在每一个普通方法里，都有一个this，谁调用这个方法，this就指向谁
(3)简单的案例

/<span style="font-size:18px;">*
* A:人类赋值年龄的问题
* B:private关键字特点
* a:是一个权限修饰符
* b:可以修饰成员变量和成员方法
* c:被其修饰的成员只能在本类中被访问
* C:案例演示
* 封装和private的应用：
* A:把成员变量用private修饰
* B:提供对应的getXxx()和setXxx()方法
* private仅仅是封装的一种体现形式,不能说封装就是私有
*/
class Demo1_Person {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "张三";			//调用姓名属性并赋值
//p1.age = -17;				//调用年龄属性并赋值
//p1.speak();					//调用行为

p1.setAge(-17);

System.out.println(p1.getAge());
}
}

class Person {
String name;					//姓名
private int age;				//年龄

public void setAge(int a) {		//设置年龄
if (a > 0 && a < 200) {
age = a;
}else {
System.out.println("请回火星吧,地球不适合你");
}

}

public int getAge() {			//获取年龄
return age;
}

public void speak() {
System.out.println(name + "..." + age);
}
}</span>