面向对象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. 子类对象可以通过继承使用父类的非私有化成员变量和成员方法
子类对象所占用的内存【堆区】空间中，是有对应父类成员变量和成员方法的内存空间。
开发中:
所有的数据，方法，数据类型都要占用一定的内存空间，程序运行是离不开内存
的。
image.png
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. 饮水机在这里，你走之后，它还在这里。
网友评论