Java Interface Pokemon (Ataque e Defesa)

Berus-kun · 31 de janeiro de 2022

Eu tenho que fazer um programa usando interface java, em que tenho a interface pokemon, classe pokemon, e o nome do pokemon

public interface PokeInterface {
    Pokemon Pokemon(String nome, int saude, String tipo, int ataque, int defesa);
    void attackPokemon(Pokemon pokemon);
        void DeffenderPokemon(Pokemon pokemon);

}

public class Pokemon {
    private String nome;
    private int saude;
    private String tipo;
        int ataque;
        int defesa;
    
    public Pokemon(String nome, int saude, String tipo, int ataque, int defesa) {
        this.nome = nome;
        this.saude = saude;
        this.tipo= tipo;
        this.ataque = ataque;
                this.defesa = defesa;

    }

    public int getSaude() {
        return saude;
    }

    public void setSaude(int saude) {
        this.saude = saude;
    }

    public int getAtaque() {
        return ataque;
    }

    public void setAtaque(int ataque) {
        this.ataque = ataque;
    }

    public int getDefesa() {
        return defesa;
    }

    public void setDefesa(int defesa) {
        this.defesa = defesa;
    }
    
    public String getnome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public int getsaude() {
        return saude;
    }

    public void setsaude(int saude) {
        this.saude = saude;
    }

    public String getTipo() {
        return tipo;
    }

    public void settipo(String tipo) {
        this.tipo = tipo;
    }
    
    
}

public class Pikachu  extends {
    
public Pikachu(String nome, int saude, String tipo, int ataque, int defesa) {
     
        
        
        
        
    }
    
    
}

Tem algum erro dando na classe Pikachu, podem me dar qualquer sugestão para me ajudar

AdrianoSiqueira · 31 de janeiro de 2022

O que Pikachu está estendendo?

Berus-kun · 31 de janeiro de 2022

@AdrianoSiqueira eu só fiz ataque e defesa para fazer na classe pika

Berus-kun · 1 de fevereiro de 2022

@AdrianoSiqueira tem alguma ideia?

AdrianoSiqueira · 1 de fevereiro de 2022

23 horas atrás, AdrianoSiqueira disse:

O que Pikachu está estendendo?

Não respondeu a pergunta...

Felipecfk · 1 de fevereiro de 2022

Eu acho que não faz muito sentido criar uma interface com nome, tipo, ataque, etc. E depois criar uma classe com as mesmas variáveis: nome, tipo, ataque, etc. A interface serve justamente pra você implementar na classe, sem ter que ficar repetindo o código.

Berus-kun · 2 de fevereiro de 2022

@Felipecfk entao apagar o atk e def no pokemon?

Felipecfk · 4 de fevereiro de 2022

Em 02/02/2022 às 07:51, Berus-kun disse:

@Felipecfk entao apagar o atk e def no pokemon?

Eu não sei se entendi bem o que o exercídio pede, mas eu acho que é algo nesse sentido:

public interface PokeInterface {

  	void pokeSetup(String nome);
}


//---------------------------------------
  
public class Pokemon implements PokeInterface {
	
	private String tipo;
	
	private int saude;
	private int ataque;
	private int defesa;

	public Pokemon(String tipo, int saude, int ataque, int defesa) {
		this.tipo = tipo;
		this.saude = saude;
		this.ataque = ataque;
		this.defesa = defesa;
	}
	
	@Override
	public void pokeSetup(String nome) {
		
		System.out.println(nome + ": " + 
		                   "\nTipo - " + tipo +
		                   "\nSaúde - " + saude +
		                   "\nAtaque - " + ataque +
		                   "\nDefesa - " + defesa);
	}
}


//---------------------------------------

import blabla.Pokemon; // blabla seria o nome do pacote, supondo que a interface e a classe pokemon estejam no mesmo pacote

public class Main {

	public static void main(String[] args) {

		Pokemon pikachu = new Pokemon("Elétrico", 35, 55, 40);
		
		pikachu.pokeSetup("Pikachu");
	}
}

Aí no terminal ficaria assim:

Pikachu:

Tipo - Elétrico

Saúde - 35
Ataque - 55

Defesa - 40

Berus-kun · 8 de fevereiro de 2022

@Felipecfk caramba, muito diferente, só algumas coisas, mas obrigado

Berus-kun · 16 de fevereiro de 2022

@Felipecfk Cara sei q já foi selecionado e tudo, mas me diga como eu faria uma batalha dentro do main? posso fazer depois ali?

Criar uma classe Main onde existe um método arena que recebe dois Pokemons para competirem, algo do tipo arena(Pokemon p1, Pokemon p2).

Dentro do método arena() p1 ataca p2 e vice-versa. Todo ataque realizado por p1 e p2, vai diminuir a saude do adversario.

Exemplo: p1.atacar(p2);

Portanto, dentro do método atacar deve ser atualizado o campo saude de quem recebeu o ataque. Por exemplo, se p1 atacou p2 a saude de p2 é atualizada com a seguinte fórmula:

saude = (saude - p1.forcaAtaque) + p2.forcaDefesa

ao final do método arena, imprimir a saude de p1 e p2.

eu fiz assim oh

public class Main {

	public static void main(String[] args) {

		Pokemon pikachu = new Pokemon("Elétrico", 100, 10, 2);
                Pokemon bulbasaur = new Pokemon("Grama", 80, 8, 3);

                
                
		pikachu.pokeSetup("Pikachu");
                
                
          System.out.println("----------------");

          bulbasaur.pokeSetup("bulbasaur");
                
                
                
                
                    
                
                
                
                

	}
}

Felipecfk · 16 de fevereiro de 2022

10 horas atrás, Berus-kun disse:

@Felipecfk Cara sei q já foi selecionado e tudo, mas me diga como eu faria uma batalha dentro do main? posso fazer depois ali?

Criar uma classe Main onde existe um método arena que recebe dois Pokemons para competirem, algo do tipo arena(Pokemon p1, Pokemon p2).

Dentro do método arena() p1 ataca p2 e vice-versa. Todo ataque realizado por p1 e p2, vai diminuir a saude do adversario.

Exemplo: p1.atacar(p2);

ahhh, entendi, eu vou ter que pensar de uma outra forma, esquece esse código aí que eu fiz. Eu vou pensar depois eu te falo uma ideia melhor

Berus-kun · 16 de fevereiro de 2022

@Felipecfk é q tipo, eu n posso fazer um metodo em interface né?

Felipecfk · 16 de fevereiro de 2022

agora, Berus-kun disse:

@Felipecfk é q tipo, eu n posso fazer um metodo em interface né?

A interface geralmente guarda os métodos mas não é ela que define o que os métodos vão fazer. Geralmente quem faz isso são as classes.

Berus-kun · 16 de fevereiro de 2022

@Felipecfk entao na classe pokemon eu faria

Berus-kun · 17 de fevereiro de 2022

@Felipecfk eu acho q seria tipo mais fácil, fazer interface pokemon, duas classes de pokemon(pikachu, bulbasauro por exemplo) e dai fazer o main

Felipecfk · 18 de fevereiro de 2022

13 horas atrás, Berus-kun disse:

@Felipecfk eu acho q seria tipo mais fácil, fazer interface pokemon, duas classes de pokemon(pikachu, bulbasauro por exemplo) e dai fazer o main

Eu pensei aqui, eu acho que seria melhor simplificar a batalha, porque se for fazer quem ataca primeiro vai depender de speed, se for ver quanto de dano vai tomar, vai depender do tipo do pokemon, do tipo do ataque que ta recebendo, isso vai ficar muito complexo, no fim das contas vai estar criando um jogo pra vender kkkk.

sim da pra criar duas classes mas o pokemon especifico pra mim faz mais sentido ser um objeto, exemplo:

class Pokemon {

    
    String tipo;
    final int hp;
    final int ataque;


      public Pokemon() {
            this.tipo = tipo
            this.hp = hp;
            this.ataque = ataque;
            //etc.

       }

}

public void batalha(Pokemon pokeA, Pokemon pokeB) {
     

     if (pokeA.speed > pokeB.speed) {

           System.out.println(pokeA+" da o primeiro golpe");

     } else {
            System.out.println(pokeB+" da o primeiro golpe");

     } 

     //etc. mais um monte de coisa
}

public class Main {

      public static void main(String[] args) {
            
              Pokemon pikachu = new Pokemon("Elétrico", 35, 55, 40)

              batalha(Pikachu, Charizard);

      }
}

Algo nesse sentido. (não testei esse código, só fiz nas coxas pra dar um exemplo rápido). Eu não sei onde entraria a interface nesse caso, mas geralmente é pra criar uma função com o mesmo nome que vai ser utilizada pra diferentes ocasiões usando um @override quando for defini-la dentro da classe. Talvez perguntar pro seu professor ser mais específico.

Berus-kun · 18 de fevereiro de 2022

@Felipecfk quando passo pro netbens ou eclipe da erro por alguma razao

ah e como eu faria o bulbasaur?

Ele da erro nas duas classes, Pokemon e tudo.

Mas tem q ser uma interface, uma interface, classe pika e classe bulba e dai uma batalha: Criar uma classe Main onde existe um método arena que recebe dois Pokemons para competirem, algo do tipo arena(Pokemon p1, Pokemon p2).

Dentro do método arena() p1 ataca p2 e vice-versa. Todo ataque realizado por p1 e p2, vai diminuir a saude do adversario.

Exemplo: p1.atacar(p2);

Portanto, dentro do método atacar deve ser atualizado o campo saude de quem recebeu o ataque. Por exemplo, se p1 atacou p2 a saude de p2 é atualizada com a seguinte fórmula:

saude = (saude - p1.forcaAtaque) + p2.forcaDefesa

ao final do método arena, imprimir a saude de p1 e p2.

Berus-kun · 19 de fevereiro de 2022

@Felipecfk tem como me ajudar nessa? é um projetinho, eu tinha feito naquela q você me ajudou, mas tem se ser dessa nova maneira, e n eh jogo n kkkk

n vou fazer jogo ainda, se for fazer é por pyton

Berus-kun · 19 de fevereiro de 2022

@Felipecfk Aqui, vou passar minha nova versão:

Crie uma interface genérica chamada Pokémon.

Esta interface contém os seguintes métodos:

ataque (Pokémon p)

defend() recebe o ataque e deduz esse valor de saúde

Crie duas classes concretas que implementem a interface Pokemon.

Pikachu: força de ataque = 10, força de defesa: 2, saúde = 100

Bulbasaur: força de ataque = 8, força de defesa: 3, saúde = 80

Nessas classes você pode colocar dois atributos, forcaAttack e forcaDefesa do tipo Integer com os valores citados acima.

Crie uma classe Main onde exista um método arena que receba dois Pokémons para competir, algo como arena(Pokemon p1, Pokemon p2).

Dentro do método arena(), p1 ataca p2 e vice-versa. Cada ataque realizado por p1 e p2 diminuirá a saúde do oponente.

Exemplo: p1.ataque(p2);

Portanto, dentro do método de ataque, o campo de saúde da pessoa que recebeu o ataque deve ser atualizado. Por exemplo, se p1 atacou p2, a saúde de p2 é atualizada com a seguinte fórmula:

saúde = (saúde - p1.ForceAttack) + p2.forceDefese

no final do método arena, imprima a saúde de p1 e p2.

public interface PokeInterface {
  public void atacar();
    public void defender();

  

     
    
    
}

public abstract class Pikachu implements PokeInterface {


	private String tipo;
       private int saude;
	private int ataque;
	private int defender;


        public Pikachu(String tipo, int saude, int ataque, int defesa) {
		this.tipo = tipo;
		this.saude = saude;
		this.ataque = ataque;
		this.defender = defesa;
	}


}

public abstract class  bulbasaur implements PokeInterface  {

	private String tipo;
       private int saude;
	private int ataque;
	private int defender;


        public bulbasaur(String tipo, int saude, int ataque, int defesa) {
		this.tipo = tipo;
		this.saude = saude;
		this.ataque = ataque;
		this.defender = defesa;
                
	}
    
    
    


}

public class Main {
 
          Pikachu pikachu = new  Pikachu ("Elétrico", 100, 10, 2);
               bulbasaur  bulbasaur = new  bulbasaur("Grama", 80, 8, 3);
    // ta dando erros nesses
    
    
    
}

Felipecfk · 20 de fevereiro de 2022

Pra mim também deu erro, isso é uma das coisas que me pega em orientação a objetos porque eles te obrigam a pensar de uma maneira meio longa e inconveniente. Eu tentei implementar a interface mas deu erro, daí talvez a classe precisasse ser abstrata como você fez, não sei porque o seu deu erro, mas vou testar aqui, amanhã te passo o que eu consegui com essas informações novas que você passou.

Citação

Crie duas classes concretas que implementem a interface Pokemon

Lembra que as duas classes precisam ser concretas. Ela dá erro mesmo enquanto você não tiver dado "override" nos métodos da interface, dentro das classes, mas eu vou postar exemplo depois daí vai ficar claro.

Felipecfk · 20 de fevereiro de 2022

//Classe abstrata
public abstract class Pokemons implements Pokemon {
    
    int saude, fAtaque, fDefesa;
    
    public Pokemons(int saude, int ataque, int defesa) {
        this.saude = saude;
        this.fAtaque = ataque;
        this.fDefesa = defesa;
    }
    
     @Override
    public void atacar(Pokemons p) {
        
    }
    
    @Override
    public void defender() {
        
    }
}

//Classe concreta
public class Pikachu extends Pokemons implements Pokemon {
      
    public Pikachu() {
        super(100, 10, 2);
    } 
}

//Classe concreta
public class Bulbasaur extends Pokemons implements Pokemon {
    
    public Bulbasaur() {
        super(80, 8, 3);       
    }
}

//Classe principal
public class Main {

    public static void arena(Pokemons p1, Pokemons p2) {
        //aqui você completa    
    }
    
    public static void main(String args[]) {
        
        Pokemons pikachu = new Pikachu();
        Pokemons bulbasaur = new Bulbasaur();
        
        arena(pikachu, bulbasaur);
    }
}

//Interface
public interface Pokemon {
    
    public void atacar(Pokemons p);
    public void defender();
}

Eu montei a estrutura, não consegui comentar acima porque essa inserção de código funciona de uma forma doida nesse site mas enfim, eu montei a estrutura (tive que criar uma classe abstrata que chamei de "pokemons", não teve jeito). Aí você faz a parte do cálculo dos métodos atacar, defender e arena. Ok?

Berus-kun · 20 de fevereiro de 2022

@Felipecfk como faço> da uma dica, vou ver mais a frente

Berus-kun · 20 de fevereiro de 2022

@Felipecfk o super em pika e bulba seria o que?

AdrianoSiqueira · 20 de fevereiro de 2022

Por que vocês não seguem essa abordagem?

public class ProgramaPokemon {

    public static void main(String[] args) {
        Pokemon p1 = new Pokemon("Pikachu", Tipo.ELETRICO, 100, 20, 15);
        Pokemon p2 = new Pokemon("Bubassauro", Tipo.GRAMA, 100, 25, 17);

        System.out.println("Estado atual:");
        System.out.println(p1);
        System.out.println(p2);

        System.out.println(p1.getNome() + " ataca " + p2.getNome());
        p1.atacar(p2);

        System.out.println("Estado atual:");
        System.out.println(p1);
        System.out.println(p2);

        System.out.println(p2.getNome() + " ataca " + p1.getNome());
        p2.atacar(p1);

        System.out.println("Estado atual:");
        System.out.println(p1);
        System.out.println(p2);
    }


    private enum Tipo {
        AGUA, ELETRICO, FANTASMA, FOGO, GRAMA, INSETO, NORMAL
    }

    private interface IAtaque {
        void atacar(Pokemon pokemon);
    }

    private static class Pokemon implements IAtaque {
        private String nome;
        private Tipo   tipo;

        private int vida;
        private int ataque;
        private int defesa;

        public Pokemon(String nome, Tipo tipo, int vida, int ataque, int defesa) {
            this.nome = nome;
            this.tipo = tipo;
            this.vida = vida;
            this.ataque = ataque;
            this.defesa = defesa;
        }

        public String getNome() {
            return nome;
        }

        public void setNome(String nome) {
            this.nome = nome;
        }

        public Tipo getTipo() {
            return tipo;
        }

        public void setTipo(Tipo tipo) {
            this.tipo = tipo;
        }

        public int getVida() {
            return vida;
        }

        public void setVida(int vida) {
            this.vida = vida;
        }

        public int getAtaque() {
            return ataque;
        }

        public void setAtaque(int ataque) {
            this.ataque = ataque;
        }

        public int getDefesa() {
            return defesa;
        }

        public void setDefesa(int defesa) {
            this.defesa = defesa;
        }

        @Override
        public void atacar(Pokemon alvo) {
            int dano = Math.max(0, ataque - alvo.defesa);
            alvo.vida -= dano;
        }

        @Override
        public String toString() {
            return "Pokemon{" +
                   "nome='" + nome + '\'' +
                   ", tipo=" + tipo +
                   ", vida=" + vida +
                   ", ataque=" + ataque +
                   ", defesa=" + defesa +
                   '}';
        }
    }
}

Se quiserem aprender sobre Java, recomendo esse curso: https://www.youtube.com/playlist?list=PL62G310vn6nFIsOCC0H-C2infYgwm8SWW.

É de graça e de alta qualidade.

Felipecfk · 20 de fevereiro de 2022

2 horas atrás, Berus-kun disse:

@Felipecfk o super em pika e bulba seria o que?

como eles ambos estão estendendo a classe pokemons, o super é uma forma de chamar todos esses atributos (saude, ataque, defesa) sem precisar declarar eles de novo nas classes pikachu e bulbassauro. O super 'puxa' o construtor da superclasse "Pokemons". Mas se você não aprendeu essa parte ainda nem coloca, senão seu professor vai xingar.