Question

下面是代码：

package com.java2.javaapplication2;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.

/**
 *
 * @author Ajinkya
 */
class A{
    int data1=10;
    void show1(){
        System.out.println("In A="+data1);
    }
}

class B extends A{
    int data2=20;
    void show2(){
        System.out.println("In B="+data2);
    }



}


public class Overriding6 {
    public static void main(String args[]){
        A a=new B();
        System.out.println("Data1="+a.data1);
        System.out.println("Data2="+a.data2);
        a.show1();
        a.show2();
    }
}

请解释A a = new B（）;以及哪些变量和方法可以访问？这种技术被称为多态参考权，但它如何在继承的影响下工作？

Answer 1

在java方法（行为）中，调用在运行时根据运行时实际对象类型解析，该类型称为动态方法调度或后期绑定或动态绑定。但是属性（成员变量）调用不是基于运行时实对象来解决的，而是基于引用类型来解析。在你的情况下：

超类引用可以保存子类对象并使用它参考你可以调用超类的所有方法和已知的子类方法（至少在超级中声明）（超级）。
当您访问任何类成员变量时，它与其无关真实对象，并根据参考类型访问。

所以你不能通过类A的引用来调用show2（），因为超类A不知道这个方法。你也不能用超类A的引用访问data2变量，因为调用成员变量是基于引用类型并通过任何引用调用成员变量它应该在该引用类型的接口/类中声明（已知）

Answer 2

System.out.println("Data2="+a.data2);

这样做不行，java就像这样

编译器在你的LEFT SIDE（变量）上查找，并根据它知道它可以访问哪些方法（在你的变量引用的类A中找不到data2），

但是在运行时，JVM会查看堆上真实创建的对象（通过“new”关键字），这是

new B();

所以，它采用编译器选择的方法，并根据内存中的可用对象在运行时实现它

所以......

A a = new B();

首先声明一个你想要的任何类型的变量（A），这样你就可以访问它的任何可能的方法或变量

并且编译器正在等待您将通过IS-A测试的任何对象分配给此变量类型，并且由于B扩展A，因此它是IS-A“A”，任何子类IS-A超类

所以编译器接受这个赋值

这种技术用于使同一方法抛出子类的不同实现（使用）受益，例如：

这些是在体育场内进行的体育运动以及门票价格

class Sport{ int getTicketPrice(){ return 0;}}
class Basketball extends Sport{ int getTicketPrice(){return 10;}}
class Football extends Sport{ int getTicketPrice(){return 20;}}

假设这是体育场馆票系统的一部分，并且有一个班级根据人们想去的运动类型确定门票价格，所以它将有一个像这样的方法

class Tickets{ int getPrice(Sport sport){return sport.getTicketPrice();}}

如果没有多态（IS-A / inheritence），我们将需要制作3个Tickets类，每个类都有一个getPrice（）方法，它将我们的3个类（Sport，Basketball，Football）中的每一个作为参数，但是

编译器将允许您使用Sport类的任何子类，因为它确定Sport类（及其所有子类）具有名为“getTicketPrice（）”的方法，并且子类没有覆盖（更改实现） /使用此方法作为此示例），将实现原始方法

所以，编译器端检查方法，并且JVM决定了这个方法的真实结果，回到我们的例子，我们将有一个类来运行这部分系统，一个类负责采取类型的运动，并检查它的票价，然后显示给用户，所以这个类的一部分将是

class BasketballBoxOffice{
    Tickets tickets = new Tickets();
    Sport sport = new Basketball();

    // this is a method that runs when ever the Tickets Seller clicks 
    // on Print Ticket Button on the Screen        

    void printTicket(){
        // some code
        System.out.println(tickets.getPrice(sport));
        // some code        
    }

    // more code
}

现在使用相同的系统，在这个体育场的足球部分的票房上，你不需要新的课程，但只需要一个“多态”

class FootballBoxOffice{
    Tickets tickets = new Tickets();
    Sport sport = new Football();    // thats all the difference

    // this is a method that runs when ever the Tickets Seller clicks 
    // on Print Ticket Button on the Screen        

    void printTicket(){
        // some code
        System.out.println(tickets.getPrice(sport));
        // some code        
    }

    // more code
}

多亏了多态（继承），不需要改变代码的任何东西，只需子类化任何类，并为它的方法创建自己的实现，并使用它

希望这不是我的愚蠢解释

任何人都可以帮我解决这个多态参考变量的解释吗？

2 个答案: