我有一个与C#中的OOP概念相关的小查询。
我有一个接口
interface intf
{
string Hello();
}
A基类
public class BaseClass
{
public string Hello()
{
return "Hello of base class called";
}
}
从BaseClass 派生并实现接口intf以及的子类。
public class ChildClass : BaseClass, intf
{
string Hello()
{
return "Hell
我的应用程序是一个用groovy/java编写的自动化测试框架。目前我有两种不同的用法: 1)我所有的测试类都是从读取属性的BaseTest类扩展而来,做一些其他的工作人员,比如设置和清理,但在主要的情况下,它会启动SpringBoot context,这是要测试的主要应用程序工作的地方。它工作得很完美,但每次我运行任何test - spring都会先启动,这会占用我一分钟的时间。2)我还有另一个类要扩展,叫做ProxyBaseTest类,它创建主应用程序的运行实例的代理(以防我在一个单独的窗口中用gradle手动启动它)。它也工作得很好。
对我来说,最主要的问题就是经常更换
class So
当时我正在阅读谷歌C++风格指南( Google ),并在部分感到困惑。在构造函数中做大量工作的缺点之一是:
如果工作调用虚拟函数,这些调用将不会被分派到子类实现。将来对类的修改可以悄悄地引入这个问题,即使您的类当前没有子类,也会造成许多混乱。
我不明白这意味着什么。有人能给出一个解释吗?为什么这会被认为是一种劣势?
我在以下代码中遇到编译错误:
public abstract class DbHandler<T>
{
public abstract bool Save(T obj);
...
}
及其实现类:
public class SpaghettiTableDb : DbHandler<SpaghettiTable>
{
public bool Save(SpaghettiTable obj)
{
return false;
}
...
}
错误是:
'SpaghettiTableDb' d
这个简单程序的输出是This is base。
public class mainApp{
private void func(){
System.out.println("This is base");
}
public static void main(String[] args){
mainApp newObj = new derived();
newObj.func();
}
}
class derived extends mainApp{
public void func(){
class SuperClass
{
public:
SuperClass(int foo)
{
// do something with foo
}
};
class SubClass : public SuperClass
{
public:
SubClass(int foo, int bar)
: SuperClass(foo)
{
// do something with bar
}
};
子类是否继承了超类的构造函数?它继承了什么?为什么我需要在子类构造函数中指定: SuperCla
我有这样的代码:
namespace ConsoleApplicationDemo
{
class base
{
public virtual void Sum()
{
Console.WriteLine("Sum in base ");
}
}
class Program:base
{
public override void Sum()
{
Console.WriteLine("SUM
class Top {
public Top(String s) {
System.out.print("B");
}
}
public class Bottom2 extends Top {
public Bottom2(String s) {
super();
System.out.print("D");
}
public static void main(String [] args) {
Bottom2 as=new Bottom2(
我有一个基类"B",它有两个构造函数,一个没有参数,另一个接受一个参数,一个整数。
我有一个子类"S",它继承自"B“,没有在其中定义任何构造函数。
我创建了一个S的实例,试图将一个整数传递给构造函数。
我知道错误:
Error 1 Too many arguments to 'Public Sub New()“
这让我感到惊讶,因为我认为如果没有在子类S中定义构造函数,那么基类构造函数方法,特别是带有单个整数param的构造函数方法,将被调用w/o,这是一个错误。
你知道我为什么会犯这个错误吗?建筑工人是个特例吗?
我的代码如下:
open class Particle
class Electron : Particle()
open class Element(val name: String) {
open fun Particle.react(name: String): Unit {
println("$name is reacting with a particle")
}
open fun Electron.react(name: String): Unit {
println("$name is reac
我有以下代码:
#include <iostream>
class Grandma
{
public:
virtual void foo() = 0;
};
class Mom : public Grandma{};
class Dad
{
public:
void foo() { std::cout << "dad's foo impl"; }
};
class Me : public Mom, public Dad{};
int main()
{
Me m;
m.foo();
}
并得到:cannot
从javase 8开始,就不再推荐rmic了。因此,最好通过导出对象的方式动态生成stubs,如下所示:
子类UnicastRemoteObject并调用UnicastRemoteObject()构造函数。
子类UnicastRemoteObject并调用UnicastRemoteObject(port)构造函数。
所以我首先调用了UnicastRemoteObject(port)构造函数,但是得到了编译错误: no suitable constructor found for UnicastRemoteObject(int),然后我尝试调用UnicastRemoteObjec
我的基类声明:
public double Value;
我的派生类声明:
public new decimal Value;
在使用new关键字的技巧中,它说:"...Use the new keyword if hiding was intended.“。
这个解释似乎不正确。当使用new关键字时,它并不隐藏基变量。它保持两个变量具有相同的名称,甚至具有不同的值。
我知道在我这方面存在一个设计问题,但是我想知道为什么new关键字没有真正隐藏基类变量。此外,如果new关键字意味着设计问题(更改派生类中的数据类型),那么为什么它是可用的。在这里使用dynamic是一种选择吗?问题是:在
请考虑以下代码:
public class Person
{
public virtual void UpdateLastLogin()
{
// business of last login here
}
}
public class Student : Person
{
public override void UpdateLastLogin()
{
// logging something specific to person
((Person)this).UpdatelastLogin();
我有下面的代码,它只是返回一个错误。
class Foo {
public static logBar<T>(a: T): T {
console.log(a);
return a
}
}
class Bar extends Foo {
public static logBar<T extends number>(a: T): T {
console.log(a);
return a
}
}
Class static side 'typeof Bar' in
为什么不能删除继承对象的属性?
class A(object):
def delete(self):
pass
def dont_delete(self):
pass
class B(A):
pass
del A.delete
del B.dont_delete
AttributeError: dont_delete
在基类中,我想测试一些东西,如果不是True,我希望避免在子类的方法中进行任何处理。
例如,在这个设计的示例中,如果不提供some_thing,则在__init__()中将其设置为None。因为它的值是None,所以在基类add_some_thing()方法中,我想返回字符串"Nothing“。但这并不能阻止子类的add_some_thing()方法继续下去。我怎样才能做到这一点?
我将从BaseQuery继承多个类,或者将if not self.some_thing...功能移到子类。我尽量不重复代码十几次。
from abc import ABC, abstractmethod
每当我重写基类的方法时,除了这个方法的实现之外,我似乎有三个选择。
1)调用base.Method(),然后提供我的实现。
2)提供我的实现,然后调用base.Method()
3)只需提供我的实现。
最近,在使用一个库时,我意识到由于没有按照库的预期实现该方法而引入了一些bug。我不确定这是在库的一部分是不好的,还是在我的理解上有什么问题。
我将举一个例子。
public class ViewManager {
public virtual void Customize(){
PrepareBaseView();
}
}
public class Pos
这个问题已经被问了很多次了,但是我在网上找不到一个地方提到这个问题。
这种情况太简单了,不能相信没有解决办法:
public class BaseDispose : IDisposable
{
void IDisposable.Dispose()
{
}
}
public class ChildDispose : BaseDispose, IDisposable
{
void IDisposable.Dispose()
{
//var disp = base as IDisposable;
//(base as IDi
我最近一直在思考Liskov替换原理,以及它与我当前任务的关系。我有一个主表单,其中包含一个菜单;在这个主表单中,我将停靠一个特定的表单,作为MDI子窗体。此特定表单可能包含或不包含菜单。如果是的话,我想把它和主菜单合并。情况是这样的:
public class MainForm
{
public void Dock(SpecificBaseForm childForm)
{
this.Dock(childForm);
if (childForm is IHaveMenu)
{
this.Menu.Merg
在阅读了最优秀的书"Head First Design Patterns“之后,我开始向我的同事们宣扬模式和设计原则的好处。在赞美我最喜欢的模式--策略模式的优点时,有人问我一个问题,让我停了下来。当然,策略使用继承和组合,当我的一位同事问到“为什么使用抽象基类而不是具体类?”时,我发表了一篇关于“对接口(或超类型)而不是实现进行编程”的长篇大论。
我只能想出“好吧,你强制你的子类实现抽象方法,并阻止它们实例化ABC”。但老实说,这个问题让我大吃一惊。在我的层次结构的顶层,使用抽象基类而不是具体类的唯一好处就是这些吗?
我知道在stackoverflow中有很多文章/问题描述了Java中的向上转换和向下转换。我知道什么是向上和向下。但我的问题并不具体到这一点。
向上转换-从子对象到父对象的转换-编译器负责处理。不需要强制转换
向下转换-从父级到子级的转换-需要显式转换
public class Animal {
public void getAnimalName(){
System.out.println("Parent Animal");
}
}
public class Dog extends Animal{
public void getDog