Classe C # (Classe)

definição de classe

A definição da classe é para começar, seguido pelo nome da classe daclasse palavra-chave.Corpo da classe, contido dentro de um par de chaves. O que se segue é a forma geral da definição de classe:

<Especificador de acesso> class_name classe 
{
    // variáveis ​​membros
    <Especificador de acesso> <tipo de dados> variable1;
    <Especificador de acesso> <tipo de dados> variable2;
    ...
    <Especificador de acesso> <tipo de dados> variableN;
    // métodos membros
    <Especificador de acesso> <tipo de retorno> method1 (parameter_list) 
    {
        // Corpo do método 
    }
    <Especificador de acesso> <tipo de retorno> method2 (parameter_list) 
    {
        // Corpo do método 
    }
    ...
    <Especificador de acesso> <tipo de retorno> methodN (parameter_list) 
    {
        // Corpo do método 
    }
}

Por favor, note:

• Acesso Identificador <especificador de acesso> especifica a classe regra de acesso e seus membros. Se não for especificado, o identificador de acesso padrão. Padrão classe identificador de acesso éinterno, os membros do identificador de acesso padrão é privado.
• tipo de dados <tipo de dados> especifica o tipo da variável, tipo de retorno <retorno Tipo> especifica o tipo de dados retornados pelo método retorna.
• Se você quiser acessar um membro da classe, que pretende utilizar operador ponto (.).
• operador ponto liga o nome do nome e os membros do objeto.

Os exemplos seguintes ilustram os conceitos discutidos até agora:

using System;
namespace BoxApplication
{
    classe Box
    {
       comprimento pública dupla; // comprimento pública amplitude dupla; // largura dupla altura pública; // altura}
    classe Boxtester
    {
        static void Main (string [] args)
        {
            Box Box1 = new Box (); // declara Box1, tipo Box
            Box Box2 = new Box (); // declara Box2, tipo Box
            double volume = 0,0; // // volume de Box1 detalhando Box1.height = 5,0;
            Box1.length = 6,0;
            Box1.breadth = 7,0;

            // Box2 detalhando Box2.height = 10,0;
            Box2.length = 12,0;
            Box2.breadth = 13,0;
           
            // Volume de volume de Box1 = Box1.height * Box1.length * Box1.breadth;
            Console.WriteLine ( "volume de Box1: {0}", volume);

            // Volume de volume de Box2 = Box2.height * Box2.length * Box2.breadth;
            Console.WriteLine ( "volume de Box2: {0}", volume);
            Console.ReadKey ();
        }
    }
}

Quando o código acima é compilado e executado, ele produz os seguintes resultados:

volume de Box1: 210
volume de box2: 1560

funções de membro e pacote

funções de membro de classe é um protótipo definição ou função na definição de classe, assim como qualquer outra variável. Como um membro da classe, ele pode operar em qualquer classe de objeto, todos os membros e pode acessar a classe do objeto.

variáveis ​​de membro são propriedades de objetos (do ponto de vista do design), e eles permanecessem privadas para implementar pacote. Essas variáveis ​​só pode ser usado para acessar as funções de membro públicas.

Vamos usar os conceitos acima para definir e obter o valor de um tipo diferente de membros da classe:

using System;
namespace BoxApplication
{
    classe Box
    {
       comprimento duplo privado; // comprimento amplitude duplo privado; // largura altura dupla privado; // altura SetLength public void (duplo len)
       {
            length = len;
       }

       setBreadth public void (double BRE)
       {
            largura = bre;
       }

       setHeight public void (double hei)
       {
            height = hei;
       }
       pública getVolume double ()
       {
           comprimento de retorno * largura * altura;
       }
    }
    classe Boxtester
    {
        static void Main (string [] args)
        {
            Box Box1 = new Box (); // declara Box1, tipo Box
            Box Box2 = new Box (); // declara Box2, tipo Box
            o dobro do volume; // // Box1 volume de detalhamento Box1.setLength (6,0);
            Box1.setBreadth (7,0);
            Box1.setHeight (5.0);

            // Box2 detalhando Box2.setLength (12,0);
            Box2.setBreadth (13,0);
            Box2.setHeight (10,0);
       
            // Volume de Box1 de volume = Box1.getVolume ();
            Console.WriteLine ( "volume de Box1: {0}", volume);

            // Volume de Box2 de volume = Box2.getVolume ();
            Console.WriteLine ( "volume de Box2: {0}", volume);
           
            Console.ReadKey ();
        }
    }
}

Quando o código acima é compilado e executado, ele produz os seguintes resultados:

volume de Box1: 210
volume de box2: 1560

C # construtores

Construtor da classe é uma função especial membro da classe executada quando criando uma nova classe de objeto.

Nome O nome do construtor da classe exatamente o mesmo, não tem nenhum tipo de retorno.

O exemplo a seguir ilustra o conceito do construtor:

using System;
LineApplication namespace
{
   Linha classe
   {
      comprimento duplo privado; // comprimento da linha pública de linha ()
      {
         Console.WriteLine ( "objeto foi criado");
      }

      SetLength public void (duplo len)
      {
         length = len;
      }
      getLength public double ()
      {
         comprimento retornar;
      }

      static void Main (string [] args)
      {
         linha linha = new Line ();    
         // Definir o line.setLength comprimento da linha (6.0);
         Console.WriteLine ( "O comprimento da linha de: {0}", line.getLength ());
         Console.ReadKey ();
      }
   }
}

Quando o código acima é compilado e executado, ele produz os seguintes resultados:

objetos criados comprimento da linha: 6

O construtor padrão não tem parâmetros.Mas se você precisa de um construtor com um parâmetro pode ter argumentos, esse construtor é chamadoconstrutor parametrizado.Esta técnica pode ajudá-lo a criar o objeto enquanto o objeto para atribuir valores iniciais, consulte os seguintes exemplos específicos:

using System;
LineApplication namespace
{
   Linha classe
   {
      comprimento duplo privado; // comprimento da linha pública de linha (dupla len) // construtor com parâmetros {
         Console.WriteLine ( "objeto foi criado, comprimento = {0}", len);
         length = len;
      }

      SetLength public void (duplo len)
      {
         length = len;
      }
      getLength public double ()
      {
         comprimento retornar;
      }

      static void Main (string [] args)
      {
         linha linha = new Line (10,0);
         Console.WriteLine ( "O comprimento da linha de: {0}", line.getLength ()); 
         // Definir o line.setLength comprimento da linha (6.0);
         Console.WriteLine ( "O comprimento da linha de: {0}", line.getLength ()); 
         Console.ReadKey ();
      }
   }
}

Quando o código acima é compilado e executado, ele produz os seguintes resultados:

Objeto foi criado, comprimento = 10
comprimento da linha: 10
comprimento da linha: 6

Em C # destructor

Classedestructor é uma função membro de classe especial, quando o tipo de objeto está fora do intervalo.

Nome destructor está na frente do nome da classe com um ondulado (~) como um prefixo, ele não retorna um valor, que leva sem parâmetros.

Destruidor para o fim do programa (como o fechamento de arquivos para liberar memória, etc.) antes da liberação dos recursos. Destruidores não podem ser herdadas ou sobrecarregados.

O exemplo a seguir ilustra o conceito do processo de destruição:

using System;
LineApplication namespace
{
   Linha classe
   {
      comprimento duplo privado; // comprimento da linha pública de linha () // constructor {
         Console.WriteLine ( "objeto foi criado");
      }
      ~ Line () // destructor {
         Console.WriteLine ( "objeto foi excluído");
      }

      SetLength public void (duplo len)
      {
         length = len;
      }
      getLength public double ()
      {
         comprimento retornar;
      }

      static void Main (string [] args)
      {
         linha linha = new Line ();
         // Definir o line.setLength comprimento da linha (6.0);
         Console.WriteLine ( "O comprimento da linha de: {0}", line.getLength ());           
      }
   }
}

Quando o código acima é compilado e executado, ele produz os seguintes resultados:

objetos criados comprimento da linha: 6
objetos excluídos 

C # classe membro estática

Podemos usar a palavra-chave membro da classeestática é declarada como estática.Quando declaramos um membro da classe é estática, o que significa que não importa quantas objeto de classe é criado, há apenas uma cópia dos membros estáticos.

Apenas uma instância dos membros da palavra-chaveestática significa que a classe.Variáveis ​​estáticas usadas para definir constantes, porque o seu valor pode ser chamado diretamente, sem a necessidade de criar uma instância da classe classe de obter. Variáveis ​​estáticas podem ser inicializados na definição da função de membro externo ou classe. Você também pode inicializar variáveis ​​estáticas definidas dentro da classe.

O exemplo seguinte demonstra a utilização demedidas estáticas:

using System;
StaticVarApplication namespace
{
    classe StaticVar
    {
       int num public static;
        contagem public void ()
        {
            Num ++;
        }
        getNum int público ()
        {
            retornar num;
        }
    }
    classe StaticTester
    {
        static void Main (string [] args)
        {
            StaticVar s1 = new StaticVar ();
            StaticVar s2 = new StaticVar ();
            s1.count ();
            s1.count ();
            s1.count ();
            s2.count ();
            s2.count ();
            s2.count ();         
            Console.WriteLine ( "variável num S1: {0}", s1.getNum ());
            Console.WriteLine ( "variável num s2: {0}", s2.getNum ());
            Console.ReadKey ();
        }
    }
}

Quando o código acima é compilado e executado, ele produz os seguintes resultados:

s1 variável num: 6
s2 num variável: 6

Você também pode colocar umafunção de membro édeclarada comoestática.Tais funções só pode acessar variáveis ​​estáticas. função estática antes que o objeto é criado, ele existe. O exemplo seguinte demonstra a utilização defunções estáticas:

using System;
StaticVarApplication namespace
{
    classe StaticVar
    {
       int num public static;
        contagem public void ()
        {
            Num ++;
        }
        int public static getNum ()
        {
            retornar num;
        }
    }
    classe StaticTester
    {
        static void Main (string [] args)
        {
            StaticVar s = new StaticVar ();
            s.count ();
            s.count ();
            s.count ();                   
            Console.WriteLine ( "variável num: {0}", StaticVar.getNum ());
            Console.ReadKey ();
        }
    }
}

Quando o código acima é compilado e executado, ele produz os seguintes resultados:

Num variável: 3