java中的抽象类

Question

可以在Java中创建抽象类的对象

Answer 1

如果你有一个像这样的抽象类：

public abstract class Foo
{
     public void bar()
     {
         car();
     }

     protected abstract void car();
}

如果你能够做到这一点：

final Foo foo;

foo = new Foo();
foo.bar();

假设“car”方法没有与之关联的代码，那么当“bar”方法调用“car”方法时会发生什么？

但是，您可以这样做：

class Star 
    extends Bar
{
    protected void car()  
    {
    }
}

然后执行：

final Foo foo;

foo = new Star();
foo.bar();

这次您有一个 Foo 类型的变量，它可以保存 Foo 的任何具体子类（非抽象的类是具体的）。现在，当您调用“bar”方法时，它使用 Foo 中的方法，而当调用“car”方法时，它使用 Star 中的方法。这是多态性的一个例子。

Answer 2

尝试实例化抽象类将在编译时失败，除非您提供其所有抽象方法的实现（通过实现匿名内部类）：

Runnable r = new Runnable() {
    public void run() {
        //do something
    }
};

Answer 3

假设这是一个完全新手的问题，那么 Java 中的抽象类如下：

Java 中的类主要有三种类型：接口、抽象类 和类。其中每一个都添加了一些特定于实际类定义的内容；

• 接口定义了可以在类中找到（并且必须实现）的方法。简而言之，接口定义行为。
• 抽象类实现一些功能，并在此之上定义附加的抽象方法，这些方法必须由扩展类实现。使用抽象类与直接类继承类似。
• 类只是您很可能已经熟悉的类。

使用任何可能的类类型都有很多理由，但是在现代 Java 代码中最常见的是，您会看到很多接口和一堆实现这些接口的类。

示例：类

考虑以下类：

public class Cat {
 public void speak() {
  System.out.println("Meow!");
 }
 public void eat(Food f) {
  System.out.println("Om nom nom, this "+f.getName()+" is delicious!"); 
 }
}

这是一个非常简单的类，是每个 Java 编码人员（甚至初学者）都熟悉的类型。这里没什么特别的。然而，这样你就会遇到一个问题：如果你有一只基本相同的狗，但它明显是在吠叫而不是喵喵叫，该怎么办？

示例：抽象类

“Cat 或 Dog”问题可以通过继承来解决。传统的标准继承看起来像这样：

public class Animal {
 public void eat(Food f) {
  System.out.println("Om nom nom, this "+f.getName()+" is delicious!");
 }
}

public class Cat extends Animal {
 public void speak() {
  System.out.println("Meow!");
 }
}

public class Dog extends Animal {
 public void speak() {
  System.out.println("Bark! Bark!");
 }
}

然而这里存在一个问题：要真正发出 Cat 喵喵声或 Dog 吠声，您必须有代码来检查到底是哪种动物动物是，将其转换为正确的类型，然后调用该方法：

if (animal instanceof Dog) {
 ((Dog) animal).speak();
} else if (animal instanceof Cat) {
 ((Cat) animal).speak();
}

如您所见，这种代码完全没有意义！我们当然希望能够直接调用 animal.speak()，对吧？为此，我们有抽象类！通过用此替换上面示例中的 Animal 类，

public abstract class Animal {
 public void eat(Food f) {
  System.out.println("Om nom nom, this "+f.getName()+" is delicious!");
 }
 public abstract void speak();
}

您只需调用 animal.speak 即可让您的 Dog 吠叫和 Cat 喵叫()！太棒了，不是吗？

请注意，您还可以将 speak() 的默认行为定义为 Animal，然后在 Cat 和 Dog< 中重写该方法。 /code> 有时，这甚至比我刚才在这里展示的更有意义。

不管怎样，另一个问题出现了：如果你的狗既是动物又是宠物怎么办？ Java 只允许单继承以避免钻石继承问题，所以你不能只拥有另一个超类对于他们来说。您可以将其添加为 Animal 的超类，但话又说回来，并非所有动物都是宠物 - 我的院子池塘里肯定没有河马！

示例：接口

由于接口仅定义行为，而不是实际实现它们（这实际上是相关的关键字！）您可以使用接口来定义原始类的附加行为。让我们假设宠物通常可以进行美容等，因此 Pet 的界面如下所示：

public interface Pet {
 void groom(Brush b);
}

现在只需将 implements Pet 添加到您的 Dog > 现在可以修饰了！只是为了确保，您的 Dog 类的第一行应如下所示：

public class Dog extends Animal implements Pet {

Now to groom your Dog or any other Pet you can do这：

if (animal instanceof Pet) ((Pet) animal).groom();

差不多就是这样了。作为练习，尝试将 Animal 实现为接口；请注意，接口实际上可以扩展其他接口。

附言。枚举和匿名内部类也可以被视为类类型，但是它们并不是每个人在学习 Java 基础知识后应该立即了解的主要类型。

Answer 4

如果您的意思是这样的话，您不能实例化抽象类（在其上调用 new ）。

可以有子类的实例。这些对象也是抽象类的实例，这意味着您可以将它们强制转换为抽象类。

Answer 5

这取决于你的意思。

如果你的意思是：“我可以有一个抽象类的实例吗”——当然； （抽象类的）具体子类的任何实例也隐式地是抽象超类型的实例。

如果您的意思是：“我可以拥有一个抽象类的实例而不定义具体的子类型吗”——是的，如果某个库（例如 javassist、cglib）为您生成了一个具体的子类型。

如果您的意思是“以下表达式是否会通过”：

assert Modifier.isAbstract(x.getClass().getModifiers());

答案是否定的。

Answer 6

看看吧。它干净整洁javacanal.blogspot.com/

Answer 7

不，这是不可能的。您需要创建一个扩展抽象类的类，然后您可以创建子类的对象。

请查找示例：

abstract class AbstractClass{

    public abstract String abstractMethod(String param1,String param2);

    public void nonAbstractMethod(String param){
        System.out.println("Value of param is "+param);
    }
}

class NonAbstractClass extends AbstractClass{
    public String abstractMethod(String param1,String param2){
        String param = param1 + param2;
        return param;
    }
}


public class DemoClass{

    public static void main(String[] args) {
        NonAbstractClass nonAbstractClass = new NonAbstractClass();
        nonAbstractClass.abstractMethod("param1", "param2");
        nonAbstractClass.nonAbstractMethod("param1");
    }
}