0428面向对象2.0

面向对象2.0

【要点】

public 修饰的类要和文件名一致
封装的意义
构造方法创建
this关键字
JavaBean规范
类之间合作

1. 构造方法【鸡肋】

1.1 作用

	用于在开发过程中创建对象使用，创建对象目前的格式
	new 类名(有可能使用到的参数);
	
	类名(有可能使用到的参数); 这就是构造方法 Constructor
	
	构造防范可以初始化当前创建对象中的成员变量数据！！！

1.2 格式

格式:
	public 类名(所需初始化参数列表) {
		初始化语句;
	}
细节:
	1. 构造方法的名字必须是类名，并且其他方法的名字不能是类名
	2. 构造方法没有返回值类型声明
	3. 初始化参数列表和正常的方法列表操作使用一致
	4. 初始化语句，大多数是都是一些赋值语句

1.3 貌似我们昨天没有写构造方法，但是我们用了[了解]

首先
	在Eclipse项目所在文件夹中，bin目录是存放当前Java程序对应的所有的.class 二进制文件(字节码文件)，该文件保存了Java文件对应的所有内容
	这里可以通过反编译工具看到一些特定的现象 [了解]
	javap -c -l -private XXX.class

Java编译器行为
	在代码中任何没有【显式】自行声明构造方法，Java编译器会在编译代码的过程中辅助程序员完成一个【无参数的构造方法】，供程序员使用

1.4 根据需求完成所需构造方法

格式:
	public 类名(所需初始化参数列表) {
		初始化语句;
	}
需求:
	1. 完成对于姓名在创建对像时初始化的构造方法
	2. 完成对于姓名，年龄创建对象时初始化的构造方法
	2. 完成对于姓名，年龄，性别创建对象时初始化的构造方法	
	
注意:
	如果在代码中程序员自行完成了构造方法，Java编译器不再提供自动生成的无参数构造方法。

【强制要求】
	以后代码中无论什么时候都要给用户提供一个无参数构造方法使用

package com.qfedu.a.constructor;

class Dog {
	// 成员变量 Field
	String name;
	int age;
	char gender;
	
	// 无参数构造方法
	public Dog() {}
	
	// 完成对于姓名在创建对像时初始化的构造方法
	public Dog(String n) {
		// 成员变量可以在类内其他中直接使用【80%正确】
		name = n;
	}
	
	// 完成对于姓名，年龄创建对象时初始化的构造方法
	public Dog(String n, int a) {
		name = n;
		age = a;
	}
	
	// 完成对于姓名，年龄，性别创建对象时初始化的构造方法	
	public Dog(String n, int a, char g) {
		name = n;
		age = a;
		gender = g;
	} 
	
	// 成员方法 Method
	public void eat() {
		System.out.println("狗狗吃狗粮");
	}
	
	public void game() {
		System.out.println("狗狗玩球");
	}
	
	public void sleep() {
		System.out.println("狗狗作息非常规律");
	}
}

public class Demo1 {
	public static void main(String[] args) {
		/*
		 *  这里调用的是一个无参数构造构造方法
		 *  但是该方法在Dog类内是没有定义的！！！
		 *  
		 *  以后使用比较多的情况大多数都是无参数构造方法
		 *  
		 *  The constructor Dog() is undefined
		 *  构造方法Dog()未定义
		 */
		// 无参数构造方法
		Dog dog = new Dog();
		System.out.println("Name:" + dog.name);
		System.out.println("Age:" + dog.age);
		System.out.println("Gender:" + dog.gender);
		
		System.out.println("-------------------------------");
		
		Dog dog2 = new Dog("骚杰");
		System.out.println("Name:" + dog2.name);
		System.out.println("Age:" + dog2.age);
		System.out.println("Gender:" + dog2.gender);
		
		System.out.println("-------------------------------");

		Dog dog3 = new Dog("骚杰", 66);
		System.out.println("Name:" + dog3.name);
		System.out.println("Age:" + dog3.age);
		System.out.println("Gender:" + dog3.gender);
		
		System.out.println("-------------------------------");
		
		Dog dog4 = new Dog("测试", 66 , '男');
		System.out.println("Name:" + dog4.name);
		System.out.println("Age:" + dog4.age);
		System.out.println("Gender:" + dog4.gender);
		
		System.out.println("-------------------------------");
	}
}

1.5 总结

1. 构造方法
	功能是用于初始化创建对象的成员变量数据
	构造方法是一个方法，参数使用方式和方法一致

2. 构造方法选择
	Java编译器会根据构造方法中的【参数类型，个数，顺序】来做选择，如果没有指定的构造方法，报错！！！

3. 无论什么时候一定要给当前类提供一个无参数构造方法。

4. 【以下代码报错】
	Dog(String name);
	Dog(String color);

	调用:
		String color = "red";
		Dog dog = new Dog(color);
	在Java代码中不允许出现相同数据类型，个数，顺序的构造方法，和参数名没有关系，Java编译器选择过程中，有且只针对数据类型，个数，顺序选择，参数名真的无所谓。

2. 类对象内存分析图【重点】

3. this关键字【鸡肋】

3.1 this关键字【重点】

this关键字表示对象本身
	1. 调用当前方法的类对象
	2. 通过构造方法创建的类对象

this表示一个对象！！！当前对象！！！

3.2 目前this关键字解决的问题

可以在方法中使用this关键字区分操作的是成员变量还是局部变量
this指向的变量未成员变量

package com.qfedu.b_this;

class Person {
	String name;
	int age;
	
	public Person() {
		// this关键字表示通过new + 构造方法创建的类对象本身
		System.out.println("Constructor: " + this);
	}
	
	public Person(String name) {
		/*
		 *  以下操作是没有用的，这是自娱自乐！！！
		 *  这里存在一个【就近原则】问题，如果出现和成员变量
		 *  同名的局部变量，采用就近原则
		 */
		// name = name;
		
		/*
		 *  这里需要赋值操作的是当前类对象中的name成员变量
		 *  this.成员变量名字 表示使用的就是当前类对象的成员变量，而不是方法的参数
		 */
		this.name = name;
	}
	
	public Person(String name, int age) {
		/*
		 * 使用this关键字区分成员变量和局部变量
		 */
		this.name = name;
		this.age = age;
	}
	
 	public void test() {
		// 表示调用当前方法的类对象
		System.out.println("test: " + this);
	}
}

public class Demo1 {
	public static void main(String[] args) {
		Person person = new Person();
		
		System.out.println("main: " + person);
		person.test();
		

	}
}

4. 封装【重点，规范】

4.1 面向对象三大特征

封装
	最基本的思想
继承
	子承父业，你长得真的像你父母
多态
	猫，狗，都是动物
	U盘，键盘，鼠标，都是USB设备
	【最难的是多态，最简单的也是多态】

4.2 封装，不单单是对于类的封装

封装：
归纳总结
提高重用度
降低使用难度，使用更方便

	循环封装过程
	方法封装功能
	类封装数据
	框架封装模块

	一段代码使用了三遍，做成一个循环
	一个循环使用了三遍，做成一个方法
	一个方法使用了三遍，做成一个工具类
	一个工具类使用了三遍，做成一个文档
	一个文档使用了三遍，做成一篇博客

4.3 Java中规范化封装【JavaBean规范】

要求:
	1. 所有的成员变量全部私有化【private修饰】
	2. 要求至少完成一个无参数构造方法，其他无所谓
	3. 要求给予所有的成员变量对应的setter和getter方法

4.3.1 权限修饰符

private
	私有化内容，使用private修饰的成员变量，成员方法和构造方法，有且只能类内使用，类外没有操作权限。
	使用private修饰的内容有且只能在class所处大括号以内使用
public
	公开内容，只要存在对应的类对象，都可以通过类对象调用类内的public修饰的成员变量和成员方法

4.3.2 解决私有化成员变量赋值和取值操作问题

private私有化修饰的成员变量，类外不能通过类对象操作，取值，赋值。

JavaBean规范规定了
	setter ==> 赋值操作
	格式:
		public void set成员变量名(对应成员变量数据类型参数) {
			赋值操作;
		}
	getter ==> 取值操作
		public 对应成员变量数据类型返回值 get成员变量名字() {
			return 成员变量;
		}

注意
	1. 方法格式固定，setter和getter方法操作过程不能修改
	2. 方法需要符合命名规范，小驼峰命名法
	3. boolean类型数据较特殊
		boolean类型的成员变量getter方法要求是is开头

4.3.3 可以使用快捷方式快速完成代码

package com.qfedu.c;

/*
 * 以后开发中一个【实体类】如何封装如何书写
 * 实体类：
 * 		真实存在的一个数据，人，狗，英雄
 */
class LOLHero {
	private String name;
	private float hp;
	private float mp;
	
	// 根据个人需求完成对应构造方法，setter和getter方法
	// Shift + Alt + S
	public LOLHero() {}

	public LOLHero(String name, float hp, float mp) {
		this.name = name;
		this.hp = hp;
		this.mp = mp;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public float getHp() {
		return hp;
	}

	public void setHp(float hp) {
		this.hp = hp;
	}

	public float getMp() {
		return mp;
	}

	public void setMp(float mp) {
		this.mp = mp;
	}
}

4.3.4 关于JavaBean规范的总结

JavaBean规范制定的要求
	1. 要求Java中的所有实体类成员变量全部私有化，最少提供一个无参数构造方法，对应成员变量实现setter和getter方法
	2. JavaBean规范，是为了后期开发汇总更好的代码适配度，提高代码运行的统一性，能够满足框架的使用
	3. JavaBean规范只是一个规范，而且是作为一个基础规范，操作都是可以使用快捷键来完成的！！！

5. 多类合作【重点】

5.1 汽车类和修理厂类分析

汽车
	可以看做是一个类
	成员变量:
		名字
		颜色
		轮胎个数
		
	成员方法:
		飙车
			飙车有要求，轮胎个数必须是4个
修理厂
	可以看做是一个类
	成员变量:
		名字
		地址
		联系方式
	成员方法:
		修理汽车的方法【重点】
			该方法是需要一个汽车类的对象

5.2 汽车类代码实现

package com.qfedu.d;

/*
 汽车
	可以看做是一个类
	成员变量:
		名字
		颜色
		轮胎个数
		
	成员方法:
		飙车
			飙车有要求，轮胎个数必须是4个
 */
public class Car {
	// 成员变量 Field
	private String name;
	private String color;
	private int wheelCount;
	
	// 构造方法 Constructor
	public Car() {}
	
	public Car(String name, String color, int wheelCount) {
		this.name = name;
		this.color = color;
		this.wheelCount = wheelCount;
	}
	
	/**
	 * 飙车方法, 如果轮胎个数不为4，提示需要找修理厂
	 */
	public void race() {
		if (4 == wheelCount) {
			System.out.println("开着" + color + "的" + name + "在秋名山320KM/H飙车");
		} else {
			System.out.println("轮胎GG思密达，快去修理厂~~~~");
		}
	}
	
	// setter 和 getter 方法 Method
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public int getWheelCount() {
		return wheelCount;
	}

	public void setWheelCount(int wheelCount) {
		this.wheelCount = wheelCount;
	}
}

5.3 修理厂类代码实现

package com.qfedu.d;

/*
修理厂
	可以看做是一个类
	成员变量:
		名字
		地址
		联系方式
	成员方法:
		修理汽车的方法【重点】
			该方法是需要一个汽车类的对象
*/
public class Factory {
	// 成员变量 Field
	private String name;
	private String address;
	private String tel;
	
	// 构造方法 Constructor
	public Factory() {}

	public Factory(String name, String address, String tel) {
		this.name = name;
		this.address = address;
		this.tel = tel;
	}
	
	/*
	 * 修理汽车的方法分析
	 * 权限修饰符
	 * 		public 
	 * 返回值类型
	 * 		void
	 * 方法名
	 * 		repair
	 * 形式参数列表【重点】
	 * 		1. 这里需要一个汽车作为参数
	 * 		2. 而且是必要参数
	 * 		3. 这里需要的是一个汽车类的对象
	 * 		(Car car) 这里是一个汽车类对象
	 * 方法声明:
	 * 		public void repair(Car car);
	 */
	/**
	 * 修理汽车的方法，这里需要的参数是一个汽车Car类的对象
	 * 
	 * @param car Car汽车类对象
	 * @throws InterruptedException 
	 */
	public void repair(Car car) throws InterruptedException {
		// 修理轮胎 通过car类对象获取对应的轮胎个数
		if (car.getWheelCount() < 4) {
			System.out.println("轮胎有问题，需要修理");
			
			// 修改当前汽车对象的轮胎个数，赋值为4
			car.setWheelCount(4);
			
			// 报错，Ctrl + 1 选择第一个回车
			Thread.sleep(1000);
			
			System.out.println("10W块RMB");
		} else {
			System.out.println("你脑子瓦特了~~~~");
		}
	}

	// setter和getter方法 Method
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	public String getTel() {
		return tel;
	}

	public void setTel(String tel) {
		this.tel = tel;
	}	
}

5.4 主方法

package com.qfedu.d;

public class Demo {
	public static void main(String[] args) throws InterruptedException {
		/*
		 * 同package内可以直接使用对应的Class 类
		 */
		Car car = new Car("领克03+", "黑色", 4);
		
		for (int i = 0; i < 10; i++) {
			car.race();
			
			/*
			 *  让程序暂停0.5S，存在一个红色的报错，这里Ctrl + 1
			 *  快速修复，选择第一个，不要问为什么
			 */
			Thread.sleep(500);
		}
		
		Thread.sleep(1000);
		
		System.out.println("轮胎boom~~~~~");
		// 轮胎爆炸一个
		car.setWheelCount(3);
		
		Thread.sleep(1000);
		car.race();
		
		// 现在需要一个修理厂对象
		Factory factory = new Factory();
		
		factory.setAddress("海航中路60号");
		factory.setName("骚磊汽修");
		factory.setTel("138后面随便");
		
		/*
		 * 这里需要通过Factory类对象，调用repair方法，修理汽车Car类的对象
		 * 方法参数是一个Car类的对象
		 */
		factory.repair(car);
		
		for (int i = 0; i < 10; i++) {
			car.race();
			
			/*
			 *  让程序暂停0.5S，存在一个红色的报错，这里Ctrl + 1
			 *  快速修复，选择第一个，不要问为什么
			 */
			Thread.sleep(500);
		}
	}
}