C # Primeiros passos 4

índice

classe

Defina a interface

Construtor e destruidor

Membro da classe

Definir campos

Método de definição

Definir atributos

Conteúdo avançado da aula

Ocultar métodos de classe base

Método de classe base anulado ou oculto

Definição de tipo aninhado

Implementação da interface

Implementar a interface na classe

---

classe

Use a definição de palavra-chave de classe

class MyClass
{
    //Class members;
}

Use public para declarar classes públicas, tais classes podem ser acessadas por código em outros projetos

public class MyClass
{
    //Class members;
}

Use abstract para declarar uma classe abstrata, a classe não pode ser instanciada, apenas herdada

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

Use selado para declarar uma classe selada, que não pode ser herdada

public sealed class MyClass
{
    //Class members;
}

Defina a interface

Use interface para declarar uma interface

interface IMyInterface
{
    //Interface members;
}

Use public para definir uma interface pública

public interface IMyInterface
{
    //Interface members;
}

Nota

1. Na definição de uma classe C #, só pode haver uma classe base.Se você herdar uma classe abstrata, deverá implementar todos os membros abstratos herdados (a menos que a classe derivada também seja abstrata).
2. O compilador não permite que as classes derivadas tenham maior acessibilidade do que as classes básicas, ou seja, as classes internas podem herdar de uma classe básica pública, mas as classes básicas públicas não podem herdar de uma classe básica interna.
3. Se não houver uma classe base, todas as classes herdam System.Object por padrão
4. A classe pode usar dois-pontos para especificar a interface suportada. Se a classe base for especificada, a classe base deve seguir imediatamente os dois pontos e, em seguida, a interface especificada; se a classe base não for especificada, a interface segue os dois pontos. Use um vírgula para separar a interface e o nome da classe base.
5. A classe que suporta esta interface deve implementar todos os membros da interface, mas se você não quiser usar um determinado membro da interface, você pode fornecer uma implementação "vazia" (sem código de função), e você também pode implementar membros da interface como membros abstratos em uma classe abstrata.

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

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

Construtor e destruidor

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
    }
}

Membro da classe

Uma das seguintes palavras-chave é necessária para definir os membros da classe

1. público: os membros podem ser acessados ​​por qualquer código
2. privado: os membros só podem ser acessados ​​por código dentro da classe (se nenhuma palavra-chave for usada, essa palavra-chave é usada por padrão)
3. interno: os membros só podem ser acessados ​​por código interno na montagem (projeto) que o define
4. protegidos: os membros só podem ser acessados ​​por código na classe ou classes derivadas

As duas últimas palavras-chave podem ser usadas em combinação.Se houver um membro interno protegido, isso significa que ele só pode ser acessado por código derivado no projeto.

Você também pode usar static para declarar campos, métodos e propriedades, expressos como membros estáticos da classe em vez de membros da instância do objeto

Definir campos

Use o formato de declaração de variável padrão + definição de palavra-chave acima

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

Método de definição

Use o formato de função padrão + palavras-chave acima para definir

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

Você também pode usar as seguintes palavras-chave

virtual: o método pode ser substituído

abstrato: o método deve ser reescrito em uma classe derivada não abstrata (usada apenas em classes abstratas)

override: O método substitui um método da classe base (se o método for substituído, esta palavra-chave deve ser usada)

extern: O método é definido em outro lugar

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.
    }
}

Definir atributos

A estrutura básica de atributos: modificadores de acesso padrão (público etc.) + nome da classe + nome do atributo + bloco get / set

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

O bloco get deve ter um valor de retorno do tipo de atributo e o conjunto usa um método semelhante para atribuir um valor ao campo

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

Conteúdo avançado da aula

Ocultar métodos de classe base

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 
    } 
}

Método de classe base anulado ou oculto

Use a palavra-chave base para indicar o código de implementação da classe base contida na classe derivada

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;
    }
}

Observe que a base usa uma instância de objeto e um erro será relatado quando usado em um membro estático

esta palavra-chave

Isso pode ser usado dentro de um membro da classe para se referir à instância do objeto atual e não pode ser usado em um membro estático.

A função mais comumente usada disso é passar a referência da instância do objeto atual para um método, como segue

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

O exemplo acima indica que existe um método DoSomething no objeto instanciado myObj de MyClass, que recebe um parâmetro.O tipo de parâmetro pode ser um tipo de classe, um tipo de classe herdado por esta classe ou uma interface implementada por esta classe ou System. Objeto.

Outro método comumente usado para isso é limitar os membros de tipos locais, da seguinte maneira:

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

Definição de tipo aninhado

Você pode definir a classe na classe, da seguinte maneira

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

Para instanciar MyNestedClass fora de MyClass, o nome deve ser qualificado, da seguinte maneira

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

Em particular, se a classe aninhada for declarada como privada, ela não pode ser instanciada externamente como acima

//嵌套类实例
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(); 
    } 
}

Implementação da interface

A interface é definida pela palavra-chave interface. Os membros que definem a interface são semelhantes aos membros da classe, mas existem várias diferenças importantes

1. Modificadores de acesso (público, privado, protegido, interno) não são permitidos e todos os membros da interface são implicitamente públicos.
2. Membros da interface não podem conter corpo de código
3. Interface não pode definir membros de campo
4. As palavras-chave static, virtual, abstract ou seal não podem ser usadas para definir os membros da interface
5. Os membros da definição de tipo são proibidos - as interfaces não podem ser definidas como membros de outras interfaces

Em particular, membros ocultos herdados da interface de base podem ser definidos com a palavra-chave new, como segue

interface IMyBaseInterface
{
    void DoSomething();
}

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

Da mesma forma, os atributos definidos na interface podem definir quais dos blocos de acesso get e set podem ser usados ​​para o atributo

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

Implementar a interface na classe

A classe que implementa a interface deve conter o código de implementação de todos os membros da interface e deve corresponder à assinatura especificada (incluindo a correspondência dos blocos get e set especificados) e deve ser pública, da seguinte maneira:

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

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

Você pode usar as palavras-chave virtual ou abstract para implementar membros da interface, mas não pode usar static ou const. Você também pode implementar membros de interface na classe base.

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

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

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

Em particular, herdar uma classe base que implementa uma determinada interface significa que a classe derivada suporta implicitamente esta interface

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(){}
}