多态再回顾及final关键字

于 2020-11-25 22:37:59 发布
阅读量87 收藏
点赞数 2
文章标签： 多态 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guibar/article/details/110149666
版权

之前已经提过一次多态，这次详细分析下。

点鸡回顾

多态

概述

​ 多态是继封装性，继承性之后，面向对象的第三大特征。

定义

​ 多态:是指同一行为，具有多种不同的表现形式。

​ 同一行为通过不同的表现形式，可以表现出不同的形态。多态，描述的就是这样一种状态。

前提条件
  1. 继承或者实现【二选其一】
  2. 父类的引用指向子类的对象【格式体现】
  3. 方法的重写【意义:不重写，是无意义的】
多态的表现

​ 多态表现的格式:

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

​ 备注:父类类型指的是父类对象继承的父类类型，或者实现的父接口类型

public class Fu{
    public void method(){
        System.out.println("这是父类的method方法");
    }
}
//1.继承
public class Zi extends Fu{
    //2.重写
    @Override
    public void method(){
        System.out.println("这是子类的method方法被执行");
    }
}
// polymorphism 多态
public class TestPolyDemo01{
    public static void main(String[] args){
        // 3.父类的引用指向了子类的对象
        Fu fu = new Zi();
        fu.method();//本质调用的是子类当中重写之后的method方法
    }
}

如果在使用多态方式调用方法时，首先检查父类当中的是否有该方法，如果没有，则编译直接报错，如果有

，执行的是子类重写后的方法。

多态的好处

在实际开发中,父类类型作为方法的形式参数(不同于实际参数)，传递子类对象(实参)给方法，进行方法的

调用，更能体现出多态的扩展性和便利性。代码如下:

public abstract class Animal{
    // 定义一个抽象的方法
    public abstract void eat();
}
// 继承子类
public class Cat extends Animal{
    @Override
    public void eat(){
        System.out.println("猫吃鱼。。。");
    }
}
public class Dog extends Animal{
    @Override
    public void eat(){
        System.out.println("狗啃骨头。");
    }
}

public class Test{
    public static void main(String[] args){
        // 根据不同的对象,来表现不同的吃的内容
       // Cat c = new Cat();
       // showCatEat(c);// 猫吃鱼
        
       // Dog dog = new Dog();
       // showDogEat(dog);
        
        Cat c2 = new Cat();
        showAnimalEat(c2);
 
    }
    
   /* public static void showCatEat(Cat cat){
        cat.eat();
    }
    public static void showDogEat(Dog dog){
        dog.eat();
    }*/
    /*
      以上2个方法可以用多态来进行优化   
    */
    public static void showAnimalEat(Animal animal){
        animal.eat();
    }
    
}

说明:由于多态特性的支持，showAnimalEat()方法当中的Animal类型，是Cat和Dog 的父类类型，父类类型

接收子类对象，当然可以把cat对象和dog对象传递给方法

当程序执行过程中。执行eat方法实际执行的是各自子类对象重写之后的eat方法

不仅仅可以做到替代，在扩展性方面，无论之后出现多少个子类，都不需要编写showXxxEat方法了，直接

使用showAnimalEat()方法了。

所以，多态的好处，体现在可以使程序编写更简单，并且具有良好的扩展性。

访问类中的成员变量有两种方式:

1.直接通过对象名访问成员变量:看等号左边是谁，优先用谁，没有继续往上找

2.间接通过成员方法访问成员变量:看该方法属于谁，优先用谁，没有则继续往上找

// 定义一个父类
public class Fu{
    int num = 10;
    // 定义成员方法
    public void showNum() {
        System.out.println(num);
        @Override
        public void showNum(){
            System.out.println(num);
        }
    }
}
// 定义子类
public class Zi extends Fu{
    int num = 20;
}
// 定义测试类
public class TestPolyFieldDemo01{
    public static void main(String[] args){
        // 多态的表现形式
        // 父类类型 变量名 = new 子类对象;
        // 变量名.成员变量名
        Fu fu = new Zi();
       System.out.println(fu.num); // 10
        fu.showNum();//   20
    }
}
引用数据类型的转型

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

向上转型

多态本身就是子类类型向父类类型向上转型的过程，这个过程是默认的。

当一个父类引用指向了一个子类对象时，便是向上转型。

使用格式:

父类类型 变量名 = new 子类类型();
比如: Animal animal = new Cat();
向下转型

父类类型向子类类型向下转换的过程，这个过程时强制的。

一个已经向上转型的子类对象，将父类的引用转为子类引用，可以使用强制类型转换的格式

使用格式:

子类类型 变量名  =  (子类类型) 父类变量名;
比如: Cat cat = (Cat) animal;
转型异常

在进行向下转型的过程中，一不小心就出现java.lang.ClassCastException类型转换异常。

为了避免这种类型转换异常的发生，Java提供了instanceof关键字，给引用变量做类型的检验。

格式如下:

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

所以，我们在转换前，我们最好先进行引用变量的类型判断，代码如下:

public class Test(){
    public static void main(String[] args){
        // 向上转型
        Animal animal = new Cat();
        // 向下转型
        if (animal instanceof Cat){
            // 表明你就是一只猫
           Cat cat = (Cat) animal;
           cat.eat();// 吃鱼
           cat.catchMouse();// 逮老鼠
        } else if (animal instanceof Dog){
           // 表明你就是一只狗
            Dog dog = (Dog) animal;
            dog.lookDoor();
        }     
    }
}
final

由于Java当中提供了继承特性，子类可以在父类的基础上改写父类的内容，比如：方法的重写，那么能不能随意的继承API当中提供的类呢，改写其内容呢？显然是不行的，为了避免这种随意更改的情况，java提供了final关键字，用于修饰不可改变的内容。

  • ​ final：不可变。用于修饰类、方法和变量

    • ​ 类：被修饰的类，不能被继承

    • ​ 方法：被修饰的方法，不能被重写

    • ​ 变量：被修饰的变量，不能被【重新赋值】

使用方式

​ 修饰类

​ 格式如下：

  public final class 类名 {
  		// 类信息
  }

通过查询API发现，JDK官方提供了很多的被final修饰的类如：String、Math、Scanner、Character等，这些类都是被final修饰的，目的是让我们仅使用，而不让我们更改其内容。

​ 修饰方法

​ 格式如下：

修饰符   final   返回值类型   方法名（参数列表） {
    // 方法体内容。。。。。
}

重写final修饰的方法，编译无法通过。

​ 修饰变量

  1. 修饰局部变量------基本类型

    ​ 基本类型的局部变量，被final修饰后，只能赋值一次，不能被更改。代码如下：

    public class Demo {
	public static void main(String[] args) {
        // 声明局部变量
        final int num;
        // 第一次赋值
        num = 10;
        // 第二次赋值
      //  num = 20;// 编译报错
    }
}

    思考：

    ​ 如下两种写法，哪种可以通过编译？

    // 第一种写法
final int num = 0;
for (int i = 0; i < 10; i++) {
    num = i;
    System.out.println(num);     // 错误
}
// 第二种写法
for (int i = 0; i <10; i++){
    final int num = i;
    System.out.println(num); // 正确
}

    1. 局部变量---------引用类型

      引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能发生改变，但是不影响对象内部的成员变量的修改。代码如下：

      public class FinalDemo2 {
    public static void main(String[] args) {
        // 构建一个对象
        final   People  p1 = new People();
       // p1 = new People();// 报错，编译无法通过
        // 调用setName()方法
        p1.setName("小王");// 可以修改
    }
}

      1. 成员变量

        成员变量涉及到【初始化】的问题，初始化方式有两种，二选其一：

        ​ 显示初始化；

        public class People {
	final String NAME = "小王";
     private int age;
}

        构造方法初始化。

        public class People {
	final String NAME;
    private int age;
    public People(String name) {
        this.name = name;
    }
}

​ 备注：被final修饰的常量名称，一般都有书写规范，所有字母均为【大写】。

guibar
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值