类

定义接口

构造函数和析构函数

类的成员

类

使用class关键字定义

class MyClass
{
    //Class members;
}

使用public声明公共类，这样的类可由其他项目中的代码来访问

public class MyClass
{
    //Class members;
}

使用abstract声明抽象类，该类不能实例化，只能继承

public abstract class MyClass
{
    //Class members,mya be abstract;
}

使用sealed声明密封类，该类不能继承

public sealed class MyClass
{
    //Class members;
}

定义接口

使用interface声明接口

interface IMyInterface
{
    //Interface members;
}

使用public定义公共接口

public interface IMyInterface
{
    //Interface members;
}

Note

在C#类的定义中，只能有一个基类，如果继承了一个抽象类，就必须实现所继承的所有抽象成员（除非派生类也是抽象的）。
编译器不允许派生类的可访问性高于基类，即内部类可以继承一个公共基类，但公共基类不可继承于一个内部基类。
如果没有基类，所有的类都默认继承System.Object
类可以使用冒号指定支持的接口，如果指定了基类，基类必须紧跟在冒号后面，之后才是指定的接口；如果未指定基类，接口就跟在冒号后面，使用逗号分隔接口和基类名。
支持该接口的类必须实现所有接口成员，但如果不想使用给定的接口成员，可以提供一种“空”的实现方式（没有函数代码），还可以把接口成员实现为抽象类中的抽象成员。

//添加接口
public class MyClass : IMyInterface
{
    //Class members;
}

//含基类
public class MyClass : MyBase , IMyInterface
{
    //Class members;
}

构造函数和析构函数

class MyClass
{
    //显示创建默认构造函数
    public MyClass()
    {
        //Constructor code
    }
}

class MyClass
{
    //显示创建私有默认构造函数--不可以使用这个构造函数创建类的对象实例
    private MyClass()
    {
        //Constructor code
    }
}

class MyClass
{
    public MyClass()
    {
        //Default constructor code
    }
    
    //非默认构造函数
    public MyClass(int myInt)
    {
        //Nondefault constructor code(use myInt)
    }
}

class MyClass
{
    //析构函数，垃圾回收时执行析构函数中代码，释放资源
    ~MyClass()
    {
        //Destructor body
    }
}

类的成员

定义类的成员需要用到下面的关键字之一

public：成员可由任意代码访问
private：成员只能由类内的代码访问（如果没有使用任何关键字，默认使用这个关键字）
internal：成员只能由定义它的程序集（项目）内部代码访问
protected：成员只能由类或派生类中的代码访问

后两个关键字可以结合使用，如可以有protected internal成员，表示只能由项目中的派生类代码访问。

也可以使用static声明字段，方法和属性，表示为类的静态成员而非对象实例的成员

定义字段

用标准的变量声明格式+上面的关键字定义

class MyClass
{
    public int myVar;
    //关键字readonly表示这个字段只能在执行构造函数时或初始化赋值语句赋值
    public readonly int myVar = 1;
    //static关键字将字段声明为静态，定义为静态后只能通过定义他们的类来访问：MyClass.myVar
    public static int myVar;
}

定义方法

用标准函数格式+上面的关键字来定义

class MyClass
{
    public <baseType> <functionName>
    //eg
    public string getString() => return "Here is a string"
}

也可以使用下面的关键字

virtual：方法可以重写

abstract：方法必须在非抽象的派生类中重写（只用于抽象类中）

override：方法重写了一个基类方法（如果方法被重写，就必须使用该关键字）

extern：方法定义在其他地方

public class MyBaseClass
{
    public virtual void DoSomething()
    {
        //Base implementation
    }
}

public class MyDerivedClass : MyBaseClass
{
    //重写方法
    public override void DoSomething()
    {
        //Derived class implementation,overrides base implementation.
    }
}

public class MyDerivedClass : MyBaseClass
{
    //使用sealed关键字指定派生类中不能对该方法做进一步修改
    public override sealed void DoSomething()
    {
        //Derived class implementation,overrides base implementation.
    }
}

定义属性

属性的基本结构：标准的可访问修饰符（public等）+类名+属性名+get/set块

public int MyIntProp
{
    //读属性
    get
    {
        //Property get code
    }
    
    //写属性
    set
    {
        //Property set code
    }
}

get块必须有一个属性类型的返回值，set采用类似的方法把一个值赋给字段

public int MyIntProp
{
    //读属性
    get
    {
        //Property get code
        return myInt;
    }
    
    //写属性
    set
    {
        //Property set code
        myInt = value;
    }
}

类的进阶内容

隐藏基类方法

public class MyBaseClass
{
    public void DoSomething()
    {
        //Base implementation
    }
}

public class MyDerivedClass : MyBaseClass
{
    public void DoSomething()
    {
        //Derived class implementation,hides base implementation
    }
}

public class MyDerivedClass : MyBaseClass
{
    //new可以显示表明隐藏基类方法
    new public void DoSomething()
    {
        //Derived class implementation,hides base implementation
    }
}

//注意区别重写方法和隐藏基类
public class MyBaseClass
{
    public virtual void DoSomething()
    {
        Console.WriteLine("Base imp");
    }
}

//重写
public class MyDerivedClass : MyBaseClass
{
    public override void DoSomething()
    {
        Console.WriteLine("Derived imp");
    }
}

//隐藏
public class MyDerivedClass : MyBaseClass
{
    new public void DoSomething()
    {
        Console.WriteLine("Derived imp");
    }
}



//实例--注意区别隐藏和重写，隐藏基类方法不必是虚方法
public class MyBaseClass 
{ 
    public virtual void DoSomething() 
    { 
        Console.WriteLine("base class"); 
    } 
} 
    
//隐藏
public class MyDerivedClass : MyBaseClass 
{ 
    new public void DoSomething() { } 
} 
 
public class MyDerivedOverClass : MyBaseClass 
{ 
    public override void DoSomething() 
    { 
        Console.WriteLine("new class"); 
    } 
} 
 
class Program 
{ 
    static void Main(string[] args) 
    { 
             
        MyDerivedClass myDerivedClass = new MyDerivedClass(); 
        MyDerivedOverClass myDerivedOverClass = new MyDerivedOverClass(); 

        MyBaseClass myBaseClass = myDerivedClass; 
        
        myBaseClass.DoSomething();              //output : base class 
        myDerivedOverClass.DoSomething();      //output : new class 
        
        myBaseClass = myDerivedOverClass; 
        myBaseClass.DoSomething();              //output : new class 
    } 
}

调用重写或隐藏基类方法

使用base关键字，表示包含在派生类中的基类的实现代码

public class MyBaseClass
{
    public virtual void DoSomething()
    {
        //Base implementation
    }
}

public class MyDerivedClass : MyBaseClass
{
    public override void DoSomething()
    {
        //Derived class implementation,extends base class implementation
        base.DoSomething();
        //More derived class implementation;
    }
}

注意base使用的是对象实例，在静态成员中使用会报错

this关键字

this可以用在类成员的内部，表示引用当前的对象实例，同样不能在静态成员中使用。

this最常用的功能是把当前对象实例的引用传递给一个方法，如下

public void doSomething（）
{
    MyClass myObj = new MyClass();
    myObj.DoSomething(this);
}

上述例子表示MyClass的实例化对象myObj内有一个方法DoSomething，该方法带一个参数，参数类型可以是类类型，由这个类继承的类类型，或者由这个类或System.Object实现的一个接口。

this常用的另一个方法是限定局部类型的成员，如下：

public class MyClass
{
    private int someData;
    public int SomeData
    {
        get
        {
            return this.someData;
        }
    }
}

嵌套的类型定义

可以在类中定义类，如下

public class MyClass
{
    public class MyNestedClass
    {
        public int NestedClassField;
    }
}

在MyClass外部实例化MyNestedClass，必须限定名称，如下

MyClass.MyNestedClass myObj = new MyClass.MyNestedClass();

特别的，嵌套的类声明为私有，就不能像上面一样在外部实例化

//嵌套类实例
public class ClassA 
{ 
    private int state = -1; 
    public int State 
    { 
        get 
        { 
            return state; 
        } 
    } 
    
    public class ClassB 
    { 
        public void SetPrivateState(ClassA target,int newState) 
        { 
            target.state = newState; 
        } 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
        ClassA myObject = new ClassA(); 
        Console.WriteLine($"myObject.State = {myObject.State}"); 
        ClassA.ClassB myOtherObject = new ClassA.ClassB(); 
        myOtherObject.SetPrivateState(myObject, 999); 
        Console.WriteLine($"myObject.State = {myObject.State}"); 
        Console.ReadKey(); 
    } 
}

接口的实现

接口由interface关键字定义，定义接口的成员和类成员类似，但是有以下几点重要区别

不允许使用访问修饰符（public，private，protected，internal），所有接口成员都是隐式公共的。
接口成员不能包含代码体
接口不能定义字段成员
不能用关键字static，virtual，abstract或sealed来定义接口成员
类型定义成员是禁止的--接口不能定义为其他接口的成员

特别的，隐藏从基接口中继承的成员，可以用关键字new来定义，如下

interface IMyBaseInterface
{
    void DoSomething();
}

interface IMyDerivedInterface : IMyBaseInterface
{
    new void DoSomething();
}

同样的，在接口中定义的属性可以定义访问块get和set中的哪些能用于该属性

interface IMyInterface
{
    int MyInt
    {
        get;
        set;
    }
}

在类中实现接口

实现接口的类必须包含该接口所有成员的实现代码，且必须匹配指定的签名（包括匹配指定的get和set块），并且必须是公共的，如下：

public interface IMyinterface
{
    void DoSomething();
    void DoSomethingElse();
}

public class MyClass : IMyInterface
{
    public void DoSomething(){}
    public void DoSomethingElse(){}
}

可以使用关键字virtual或abstract来实现接口成员，但不能使用static或const。还可以在基类上实现接口成员。

public interface IMyInterface
{
    void DoSomething();
    void DoSomethingElse();
}

public class MyBaseClass
{
    public void DoSomething(){}
}

public class MyDerivedClass : MyBaseClass, IMyinterface
{
    public void DoSomethingElse(){}
}

特别的，继承一个实现给定接口的基类，就意味着派生类隐式地支持这个接口

public interface IMyInterface
{
    void DoSomething();
    void DoSomethingElse();
}

public class MyBaseClass
{
    public virtual void DoSomething(){}
    public virtual void DoSomethingElse(){}
}

public class MyDerivedClass : MyBaseClass
{
    public override void DoSomething(){}
}

C#入门4

类

定义接口

构造函数和析构函数

类的成员

定义字段

定义方法

定义属性

类的进阶内容

隐藏基类方法

调用重写或隐藏基类方法

嵌套的类型定义

接口的实现

在类中实现接口

猜你喜欢