Day06笔记
课程内容
1、二维数组
2、面向对象的思想介绍
3、类和对象的概念和使用
4、创建对象的内存理解
5、面向对象其他内容
二维数组
概述
1、理解：还是一个数组，只不过数组中的每个元素，都是一个一维数组
2、二维数组的定义：
元素的数据类型[][] 数组名称 = new int[有几个一维数组][每个一维数组有几个元素];
3、二维数组的初始化：
1、和定义相同的初始化方式，需要逐一给元素赋值
直接打印二维数组arr：[[I@15db9742，[[表示二维数组，I表示元素类型，@表示 分隔符，15db9742表示内存地址的哈希码值
打印二维数组的长度：二维数组中有几个一维数组
打印二维数组的某个元素arr[0]：[I@6d06d69c,因为二维数组中的每个元素，都是 一个一维数组的地址值
打印二维数组中的某个一维数组的长度：表示每个一维数组中有几个元素
打印二维数组中的某个一维数组的某个元素arr[0][0]：第一个一维数组的第一个元 素
图示：
2、第二种初始化方式：
int[][] arr = new int[3][];
arr[0] = new int[5];
arr[1] = new int[3];
每个一维数组的长度都可以不一样
3、第三种初始化方式：静态初始化
int[][] arr = {{9, 11, 3, 666}, {2, 888}, {0}, {}};
使用静态初始化的方式，将每个一维数组都创建成功，并且赋值了
代码示例
class Demo04_二维数组 {
public static void main(String[] args) {
int[][] arr1 = new int[3][5];
System.out.println(arr1);
System.out.println(arr1.length);
System.out.println(arr1[0]);
System.out.println(arr1[0].length);
System.out.println(arr1[0][0]);
arr1[0][0] = 10;
arr1[0][1] = 20;
int[][] arr2 = new int[3][];
System.out.println(arr2);//15db9742
System.out.println(arr2.length);//3
System.out.println(arr2[0]);//null
//System.out.println(arr2[0].length);//空指针异常
//System.out.println(arr2[0][0]);//空指针异常
arr2[0] = new int[5];
arr2[1] = new int[6];
arr2[2] = new int[1];
System.out.println(arr2[0].length);
System.out.println(arr2[1].length);
System.out.println(arr2[2][0]);
int[][] arr3 = {{9, 11, 3, 666}, {2, 888}, {0}, {}};
System.out.println(arr3[0]);//地址值
System.out.println(arr3[1].length);//2
System.out.println(arr3[2][0]);//0
System.out.println(arr3[3].length);//0
}
}
二维数组的遍历
一维数组使用一层循环，二维数组是数组嵌套数组，遍历就使用循环嵌套循环
代码示例
class Demo05_二维数组的遍历 {
public static void main(String[] args) {
int[][] arr = {{9, 11, 3, 666}, {2, 888}, {0}, {}};
//将每个一维数组遍历出来
for (int i = 0; i < arr.length; i++) {
//每个arr[i]都是一个一维数组，遍历这个一维数组
for(int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}
面向对象的思想介绍
1、面向对象是一种编程思想
2、面向对象和面向过程的区别：
面向过程：更强调的是解决问题的具体步骤和逻辑，更多强调的是解决问题的【方法】。解决问题的总体思路：自顶向下，逐步分解
面向对象：更强调的是解决问题的主体（谁来解决这个问题），更多强调的是对象，更多强调的是【数据】。谁拥有数据，谁就拥有操作数据的权利。解决问题的总体思路：自底向上，逐步组装
举例：洗衣服
1、面向过程：准备盆子、放洗衣粉、倒水、泡衣服、揉一揉、洗干净，晾出来
2、面向对象：找一个可以洗衣服的机器，洗衣机，把需要的衣服和洗衣液放进去，点击按钮，等待完成。
3、面向对象的好处：
1、更符合人类的思想习惯（凡事喜欢找东西、找人、找能解决问题的事物）
2、复杂的问题简单化
3、身份发生了变化，由执行者变成了指挥者
4、特征：
封装
继承
多态
5、面向过程和面向对象的关系：
面向对象基于面向过程，而并非排斥的关系
类和对象的概念和使用
类和对象的概念
1、类：类型，是一大堆各不相同的具体事物，抽象出来的一个概念。
抽象：抽取像的、相同的、相似的内容出来，形成一个概念
2、对象：事物的具体体现。一组相关数据和操作数据的集合形成的集合体。
类和说明
1、类是具体事物抽取的概念，这个概念，一定应该可以描述具体的事物
2、类：一组相关属性和行为描述的集合
3、属性：对于事物特征的描述，一般都是名词或者形容词
Java：使用一个变量来描述，和以前定义一样，只不过位置发生了改变，类中方法外
4、行为：对于事物可以做什么的描述，一般都是动词或者动宾结构
Java：使用一个方法来描述，和以前定义一样，只不过去掉了static关键字
5、人类举例：
属性：姓名、年龄、性别
功能：吃饭、睡觉、工作
对象的创建和使用
1、对象创建的格式：
类名 对象名 = new 类名();
2、对象创建格式详解：
1、类名：要创建的对象所属的类，例如：Scanner、Person
2、对象名：合法的标识符
3、=：赋值符号，右边的对象的地址，赋值给左边的引用
4、new：在堆内存中开辟一块空间
5、类名：和前面的类名一致即可
6、()：在调用类中的空参构造方法
3、访问属性：
对象名.属性名（访问）
对象名.属性名 = 属性值（赋值）
4、访问方法：
对象名.方法名();
代码示例
class Demo06_PersonTest {
public static void main(String[] args) {
Person p = new Person();
System.out.println(p.name + "..." + p.age + "..." + p.gender);
p.name = "zhangsan";
p.age = 23;
p.gender = "m";
System.out.println(p.name + "..." + p.age + "..." + p.gender);
p.eat();
p.sleep();
p.work();
}
}
class Person {
//定义属性
String name;
int age;
String gender;
//定义方法
public void eat() {
System.out.println("人吃饭");
}
public void sleep() {
System.out.println("人睡觉");
}
public void work() {
System.out.println("人工作");
}
}
练习
定义一个汽车类
属性：颜色（color），轮胎个数（num）
行为：跑（run：显示当前汽车对象的颜色和轮胎个数）
在测试类中，创建两个汽车对象，分别赋值不同的颜色和轮胎个数，访问属性和方法
创建对象的内存理解
1、创建对象的步骤
1、将需要创建的对象所属的类，加载到方法区
2、在栈内存中，创建该类型的引用
3、在堆内存中开辟对象的空间
4、给对象的属性进行赋值（默认的初始化值）
5、将对象的地址，赋值给栈内存中的引用
2、图示：
代码示例
class Demo07_CarTest {
public static void main(String[] args) {
Car c1 = new Car();
c1.color = "red";
c1.num = 4;
c1.run();
Car c2 = new Car();
c2.color = "yellow";
c2.num = 8;
c2.run();
}
}
/*
定义一个汽车类
属性：颜色（color），轮胎个数（num）
行为：跑（run：显示当前汽车对象的颜色和轮胎个数）
在测试类中，创建两个汽车对象，分别赋值不同的颜色和轮胎个数，访问属性和方法
*/
class Car {
String color;
int num;
public void run() {
System.out.println(color + "..." + num);
}
}
两个引用指向同一个对象的内存图
代码示例
class Demo08_CarTest2 {
public static void main(String[] args) {
Car c1 = new Car();
c1.color = "black";
c1.num = 4;
Car c2 = c1;
c1.color = "yellow";
c2.run();
c1.run();
}
}
面向对象其他内容
成员变量和局部变量的比较
1、概念：
成员变量：类中的所有内容都是成员，定义在类中的变量，就是成员变量
局部变量：定义在方法中的变量，就是局部变量
2、不同点：
1、代码层面：定义位置不同
成员变量定义在类中方法外
局部变量定义在方法中，或者方法的声明上（参数列表中的形式参数）
2、内存方面，空间位置不同
成员变量属于对象，存储在堆内存的对象中
局部变量属于方法，存储在栈内存的当前方法的栈帧中
3、内存方面，时间不同，生命周期不同
成员变量属于对象，和对象的生命周期相同，随着对象的创建而创建，随着对象的 消失而消失（对象在你new的时候就创建，没有任何引用指向这个对象的时候， 这个对象就会消失）
局部变量属于方法，和方法的生命周期相同，随着方法被调用而存在，随着方法的 执行结束而消失
4、初始状态不同：初始化值的不同
局部变量：没有默认的初始化值，必须先手动赋值，然后才能使用
成员变量：有默认的初始化值，根据数据类型的不同，有不同的默认值
引用数据类型：null
基本数据类型：
整数类型：0
小数类型：0.0
布尔类型：false
字符类型：’\u0000’
方法的形式参数是引用数据类型
1、方法的形式参数，既可以是基本数据类型，也可以是引用数据类型
2、引用数据类型：类、接口、枚举、数组
3、当方法的参数列表是引用数据类型的时候，其实是在方法中声明了一个引用类型的变量，将来在调用这个方法的时候，需要由调用者将一个对象的地址传入该方法的形式参数的引用变量中。
4、画图理解：
代码示例
class Demo09_MobileTest {
public static void main(String[] args) {
Mobile m = new Mobile();
m.brand = "华为";
m.price = 4321;
useMobile(m);
}
public static void useMobile(Mobile m) {
m.show();
}
}
class Mobile {
String brand;
int price;
public void show() {
System.out.println(brand + "..." + price);
}
}
方法的返回值类型是引用数据类型
1、方法的返回值类型，既可以是基本数据类型，也可以是引用数据类型
2、如果方法的返回值类型是引用数据类型，其实返回的是某个对象的地址
3、画图理解：
代码示例
class Demo10_MobileTest {
public static void main(String[] args) {
Mobile m = createMobile();
m.show();
}
public static Mobile createMobile() {
Mobile m = new Mobile();
m.brand = "小米";
m.price = 2222;
return m;
}
}
匿名对象的创建和使用
1、没有名字的对象
2、创建格式：
new 类名();
3、匿名对象的使用场景：
1、匿名对象中的方法，只调用一次。不需要在栈内存中，开辟引用的空间，可以直接调用对象的方法。如果使用不止一次，就不要使用匿名对象
2、匿名对象可以作为方法的实际参数进行传递
3、匿名对象可以作为方法的返回值进行返回
4、匿名对象的注意事项：
匿名对象可以给成员变量赋值，但是没有任何意义，因为一旦赋值完成，这个对象就变成了垃圾，被回收掉了。
代码示例
import java.util.Scanner;
class Demo11_匿名对象的使用 {
public static void main(String[] args) {
Person p = new Person();
p.eat();
new Person().eat();
//int x = new Scanner(System.in).nextInt();
//int y = new Scanner(System.in).nextInt();
//System.out.println(x * x);
//匿名对象作为方法的实际参数进行传递
playMobile(new Mobile());
Mobile m = makeMobile();
m.show();
new Mobile().brand = "oppo";//第一个对象赋值完成之后，很快被回收
new Mobile().price = 3333;//第二个对象赋值完成之后，很快被回收
//第三个和第四个对象并没有被赋值，打印结果就是null...0
System.out.println(new Mobile().brand + "..." + new Mobile().price);
}
public static void playMobile(Mobile m) {//Mobile m = new Mobile();
m.show();
}
public static Mobile makeMobile() {
//匿名对象作为方法的返回值进行返回
return new Mobile();
}
}