继承的概念：继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
例如生活中的继承关系：
14B0951E-FC75-47A3-B611-4E1883887339.jpg
兔子和羊属于食草动物类，狮子和豹属于食肉动物类。食草动物和食肉动物又都是属于动物类。所以继承需要符合的关系是：is-a，父类更通用，子类更具体。虽然食草动物和食肉动物都是属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。
为什么需要继承
- 继承简化了人们对事物的认识和描述，能清晰体现相关类间的层次结构关系。
- 继承提供了软件复用功能。若类B继承类A，那么建立类B时只需要再描述与基类(类A)不同的少量特征(成员属性和成员方法)即可。这种做法能减小代码和数据的冗余度，大大增加程序的重用性。
- 继承通过增强一致性来减少模块间的接口和界面，大大增加了程序的易维护性。
继承类型
需要注意的是 Java 不支持多继承，但支持多重继承。如图 ：
java-extends-2020-12-08.png
继承的特性
- 子类拥有父类所有的属性、方法，但被 private 修饰的属性和方法子类无法直接访问。
- 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
- 子类可以用自己的方式实现父类的方法。
- Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
- 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。
继承关键字
继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承 Object(这个类在 java.lang 包中，所以不需要 import)祖先类。
在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，通过 extends 关键字可以申明一个类是从另外一个类继承而来的。extends 关键字只能继承一个类。一般形式如下：
class 父类 {
}
class 子类 extends 父类 {
}
implements关键字：使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。一般形式如下：
public interface A {
public void eat();
public void sleep();
}
public interface B {
public void show();
}
public class C implements A,B {
}
super 与 this 关键字
- super关键字：可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
- this关键字：指向自己的引用。this 关键字可以解决实例变量和局部变量之间发生的同名的冲突。
一般使用形式如下：
// 动物类 父类
class Animal {
void eat() {
System.out.println("animal : eat");
}
}
// 狗狗类 子类 继承动物类
class Dog extends Animal {
void eat() {
System.out.println("dog : eat");
}
void eatTest() {
this.eat(); // this 调用自己的方法
super.eat(); // super 调用父类方法
}
}
public class Test {
public static void main(String[] args) {
Animal a = new Animal();
a.eat();
Dog d = new Dog();
d.eatTest();
}
}
// 程序执行输出结果如下：
// a.eat()方法输出 animal : eat
// d.eatTest()方法中 this.eat()方法输出 dog : eat
// d.eatTest()方法中 super.eat()方法输出 animal : eat
final 关键字：final 可以用来修饰变量(包括类属性、对象属性、局部变量和形参)、方法(包括类方法和对象方法)和类。final 含义为 "最终的"。使用 final 关键字声明类，就是把类定义定义为最终类，不能被继承(注: final 定义的类，其中的属性、方法并不是 final 的)；使用 final 关键字修饰方法，该方法不能被子类重写。
声明类格式如下：
final class 类名 {//类体}
修饰方法格式如下：
修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}
构造器
子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动（隐式）在子类的构造器第一行调用父类的无参构造器；如果子类构造方法第一行显式调用了父类构造方法，则系统不在提供对父类的无参构造器的自动调用。
class SuperClass {
private int n;
SuperClass(){
System.out.println("SuperClass()");
}
SuperClass(int n) {
System.out.println("SuperClass(int n)");
this.n = n;
}
}
// SubClass 类继承
class SubClass extends SuperClass{
private int n;
SubClass(){ // 自动调用父类的无参数构造器
System.out.println("SubClass");
}
public SubClass(int n){
super(300); // 调用父类中带有参数的构造器
System.out.println("SubClass(int n):"+n);
this.n = n;
}
}
// SubClass2 类继承
class SubClass2 extends SuperClass{
private int n;
SubClass2(){
super(300); // 调用父类中带有参数的构造器
System.out.println("SubClass2");
}
public SubClass2(int n){ // 自动调用父类的无参数构造器
System.out.println("SubClass2(int n):"+n);
this.n = n;
}
}
public class TestSuperSub{
public static void main (String args[]){
System.out.println("------SubClass 类继承------");
SubClass sc1 = new SubClass();
SubClass sc2 = new SubClass(100);
System.out.println("------SubClass2 类继承------");
SubClass2 sc3 = new SubClass2();
SubClass2 sc4 = new SubClass2(200);
}
}
// 程序运行输出结果为：
// ------SubClass 类继承------
// SuperClass()
// SubClass
// SuperClass(int n)
// SubClass(int n):100
// ------SubClass2 类继承------
// SuperClass(int n)
// SubClass2
// SuperClass()
// SubClass2(int n):200
Java 转型问题
向上转型：通俗地讲即是将子类对象转为父类对象。此处父类对象可以是接口。向上转型不用强制转换。向上转型中的方法调用：
public class Upcasting {
public static void main(String[] args) {
// 向上转型
Animal bird = new Bird();
bird.eat();
// 调有时用子类作为参数
sleep(new Bird());
sleep(new Dog());
}
// 这里以父类做为方法参数
public static void sleep (Animal animal) {
// 方法睡
animal.sleep();
}
}
// 动物类，作为父类
class Animal {
// 方法 吃
public void eat() {
System.out.println("动物正在吃...");
}
// 方法 睡
public void sleep() {
System.out.println("动物正在睡...");
}
}
// 小鸟类 继承 动物类
class Bird extends Animal {
// 方法 吃
public void eat() {
System.out.println("小鸟正在吃...");
}
// 方法 飞翔
public void fly() {
System.out.println("小鸟正在飞翔...");
}
// 方法 睡
public void sleep() {
System.out.println("小鸟正在睡...");
}
}
//小狗类 继承 动物类
class Dog extends Animal {
// 方法 吃
public void eat() {
System.out.println("小狗正在吃...");
}
// 方法 跑
public void run() {
System.out.println("小狗正在跑...");
}
// 方法 睡
public void sleep() {
System.out.println("小狗正在睡...");
}
}
// 程序运行输出结果为：
// 小鸟正在吃...
// 小鸟正在睡...
// 小狗正在睡...
代码解析 ：
- Animal bird = new Bird() 向上转型时，bird 实际指向的是 Bird 子类，故 bird.eat() 调用方法时会调用子类本身的方法。
- 需要注意的是向上转型时 bird 会遗失除了与父类对象共有的其他方法。如本例中的 fly 方法不再为 bird 所有。
- Upcasting 类中定义的 sleep() 方法以父类 Animal 类对象为参数，调有时分别用子类 Bird 类对象与 Dog 类对象作为参数，结果分别调用了子类的 sleep() 方法，就是利用了向上转型。这样使代码变得简洁。不然的话，如果 sleep() 方法以子类对象为参数，则有多少个子类就需要写多少个函数。这也体现了 JAVA 的抽象编程思想。
向下转型：与向上转型相反，即是把父类对象转为子类对象。需要强制转换。向下转型中的方法调用：
public class Downcasting {
public static void main(String[] args) {
Girl girl = new Girl();
// 不安全的向下转型，girl指向的是父类对象，编译无错但会运行会出错 ClassCastException，所以需要添加判断
if(girl instanceof MMGirl) {
MMGirl mmgirl = (MMGirl)girl;
mmgirl.smile();
mmgirl.c();
}
// 向上转型
Girl girl2 = new MMGirl();
// 安全的向下转型，mmGirl指向的是子类对象，编译和运行皆不会出错
MMGirl mmGirl = (MMGirl) girl2;
mmGirl.smile();
mmGirl.c();
}
}
// 女孩类 作为父类
class Girl {
// 方法 微笑
public void smile(){
System.out.println("girl smile()...");
}
}
// MM女孩类 继承 女孩类
class MMGirl extends Girl{
// 方法 微笑
@Override
public void smile() {
System.out.println("MMGirl smile sounds sweet...");
}
// 方法 c
public void c(){
System.out.println("MMGirl c()...");
}
}
// 程序运行输出结果为：
// MMGirl smile sounds sweet...
// MMGirl c()...
总结：
- 1、父类引用指向子类对象，而子类引用不能指向父类对象。
- 2、把子类对象直接赋给父类引用叫 upcasting 向上转型，向上转型不用强制转换。
- 3、把指向子类对象的父类引用赋给子类引用叫 downcasting 向下转型，要强制转换。
网友评论