考虑-
public class Class_A {
public void func() {...}
public void func(int a){...}
三个人-
Class_A a = new Class_A(); // legal
a.func(); // legal
a.func(1); // legal
但是,在将具有arg的构造函数(如public Class_A (int a){...} )添加到Class_A之后,默认构造函数将变成-
Class_A a = new Class_A(); // The constructor Class_A() is
令人怀疑的是:
在子类中定义常量构造函数时,上层类的默认构造函数必须是常数。
但是,当上层类的默认构造函数定义为常量时,继承类的构造函数不必是常数。
下面的守则说明了这种情况:
// Default constructor of the subclass defined as constant:
class Super_class {
Super_class();
}
class Sub_class extends Super_class {
const Sub_class() : super();
}
// Default constructor of the upper cla
class ClassSealer {
private:
friend class Sealed;
ClassSealer() {}
};
class Sealed : public ClassSealer
{
// ...
};
class FailsToDerive : public Sealed
{
// This class is capable of being instantiated
};
上面没有封上类,但是下面的作品,为什么?
class ClassSealer {
private:
friend class Sealed;
ClassS
我正在尝试学习C++继承,但有一件事对我来说没有任何意义。谷歌搜索的关于派生类未继承的内容的所有内容都说,构造函数、朋友和operator=都不是继承的。然而,这个信息不符合我的计划的结果。
我做了一个继承的例子,结果如下:
#include <iostream>
using namespace std;
class Base
{
public:
Base()
{
cout << "constructor base class without parameters" << endl;
}
Base(int a)
我知道两种禁止继承的方法:
上最后一节课
宣布一个私有构造函数
为了防止继承,类的默认构造函数必须声明为私有。
class Class {
private Class() {}
}
class OtherClass extends Class {
// Error! There is no default constructor available
}
为使用super所做的一切
class Class {
public Class() {}
}
class OtherClass extends Class {
public Othe
当我们从下面的类初始化对象时,哪些类将使用默认构造函数?
class X {}
class Y {
Y () {}
}
class Z {
Z(int i ) {}
}
类Z将不使用默认构造函数。类X将使用默认构造函数。
那Y呢?用户定义的空构造函数是否称为默认构造函数?就像他们在维基百科(Java部分) 上说的那样
或者,如果我们在初始化对象时可以说是默认构造函数,那么类中不应该定义构造函数吗?
我试图像这样调用父母的第二个构造函数
abstract class A(val i: Int) {
constructor(c: C) : this(c.i)
}
class B() : A(0) {
constructor(c: C) : super(c) // error is here
}
class C(val i: Int)
但是它会产生Primary constructor call expected错误。子类如何调用父类的辅助构造函数?
下面的代码给出了一个编译错误:
class parent {
parent(int a){}
}
class child extends parent{}
错误:
Main.java:6: cannot find symbol
symbol : constructor parent()
location: class parent
class child extends parent{}
^
1 error
我试着做不同的事情,发现向父构造函数添加返回类型可以消除错误!
class parent {
int parent(int a){}
}
class child extend
“使用”私有成员变量使其成为公共成员,但构造函数保持私有。示例:
class MyClass;
class Base
{
private:
Base(float v) : m_v{v} {}
float m_v;
friend MyClass;
};
class MyClass: public Base
{
public:
using Super = Base;
using Super::Super; // this is still private
using Super::m_v; // this is public
};
我一直认为,当创建带有子类的对象时,我们需要显式地使用super(arguments list)调用超类的构造函数。然而,我做了一个实验,并意识到,即使没有的使用super(),超类的构造函数也将被自动调用。这是真的吗?
如果这是真的,什么时候super()是多余的,什么时候不是?
class Parent
{
public Parent()
{
System.out.println("Super Class");
}
}
class Child extends Parent
{
public Child
我只是在尝试抽象类,结果遇到了一个错误。
我有一个这样的类:
public abstract class C {
String aname;
int aid;
public C(String s, int n) {
aname = s;
aid = n;
}
public static void main(String[] args) {
System.out.println("Hello");
}
}
现在,另一个类对它进行了如下扩展:
public class D exten
我正在开发下面的代码...
class P {
//public P(){}
public P(int i) {
}
}
class D extends P {
public D(){ // default constructor must be defined in super class
}
}
public class agf {
public static void main(String[] args) {
}
}
现在在类p中定义了显式参数化构造函数,在类D中定义了默认构造函数,但它仍然显示编译时错误,请
在Java和C++中,术语“默认构造器”都是正式的,在这两个世界中,这似乎意味着不同的东西。我想知道我的理解是否正确,一些相关概念的正确命名是什么?
默认构造函数在中是指在没有为类定义构造函数时由编译器生成的( no -arg)构造函数。
C++中的默认构造函数意味着可以在没有参数的情况下调用构造函数。
给出以下示例
Java:
class NoCtorClass {
// No ctor defined, compiler is generating one --------- J-1
}
class NoArgCtorClass {
public No
我知道下面这些都不管用,但你能帮我理解一下原因吗?
class A {
A(int x) {
System.out.println("apel constructor A");
}
}
class B extends A {
B() {
System.out.println("apel constructor B");
}
}
public class C {
public static void main(String args[]) {
B b = new B
我用java编写了这个简单的类,只是为了测试它的一些特性。
public class class1 {
public static Integer value=0;
public class1() {
da();
}
public int da() {
class1.value=class1.value+1;
return 5;
}
public static void main(String[] args) {
class1 h = new class1();
clas
我读了一些代码,不明白基是如何工作的。读几个例子,但它们不能解释我的问题。
两者都提供相同的输出。我们为什么需要基地()?
没有基的代码
class B : A
{
public B()
{
Console.WriteLine("B");
}
}
class A
{
public A()
{
Console.WriteLine("A");
}
}
class test
{
static void Main()
{
A a = new A();
有人能告诉我为什么基类的构造函数方法会被两次调用吗?
#include <iostream>
using namespace std;
class A{
public:
A(){
cout << "default constructor of base class" << endl;
}
};
class B:public A{
public:
B(){
A();
cout << "default constructor of de
在这个程序中,super不需要到达超类的构造函数:
class Base{
Base(){
System.out.println("Base");
}
}
public class test2 extends Base{
test2() {
//super();
System.out.print("test2");
}
public static void main(String argv[]){
test2 c = new test2();
我得到了这个错误:
'CTest.A.A()‘由于其保护级别而无法访问。
在编译此代码时:
public class A
{
private A()
{
}
}
public class B : A
{
public void SayHello()
{
Console.WriteLine("Hello");
}
}
有人能解释原因吗?
我在玩Java的倒影。我有一个带有构造函数的抽象类Base。
abstract class Base {
public Base( String foo ) {
// do some magic
}
}
我还有一些扩展Base的进一步类。它们不包含太多的逻辑。我想用Base的构造函数实例化它们,而不必在这些派生类中编写代理构造器。当然,我想用反射实例化这些派生类。
Class cls = SomeDerivedClass.class;
Constructor constr;
constr = cls.getConstructor( new Class[] { S
当我运行以下代码时,我得到了未报告的异常
我的代码如下
class Super {
public Super() throws Exception {
System.out.println("Super Class");
}
}
public class Sub extends Super {
public static void main(String[] args) throws Exception {
Sub s = new Sub();
}
}
获取以下错误: Sub.ja
我想做这样的事情
public class Class1
{
public Class1()
{
}
public Class1(int a)
{
}
}
public class Class2 :Class1
{
public Class2(int a)
{
}
public Class2(): base(2)
{
this(2); // new Class2(2);
我在我的程序中使用继承和超级函数,但是当我扩展类时,它会显示错误消息“'cc‘中没有默认的构造函数”。此错误消息是在扩展第一个子类并试图生成第二个子类之后发出的。这是代码
class aa{
int i=-1;
int show(){
return i;
}
}
class bb extends aa{
int i;
bb(int g,int j){
super.i=g;
i=j;
}
}
class cc extends bb {
int j,k;
cc(int i, int j,int k) {
super(i,j);
super.i=i;
thi
我困惑于什么是默认的构造函数访问修饰符,以及这个MSDN状态表示什么?
If the direct base class does not have an accessible parameterless instance constructor, a compile-time error occurs.
因为当我在测试程序中应用这个程序时,它失败了。我可以创建一个对象或类,该对象或类继承另一个类,因为没有定义任何外部参数的构造函数。
class A
{
}
class B : A
{
}
class C
{
public void main()
{
B
如我所知,父类的构造函数先被调用,然后被称为子Class.But,为什么在静态构造函数的情况下,它首先从派生类执行,然后从子类执行?
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Child t = new Child();
}
}
class Parent
{
public Parent()
{
class base {};
class der1 : public base{};
class der2 : public base{};
..........
..........
class derXXX : public base{};
有几个类是从基类派生出来的。现有代码:基类不是抽象类,所以有基类的实例以及所有的派生class.All已经完成了测试。
要求:现在我想停止基类的实例创建,而不更改所有派生类的/testing。如何做到这一点?
我试图在类上反映javascript对象,但出于某种原因,所有javascript类的构造函数似乎指向内存中相同的引用对象。这意味着我不能在两个不同的javascript类上反映两个不同的对象,因为第一个类只是被第二个类覆盖。
require('reflect-metadata');
class Class1 {}
class Class2 {}
class Sub1 {}
class Sub2 {}
Reflect.defineMetadata("METADATA", Sub1, Class1.constructor);
Reflect.define
我试图理解这个pdf: (第61-62页)中类的类定义。下面是代码中我有问题的部分。以下是头文件:
#ifndef _TERM_STRUCTURE_CLASS_INTERPOLATED_
#define _TERM_STRUCTURE_CLASS_INTERPOLATED_
#include "term_structure_class.h"
#include <vector>
using namespace std;
class term_structure_class_interpolated : public term_structure_class {
p
我有下面的代码,我不明白,为什么在创建对象b时,类A的构造函数没有调用.我非常感谢您有一点help.hank。
#include <iostream>
using namespace std;
class MyClass
{
int x;
public:
MyClass(int y);
MyClass(MyClass &my)
{
x = my.x;
cout << "My class created by copy" <
我很难理解,为什么A类构造函数输出41,B类构造函数输出40,在下面的例子中
class AK {
AK(int i) {
System.out.println("Cstr of A " + i);
}
AK(){
System.out.println("Cstr of A()");
}
}
class BK extends AK {
BK(int i) {
super(i+1);
System.out.println(
是否必须从子类构造函数中的构造函数中调用父构造函数?
要解释,请考虑以下示例:
class Parent{
function __construct(){
//something is done here.
}
}
class Child extends Parent{
function __construct(){
parent::__construct();
//do something here.
}
}
这样做是很正常的。但是,请考虑类Child的下列构造函数:
function __constr
我对Java很陌生。在下面的代码中,我很难理解这些概念。
class A {
private Integer intr;
public A(Integer intr) {
this.inrt = intr;
}
public Integer getIntr() {
return intr;
}
}
class B extends A {
public B(Integer intr) { //Eclipse asking me to create this constructor.
sup
你们能不能给我解释一下为什么这个例子的输出是:
Exam1
This is Tennis Shoes
derived class
This is a white Tennis Shoes is created
如果你能向我解释一下,在我们创建了一个White Tennis Shoes对象之后到底发生了什么,以及发生了什么。请不要告诉我做你们的家庭作业或者我正在准备我的考试,这是一个古老的问题。
代码如下:
class Shoes{
public Shoes(){
this("you have created a shoes Object"
它是关于MDN页面中的JS类的。我不明白为什么坏类有一个引用错误。这是因为Bad类的空构造函数作为默认值调用super()吗?
class Base {}
class Good extends Base {}
class AlsoGood extends Base {
constructor() {
return {a: 5};
}
}
class Bad extends Base {
constructor() {}
}
new Good();
new AlsoGood();
new Bad(); // ReferenceError
我有这样一个代码:
当我尝试编译它时,我得到的结果是:
./type_holder.h:45:14: error: no matching constructor for initialization of 'test_class'
return new T(args...);
^ ~~~~
./type_holder.h:54:35: note: in instantiation of member function 'di::DiConstructor<true, test_
子类被强制显式调用基类的构造函数,这似乎没有意义。如果用户可以创建自己的构造函数,而不局限于基类,那么它将更加灵活。有人能告诉我为什么这个行为在JAVA中是强制的吗?这样做的好处是什么?
class A
{
public A(String s)
{
System.out.println(s);
System.out.println("BASE parameter
如果类中只有参数化构造函数,那么为什么不能使用默认构造函数创建对象呢?与添加参数化构造函数之前一样,类中没有默认构造函数!不过,默认构造函数可以创建lass实例。但是,在添加参数化构造函数后,默认构造函数将停止工作。为什么?
有人能解释吗?
class Program
{
static void Main(string[] args)
{
Test test = new Test(); //instance created using parameterized constructor
Test2 test = new Test2(); //i
假设我们有以下主构造函数和辅助构造函数:
open class Animal(val name:String){
internal constructor(message:InputStream): this(readName(message))
}
为什么不能调用超类的内部构造函数?
class Dog(name:String):Animal(name){
internal constructor(message:InputStream):super(message)
^^^^^
我有两节课:
import java.lang.*;
class A {
public A(int number) {
System.out.println("HI I AM INSIDE PARENT CONSTRUCTOR");
}
}
class B extends A {
public static void main(String[] args) {
A obj = new A(10);
}
}
错误:-未为默认构造函数定义隐式超级构造函数A()。必须定义显式构造函数。