Entendendo o uso de Classes C# – Parte 2
Como visto no Entendo o uso de Classes C# – Parte 1, as classes são usadas para abstrair objetos. Nessas classes, tanto os parâmetros quanto os métodos podem possuir o estado de público ou privado. O estado público designa que o parâmetro/método pode ser acessado de fora da classe, enquanto o privado só pode ser manipulado pela mesma. Há outros estados que podemos usar, mas não será aplicado neste artigo.
Abra o projeto criado no artigo anterior, acesse o arquivo GuerreiroZ e substitua para o seguinte código:
public class GuerreiroZ { //Usado para Instanciar a classe com parâmetros preenchidos public GuerreiroZ(string nome, Racas raca, int ki) { Nome = nome; Raca = raca; this.ki = ki; } //Usado para Instanciar a classe vazia public GuerreiroZ() { } //Restante do código... }
Neste momento, a classe irá apresentar erros, mas isso será solucionado com o trecho a seguir, adicione os atributos a classe:
//Valores pré definidos e estáticos public enum Racas { Humano, Saiyajin, Androide, Namekuseijin } public string Nome; public Racas Raca; private int ki;
Acima criamos um Enum, o qual são valores estáticos pré definidos, isso nos auxilia em pré determinar quais valores o parâmetro Raca deve ter. Temos também um atributo público chamado Nome um privado chamado ki.
Agora, adicione o seguinte trecho:
/// <summary> /// Método usado para aumentar o Ki /// </summary> /// <param name="ki"></param> public void AumentarKi(int ki) { this.ki += ki; } /// <summary> /// Método usado obter o Ki /// </summary> /// <returns>Int</returns> public int ObterKi() { return this.ki; }
Pelo fato do atributo ki ser privado, ele não pode ser acessado externamente da classe, portanto, criamos o método ObterKi para pegar o valor e o AumentarKi, para incrementar o valor (note que este último recebe um parâmetro), ambos métodos públicos.
Seguindo na codificação, adicione agora o trecho:
/// <summary> /// Método usado para usar um poder /// </summary> /// <param name="raca"></param> public void UsarPoder(Racas raca) { int minUso; int maxUso; switch (raca) { case Racas.Androide: minUso = 500; maxUso = 1000; if (conferirSePodeUsarPoder( maxUso)) diminuirKi(minUso, maxUso); break; case Racas.Humano: minUso = 200; maxUso = 800; if (conferirSePodeUsarPoder(maxUso)) diminuirKi(minUso, maxUso); break; case Racas.Namekuseijin: minUso = 1000; maxUso = 2000; if (conferirSePodeUsarPoder( maxUso)) diminuirKi(minUso, maxUso); break; case Racas.Saiyajin: minUso = 3000; maxUso = 5000; if (conferirSePodeUsarPoder(maxUso)) diminuirKi(minUso, maxUso); break; default: Console.WriteLine("Raça não existe"); break; } }
Este é um método um pouco mais complexo, nele pedimos como parâmetro um valor do enum Racas e fazemos um Switch, de acordo com o valor passado, conferimos se o Guerreiro Z tem ki suficiente pra usar o poder.
Vamos implementar os 2 últimos métodos:
/// <summary> /// Método usado para conferir se o guerreiro tem ki suficiente para usar o poder /// </summary> /// <param name="max"></param> /// <returns>Bool</returns> private bool conferirSePodeUsarPoder(int max) { if (ki >= max) return true; return false; } /// <summary> /// Método usado para diminuir randomicamente o ki /// </summary> /// <param name="min"></param> /// <param name="max"></param> private void diminuirKi(int min, int max) { //Classe responsável por randomizar Random rnd = new Random(); //Randomiza um número inteiro com base de um intervalo de números this.ki -= rnd.Next(min, max); }
Foram adicionados 2 métodos privados, que são acessados pelo método público UsarPoder. O método conferirSePodeUsarPoder retorna um valor do tipo boolean, ao conferir se o guerreiro possui ou não Ki para usar o seu poder. Já o método diminuirKi, é responsável por randomizar um número inteiro entre um intervalo e decrementar do atributo ki este valor gerado.
Arquivo GuerreiroZ.cs completo:
public class GuerreiroZ { //Usado para Instanciar a classe com parâmetros preenchidos public GuerreiroZ(string nome, Racas raca, int ki) { Nome = nome; Raca = raca; this.ki = ki; } //Usado para Instanciar a classe vazia public GuerreiroZ() { } //Valores pré definidos e estáticos public enum Racas { Humano, Saiyajin, Androide, Namekuseijin } public string Nome; public Racas Raca; private int ki; /// <summary> /// Método usado para aumentar o Ki /// </summary> /// <param name="ki"></param> public void AumentarKi(int ki) { this.ki += ki; } /// <summary> /// Método usado obter o Ki /// </summary> /// <returns>Int</returns> public int ObterKi() { return this.ki; } /// <summary> /// Método usado para usar um poder /// </summary> /// <param name="raca"></param> public void UsarPoder(Racas raca) { int minUso; int maxUso; switch (raca) { case Racas.Androide: minUso = 500; maxUso = 1000; if (conferirSePodeUsarPoder( maxUso)) diminuirKi(minUso, maxUso); break; case Racas.Humano: minUso = 200; maxUso = 800; if (conferirSePodeUsarPoder(maxUso)) diminuirKi(minUso, maxUso); break; case Racas.Namekuseijin: minUso = 1000; maxUso = 2000; if (conferirSePodeUsarPoder( maxUso)) diminuirKi(minUso, maxUso); break; case Racas.Saiyajin: minUso = 3000; maxUso = 5000; if (conferirSePodeUsarPoder(maxUso)) diminuirKi(minUso, maxUso); break; default: Console.WriteLine("Raça não existe"); break; } } /// <summary> /// Método usado para conferir se o guerreiro tem ki suficiente para usar o poder /// </summary> /// <param name="max"></param> /// <returns>Bool</returns> private bool conferirSePodeUsarPoder(int max) { if (ki >= max) return true; return false; } /// <summary> /// Método usado para diminuir randomicamente o ki /// </summary> /// <param name="min"></param> /// <param name="max"></param> private void diminuirKi(int min, int max) { Random rnd = new Random(); this.ki -= rnd.Next(min, max); } }
Agora que temos nossa classe completamente criada, vá até o arquivo Program.cs e cole o seguinte código:
static void Main(string[] args) { GuerreiroZ Goku = new GuerreiroZ("Goku",GuerreiroZ.Racas.Saiyajin, 10000); GuerreiroZ Piccolo = new GuerreiroZ("Piccolo", GuerreiroZ.Racas.Namekuseijin, 5000); GuerreiroZ N18 = new GuerreiroZ("N18", GuerreiroZ.Racas.Androide, 3500); GuerreiroZ Kuririn = new GuerreiroZ("Kuririn", GuerreiroZ.Racas.Humano, 2500); Console.WriteLine($"Nome: {Goku.Nome}, Raça: {Goku.Raca}, Poder: { Goku.ObterKi() }"); Console.WriteLine($"Nome: {Piccolo.Nome}, Raça: {Piccolo.Raca}, Poder: { Piccolo.ObterKi() }"); Console.WriteLine($"Nome: {N18.Nome}, Raça: {N18.Raca}, Poder: { N18.ObterKi() }"); Console.WriteLine($"Nome: {Kuririn.Nome}, Raça: {Kuririn.Raca}, Poder: { Kuririn.ObterKi() }"); Goku.AumentarKi(15000); Console.WriteLine($"Novo poder do Goku: { Goku.ObterKi() }"); Goku.UsarPoder(Goku.Raca); Console.WriteLine($"Goku usou poder: { Goku.ObterKi() }"); Goku.UsarPoder(Goku.Raca); Console.WriteLine($"Goku usou poder: { Goku.ObterKi() }"); Goku.AumentarKi(1000000); Goku.Nome = "Goku Super Saiyajin 1"; Console.WriteLine($"Nome: {Goku.Nome}, Poder: { Goku.ObterKi() }"); Console.ReadKey(); } //Outputs: // Nome: Goku, Raça: Saiyajin, Poder: 10000 // Nome: Piccolo, Raça: Namekuseijin, Poder: 5000 // Nome: N18, Raça: Androide, Poder: 3500 // Nome: Kuririn, Raça: Humano, Poder: 2500 // Novo poder do Goku: 25000 // Goku usou poder: 20028 // Goku usou poder: 16491 // Nome: Goku Super Saiyajin 1, Poder: 1016491
Como no artigo 1, criamos várias classes do GuerreiroZ, com valores diferentes. Apesar de todas terem a mesma origem, elas não são compartilhadas e podem ser manipuladas sem interferir em outra instância.
Dica: Neste exemplo manipulamos somente a classe do Goku, manipule os outros, altere valores, brinque com o código para assimilar o conteúdo.
Conclusão
O uso de classe facilita a organização de seu projeto e ajuda a colocar nomes em determinados objetos, devido a isso, use e abuse dela , criando e atribuindo os parâmetros/métodos de forma adequada a cada classe criada.