【JavaSE系列】第八话 —— 继承和它的边角料们
☕目录☕
🍕思维导图
🍟一、引出继承
🍔二、继承的概念
🧇三、继承的语法
🌭四、父类成员访问
🍿🍿4.1 子类中访问父类的成员变量
🥞🥞4.2 子类访问父类的成员方法
🍞五、super 关键字
🥐🥐5.1 super.成员变量
🧀🧀5.2 super.成员方法
🍖🍖5.3 super.构造方法
🥩六、继承方式
🍱七、final关键字
🍰八、继承与组合
🍚写在最后
思维导图
一、引出继承
Java中 使用类 对 现实世界中的实体进行描述;
类经过实例化以后的产物 对象,则可以用来表示现实中的实体;
但是,在现实生活中,某些实体与实体之间 具有相同的属性;
比如说,上面的小猫和小狗,就具有一个共性:它们都是动物;
如果用Java语言来描述小猫和小狗,那么就可以这样来设计:
//定义一个Cat类class Cat { public String name; public int age; public String sex; public void eat() { System.out.println(this.name+"吃饭"); } public void mew(){ System.out.println(this.name+"喵喵叫"); }}
//定义一个Dog类class Dog { public String name; public int age; public String sex; public void eat() { System.out.println(this.name+"吃饭"); } public void bark(){ System.out.println(this.name+"汪汪叫"); }}
很明显,Cat类 和 Dog类 有许多一样的属性;
那么,能不能将这些共性给抽取出来呢?
在面向对象的过程中,提出了 继承 的概念;
专门用来进行 共性抽取,实现 代码复用。
二、继承的概念
继承机制:
是面向对象程序设计 是代码可以复用的最重要的手段;
它允许程序员在保持原有类的特性 的基础上 进行扩展,增加新功能,这样产生新的类,称为 派生类;
继承体现了 面向对象程序设计的层次结构,体现了由简单到复杂的认知过程;
继承 主要解决的问题是:共性的抽取,实现代码复用。
例如,上面的小猫和小狗的例子,我们可以把它们的共性抽取出来,然后把这些抽取出来的共性重新放到一个类当中:
public String name; public int age; public String sex; public void eat() { System.out.println(this.name+"吃饭"); }
此时,可以通过 关键字extends 构成一个继承关系:
三、继承的语法
//修饰符可以省略,也可以不用省略[修饰符] class 子类 extends 父类 { //继承的成员变量或方法}
【注意】
- 子类 会将父类中的成员变量或者成员方法 给继承到子类中;
- 子类继承父类之后,需要添加自己特有的成员,体现出与父类的不同,否则就没有必要继承了。
所以,对上面的例子 可以使用 继承 的方式来设计:
class Animal { public String name; public int age; public String sex; public void eat() { System.out.println(this.name+"吃饭"); } public void sleep(){ System.out.println("睡觉"); }}//Cat类class Cat extends Animal{ public void mew(){ System.out.println(this.name+"喵喵叫"); }}//Dog类class Dog extends Animal{ public void bark(){ System.out.println(this.name+"汪汪叫"); }}public class TestDemo { public static void main(String[] args) { Cat cat = new Cat(); cat.name = "喵喵"; cat.eat(); cat.mew(); Dog dog = new Dog(); dog.name = "汪汪"; dog.sleep(); dog.bark(); }}
四、父类成员访问
在继承体系中,子类将父类中的方法和字段继承下来了;
那在子类中能否直接访问 父类中继承下来的成员呢?
4.1 子类中访问父类的成员变量
1.子类和父类 不存在 同名成员变量
class Base{ public int a = 1; public int b = 2;}class Derived extends Base { public int c = 3; public int d = 4; public void test(){ System.out.println(a); System.out.println(b); System.out.println(c); System.out.println(d); }}public class TestDemo2 { public static void main(String[] args) { Derived derived = new Derived(); derived.test(); }}
画图示例:
结果示例:
2.子类和父类 成员变量存在同名情况
class Base3{ public int a = 1; public int b = 2;}class Derived3 extends Base3 { public int a = 3; public int d = 4; public void test(){ System.out.println("a = "+a); System.out.println("b = "+b); System.out.println("d = "+d); }}public class TestDemo3 { public static void main(String[] args) { Derived3 derived3 = new Derived3(); derived3.test(); }}
结果示例:
【结论】
由图可以看出,父类和子类都有相同的成员变量a,而最终打印的结果是 子类成员变量a 的值;
这就说明:如果 子类和父类的成员变量重名,那么 优先访问子类的成员变量;
这也可以理解,继承嘛,当自己的意志和父类的意志有冲突的时候,优先考虑一下自己的意志嘛!
那么,如果实在想访问父类的成员变量,很简单,使用关键字super;
这个会在下面详细的介绍。
4.2 子类访问父类的成员方法
1.子类和父类 成员方法 不存在同名的情况
class Base3{ public void method(){ System.out.println("Base3:method"); }}class Derived3 extends Base3 { public void method2(){ System.out.println("Derived3:method2"); } public void test(){ method(); method2();}public class TestDemo3 { public static void main(String[] args) { Derived3 derived3 = new Derived3(); derived3.test(); }
结果示例:
【总结】成员方法没有同名时,子类优先访问;如果子类没有所需的成员变量和成员方法,而父类也没有,那么程序将会报错。
2. 子类和父类 成员方法 存在同名的情况
class Base3{ public void method(){ System.out.println("Base3:method"); }}class Derived3 extends Base3 { public void method(int a){ System.out.println("Derived3:method2 "+a); } public void test(){ method(); method(100); }}public class TestDemo3 { public static void main(String[] args) { Derived3 derived3 = new Derived3(); derived3.test(); }}
结果示例:
【说明】
- 通过子类对象访问父类与子类中 不同名方法时,优先在子类中找,找到则访问;否则在父类中找,找到则访问;否则程序编译报错;
- 通过 子类 访问 父类与子类同名方法时,如果父类和子类 同名方法的参数列表不同(重载),根据调用方法 适传递的参数选择合适的方法访问,如果没有则报错;如果父类和子类 同名方法的原型一致(重写-后面会介绍的),这只能访问到子类的,父类的无法通过子类对象直接访问到。
五、super 关键字
由于设计不好,或者因场景需要,子类和父类 可能会存在相同名称的成员;
如果要在子类中访问父类同名成员时,那么应该怎么访问呢?
直接访问是无法做到的;
Java中提供了super关键字,该关键字的主要作用:在子类方法中访问父类的成员。
5.1 super.成员变量
5.2 super.成员方法
5.3 super.构造方法
下面请看一段代码:
package Demo1;class Animal { public String name; public int age; public void eat() { System.out.println(this.name + "正在吃饭"); }}class Cat extends Animal { public String hair; public void mew() { System.out.println(this.name + "正在叫"); }}public class Test { public static void main(String[] args) { Cat cat1 = new Cat(); cat1.name = "咪咪"; cat1.mew(); cat1.eat(); }}
代码运行结果:
当我们把 name和age的访问权限修改成private以后,子类就不去能访问了(注意是不能访问了,而不是没有被继承):
那么,此时可以去提供 getter和setter方法,再对代码进行修修改改:
package Demo1;class Animal {// public String name; private String name;// public int age; private int age; 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 void eat() { System.out.println(this.name + "正在吃饭"); }}class Cat extends Animal { public String hair; public void mew() { //System.out.println(this.name + "正在叫"); //System.out.println(this.getAge()); }}public class Test { public static void main(String[] args) { Cat cat1 = new Cat(); //cat1.name = "咪咪"; cat1.setName("咪咪"); cat1.mew(); cat1.eat(); }}
于是,这些成员就被赋初值了:
当然,我们曾经介绍过,赋初值的方法 除了setter和getter方法以外,还可以使用构造方法:
可是,当我们就直接加上构造方法的时候,代码就会报错啦:
这是为什么呢?
——原来,当构造子类的时候,一定要先帮助父类构造,再帮助子类构造。
所以说,还需要创建子类的构造方法,同时,要想先帮助父类构造,那可以用super关键字来进行调用:
【注意】
- 在调用构造方法的时候,和this一样,super必须放在第一行;
- 父子父子,先有父再有子,在子类当中可以通过super关键字来调用父类的构造方法;
- super不能在 静态方法中使用:
当然,我们也可以这样来写代码:
package Demo1;class Animal { private String name; private int age; 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 void eat() { System.out.println(this.name + "正在吃饭"); } public Animal() { } public Animal(String name, int age) { this.name = name; this.age = age; }}class Cat extends Animal { public String hair; public void mew() { System.out.println(this.getName() + "正在叫"); } public Cat() { super(); } public Cat(String name,int age,String hair){ super(name, age); this.hair = hair; }}public class Test { public static void main(String[] args) { Cat cat1 = new Cat("咪咪",8,"black"); cat1.mew(); cat1.eat(); }}
代码编译结果:
六、继承方式
在现实生活中,事物之间的关系是非常复杂、灵活多样的,比如:
但是,在Java中,只存在以下几种继承方式:
【注意】Java是不支持多继承的,即:不支持 一个子类有多个父类。
从上面来看,父类一层一层的被继承下去;
但是,如果不想被继承了,那到底该怎么做呢?
很简单,这就需要又引出了final关键字......
七、final关键字
当一个类被final关键字修饰以后,这个类就不能继承了:
【注意】
被final修饰的类,我们把它叫做密封类(说明 当前的类不能被继承);
以前也介绍过,被final修饰的成员不能被修改(变成了常量);
当然,final还可以修饰方法......
八、继承与组合
和继承类似,组合也是一种表达类之间关系的方式,也是可以达到代码复用的效果;
组合并没有涉及到特殊的语法(比如说 extends 这样的关键字),仅仅是将一个类的实例 作为另外一个类的字段;
继承 表示对象之间是 is-a 的关系,比如:小狗是动物,小猫是动物;
组合 表示对象之间是 has-a 的关系,比如:汽车;
汽车和其轮胎、发动机、方向盘、车载系统 等的关系就应该是组合,因为汽车就是由这些零部件组成的。
// 轮胎类class Tire{ // ...}// 发动机类class Engine{ // ...}// 车载系统类class VehicleSystem{ // ...}class Car{ private Tire tire; // 可以复用轮胎中的属性和方法 private Engine engine; // 可以复用发动机中的属性和方法 private VehicleSystem vs; // 可以复用车载系统中的属性和方法 // ...}// 奔驰是汽车class Benz extend Car{ // 将汽车中包含的:轮胎、发送机、车载系统全部继承下来 }
组合和继承都可以实现代码复用;
应该使用继承还是组合,需要根据应用场景来选择;
一般建议:能用组合尽量用组合。
如果大家对这个有很大兴趣的话,可以点击这个传送门:
深入理解Java中的组合和继承-传送门时刻准备中......
写在最后
那么,现在 Java的第二个特性——继承 也到此告一段落了;
由于博主水平有限,可能会出现一些表达不清楚,或者出现一些其他的情况,
欢迎各位铁汁们指出来,让博主一起改正,
一起努力,共同进步;
好了,如果这篇博客对铁汁们有帮助的话,可以送一个免费的 赞 嘛;
当然,顺手点个关注是再好不过的了......