面向对象-多态(抽象、方法重写、模板设计、强制类型转换)

猪猪每天在进步(ง ˙o˙)ว

已于 2024-02-03 17:31:17 修改

阅读量1.4k

点赞数 40

文章标签： java github git windows idea intellij-idea

于 2024-02-03 17:30:29 首次发布

本文链接：https://blog.csdn.net/qq_64391254/article/details/136008593

版权

什么是多态
多态是在继承/实现情况下的一种现象，表现为：对象多态，行为多态

多态的具体代码实现

Student类和Teacher都继承了People类

package com.zz.polymorphism;

public class Test {
    public static void main(String args[]){
        //目标：认识多态，对象多态，行为多态

        //1.对象多态
        People p1 = new Teacher();
        People p2 = new Student();

        //2.行为多态
        p1.run();//识别技巧：编译看左边，运行看右边
        p2.run();

        System.out.println(p2.name);//对于变量编译看左边，运行看左边
    }
}

多态的前提

有继承/实现关系，存在父类引用子类对象；存在方法重写。

多态的一个注意事项

多态是对象、行为的多态，java中的属性（成员变量）不谈多态。

使用多态的好处

在多态形式下，右边对象是解耦合的，便于扩展和维护。
定义方法时，使用附列类型的形参，可以接受一切子类对象，扩展性更强，更便利。

 Student s = new Student();
 go(s);

 Teacher t = new Teacher();
 go(t);

 //好处2.可以使用父类类型的变量作为形参，可以接收一切子类对象
    public static void go(People p){
        p.run();
    }

多态存在的问题

多态下不能使用子类的独有功能。

解决：使用类型转换

类型转换解决多态问题

自动类型转换：父类变量名 = new 子类();

People p = new Teacher();

强制类型转换：子类变量名 = (子类) 父类变量

Teacher t = (Teacher)p;

强制类型转换的一个注意事项

存在继承/实现关系就可以在编译阶段进行强制类型转换，编译阶段就不会报错。
运行时，如果发现对象的真实类型与强转后的类型不同，就会报类型转换异常（ClassCastException）的错误出来。

  People p2 = new Student();
  
  Teacher teacher = (Teacher)p2;//编译不报错，运行时发现对象类型错误

强转前，Java建议：

使用Instanceof关键字，判断当前对象的真实类型，再进行强转。

//解决
        if(p1 instanceof Student){
            Student s1 = (Student)p1;
        }else{
            Teacher t1 = (Teacher)p1
        }

final关键字

final关键字是最终的意思，可以修饰（类、方法、变量）。
修饰类：该列被称为最终类，特点是不能被继承了。
修饰方法：该方法称为最终方法，特点是不能被重写了。
修饰变量：该变量只能被赋值一次。

package com.zz.Final;

public class Test {
//   常量：public static final修饰的成员变量，建议名称全部大写，多个单词使用下划线连接
    public static final String NAME  = "中国";
    public static void main(String args[]){
        //目标：认识final的作用
        //3.final可以修饰变量总规则，有且仅能赋值一次
        /**
         * 变量:
         * 一、局部变量
         * 二、成员变量
         *      1.静态成员变量
         *      2.实例成员变量
         */
        final int a;
        a = 12;
//        a = 13;第二次赋值，出错

        final double r = 3.14;
//        r = 3;第二次赋值，出错

//        NAME = "美国";第二次赋值，出错

    }

    //1.final修饰类，类不能被继承了
    final class A{
    }
//    class B extends A{}

    //2.final修饰方法，方法不能被重写了
    class C{
        public final void test(){}
    }
    class D extends C{
//        public void test(){}
    }
}

final修饰变量的注意

final修饰基本类型的变量，变量存储的数据不能被改变。

常量

使用了static final修饰的成员变量被称为常量。
作用：通常用于记录系统的配置信息

使用常量记录系统配置信息的优势、执行原理

提高代码的可读性，可维护性也更好。
程序编译后，常量会被“宏替换”：出现常量的地方全部会被替换成其记住的字面量，这样可以保证使用常量和直接使用字面量的性能是一样的。

抽象类

什么是抽象类

在Java中有一个关键字叫：abstract,它就是抽象的意思，可以用它修饰类，成员方法。
abstract修饰类，这个类就是抽象类，修饰方法，这个方法就是抽象方法。
写法：修饰符 abstract class 类名{
修饰符 abstract 返回值类型方法名称（形参列表）
}

public abstract class A{
    //抽象方法：必须abstract修饰，只有方法签名，不能有方法体
    public abstract void test();
}

抽象类的注意事项、特点

抽象类中不一定有抽象方法，有抽象方法一定是抽象类。
类该有的成员（成员变量，方法，构造器）抽象类都可以有。
抽象类最主要的特点：抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。
一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。

抽象类的场景和好处

父类知道每个子类都要做某个行为，但每个子类要做的情况不一样，父类就等定义成抽象方法，交给子类去重写实现，可以更好的支持多态。

模板方法设计

写法