简介
👨💻个人主页：@云边牧风
👨🎓小编介绍：欢迎来到云边牧风破烂的小星球🌝
📋专栏：Java基础知识
🔑本章内容：Java继承与多态 之 类的继承
记得 评论📝 +点赞👍 +收藏😽 +关注💞哦~
从这一章开始，就不叫Java入门啦，因为前两章已经把入门的知识都讲到了，相信小伙伴们也都入门了，所以从第三章开始叫Java基础进阶了，这一章的内容主要有👇：
3.1 类的继承
3.2 对象的上转型对象
3.3 多态性
3.4 abstract 类和abstract方法
3.5 super关键字
我们分为两到三节的篇幅，由浅入深地讲明白以上内容；第一节讲类的继承和对象的上传型对象
一、类的继承
1.1类的继承 相关的几个概念
针对以上的例子，有👇：
– 职员对象（ Employee ）可能有的属性信息包括：• 员工号（ employeeNumber ）• 姓名（ name ）• 地址（ address ）• 电话号码（ phoneNumber ）– 管理人员（ Manager ）除具有普通员工的属性外，还可能具有下面的属性• 职责（ responsibilities ）• 所管理的职员（ listOfEmployees ）
对应的关系图为：
1.2子类
class 子类名 extends 父类名
{…
}
class Student extends People //Student是People的子类
{…
}
Object——getClass方法 （主要面对多代码时用来定位某个类源于哪里—“他爸是谁”）
void PrintClassName(Object obj) {
System.out.println("The Object's class is " + obj.getClass().getName());
}
对以上的理解是这样的👇：
由此我们可以得到一个“查户口”的一般形式（例子）：
有个问题，不知道同学们想过没有：如果查到两个class都源于一个父类，我们怎么确定他俩是不是一样的？
——为此，有个自带的方法（函数）可以帮我们解决——equals（）
public boolean equals(Object x) {
return this == x;
}
1.3相等和同一的概念
为了方便大家理解，请看例子👇：
1.3.1使用“==”判断同一对象
class 人物 {
double 身高;
double 体重;
}
执行代码：
人物 八戒 = new 人物();
人物 悟空 = new 人物();
if (八戒 == 悟空)
System.out.println("YES");
else
System.out.println("NO");
运行结果是：NO //八戒和悟空不是“同一”对象
1.3.2修改代码后执行
执行代码：
人物 八戒 = new 人物();
人物 悟空 = 八戒;
if (八戒 == 悟空)
System.out.println("YES");
else
System.out.println("NO");
运行结果是：YES //八戒和悟空指向“同一”对象
1.3.2使用equal（）方法判断
class People {
double height;
double weight;
public People(double height,
double weight)
}
执行代码：
People a = new People(180,70);
People b = new People(180,70);
if ( a.equals(b) )
System.out.println("YES");
else
System.out.println("NO");
运行结果是：NO//a和b不是“同一”对象 (尽管数据一样但分配的地址是不一样的—对象不同)
还有👇：
执行代码：
String s1=new String(“Hello”);
String s2=new String(“Hello”);
if ( s1==s2 )
System.out.println("YES");
else
System.out.println("NO");
运行结果：NO
执行代码：
String s1=new String(“Hello”);
String s2=new String(“Hello”);
if ( s1.equals(s2) )
System.out.println("YES");
else
System.out.println("NO");
运行结果：YES//两个引用类型的变量引用的是同一个对象
👆问题：为什么String类的equals方法可以判断“相等”？
再如：重写“People”类的equals方法
class People {
double height;
double weight;
public boolean equals(Object o){
if (this.getClass() != o.getClass())
return false;
People r = (People)o;
return this. height ==r. height &&this. weight ==r. weight;
}
}
可以得到：
执行代码：
People a = new People(180,70);
People b = new People(180,70);
if ( a.equals(b) )
System.out.println("YES");
else
System.out.println("NO");
运行结果是：YES//重写equals方法后，源于一个父类&&值相等——即return true
1.4子类的继承性
例如👇：
public class People{
String name;
int age;
void eat(){…}
}子类代码为👇
public class Student extends People{
String hometown;
int grade;
void study(){…}
}
在Main中可以这样写👇：
Student student=new Student();
student.eat();//没毛病
student.study();//没毛病1.5隐藏和覆盖
1.5.1隐藏与覆盖的联系与区别
例如👇：
问题1：父类中，哪些成员变量被隐藏？哪些方法被覆盖？
问题2：创建一个好人的实例a：
“好人 a = new 好人();”此时，a拥有哪些成员变量和方法？
1.5.2隐藏成员的访问
例如👇：
class 人 {
double 寿命;
void set寿命(double d){
寿命=d;
}
}class 好人 extends 人 {
double 寿命; //隐藏了继承的成员变量“寿命”
double get寿命(){ //新增的方法，访问自己声明的“寿命”
return 寿命;
}
double get隐藏寿命(){ //新增的方法，访问被隐藏的“寿命”
return super.寿命;
}
}
执行代码：
好人 a = new 好人();
a.set寿命(100); //由于方法是直接继承而来的(在“好人”中
//没有声明（定义）属于好人自己的set寿命（）方法)，
//因此访问的是被隐藏的“寿命”
//即这个100是存到了父类“人”中的寿命（所以说是隐藏的），而子类“好人”的寿命还是初始值0
System.out.println(a.get寿命());
System.out.println(a.get隐藏寿命());运行结果：
0.0
100.0
1.5.3覆盖方法的访问
例如👇：
class 人 {
String 姓名;
double 寿命;
String get姓名( ){
return 姓名;
}
void set寿命(double d ){
寿命=d;
}
}
class 好人 extends 人 {
double 寿命;
void set寿命(double d){ //覆盖了父类的“set寿命”方法,这样操作的是子类自己的寿命
寿命=d;
}
void set隐藏寿命(double d){ //访问被覆盖的父类的“set寿命”方法
super.set寿命(d); //改变的是他爹的寿命
}
double get寿命(){
return 寿命; //访问的是子类自己的寿命
}
double get隐藏寿命(){
return super.寿命; //访问的是他爹的寿命
}
}
执行代码：
好人 a = new 好人(); //此时，a拥有两个成员变量“寿命”
a.set寿命(100); //由于方法是覆盖的，因此访问的是重定义的“寿命”（子类自己的）
System.out.println(a.get寿命());//访问的是子类自己的寿命
System.out.println(a.get隐藏寿命()); //他爹的寿命
a.set隐藏寿命(120); //调用父类的“set寿命”方法，因此访问的是被隐藏的“寿命”（他爹的）
System.out.println(a.get寿命());//子类自己的寿命
System.out.println(a.get隐藏寿命());//他爹的寿命运行结果：
100.0
0.0
100.0
120.0
1.5.4覆盖的注意事项
因为：如果覆盖方法时降低了访问权限，例如变成private方法，那么子对象的上转型对象无法调用覆盖的方法，类的继承性多态就无法实现
1.5.5构造方法的继承问题
注意：super语句调用父类构造方法的格式：
正确：super(参数表)
错误：super.父类名(参数表)
例如：使用super调用父类构造方法👇
class 人 {
String 姓名;
人(String s){
姓名 = s;
}
class 好人 extends 人 {
String 姓名;
好人(String s){
super(s);//必须在第一行
姓名 = s;
}
}
执行：
好人 a = new 好人("雷锋");
System.out.println(a.姓名);
运行结果：
雷锋
（1）同一包中的继承性
（2）不同包中的继承性
（3）总结：类的访问限制表
由上表可以得到👇：
二、final关键字
2.1final类的应用：
2.2final成员变量的应用：
//Math 类中的 PI
public static final double PI = 3.141592653589793 ;
// 网站数据库访问类中的“连接字符串”
// DBHelper 类
public static final 连接字符串 = " Server= (local) ; UID= sa ; PWD= sa ; database= Study Java " ;
三、对象的上转型对象
3.1、定义
3.2、对象转型与“类型转换”（塑型）
3.3、对象转型的注意事项
子类 b = (子类)a;
Manager类的继承关系图为👇：
3.4、上转型对象的访问限制
子类 b = new 子类();
父类 a = b;
a能访问对象b的哪些属性和功能👇：
3.5、关于instanceof运算符
lisi instanceof UniverStudent;//true
lisi instanceof Student;//true
lisi instanceof People;//true
zhangsan instanceof Student;//true
zhangsan instanceof UniverStudent;//false
结束语：
以上是Jav第三章的第1节，希望大家喜欢
下一节开始讲第三章第2节多态性、abstract 类和abstract方法、super关键字
喜欢的可以点赞+关注哈 ❤
2032
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
