Java面向对象总结＜三＞

面向对象

1. 继承

1.1 生活中的继承

财产继承！！！
	二爷 ==> 王多鱼
长相继承！！！
	你长得真的像你父母。
技能继承！！！
	师徒制！！！

游戏开发中继承使用是非常多的！！！
	例如 
	MOBA游戏 LOL 每一个英雄都有血量，魔法值，攻击力，法术强度...如果每一个英雄都完成对应属性，会导致大量的空间浪费。所有会采用继承的方法，使用一个【基类】完成基本属性的定义，让每一个英雄类都继承当前基类，从而使用对应属性，并且在继承的基础之上完成自己的特定内容。比如说 模型大小，攻击方式，技能方式。。。
	Java开发中，继承更多的是用于统一规范，统一操作，统一节奏。
	【归纳总结】

1.2 Java中继承格式和要求

关键字:
	extends 继承使用的关键字

格式:
	class A extend B {
		
	}
	A类是B类的一个子类
	B类是A类的【唯一父类】
		Java继承采用的是单继承方式！！！
		子类有且只能有一个父类

package com.qfedu.a_extends;

class A {
	// 成员变量 
	public int num;
	private String name;
	
	// 成员方法
	public void test() {
		System.out.println("public修饰公开成员方法");
	}
	
	private void testPrivate() {
		System.out.println("private修饰私有化成员方法");
	}
}

/*
 * B类是A类的一个子类，A类是B类的唯一父类。Java是一门单继承语言
 */
class B extends A {
	
}

/*
 * public修饰的类要求和当前文件名一致！！！
 */
public class Demo1 {
	public static void main(String[] args) {
		A a = new A();
		
		a.num = 10;
		// 私有化 成员变量类外不能使用
		// a.name = "苟磊";
		
		a.test();
		// The method testPrivate() from the type A is not visible
		// a.testPrivate();
		
		B b = new B();
		
		// 子类可以通过继承使用父类非私有化成员变量
		b.num = 10;
		// 子类不可以使用父类私有化成员变量，私有化成员变量有且只能在父类类内使用
		// b.name = "苟磊";
		
		// 子类可以通过继承使用父类非私有化成员方法
		b.test();
		// 子类不能使用父类中的私有化成员方法，私有化成员方法有且只能在父类类内使用
		// b.testPrivate();
	}
}

package com.qfedu.a_extends;

/*
 * 父类
 */
class Father {
	
	public int num;
	
	public Father() {
		System.out.println("父类构造方法");
	}
	
	public void test() {
		System.out.println("父类方法");
	}
}

/*
 * 子类 
 * 	 子类继承于父类
 *	有其父必有其子！！！
 */
class Son extends Father {
	public Son() {
		System.out.println("子类构造方法");
	}
}

public class Demo2 {
	public static void main(String[] args) {
		/*
		 * 构造方法做什么事情？？？
		 *    初始化当前成员变量内容。没有独立创建对象的能力	
		 *    
		 * 创建子类对象过程中会默认调用父类的无参数构造方法！！！	
		 */
		Son son = new Son();
		
		son.num = 100;
		son.test();
	}
}

1.3 继承之后的特征总结

1. 子类可以通过继承的父类的非私有化成员变量和非私有化成员方法的使用权利。
2. 子类不可以通过继承得到父类的私有化内容。
3. 创建子类对象会默认调用父类的无参数构造方法，用于初始化父类的成员变量空间，供子类使用，
4. 继承可以简化子类成员变量数据，归于父类总结。

1.4 继承带来的问题-重写引入

package com.qfedu.a_extends;

class Fu {
	public void work() {
		System.out.println("机械工程师！！！");
	}
	
	public void play() {
		System.out.println("捕鱼达人，黄金矿工");
	}
}

/*
 * 子类继承父类，可以使用父类非私有化成员方法。
 * 但是父类方法不一定能够满足子类的情况！！！
 * 
 * 如果子类重新完成方法，会导致代码中方法过多，采用降低了开发压力。
 * 期望：
 * 		1. 方法名字，参数，返回值类型不要改变。
 * 		2. 方法运行内容满足子类的特征。
 * 
 * 解决方案:
 * 		重写
 * 		不修改方法声明情况下，修改方法体内容，满足子类的实际运行情况。
 * 
 * @Override
 * 		注解
 * 		重写格式严格检查
 * 		检查内容:
 * 			1. 方法声明的所有内容 权限修饰符，返回值类型，方法名还有形式参数列表
 * 			2. 是否存在继承关系
 */
class Ez extends Fu {
	@Override
	public void work() {
		System.out.println("HW资深黑钻讲师");
	}
	
	@Override
	public void play() {
		System.out.println("PUBG 2018年第二季度 四排天梯 2399 分");
	}
}

public class Demo3 {
	public static void main(String[] args) {
		Ez ez = new Ez();
		
		ez.work();
		ez.play();
	}
}

1.5 真实案例

强制重写期望

package com.qfedu.a_extends;

/*
 * LOL英雄类
 * 
 * 目前情况下。LOLHero类的子类可以使用LOLHero类内的成员方法执行代码
 * 但是我们期望每一个英雄QWER技能应该是不一样的！！！希望LOLHero类子类
 * 全部重写父类中的方法。
 * 
 * 思考:
 * 	如果子类要求强制实现父类的方法，父类方法对应的方法体是否可以省略???
 * 		可以考虑省略，父类中方法只是提供声明，实现过程交给子类完成。
 * 
 * 思考:
 * 	子类要求强制完成父类中的方法，语法要求合适还是个人约束合适???
 * 		期望如果子类没有重写父类方法，直接语法报错！！！【错误前置思想】
 */
class LOLHero {
	public void q() {
		System.out.println("Q技能");
	}
	
	public void w() {
		System.out.println("W技能");
	}
	
	public void e() {
		System.out.println("E技能");
	}
	
	public void r() {
		System.out.println("R技能");
	}
}

/*
 * 锤石类，是LOL英雄类的子类
 */
class Thresh extends LOLHero {
	
}

/*
 * 快乐风男，也是LOL英雄类的子类
 */
class HappyWindBoy extends LOLHero {
	
}

public class Demo4 {
	public static void main(String[] args) {
		Thresh thresh = new Thresh();
		HappyWindBoy happyWindBoy = new HappyWindBoy();
		
		thresh.q();
		thresh.w();
		thresh.e();
		thresh.r();
		
		happyWindBoy.e();
		happyWindBoy.q();
		happyWindBoy.w();
		happyWindBoy.r();
	}
}

1.6 abstract关键字解决强制重写期望

语法:
	子类继承父类，在父类中的abstract方法，子类要求强制重写。

错误处理1:
 	Abstract methods do not specify a body
 		abstract修饰的方法没有方法体
 	The type LOLHero must be an abstract class to define abstract methods
 		LOLHero类必须是一个abstract修饰的类，才可以定义abstract修饰的方法。
 	Ctrl + 1 快速修复	
 		选择 Remove Method Body 删除方法体
 
错误处理2:
 	The abstract method q in type LOLHero can only be defined by an abstract class
 		在LOLHero类中使用abstract关键字修饰的q方法有且只能定义在一个abstract修饰的类内
 	The type LOLHero must be an abstract class to define abstract methods
 		LOLHero类必须是一个abstract修饰的类，才可以定义abstract修饰的方法。
 	Ctrl + 1 快速修复
 		选择 Make Type 'LOLHero' abstract 让当前类变成一个abstract修饰的类
 
错误处理3:
 	The type Thresh must implement the inherited abstract method LOLHero.q()
 		Thresh类必须实现通过继承得到的LOLHero类内的abstract方法q
 	The type HappyWindBoy must implement the inherited abstract method LOLHero.q()	
 		HappyWindBoy类必须实现通过继承得到的LOLHero类内的abstract方法q
 	Ctrl + 1 快速修复:
 		选择 Add unimplemented methods 添加未实现的方法

1.7 abstract关键字使用注意事项

1. 使用abstrac关键字修饰的类，不能有自己的类对象，因为在abstract修饰的类内有可能存在abstract修饰的方法，abstract修饰的方法没有方法体。如果创建对应的abstract类对象，无法执行没有方法体的方法。

2. abstract修饰的方法没有方法体

3. abstract修饰的方法有且只能在abstract修饰的类内

4. 一个普通类继承abstract类，必须完成abstract类内的所有abstract方法。

2. final关键字

2.1 final关键字作用

成员变量
	1. 定义是必须初始化
	2. 一旦被赋值，无法修改
	3. 作为带有名字的常量使用。MAX_VALUE MAX_FILE_SIZE
	
成员方法
	不能被子类重写
	一般用于在底层代码中，涉及到核心业务逻辑和安全控制的代码，一旦完成无法修改
	
类
	没有子类，不能被继承。【断子绝孙】
	Java中的String字符串类就是使用final修饰的类
	
局部变量
	局部变量使用final修饰，一旦被赋值，后期无法修改

2.2 final面试题

package com.qfedu.b_final;

class Person {
	String name;
	int age;
}

public class Demo2 {
	public static void main(String[] args) {
		/*
		 * final修饰的是Person类对象 person，person同时也是一个
		 * 引用数据类型的变量，也就是说当前person的指向不能发生任何的改变
		 * 但是不影响person指向空间的内容可以进行修改操作
		 * 
		 * 例如:
		 * 		房本上地址不能变
		 * 		房子装修随便你
		 */
		final Person person = new Person();
		
		/*
		 * The final local variable person cannot be assigned. 
		 * It must be blank and not using a compound assignment
		 */
		//*
		// person = new Person(); // 1 错误
		person.name = "苟磊"; // 2
		person.age = 16; // 3
		//*/
	}
}