一个小时搞定JAVA面向对象（6）——多态

最新推荐文章于 2024-09-27 00:45:01 发布
最新推荐文章于 2024-09-27 00:45:01 发布
阅读量510 收藏 8
点赞数 4
文章标签： java 开发语言 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65034569/article/details/139396313
版权

文章目录

多态

多态必须要子父类继承或者接口实现关系,必须有方法的重写.

定义格式:

​ new对象:父类引用指向子类对象

Fu fu = new Zi( )
    理解为大类型接收了一个小类型的数据

注意:

​ 多态下不能直接调用子类特有功能

案例:

public abstract class Animal {
    public abstract void eat();
}

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗啃骨头");
    }

    //特有方法
    public void lookDoor(){
        System.out.println("狗会看门");
    }
}

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    //特有方法
    public void catchMouse(){
        System.out.println("猫会捉老鼠");
    }
}

public class Test01 {
    public static void main(String[] args) {
        //原始方式
        Dog dog = new Dog();
        dog.eat();//重写的
        dog.lookDoor();//特有的

        Cat cat = new Cat();
        cat.eat();//重写的
        cat.catchMouse();//特有的

        System.out.println("==================");
        //多态形式new对象
        Animal animal = new Dog();//相当于double b = 10
        animal.eat();//重写的 animal接收的是dog对象,所以调用的是dog中的eat
//      animal.lookDoor();   多态前提下,不能直接调用子类特有成员

        Animal animal1 = new Cat();
        animal1.eat();//cat重写的


    }
}

多态条件下成员的访问特点

成员变量

看等号左边是谁,先调用谁中的成员变量

public class Fu {
    int num = 1000;
}

public class Zi extends Fu{
    int num = 100;
}

public class Test01 {
    public static void main(String[] args) {
        Fu fu = new Zi();
        System.out.println(fu.num);
    }
}

成员方法

看new的是谁,先调用谁中的成员方法,子类没有就找父类

public class Fu {
    int num = 1000;
    public void method(){
        System.out.println("我是父类中的method方法");
    }
}

public class Zi extends Fu{
    int num = 100;

    public void method(){
        System.out.println("我是子类中的method方法");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Fu fu = new Zi();
        System.out.println(fu.num);//父类中的num
        fu.method();//子类中重写的method方法
    }
}

多态的好处

多态方法和原始方式new对象的优缺点:

  • 原始方式:
    1. 优点:既能调用重写的,还能调用父类非私有的,还能调用自己特有的
    2. 缺点:扩展性差
  • 多态方法:
    1. 优点:扩展性强
    2. 缺点:不能直接调用子类特有功能

总结:

  1. 形参传递父类类型,调用此方法父类类型可以接收任意它的子类对象
  2. 传递哪个子类对象,就指向哪个子类对象,就调用哪个子类对象重写的方法

案例:

public abstract class Animal {
    public abstract void eat();
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗啃骨头");
    }

    //特有方法
    public void lookDoor(){
        System.out.println("狗会看门");
    }
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    //特有方法
    public void catchMouse(){
        System.out.println("猫会捉老鼠");
    }
}


public class Test01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();//重写的
        dog.lookDoor();//特有的

        //dog = new Cat();
        System.out.println("=============");
        method(dog);

        Cat cat = new Cat();
        method(cat);

       /* houzi houzi = new houzi();
        method(houzi);

        bird bird = new bird();
        method(bird);*/
    }

    public static void method(Dog dog){
        dog.eat();
        dog.lookDoor();
    }

    public static void method(Cat cat){
        cat.eat();
        cat.catchMouse();
    }

   /* public static void method(houzi houzi){
        cat.eat();
        cat.catchMouse();
    }*/
}


public class Test02 {
    public static void main(String[] args) {
        /*
           double b = 10;
           b = 100L;
         */
        Animal animal = new Dog();
        animal.eat();

        animal = new Cat();
        animal.eat();
        System.out.println("=================");

        Dog dog = new Dog();
        method(dog);

        Cat cat = new Cat();
        method(cat);

    }

    /*
       形参传递父类类型,调用此方法父类类型可以接收任意它的子类对象
       传递哪个子类对象,就指向哪个子类对象,就调用哪个子类对象重写的方法
     */
    public static void method(Animal animal){
        //Animal animal = dog   Animal animal = cat
        animal.eat();
    }
}

多态的缺点

在多态中如果我们想要调用子类特有的方法是实现不了的.

多态中的转型

向上转型

表现形式:父类类型 对象名1 = new 子类对象()

向下转型

意思就是将父类强制转换成子类.

表现形式:子类类型 对象名2 = (子类类型)对象名1

转型案例:

public abstract class Animal {
    public abstract void eat();
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    //特有方法
    public void catchMouse(){
        System.out.println("猫会捉老鼠");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗啃骨头");
    }

    //特有方法
    public void lookDoor(){
        System.out.println("狗会看门");
    }
}

public class Test01 {
    public static void main(String[] args) {
        //多态new对象  向上转型
        Animal animal = new Dog();
        animal.eat();//dog重写的
        //animal.lookDoor();//多态不能调用子类特有功能

        //向下转型
        Dog dog = (Dog) animal;
        dog.eat();
        dog.lookDoor();
    }
}

类型转换异常

  1. 如果等号左右两边类型不一致,会出现类型转换异常(ClassCastException).

  2. 解决办法:使用**instanceof进行判断**, 判断的是关键字前面的对象是否符合关键字后面的类型

  3. 使用方法:
    对象名 instanceof 类型
    【测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据】

  4. 代码案例:

    public abstract class Animal {
    public abstract void eat();
}

public abstract class Animal {
    public abstract void eat();
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗啃骨头");
    }

    //特有方法
    public void lookDoor(){
        System.out.println("狗会看门");
    }
}


public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    //特有方法
    public void catchMouse(){
        System.out.println("猫会捉老鼠");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        method(dog);

        System.out.println("===============");

        Cat cat = new Cat();
        method(cat);
    }

    public static void method(Animal animal){//animal = dog    animal = cat
      /*  animal.eat();
        *//*
           这里会出现类型转换异常(ClassCastException)
           原因:当调用method,传递Cat对象时,animal代表的就是cat对象
               此时我们将代表cat对象的animal强转成了dog
               此时等号左右两边类型不一致了,所以出现了类型转换异常
         *//*
        Dog dog = (Dog) animal;
        dog.lookDoor();*/

        if (animal instanceof Dog){
            Dog dog = (Dog) animal;
            dog.eat();
            dog.lookDoor();
        }

        if (animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.eat();
            cat.catchMouse();
        }
    }
}
天下无贼！
关注
一个小时搞定JAVA面向对象（5）——抽象与接口
qq_65034569的博客
06-04 1909
public interface 接口名{ }public class 实现类类名 implements 接口名{ }使用方法:实现类实现接口重写接口中的抽象方法创建实现类对象(接口不能new对象)调用重写的方法//接口实现代码案例public interface USB { //定义接口public class Mouse implements USB{ //定义接口实现类@OverrideSystem.out.println("鼠标打开");@Override。
【JAVA学习】2、面向对象编程的核心——对象和类
陈艺荣
09-18 1598
【JAVA学习】面向对象编程的核心——对象和类前言面向过程VS面向对象基础概念优缺点比较面向对象三大基础特性封装继承多态面向对象编程的五大基本原则单一职责原则SRP(Single Responsibility Principle)开放封闭原则OCP(Open－Close Principle)里式替换原则LSP(the Liskov Substitution Principle LS)依赖倒置原则DIP(the Dependency Inversion Principle DIP)接口分离原则ISP(the
大白话系列之——Java的面向对象思想
曹举的个人博客
06-03 1186
1、举例理解面向对象 说到面向对象的思想，有一句话不得不说：万物皆对象，万物皆可归类 什么意思呢？ 就是说在面向对象的思想里它认为只要是存在的事物，它都是一个实例对象，都能找到一种或多种属于它的归类。 比如说有一个学生张三，你可以把他归类于人类，也可以把它归类于学生类等等； 再比如说你们家的猫，你可以把它归类于动物类，也可以把它归类于猫科类。 所以，类具体的怎么去定义，是看你从哪个角度...
java基础复习（四）：面向对象深度解析
qq_44793993的博客
05-17 523
文章目录理解面向对象三大特性类与对象类加载过程static对象的创建new关键字做了什么new的执行细节this和superthis的本质this与static无法共存的本质super的本质重写与重载接口与抽象类 理解面向对象 三大特性 类与对象 类加载过程 static 对象的创建 new关键字做了什么 new的执行细节 this和super this的本质 this与static无法共存的本质 super的本质 重写与重载 接口与抽象类 ...
JAVA基础——接口（全网最详细教程）
热门推荐
扬俊的小屋
05-10 38万+
Java基础——接口 接口概念 官方解释：Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。 我的解释：接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组...
【面向对象】——浅谈接口
全力奔跑，梦在彼岸
02-02 648
【背景】        提到接口，想必大家都不陌生，在学习设计模式的时候，对于接口的认识更加深了，知识的学习需要不断地总结整理，颗粒收仓的过程，下面请随我来一起学习吧。 【正文】        【为什么会有接口？】             上一篇文章：【【面向对象】——浅谈抽象类  ，我们提到了抽象类，抽象类的存在是为了将不同类中相同的方法抽离出来，子类继承父类时实现了代码的复用；由抽象类
面向对象的详解，只看这一篇就够了
m0_58702068的博客
07-16 918
目录 一，面向对象概述 与传统程序设计区别 解决规模 二，类 概述 封装 扩展 继承 三，对象 对象的三特性： 行为 状态 标识 四，创建类的思路 五，类之间关系 依赖 聚合 继承 一，面向对象概述 面向对象程序设计(object-oriented programming, OOP)是目前主流的程序设计范型。它的出现代替了以前的基于面向过程的编程技术。 由于Java是基于面向对象设计的一门语言，所以想要学习Java，熟悉OOP...
面向对象第一节——面向对象思想
shouxindejava的专栏
02-19 981
大自然是面向对象方法最早的发明者，也是面向对象规则最熟练的使用者，我们程序设计中面向对象的理念，方法和思想，皆是对我们生活的这个现实社会的抽象。 说到面向对象，自然会提起面向过程，关于两者之间关系的讨论几乎是所有教科书的必选动作，这里，我不想用一大堆文字去解释它们的联系与区别，只想用一个例子来直观的告诉大家两者最明显的区别。当然，所有的比喻都背离了事物的本质，即使比喻用的足够形象。比喻的目的
Java面向对象之多态（向上转型与向下转型）
张宇杰的博客
05-26 337
多态，大概每个人都知道。但是，又有几个人真的理解什么是多态、多态有哪些细节呢？如果你看到这篇文章的名字，脑海中对多态没有一个清晰的概念，不妨点进来看看，也许会有收获。什么是多态简单的理解多态多态，简而言之就是同一个行为具有多个不同表现形式或形态的能力。比如说，有一杯水，我不知道它是温的、冰的还是烫的，但是我一摸我就知道了。我摸水杯这个动作，对于不同温度的水，就会得到不同的结果。这就是多态。那么，j...
Java经典面试之—— 基础（一）
技术专家
05-27 488
1、下面能通过编译运行出 Hello World 的是（） A、public class Hello { public static void main(String[]args) { System.out.println("Hello World"); } } B、public class Hello { public static void main(String[] args) { system.out.println("Hello
常见的java面试八股文——java基础（1）
xiaowanziddd的博客
03-06 2861
java面试八股文 面向过程与面向对象 面向过程（PO）：把事情拆分成一个个的方法和数据，然后按照一定的顺序，执行完毕这些方法，等方法执行完了，事情就搞定了。因为每个方法都可以看作一个过程所以叫面向对象。 面向对象（OO）：面向对象会把事物抽象成对象的概念，先抽象出对象，然后对对象赋一些属性和方法，然后让每个对象去执行自己的方法。问题得到解决。 面向过程与面向对象的优缺点对比： 面向过程： 优点：性能比面向对象高，因为不需要实例化对象。 缺点：可维护性差 面向对象： 优点：易维护、易复用、易扩展，由于面向对
Java多态与泛型 ，动态绑定，静态绑定
GeofferySun的专栏
04-19 1007
（一）多态 1.概念 简单理解就是，一个对象可以表现出多种状态。可以看做是对抽象对象的逆过程，具体化抽象对象的行为。而它是如何实现这种表现出多种状态功能的呢。 从Java语法上来讲有如下两种方式： 1.1 使用继承: 将父对象（更抽象的对象/或者说基类）设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。 class Aninal{ void sound(发出声音)；}//sound是动物的一个叫声方法 class cat extend Anima
Spring Boot 学习和使用
cesske的博客
09-24 1059
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
工厂模式的介绍及实现
户伟伟的博客
09-25 109
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 345
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
智能BI平台项目
2302_79400545的博客
09-22 237
BI商业智能：数据可视化、报表可视化系统。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 876
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 734
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
Java 11：继承与多态详解——面向对象编程关键
- 多态的概念：多态是面向对象编程中的一个重要特性，它允许同名的方法在不同上下文中有不同的行为，增强了程序的灵活性和抽象性。 - 方法覆盖（重写）：子类通过定义与父类同名且参数相同的成员方法，可以隐藏并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值