Java基础入门12：面向对象高级二（多态、final、抽象类、接口）

叶芋爱耗者

已于 2024-07-20 14:19:43 修改

阅读量821

点赞数 27

分类专栏： Java 文章标签： java 开发语言

于 2024-07-20 11:17:08 首次发布

本文链接：https://blog.csdn.net/2301_80944764/article/details/139561168

版权

Java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

面向对象三大特征之三：多态

什么是多态？

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

多态的前提是：有继承/实现关系；存在父类引用子类对象；存在方法重写。

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

package com.itchinajie.d1_polymorphism;

public class Test {
    public static void main(String[] args) {
        //目标：认识多态：对象多态、行为多态
        //1、对象多态
        People p1 = new Student();
        p1.run();//识别技巧：编译看左边，运行看右边
        System.out.println(p1.name);//注意：对于变量，编译看左边，运行看左边

        People p2 = new Teacher();
        p2.run();//识别技巧：编译看左边，运行看右边
        System.out.println(p2.name);//注意：对于变量，编译看左边，运行看左边
    }
}


package com.itchinajie.d1_polymorphism;
//父类
public class People {
    public String name = "父类People的名称";
    public void run(){
        System.out.println("人可以跑~~");
    }
}

package com.itchinajie.d1_polymorphism;

public class Student extends People{
    public String name = "子类Student的名称";

    @Override
    public void run(){
        System.out.println("学生跑的贼快~~");
    }
}

package com.itchinajie.d1_polymorphism;

public class Teacher extends People{
    public String name = "子类Teacher的名称";

    @Override
    public void run(){
        System.out.println("老师跑的气喘吁吁~~");
    }
}

使用多态的好处

可以解耦合，扩展性更强；使用父类类型的变量作为方法的形参时可以接收一切子类对象。

但是多态下不能直接调用子类的独有方法，我们可以通过强制类型转换进行解决：

//目标：理解多态的好处
        //好处1：可以实现解耦合，右边对象可以随时切换，后续业务随机改变
        People p1 = new Student();
        p1.run();
        //p1.test();//3、弊端：多态下不能使用子类的独有功能，怎么解决
        //强制类型转换
        Student s1 = (Student) p1;
        s1.test();
//好处2：可以使用父类类型的变量作为形参，可以接收一切子类对象。
        Student s = new Student();
        go(s);

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


    }
    public static void go(People p){
        p.run();
        if(p instanceof Student){
            Student s = (Student) p;
            s.test();
        }else if (p instanceof Teacher){
            Teacher t = (Teacher) p;
            t.teach();
        }
    }

多态下类型转换的问题

编译阶段有继承或者实现关系就可以强制转换，但是运行时可能出现类型转换异常。

 //强制类型转换可能存在的问题：编译阶段有继续或者实现关系就可以强制转换，但是运行时可能出现类型转换异常
        //Teacher t1 = (Teacher) p1;//运行时出现了：ClassCastException
        //t1.teach();

        //强转前，Java建议：使用instanceof关键字，判断当前对象的真实类型，再进行强转。
        if(p1 instanceof Student){
            Student s2 = (Student) p1;
            s2.test();
        }else if (p1 instanceof Teacher){
            Teacher t2 = (Teacher) p1;
            t2.teach();
        }

final关键字

final关键字是最终的意思，可以修饰(类、方法、变量)

修饰类：该类被称为最终类，特点是不能被继承了。

修饰方法：该方法被称为最终方法，特点是不能被重写了。

修饰变量：该变量只能被赋值一次。

final修饰变量的注意

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

filna修饰引用类型的变量，变量存储的地址不能被改变，但地址所指向对象的内容是可以被改变的。

package com.itchinajie.d3_final;

public class Test {
    /*
    常量：public static final修饰的成员变量，建议名称全部大写，多个单词下划线链接
    */
    public static final String SCHOOL_NAME = "黑马";

    private final String name= "牛逼";//这种用法没有意义

    public static void main(String[] args) {
        //目标：认识final的作用
        //3、final可以修饰变量总规则：有且仅能赋值一次
        /*变量：
        * 一、局部变量
        * 二、成员变量
        *    1、静态成员变量
        *    2、实例成员变量*/
        final int a;
        a = 1;
       // a = 2;//第二次赋值，出错了

        final double r = 3.14;
        //r = 0.1;//报错

        final int[] arr = {22,11,33};
        //arr = null;//改地址有问题
        arr[1] = 333;//该数值没问题

        //SCHOOL_NAME = "白马";//报错

        //t.name = "孙悟空";//报错
    }
    public static void buy(final double z){
        //z = 1;//第二次赋值，报错
    }
}
//1、final修饰类，类不能被继承了
final class A{
}
/*
class B extends A{
}
*/

//2、final修饰方法了，方法就不能被重写了
class C{
    public final void test(){

    }
}
class D extends C{
//    @Override
//    public void test() {
//        super.test();
//    }
}

这里有个东西叫做常量

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

package com.itchinajie.d3_final;


public class Test2 {
    //软编码

    public static final String SCHOOL_NAME = "黑马程序员";

    public static void main(String[] args) {
        //目标：认识常量
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        /*
        硬编码
        System.out.println("黑马程序员");
        System.out.println("黑马程序员");
        System.out.println("黑马程序员");
        System.out.println("黑马程序员");
        System.out.println("黑马程序员");
        System.out.println("黑马程序员");
   */
    }
}

注意！常量名的命名规范：建议使用大写英文单词，多个单词使用下划线连接起来。

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

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

抽象类

在到ava中有一个关键字叫：abstract,它就是抽象的意思，可以用它修饰类、成员方法。

abstract修饰类，这个类就是抽象类；修饰方法，这个方法就是抽象方法。

package com.itchinajie.d4_abstract;

public abstract class A {
    private String name;
    public static String schoolName;

    public A() {
    }
    //抽象方法：必须用abstract修饰，只有方法签名，一定不能有方法体
    public abstract void run();
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static String getSchoolName() {
        return schoolName;
    }

    public static void setSchoolName(String schoolName) {
        A.schoolName = schoolName;
    }

    public A (String name){
        this.name = name;
    }
}

抽象类的注意事项和特点

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。

类该有的成员(成员变量、方法、构造器)抽象类都可以有。

抽象类最主要的特点：抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。

一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。

抽象类的好处

通过一个小案例来总结一下：

需求：
某宠物游戏，需要管理猫、狗的数据。
猫的数据有：名字；行为是：喵喵喵的叫~
狗的数据有：名字；行为是：汪汪汪的叫~
请用面向对象编程设计该程序。

一共创建四个类

package com.itchinajie.d5_abstract2;

public class Test {
    public static void main(String[] args) {
        //目标：掌握抽象类的好处
        Animal a = new Cat();
        a.setName("叮当猫");
        a.cry();//更好的支持了多态
    }
}

Animal抽象类

package com.itchinajie.d5_abstract2;

public abstract class Animal {
    private String name;

    public abstract void cry();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}


package com.itchinajie.d5_abstract2;

import com.itchinajie.d4_abstract.A;

public class Cat extends Animal{
    @Override
    public void cry(){
        System.out.println(getName() + "喵喵喵的叫~~");
    }

}


package com.itchinajie.d5_abstract2;

public class Dog extends Animal{
    @Override
    public void cry(){
        System.out.println(getName() + "汪汪汪的叫~~");
    }
}

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

建议使用finals关键字修饰模板方法，为什么？

模板方法是给对象直接使用的，不能被子类重写。
一旦子类重写了模板方法，模板方法就失效了。

抽象类的常见应用场景：模板方法设计模式

模板方法设计模式解决了什么问题？

解决方法中存在重复代码的问题。

模板方法设计模式的写法

1、定义一个抽象类。
2、在里面定义2个方法
一个是模板方法：把相同代码放里面去。
一个是抽象方法：具体实现交给子类完成。

package com.itchinajie.d6_abstact_temp;

public class Test {
    //目标：搞清楚抽象类的应用场景之一，经常用来设计模板方法设计模式
    //场景：学生，老师都要写一篇作文：我的爸爸
    //第一段是一样的
    //正文部分自由发挥
    //最后一一段也是一样的
    public static void main(String[] args) {
        Teacher t = new Teacher();
        t.write();
    }
}

package com.itchinajie.d6_abstact_temp;

public abstract class People {
    /*
    * 设计一个模板方法设计模式
    * 1、定义一个模板方法出来
    * */
    public void write(){
        System.out.println("\t\t\t\t\t《我的爸爸》");
        System.out.println("\t\t我的爸爸好啊，牛逼啊，来看我的爸爸有多牛");
        //2、模板方法并不清楚正文部分到底应该怎么写，但是他知道子类肯定要写
        System.out.println(writeMain());
        System.out.println("有这样的爸爸太好了");
    }
    //3、设计一个抽象方法写正文，具体的实例交给子类来完成
    public abstract String writeMain();

}

package com.itchinajie.d6_abstact_temp;

public class Student extends People{
    @Override
    public String writeMain(){
        return "我的爸爸特别牛，我开车都不看红绿灯~~";
    }

}

package com.itchinajie.d6_abstact_temp;

public class Teacher extends People{
    @Override
    public String writeMain(){
        return "我的爸爸也挺好的，让我站在这里别走，他去买点橘子~~~";
    }
}

接口

认识接口

Java提供了一个关键字interface,用这个关键字我们可以定义出一个特殊的结构：接口。

package com.itchinajie.d7_interface;
public class Test {
    public static void main(String[] args) {
        //目标：认识接口
        System.out.println(A.SCHOOL_NAME);

        //A a = new A ();//注意：接口不能创建对象
        D d = new D();
    }
}


package com.itchinajie.d7_interface;
public interface A {
    //成员变量（常量）
    String SCHOOL_NAME = "黑马程序员";
    //成员方法（抽象方法）
    void test();
}

注意：接口不能创建对象；接口是用来被类实现(implements)的，实现接口的类称为实现类。

package com.itchinajie.d7_interface;
//实现类
public class D implements B,C {
    @Override
    public void testb1() {
    }
    @Override
    public void testb2() {
    }
    @Override
    public void testc1() {
    }
    @Override
    public void testc2() {
    }
}


package com.itchinajie.d7_interface;
public interface B {
   void testb1();
   void testb2();
}


package com.itchinajie.d7_interface;
public interface C {
    void testc1();
    void testc2();

}

一个类可以实现多个接口（接口可以理解成干爹），实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则实现类需要定义成抽象类。

使用接口的好处

1、弥补了类单继承的不足，一个类同时可以实现多个接口。通过接口，我们可以让一个类有一个亲爹的同时，还可以找多个干爹去扩展自己的功能。

2、让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现。一个类我们说可以实现多个接口，同样，一个接口也可以被多个类实现的。这样做的好处是我们的程序就可以面向接口编程了，这样我们程序员就可以很方便的灵活切换各种业务实现了。

package com.itchinajie.d8_interface2;

import com.itchinajie.d4_abstract.A;

public class Test {
    public static void main(String[] args) {
        //目标：搞清楚使用接口的好处
        Driver s = new C();
        s.drive();

        Driver d = new B();
        d.drive();
    }
}
class B implements Driver{

    @Override
    public void drive() {

    }
}
class C extends Student implements Driver , Singer{

    @Override
    public void drive() {

    }

    @Override
    public void sing() {

    }
}

class Student{

}
interface Driver{
    void drive();
}
interface Singer{
    void sing();
}

接口的应用案例：班级学生信息管理模块的开发

需求：
请设计一个班级学生的信息管理模块：学生的数据有：姓名、性别、成绩

功能1：要求打印出全班学生的信息；功能2：要求打印出全班学生的平均成绩。

注意！以上功能的业务实现是有多套方案的，比如：

第1套方案：能打印出班级全部学生的信息；能打印班级全部学生的平均分。

第2套方案：能打印出班级全部学生的信息（包含男女人数）；能打印班级全部学生的平均分(要是去掉最高分、最低分)。

要求：系统可以支持灵活的切换这些实现方案。

package com.itchinajie.d9_interface_Demo;
//封装对象，姓名 性别 年龄
public class Student {
    private String name;
    private char sex;
    private int age;

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student(String name, char sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
}

//录入学生信息
package com.itchinajie.d9_interface_Demo;

import java.util.ArrayList;

public class ClassManager {
    private ArrayList<Student> students = new ArrayList<>();
    private StudentOperator studentOperator = new StudentOperatorImpl2();

    public ClassManager(){
        students.add(new Student("迪丽热巴",'女',99));
        students.add(new Student("古力娜扎",'女',97));
        students.add(new Student("马尔扎哈",'男',98));
        students.add(new Student("卡尔扎巴",'男',99));
    }
    //打印全班全部学生的信息
    public void printInfo(){
        studentOperator.printAllInfo(students);
    }

    //打印全班全部学生的平均分
    public void printScore(){
        studentOperator.printAverageScore(students);
    }
}


//创建接口类用来重写方法
package com.itchinajie.d9_interface_Demo;

import com.itchinajie.d4_abstract.A;

import java.util.ArrayList;

public interface StudentOperator {
    void printAllInfo(ArrayList<Student> students);
    void printAverageScore(ArrayList<Student> students);
}


//重写方法
package com.itchinajie.d9_interface_Demo;

import java.util.ArrayList;

public class StudentOperatorImpl1 implements StudentOperator{

    @Override
    public void printAllInfo(ArrayList<Student> students) {
        System.out.println("----------全班全部学生信息如下-------------");
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            System.out.println("姓名：" + s.getName() + "，性别：" + s.getSex() + "，成绩：" + s.getAge());
        }
        System.out.println("-----------------------------------");

    }

    @Override
    public void printAverageScore(ArrayList<Student> students) {
        double allScore = 0.0;
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            allScore  += s.getAge();

        }
        System.out.println("平均分：" + (allScore) / students.size());
    }
}


//测试类
package com.itchinajie.d9_interface_Demo;

public class Test {
    public static void main(String[] args) {
        //目标：完成班级信息管理的案例
        ClassManager clazz = new ClassManager();
        clazz.printInfo();
        clazz.printScore();
    }
}

接口的其他细节JDK8开始，接口中新增的三种方法

1、默认方法：使用default修饰，使用实现类的对象调用。

2、静态方法：static修饰，必须用当前接口名调用

3、私有方法：private修饰，jdk9开始才有的，只能在接口内部被调用。

他们都会默认被public修饰。

package com.itchinajie.d10_interface_jdk8;

public class Test {
    public static void main(String[] args) {
        //目标：掌握接口新增的三种方法形式
        B b = new B();
        b.test1();
        //b.test2();//访问私有方法报错
        A.test3();
    }
}


package com.itchinajie.d10_interface_jdk8;

public class B implements A{

}


package com.itchinajie.d10_interface_jdk8;

public interface A {
    /*
    * 1、默认方法：必须使用default修饰，默认会被public修饰
    * 实例方法：对象的方法，必须是用实现类的对象来访问*/
    public default void test1(){
        System.out.println("===默认方法===");
        test2();
    }
    /*
    * 2、私有方法：必须使用private修饰(JDK9才开始支持)
    * 实例方法：对象的方法.*/
    private void test2(){
        System.out.println("====私有方法===");
    }
    /*
    * 3、静态方法：必须使用static修饰，默认会被public修饰
    * */
    static void test3(){
        System.out.println("===静态方法===");
    }


    default void test6(){

    }
}

新增的三种方法增强了接口的能力，更便于项目的扩展和维护。

接口的其他细节：接口的多继、使用接口的注意事项

接口其他注意事项（了解）
1、一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承。
2、一个类实现多个接口，如果多个接口中存在方法签名冲突，则此时不支持多实现。
3、一个类继承了父类，又同时实现了接口，父类中和接口中有同名的默认方法，实现类会优先用父类的。
4、一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可。

package com.itchinajie.d11_interface_attention;

public class Test {
    public static void main(String[] args) {
        //目标：理解接口的多继承
    }

}
interface A{
    void test1();
}
interface B{
    void test2();
}
interface C{}
//接口是多继承的
interface D extends A,B,C{
}
class E implements D{

    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }
}

(本章图片均来自于黑马程序员视频)