精华内容
下载资源
问答
  • Java多态概念
    2022-01-16 10:35:04

    多态的前提

    1、要有继承关系
    
    2、要有方法的重写
    	其实没有重写也是可以的,但是不重写就没有意义
     	例如:动物都有吃这个方法,但是每个具体的动物吃的实现不一样,
     	变现出不同动物的特有属性。
     	
    3、要有父类的引用指向子类对象
    	父类名 变量名 = new 子类名(参数列表);
    

    多态访问成员的特点

    1、成员变量
       编译看左,运行看左
    2、构造方法
       创建子类对象的时候,先访问父类中的构造方法,对父类的数据先进行初始化
    3、成员方法
    	编译看左,运行看右。
    	因为成员方法存在重写,所以访问看右边
    4、静态成员方法
        编译看左,运行也看左。
        由于被static修饰的成员都是与类相关的,这里不是重写,所以运行的时候,
        访问的还是左边的。
    

    多态的弊端:

    多态无法使用父类特有的方法

    解决弊端

    使用对象之间转型访问父类特有的方法
    1、向上转型:
    父类名 变量名1 = new 子类名();

    2、向下转型
    子类名 变量名2 = (子类名)变量名1;``
    Markdown将文本转换为 HTML。

    向下转型需要注意的一个问题:
        要求转型的类与父类引用存在继承关系,并且一开始创建多态的时候,
    	使用的是该类。
    
    更多相关内容
  • JAVA中多态性是对象多种表现形式的体现。在面向对象中,最常见的多态发生在使用父类的引用来引用子类的对象。下面这篇文章主要给大家介绍一下,需要的朋友可以参考下
  • 主要介绍了进一步理解Java中的多态概念,是Java入门学习中的基础知识,需要的朋友可以参考下
  • java多态概念

    2022-03-15 00:33:53
    * 1 多态是方法的多态,属性没有多态 * 2父类和子类有联系,注意类型转换ClassCastExeception * 3 存在条件:继承关系,方法需要重写,父类引用指向子类对象 * */ /* * static静态方法不能被重写,属于类方法, ...

    public class Demo_test {
    /*
    * 多态规则
    * 1 多态是方法的多态,属性没有多态
    * 2父类和子类有联系,注意类型转换ClassCastExeception
    * 3 存在条件:继承关系,方法需要重写,父类引用指向子类对象
    * */

    /*
    * static静态方法不能被重写,属于类方法,  static修饰的方法和类一起加载, 非static和对象一起加载
    * final 常量修饰
    * pribave私有方法,无法重写
    * */
    
        public static void main(String[] args) {
            tear std_tear = new std();//父类引用指向子类,正常只能调用父类方法,调用子类需要向下转型
            std std = new std();//子类自己对象
            tear tear = new tear();//父类自己对象
    
            tear.phoen();//父类调用自己phone的方法
    
            std.book();//子类调用父类的phone方法
    
            std.phoen();//子类调用自己的phone(重写父类phone)
    
            std_tear.write();//父类引用调用父类独有方法
    
            std_tear.phoen();//父类类调用子类phone(已经重写父类phone)
    
            ((std) std).book(); //父类引用调用子类,强制向下转型调用子类方法
        }
    }
    class std extends tear{
        int a = 0;
    
        public void book(){//调用父类方法
            super.phoen();
        }
    
        @Override//重新父类方法
        public void phoen() {
            System.out.println("son phone");
        }
    }
    class tear{
        int b =1;
        public void phoen(){
            System.out.println("father phone");
        }
        public void write(){
            System.out.println("father write");
        }
    }
    
    展开全文
  • Java多态概念与应用

    千次阅读 多人点赞 2021-03-07 12:33:28
    1.1 多态概念 多态指的是同一个行为具有多个不同表现形式或形态的能力。是不是感觉很抽象,很难理解。没关系,接下来将用一个小demo带你了解多态的概念和优点。 提示:文章写完后,目录可以自动生成,如何生成可参考...

    多态

    多态指的是同一个行为具有多个不同表现形式或形态的能力。是不是感觉很抽象,很难理解。没关系,接下来我将全面带你了解Java多态。


    前言

    多态作为Java三大特性之一,其重要性相信也不用我多说吧。今天这篇帖子就将全面为你介绍多态的概念和应用

    一、多态是什么?

    多态是指同一个行为具有多个不同表现形式或形态的能力。是不是感觉很抽象,没事,接下来就让我用一个demo带你了解什么是多态吧。

    1. 代码思考

    新建person类

    public class Person {
        public String total(){
            return "this person class";
        }
    }
    
    

    新建Student类

    public class Student extends Person {
        @Override
        public String total(){
            return "这是 student class";
        }
    }
    

    2.输出的结果是什么?

    public class Demo{
        public static void main(String[] arg){
            Person student = new Student();
            System.out.println(student.total()); 
            // 这是 student class
        }
    }
    

    为什么对象声明是Person类,但输出的却是Student 类的方法。这是多态的关键所在:
    Java实例方法调用是基于运行时实际类型动态调用,而并非引变量本身

    3.多态需要满足要求

    将上述多态代码,抽离出特点。我们可以得到多态需要满足条件:

    1. 子类继承父类
    2. 子类重写父类方法
    3. 子类对象指向父类声明(最关键一点)

    那有的同学就会疑问了,那我直接使用子类引用不就行了吗,为什么要多此一举。那不妨来看一下接下来这一段代码。

    4.多态的应用

    public class Demo{
        public static void main(String[] arg){
            Person person = new Person();
            Person student = new Student();
            getClassName(person); // 这是 person class
            getClassName(student); // 这是 student class
        }
        public static void getClassName(Person person){
            System.out.println(person.total());
        }
    }
    

    这就是多态的巧妙与应用了,这里我们可以看到,getClassName需要的参数是Person 类型。但当我们传入的是student 对象时,程序依旧运行正确输出了。

    在实际开发中,代码和方法的量级很为庞大。如果某一天客户有一个新的需求让你添加一个新的功能,你需要重写一个新类,然后在调用接口处重新加一个方法,用于调用你新写的类中的方法。而多态的出现,让你只需新建子类,重写父类方法,也不需要新增调用接口。而且最主要的是也不用改写前辈的可能随时引爆的代码了(手动狗头)。

    因此多态的出现也很大程度的降低了代码冗余性,提高了代码的复用性,也降低了出错的可能性,而且也方便管理。

    5 多态中父类声明对象只能调用所声明类中的方法

    public class Student extends Person {
        @Override
        public String total(){
            return "这是 student class";
        }
    
        public String util(){
            return "这是 util 方法";
        }
    }
    

    向Student类中新建方法util(),那此时student变量可以调用util()吗,答案是不能。
    在这里插入图片描述
    此时我们可以看到,在变量student方法栏中没有新建的util()方法。这是因为声明引用为student父类,所以,多态中父类声明对象只能调用所声明类中的方法。

    二、多态进阶应用

    1.问题

    某企业A类经理纳税13%,B类高管纳税8%,C类员工享受补贴不纳税。请你设计一个程序计算改企业所有员工需要纳税金额(使用多态)?

    你可以先动手实现一下

    2.代码实现

    新建Employee类,用于定义接口,即父类。

    public class Employee {
        double tax = 0;
        public Employee(int tax){
            this.tax = tax;
        }
        public double getTax() {
            return 0;
        }
    }
    

    分别新建 Management、Senior、Normal 继承 Employee,代表不同类型员工。

    public class Management extends Employee {
        public Management(int tax){
            super(tax);
        }
        @Override
        public double getTax() {
            return  tax*0.13;
        }
    }
    
    public class Senior extends Employee {
        public Senior(int tax) {
            super(tax);
        }
        @Override
        public double getTax(){
            return tax * 0.08;
        }
    }
    
    public class Normal extends Employee{
        public Normal(int tax) {
            super(tax);
        }
        @Override
        public double getTax(){
            return 0;
        }
    }
    
    

    定义接口,计算所有员工的纳税金额总和。

    public class Demo{
        public static void main(String[] arg){
            Employee[] employeeTax = new Employee[]{
                    new Management(23414),
                    new Senior(1234),
                    new Normal(3478)
            };
            System.out.println(getEmployeeTaxSum(employeeTax));
        }
        public static double getEmployeeTaxSum(Employee[] employee){
            double taxNum = 0;
            for (Employee eTax : employee){
                taxNum += eTax.getTax();
            }
            return taxNum;
        }
    }
    

    supper关键字的应用

    在多态中,如果子类重写了父类的方法,那么实际会指向的是子类的方法,但是如果你又想执行父类的方法,那么你可以使用super关键字应用父类方法。

    总结

    以上就是今天要讲的内容,本文全面介绍了Java多态的概念、特性、使用条件以及应用场景。相信仔细阅读这篇文章,你就能搞清Java多态。

    如果你觉得这篇帖子不错,可以关注我,我将定期更新Java知识。

    展开全文
  • Java基本概念多态

    千次阅读 2021-03-01 06:16:25
    一、简介描述:多态性是面向对象编程中的一个重要特性,主要是用来实现动态联编的。换句话说,就是程序的最终...多态可以让我们不用关心某个对象到底是什么具体类型,就可以使用该对象的某些方法,从而实现更加灵活...

    一、简介

    描述:

    多态性是面向对象编程中的一个重要特性,主要是用来实现动态联编的。换句话说,就是程序的最终状态只有在执行过程中才被决定,而非在编译期间就决定了。这对于大型系统来说能提高系统的灵活性和扩展性。

    多态允许相同类域的不同对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

    多态可以让我们不用关心某个对象到底是什么具体类型,就可以使用该对象的某些方法,从而实现更加灵活的编程,提高系统的可扩展性。

    如果对象的编译时类型和运行时类型不一致,就会造成多态。

    存在条件:

    类之间有继承关系。

    子类重写父类方法。

    父类引用指向子类对象。

    注意:

    多态是方法的多态,属性没有多态性。

    一个对象的实际类型是确定的,但是可以指向这个对象的引用的类型,却是可以是这对象实际类型的任意父类型。

    子类继承父类,调用方法,如果该方法在子类中没有重写,那么就是调用的是子类继承父类的方法,如果重写了,那么调用的就是重写之后的方法。

    'protected'修饰的父类方法可以被子类见到,也可以被子类重写,但是它是无法被外部所引用的,所以没有多态性。

    通过一个变量调用其引用的对象的一个方法,编译器是否能让其编译通过,主要是看该变量类型的类中有没有定义该方法,如果有则编译通过,如果没有则编译报错。而不是看这个变量所引用的对象中有没有该方法。

    Java中的方法调用,是运行时动态和对象绑定的,不到运行的时候,是不知道到底哪个方法被调用的。

    编写程序时,如果想调用运行时类型的方法,只能进行类型转换,不然通不过编译器的检查。但是如果两个没有关联的类进行强制转换,会报类型转换异常:ClassCastException。

    示例:

    public class Test {

    public static void main(String[] args) {

    /* 编译看左,运行看右 */

    Student student = new Student();

    /* 变量person是可以指向Person类型或其子类型的对象,所以可以指向Student类型对象 */

    Person person = new Student();

    /* 变量student能调用的方法是Student类中有的方法(包括继承过来的) */

    student.say();//Student

    /* 变量person能调用的方法是Person类中有的方法 */

    person.say();//Student

    }

    }

    class Person {

    public void say() {

    System.out.println("Person");

    }

    }

    class Student extends Person {

    public void say() {

    System.out.println("Student");

    }

    }

    二、重写、重载、多态的关系

    重载是编译时多态

    调用重载的方法,在编译期间就要确定调用的方法是谁,如果不能确定则编译报错 。

    重写是运行时多态

    调用重写的方法,在运行期间才能确定这个方法到底是哪个对象中的。

    重写方法所属取决于调用方法的引用,在运行期间所指向的对象是谁,那么调用的就是该对象中的方法。

    三、方法绑定

    程序执行调用方法时,系统根据相关信息,能够执行内存地址中代表该方法的代码。

    根据绑定方法的代码的时机不同,分为静态绑定和动态绑定。

    静态绑定:

    在编译期完成,可以提高代码执行速度。

    动态绑定:

    通过对象调用的方法,采用动态绑定机制。

    这虽然让我们编程灵活,但是降低了代码的执行速度。

    Java所有方法都是JVM在运行期才进行动态绑定的。

    四、'instanceof'关键字

    描述:

    'instanceof'是Java的一个二元操作符。

    'instanceof'是Java的保留关键字。

    'instanceof'的作用是测试它左边的对象是否是它右边的类的实例,返回一个布尔值。

    注意:

    'instanceof'左边的引用的类型与右边的类之间,必须有父子关系或子父关系,否则编译会报错。

    'instanceof'的布尔值结果,根据左边的引用的对象类型是否为右边的类的子类型。

    示例:

    public class Test {

    public static void main(String[] args) {

    Object object = new Student();

    System.out.println(object instanceof Student);//true

    System.out.println(object instanceof Person);//true

    System.out.println(object instanceof Object);//true

    System.out.println(object instanceof Teacher);//false

    System.out.println(object instanceof String);//false

    Person person = new Student();

    System.out.println(person instanceof Student);//true

    System.out.println(person instanceof Person);//true

    System.out.println(person instanceof Object);//true

    System.out.println(person instanceof Teacher);//false

    Student student = new Student();

    System.out.println(student instanceof Student);//true

    System.out.println(student instanceof Person);//true

    System.out.println(student instanceof Object);//true

    }

    }

    class Person {

    }

    class Student extends Person {

    }

    class Teacher extends Person {

    }

    五、类型转换

    描述:

    由于多态的关系,父类引用可以指向子类对象,子类引用不能指向父类对象。当我们想要调用子类中的方法,而对象的引用类型是其父类时,就需要将该引用类型进行强制类型转换。

    把子类对象直接赋给父类引用叫向上转型,向上转型不用进行强制类型转换。

    把指向子类对象的父类引用赋给子类引用叫向下转型,需要进行强制类型转换。

    向上转型会丢失子类特有的方法,但是子类若重写了父类的方法,重写的子类方法仍有效。

    向上转型可以减少重复代码,体现了抽象编程的思想。父类引用作为形式参数,调有时用子类引用作为实际参数,就是利用了向上转型。

    强制类型转换语法:

    (targetType) object

    示例:

    public class Test {

    public static void main(String[] args) {

    Person person1 = new Student();

    Student student1 = (Student) person1;

    student1.go();//studentGo

    student1.run();//studentRun

    person1.run();//studentRun

    Object object1 = new Student();

    Person person2 = (Person) object1;

    person2.run();//studentRun

    /*

    因为object2引用的对象类型不是Student的子类型,所以以下代码会出现运行时异常:ClassCastException

    Object object2 = new Teacher();

    Student student2 = (Student) object2;

    */

    }

    }

    class Person {

    public void run() {

    System.out.println("personRun");

    }

    }

    class Student extends Person {

    public void run() {

    System.out.println("studentRun");

    }

    public void go() {

    System.out.println("studentGo");

    }

    }

    class Teacher extends Person {

    }

    展开全文
  • Java多态概念理解(java期中作业)

    千次阅读 2020-11-17 16:35:09
    一、Java多态简介 多态是java继封装、继承后的面向对象的第三大特征,多态是同一个行为具有多个不同表现形式或形态的能力,多态是一个接口,使用不同的实例而执行不同操作。使用多态可以使程序有良好的扩展,并可以...
  • Java 多态的实现原理

    2021-02-27 19:49:57
    1、多态的机制1.1 本质上多态分两种1、编译时多态(又称静态多态)2、运行时多态(又称动态多态)重载(overload 发生在一个类中,方法名必须相同,不同参数)就是编译时多态的一个例子,编译时多态在编译时就已经确定,...
  • java多态概念

    2021-03-09 17:52:50
    java多态概念 对于多态,可以总结它为: 一、使用父类类型的引用指向子类的对象; 二、该引用只能调用父类中定义的方法和变量; 三、如果子类中重写了父类中的一个方法,那么在调用这个方法的时候,将会调用子类...
  • java多态的理解及实现原理

    千次阅读 2020-02-25 19:01:21
    1.多态是个什么鬼? 2.为啥需要多态多态的优势在哪?劣势在哪? 3.如果需要,那么它是怎么实现的,原理是什么 4.如何使用和使用场景是什么? 下面开始回答上面的问题,额,好吧,这个是我百度了好多地方然后...
  • 一、概念 多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。
  • JAVA多态的概述及作用 战神三考:Why、What、How 1、为何用多态? 2、多态是什么? 3、多态怎么用? 1、为什么要用多态 1)提高了代码的维护性 (通过继承和实现来保证) 2)提高了代码的扩展性 (通过多态来保证) 3)...
  • Java多态

    千次阅读 多人点赞 2022-04-07 19:37:12
    java多态中关于重载重写、向上和向下转型的一些解析
  • 相信很多学习java的人对于java多态是非常了解的,它的知识点也是非常重要的。今天就来为大家介绍一下,java多态是什么意思?并且用实例分享出来,一起来了解一下吧。首先,多态指同一个实体同时具有多种形式。它是...
  • Java 多态的特性和概念

    千次阅读 2019-04-25 16:52:51
    多态是同一个行为具有多个不同表现形式或形态的能力。 多态就是同一个接口,使用不同的实例而执行不同操作,如图所示: image 多态性是对象多种表现形式的体现。 现实中,比如我们按下 F1 键这个动作: ...
  • 一、多态概念 多态性是指同一个操作作用于某一类对象,可有不同的解释,产生不同的执行结果 多态存在的三个必要条件 需要存在继承或实现关系 同样的方法调用而执行不同的操作、运行不同代码(重写) 在...
  • Java多态总结

    2021-03-06 02:15:20
    这是我们最后一个概念,也是最重要的知识点。1.定义:多态:指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)2.实现多态的技术称为:动态...
  • 多态的基本概念 多态:同一种事物表现出来的多种形态。 多态语法格式 格式为:父类类型的引用指向子类类型的对象。如下所示 Person person=new Worker(); 多态的特点 (1)当父类类型的引用指向子类类型的对象时,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 87,260
精华内容 34,904
关键字:

java多态的概念

java 订阅