Java入门基础-11面向对象高级(二）

取名废本人

于 2024-07-31 21:57:47 发布

阅读量730

点赞数 21

分类专栏： # Java入门基础文章标签： java 开发语言笔记

本文链接：https://blog.csdn.net/m0_64126885/article/details/140819320

版权

Java入门基础专栏收录该内容

8 篇文章 0 订阅

订阅专栏

Java入门基础-11面向对象高级(二）

本章知识点总结于黑马程序员的视频课程：《Java入门基础课程》，是对上课做的笔记

Java入门基础课程视频地址

Java入门基础-10面向对象高级

前言

在这里插入图片描述

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

认识多态

什么是多态？

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

多态的具体代码体现：
在这里插入图片描述
多态的前提：

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

多态的一个注意事项：

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

Peopel.java

// 父类
public class People {
    public String name = "父类People的名称";

    public void run(){
        System.out.println("人类可以跑");
    }
}

Teacher.java

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

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

Student.java

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

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

Test.java

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

        // 1.对象多态
        People p1 = new Teacher(); // 多态识别技巧：编程看左边，运行看右边
        
        p1.run(); // 行为多态
        System.out.println(p1.name); // 注意：对于变量，编程看左边，运行看左边

        People p2 = new Student();
        p2.run();
        System.out.println(p2.name);
    }
}

运行结果：
在这里插入图片描述

使用多态的好处、类型转换问题

使用多态的好处：

在多态形式下，右边对象是解耦合的，更便于扩展合维护。
People p1 = new Teeacher( ); // Teeacher( )可以换成 Student( );
p1.run( );
定义方法时，使用父类类型的形参，可以接收一切子类对象，扩展性更强、更便利。
public static void go(People p){ }

多态下会产生的一个问题，怎么解决？

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

类型转换：

自动类型转换：父类变量名 = new 子类
People p = new Teacher( );
强制类型转换：子类变量名 = （子类）父类
Teacher t = (Teacher) p;

强制转换的一个注意事项：

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

强转前，Java建议：

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

示例代码：

// 强制类型转换
        // Student s1 = (Student) p1;
        // 建议使用instanceof
        // p1 是 Teacher();
        if (p1 instanceof Student){
            Student s2 = (Student) p1;
            s2.test();
        }else {
            Teacher t2 = (Teacher) p1;
            t2.teach();
        }

运行结果：
在这里插入图片描述

final

认识final

final：

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

final修饰变量的注意：

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

代码示例：

public class Test {
    public static final String SCHOOL_NAME = "黑马";

    private final String name = "猪八戒"; // 这种用法没有意义，知道就行。

    public static void main(String[] args) {
        // SCHOOL_NAME = "白马"; // 第二次赋值，出错了

        // final 可以修饰变量，有且只能赋值一次
        final int a = 12;
        // a = 13; // 第二次赋值，出错了

        final double r = 3.14;
        // r = 3.24; // 第二次赋值，出错了
    }

    // final 修饰类，类不能被继承
    final class A{}
    // class B extends A{} // 出错

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

        }
    }
    class D extends C{
//        @Override
//        public void test(){
//        报错
//        }
    }
}

补充知识：常量详解

常量：

使用了 static final 修饰的成员变量就被称为常量；
作用：通常用于记录系统的配置信息。
注意：常量名的命名规范：建议使用大写英文单词，多个单词使用下划线连接起来。

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

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

抽象类

认识抽象类

什么是抽象类？

在Java中有一个关键词叫：abstract，它就是抽象的意思，可以用它修饰类、成员方法。
abstract修饰类，这个类就是抽象类；修饰方法，这个方法就是抽象方法。

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

抽象类的注意事项、特点：

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

在这里插入图片描述

抽象类的场景和好处

父类知道每个子类都要做某个行为，但每个子类要做的情况不一样，父类就定义成抽象方法，交给子类去重写实现，我们设计这样的抽象类，就是为了更好的支持多态。
多个类中只要有重复代码（包括相同的方法签名），我们都应该抽取到父类中去，此时，父类中就有可能存在只有方法签名的方法，这时i，父类必定是一个抽象类了，我们这样的抽象类，就是为了更好的支持多态。

在这里插入图片描述
代码示例：
Test.java

public class Test {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.setName("叮当猫");
        a.cry();
    }
}

Animal.java

public abstract class Animal {
    private String name;

    public abstract void cry();

    public String getName() {
        return name;
    }

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

Cat.java

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

Dog.java

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

运行结果：
在这里插入图片描述

抽象类的应用场景和好处是什么？

两种主要的应用场景，一种是：用抽象类，我们可以把子类中相同的代码，包括方法签名都抽上来，这样能更好的支持多态，以提高代码的灵活性。
一种是：反过来用，我们不知道系统未来具体的业务实现时，我们可以先定义抽象类，将来让子类去继承实现，以方便系统的扩展。

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

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

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

模板方法设计模式的写法

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

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

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

代码示例：
Test.java

public class Test {
    public static void main(String[] args) {
        // 学生和老师都要写一篇文章，标题为：我的爸爸
        // 第一段与最后一段是一样的，中间段落自由发挥
        People p1 = new Student();
        p1.write();

        People p2 = new Teacher();
        p2.write();
    }
}

People.java

public abstract class People {
    public final void write(){
        System.out.println("\t\t\t\t《我的爸爸》");
        System.out.println("\t\t开头段落，老师和学生的内容一样");
        System.out.println(writeMain());
        System.out.println("\t\t结尾段落，老师和学生的内容一样");
    }
    public abstract String writeMain();

Student.java

public class Student extends People{
    @Override
    public String writeMain() {
        return "\t\t学生的中间段落内容";
    }
}

Teacher.java

public class Teacher extends People{
    @Override
    public String writeMain() {
        return "\t\t老师的中间段落";
    }
}

运行结果：
在这里插入图片描述

接口

接口概述

认识接口：

Java提供了一个关键字interface，用这个关键字我们可以定义出一个特殊的结构：接口。
public interface 接口名{
// 成员变量（常量）
// 成员方法（抽象方法）
}
注意：接口不能创建对象；接口是用来被类通过关键字 implements 实现的，实现接口的类被称为实现类。
修饰符 class 实现类 implements 接口1，接口2，…{
}
一个类可以实现多个接口（接口可以理解成干爹），实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则实现类需要定义成抽象类。

接口的好处是啥？

弥补了类单继承的不足，类可以同时实现多个接口。
让程序可以面向接口编程，这样既不用关心实现的细节，也可以灵活方便的切换各种实现。

接口的综合案例

在这里插入图片描述

代码：
Student.java

package test6_interface;

public class Student {
    private String name;
    private char sex;
    private double score;

    public Student() {
    }

    public Student(String name, char sex, double score) {
        this.name = name;
        this.sex = sex;
        this.score = score;
    }

    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 double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }
}

ClassManager.java

package test6_interface;

import java.util.ArrayList;

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


    public ClassManager() {
        students.add(new Student("1", '女', 90));
        students.add(new Student("2", '女', 80));
        students.add(new Student("3", '男', 78));
        students.add(new Student("4", '男', 50));
        students.add(new Student("5", '女', 57));

    }

    // 打印全班全部学生信息
    public void printInfo(){
        studentOperator.printAllInfo(students);
    }

    // 打印全班全部学生成绩
    public void printScore(){
        studentOperator.printAverageScore(students);
    }
}

StudentOperator.java 接口

package test6_interface;

import java.util.ArrayList;

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

StudentOperaImpl1.java

package test6_interface;

import java.util.ArrayList;

public class StudentOperaImpl1 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.getScore());
        }
        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.getScore();
        }
        System.out.println("平均分为：" + 1.0 * (allScore / students.size()));

    }
}

StudentOperaImpl2.java

package test6_interface;

import java.util.ArrayList;

public class StudentOperaImpl2 implements StudentOperator{
    @Override
    public void printAllInfo(ArrayList<Student> students) {
        System.out.println("-----------全班全部学生信息如下：-----------");
        int count1 = 0; // 男
        int count2 = 0; // 女
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            System.out.println("姓名：" + s.getName() + ", 性别" + s.getSex() + ", 成绩" + s.getScore());
            if (s.getSex() == '男'){
                count1 ++;
            }else {
                count2 ++;
            }
        }
        System.out.println("-----------------------------------------");
        System.out.println("男生人数为：" + count1 + ", 女士人数为：" + count2);
        System.out.println("全班人数为：" + students.size());
    }

    @Override
    public void printAverageScore(ArrayList<Student> students) {
        double allScore = 0.0;
        double max = students.get(0).getScore();
        double min = students.get(0).getScore();
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            allScore += s.getScore();
            if (max < s.getScore()) max = s.getScore();
            if (min > s.getScore()) min = s.getScore();
        }
        System.out.println("学生最高分" + max);
        System.out.println("学生最低分" + min);
        System.out.println("平均分为：" + 1.0 * ((allScore - max - min) / (students.size() - 2)));

    }

}

Test.java

package test6_interface;

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ClassManager classManager = new ClassManager();
        classManager.printInfo();
        classManager.printScore();
    }
}

使用StudentOperaImpl1()运行结果：
在这里插入图片描述

使用StudentOperaImpl2()运行结果：

在这里插入图片描述

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

1、默认方法（实例方法）：使用用default修饰，默认会被加上public修饰。注意：只能使用接口的实现类对象调用。
2、私有方法：必须用private修饰（JDK　９开始才支持）
３、类方法（静态方法）：使用static修饰，默认会被加上public修饰。注意：只能用接口名来调用。

代码示例：

public interface A {
    // 1、默认方法（实例方法）：使用用default修饰，默认会被加上public修饰。注意：只能使用接口的实现类对象调用。
    default void test1(){
        
    }
    // 2、私有方法：必须用private修饰（JDK　９开始才支持）
    /*private void test2(){
        // 本机安装的JDK 8，所有无法使用
    }*/
    // ３、类方法（静态方法）：使用static修饰，默认会被加上public修饰。注意：只能用接口名来调用。
    static void test3(){
        
    }
}

JDK8开始，接口中为啥要新增这些方法?

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

接口的其他细节：接口的多继承、使用接口的注意事项[了解]

接口其他注意事项（了解）

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

代码示例：
在这里插入图片描述

取名废本人

关注

21
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
Java入门基础-11面向对象高级(二）

什么是多态？多态是在继承/实现情况下的一种现象，表现为：对象多态、行为多态。多态的具体代码体现：有继承/实现关系；存在父类引用了子类对象；存在方法重写。多态是对象、行为的多态，Java中的属性（成员变量）不谈多态。// 父类public String name = "父类People的名称";System.out.println("人类可以跑");public String name = "子类Teacher的名称";@Override。
复制链接

扫一扫