首页 > 编程语言 >Java入门基础-11面向对象高级(二）

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

时间：2024-07-31 21:57:37浏览次数：18  
标签：11 Java void 多态 接口 面向对象 Student 抽象类 public

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、一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可。

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

标签：11,Java,void,多态,接口,面向对象,Student,抽象类,public
From： https://blog.csdn.net/m0_64126885/article/details/140819320

相关文章

  • JAVA程序设计——二维小游戏制作
    二维小游戏制作一、课题内容和要求1.课题内容：（1）学生需要针对游戏类应用软件（如数独，扫雷，飞机大战，贪食蛇，青蛙过河等，鼓励自己设计开发游戏）的开发，使用互联网信息检索工具，查找和学习游戏类软件开发相关理论，分析和研究开放源代码；选择合适的JAVA开发工具完成软件项目的创建，代码编写......
  • 浅聊java运行机制
    Java程序运行机制首先要清楚运行机制一般有两种解释型编译型解释型：顾名思义，就像有个人在旁边给你解释东西一样。比如看一本英文书，英语老师在旁边一句一句给你翻译解释。在写源代码时，每写一个解释型就会给你翻译一个。如果想要回到之前写的代码，又得重新进行翻译。这样效率......
  • JavaScript(四）——JavaScript 语法
    目录JavaScript语法JavaScript字面量JavaScript变量JavaScript操作符JavaScript语句JavaScript关键字JavaScript注释JavaScript数据类型JavaScript函数JavaScript字母大小写JavaScript字符集驼峰命名法小驼峰命名法大驼峰命名法（帕斯卡命名法）JavaS......
  • ubuntu安装x11vnc，xauth: unable to generate an authority file name
    ubuntu安装x11vnc，xauth:unabletogenerateanauthorityfilename在Ubuntu上安装和配置x11vnc时，如果遇到“xauth:unabletogenerateanauthorityfilename”的错误，通常是由于权限问题或缺少必要的环境变量引起的。以下是一些解决此问题的步骤：安装x11vnc首......
  • 全网最适合入门的面向对象编程教程：29 类和对象的Python实现-断言与防御性编程和help函
    全网最适合入门的面向对象编程教程：29类和对象的Python实现-断言与防御性编程和help函数的使用摘要：在Python中，断言是一种常用的调试工具，它允许程序员编写一条检查某个条件。本文主要介绍了断言的应用场景和特点以及assert语句的使用，同时介绍了防御性编程和help()函数......
  • 基于Java+SSM+jsp的医药管理系统的设计与实现(源码+数据库+讲解等)
    文章目录前言详细视频演示项目运行截图技术框架后端采用SSM框架前端框架JSP可行性分析系统测试系统测试的目的系统功能测试数据库表设计代码参考数据库脚本为什么选择我？获取源码前言......
  • java异常
    异常1、对异常的理解ThrowableError类:程序运行过程中，非常严重的错误，我们是处理不了的   1.如while(true)死循环会报堆溢出2.栈内存溢出比如说:publicclassTest{publicstaticvoidmain(String[]args){test();}publicstaticvoidt......
  • JavaSE基础 （认识String类）
    一，什么是String类在C语言中已经涉及到字符串了，但是在C语言中要表示字符串只能使用字符数组或者字符指针，可以使用标准库提供的字符串系列函数完成大部分操作，但是这种将数据和操作数据方法分离开的方式不符合面相对象的思想，而字符串应用又非常广泛，因此Java语言专门提供了Strin......
  • javascript(三)
    五、事件发生在HTML元素上的事情，当在HTML页面中使用JavaScript时，JavaScript可以触发这些事件1.常用事件事件描述onchangeHTML元素改变onclick点击onmouseover鼠标移入onmouseout鼠标移出onkeydown按下键盘onload浏览器已完成页面的加载......
  • java基础知识汇总（二）
    PART1:变量与数据类型Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间。整数默认：int小数默认：double使用变量注意事项：作用域：变量定义在哪一级大括号中，哪个大括号的范围就是这个变量的作用域。相同的作用域中不能......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99