一个简单的问题，请进来看一下~~

Question

我发现一个问题，如果有一个抽象类，定义了1个抽象方法，那么它的派生类没有定义抽象方法，这时再创建一个类来创建派生类的对象时，是错的
但是：如果这时我在基类中再定义一个抽象类，并且在派生类中只定义一个抽象方法，此时再创建派生类对象的时候居然可以编译，这是为什么？？

Answer 1

你是说这样？？？
abstract class a {

public abstract void aa();

public abstract class zz{

}
}class b extends a {
public void aa() {

}
}没有问题吖，子类已经重写了父类的抽像方法了。
你是不是想问为什么子类没有“重写”父类里的那个抽象类，却可以编译通过？？
子类只需要重写父类的抽像方法就可以了，zz不是方法，所以根本不能重写。

Answer 2

当然因为在java中抽象类中所有的方法都一定是抽象的，还有一些常量。
所以如果你用子类继承了他只需要实现它的抽象方法而并不需要实现它的抽象子类。

Answer 3

不明白你说的意思,既然是派生类中有抽象方法,那这个派生类就应该声明为abstract,抽象类怎么能new 个对象出来!

Answer 4

问问竹子，后面的内容是你复制的还是api接口啊，感觉应该不是复制的，要不然你头都要大了，呵 

Answer 5

我来贴代码~~~
第一段：
public abstract class Animal{
public abstract void sound(); //抽象方法
public abstract void speed(); //同上
public Animal(String aType){
type = new String(aType);
}
public String toString(){
return "This is a " + type;
}

private String type;
}
第二段：
public class Dog extends Animal {
public Dog(String aName){
super("Dog");
name = aName;
breed = "Unknown";
}
public Dog(String aName, String aBreed){
super("Dog");
name = aName;
breed = aBreed;
}
public String toString(){
return super.toString() + "\nIt's " + name + " the " + breed;
}
public void sound(){  //我这里定义了基类中的一个抽象方法
System.out.println("Woof  Woof");
}
private String name;
private String breed;
}
第三段：
public class TestDerived {
public static void main(String[] args){
Dog aDog = new Dog("Fido","Chihuahua");//生成了Dog对象，但是我Dog对象里只定义了一个抽象方法
Dog starDog = new Dog("Lassie");
System.out.println(aDog);
System.out.println(starDog);
}
}
基类中有2个抽象方法，但是在派生类中只定义了一个抽象方法，而Dog类我并没有声明为 abstract ，但在创建Dog对象时却没问题~~

Answer 6

public void sound(){  //我这里定义了基类中的一个抽象方法 
System.out.println("Woof  Woof"); 
} 明明是实现,怎么说是定义!

Answer 7

前半句听懂了，如下：public abstract class AbstractSuper {
    public abstract void test();
}
public class SubClass extends AbstractSuper {
    //Nothing
}抽象类的定义是包含抽象方法的类，因为抽象方法没有方法体，所以不能创建抽象类的实例（否则调用抽象方法该如何执行？）虽然 SubClass 没有定义抽象方法，但它从超类 AbstractSuper 中继承了一个抽象方法 test，所以子类 SubClass 实际是有抽象方法的，当然不能创建 SubClass 的实例，而且如果 SubClass 不用 abstract 修饰它本身就会产生编译错误，而不是在 new 它实例时。

Answer 8

//我来贴代码~~~
//第一段：
abstract class Animal { public abstract void sound(); //抽象方法 public abstract void speed(); //同上 public Animal(String aType) {
this.type = new String(aType);
} public String toString() {
return "This is a " + this.type;
} private String type;}//第二段：
class Dog extends Animal {  //此处导致编译失败 The type Dog must implement the inherited abstract method Animal.speed() public Dog(String aName) {
super("Dog");
this.name = aName;
this.breed = "Unknown";
} public Dog(String aName, String aBreed) {
super("Dog");
this.name = aName;
this.breed = aBreed;
} public String toString() {
return super.toString() + "\nIt's " + this.name + " the " + this.breed;
} public void sound() { //我这里定义了基类中的一个抽象方法 //更正：我这里实现了超类中的一个抽象方法
System.out.println("Woof  Woof");
} private String name;
private String breed;}//第三段：
public class TestDerived { public static void main(String[] args) {
Dog aDog = new Dog("Fido", "Chihuahua");  //生成了Dog对象，但是我Dog对象里只定义了一个抽象方法
Dog starDog = new Dog("Lassie");
System.out.println(aDog);
System.out.println(starDog);
}}//基类中有2个抽象方法，但是在派生类中只定义了一个抽象方法，而Dog类我并没有声明为 abstract ，但在创建Dog对象时却没问题~~

Answer 9

楼主的这段代码,在eclipse下,Dog类提示有错(这是当然的),不过它却生成了Dog.class文件,然后运行第三段代码,也还真的是运行了.其实Dog类应该编译不通过的,但是为什么eclipse在提示有错的情况下,还为它生成class文件了?

Answer 10

很奇怪是吧，这东西居然还真能运行...其实我是抱着实一下的态度搞这个的，没想到真的试出问题来了~~~这应该就是BUG了吧~~~