什么是抽象类[[副本]

1. 最常用作基类或接口(某些语言有单独的 interface 构造,有些没有)-它没有 实现(由子类/实现类提供)
2. 抽象与重用
3. 当基类不能为方法提供有意义的默认实现时(但允许子类重用实现的非抽象部分);任何字段、非抽象方法等)

public abstract class Stream { /* lots of code, some abstract methods */ }

一条小溪到底是什么 独自 ? 什么 友善的 溪流?流到文件?网络?内存缓冲区?每种方法可能有不同的和不相关的读/写方式,但提供一个通用的API。它使 毫无意义 创造 A. Stream abstract 同学们,你们可以 代码 到 不知道细节的API:

Stream s = CreateStream(...); // I don't *care* what kind of stream
s.Write(new byte[] {1,2,3,4,5});
s.Close();

1. 整合常见行为(与仅定义契约的接口不同)
2. 为函数提供默认(以及可选的可重写)实现
3. 为继承层次结构提供定义良好的分支点
4. 控制注入点

这个名单还有很多。

1) 创建一个不能实例化的类有什么意义?

某些东西没有直接实例化并不意味着它是有用的。抽象类在继承中起着重要作用,在继承类的类设计中非常有用。

这还允许您将继承的类关联在一起,这意味着您可以假设抽象类中定义的某些方法将存在于继承的类中,这可能很有用。

通常,我使用它来确保一系列继承类具有特定的方法等。对我来说,它对于设计一组继承类的结构非常有用。

我不认为抽象类是必要的,但在某些情况下使用它会很有用,有助于简化您正在解决的问题。

抽象类是不能实例化的类。例如,正方形、圆形或矩形是一种形状,可以从类形状派生。

重点是指定派生类的方法 必须 实现,与 ,但也提供了一些实现(接口无法实现)。严格地说,抽象类从来都不是“必要的”——但它们是有用的。只需在.NET或Java标准库中搜索它们,然后自己看看它们是如何使用的。你会发现有很多例子。

抽象类只有在使用 . 您创建的子类必须实现相同的功能 作为您的抽象类,它将继承您在抽象类中定义的一些基本实现。

它只是对使用它的客户机隐藏实际的实现。

• 它提供特定功能的具体实现,不能直接实例化
• 这将只能从实现它的类访问。

interface ILogger
{
    string PrepareLog(System.Exception ex);
    void InitializeLogger(string Type);
    int WriteLog(string msg);
}

 class EventLogger : ILogger
{
    public override void InitializeLogger(string Type)
    {
        //Event Logger Initialize   
    }
    public override int WriteLog(string msg)
    {
        //Write to event log
        return 1;
    }
    public override string PrepareLog(System.Exception ex)
    {
      return ex.StackTrace ;
    }
}

class FileLogger : ILogger
{
    public override void InitializeLogger(string Type)
    {

    }
    public override int WriteLog(string msg)
    {
        //Write to File
        return 1;
    }
    public override string PrepareLog(System.Exception ex)
    {
      return ex.StackTrace ;
    }
}


class MailLogger : ILogger
{
    public override void InitializeLogger(string Type)
    {

    }
    public override int WriteLog(string msg)
    {
        //Write to mail
        return 1;
    }

    public override string PrepareLog(System.Exception ex)
    {
        //prepare HTML Formatted msg
        return ex.StackTrace ;
    }
}

EventLogger、FileLogger和maillogger类实现了iLogger并给出了 上下文特定 实施现在我们想要隐藏PrepareLog的实际实现,这将完成从exception对象准备日志消息的常见操作。

因此,让我们用抽象类稍微改变一下实现

abstract class AbstractLogger:ILogger
{
    #region ILogger Members

    public virtual string PrepareLog(System.Exception ex)
    {
        return ex.StackTrace;
    }

    public abstract void InitializeLogger(string Type);
    public abstract int WriteLog(string msg);

    #endregion
}


class EventLogger : AbstractLogger
{
    public override void InitializeLogger(string Type)
    {
        //Event Logger Initialize   
    }
    public override int WriteLog(string msg)
    {
        //Write to event log
        return 1;
    }
}

class FileLogger : AbstractLogger
{
    public override void InitializeLogger(string Type)
    {

    }
    public override int WriteLog(string msg)
    {
        //Write to File
        return 1;
    }
}

class DBLogger : AbstractLogger
{
    public override void InitializeLogger(string Type)
    {

    }
    public override int WriteLog(string msg)
    {
        //Write to DB
        return 1;
    }
}

class MailLogger : AbstractLogger
{
    public override void InitializeLogger(string Type)
    {

    }
    public override int WriteLog(string msg)
    {
        //Write to mail
        return 1;
    }

    public override string PrepareLog(System.Exception ex)
    {
        //prepare HTML Formatted msg
        return ex.StackTrace ;
    }
}

现在我已经创建了 抽象记录器

因此,现在PrepareLog方法完全隐藏(意味着日志准备)不让cosumer初始化任何记录器。

那么为什么PrepareLog是虚拟的呢??

抽象

抽象就像键盘、显示器或手机。所有键盘都能输入数据;所有显示器都能显示像素;所有的手机都能打电话。但这些产品的制造商有不同的实施方式。

手机是一种工具 手机 ,和抽象类的子类都是

抽象类的要点是定义(限制)接口,而不描述实现。

接口和抽象类都促进了代码库中的松散耦合。抽象类是接口和具体类之间的折衷,因为抽象类可以有具有实现行为的实际方法。

Josh Bloch 将其称为“抽象接口”模式。这允许您部署抽象类的不同实现,而抽象类实际上并不是完全抽象的——只有接口才是抽象的。

与接口相同,抽象类是 您在其中提供了一些通用(或 摘要 Stream 示例-非常好的示例。

在编程时,您注意到一些代码块由接口的所有实现共享。

它只是抽象的,因为您希望所有继承类都有自己的实现。

抽象类通过能够创建一个包含概念而不是具体内容的类来实现一个有用的目的。例如, 可以是一个类,但没有人只是一个动物,它也不是一个类 或 等等,它们是不同种类的动物。希望这有帮助。它还与继承和多态性等概念相结合。