Day06_面向对象二:多态、final关键字、抽象类、接口

最新推荐文章于 2024-09-28 09:34:36 发布
最新推荐文章于 2024-09-28 09:34:36 发布
阅读量930 收藏 16
点赞数 9
分类专栏： Java学习 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tonghua1124/article/details/136890929
版权

多态

  1. 前提: 存在继承/实现关系,存在父类引用子类对象，存在方法重写
  2. 多态是对象、行为的多态。属性(成员变量)不谈多态
  3. 多态是指: 父亲类型 变量名 = new 子类对象
package demo0320;

public class Father {
    String name = "父亲";
    public void run(){
        System.out.println("父亲正在奔跑");
    }
}

package demo0320;

public class SonFrist extends Father{
    String name = "儿子1";
    @Override
    public void run(){
        System.out.println("孩子1正在奔跑");
    }
}

package demo0320;

public class SonSecond extends Father{
    String name = "儿子2";
    @Override
    public void run(){
        System.out.println("孩子2正在奔跑");
    }
}

package demo0320;


public class test {
    public static void main(String[] args) {
        // 对象多态
        Father F1 = new SonFrist();
        // 行为多态
        // 编译看左边,执行看右边
        F1.run();
        System.out.println(F1.name);
        Father F2 = new SonSecond();
        F2.run();
        System.out.println(F2.name);
    }
}

多态的优势

1.可以实现解耦合,右边子类对象可以随时切换,后续可以根据业务需求随时变化

2.可以使用父类类型作为变量类型,右边可以是一切子类对象

3.多态的缺陷: 多态不能使用子类的独有功能

多态的强制类型转换

目的: 为了解决父类对象无法调用子类对象的独有功能

package demo0320;

public class Father {
    String name = "父亲";
    public void run(){
        System.out.println("父亲正在奔跑");
    }
}

package demo0320;

public class SonFrist extends Father{
    String name = "儿子1";
    @Override
    public void run(){
        System.out.println("孩子1正在奔跑");
    }

    public void Certificate(){
        System.out.println("孩子1有5张奖状");
    }
}

package demo0320;

public class SonSecond extends Father{
    String name = "儿子2";
    @Override
    public void run(){
        System.out.println("孩子2正在奔跑");
    }
    public void Certificate(){
        System.out.println("孩子2有3张奖状");
    }
}

package demo0320;


public class test {
    public static void main(String[] args) {
        // 对象多态
        Father F1 = new SonFrist();
        Father F2 = new SonSecond();
        // 此处会出现问题,虽然是new的子类对象,但是编译过程中看到是左边,也就是父类对象,由于父类中没有Certificate方法,所以会编译错误
        // F1.Certificate()
        // 可以通过强转,来保障编译器的顺利通过
        SonFrist s1 = (SonFrist) F1;
        s1.Certificate();
        // 此时不会ide不会产生红色异常,但是在运行是会报错ClassCastException
        // 原因在于,F1右边是创建的SonFrist对象,此时强转为另一个不同的子类对象,这是不被允许的
        // SonSecond s2 = (SonSecond) F1;
        SonSecond s3 = (SonSecond) F2;
        // 比较好的强转方式是在强转前,通过instanceof关键字先判断是否是期望的对象
        // 通过instanceof先判断在强转,可以有效保障强转不产生异常
        if(F1 instanceof SonSecond){
            SonSecond s4 = (SonSecond) F2;
        }
    }
}

final

  1. final关键字有最终的意思,可以修饰(类、方法、变量)
  2. 修饰类: 该类被称为最终类,特点是不能被继承了
  3. 修饰方法: 该方法称为最终方法,特点是不能被重写了
  4. 修饰变量: 该变量只能被赋值一次
package demo0320;

final class A{};
// A类被final修饰,无法在被继承
// class B extends A{}
class C{
    final public void run(){
        System.out.println("对象在奔跑");
    }
}
class D extends C{
    // run方法被final修饰,不能在被重写
//    @Override
//    public void run(){
//
//    }
}
public class test {
    // 由于final只能赋值一次,且该变量在类被创建的时候没有值的情况下,会给到一个默认值null,导致后续在想对这个变量修改变得不在可能
    // 所以对于这些再类创建时候就产生默认值的变量,如果永final修饰,必须给到想要的初始值
    public static final String name = "童话";
    public final int age = 10;
    public static void main(String[] args) {
        final int a;
        a = 10;
        // 在修改a变量的值是不可以的,赋值只能有一次
        // a = 20;
    }
    public static void buy(final double z){
        // 用final修饰的形参,是无法在函数内部修改的
        // z = 0.75;
    }
}

final修饰变量的注意事项

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

常量

  1. 使用static final修饰的成员变量被称为常量
  2. 作用: 通常用来记录系统的配置信息,不可被改变
  3. 优势: 代码可读性更好,可维护性也更好
  4. 程序编译后,常量会被宏替换:出现常量的地方全部都会被替换成其记住的字面量,这样可以保证使用常量和使用字面量的性能是一样的

抽象类

  1. 在java中有一个关键字abstract,用它修饰的类叫做抽象类,用它修饰的方法叫做抽象方法
  2. 抽象类中不一定有抽象方法,有抽象方法的类一定是抽象类
  3. 类该有的成员(成员变量、方法、构造器)抽象类也可以有
  4. 抽象类的主要特点: 抽象类是无法new对象的,仅仅作为一种特殊的父类,让子类继承并实现
  5. 一个类继承抽象类,必须重写完所有的抽象方法,否则这个类也必须被定义为抽象类
  6. abstract修饰的方法称为抽象方法,特点是有方法签名,但是不能有方法体
package demo0320;

// abstract修饰的类称为抽象类
// 抽象类中不一定有抽象方法,有抽象方法的类一定是抽象类,ublic abstract class Father 丢掉abstract会报错,方法丢掉abstract没问题
// 类该有的成员(成员变量、方法、构造器)抽象类也可以有
// 抽象类的主要特点: 抽象类是无法new对象的,仅仅作为一种特殊的父类,让子类继承并实现
// 一个类继承抽象类,必须重写完所有的抽象方法,否则这个类也必须被定义为抽象类
public abstract class Father {
    // abstract修饰的方法称为抽象方法,特点是有方法签名,但是不能有方法体
    public abstract void run();

    public String name;
    public Father(){
        System.out.println("无参数构造器");
    }

    public void eat(){
        System.out.println("普通的成员方法");
    }

}

抽象类的场景和好处

  1. 父类知道每个子类都要实现的某个方法,但是不同子类实现情况不一样,父类就定义为抽象方法,交给子类去重写实现
  2. 个人理解: 在工作中,我作为主管,我只要写好类，和这些类的方法,然后交给实习生去完成这些类的具体内容,因为是抽象类,所以实习生必须要写完我给的方法
package demo0320;
public abstract class Father {
    // abstract修饰的方法称为抽象方法,特点是有方法签名,但是不能有方法体
    public abstract void run();
    public abstract void speak();

    public String name;
    public Father(){
        System.out.println("无参数构造器");
    }

    public void eat(){
        System.out.println("普通的成员方法");
    }

}

package demo0320;

public class SonFrist extends Father{
    String name = "儿子1";
    // 必须要全部重写,少写一个都不行
    @Override
    public void run(){
        System.out.println("孩子1正在奔跑");
    }
    @Override
    public void speak(){
        System.out.println("孩子1在讲话");
    }

    public void Certificate(){
        System.out.println("孩子1有5张奖状");
    }
}

package demo0320;

public class test {
    public static void main(String[] args) {
        // 无法new出来抽象类对象
        // Father F1 = new Father();
        // 但是可以通过父类 变量 = new 子类对象来创建
        Father F1 = new SonFrist();
        F1.eat();
        F1.speak();
    }
}

接口

  1. Java提供了一个关键字interface,用这个关键字可以定义出一个特殊得结构:接口
public interface 接口名称{
	// 成员变量(常量)
	// 成员方法(抽象方法)
}

package demo0320;
// 接口有且只有两个内容,成员变量(常量),成员方法(抽象方法)
public interface A {
    // 成员变量(常量)
    // 会出现异常,因为着不是常量
    // String name;
    // java会自动帮变量添加static final修饰
    // public static final String name = "童话";
    // 所谓得常量,就是要给定初始值,且初始值不会发生改变
    String name = "童话";
    // 这样定义的方法是不被允许得,方法只能是抽象方法
//    public void test(){
//
//    }
    // 这样定义得方法是多余的,因为java也是会自动帮忙添加public abstract
//    public abstract void test();
    void test();
}

接口的实现

  1. 接口不能创建对象,接口时用来被类实现的,通过implements,实现接口的类被称为抽象类
  2. 一个类可以实现多个接口,实现类实现多个接口,必须重写完所有接口的全部抽象方法,否则实现类需要定义为抽象类
package demo0320;

public interface A {
    String name = "童话";
    void test();
}

package demo0320;

public interface B {
    void test1();
    void test2();
}

package demo0320;

public interface C {
    void test3();
}

package demo0320;

public class D implements A,B,C{
    @Override
    public void test() {

    }

    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }

    @Override
    public void test3() {

    }
}

接口的好处

1.弥补了类单继承的不足,一个类可以实现多个接口

2.让程序可以面向接口编程

3.实现类可以同时继承(extends)一个父类和继承(implements)多个接口

4.同多态一样,可以通过 接口类型 变量名 = new 实现类(),可以实现快速切换

接口中新增的三种方法

package demo0320;

public interface E {
    /*
        1.默认方法,必须使用的default修饰,默认会被public修饰
        实现方法, 必须用实现类的对象来访问
     */
    default void test1(){
        System.out.println("默认方法");
    }
    /*
        私有方法,必须使用private修饰(JDK9)
        实例方法: 只能在接口内部的默认方法或者静态方法中调用
     */
    private void test2(){
        System.out.println("私有方法");
    }
    /*
        静态方法,必须使用static修饰,默认会被public修饰
        可以通过接口.方法
     */
    static void test3(){
        System.out.println("静态方法");
    }

    default void test4(){
        test2();
    }
}

package demo0320;

public class D implements E{

}

package demo0320;

public class test {
    public static void main(String[] args) {
       E E1 = new D();
       E1.test1();
       E.test3();
       E1.test4();
    }
}

接口的多继承

1.一个接口可以同时继承多个父类接口

2.接口继承多个父类接口的时,不用重写父类方法

3.继承多个接口时,要保证这多个接口不会出现重复的方法签名,否则无法多继承

4.一个类继承了父类,又同时继承了接口,如果接口和父类中有同名的默认方法,实现类会有限用父类的

5.一个实现类实现多个接口,多个接口存在重复的同名的默认方法,可以不冲突,实现类重写该方法即可

tonghua1124
关注
专栏目录
day14-面向对象-多态&final&抽象类
12-12
"java 中的多态和 final 关键字" 在 Java programming language 中，多态是一种非常重要的特征，它允许对象以不同的形式出现。多态的发生前提是：必须有继承或实现关系、有方法的重写、父类引用指向子类的对象。在 ...
day10-final、接口、多态.pdf
11-02
"day10-final、接口、多态.pdf" 本文档主要讲解了 Java 语言中的 final 关键字、接口和多态的概念。 首先，final 关键字用于修饰不可改变的内容，可以修饰类、方法和变量。被 final 修饰的类不能被继承，方法不能...
day02-多态&抽象类&接口1
08-04
多态是面向对象编程中的一个重要概念，它允许我们使用父类类型的引用来调用子类的方法。在Java中，多态的实现基于继承、方法重写以及父类引用指向子类对象。 1.1 多态的概述 多态（Polymorphism）是指同一个对象在...
2021面向对象程序设计推荐资料.ppt
11-30
面向对象程序设计是一种编程范式，它基于“对象”的概念，将现实世界中的实体抽象成计算机中的类，并通过这些类来构建程序。2021年的面向对象程序设计推荐资料中，主要涵盖了基本概念、核心技术和类的创建等方面的...
day10-code_java_frighten7x5_
09-30
2. **抽象类与接口**：Java中的抽象类和接口也可以实现多态。抽象类不能被实例化，但可以作为其他类的基类，强制子类重写特定方法。接口则是一种完全抽象的类型，它可以包含方法签名和常量，且一个类可以实现多个...
工厂模式的介绍及实现
户伟伟的博客
09-25 109
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Spring Boot 学习和使用
cesske的博客
09-24 1067
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 358
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 879
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 734
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
JPA+Thymeleaf增删改查
y050505的博客
09-25 459
在使用JPA（Java Persistence API）和Thymeleaf作为模板引擎进行Web开发时，实现增删改查（CRUD）操作是一个常见的需求。下面，我将简要介绍如何使用Spring Boot框架结合JPA和Thymeleaf来实现这一功能。
Java - LeetCode面试经典150题(二)
最新发布
心如冰清，天塌不惊
09-28 561
否则，返回 false。给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。遍历字符串数组，将其中的字符串，进行排序，这样就形成一个唯一的字符串了，之后将原字符串追加到这个排序完的字符串映射的String列表中。这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。将magazine中的每个字符的个数记录下来，用map映射成。
一分钟掌握 Java11 新特性
java那些事儿
09-24 602
Java 11 的新特性使得语言更加现代化，增强了代码的可读性和可维护性，同时改善了性能和开发体验。无论是在日常编程中，还是在处理复杂的应用程序时，这些新特性都能够为开发者提供更大的便利。
SpringBoot gateway如何支持跨域？
m0_63164811的博客
09-25 243
SpringBoot gateway如何支持跨域？
第 28 章 Javascript错误处理与调试
weixin_44010641的博客
09-23 1370
JavaScript 在错误处理调试上一直是它的软肋，如果脚本出错，给出的提示经常也让人摸不着头脑。ECMAScript 第 3 版为了解决这个问题引入了 try…catch 和 throw 语句以及一些错误类型，让开发人员更加适时的处理错误。
Linux上Java项目环境安装
2301_76556912的博客
09-25 317
【代码】Linux上Java项目环境安装。
JVM内存模型
weixin_63691530的博客
09-23 843
Java程序的跨平台特性主要是指字节码文件可以在任何具有Java虚拟机的计算机或者电子设备上运行，Java虚拟机中的Java解释器负责将字节码文件解释成为特定的机器码进行运行。
SpringBoot文档管理系统：性能优化
2401_85743969的博客
09-24 845
在在线文档管理系统开发之前所做的市场调研及其他的相关的管理系统，都是没有任何费用的，都是通过开发者自己的努力，所有的工作的都是自己亲力亲为，在碰到自己比较难以解决的问题，大多是通过同学和指导老师的帮助进行相关信息的解决，所以对于在线文档管理系统的开发在经济上是完全可行的，没有任何费用支出的。系统开发所使用的技术也都是自身所具有的，也是当下广泛应用的技术之一。开发整个系统使用的是云计算，流量的可扩展性和基于流量的智能调整云计算的优点就是流量的可扩展性和基于流量的智能调整，保障系统的安全及数据信息的及时备份。
Java Stream 运行原理
萝卜地里的兔子的博客
09-24 224
点我看全文
Java接口与多态：final关键字的应用
在Java编程中，"day10-final、接口、多态.pdf"文档主要探讨了Java中的关键概念，包括final关键字、接口和多态。这些内容对于理解Java语言的封装和面向对象原则至关重要。 首先，final关键字被用来表示"不可变性"，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值