【java初学】面向对象继承

面向对象4.0

1. 面向对象之继承

1.1 生活中的继承

王多鱼
	二爷的遗产
	
你长的真像你爹
	遗传，继承！！！
	
开发中使用继承最多的地方:
	游戏开发！！！
	LOL
		血量，蓝量，攻击力，法术强度，攻击速度，护甲，魔抗，CD，移动速度，物理穿
		甲，法术穿甲，物理吸血，法术吸血....
		这里会考虑将所有的通用属性，封装成一个类，通过【继承】让每一个英雄类都可
		以使用到这些属性。这个类叫做【基类】.

1.2 Java中的继承

关键字
	extends 继承使用关键字
格式:
	class A extends B {
	
	}
	
	A类是B类的一个子类
	B类是A类的唯一父类
	Java语言是一门单继承语言。

继承效果
	1. 子类可以通过继承使用父类的非私有化成员变量和成员方法
	2. 子类无法通过继承使用父类的私有化成员变量和成员方法

1.3 子类对象创建，会调用父类的构造方法解释

1. 构造方法是用来做什么的???
	创建对象 new + 构造方法(); 
		new 申请内存【堆区】空间，并且擦除所有数据
		构造方法用于初始化当前类对象成员变量或者一些必要数据。
		构造方法没有创建对象的能力，只做【初始化操作】

2. 子类对象可以通过继承使用父类的非私有化成员变量和成员方法
	子类对象所占用的内存【堆区】空间中，是有对应父类成员变量和成员方法的内存空间。
	开发中:
		所有的数据，方法，数据类型都要占用一定的内存空间，程序运行是离不开内存
		的。

1.4 super关键字【鸡肋】

1. super区分子类和父类同名内容。
2. 通过super关键字调用父类的构造方法[后面讲 Exception]

package com.qfedu.a_extends;

class Person {
	public String name;
	public int age = 10;
	
	public void work() {
		System.out.println("Person类work方法");
	}
}

/**
 * super关键字区分父类和子类同名内容
 * @author Anonymous
 *
 */
class SinglePerson extends Person {
	public int age = 20;
	
	public void work() {
		System.out.println("SinglePerson类work方法");
	}
	
	/*
	 * super关键字可以解决父类和子类同名内容情况。
	 */
	public void test() {
		// 子类和父类有同名内容情况下，默认为就近原则
		System.out.println(age);
		
		// 通过super明确告知编译器，这里使用的age是父类成员变量age
		System.out.println(super.age);
		
		// 调用方法也是采用就近原则
		work();
		
		// 通过super明确告知编译器这里调用的是父类的work方法。
		super.work();
	}
}

public class Demo3 {
	public static void main(String[] args) {
		
	}
}

1.5 继承带来的问题

Java中继承主要目的
	1. 制定规范
	2. 继承可以进行方法传递，子类可以使用父类的方法，简化开发流程

子类通过继承可以使用父类中的成员方法，但是父类成员方法     
无法满足子类的特殊情况。                    
                                
为了降低程序员的开发压力，面向对象语言中，引入了一个【重写】概念

1.6 重写 Override

重写:
	用于在不增加方法量的情况下，解决父类方法无法满足子类使用情况。

重写方法要求
	1. 子类和父类方法声明完全一致。
		权限修饰符 返回值类型 方法名(形式参数列)
	2. 子类重写父类方法，可以修改方法体内容，来满足子类情况
	3. 通常情况下，会使用注解 @Override来开启严格格式检查。

package com.qfedu.b_override;

/**
 * LOLHero基类
 * @author Anonymous
 *
 */
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方法");
	}
}

/**
 * 锤石类
 * @author Anonymous
 *
 */
class Thresh extends LOLHero {
	/*
	 * 重写之后，父类和子类方法声明完全一致，并没有增加方法的记忆压力
	 * 只不过修改了子类方法体内容，从而更加合适子类的使用情况！！！
	 */
	@Override
	public void Q() {
		// TODO todo是未完成代码标记，需要在todo注释之后完成代码
		System.out.println("死亡判决");
	}
	
	@Override
	public void W() {
		System.out.println("魂引之灯");
	}
	
	@Override
	public void E() {
		System.out.println("厄运钟摆");
	}
	
	@Override
	public void R() {
		System.out.println("幽冥监牢");
	}
}

/**
 * 维鲁斯类
 * @author Anonymous
 *
 */
class Varus extends LOLHero {

	@Override
	public void Q() {
		System.out.println("穿刺之箭");
	}

	@Override
	public void W() {
		System.out.println("枯萎箭袋");
	}

	@Override
	public void E() {
		System.out.println("恶灵箭雨");
	}

	@Override
	public void R() {
		System.out.println("腐败锁链");
	}
	
}

public class Demo1 {
	public static void main(String[] args) {
		/*
		 * 子类通过继承可以使用父类中的成员方法，但是父类成员方法
		 * 无法满足子类的特殊情况。
		 * 
		 * 为了降低程序员的开发压力，面向对象语言中，引入了一个【重写】概念
		 */
		Thresh goulei = new Thresh();
		
		goulei.E();
		goulei.R();
		goulei.W();
		goulei.Q();
		
		System.out.println();
		
		Varus saolei = new Varus();
		
		saolei.E();
		saolei.W();
		saolei.R();
		saolei.Q();
	}
}

1.7 重写注意事项

1. 重写是建立在继承或者遵从[implements]关系之上的。通常是由子类或者实现类完成的。

2. @Override 
	注解 ==> 注释 + 解释
	开启重写严格格式检查。【编译时作用】

3. 重写可以简化代码结构，在不增加方法的情况下，满足子类的特殊使用情况。 

1.9 重写的问题

	LOLHero类内有QWER方法，这里其实是要求子类按照自己的需求来完成重写的，但是代码没有从【语法】角度进行强行约束。
	目前缺少让子类重写方法的【强制要求】
	这里需要使用abstract关键字

2. abstract关键字【重点】

2.1 abstract关键字语法要求

abstract修饰的方法
	要求子类必须强制完成/强制重写！！！

package com.qfedu.c;

/*
abstract关键字使用 Eclipse操作引导

第一个问题：
	Abstract methods do not specify a body
	abstract修饰的方法，不允许有方法体

快速修复:
	Ctrl + 1
	Remove method body;
	删除当前abstract修饰方法的方法体。

 第二个问题:
 	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
 	
 第三个问题:
 	The type HappyWindBoy must implement the inherited abstract method LOLHero.Q()
		HappyWindBoy类因为继承LOLHero类，必须实现LOLHero类内的abstract修饰的方法 Q();
 快速修复:
 	 Ctrl + 1
 	 Add unimplemented method;
 	 	添加未实现的方法
 */
/**
 * LOLHero基类
 * @author Anonymous
 *
 */
abstract class LOLHero {
	abstract public void Q();
	
	abstract public void W();
	
	abstract public void E();
	
	abstract public void R();
}

/**
 * 快乐风男
 * @author Anonymous
 *
 */
class HappyWindBoy extends LOLHero {

	@Override
	public void Q() {
		System.out.println("斩钢闪");
	}

	@Override
	public void W() {
		System.out.println("风之障壁");
	}

	@Override
	public void E() {
		System.out.println("踏前斩");
	}

	@Override
	public void R() {
		System.out.println("狂风绝息斩");
	}
	
}

/**
 * 提莫类
 * @author Anonymous
 *
 */
class Timor extends LOLHero {

	@Override
	public void Q() {
		System.out.println("你瞎吧");
	}

	@Override
	public void W() {
		System.out.println("溜~~~");
	}

	@Override
	public void E() {
		System.out.println("呵 tui~~~");
	}

	@Override
	public void R() {
		System.out.println("蹦沙卡拉卡");
	}

}

public class Demo1 {
	public static void main(String[] args) {
		HappyWindBoy happyWindBoy = new HappyWindBoy();
		
		happyWindBoy.Q();
		happyWindBoy.W();
		happyWindBoy.E();
		happyWindBoy.R();
		
		Timor timor = new Timor();
		timor.Q();
		timor.W();
		timor.E();
		timor.R();
	}
	
}

2.2 abstract使用总结

1. abstract关键字目前只要求了解语法规范。【实际使用和开发使用，后期项目中讲解】

2. abstract修饰的方法不能有方法体，有且只有方法的声明，这里只是在当前类内告知编译器，这里定义了一个方法的声明。

3. abstract修饰的方法，有且只能存在于abstract修饰的类内，或者interface接口内

4. 一个普通类如果继承abstract修饰的类需要完成abstract类内的所有abstract修饰方法，【语法强制要求】

5. abstract修饰的类请问有没有类对象???
	abstract修饰的类不能创建自己的类对象，因为abstrat修饰的类内可能存在abstract修饰的方法，而abstract修饰的方法没有方法体，无法通过类对象调用执行。

3. final关键字

3.1 基本语法

成员变量
	final修饰的成员变量，定义时必须初始化，并且无法被重新赋值。
成员方法
	final修饰的成员方法，不能被子类重写，为最终方法。
局部变量
	final修饰的局部变量一旦被赋值无法修改！！！
类
	final修饰的类不能被子类继承，没有子类
	断子绝孙
	代表之作:
		Java中的String字符串类就是一个final修饰的类

3.2 final面试题

package com.qfedu.d_final;

class Person {
	public String name = "苟磊";
	public int age = 16;
}

public class Demo2 {
	public static void main(String[] args) {
		final Person person = new Person();
		
		System.out.println(person.name + " " + person.age);
		
		/*
		 * 一下操作那些正确，那些错误?
		 * 
		 * 请问:
		 * 		这里是指向不可变，还是指向内容不可变???
		 * 
		 * 这里final Person person 实际上修饰的内容是person引用数据类型变量
		 * 也就是说当前引用数据类型变量中保存的数据是不能修改的！！！
		 * 引用数据类型变量保存的数据是地址，地址指向不得改变。
		 * 
		 * 指向空间中保存的数据内容是可以改变的！！！
		 * 
		 * 生活例子:
		 * 		你买的房子地址不会发生改变，但是房子内部的装修装饰是可以发生改变。
		 */
		 // person = new Person();
		 
		 person.name = "航海中路彭于晏";
		 person.age = 6;
	}
}

4. static关键字【重点】

4.1 static修饰静态成员变量

4.1.1 为什么要使用静态成员变量

	开发中存在一些共享数据，这些数据存在于每一个类对象中，并且一致数据！！！如果每一个对象都存储当前数据，会导致大量的资源浪费！！！
	
	共享单车
		共享资源，共享经济
        1. 共享单车不占用用户空间。占用公共空间。
		2. 共享单车是否与你有关???
			所属权归共享单车的运营公司
			每一个用户拥有使用权。
		3. 共享单车被XXX卸了座，大家都无法使用。
		4. 你来到北京之前，共享单车已经存在，你走之后，共享单车依然存在。
	
	饮水机
		共享资源
		1. 占用共享空间，不占用用户空间
		2. 饮水机与你有关?
			只能使用
			所属权归千锋郑州校区
		3. 饮水机里面放了巴豆，蹦沙卡拉卡...
		4. 你来千锋之前，饮水机在这里，你走之后，它还在这里。