Curso de C#: Lição 5: Métodos

Em lições anteriores deste tutorial, todos os nossos funcionalidade para cada programa residiu no método Main (). Enquanto isso foi suficiente para os simples programas que utilizamos para aprender conceitos anteriores, não existe uma maneira melhor de organizar o seu programa, utilizando métodos.

Por | @oficinadanet Programação
Em lições anteriores deste tutorial, todos os nossos funcionalidade para cada programa residiu no método Main (). Enquanto isso foi suficiente para os simples programas que utilizamos para aprender conceitos anteriores, não existe uma maneira melhor de organizar o seu programa, utilizando métodos. Um método ajuda a separar o seu código em módulos que executam uma determinada tarefa.Os objectivos desta aula são as seguintes:

* Compreender a estrutura de um método.
* Conhecer a diferença entre métodos estáticos e exemplo.
*  Aprenda a instanciar objetos.
* Saiba como chamar métodos de um objeto instanciado.
* Compreender 4 tipos de parâmetros.
* Saiba como usar a esta referência.


Estrutura de um método


Métodos são extremamente úteis porque lhe permitem separar sua lógica em unidades diferentes. Você pode passar informações aos métodos, tem que executar uma ou mais declarações, e obter um valor de retorno. A capacidade de passar parâmetros e retornar valores é opcional e depende do que você quer que o método para fazer. Aqui está uma descrição da sintaxe necessária para a criação de um método:
attributes modifiers return-type method-name(parametros)
{
    implementação
}


O return-type pode ser qualquer tipo C #. Ela pode ser atribuída para uma variável para uso posterior no programa. O método nome é um identificador único para o que você deseja chamar um método. Para promover o entendimento de seu código, um método nome deve ser significativa e associada com a tarefa do método executa. Parâmetros lhe permitir passar a informação e de um método. Eles são rodeados por parêntesis.

Listagem 5-1.Um método simples: OneMethod.cs

using System;

class OneMethod
{
    public static void Main()
    {
        string myChoice;

        OneMethod om = new OneMethod();

        do
       {
            myChoice = om.getChoice();

            // Make a decision based on the user's choice
            switch(myChoice)
            {
                case "A":
                case "a":
                    Console.WriteLine("You wish to add an address.");
                    break;
                case "D":
                case "d":
                    Console.WriteLine("You wish to delete an address.");
                    break;
                case "M":
                case "m":
                    Console.WriteLine("You wish to modify an address.");
                    break;
                case "V":
                case "v":
                    Console.WriteLine("You wish to view the address list.");
                    break;
                case "Q":
                case "q":
                    Console.WriteLine("Bye.");
                    break;
                default:
                    Console.WriteLine("{0} is not a valid choice", myChoice);
                    break;
            }

            // Pause to allow the user to see the results
            Console.WriteLine();
            Console.Write("press Enter key to continue...");

            Console.ReadLine();
            Console.WriteLine();

        } while (myChoice != "Q" && myChoice != "q"); // Keep going until the user wants to quit
    }

    string getChoice()
    {
        string myChoice;

        // Print A Menu
        Console.WriteLine("My Address Bookn");

        Console.WriteLine("A - Add New Address");
        Console.WriteLine("D - Delete Address");
        Console.WriteLine("M - Modify Address");
        Console.WriteLine("V - View Addresses");
        Console.WriteLine("Q - Quitn");

        Console.Write("Choice (A,D,M,V,or Q): ");

        // Retrieve the user's choice
        myChoice = Console.ReadLine();
        Console.WriteLine();

        return myChoice;
    }
}


O programa da Listagem 5-1 é semelhante à Loop Do programa de Aula 4, com excepção de uma diferença. Em vez de imprimir o menu e aceitando entrada no método Main (), esta funcionalidade foi transferido para um novo método chamado getChoice (). O tipo de retorno é uma string. O método name "getChoice" descreve o que acontece quando ele é invocado. Desde o parênteses estão vazias, nenhuma informação será transferida para o método getChoice ().

Dentro do método bloco nós primeiramente declarar a variável myChoice. Embora este seja o mesmo nome e tipo do myChoice variável em Main (), que são os dois únicos variáveis. Eles são variáveis locais e são visíveis apenas no bloco, que são declaradas. Em outras palavras, o myChoice em getChoice () sabe nada sobre a existência do myChoice em Main (), e vice-versa.

O método getChoice () imprime um menu para o console e fica-se com a entrada do usuário.O return envia os dados do myChoice variável volta para o chamador, Main (), de getChoice (). Note que o tipo retornado pelo retorno deve ser o mesmo que o retorno do tipo de declaração da função. Neste caso, é uma string.

No método Main (), devemos instanciar uma nova OneMethod objeto antes de podermos utilizar getChoice (). Isso é por causa do modo como getChoice () é declarado. Desde que nós não especificar um modificador estático, como para Main (), getChoice () torna-se uma instância método. A diferença entre instância métodos estáticos e métodos é que várias instâncias de uma classe podem ser criados (ou instanciado) e cada instância tem o seu próprio método separado getChoice (). No entanto, quando um método é estático, não há ocorrências desse método, e você pode invocar apenas que uma definição do método estático.

Portanto, como afirmou, getChoice () não é estática e, portanto, temos que exemplificam um novo objeto de utilizá-la. Isto é feito com a declaração OneMethod om = new OneMethod (). No lado esquerdo da declaração é o objeto referência om, que é do tipo OneMethod. A distinção de om a ser uma referência é importante. Não é um objecto em si, mas é uma variável que pode remeter (ou ponto) de um objeto do tipo OneMethod. No lado direito da declaração é uma atribuição de um novo OneMethod opor-se a referência om. A palavra-chave é um novo operador C #, que cria uma nova instância de um objeto na heap. O que está a acontecer aqui é que uma nova instância OneMethod está sendo criada no heap e, em seguida, a ser atribuído ao om referência. Agora que temos uma instância da classe OneMethod referenciados por om, nós podemos manipular esse exemplo, através da referência om.

Métodos, campos, e outros membros classe pode ser acessado, identificados, ou manipuladas através do "." (dot) operator. (Cs) operador. Desde que queremos chamar getChoice (), é fazê-lo usando o operador ponto através do om referência: om.getChoice (). O programa então executa as declarações no getChoice () e retorna bloco. Para capturar o valor getChoice () Volta, usamos o "=" (atribuição) operador. Retornado A corda é colocada em Main () 's locais myChoice variável. A partir daí, o resto do programa executa como esperado, utilizando conceitos de lições anteriores.

Listagem 5-2. Parâmetros de métodos: MethodParams.cs

using System;

class Address
{
    public string name;
    public string address;
}

class MethodParams
{
    public static void Main()
    {
        string myChoice;

        MethodParams mp = new MethodParams();

        do
       {
            // show menu and get input from user
            myChoice = mp.getChoice();

            // Make a decision based on the user's choice
            mp.makeDecision(myChoice);

            // Pause to allow the user to see the results
            Console.Write("press Enter key to continue...");
            Console.ReadLine();
            Console.WriteLine();
        } while (myChoice != "Q" && myChoice != "q"); // Keep going until the user wants to quit
    }

    // show menu and get user's choice
    string getChoice()
    {
        string myChoice;

        // Print A Menu
        Console.WriteLine("My Address Bookn");

        Console.WriteLine("A - Add New Address");
        Console.WriteLine("D - Delete Address");
        Console.WriteLine("M - Modify Address");
        Console.WriteLine("V - View Addresses");
        Console.WriteLine("Q - Quitn");

        Console.WriteLine("Choice (A,D,M,V,or Q): ");

        // Retrieve the user's choice
        myChoice = Console.ReadLine();

        return myChoice;
    }

    // make decision
    void makeDecision(string myChoice)
    {
        Address addr = new Address();

        switch(myChoice)
        {
            case "A":
            case "a":
                addr.name = "Joe";
                addr.address = "C# Station";
                this.addAddress(ref addr);
                break;
            case "D":
            case "d":
                addr.name = "Robert";
                this.deleteAddress(addr.name);
                break;
            case "M":
            case "m":
                addr.name = "Matt";
                this.modifyAddress(out addr);
                Console.WriteLine("Name is now {0}.", addr.name);
                break;
            case "V":
            case "v":
                this.viewAddresses("Cheryl", "Joe", "Matt", "Robert");
                break;
            case "Q":
            case "q":
                Console.WriteLine("Bye.");
                break;
            default:
                Console.WriteLine("{0} is not a valid choice", myChoice);
                break;
        }
    }

    // insert an address
    void addAddress(ref Address addr)
    {
        Console.WriteLine("Name: {0}, Address: {1} added.", addr.name, addr.address);
    }

    // remove an address
    void deleteAddress(string name)
    {
        Console.WriteLine("You wish to delete {0}'s address.", name);
    }

    // change an address
    void modifyAddress(out Address addr)
    {
        //Console.WriteLine("Name: {0}.", addr.name); // causes error!
        addr = new Address();
        addr.name = "Joe";
        addr.address = "C# Station";
    }

    // show addresses
    void viewAddresses(params string[] names)
    {
        foreach (string name in names)
        {
            Console.WriteLine("Name: {0}", name);
        }
    }
}


Listagem 5-2 é uma modificação da listagem 5-1, modularizando o programa e adicionando mais aplicação para mostrar parâmetro passagem. Existem 4 tipos de parâmetros C # um método pode segurar: out, ref, parâmetros e valor. Para ajudar a ilustrar utilização de parâmetros, criamos um endereço classe string com dois campos.

Em Main () que chamamos getChoice () para obter a entrada do usuário e colocá-la no myChoice variável. Então nós usamos myChoice como um argumento para makeDecision (). Na declaração de makeDecision (), você verá o seu um parâmetro é declarado como uma string com o nome myChoice. Mais uma vez, este é um novo myChoice, separado do chamador argumento do local e apenas a este método. Desde makeDecision () 's myChoice parâmetro não tem quaisquer outros modificadores, que é considerado um valor parâmetro. O real valor do argumento é copiado na pilha. Variáveis dada pelo valor parâmetros são locais e quaisquer alterações a essa variável local não afetam o valor da variável utilizada no argumento do chamador.

O switch em makeDecision () chama um método para cada caso. Esses método chamadas são diferentes dos que utilizamos na Main (). Em vez de usar o mp referência, que utilize a esta palavra-chave. Trata-se de uma referência ao objeto atual. Sabemos que o actual tem sido objeto instanciado porque makeDecision () não é um método estático.Portanto, podemos utilizar a referência a este apelo métodos dentro da mesma instância.

O método addAddress () demora um parâmetro ref. Isto significa que uma referência ao parâmetro é copiado para o método. Esta referência remete ainda para o mesmo objeto sobre o heap como o original referência utilizado no argumento do chamador. Isto significa que qualquer mudança para o local referência do objeto também modifica a referência do objeto chamador. O código não pode mudar a referência, mas pode fazer as alterações para o objeto a ser referenciado. Pode-se pensar que se trata de uma forma de ter um input / output parâmetro.

Como sabem, os métodos têm retorno valores, mas às vezes você deseja retornar mais de um valor de um método.Um out parâmetro permite-lhe devolver valores adicionais a partir de um método.

ModifyAddress () tem um parâmetro para fora. Out parâmetros só são transmitidas de volta à função chamadora. Devido a cessão definitiva regras, você não pode usar essa variável até que ela tem um valor válido atribuído. A primeira linha em modifyAddress () é comentado propósito para ilustrar este ponto. Descomente e compilá-lo para ver o que acontece. Uma vez atribuído o programa e volta, o valor do parâmetro out serão copiadas para o chamador argumento da variável. Você deve atribuir um valor para um parâmetro para fora antes de seu método retorna.

Uma grande utilidade para além da linguagem C # é o parâm parâmetro, o que permite definir um método que pode aceitar um número variável de argumentos. O parâm parâmetro deve ser uma única dimensão ou retalhadas array. Ao ligar viewAddresses (), nós passamos em quatro argumentos string. O número de argumentos é variável e será convertido para uma string [] automaticamente. Em viewAddresses () usamos um loop foreach para imprimir cada um destes textos.Em vez da lista de argumentos string, a contribuição poderia ter sido também uma string array. O parâmetro é considerado um único parâmetro de entrada e qualquer alteração afecta apenas a cópia local.

Resumo


Em resumo, você compreende a estrutura de um método. Os quatro tipos de paramters estão valor, ref, fora, e parâm. Quando você quiser usar uma instância método, você deve instanciar seu objeto, em oposição aos métodos estáticos que podem ser chamados a qualquer momento. A esta referência remete para as suas contendo objetos e pode ser usado para se referir a seu objeto contendo's membros, incluindo métodos.

Matéria automaticamente traduzida de: http://www.csharp-station.com/Tutorials/Lesson05.aspx

Mais sobre: curso c Sharp c sharp
Share Tweet
Recomendado
Comentários
Carregar comentários
Destaquesver tudo