Java基础之继承与多态

其他 2020-04-20 10:33:53 阅读次数: 0

1. 继承

1.1 概述

由来

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要 继承那一个类即可
在这里插入图片描述
继承描述的是事物之间的所属关系，这种关系是： is-a 的关系。例如，图中波斯猫属于猫类，猫属于动 物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。

定义

  • 继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为

好处

  • 提高代码的复用性。
  • 类与类之间产生了关系，是多态的前提。

1.2 继承的格式

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类 
{ 
    ...
}   
class 子类 extends 父类 {
    ... 
}

代码实现

/*
  定义员工类Employee，做为父类
*/ 
class Employee {
    String name; // 定义name属性
    // 定义员工的工作方法  
    public void work() {
        System.out.println("尽心尽力地工作");
    }
}
/*
 定义讲师类Teacher 继承 员工类Employee 
*/ 
class Teacher extends Employee { 
    // 定义一个打印name的方法
    public void printName() {
        System.out.println("name=" + name); 
    } 
} 
/*
 定义测试类 
*/
public class Test {
    public static void main(String[] args) {
        // 创建一个讲师类对象 
        Teacher t = new Teacher();
        // 为该员工类的name属性进行赋值
        t.name = "小明";
        // 调用该员工的printName()方法 
        t.printName(); // name = 小明 ]
        // 调用Teacher类继承来的work()方法 
        t.work();  // 尽心尽力地工作
    }
}

1.3 成员变量

成员变量不重名

如果子类父类中出现不重名的成员变量，这时的访问是没有影响的

class Fu {
    //Fu中的成员变量
    int num = 5;
}

class Zi extends Fu {
    //Zi中的成员变量
    int num2 = 6;

    //Zi中的成员方法
    public void show() {
        // 访问父类中的num
        System.out.println("Fu num = " + num);// 继承而来,所以直接访问
        // 访问子类中的num2
        System.out.println("Zi num2 = " + num2);
    }
}
class Test{
    public static void main(String[] args) {
        // 创建子类对象
        Zi z = new Zi();
        // 调用子类中的show()方法
        z.show();
    }
}
演示结果：
Fu num = 5
Zi num2 = 6

成员变量重名

如果子类父类中出现重名的成员变量，这时的访问是有影响的

class Fu {
    //Fu中的成员变量
    int num = 5;
}

class Zi extends Fu {
    //Zi中的成员变量
    int num = 6;

    //Zi中的成员方法
    public void show() {
        // 访问父类中的num
        System.out.println("Fu num = " + num);
        // 访问子类中的num
        System.out.println("Zi num = " + num);
    }
}
class Test{
    public static void main(String[] args) {
        // 创建子类对象
        Zi z = new Zi();
        // 调用子类中的show()方法
        z.show();
    }
}
演示结果:
Fu num = 6
Zi num = 6

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰父类成员变量，类似于 this关键字 。

  • 使用格式:
super.父类成员变量

子类方法修改:

class Zi extends Fu {
    //Zi中的成员变量
    int num = 6;

    //Zi中的成员方法
    public void show() {
        // 访问父类中的num
        System.out.println("Fu num = " + super.num);
        // 访问子类中的num
        System.out.println("Zi num = " + this.num);
    }
}
演示结果:
Fu num = 5
Zi num = 6

1.4 成员方法

成员方法不重名

如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法.

class Fu {
    public void show() {
        System.out.println("Fu类中的show方法执行");
    }
}
class Zi extends Fu {
    public void show2(){
        System.out.println("Zi类中的show2方法执行");
    }
}
public class Test{
    public static void main(String[] args) {
        Zi z = new Zi();
        //子类中方没有show方法,但是可以找到父类方法区执行
        z.show();;
        z.show2();
    }
}

成员方法重名–重写(Override)

如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (Override)。

  • 方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同）,会出现覆盖效 果,也称为重写或者复写。声明不变，重新实现
class Fu {
    public void show() {
        System.out.println("Fu类中的show方法执行");
    }
}
class Zi extends Fu {
    //子类重写了父类的show方法
    public void show(){
        System.out.println("Zi类中的show2方法执行");
    }
}
public class Test{
    public static void main(String[] args) {
        Zi z = new Zi();
        //子类中方有show方法,只执行重写后的show方法
        z.show();//Zi类中的show2方法执行
    }
}

重写的应用

子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强

class Phone{
    public void sendMessage(){
        System.out.println("发短信");
    }
    public void call(){
        System.out.println("打电话");
    }
    public void showNum(){
        System.out.println("来电显示号码");
    }
}
//智能手机类
class NewPhone extends Phone{
    //重写父类的来电显示号码功能,并增加自己的显示姓名和图片的功能
    public void showNum(){
        //调用父类已经存在的功能使用super
        super.showNum();
        //增加自己特有显示姓名和图片的功能
        System.out.println("显示来电姓名");
        System.out.println("显示头像");
    }
}
public class Test{
    public static void main(String[] args) {
        //创建子类对象
        NewPhone np = new NewPhone();
        //调用该父类继承而来的方法
        np.call();
        //调用子类重写的方法
        np.showNum();
    }
}
  • 子类方法覆盖父类方法,必须保证权限大于等于父类权限.
  • 子类方法覆盖父类方法,返回值类型,函数名和参数列表都要一摸一样.

1.5 构造方法

  • 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的
  • 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构 造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。
class Fu{
    private int n;
    Fu(){
        System.out.println("Fu()");
    }
}
class Zi extends Fu{
    Zi(){
        // super (),调用父类的构造方法
        super();
        System.out.println("Zi()");
    }
}
public class Test{
    public static void main(String[] args) {
        Zi zi = new Zi();
    }
}
输出结果:
Fu()
Zi()

1.6 super和this

父类空间优先于子类对象产生

在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空 间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构 造方法调用时，一定先调用父类的构造方法
在这里插入图片描述

super和this的含义

  • super:代表父类的存储空间标识(可以理解为父类的引用).
  • this:代表当前对象的引用(谁调用就代表谁).

super和this的用法

  • 访问成员
this.成员变量       --   本类的
super.成员变量      --   父类的

this.成员方法名()   --   本类的
super.成员方法名()  --   父类的
  • 访问构造方法
this()   --   本类的构造方法
super()  --   父类的构造方法

子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。 super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

1.7 继承的特点

  • Java只支持单继承,不支持多继承.
//一个类只能有一个父类,不可以有多个父类.
class C extends A{} //ok
class C extends A,B{} //error
  • Java支持多层继承(继承体系)
class A{}
class B extends A{}
class c extends B{}

顶层父类是Object类,所有的类默认继承Object ,作为父类

  • 子类和父类是一种相对的概念

2. 多态

2.1 概述

引入

多态是继封装,继承之后,面向对象的第三大特性
生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也 是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态

定义

  • 多态:是指同一行为,具有多个不停表现形式.

前提

  • 继承或者实现
  • 方法的重写[意义体现:不重写,无意义]
  • 父类引用指向子类对象[格式体现]

2.2 多态额体现

多态体现的格式:

父类对象 变量名 = new 子类对象;
变量名.方法名();

父类类型:指子类对象继承的父类类型,或者实现的父类接口类型.

Fu f = new Zi();
f.method();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写 后方法。

//定义父类:
abstract class Animal{
    public abstract void eat();
}
//定义子类
class Cat extends Animal{
    public void eat(){
        System.out.println("吃鱼");
    }
}
class Dog extends Animal{
    public void eat(){
        System.out.println("吃骨头");
    }
}
//定义测试类
public class Test{
    public static void main(String[] args) {
        //多态形式,创建对象
        Animal a1 = new Cat();
        //调用的是Cat的eat
        a1.eat();
        //多态形式,创建对象
        Animal a2 = new Dog();
        //调用的是Dog的eat
        a2.eat();
    }
}

2.3 多态的好处

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展 性与便利

//定义父类:
abstract class Animal{
    public abstract void eat();
}
//定义子类
class Cat extends Animal{
    public void eat(){
        System.out.println("吃鱼");
    }
}
class Dog extends Animal{
    public void eat(){
        System.out.println("吃骨头");
    }
}
//定义测试类
public class Test{
    public static void main(String[] args) {
        //多态形式,创建对象
        Cat c = new Cat();
        Dog d = new Dog();
        //调用showCatEat
        showCatEat(c);
        //调用showDogEat
        showDotEat(d);
        /*
        以上两个方法,均可以showAnimalEat(Animal a)方法所替代
        而执行效果一样
         */
        showAnimalEat(c);
        showAnimalEat(d);
    }
    private static void showDotEat(Dog d) {
        d.eat();
    }
    private static void showCatEat(Cat c) {
        c.eat();
    }
    private static void showAnimalEat(Animal a) {
        a.eat();
    }    
}

2.4 引用类型转换

多态的类型转换分为向上转型和向下转型两种:

向上转型

  • 向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认.
  • 格式:
父类类型 变量名 = new 子类类型();
Animal a = new Cat;

向下转型

  • 向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的
  • 格式:
子类类型 变量名 = (子类类型) 父类变量名;
Cat c = (Cat) a;

为什么要转型

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥 有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子 类特有的方法，必须做向下转型

//定义父类:
abstract class Animal {
    public abstract void eat();
}

//定义子类
class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }

    public void catchMouse() {
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头");
    }
    public void watchHouse(){
        System.out.println("看家");
    }
}

//定义测试类
public class Test {
    public static void main(String[] args) {
        //向上转型
        Animal a = new Cat();
        a.eat();    //调用的是Cat的eat
        //向下转型
        Cat c = (Cat) a;
        c.catchMouse(); //调用的是Cat的catchMouse
    }
}

转型的异常

public class Test {
    public static void main(String[] args) {
        //向上转型
        Animal a = new Cat();
        a.eat();    //调用的是Cat的eat
        //向下转型
        Dog d = (Dog) a;
        d.watchHouse(); //调用的是 Dog 的 watchHouse 【运行报错】 
    }
}

这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了 Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。

为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验,格式如下：

变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。 
如果变量不属于该数据类型，返回false

public class Test {
    public static void main(String[] args) {
        //向上转型
        Animal a = new Cat();
        a.eat();    //调用的是Cat的eat
        //向下转型
        if (a instanceof Cat){
            Cat c = (Cat) a;
            c.catchMouse(); // 调用的是 Cat 的 catchMouse 
        }else if (a instanceof  Dog) {
            Dog d = (Dog) a;
            d.watchHouse(); //调用的是 Dog 的 watchHouse 
        } 
    }
}
～崔斯坦
发布了24 篇原创文章 · 获赞 27 · 访问量 2050
私信 关注

猜你喜欢

转载自blog.csdn.net/weixin_45860268/article/details/103578137
今日推荐
周排行
深度学习------Lingvo框架下的加速通道GPipe
webjars管理静态资源
C专家编程_2.2
mysql 源码安装
json文件操作
123231432
注解的实现
Spring MVC 控制器
《人月神话》读后感二
C#使用HttpWebRequest和HttpWebResponse上传文件示例
每日归档
更多
2024-09-08(0)
2024-09-07(0)
2024-09-06(0)
2024-09-05(0)
2024-09-04(0)
2024-09-03(0)
2024-09-02(0)
2024-09-01(0)
2024-08-31(0)
2024-08-30(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022