Java类与对象

引出

●看一个养猫猫问题

张老太养了两只猫猫: 一只名字叫小白, 今年3岁, 白色. 还有一只叫小花, 今年100岁, 花色. 请编写一个程序, 当用户输入小猫的名字时, 就显示该猫的名字, 年龄, 颜色. 如果用户输入的小猫名字错误, 则显示 张老太没有这只猫咪.

●使用现有技术解决 Object01.java

import java.util.Scanner;

public class Object01 {
    //编写一个main方法
    public static void main(String[] args) {
    	/*
    	张老太养了两只猫猫: 一只名字叫小白, 今年3岁, 白色. 体重, 爱好
    	还有一只叫小花, 今年100岁, 花色. 请编写一个程序, 
    	当用户输入小猫的名字时, 就显示该猫的名字, 年龄, 颜色. 
    	如果用户输入的小猫名字错误, 则显示 张老太没有这只猫咪.

		//思路分析
    	1.单独定义变量 -> 不利于数据的管理(你把一只猫的信息拆解)
    	2.创建Scanner对象, 接收用户输入
    	 */
    	
    	//代码实现
    	//第一只猫信息
    	String cat1Name = "小白";
    	int cat1Age = 3;
    	String cat1Color = "白色";
    	//第二只猫信息
    	String cat2Name = "小花";
    	int cat2Age = 100;
    	String cat2Color = "花色";
    	
    	Scanner myScanner = new Scanner(System.in);
    	System.out.print("输入小猫的名字: ");
    	String catName = myScanne r.next();

    	//数组 ==> (1)数据类型体现不出来  (数组是多个相同类型数据的组合)
    	//		   (2)只能通过[下标]获取信息, 造成变量名字和内容的对应关系不明确
    	//		   (3)不能体现猫的行为
    	//第1只猫信息
    	String[] cat1 = {"小白", "3", "白色"}; cat1[]
    	String[] cat2 = {"小花", "100", "花色"};
	}  
}

●现有技术解决的缺点分析

不利于数据的管理
效率低 ⇒ 引出我们的新知识点, 类与对象
有很多书视频甚至还提到哲学,道家思想,形而上思想,才引出类与对象, 其实没那么复杂. java语言设计设去设计类与对象, 其实是特别简单的思想.

java设计者 引入类与对象(OOP), 根本原因就是现有的技术, 不能完美地解决新的需求

其实就是这么一点东西, 但是往往我们会把一些技术理解的过于神秘, 跟着学有关系~ 跟道家思想有关系~ 都是没有意思的

概念

一个程序就是一个世界, 有很多事物 (对象[属性, 行为])

●类与对象的关系示意图

1.把一种事物的共性(属性)提取出来,形成的一个叫做类的数据类型.

2.这个数据类型就是我们自定义的数据类型谁定义的? 程序员定义的

快速入门

●面向对象的方式解决养猫问题 Object01.java

public class Object01 {
    //编写一个main方法
    public static void main(String[] args) {
    	//使用OOP面向对象解决
    	//实例化一只猫[创建一只猫对象]
    	//解读
    	//1.new Cat() 创建一只猫
    	//2.Cat cat1 = new Cat(); 把创建的猫 赋给 cat1
    	//3.cat1 就是一个对象(猫对象)
    	Cat cat1 = new Cat();
    	cat1.name = "小白";
    	cat1.age = 3;
    	cat1. color = "白色";
    	cat1.weight = 2;
    	//创建第二只猫, 并赋给 cat2
    	//cat2也是一个对象(猫对象)
    	Cat cat2 = new Cat();
    	cat2.name = "小花";
    	cat2.age = 100;
    	cat2.color = "花色";
    	cat2.weight = 3;

    	//怎么访问对象的 属性 呢
    	System.out.println("第一只猫信息: " + cat1.name + " " 
    		+ cat1.age + " " + cat1.color + " " + cat1.weight);
    	System.out.print("第二只猫信息: " + cat2.name + " " 
    		+ cat2.age + " " + cat2.color + " " + cat2.weight);

	}  
}


//使用面向对象的方式解决养猫问题
//定义一个猫类 -> 自定义的数据类型
class Cat {
	//属性
	String name;//名字
	int age;//年龄
	String color;//颜色
	double weight;//体重

	//行为

}

●类和对象的区别和联系

通过上面的案例和讲解我们可以看出:
1)类是抽象的, 概念的, 代表一类事物, 比如人类, 猫类…, 即它是数据类型
2)对象是具体的, 实际的, 代表一个具体事物, 即 是实例
3)类是对象的模板, 对象是类的一个个体, 对应一个实例.

对象内存布局

●对象在内存中的存在形式

属性概念

●属性/成员变量

√ 基本介绍 Object02.java
1.从概念或叫法上看: 成员变量 = 属性 = field字段 (即 成员变量是用来表示属性的, 这里, 统一叫 属性)
2.属性是类的一个组成部分, 一般是基本数据类型, 也可以是引用类型(对象, 数组). 比如我们前面定义猫类 的 int age 就是属性.

public class Object02 {
    //编写一个main方法
    public static void main(String[] args) {

    }
}

class Car {
    String name;//属性, 成员变量, 字段 field
    double price;
    String color;
    String[] master;//属性可以是基本数据类型, 也可以是引用类型(对象, 数组)
}

√ 注意事项和使用细节 PropertiesDetail.java
1)属性的定义语法同变量不同, 实例: 访问修饰符 属性类型 属性名;
   这里简单地介绍一下访问修饰符: 控制属性的访问范围
   有4种访问修饰符 public protected 默认 private, 后面再详细学习
2)属性的定义类型可以是任意类型, 包含基本类型和引用类型

3)属性如果不赋值, 有默认值, 规则和数组一样
   byte 0, short 0, int 0, long 0
   float 0.0, double 0.0
   char ‘\u0000’, boolean false
   String null
4)

public class PropertiesDetail {
    //编写一个main方法
    public static void main(String[] args) {
    	//创建Person对象
    	//p1 是对象名(对象引用)
    	//new Person() 创建的对象空间(包括数据) 才是真正的对象
    	Person p1 = new Person();

    	//对象属性的默认值, 遵守数组的规则
	    /*
	     byte 0, short 0, int 0, long 0
	     float 0.0, double 0.0
	     char ‘\u0000’, boolean false
	     String null
	    */
	   System.out.println("当前这个人的信息");
	   System.out.println("age=" + p1.age + " name=" + p1.name + " sal=" + 
	   		p1.sal + " isPass=" + p1.isPass);
    }
}

class Person {
	//四个属性
	int age;
	String name;
	double sal;
	boolean isPass;
}

创建对象访问属性

●如何创建对象

1.先声明再创建
Cat cat; //声明对象 cat
cat = new Cat(); //创建

2.直接创建
Cat cat = new Cat();


●如何访问属性
√ 基本语法
对象名.属性名;
cat.name;
cat.age;
cat.color;

对象分配机制

●类和对象的内存分配机制(重要)

√ 看一个思考题 Object03.java
我们定义一个人类(Person)(包括 名字, 年龄)

我们看看下面一段代码
Person p1 = new Person();
p1.age = 10;
p1.name = “小明”;
Person p2 = p1;//把p1 赋给了 p2; 让p2指向p1
System.out.println(p2.age);

请问: p2.age究竟是多少? 并画出内存图.

public class Object03 {
    //编写一个main方法
    public static void main(String[] args) {
    	Person p1 = new Person();
		p1.age = 10;
		p1.name = "小明";
		Person p2 = p1;//把p1 赋给了 p2; 让p2指向p1
		System.out.println(p2.age); 
    }
}

class Person {
	int age;
	String name;
}

√ Java内存结构分析

1. 栈: 一般存放基本数据类型(局部变量)
2. 堆: 存放对象(Cat cat, 数组等)
3. 方法区: 常量池(常量, 比如字符串), 类加载信息
4. 示意图[Person(age, name)]
   

√ Java创建对象的流程简单分析
Person p = new Person();
p.name = “jack”;
p.age = 10;
1.先加载Person类信息(属性和方法信息, 只会加载一次)
2.在堆中分配空间, 进行默认初始化[看规则]
3.把地址赋给 p, p 就指向对象
4.进行指定初始化, 比如 p.name = “jack”; p.age = 10


√ 看一个练习题, 并分析画出内存布局图, 进行分析
//我们看看下面一段代码, 会输出什么信息
Person a = new Person();
a.name = “小明”;
a.age = 10;
Person b;
b = a;
System.out.println(b.name);//小明
b.age = 200;
b = null;
System.out.println(a.age);//200
System.out.println(b.age);//报错

public class Object03 {
    //编写一个main方法
    public static void main(String[] args) {
    	/*Person p1 = new Person();
		p1.age = 10;
		p1.name = "小明";
		Person p2 = p1;//把p1 赋给了 p2; 让p2指向p1
		System.out.println(p2.age);*/ 
		Person a = new Person();
		a.name = "小明";
		a.age = 10;
		Person b;
		b = a;
		System.out.println(b.name);//小明
		b.age = 200;
		b = null;
		System.out.println(a.age);//200
		System.out.println(b.age);//报错
    }
}

class Person {
	int age;
	String name;
}

成员方法

●基本介绍
在某些情况下, 我们需要定义成员方法(简称方法). 比如人类: 除了有一些属性外(年龄, 姓名…), 我们人类还有一些行为比如: 可以说话, 跑步…通过学习, 还可以做算术题. 这时就要用成员方法才能完成. 现在要求对Person类完善.

●成员方法快速入门 Method01.java
1)添加speak 成员方法, 输出 我是一个好人
2)添加cal01 成员方法, 可以计算从 1 + … + 1000 的结果
3)添加cal02 成员方法, 该方法可以接收一个数n, 计算从 1 + … + n 的结果
4)添加getSum 成员方法, 可以计算两个数的和

public class Method01 {
    //编写一个main方法
    public static void main(String[] args) {
    	//方法使用
    	//1. 方法写好后, 如果不去调用(使用), 不会输出
 		//2. 先创建对象, 然后调用方法即可
 		Person p1 = new Person();
 		p1.speak();//调用方法
 		p1.cal01();//调用cal01方法
 		p1.cal02(5);//调用cal02方法, 同时给n = 5
 		p1.cal02(10);//调用cal02方法, 同时给n = 10

 		//调用getSum方法, 同时num1=10, num2=20
 		//把 方法 getSum 返回的值, 赋给 变量 returnRes
 		int returnRes = p1.getSum(40, 20);
 		System.out.println("getSum方法返回的值=" + returnRes);
    }
}

class Person {
	int age;
	String name;

	//方法(成员方法)
	//添加speak 成员方法, 输出 我是一个好人
	//解读
	//1. public 表示方法是公开的
	//2. void : 表示方法没有返回值
	//3. speak() : speak是方法名 ()是形参列表
	//4. {} 方法体, 可以写我们要执行的代码
	//5. System.out.println("我是一个好人"); 表示我们的方法就是输出一句话
	public void speak() {
		System.out.println("我是一个好人");
	}

	//添加cal01 成员方法, 可以计算从 1 + ... + 1000 的结果
	public void cal01() {
		/*
		可以用循环语句
		1.循环1-1000
		2.定义一个变量 int sum, 累积求和
		 */
		int sum = 0;
		for (int i = 1; i <= 1000; i++) {
			sum += i;
		}
		System.out.println("cal01方法 计算结果=" + sum);
	}

	//添加cal02 成员方法, 该方法可以接收一个数n, 计算从 1 + ... + n 的结果
	//解读
	//1. (int n) 形参列表, 表示当前有一个形参 n, 可以接收用户输入
	public void cal02(int n) {
		//循环完成
		int sum = 0;
		for (int i = 1; i <= n; i++) {
			sum += i;
		}
		System.out.println("cal02方法 计算结果=" + sum);
	}

	//添加getSum 成员方法, 可以计算两个数的和
	//解读
	//1. public 表示方法是公开的
	//2. int : 表示方法执行后, 返回一个 int值
	//3. getSum 方法名
	//4. (int num1, int num2) 形参列表, 2个形参, 可以接收用户传入的两个数
	//5. return res; 表示把 res 的值, 返回
	public int getSum(int num1, int num2) {
		int res = num1 + num2;
		return res;
	}
}

●方法的调用机制原理
画出程序执行过程[getSum]+说明

●为什么需要成员方法 Method02.java
√ 看一个需求:
请遍历一个数组, 输出数组的各个元素值 int[][] map = {{0, 0, 1}, {1, 1, 1}, {1, 1, 3}};
√ 解决思路1: 传统的方法, 就是使用单个for循环, 将数组输出, 大家看看问题是什么?
√ 解决思路2: 定义一个类 MyTools, 然后写一个成员方法, 调用方法实现, 看看效果又如何.

●成员方法的好处
√ 提高代码的复用性
√ 可以将实现的细节封装起来, 然后供其它用户来调用即可


●成员方法的定义

访问修饰符[public…] 返回数据类型 方法名 (参数列表…) {//方法体
         语句;
         return 返回值;
}

1.形参列表: 表示成员方法输入 cal(int n), getSum(int num1 int num2)
2.返回数据类型: 表示成员方法输出, void 表示没有返回值
3.方法主体: 表示为了实现某一功能代码块
4.return 语句不是必须的
5.温馨提示: 结合前面的示意图, 理解.

注意事项和细节

●注意事项和细节 MethodDetail.java

√ 访问修饰符 (作用是控制 方法使用的范围)
如果不写是默认访问修饰符. [有4种: public, protected, 默认, private]

√ 返回数据类型
1.一个方法最多只有一个返回值 [思考, 如何返回多个结果. 可以返回数组]
2.