algo útil

1. Herança

Para trabalhar com o mecanismo de jogo CodeGym, você precisará usar a herança . Mas e se você não souber o que é isso? Por um lado, você precisa entender e estudar este tópico. Por outro lado, o mecanismo foi especialmente projetado para ser muito simples, para que você possa se virar com um conhecimento superficial de herança.

Então, o que é herança? Em termos simples, a herança é um relacionamento entre duas classes. Uma delas atua como a classe pai e a outra se torna a classe filha (descendente). Além do mais, uma classe pai pode nem saber que tem classes descendentes. Em outras palavras, o pai não obtém muito benefício de ter classes descendentes.

Mas a herança oferece muitas vantagens para a classe filha. A mais importante delas é que todas as variáveis ​​e métodos da classe pai apareçam na classe filha, como se o código da classe pai fosse copiado diretamente para a classe filha. Isso não é totalmente preciso, mas será suficiente para uma compreensão básica da herança.

Aqui estão alguns exemplos para ajudá-lo a entender melhor a herança.

Exemplo 1 — aqui está o exemplo mais simples

public class Parent
{
}

public class Child extends Parent
{
}

Exemplo 2 — usando as variáveis ​​da classe pai

public class Parent
{
  public int age;
  public String name;
}

public class Child extends Parent
{
  public void printInfo()
  {
    System.out.println(name + " " + age);
  }
}

Exemplo 3 — usando métodos da classe pai

public class Parent
{
   public int age;
   public String name;
   public getName() {
      return name;
   }
}

public class Child extends Parent
{
   public void printInfo()
   {
      System.out.println(getName() + " " + age);
   }
}

Omitindo alguns detalhes, podemos dizer que, do ponto de vista do compilador Java, simplesmente copiamos o código da classe pai para o código da classe filha:

public class Child extends Parent
{
   public int age;        // An inherited variable
   public String name;    // An inherited variable
   public getName() {     // An inherited method
      return name;
   }

   public void printInfo()
   {
      System.out.println(getName() + " " + age);
   }
}

2. Sobreposição de método

Às vezes, há situações em que fazemos nossa Childclasse herdar uma classe muito útil Parent, fazendo com que o filho herde todas as variáveis ​​e métodos do pai. Mas alguns desses métodos podem não funcionar da maneira que queremos ou não funcionar da maneira que queremos.

O que você faz neste caso? Podemos sobrescrever um método cuja implementação não gostamos . Isso é algo simples de fazer: em nossa Childclasse, simplesmente declaramos um método com a mesma assinatura do método da Parentclasse e, em seguida, escrevemos nosso próprio código nele.

Exemplo 1 — substituição de método

public class Parent
{
   public String name;
   public void setName(String nameNew) {
      name = nameNew;
   }

   public getName() {
      return name;
   }
}

Luke, No!!!

public class Child extends Parent
{
   public void setName(String nameNew) {
      name = nameNew + ", No!!!";
   }

   public void printInfo()
   {
      setName("Luke");
      System.out.println(getName());
   }
}

Simplificando um pouco a situação, a herança faz com que o código da classe pai seja copiado para a classe filha. Mas se uma classe descendente já possui um método que existe em uma classe ancestral, esse método não é copiado da classe ancestral. Aqui dizemos que o método na classe filha substitui o método na classe pai. Veja o exemplo abaixo. Talvez isso ajude a tornar as coisas um pouco mais claras:

public class Child extends Parent
{
   public String name;    // An inherited variable

   public void setName(String nameNew)  // The overridden method replaces the inherited one
   {
      name = nameNew + ", No!!!";
   }

   public getName()    // An inherited method
   {
      return name;
   }

   public void printInfo()
   {
      setName("Luke");
      System.out.println(getName());
   }
}

Exemplo 2 - um pouco de mágica de herança (e substituição de método)

public class Parent
{
   public getName() {
      return "Luke";
   }

   public void printInfo()
   {
      System.out.println( getName() );
   }
}

public class Child extends Parent
{
   public getName() {
      return "Luke, I am your father";
   }
}

Se o printInfo()método for chamado em um Parenttipo, ele, por sua vez, chamará o getName()método da Parentclasse.

Se o printInfo()método for chamado em um Childobjeto, ele por sua vez chamará o getName()método da Childclasse.

Em outras palavras, o printInfo()método é declarado apenas na Parentclasse, mas chama o getName()método da Childclasse se o printInfo()método for chamado em um Childobjeto.

Exemplo:

Parent parent = new Parent();
parent.printnInfo();

Luke

Child child = new Child();
child.printnInfo();

Luke, I am your father

E tudo porque do ponto de vista do compilador (uma versão bem simplificada dele), o código da Childclasse fica assim:

public class Child extends Parent
{
   public getName() {
      return "Luke, I am your father";
   }

   public void printInfo()
   {
      System.out.println(getName());
   }
}

3. Listas

Aqui está um breve lembrete sobre listas ( List). Listas têm muito em comum com arrays:

• Eles podem armazenar muitos dados de um tipo específico.
• Eles permitem que você obtenha elementos por seu índice.
• Os índices dos elementos começam em 0.

Vantagens das listas:

Ao contrário dos arrays, as listas podem mudar de tamanho dinamicamente. Imediatamente após a criação, o tamanho de uma lista é 0. Conforme os itens são adicionados à lista, seu tamanho aumenta. Exemplo de criação de uma lista:

ArrayList<String> myList = new ArrayList<String>();

O valor indicado entre os colchetes angulares é o tipo de dados que a lista pode armazenar.

Aqui estão alguns métodos para trabalhar com uma lista:

ArrayList<String> list = new ArrayList<String>();

list.add("name");

list.add(0, "name");

String name = list.get(5);

list.set(5, "new name");

int count = list.size();

list.remove(4);

Para obter mais informações sobre listas, você pode ler os seguintes artigos:

• ArrayList em imagens
• Classe ArrayList
• Removendo um item de um ArrayList

4. Números aleatórios

O motor de jogo CodeGym tem dois métodos que podem ser usados ​​para gerar números aleatórios. Esses métodos são:

int getRandomNumber(int max)

int getRandomNumber(int min, int max)

O primeiro método — getRandomNumber(int max)— retorna um número aleatório no intervalo 0, 1, 2, ... max-1. Nos bastidores, ele usa a Randomclasse do java.utilpacote, mas isso não muda como você usa um número aleatório.

getRandomNumber(int)aceita um número inteiro como argumento. Esse número será o limite superior dos números que o gerador de números aleatórios pode retornar. O limite inferior é 0. Atenção! O gerador de números aleatórios NUNCA retornará o valor do limite superior. Por exemplo, se você chamar getRandomNumber(3), ele retornará aleatoriamente 0, 1 ou 2. Como você pode ver, ele não retornará 3. Usar um gerador de números aleatórios dessa maneira é bastante simples, mas é adequado para muitos casos.

O segundo método — getRandomNumber(int min, int max)— retorna um número inteiro aleatório no intervalo [min, max-1]. Ele nunca retornará um número menor que mine nunca retornará um número maior que max-1.

Como esses métodos podem ser usados ​​na prática?

1. Dados

Suponha que você queira simular o lançamento de um dado e obter um número aleatório no intervalo 1-6. Como você faria? Isso pode ser feito com código como este:

int dice = getRandomNumber(1, 7);

Este método retornará um número inteiro aleatório no intervalo 1-6.

2. Prática de tiro ao alvo

Suponha que você queira simular um tiro em um alvo, e a precisão de um tiro inclui um componente aleatório que varia no intervalo de -10até +10inclusive. Isso pode ser feito com código como este:

int dx = getRandomNumber(-10, 11);

Este método retornará um número inteiro aleatório no intervalo -10de +10.

Existem muitas maneiras de usar números aleatórios em jogos. Você está limitado apenas pela sua imaginação. Escreva seus próprios jogos, refine-os e aproveite o processo.

Todos podem jogar, mas apenas os programadores podem criá-los.