Java继承与多态的概念是什么及怎么实现

这篇文章主要介绍“Java继承与多态的概念是什么及怎么实现”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“Java继承与多态的概念是什么及怎么实现”文章能帮助大家解决问题。

一、继承

1、继承的概念

继承机制：是面向对象程序设计是代码可以复用的最重要手段，允许程序员在保持原有类特性的基础上进行扩展，增加新的功能，产生的新类，成为派生类/子类。继承主要解决的问题是：共性的抽取，实现代码的复用。

2、继承的语法

表示类与类的继承关系，需要借助关键字extends，语法如下：

修饰符  class  子类/派生类   extends  父类/基类/超类{

       //…………

}

• 子类会将父类的成员变量或者成员方法继承到子类中

• 子类继承父类后，必须添加自己特有的成员，体现与基类的不同

3、父类成员访问

（1）子类中访问父类的成员变量

• 不存在同名成员变量时，正常访问就行

• 存在同名成员变量，使用（super.变量名）实现父类成员变量的访问

public class Base {    int a;    int b;    int c;} public class Derived extends Base{    int a; // 与父类中成员a同名，且类型相同    char b; // 与父类中成员b同名，但类型不同    public void method(){        a = 100; // 访问父类继承的a，还是子类自己新增的a？        b = 101; // 访问父类继承的b，还是子类自己新增的b?        c = 102; // 子类没有c，访问的肯定是从父类继承下来的c    }}

• 访问成员变量时，优先访问自己的成员变量。即同名成员变量访问时，优先访问子类的。即：子类将父类的成员隐藏了

• 成员变量访问遵循就近原则，自己有优先自己的，自己没有则向父类中查找。

（2）子类中访问父类的成员方法

• 成员方法名字不同，正常访问即可

• 成员方法名字相同，可以通过 【super.方法名】访问同名父类方法

如果父类和子类同名方法的参数列表不同（重载），根据调用方法时传递的参数选择合适的方法访问。

如果父类和子类的同名方法原型一致，则访问子类的

4、super关键字

super关键字的主要作用是：在子类方法中访问父类的同名成员。（只能在非静态方法中使用）

public class Base {    int a;    int b;    public void methodA(){        System.out.println("Base中的methodA()");    }    public void methodB(){        System.out.println("Base中的methodB()");}public class Derived extends Base{    int a;     char b;     // 与父类中methodA()构成重载    public void methodA(int a) {        System.out.println("Derived中的method()方法");    }    // 与父类中methodB()构成重写    public void methodB(){        System.out.println("Derived中的methodB()方法");    }    public void methodC(){        a = 100; // 等价于： this.a = 100;        b = 101; // 等价于： this.b = 101;        // 访问父类的成员变量时，需要借助super关键字        // super是获取到子类对象中从基类继承下来的部分        super.a = 200;        super.b = 201;        methodA(); // 没有传参，访问父类中的methodA()        methodA(20); // 传递int参数，访问子类中的methodA(int)        methodB(); // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到        super.methodB(); // 访问基类的methodB()    }}

5、子类构造方法

子类对象构造时，需要先调用父类的构造方法，然后执行子类的构造方法。

public class Base {    public Base(){        System.out.println("Base()");    }}public class Derived extends Base{    public Derived(){   // super(); // 注意子类构造方法中默认会调用基类的无参构造方法：super(),   // 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，   // 并且只能出现一次        System.out.println("Derived()");    }}

• 若父类显示定义无参或者默认的构造函数，在子类的构造方法第一行默认有隐含的super()调用。

• 父类定义带参数的构造方法时，编译器不会再给子类生成默认的构造方法，需要子类显式定义，并在子类构造方法中调用合适的父类构造方法

• 子类构造方法中，super(……)调用父类构造方法，必须是子类构造方法的第一条语句

• super(……)只能在子类构造方法中出现一次，并且不能和this同时出现

6、super和this

super和this都可以在成员方法中用来访问成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，那么它们之间的区别是什么？

（1）相同点

• 都是java的关键字

• 只能在类的非静态方法中使用，用来访问非静态成员方法和属性

• 必须作为构造方法中的第一条语句，并且不能同时存在

（2）不同点

• this是当前对象的引用，super是子类对象中从父类继承的成员的引用

• this是非静态成员方法的一个隐藏参数，super不是隐藏参数

• 在构造方法中：this()用于调用本类的构造方法，super()用来调用父类构造方法，两种调用不能同时出现在构造方法中

• 子类的构造方法中一定会存在super()的调用，但是this()用户不写就没有

7、代码块执行顺序

【普通类】

• 静态代码块先执行，并且只执行一次，在类加载阶段执行

• 当有对象创建时，才会执行实例代码块，最后执行构造方法

【继承关系上的执行顺序】

• 父类静态代码块优先于子类静态代码块执行，最早执行

• 父类实例代码块和父类构造方法紧接着执行

• 子类的实例代码块和构造方法最后执行

• 第二次实例化子类对象时，父类和子类的静态代码块不会再执行

8、继承方式

【注】Java中不支持多继承

• super只能指代直接父类

• 继承关系一般不超过三层

9、final关键字

• 修饰变量时，表示常量（不能修改）

• 修饰类：此类不能被继承

• 修饰方法：表示方法不能被重写

10、继承和组合

组合和继承都能实现代码的复用。组合没有涉及到特殊的语法（如extend关键字），仅仅是将一个类的实例作为另一个类的属性。

• 继承表示对象与对象之间是is-a的关系

• 组合表示对象与对象之间是has-a的关系

一般建议：能用组合尽量用组合

二、多态

1、向上转型

通过父类类型的引用调用子类对象，向上转型是安全的

【发生向上转型的时机】

• 直接赋值

• 方法传参

• 函数的返回值

public class TestAnimal {    // 2. 函数传参：形参为父类引用，可以接收任意子类的对象    public static void eatFood(Animal a) {        a.eat();    }     // 3. 作返回值：返回任意子类对象    public static Animal buyAnimal(String var) {        if ("狗" == var) {            return new Dog("狗狗", 1);        } else if ("猫" == var) {            return new Cat("猫猫", 1);        } else {            return null;        }    }     public static void main(String[] args) {        Animal cat = new Cat("元宝", 2); // 1. 直接赋值：子类对象赋值给父类对象        Dog dog = new Dog("小七", 1);    }}

优缺点：

• 优点：让代码更加灵活

• 缺点：不能访问到子类特有的方法

2、重写

函数名相同、参数列表相同、返回值相同或是【协变类型】（父子类关系）

【方法重写的规则】

• 重写的方法访问权限不能比父类中原方法的的权限低；

• 父类中被static、private、final修饰的方法、构造方法不能被重写；

• 重写的方法，可以使用 @override 注解来显示指定（帮助我们进行一些合法性的检验）。比如方法名拼写错误，编译会报错；

• 重写的返回值类型可以不同，但是必须具有父子关系。

• 被final修饰的方法，叫做密封方法，该方法不能被重写。

• 外部类只能是public或者默认权限

【动态绑定和静态绑定】

• 动态绑定：发生的条件（1、父类引用引用子类对象；2、通过父类引用，可以访问到子类中的方法）。后期绑定，即在编译时不能确定方法的行为，需要等到程序运行时，才能够确定调用哪个类的方法；

• 静态绑定：前期绑定，编译时，根据用户传递的参数类型确定具体的调用方法（函数重载）

3、多态

一个引用调用同一个方法，可以表现出不同的形式，这种思想称为多态。在父类的构造方法中不要调用重写的方法。

【多态实现的条件】

• 必须在继承条件下

• 子类对父类方法进行重写

• 通过父类引用调用重写的方法

• 发生了向上转型

public class Animal(){    String name;    int age;    public Animal(String name, int age){        this.name = name;        this.age = age;    }    public void eat(){        System.out.println(name + "吃饭");        }}public class Cat extends Animal{    public Cat(String name, int age){        super(name, age);    }    @Override    public void eat(){        System.out.println(name+"吃鱼~~~");    }}public class Dog extends Animal {    public Dog(String name, int age){        super(name, age);    }    @Override    public void eat(){        System.out.println(name+"吃骨头~~~");    }}public class TestAnimal {    // 编译器在编译代码时，并不知道要调用Dog 还是 Cat 中eat的方法   // 等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法   // 注意：此处的形参类型必须时父类类型才可以    public static void eat(Animal a){        a.eat();    }    public static void main(String[] args) {        Animal animal1 = new Cat("元宝",2);        Animal animal2 = new Dog("小七", 1);        eat(animal1);        eat(animal2);    }}

【注】Java中所有的类默认继承Object类

关于“Java继承与多态的概念是什么及怎么实现”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识，可以关注编程网精选频道，小编每天都会为大家更新不同的知识点。