Java 如何创建抽象类的无名派生类的对象？

考虑以下Java程序：

abstract class Surprising
{       
    void fun()
    {
        System.out.println("fun() is invoked");
    }
}
class myclass
{
    public static void main(String args[])      
    {
        Surprising s=new Surprising() { };
        s.fun();
    }
}

这里我创建的是抽象类的无名子类的对象，而不是抽象类的对象，因为Java中不允许创建抽象类的对象

---

什么是等价的C++程序？在C++中有可能做到这一点吗？如果是，怎么做&如果不是，为什么不允许？

假设我们有一个

A

：

class A
{
    ...
};

现在要创建它的派生，我们使用

class B : public A
{
    ...
};

现在要创建匿名类的对象，我们不提供类名：

class
{
    ...
} anon_object;

最后，我们结合了两种方式，继承和匿名类：

class : public A
{
    ...
} anon_a_derived_object;

---

假设我们有一个类

A

：

class A
{
    ...
};

现在要创建它的派生，我们使用

class B : public A
{
    ...
};

现在要创建匿名类的对象，我们不提供类名：

class
{
    ...
} anon_object;

最后，我们结合了两种方式，继承和匿名类：

class : public A
{
    ...
} anon_a_derived_object;

---

您不能像在Java中那样动态地执行此操作，因为它将类声明为

new

表达式的一部分。但您可以在函数内创建一个本地类并使用它：

void main(int argc, char **argv)
{
  class MySurprising : public Surprising {};
  MySurprising s;
}

---

您不能像在Java中那样动态地执行此操作，因为它将类声明为

new

表达式的一部分。但您可以在函数内创建一个本地类并使用它：

void main(int argc, char **argv)
{
  class MySurprising : public Surprising {};
  MySurprising s;
}

---

<>在C++中，<>代码>惊奇>代码>类不是抽象的，因为它定义了它的所有成员。如果您想要一个抽象（即不可实例化）类，请至少将其一个成员设置为纯虚拟。就像这里：

class Surprising
{
public:
    virtual void fun()=0;
};

然后，您可以在创建实例的匿名类中定义成员，然后在该实例上调用新定义的成员函数：

#include <iostream>

int main()
{
    class  : public Surprising
    {
    public:
        virtual void fun() { std::cout << "Surprise!" << std::endl; }
    } inst_;
    inst_.fun();

    return 0;
}

#包括
int main（）
{
类别：公众惊讶
{
公众：
“虚空”（{STD::CUT< P> C++）<代码>惊奇< /Cord>类不是抽象的，因为它定义了它的所有成员。如果你想要一个抽象的（即不是实例化）类，那么至少让它的一个成员纯虚。
class Surprising
{
public:
    virtual void fun()=0;
};

然后，您可以在创建实例的匿名类中定义成员，然后在该实例上调用新定义的成员函数：

#include <iostream>

int main()
{
    class  : public Surprising
    {
    public:
        virtual void fun() { std::cout << "Surprise!" << std::endl; }
    } inst_;
    inst_.fun();

    return 0;
}

#包括
int main（）
{
类别：公众惊讶
{
公众：
虚拟空函数（{ STD::CUT< P>）。java和C++之间存在几个与此问题相关的差异。我尝试生成C++代码，它与java代码最匹配。
#include <iostream>

class Surprising           // class is abstract since it has pure virtual method
{
public:
  virtual void fun() = 0;  // pure virtual method makes the class abstract
};

// we can define the pure virtual method, but not in class
inline void Surprising::fun()
{
  std::cout<<"fun() is invoked\n";
}

int main()
{
  struct : Surprising      // anonymous derived class
  {
    void fun()             // we must provide an implementation of fun()
    {                      // for otherwise this class remains abstract and
      Surprising::fun();   // cannot be instantinated
    }
  } s;                     // object of anyonmous class
  s.fun();
}

#包括
类//类是抽象的，因为它有纯虚方法
{
公众：
virtual void fun（）=0；//纯虚方法使类抽象
};
//我们可以定义纯虚方法，但不能在类中定义
内联void:：fun（）
{
STD:：CUT> P>，java和C++之间存在着几个与此问题相关的差异。我尝试生成C++代码，它与java代码最匹配。
#include <iostream>

class Surprising           // class is abstract since it has pure virtual method
{
public:
  virtual void fun() = 0;  // pure virtual method makes the class abstract
};

// we can define the pure virtual method, but not in class
inline void Surprising::fun()
{
  std::cout<<"fun() is invoked\n";
}

int main()
{
  struct : Surprising      // anonymous derived class
  {
    void fun()             // we must provide an implementation of fun()
    {                      // for otherwise this class remains abstract and
      Surprising::fun();   // cannot be instantinated
    }
  } s;                     // object of anyonmous class
  s.fun();
}

#包括
类//类是抽象的，因为它有纯虚方法
{
公众：
virtual void fun（）=0；//纯虚方法使类抽象
};
//我们可以定义纯虚方法，但不能在类中定义
内联void:：fun（）
{
std：：cout这与问题中的示例有很大的不同。每个匿名者现在都必须实现
fun
方法。我建议添加一个额外的虚拟方法，以便
惊喜
类仍然具有
fun
的实现，这没有必要，我这样做只是因为我ad感觉OP有一个特定的原因使
令人惊讶
抽象化，即防止实例化。我们也可以定义
fun（）
中的函数，然后从中派生出一个类，但是如果派生对象不添加或更改功能，那么进行子分类有什么意义呢？
最好让匿名类使用
override
关键字，而不是
virtual
干杯这是一个漂亮的big与问题中的示例不同。每个匿名者现在都必须实现
fun
方法。我建议添加一个额外的虚拟方法，以便
惊奇的
类仍然具有
fun
的实现。没有必要这样做，我只是这样做，因为我觉得OP已经实现了使
出人意料的
抽象化的一个具体原因，即防止实例化
函数已经在
中运行，然后从中派生出一个类，但是如果派生函数没有添加或更改功能，那么进行子分类有什么意义呢？
最好让匿名类使用
override
关键字，而不是
virtual
关键字将是匿名的
struct:saging{s；s.fun（）；
@Walter这是其他答案所显示的。出于完整性考虑，我将省略我的答案。例如，这让您可以选择动态分配。更类似的是匿名的
struct:saging{s；s.fun（）
@Walter其他答案就是这样的。出于完备性考虑，我将保留我的答案。例如，这让您可以选择动态分配。