当我们从下面的类初始化对象时,哪些类将使用默认构造函数?
class X {}
class Y {
Y () {}
}
class Z {
Z(int i ) {}
}
类Z将不使用默认构造函数。类X将使用默认构造函数。
那Y呢?用户定义的空构造函数是否称为默认构造函数?就像他们在维基百科(Java部分) 上说的那样
或者,如果我们在初始化对象时可以说是默认构造函数,那么类中不应该定义构造函数吗?
我对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
是否必须从子类构造函数中的构造函数中调用父构造函数?
要解释,请考虑以下示例:
class Parent{
function __construct(){
//something is done here.
}
}
class Child extends Parent{
function __construct(){
parent::__construct();
//do something here.
}
}
这样做是很正常的。但是,请考虑类Child的下列构造函数:
function __constr
下面的代码显示了第4行的错误()
class MyClass{
public MyClass(int a){ } //Line 2
public static void main(String a[]){
MyClass n = new MyClass(); //Line 4
System.out.print("TRUE");
}
}
但是,一旦我删除了第2行,它就会运行,没有任何错误。不过,我没有添加默认构造函数。为什么?
我得到了这个错误:
'CTest.A.A()‘由于其保护级别而无法访问。
在编译此代码时:
public class A
{
private A()
{
}
}
public class B : A
{
public void SayHello()
{
Console.WriteLine("Hello");
}
}
有人能解释原因吗?
当我们为一个类定义一个复制构造函数时,我们必须显式定义一个默认构造函数吗?请说明理由。
例如:
class A
{
int i;
public:
A(A& a)
{
i = a.i; //Ok this is corrected....
}
A() { } //Is this required if we write the above copy constructor??
};
此外,如果我们为除复制构造函数之外的类定义任何其他参数化
class test
{
public:
test(int x)
{
val = x;
}
private:
int val;
};
test t(3);
关于这段代码我得到了2分。
test t(3)首先调用默认构造函数,然后执行val = 3
如果至少有用户定义的构造函数,则编译器不会生成隐式默认构造函数。
有矛盾吗?
我看过,但我不太确定我是否理解答案。如果我委托一个构造函数,则会从初始化列表中进行哪些初始化?
示例:
MyClass::MyClass(int a, int b)
:
MyClass(a, b, NULL),
int1(a),
int2(b),
pOtherClass(NULL)
{
}
MyClass::MyClass(int a, int b, Other *p)
:
int1(a),
int2(b),
pOtherClass(p)
{
if (pOtherClass == NULL)
{
pOtherClass = &DefaultIns
考虑-
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
我知道,在继承的情况下,如果缺少默认的构造函数,subClass构造函数应该显式地调用superClass构造函数。
但是,当链接到subClass中的另一个构造函数时,为什么我们不必调用superClass构造函数呢?由于下面的代码没有给出编译错误
SuperClass:
public class Top {
public Top(String n) {
// TODO Auto-generated constructor stub
}
SubClass:
public class sub extends Top {
public sub(int x
我正在阅读上的C++常见问题解答,当我遇到以下代码来实现一个“密封”类时:
class Base{
public:
friend class A;
private:
Base(){cout<<"Base constructor called";}
};
class A : public virtual Base{
public:
A(){cout<<"A const called";}
};
class B : private A{};
int main(){
A a;
“使用”私有成员变量使其成为公共成员,但构造函数保持私有。示例:
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
};
我试图像这样调用父母的第二个构造函数
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错误。子类如何调用父类的辅助构造函数?
public class LinkedListStructs {
public LinkedList l1 = new LinkedList();
public LinkedListStructs(){
ListNode h1 = new ListNode(4);
ListNode h2 = new ListNode(3);
ListNode h3 = new ListNode(12);
ListNode h4 = new ListNode(9);
ListNode h5 = new ListNo
我有一个叫做Queen的类,它是Ant的一个子类。queen的构造函数接受参数,并将这些参数传递给Ants构造函数,外加Queen的其他细节。现在,这就是它应该如何工作的。然而,我发现Ant构造函数从未被调用过。我是不是遗漏了什么?
public class Queen extends Ant
{
public Queen(int width, int height, Square[][] grid)
{
super(0, 0, width, height);
//grid[locationHeight][locationWidth].addQu
给出密码
#include <iostream>
#include <vector>
class Entity {
public:
Entity(const int x, const int y) :
x(x), y(y)
{
this->entities.push_back(*this);
}
int x, y;
std::vector<Entity> entities;
};
int main() {
auto p = Entity(10, 20);
令人怀疑的是:
在子类中定义常量构造函数时,上层类的默认构造函数必须是常数。
但是,当上层类的默认构造函数定义为常量时,继承类的构造函数不必是常数。
下面的守则说明了这种情况:
// 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
我只是在尝试抽象类,结果遇到了一个错误。
我有一个这样的类:
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
好的,我正在做一个学校的作业,我设置了我的主类和另一个名为Transaction的类。在我的主类中,我有:
Transaction t = new Transaction();
而Transaction带有下划线:它表示构造函数未定义。为什么?!
事务类如下所示:
public class Transaction {
private String customerNumber, fName, lName, custAddress, custCity;
private int custZip, custPhone;
/** Constructor*/
public Transaction(S
我有两节课:
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()。必须定义显式构造函数。
我试图在一个类中创建一个JFrame,然后在我的主类中为它添加一个JPanel,这是不可能的吗? 这是我的主类 public class Main {
JPanel p;
JLabel lbl1;
public static void main(String[] args) {
new Main();
}
Main() {
new Window();
JPanel p = new JPanel();
JLabel lbl1 = new JLabel("Hello"
我发现我的代码不能像这样编译,对吗?这里有没有编译器提供的构造函数?
class A
{
private:
A(const A& n);
};
int main()
{
A a;
}
错误是test.cpp:18: error:没有匹配的函数来调用‘A::A()’test.cpp:11:注意:候选函数是: A::A(const A&)
我在Ubuntu8.04下使用g++
public A {
public A(String arg0) {
...
}
public A(String arg0, String arg1) {
...
}
}
public B extends A {
}
我希望B自动从A继承构造函数,而不必显式地实现它们,例如:
public B(String arg0) {
super(arg0);
}
public B(String arg0, String arg1) {
super(arg0, arg1);
}
我怎样才能做到这一点?