当前页面: 开发资料首页 → J2SE 专题 → 关于多态的问题 ，帮我解决拉，，谢谢拉

关于多态的问题 ，帮我解决拉，，谢谢拉

摘要: 关于多态的问题 ，帮我解决拉，，谢谢拉

先看代码
public abstract Door
{
abstract void open();
}

public abstract BigDoor extends Door
{
int a = 10;
int b = 10;
void open()
{
System.out.println(-#34;开门-#34;);
}
public static void main(String [] args)
{
Door door = BigDoor();
door.a; // 为什么不能这样访问子类中的成员变量,C++中为什么可以？

}
}

// 为什么不能这样写 ，给我讲点内存方面的分配知识..
// 那到底什么才算多态 难道就是就是方法的多态么？

---

父类变量引用不能访问子类资源,所以不能访问

还有你这句Door door = BigDoor();错了

---

看到这句了吗public abstract BigDoor extends Door
这是一个abstract类,这种类是不能被实例化的,就是new一个这样的抽象类.

---

抽象类不能实例化,也就不能new 对象

1.JAVA里没有多继承，一个类之能有一个父类。而继承的表现就是多态。一个父类可以有多个子类，而在子类里可以重写父类的方法（例如方法print()），这样每个子类里重写的代码不一样，自然表现形式就不一样。这样用父类的变量去引用不同的子类，在调用这个相同的方法print()的时候得到的结果和表现形式就不一样了，这就是多态，相同的消息（也就是调用相同的方法）会有不同的结果。举例说明：
//父类
public class Father{
//父类有一个打孩子方法
public void hitChild(){
}
}
//子类1
public class Son1 extends Father{
//重写父类打孩子方法
public void hitChild(){
System.out.println(-#34;为什么打我？我做错什么了！-#34;);
}
}
//子类2
public class Son2 extends Father{
//重写父类打孩子方法
public void hitChild(){
System.out.println(-#34;我知道错了，别打了！-#34;);
}
}
//子类3
public class Son3 extends Father{
//重写父类打孩子方法
public void hitChild(){
System.out.println(-#34;我跑，你打不着！-#34;);
}
}

//测试类
public class Test{
public static void main(String args[]){
Father father;

father = new Son1();
father.hitChild();

father = new Son2();
father.hitChild();

father = new Son3();
father.hitChild();
}
}
都调用了相同的方法，出现了不同的结果！这就是多态的表现！


2.JAVA中没有多继承，而用接口实现了多继承！一个类或是可以同时实现多个接口！（就相当于C++里一个类同时继承了多个类！）例如：
public class Son implements Father1,Father2,Father3{

}

接口有利于代码功能的扩展（增加新的功能）！而继承则有利于代码功能的修改（把旧的功能改成新的功能）！这里旧功能的修改和新功能的增加前提是不修改旧的功能，旧的功能仍然可以使用！旧类的代码也不做修改！

接着上面的继承举例：上面例子中的子类我们统称为一代子类

1.用继承修改旧的功能。
现在如果一代Son1的功能打孩子，也就是方法hitChild()里边的功能实现有问题，我们要把具体实现修改掉，那么我们可以重新写一个新的二代子类Son11继承自一代子类Son1，并重写其hitChild()方法。

//二代子类
public class Son11 extends Son1{
//重写父类打孩子方法
public void hitChild(){
System.out.println(-#34;我是二代子类对此方法的新实现-#34;);
}
}

2.用接口实现增加新的功能。
现在类Son1已经有了‘打孩子’功能（也就是方法），而我们有了新的需求，我们需要它还要有一个新的功能‘宠孩子’（新方法pet();）。而旧的代码不能动！那么我们可以定义一个新的接口（PetInterFace），接口里定义这个方法pet()的声明。再重新写一个二代子类Son11，让它先继承类Son1，同时实现接口 PetInterFace！并实现接口里的 pet()方法！

//新接口
public interface PetInterFace{
//新功能方法
public void pet();
}

//二代子类
public class Son11 extends Son1 implements PetInterFace{
//实现接口方法
public void pet(){
System.out.println(-#34;父亲很爱我！-#34;);
}
}
这样这个二代子类即有了老的方法，又有新的功能！

---

哦 我写掉了一个 NEW
Door door = BigDoor(); 该成 Door door = new BigDoor();

---

是不是 如果以Door door = new BigDoor(); 定义后；
我想通过 对象door访问子类的成员变量 怎么做
“？？？？？

---

成员变量 申明为public撒

---

Door door = new BigDoor();这也不对撒,BigDoor是抽象类,抽象类不能实例化

---

如果把BigDoor改成非抽象类
那么Door door = new BigDoor();
door永远无法调用到子类中独有的资源,包括属性和方法,即使这些属性方法被定义成public
要想访问必须BigDoor door = new BigDoor();这样才能访问

---

楼上正解，“door永远无法调用到子类中独有的资源,包括属性和方法,即使这些属性方法被定义成public”

---

public abstract Door
{
abstract void open();
}

public BigDoor extends Door
{
int a = 10;
int b = 10;
void open()
{
System.out.println(-#34;开门-#34;);
}
public static void main(String [] args)
{
BigDoor door = new BigDoor();
door.a;
}
}
这样的话可以访问。

---

class A{
int i=1;
public void open(){

System.out.println(-#34;open-#34;);
}
}
public class Abc extends A{
int i=2;
int j=5;
public void open(){
System.out.println(-#34;open2-#34;);
}
public static void main(String[] ars){
A abc = new Abc();
abc.open();
System.out.println(abc.i);
// System.out.println(abc.j);
}
}
楼主看这个程序应该可以理解了。
输出为
open2
1

为什么呢？
函数调用的时候访问了子类，而调用基本类型的时候却调用了基类。

体会一下。

---

mark

---

Door door =new BigDoor();
Door类中没有a

---

人家强调了的。你建立的是抽象子类。所以子类不能够实例化。所以说你的程序本身就有问题。是不可能执行出来的。会编译错误！！！当字类继承父类时，因为是继承的是非private修饰成员变量，所以就出现了信息隐藏，也就是父类的属性值依然在内存中，没有被释放，因此当父类对象引用他的时候。对象将调出内存中的父类的属性值，因此不显示子类 属性的值，要象改变父类的属性值。可以用方法的重载。当重载时父类方法不是在内存里的。而有子类的方法！故可以满足你的要求。

---

好贴。

---

阅

---