Can'；不要在Java中扩展类

我觉得问这个问题很愚蠢，但我真的看不出问题所在。编译它给了我一个选择

这是超级班

package elements;
import persistence.postgres.DataSource;
import persistence.postgres.IdBroker;
import persistence.postgres.PersistenceException;
import util.Util;

public class Hotspot {
private double lat;
private double lng;
private long id;
private String username;
private String time_stamp;
private String point_of_interest;
private String comment;

public Hotspot(double lat, double lng, String username, String comment, String p_o_i) {
    this.lat = lat;
    this.lng = lng;
    this.username = username;
    try {
        this.id = IdBroker.getId(new DataSource().getConnection());
    } catch (PersistenceException e) {
        e.printStackTrace();
    }
    time_stamp = Util.timeStamp();
    this.comment = comment;
    this.point_of_interest = p_o_i;
}

public Hotspot(double lat, double lng, String username, long id,  String time_stamp) {
    this.lat = lat;
    this.lng = lng;
    this.username = username;
    this.id = id;
    this.time_stamp = time_stamp;
}

//Getter Setter for all variable and HashCode/Equals

}

这是子脚本

package persistence.postgres;

import elements.Details;
import elements.Hotspot;

public class HotspotProxy extends Hotspot {
private HotSpotDAOpostgres hsd;
private Details details;

//insert
public HotspotProxy(double lat, double lng, String username, String comment, String poi) {
    super(lat, lng, username, comment, poi);
    this.hsd = new HotSpotDAOpostgres();
}

//Retrieve
public HotspotProxy(double lat, double lng, String username, long id, String time_stamp) {
    super(lat, lng, username, id, time_stamp);
    this.hsd = new HotSpotDAOpostgres();
}

public String getPointOfInterest() {
    redifined method
}

public String getComment() {
        //redifined method
}
}

这给了我一个错误

Hotspot h = new Hotspot(31.124, 43.123, "name", "comment", "point of interest");
HotspotProxy hp = (HotspotProxy)h;

请告诉我我哪里不及格。感谢您的建议

热点：=动物
HotspotProxy:=狗

您可以将

狗

转换为

动物

（从特殊到一般，或者换句话说，从子类转换为基类），但不能反过来（从一般到特殊，或者换句话说，从基类转换为子类），因为每只

狗

都是

动物

，但并非所有的

动物

都是

狗

如果你有

Animal a = new Dog();

然后，将允许以下情况：

Dog d = (Dog) a;

---

因为

a

实际上是一只

Dog

所以不能将超类的实例强制转换为子类

没错，

热点代理

也是一个

热点

，但是并非所有热点都是热点代理

请注意，这不是编译错误。这是一个运行时错误。这是因为您执行了强制转换（显式强制转换！），所以基本上您告诉编译器相信您知道自己在做什么，但是。。你没有。因此编译器会说“好的，我会编译，他知道他在做什么”，但是当你运行程序时，你会得到一个运行时错误

---

（如果删除强制转换，确实会出现编译错误）。

这是因为您试图将一个超级类对象强制转换为子类

Hotspot h = new Hotspot(31.124, 43.123, "name", "comment", "point of interest");
HotspotProxy hp = (HotspotProxy)h;

---

您在第二条语句中执行了类型强制，并愚弄了编译器，使其相信

h

确实是

hospotproxy

对象。编译器允许这样做，因为

热点h

可以引用其子类的任何对象。因此，如果前一行是

Hotspot h=new hostpotproxy（）

，则此强制转换将成功。但在运行时，JVM发现您违反了编译器的信任，并且

h

是

Hotspot

的对象，而不是

hostpotproxy

，因此它抛出异常

有时，对象变量实际上是任何变量的子类的实例。例如，你可以

Hotspot h = new HotspotProxy(...)

---

因为

热点代理

是

热点

。在这种情况下，布尔值

（hospotproxy的h instanceof）

将

为true

。但是，在您的情况下，

h

变量是

hospotproxy

，因此

（hospotproxy的h instanceof）

将是

false

，强制转换将失败。

首先检查hospotproxy的实例是否为hospotproxy

if(h instanceof HotspotProxy)
HotspotProxy hp = (HotspotProxy)h;

---

您可以向下转换，前提是您使用的引用变量实际上指向子类对象。 例如，假设类狗扩展了类动物

然后

当我们以这种方式强制转换时，编译器将信任我们：它所确保的只是对象属于相同的继承层次结构。所以这会很好。但在第二种情况下，以及在您的情况下，这抛出了ClassCastException be

您可以在向下转换之前检查代码，以防止出现此类错误：

if(HotSpot1 instanceof HotSpotProxy)
{
 HotSpotProxy hsp= (HotSpotProxy) HotSpot1;
}

---

值得注意的是，在下面的所有答案中，您永远不能从超级类转换为子类，这并不是绝对正确的。相反，无法保证演员阵容会成功。常见的下载示例包括

（Graphics2D）g

和

（AbstractDocument）e.getDocument（）

。

if(HotSpot1 instanceof HotSpotProxy)
{
 HotSpotProxy hsp= (HotSpotProxy) HotSpot1;
}