标签: base-class

如果我从另一个派生一个类并覆盖一个函数,我可以通过调用派生类中Base::myFunction()的实现来调用基函数myFunc.

但是有没有办法在我的Base类中定义在任何情况下调用基函数,也没有在覆盖函数中显式调用它？(在执行派生函数之前或之后)

甚至更好,如果我有我的虚拟虚拟函数Base的类,和两个实现的私有函数before()和after(),是有可能的定义Base之前,在任何派生类此功能后,类Base类被调用,before()并且after()将被称为？

谢谢!

如果我有一个基类通过构造函数依赖注入服务:是否可以在不使用的情况下声明子类的构造函数: base (params)？

public MyBaseClass
{
   private IServiceA _serviceA;
   private IServiceB _serviceB;
   private IServiceC _serviceC;

   public MyBaseClass(null, null, null)
   public MyBaseClass(IServiceA serviceA, IServiceB serviceB, IServiceC serviceC)
   {
       _serviceA = serviceA;
       _serviceB = serviceB;
       _serviceC = serviceC;
   }
}

并且注入了一些额外依赖项的子类:

public MySubClassA : MyBaseClass
{
   private IServiceD _serviceD;

   public MySubClassA (null, null, null, null)
   public MySubClassA (IServiceA serviceA, IServiceB serviceB, 
                       IServiceC serviceC, IServiceD serviceD)
          : base (serviceA, serviceB, serviceC)
   {
       _serviceD = serviceD;
   }
}

这里的问题是我有多个子类,现在只有10个左右,但数量会增加.每次我需要向基类添加另一个依赖项时,我必须遍历每个子类并在那里手动添加依赖项.这个手工工作让我觉得我的设计有问题.

那么是否可以MyBaseClassA在子类的构造函数中声明构造函数而不需要基类所需的服务？例如,以便构造函数 …

非常简单的基类 Closer

import {EventEmitter, Output} from 'angular2/core';

export class Closer {
  @Output() closed: EventEmitter<any> = new EventEmitter();

  constructor() {}

  close() {
    this.closed.emit({});
  }
}

如果我是extends Closer另一个班级然后用它来标记

<derived-class (closed)="closeHandler()"></derived-class>

closeHandler()永远不会被召唤.我可以看到Closer.close()被调用但是emit不会被派生类传播,也不会被其模板包含派生类和事件绑定的类处理.

如果我只是将其移动@Output到派生类,它就可以工作.但似乎Angular2应该将它放在派生类上.完全定义一组行为并继承它的能力会很好.

我相信,一个derived class可以override只对那些从继承的功能base class.我的理解是否正确？

也就是说,如果基类具有公共成员函数func,那么派生类可以override是成员函数func.

但是如果基类有私有成员函数说foo,那么派生类不能覆盖成员函数foo.

我对吗？

编辑

在研究了SO成员给出的答案后,我想出了一个代码示例.我提到我在代码中作为评论研究的要点.希望我是对的.谢谢

/* Points to ponder:
   1. Irrespective of the access specifier, the member functions can be override in base class.
      But we cannot directly access the overriden function. It has to be invoked using a public
      member function of base class.
   2. A base class pointer holding the derived class obj's address can access only those members …

即使当前实例是派生类,我们如何从基类中的另一个方法调用虚方法？

我知道我们可以调用方法2在基地从方法的类派生类使用base.Method2() ,但我想要做的就是从其他的虚拟方法调用它什么基础类.可能吗？

using System;

namespace ConsoleApplication1
{
  class Program
  {
    static void Main( string[] args )
    {
      Base b = new Derived(  );
      b.Method1(  );
    }
  }


  public class Base
  {
    public virtual void Method1()
    {
      Console.WriteLine("Method1 in Base class.");
      this.Method2( );   // I want this line to always call Method2 in Base class, even if the current instance is a Derived object.
      // I want 'this' here to always …

我刚刚通过继承为我的页面创建了一个基类System.Web.UI.Page：

public abstract class PageBase : System.Web.UI.Page
{
    ...
}

当我注意到您还可以在 ASP.NET 视图中声明一个基页时：

<%@ Page Language="C#" CodeFileBaseClass="PageBase.cs" CodeFile="page.aspx.cs"
    Inherits="page" %>

有人可以解释这两种方法的优缺点吗？你什么时候会使用一个而不是另一个，或者它们都是一样的？如果同时使用两者会怎样？

嗯,我正在经历这个关于"在MSDN上的优秀文章基类用途 ".虽然我理解基类和接口的概念,但我无法理解本文第二段中的模板方法的用法(" 受保护的方法和构造函数 ").

有没有人可以借助一个简单的实际例子帮助我理解这个概念？或许,理解模板方法的概念是一个很好的起点.

提前致谢.

我找不到如何在 Javascript 中删除代码重复（基本上是我在 Java 中使用基类实现的）。

具体示例是（至少）以下代码，它对所有规范文件（以及潜在的页面对象，因为我正在量角器中使用该模式进行测试）都是通用的：

var chai = require("chai");
var chaiAsPromised = require("chai-as-promised");
chai.use(chaiAsPromised);
var expect = chai.expect;

我可以做一些有希望随处可得？我尝试在量角器配置中在规范之前加载一个文件：

specs: [
  'e2e/helpers/commonDefinitions.js',
  'e2e/**/*.spec.js'
]

或使用beforeLaunch或onPrepare（但想要一个函数，不确定如何以这种方式公开变量），但没有成功。

但是，对于这种代码重用，我更喜欢通用的 Javascript 方法。

有什么好的方法可以避免在任何地方重复这种常见的代码，尤其是在测试中（mocha、karma、protractor）？

我刚刚读过一篇关于通用实体基类的文章。简单地说，如果我没有错的话，后面的主要思想是在一个接口中收集所有通用的、非实体特定的字段，而不是在主要实体中实现它。这将是一篇 TL:DR；让我们看一些代码。

这是基本实体接口，它是另一个接口的通用实现

public interface IEntity : IModifiableEntity
{
    object Id { get; set; }
    DateTime CreatedDate { get; set; }
    DateTime? ModifiedDate { get; set; }
    string CreatedBy { get; set; }
    string ModifiedBy { get; set; }
    byte[] Version { get; set; }
}

public interface IEntity<T> : IEntity
{
    new T Id { get; set; }
}

这是它在抽象类中的实现

public abstract class Entity<T> : IEntity<T>
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public T Id { get; set; }
    object IEntity.Id
    { …

我有一个类型特征和概念，用于检查 an 是否std::variant可以保存给定的类型T。现在我有一个variant2派生自 的类型std::variant，并且我想将该类型特征与新variant2类型一起使用。我怎样才能优雅地完成这个任务呢？

这不起作用（演示）：

#include <variant>
#include <string>
#include <iostream>
#include <concepts>
#include <type_traits>

template<typename T, typename Variant>
struct variant_type;

template<typename T, typename... Args>
struct variant_type<T, std::variant<Args...>> 
    : public std::disjunction<std::is_same<T, Args>...> {};

template<typename T, typename Variant>
concept is_variant_type = variant_type<T, Variant>::value;

template <typename... Ts>
struct variant2 : public std::variant<Ts...> {
};

variant2<std::monostate, int, bool, std::string> var;

int main() {
    using T = std::string;

    if constexpr (is_variant_type<T, decltype(var)>) …