Access modifiers:
public
The type or member can be accessed by any other code in the same
assembly or another assembly that references it.
private
The type or member can only be accessed by code in the same
class or struct.
protected
The type or member can only be accessed by code in the same
class or struct, or in a derived class.
internal
The type or member can be accessed by any code in the same
assembly, but not from another assembly.
protected internal
The type or member can be accessed by any code in
the same assembly, or by any derived class in another assembly.
Static
The static modifier on a class means that the
class cannot be instantiated, and that all of its members are static. A static
member has one version regardless of how many instances of its enclosing type
are created. A static class is basically the same as a non-static class, but
there is one difference: a static class cannot be instantiated. In other words,
you cannot use the new keyword to create a variable of the class type. Because
there is no instance variable, you access the members of a static class by
using the class name itself.
Making a class static just prevents people from
trying to make an instance of it. If all your class has are static members it
is a good practice to make the class itself static.
class SomeClass
{
public int InstanceMethod() { return 1; }
public static int StaticMethod() { return 2; }
}
In order to call InstanceMethod, you need an instance of the class:
SomeClass instance = new SomeClass();
instance.InstanceMethod(); //Fine
instance.StaticMethod(); //Won't
compile
SomeClass.InstanceMethod();
//Won't compile
SomeClass.StaticMethod();
//Fine
Abstract
class
Abstract classes, marked by
the keyword abstract in the class definition, are typically used to define a
base class in the hierarchy. What's special about them, is that you can't
create an instance of them - if you try, you will get a compile error. Members marked as
abstract, or included in an abstract class, must be implemented by classes that
derive from the abstract class.
Let's see how it works
Since all the members in the class Bob(name,
alias, age) are declared public, it can be accessed outside the class Bob.
Here only alias is declared public, both age
and name are declared private. Hence we can access only alias outside the class
Bob.
