为什么这个简单的类层次结构最终出现在抽象类B中?在这个案子里我不知道该怎么找。(也许是钻石问题?)
class I_A
{
virtual void foo() = 0;
};
class I_B : public I_A
{
virtual void bar() = 0;
};
class A : public I_A
{
void foo() override {}
};
class B: public A, public I_B
{
void bar() override {}
};
B b; ///< Compiler says it i
这里有一些关于js中oop的问题(下面代码中的问题)。
<html>
<script>
function A(){
a = 'a - private FROM A()';
this.a = 'a - public FROM A()';
this.get_a = function(){
return a;
}
}
function B(){
this.b = 'b - private FROM B()';
我对javascript面向对象编程很陌生。我想写一个JS类,它有一些变量和方法。
我正在尝试这样做:
function B(){
function makeB()
{
alert('make B');
}
}
var b = new B();
b.makeB();
它显示:Uncaught TypeError: Object #<B> has no method 'makeB'
我不能宣布这样的函数吗?但是,只要使用相同的方法添加this,我就可以访问它。它是变量中的局部函数吗?
除了这个,我试过这个:
fu
我的问题很简单:~给定两个类,我希望其中一个类扩展另一个类,但是将一些方法转化为private类
Class B
public Method a();
public Method b();
public Method c();
Class A extends B
private Method a();
private Method b();
public Method c();
这有可能吗?怎么可能?谢谢!
我不确定这个标题是否公平,但这是我的……
function A() {};
A.prototype.B = function(){
this.backref = //?? -- should be set to "a"
};
var a = new A(); // specialized factory...
var b = new a.B(); // instantiate an "a" specialized version of B
var zztop = b.backref instanceof A; //would be true
我想澄清一下在c++中包含类的问题。我不知道怎么做,因为我不知道主题之间的区别
#pragma once
#include "B.h" // Is it enough to include like this? ?
class B; // what this line does ?
class A : public B // what public B does here ?
{
// .......
};
那么,我如何知道我应该使用类b、或公共B,还是只使用a#包括"B.h"?我希望我说得够清楚,谢谢你的帮助
我想知道这样的事情是否可能发生:
基本类A
派生类B1来自一个实例a of class A (即a = new A() )
派生类B2来自同实例a of A
我举一个例子:
var a = new A();
function A() {
this.var_test = 0;
this.test = function () {
alert(this.var_test++);
}
}
function B1() {
}
B1.prototype = a;
function B2() {
}
B2.prototype
假设我有一个父亲类要被孩子类继承,后来我想在不修改原有的父亲类的情况下添加更多的东西到父亲类中,请教我怎么做。
让我澄清一下我的问题。父亲中的任何贵重物品和方法都会自动被所有的孩子类访问,对吗?例如:
public class Father
{
public int a;
public int b;
public int c()
{
return a+b;
}
}
public class Child : Father
{
private int d=a*b+c();
}
现在我想向父亲添加一个布尔值e和一个方法f(),这样我的
最后,在基类中没有默认构造函数的情况下,出现了多重继承菱形问题。
struct A {
A(int x) {}
};
struct B : virtual public A {
using A::A;
};
struct C : virtual public A {
using A::A;
};
struct D : virtual public B, public C {
D(int x) : B(x), C(x) {}
};
int main() {
D d(1);
}
编译器抱怨:
error: constructor for 'D' must
我的设计中有一个契约继承,我想通过web3从基本合同中调用一个方法。问题是我不知道该怎么做:
如果我真的喜欢这个:
contract B {
uint Bstate;
function methodX (){
Bstate =1;
}
}
然后
import "B.sol"; // because B is in an other file
contract A is B {
}
我需要在部署contract B之后手动部署contract A并使用它的abi调用methodX还是我可以直接从con
#include<iostream>
using namespace std;
class A
{
int a;
int b;
public:
void eat()
{
cout<<"A::eat()"<<endl;
}
};
class B: public A
{
public:
void eat()
{
cout<<"B::eat()"<<endl;
}
};
class C: public A
{
继承类中的方法应从继承对象类型返回对象类型。在C++中,这种行为很容易实现。但我不知道用javascript怎么做。我知道这是错误的,但我这样写。
class A {
someMethod() {
return new A();
}
}
class B extends A {
}
var b = new B();
b.someMethod() // should return an object of type B not A
在C++中,这很容易做到
template <typename c>
struct a
{
a() : _value(NULL) {}
我有菱形的类层次结构:
A
/ \
B C
\ /
D
为了避免D中A的两个副本,我们需要在B和C处使用虚拟继承。
class A { };
class B: virtual public A {};
class C: virtual public A { };
class D: public B, public C { };
问:为什么虚拟继承需要在B和C执行,即使模棱两可是在D?如果它是在D处,它会更直观。
为什么这个特性是由标准委员会设计成这样的?如果B和C类来自第三方库,我们该怎么办?
编辑:
我有A班和B班。
class A{
public:
foo();
};
class B : public A{
public:
int x;
};
假设在测试file.How中有一个来自B类的对象,我应该调用foo函数吗?
object.foo(); // or
object.A::foo();
其他问题:我们什么时候调用这样的函数?如果我做多重继承怎么办?
我一直在尝试使用to框架部署一份合同,最近我在开发网络上测试了这些合同。
我的合同很大,当我试图把它部署到一个测试网时,我被指示把它分开,这样合同就不会超过汽油限额。不过,考虑到这一合同确实部署到开发网络上的默认气体限制。
所以我拿出了合同的一部分,并从基础上衍生出另一个合同,并在其中添加了删除的部分。为了再次测试它,我尝试将它部署到开发网络中,现在我得到了错误:
'Error: The contract code couldn't be stored, please check your gas amount.'
所以我采取的步骤是:
将我的gasLimit改为1
interface I{
}
class A implements I{
}
class B extends A {
}
class C extends B{
public static void main(String args[])
{
A a = new A();
B b = new B();
b = (B)(I)a; //Line 1
}
}
我知道这不是真正的代码:)
我只想知道第一行的演员是怎么做的。
我知道引用变量'a‘转换为B类/接口I。
但是,我不确定演员取place..can的顺序,有人
我刚接受了采访,有人问了我一个问题。
面试官- Java支持多重继承吗?
Me -不
面试官- Java中的每个类都扩展类对象(类对象除外),如果我们从外部扩展一个类,比如
Class A extends B{
// some code here
}
然后你可以说A类扩展了B类和类对象,这意味着它是多重继承。那么你怎么能说Java不支持多重继承呢?
Me -实际上B类扩展了类对象,所以当你在A类中扩展B类时,A类间接地扩展了类对象。这是多层次继承,而不是多重继承。
但我的回答并没有使他满意。
我的答案正确吗?或者我哪里错了?内部实际发生了什么?
对于这样的事情,particial类是一个很好的解决方案吗:
我在数据库中的两个表如下所示:
Table A int id*, string Name
Table B int id*, string Ag
class A {
public string Name;
}
class B {
public string Ag;
}
现在,我想在id上连接booth表A和B
public class JoinedTable
{
partial class A : A
{
}
partial class B : B
{
}
}
你觉得这
我熟悉这条错误消息,但在本例中我不太确定:
class Foo extends A {
// getting error here
}
trait A extends B {
def something(num:Int):Boolean = {
num == 1
}
}
trait B {
def something[S](num:S):Boolean
}
但这是很好的汇编:
class Foo extends A ...
trait A extends B[Int] {
def something(num:Int):Bool
我正在学习OOPS的概念,并遇到了私有继承。根据我所学到的--当一个类从基类派生出来时,当派生类被实例化时,则首先调用基类的构造函数,然后是派生类的构造函数。因此,在代码"A创建“将首先打印。问题是,既然继承是私有的,A的所有成员在B中都是私有的,那么当B被实例化时,如何调用A的构造函数。按照这个逻辑,下面的代码应该会生成错误,但是当我运行它时,它会编译得很好,并给出输出"A创建“和"B创建”。这是怎么回事?还是我在理解这个概念时犯了什么错误?
#include <iostream>
using namespace std;
class A{
public
考虑以下简单的java代码:
class A {
private int a = 10;
public void print() {
System.out.println(this.getClass().getName() + " " + a);
}
}
public class B extends A {
public void p1() {
print();
}
public static void main(String... args) {
B b = new
当程序运行时,显示函数将被调用。但不明白怎么回事?
class A
{
class B
{
void display()
{
System.out.println("display in B.....");
}
}
}
class Twenty extends A.B
{
Twenty(A temp)
{
temp.super();
}
public static void main(String args[])
{
到目前为止,我有一个类似这样的类:
type C<'a when 'a :> A> (...)
但是现在我创建了一个新的类型B:
type B (...) =
inherit A()
但我不希望C支持B,这不能编译:
type C<'a when 'a :> A and not 'a :> B> (...)
我该怎么做呢?