面向对象初识

面向对象初识

1. 生活中的面向对象和面向过程对比

烤羊排:
	a. 找一个卖烤羊排的店铺
		1. 导航到店铺
		2. 找个位置，点菜烤羊排
		3. 等
		4. 吃 埋单
		5. 走
		
	b. 自己做
		1. 买羊排 ==> 宁夏盐滩羊
		2. 准备的调料 ==> 葱，姜，蒜，皮牙子，孜然，辣椒，盐
		3. 半扇羊排焯水(葱，姜，蒜)，打去浮沫，煮 15 分钟
		4. 烤制 烤盘铺锡纸 
			烤箱预热 5 分钟(220 上下火) 
			220度上下火 15 分钟 翻面 10 分钟 190度
		5. 出炉
		6. 孜然，辣椒，盐 蘸料开吃
		7. 打扫卫生

卤牛肉	
	a. 找个熟食店购买
		一斤 85 ~ 95
		一切打包带走
		吃
		
	b. 自己做
		1. 买牛肉(牛腩，上脑)
		2. 调料
			小茴香，八角，肉蔻，草果，花椒，麻椒，干辣椒，桂皮，香叶，白芷 
			白酒 老抽 生抽 黄豆酱 耗油 冰糖 葱，姜，蒜，料酒
		3. 牛肉 冷水下锅，焯水(葱，姜，料酒)
		4. 香料先泡水，捞出，泡酒
		5. 炒糖色，下葱，姜，蒜炒制，下香料(酒)，酱油炒，牛肉下！！！加热水
		6. 老抽调色，盐，黄豆酱，耗油，葱段，蒜粒，冰糖
		7. 高压锅 35 分钟 / 小火炖 50 分钟
		8. 肉捞出，卤汁过滤保存
		9. 吃！！！拌面，拌饭

面向对象
	找合适的人，办合适的事
面向过程
	亲力亲为，自力更生

2. 类和对象

类	对象
人类	吕布，貂蝉，雷军，乔布斯，马云，麻花藤，何同学，彭于晏，Faker
猫类	八九，汤姆，哆啦A梦，黑猫警长，贝斯特，虹猫，噬元兽，浩东家的虎妞
狗类	八公，哮天犬，大黄，豆豆，糯米，神犬小七
汽车类	磊哥的领克01，万峰的车，蝙蝠侠的蝙蝠战车，变形金刚里的大黄蜂，擎天柱，车牌号豫A16T1T的车

类:
	针对于一类事物的描述，包括属性描述和行为描述
    人类为例
    	属性描述: 身高，体重，年龄，姓名，性别，发量	
    	行为描述: 吃饭，睡觉，写代码，打游戏

对象:
	具体的，唯一的，独立的，特殊的个体

3. Java 中定义类的格式【重点】

格式:
	class 类名 {
		属性描述
			采用变量形式，存储对应的数据，进行属性描述
			【Field 成员变量】
		行为描述
			采用方法形式，使用方法声明明确方法所需参数和返回值信息，同时完成对应的功能。
			【Method 成员方法】
	}
	类名有什么要求:
		见名知意。大驼峰命名法

3.1 Java定义类之成员变量

class Person {
	/* 属性描述 ==> 【Field 成员变量】 */
	/*
	id 成员变量，数据类型为 int 类型，用于描述当前类对应对象的 id 属性
	id 成员变量对应的具体数据，需要在创建对象之后给予赋值操作者
	*/
	int id;
	
	/*
	name 成员变量，数据类型为 String 字符类型，用于描述当前类对应对象的
	name 属性，当前 Person 对象 人类对象的姓名
	*/
	String name;
	
	/*
	age 成员变量，数据类型为 int 类型，用于描述当前类对应的 age 属性
	age ==> 年龄
	*/
	int age;
}

3.2 Java 定义类之成员方法

/**
* 自定义类，当前类没有使用 public 关键字
* 类名和文件名不一致，
* Person 类型，类名符合见名知意，大驼峰命名法
*/
class Person {
	/* 行为描述 ==> 【Method 成员方法】 */
	/**
	* Person 类吃饭(eat)行为描述，参数为字符串类型，要求用户调用时
	* 提供字符串类型参数，告知吃什么食物
	*
	* @param food 食物的名称 String 字符串类型
	*/
	public void eat(String food) {
		System.out.println("今天吃" + food);
	}
	
	/**
	* Person 类睡觉(sleep)行为描述
	*/
	public void sleep() {
		System.out.println("说出来你可能不信，我被床封印了");
	}
	
	/**
	* Person 类编程/写代码(coding)行为描述
	*/
	public void coding() {
		System.out.println("键盘敲烂，月薪过万");
	}
}

3.3 Java 创建对象方式

比葫芦画瓢s
	Scanner sc = new Scanner(System.in);

必须清楚的知识点:
	1. Java 开发中存在 名称+小括号 的结构，除分支循环之外，都是方法
    	sleep(); eat(String food); coding();
    2. Java 中首字母大写的标识符，按照规定只能是 类名，接口名
   
拆分 Scanner 扫描器创建过程:
	Scanner:
		类名，数据类型名，表示当前创建的是 Scanner 类对应对象。或者说创建的对象数据类型为 Scanner 类型
	sc:
		对象名称，变量名称，同时也是一个【引用数据类型】
	new:
		1. 根据当前数据类型所需，在内存的【堆区】申请对应的内存空间。
			补充：创建对象时根据【构造方法】的名称，明确当前申请空间对应的数据类型是哪一个类型，
			从而确定数据类型占用的空间大小
		2. new 关键字会将申请的内存空间中所有数据内容全部清除干净
	Scanner(实际参数);
		Scanner() 构造方法，构造方法要求方法名必须是类名，用于在创建对象的过程中，明确创建对象的数据类型。
		而且在 Java 代码中，有且只允许构造方法使用类名，其他方法一律不允许！！！

目前创建对象格式
	类名 对象名 = new 构造方法(实际参数);

/*
创建对象/实例化对象的格式:
	类名 对象名 = new 构造方法(所需参数);
*/
Person p1 = new Person();

/*
Person@15db9742
	Person 是类型描述，表示当前对象对应的数据类型是什么
	@ 在哪里！！！
	15db9742 十六进制，是当前对象在内存空间的地址。门牌号(银屏路25号)
*/
System.out.println(p1);

3.4 通过对象操作成员变量赋值/取值

比葫芦画瓢:
	int[] arr = new int[10];
	arr.length ==> 得到数组的容量
	. ==> 的

对象操作成员变量赋值/取值格式
	对象名.成员变量
		可以执行赋值操作，也可以进行取值操作

/*
Person 类对象操作成员变量
	目前 Person 类内对应的成员变量有
		int id; String name; int age;
格式:
	类对象.成员变量
*/
// 通过类对象操作成员变量赋值操作 磊哥花名：骚磊，苟磊，狗磊，狗鸽，蛋哥，蛋总，臀哥，翘臀
p1.id = 1;
p1.name = "苟磊";
p1.age = 16;

// 通过类对象操作成员变量取值操作
System.out.println("ID: " + p1.id);
System.out.println("Name: " + p1.name);
System.out.println("Age: " + p1.age);

3.5 通过对象调用成员方法

比葫芦画瓢:	
	Scanner sc = new Scanner(System.in);
	
	int类型数据 = sc.nextInt();
	double类型数据 = sc.nextDouble();
	float类型数据 = sc.nextFloat();

通过对象调用成员方法的格式:
	对象.方法名(实际参数);

/*
Person 对象调用执行成员方法
	对象.成员方法();
	目前 Person 类内对应的成员方法有
		void eat(String); void sleep(); void coding();
*/
// 通过 Person 对象 p1 调用 eat 方法，方法所需参数为 String 类型
p1.eat("土豆丝+豆芽+烙馍");
p1.sleep();
p1.coding();

4. 构造方法【鸡肋】

4.1 Java 编译器提供的无参数构造方法

【发现】
	1. 在当前的案例代码中，并没有对应的无参数构造方法，在代码中却可以直接调用。
	2. Demo1.java 编译之后，在结果中发现有两个 .class 字节码文件，分别是 Demo1.class 和 Person.class
		因为在 Demo1.java 文件中有两个 class，每一个类/class 都会生成对应的 .class 字节码文件, .class
		字节码文件中包含完整的参与运行的代码内容。 

【反编译 .class 文件】
	给到一些必要的信息，提供给程序员分析代码参与执行的内容

javap -c -l -private XXX.class

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7i1lV0k6-1667227064820)(img/01-Java编译器提供的无参数构造方法.png)]

【注意】
	Java 编译器是发现当前类没有自己声明/定义构造方法，会自动提供一个无参数构造方法供程序员使用，如果当前 Java 代码中存在任意一个构造方法，Java 编译器不再提供对应的无参数构造方法。

4.2 Java 中构造方法

构造方法的作用：
	1. 构造方法的名称必须是类名，用于提供给 new 关键字使用，明确当前实例化/创建的对象对应的数据类型是什么类型
	2. 构造方法有且只有【初始化】 new 关键字 + 构造方法 实例化/创建 对象数据内容功能。

构造方法格式:
	public 类名(初始化操作必要的参数) {
		初始化赋值语句，给予成员变量赋值操作。
	}

4.3 构造方法案例

/**
* 自定义类型，SingleDog 类
*/
class SingleDog {
	// Single 成员变量
	int id;
	String name;
	int age;
	
	// 无参构造方法
	public SingleDog() {
		System.out.println("无参数构造方法，所有的成员变量都没有初始化，完全对应无数据情况");
	}
	
	// 带有 String 类型参数的构造方法， 用于初始化 name 成员变量
	public SingleDog(String n) {
		/*
		name 是 SingleDog 类的成员变量 String 类型
		n 是构造方法参数，String 类型
		*/
		name = n;
		System.out.println("String 类型参数构造方法，仅初始化 name 成员变量数据内容");
	}
	
	// 带有 int, String 类型参数的构造方法，用于初始化 id，name 成员变量
	public SingleDog(int i, String n) {
		/*
		使用构造方法参数 int 类型 i 给予成员变量 id 赋值操作
		*/
		id = i;
		/*
		使用构造方法参数 String 类型 n 给予成员变量 name 赋值操作
		*/
		name = n;
		System.out.println("int, String 类型参数构造方法，仅初始化 id, name 成员变量数据内容");
	}
	
	// 带有 int, String, int 类型参数的构造方法，用于初始化 id，name，age 成员变量
	public SingleDog(int i, String n, int a) {
		/*
		使用构造方法参数 int 类型 i 给予成员变量 id 赋值操作
		*/
		id = i;
		/*
		使用构造方法参数 String 类型 n 给予成员变量 name 赋值操作
		*/
		name = n;
		/*
		使用构造方法参数 int 类型 a 给予成员变量 age 赋值操作
		*/
		age = a;
		System.out.println("int, String, int 类型参数构造方法，仅初始化 id, name, age 成员变量数据内容");
	}
	
}

public class Demo2 {
	public static void main(String[] args) {
		/* 
		new 关键字 + 无参数构造方法，
		实例化/创建 SingleDog 对象，对象名为 sd1
		*/
		SingleDog sd1 = new SingleDog();
		
		// 展示 sd1 对象成员变数据内容
		System.out.println("sd1 id: " + sd1.id);
		System.out.println("sd1 name: " + sd1.name);
		System.out.println("sd1 age: " + sd1.age);
		System.out.println();
		
		/*
		new 关键字 + String 类型参数的构造方法
		实例化/创建 SingleDog 对象，对象名为 sd2
		*/
		SingleDog sd2 = new SingleDog("张三");
		
		// 展示 sd2 对象成员变数据内容
		System.out.println("sd2 id: " + sd2.id);
		System.out.println("sd2 name: " + sd2.name);
		System.out.println("sd2 age: " + sd2.age);
		System.out.println();
		
		/*
		new 关键字 + int， String 类型参数构造方法
		实例化/创建 SingleDog 对象，对象名为 sd3
		*/
		SingleDog sd3 = new SingleDog(1, "张三");
		
		// 展示 sd3 对象成员变量数据内容
		System.out.println("sd3 id: " + sd3.id);
		System.out.println("sd3 name: " + sd3.name);
		System.out.println("sd3 age: " + sd3.age);
		System.out.println();
		
		/*
		new 关键字 + int， String，int 类型参数构造方法
		实例化/创建 SingleDog 对象，对象名为 sd4
		*/
		SingleDog sd4 = new SingleDog(1, "张三", 20);
		
		// 展示 sd3 对象成员变量数据内容
		System.out.println("sd4 id: " + sd4.id);
		System.out.println("sd4 name: " + sd4.name);
		System.out.println("sd4 age: " + sd4.age);
		System.out.println();
	}
}

4.4 构造方法总结

1. 构造方法格式
	public 类名(必要参数) {
		成员变量赋值语句;
	}

2. 实例化/创建对象的格式
	类名 对象名 = new 构造方法(实际参数);

3. 实例化对象/创建对象 是由 new + 构造方法 完成
	a. new 关键字根据构造方法名称，明确对应数据类型，在内存【堆区】申请对应的空间
	b. new 关键字将申请的空间进行清理数据，打扫卫生
	c. 构造方法利用参数内容和赋值语句，给予成员变量赋值操作

5. 对象内存分析图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h8JIADds-1667227064822)(img/02-对象内存分析图.png)]

6. 作业-十二生肖【重点重点重点】

要求:
	1. 每一个类对应三个或者三个以上成员变量
	2. 每一个类对应三个或者三个以上成员方法，必须保证有一个成员方法至少有一个参数
	3. 每一个类必须有三个或者三个以上的构造方法，并且强制要求有一个无参数构造方法
	4.【重点】成员变量名称所有类不可重复
		例如:
			Tiger name 成员变量描述名字，其他的 十一个生肖没有名字
	5.【重点】成员方法名称所有类不可重复
		例如:
			Tiger sleep() 成员方法描述睡觉行为，其他 十一个生肖不能睡觉
	6. 每一个类单独一个文件
		文件名:
			Demo1.java  
				==> public class Demo1
				==> class Tiger
	7. 每一个类必须使用所有构造方法，创建对应对象，并且使用创建对象，调用所有成员变量数据进行展示，和所有成员方法进行执行。
	8. 每一个方法，必须有对应的标准文档注释！！！

以上代码会完成
	1. 12 类
	2. 36个 成员变量 36个 成员方法 36个 构造方法
	3. new 对象 过程 36 次
		调用成员变量 108 次
		调用成员方法 108 次

class Cat {
	// 每一个类提供三个或者三个以上成员变量，12生肖不允许重复成员内容。
	String name;
	int age;
	char gender;
	
	// 每一个类提供三个或者三个以上的构造方法，必须有无参数构造方法。
	/**
	* Cat 类无参数构造方法
	*/
	public Cat() {}
	
	/**
	* 初始化 name 成员变量构造方法
	*
	* @param name String 类型参数用于初始化 name 成员变量
	*/
	public Cat(String n) {
		name = n;
	}
	
	/**
	* 初始化 name , age, gender 成员变量构造方法
	*
	* @param name   String 类型参数用于初始化 name 成员变量
	* @param age    int 类型参数用于初始化 age 成员变量
	* @param gender char 类型参数用于初始化 gender 成员变量
	*/
	public Cat(String n, int a, char g) {
		name = n;
		age = a;
		gender = g;
	}
	
	// 每一个类提供三个或者三个以上成员方法，12生肖不允许重复成员方法内容
	/**
	* 吃饭行为描述
	*
	* @param food 食物
	*/
	public void eat(String food) {
		System.out.println("可爱的小猫咪吃" + food);
	}
	
	/**
	* 玩耍行为描述
	*/
	public void play() {
		System.out.println("猫玩球");
	}
	
	/**
	* 睡觉行为描述
	*/
	public void sleep() {
		System.out.println("猫仰天大睡");
	}
}

public class Demo3 {
	public static void main(String[] args) {
		// 利用三个构造方法，分别创建对应的对象
		Cat cat1 = new Cat();
		Cat cat2 = new Cat("八九");
		Cat cat3 = new Cat("八九", 3, '母');
		
		// 利用三个对象，分别展示其中的数据保存情况，并且调用成员方法
		System.out.println("Name:" + cat1.name);
		System.out.println("Age:" + cat1.age);
		System.out.println("Gender:" + cat1.gender);
		cat1.eat("罐头");
		cat1.play();
		cat1.sleep();
		System.out.println();
		
		System.out.println("Name:" + cat2.name);
		System.out.println("Age:" + cat2.age);
		System.out.println("Gender:" + cat2.gender);
		cat2.eat("罐头");
		cat2.play();
		cat2.sleep();
		System.out.println();
		
		System.out.println("Name:" + cat3.name);
		System.out.println("Age:" + cat3.age);
		System.out.println("Gender:" + cat3.gender);
		cat3.eat("罐头");
		cat3.play();
		cat3.sleep();
		System.out.println();
	} 
}

ender);
cat1.eat(“罐头”);
cat1.play();
cat1.sleep();
System.out.println();

	System.out.println("Name:" + cat2.name);
	System.out.println("Age:" + cat2.age);
	System.out.println("Gender:" + cat2.gender);
	cat2.eat("罐头");
	cat2.play();
	cat2.sleep();
	System.out.println();
	
	System.out.println("Name:" + cat3.name);
	System.out.println("Age:" + cat3.age);
	System.out.println("Gender:" + cat3.gender);
	cat3.eat("罐头");
	cat3.play();
	cat3.sleep();
	System.out.println();
} 

}