抽象类和静态类有什么区别？

Question

Neither is instantiable. What are the differences, and in what situations might you use one or the other?

Answer 1

static indicates the class can only have static members and you cannot create an instance of it. This is used for stateless functionality (for example a type that just defines extension methods, or utility methods). You can also declare a member static on a non-static class. This allows you to attach functionality to a type without having to instantiate it.

Here's more detail on using static members and classes .

abstract s define the basic structure and functionality shared by all derivative types, but cannot be used by themselves. Think of them as, I suppose, a blue print and a contract. This is a core concept for OOP.

Here's more detail on using abstracts .

Answer 2

Here is a short summary:

• A static class can only contain static members (it is just a container for methods that do not logically belong to an instance of any standard class)
• An abstract class can contain all usual kinds of members (static, abstract and also instance)

The key difference is that you can inherit from an abstract class, but you cannot inherit from a static class. Technically speaking, the .NET runtime doesn't have any notion of static classes, so the C# compiler compiles them as classes that are both abstract and sealed (meaning that you cannot inherit from them).

So, static classes are abstract classes that are also sealed (although this is not the usual way to look at the problem if you are C# programmer) and contain only static members (which is enforced by the C# compiler).

Answer 3

An abstract class is intended to be used as a base of a class inheritance hierarchy. A static class cannot be the base of a class inheritance hierarchy.

A static class is intended for singleton state or stateless functionality. An abstract class is not suitable for singleton functionality, because, even though it may contain static methods and fields as a static class does, it cannot forbid inheritance, so the singleton use may be defeated by subclasses. Or, at the very least, it would be confusing to other programmers, because its definition would communicate an intent that is different from its actual intended use.

The superficial similarity between abstract and static classes is only in the fact that neither may be instantiated. Beyond that, they are completely different animals with completely different use cases.

Answer 4

The CLR has no notion of static classes, it is specific to C#. The compiler implements it by slick use of CLR attributes for a class: it declares it abstract and sealed. That prevents any language from instantiating such a class. This is what it looks like when you run Ildasm:

.class public abstract auto ansi sealed beforefieldinit ConsoleApplication1.Test
       extends [mscorlib]System.Object
{
}

Making it sealed is very much the point of a static class, it is used as a container for static methods and fields. Which makes them act like global variables and functions like you have in languages like C or Pascal.

An abstract class is very much the opposite, it is designed to be derived from. A abstract class that has all of its member abstract acts like an interface. C# has a keyword for that, making static class and interface the exact opposites.

Answer 5

Abstract classes get instantiated indirectly via derived classes. They provide common behaviour and instance state, but signal that more is required and must be provided by derived concrete classes. For example, Transform might be an abstract class: it declares a common Apply(Shape) method, but no implementation of that method. Concrete derived classes like Rotation or Translation will implement that method, and those classes can be instantiated.

Static classes cannot be instantiated, and any state is at the class level rather than the instance level. They are typically used to define utility methods where there is no state associated with the methods. Transform couldn't be a static class, because the concrete derived classes need per-instance state (eg Rotation needs a per-instance Angle , because different Rotation transforms could be by different angles).

Answer 6

Abstract classes are intended to be used as base classes; they cannot have direct instances. Instead, you have to derive subclasses, which provide the what was (usually intentionally) left out in the abstract base class.

Example: consider you have a complex application, where users may log-in to. Various authentication mechanisms should be usable, say, LDAP, NTLM, you name it. One way to model a "user" or "principal" in such a context would be to collect, what is common across all those mechanisms, into an abstract base class, and leave "gaps" (abstract methods) where the actual implementations come into play:

abstract class Authenticator {

   protected Dictionary<string,User> userCache;

   ...

   public User LoadUser(string name) {
        User user;
        if( userCache.TryGet(name, out user) ) return user;
        else {
            user = LoadFromStore(name);
            userCache.Add(name, user);
            return user;
        }
   }

   protected abstract User LoadFromStore(string name);
}

Here, caching of users is a common concern, modelled in the base case, whereas the actual retreival is left for a subclass to provide.

Static class are a different matter alltogether. They are essentially a place to keep your utility functions:

static class StrUtil {

    public static string TrimWhitespace(string str) {
        ...
    }
}

Think of them as some kind of special namespace, which can only contain static members. Basically, a place to put functions.

Answer 7

Abstract Class (Base class): Enables other classes to inherit from this class ( one class acquires the properties (methods and fields) of another ) , but forbids to instantiate ie we cannot have objects of this class. http://csharp.net-tutorials.com/classes/abstract-classes

Static Class: This class cannot be instantiated . Also this class cannot be inherited . To access methods of this class, you can directly use classname.method. https://social.technet.microsoft.com/wiki/contents/articles/21028.difference-between-static-class-sealed-class-and-abstract-class-in-c.aspx

Answer 8

Abstract class main purpose is to define one or more abstract method(s). Any class extending Abstract class will implement the abstract method or else its also need to be declared as "Abstract".

But, its also possible to declare a class as "Abstract" without implementing any abstract method(s) in it. See the sample below.

public abstract class AbstractTest {
    public void abcd(){}

    public static void main(String[] args) {
        System.out.print("hi...");
    }
}

Only inner class can be declared as "Static", see the code below. Upper/encapsulating class can't be declared as "Static". It can be accessed by using Upper/encapsulating class variable.Static-inner-classname ie same as any static method invocation using class name.

public class StaticTest {
    public static void main(String ag[]){
        System.out.println("hello...1");
        StaticTest.StaticTest2.meth2();
    }
    
    public static class StaticTest2 {
        public static void meth2(){
            System.out.print("hello...2");
        }
    }
}

Answer 9

Main difference between the two is extensibility.

CLR marks all 'static' classes as ' abstract & sealed ' behind the scene (ie, they cannot be inherited hence cannot be extended) and .NET Framework CLR loads them automatically when containing program or namespace is loaded. This gives performance gain on runtime.

Philosophy behind 'abstract' classes is capitalizing all common features of all extended classes in one place.

Hope it helps.