13、面向对象

13_面向对象

1、封装

1.1 狭义的封装和广义的封装

狭义的封装
		面向对象的封装
		Java 中定义的类要求符合 JavaBean 规范
		
广泛的封装
		一段代码使用了三遍 	封装一个方法
		一组相关的方法使用了三遍		封装一个类
		一个类使用了三遍 	完成完整的开发文档
		

1.2 Java 符合 JavaBean 规范的封装

JavaBean 规范
		1、所有成员变量全部【私有化】
		2、所有成员变量提供对应的的【Getter and Setter】方法
		3、必须提供一个无参构造方法，其它有参构造方法根据实际所需提供

1.2.1 私有化

使用关键字 private

关键字：public 
		公共的，用于修饰成员变量、成员方法、构造方法等。
		被修饰的内容在类外可以根据对应的语法要求直接使用，限制较少。

关键字：private
		私有的，用于修饰成员变量、成员方法、构造方法等。
		被修饰的内容在类外无法直接使用

1.2.2 this 关键字

使用场景：
		方法参数变量名称和成员变量名称一致的情况下使用
		使用 this 关键字明确当前操作变量为成员变量，不是方法参数变量

1.2.3 getter 和 setter 方法

Getter 方法功能：
		用于获取私有化成员变量数据存储内容
		因为私有化成员变量无法在类外直接操作，使用 getter 方法形式规范取值操作过程

格式：
public 对应的成员变量的数据返回类型 get成员变量名() {
	return 成员变量;
}

Setter 方法功能：
		用于对私有化成员变量进行赋值操作
		因为私有化成员变量无法在类外直接使用，使用 setter 方法形式规范赋值操作过程

格式：
public void set成员变量名(对应成员变量数据类型参数) {
	赋值成员变量语句;
}

1.2.4 JavaBean 规范实体类案例

/**
* 当前类符合 JavaBean 规范封装的实体类
* 		1、所有成员变量全部私有化
* 		2、提供针对于所有成员变量的 Getter and Setter 方法
* 		3、必须提供一个无参构造方法 其它有参构造方法根据所需提供 
*/
class SinglePerson {
	//成员变量私有化
	private int id;
	private String name;
	private int age;
	
	/**
	* SinglePerson 类无参构造方法
	*/
	public SinglePerson() {}
	
	/**
	* 初始化 id, name, age 成员变量
	* 
	* @param id 整型 用于初始化 id 成员变量
	* @param name String 类型 用于初始化 name 成员变量
	* @param age 整型 用于初始化 age 成员变量
	*/
	public SinglePerson(int id, String name, int age) {
		this.id = id;
		this.name = name;
		this.age = age;
	}
	
	//针对于私有化成员变量的 setter getter 方法
	public int getId() {
		return id;
	}
	
	public void setId(int id) {
		this.id = id;
	}
	
	public String getName()  {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
}

public class Demo1 {
	public static void main(String[] args) {
		//使用无参构造方法实例化 SinglePerson 类对象 sp1
		SinglePerson sp1 = new SinglePerson();
		
		//使用 setter 方法进行成员变量赋值操作
		sp1.setId(1);
		sp1.setName("小芳");
		sp1.setAge(18);
		
		//使用 getter 方法进行成员变量取值操作
		System.out.println("id: " + sp1.getId());
		System.out.println("name: " + sp1.getName());
		System.out.println("age: " + sp1.getAge());
		
		System.out.println();
		
		使用有参构造方法实例化 SinglePerson 类对象 sp2 并传递参数
		SinglePerson sp2 = new SinglePerson(2, "小雪", 16);
		
		//使用 getter 方法进行成员变量取值操作
		System.out.println("id: " + sp2.getId());
		System.out.println("name: " + sp2.getName());
		System.out.println("age: " + sp2.getAge());
	}
}

运行结果如下

2、继承

2.1 Java 中继承的基本语法

使用关键字 extends

格式：	
		class A extends B {}
		A 类是 B 类的唯一子类
		B 类是 A 类的唯一父类

Java 中的继承主要关注的是
		1、类型的延续性，类型的一致性
		2、方法的传递性

特征：
		1、子类可以通过继承得到父类中的非私有化成员变量和成员方法的使用权限
		2、子类不可以通过继承得到父类中的私有化成员变量和成员方法

2.2 继承使用案例

//继承案例
class SuperClass {
	//public 修饰的成员变量和成员方法
	public int num = 10;
	
	public void game() {
		System.out.println("AWM绝地求生");
	}
	
	//private 修饰的成员变量和成员方法
	private int ret = 20;
	
	private void uniqueTech() {
		System.out.println("有手就行");
	}
}

/**
* extends 关键字完成继承操作
* SubClass 是 SuperClass 的一个子类
* SuperClass 是 SubClass 的唯一父类
*/
class SubClass extends SuperClass {
	
}

public class Demo2 {
	public static void main(String[] args) {
		SubClass subclass = new SubClass();
		
		//子类对象可以通过继承得到父类 public 修饰的成员变量和成员方法
		System.out.println(subclass.num);
		subclass.num = 20;
		System.out.println(subclass.num);
		
		subclass.game();
		
		//通过子类调用父类私有化成员变量和成员方法会报错
		//private 修饰的私有化内容只能在同一个类中被调用 类外无法使用
		//subclass.uniqueTech();
	}
}

运行结果如下

2.3 方法重写

要求：
		1、必须存在继承关系，子类重写父类方法
		2、子类重写的方法声明和父类的方法声明一致
		3、方法重写时，子类可以重新定义方法体
		4、在重写的方法之前使用 @Override 注解（注释 + 解释），校验方法声明是否和父类一致，不一致则报错

2.4 方法重写案例

//方法重写
class Father {
	public void game() {
		System.out.println("黄金矿工");
	}
	
	public void work() {
		System.out.println("物流管理");
	}
}
/*
* Son 类是 Father 类的子类 通过继承可以调用父类中非私有化的成员变量和成员方法
* 
* 继承可以增强方法延续性 但是父类的方法实现的内容可能并不满足子类的实际情况
* 
* 可以使用方法重写 在子类中把父类的方法重写 修改方法语句块以达到子类开发需求
*/
class Son extends Father {
	/**
	* 子类重写父类 game 方法 
	*/
	@Override
	public void game() {
		System.out.println("原神");
	}
	
	/**
	* 子类重写父类 game 方法
	*/
	@Override
	public void work() {
		System.out.println("程序员~");
	}
}

public class Demo3 {
	public static void main(String[] args) {
		Son son = new Son();
		
		son.game();
		son.work();
	}
}

运行结果如下

3、多类合作

存放在一个文件夹下

3.1 Car.java

//汽车类
public class Car {
	//成员变量
	/**
	* 品牌
	*/
	private String name;
	
	/**
	* 车身颜色
	*/
	private String color;
	
	/**
	* 轮胎个数
	*/
	private int wheelCount;
	
	//无参构造方法
	public Car() {}
	
	//初始化所有成员变量的构造方法
	public Car(String name, String color, int wheelCount) {
		this.name = name;
		this.color = color;
		this.wheelCount = wheelCount;
	}
	
	//成员方法
	/**
	* 飙车方法 轮胎数要求完整的四个 否则无法进行该动作 
	*/
	public void race() {
		if (4 == wheelCount) {
			System.out.println("我开着" + color + name + "在秋名山送外卖");
		} else {
			System.out.println("轮胎飞走一个，需要修理");
		}
	}
	
	//对应私有成员变量的 getter setter 方法
	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;
	}
}

3.2 Factory.java

//修理厂类
public class Factory {
	//成员变量
	private String name;
	private String address;
	private String telephone;
	
	//无参构造方法
	public Factory() {}
	
	//初始化所有成员变量的构造方法
	public Factory(String name, String address, String telephone) {
		this.name = name;
		this.address = address;
		this.telephone = telephone;
	}
	
	/*
	 * 修理汽车的核心方法
	 * 
	 * 方法名 ： 
	 * 		repair
	 * 形式参数列表 ： 
	 * 		(Car car)
	 * 		表示当前方法所需的实际参数数据类型为 Car
	 * 		参数名为 car
	 * 方法声明：
	 * 		public void repair(Car car);
	 */
	
	/**
	* 修理厂维修汽车的方法 方法参数是 Car 类型 调用执行方法的过程需要
	* Car 类型对应的对象作为实际参数
	* 
	* @param car Car 类型
	*/
	public void repair(Car car) throws Exception{
		//1、检查车辆的轮胎情况 通过 Car 类型对象调用获取轮胎个数的方法 getWheelCount()
		if (car.getWheelCount() != 4) {
			System.out.println("您的轮胎有问题~~需要维修，请稍后");
			Thread.sleep(1000);
			//调用 Car 类对象的 setWheelcount() 方法 设置轮胎个数
			car.setWheelCount(4);
			System.out.println("车辆修复完成，请付款 1000 RMB");
		} else {
			System.out.println("您的汽车并未检查出故障");
		}
	}
	
	//对应私有成员变量的 getter setter 方法
	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 getTelephone() {
		return telephone;
	}
	
	public void setTelephone(String telephone) {
		this.telephone = telephone;
	}
}

3.3 代码调用执行

/**
* 同一个包内 类可以直接调用
* @author Echo
* 
*/
public class Demo1 {
	public static void main(String[] args) throws Exception {
		//实例化 Car 类对象
		Car car = new Car();
		
		//设置属性
		car.setName("AE86");
		car.setColor("黑色");
		car.setWheelCount(4);
		
		//使用 car 对象调用 race 方法 进行飙车行为
		for (int i = 0; i < 5; i++) {
			car.race();
			
			//代码运行间断时间 1 秒
			Thread.sleep(1000);
		}
		
		System.out.println("轮胎出现故障");
		Thread.sleep(1000);
		
		//轮胎飞走一个
		car.setWheelCount(3);
		
		//继续飙车
		car.race();
		
		//实例化 Factory 类对象
		Factory factory = new Factory();
		
		//设置属性
		factory.setName("XX汽修");
		factory.setAddress("南京路XX号");
		factory.setTelephone("138-XXXX-XXXX");
		
		//汽车出现问题 返回修理厂
		factory.repair(car);
		
		//使用 car 对象调用 race 方法 进行飙车行为
		for (int i = 0; i < 5; i++) {
			car.race();
			
			//代码运行间断时间 1 秒
			Thread.sleep(1000);
		}
	}
}

运行结果如下