Ejercicio 1!

Antes de empezar con el ejercicio, voy a poner las principales dudas que me surgieron al leer el enunciado y que yo modificaría o dejaría mejor explicadas.

El ejercicio consiste en crear un juego de personajes de rol donde tenemos que crear 4 clases y una interfaz:

·    Personaje: Recoge las características generales comunes a cualquier tipo de personaje. Habrá de programarse de forma que no se puedan crear instancias de esta clase. (Esta frase no deja claro lo que nos están pidiendo. Quizás poniendo que no se pueden crear objetos o directamente diciendo que se trata de una clase padre(asi ya indicamos que el ejercicio trata de herencia) abstracta, se entendería mejor.)
o    Información que deberá guardar como mínimo: vida del personaje, fuerza, inteligencia, astucia y vigor inicial: Esta característica tendrá en todo momento el mismo valor para todos los personajes, esto es, si alguno cambia su vigor, el nuevo valor cambiará para todos.(Lo que quiere decir, el atributo vigor tiene que ser estático, aunque la forma de explicarlo del enunciado también se entiende bien).
o    Métodos:
- Constructores varios: Además de inicializar la información del personaje, deberán tomar nota del objeto que los llamó, a fin poder llamarlo más tarde.(No termino de entender ni este apartado ni el siguiente)
- Métodos de acceso a la información: Estos métodos, además, deberán notificar al método “personajeCambiado(Personaje)” del objeto que creo el personaje cada cambio que se produzca en la información del personaje.
-  Un método “imprimir()” sin implementar.(Queda claro que tiene que ser abstracto)
·    Guerrero: Guardará la misma información y tendrá los mismos métodos que Personaje(es decir, guerrero hereda de la clase personaje), y además añadirá:
o    Información: habilidad, puntería y una variable que lleve la cuenta de cuantos guerreros hay en cada momento(un contador).
o    Métodos:
- Un método para imprimir por pantalla toda la información del personaje.
·    Maga:    Guardará la misma información y tendrá los mismos métodos que Personaje(también hereda de la clase Personaje), y además añadirá:
o    Información: Magia, poder de la luz y una variable que lleve la cuenta de cuantas magas hay en cada momento(otro contador).
o    Métodos:
-   Un método para imprimir por pantalla toda la información del personaje.
-    Esta clase deberá además implementar la interfaz “Hechicero”(tiene que implementar los métodos que contenga la interfaz hechicero ).
·    Interfaz Hechicero:
o    Métodos:
-    Doblar magia.
-    Doblar poder de la luz.
·    Clase de prueba: El método “main” de esta clase de prueba dará un valor inicial al vigor de los personajes, después procederá a crear una maga. Debe incluir también un método personajeCambiado(Personaje), que simplemente imprima por pantalla las características del personaje cambiado.

CLASE PERSONAJE

//clase base Personaje, abstracta para que no se pueda instanciar.

public abstract class Personaje{
public int vida;
public int fuerza;
public int inteligencia;
public int astucia;
public static int vigor;//común a todos los personajes, por eso es estático

//Constructor
public Personaje(int vida, int fuerza, int inteligencia, int astucia, int v){
this.vida=vida;
this.fuerza=fuerza;
this.inteligencia=inteligencia;
this.astucia=astucia;
vigor=v;
}

//Método abstracto imprimir para implementar en clases derivadas
public abstract void imprimir();

//Métodos de acceso
public int dameVida(){
return vida;
}
public int dameFuerza(){
return fuerza;
}
public int dameInteligencia(){
return inteligencia;
}
public int dameAstucia(){
return astucia;
}
public int dameVigor(){

return vigor;
}

public void ponVida(int vida){
this.vida=vida;
}
public void ponFuerza(int fuerza){
this.fuerza=fuerza;
}
public void ponInteligencia(int inteligencia){
this.inteligencia=inteligencia;
}
public void ponAstucia(int astucia){
this.astucia=astucia;
}

//Método estático para cambiar el vigor de todos los personajes
public static void ponVigor(int v){
vigor=v;
}

public void personajeCambiado(Personaje personaje){
ponVida(personaje.vida);
ponFuerza(personaje.fuerza);
ponInteligencia(personaje.inteligencia);
ponAstucia(personaje.astucia);
ponVigor(personaje.vigor);

}

}//Fin clase

CLASE GUERRERO

//Clase guerro que hereda de Personaje
public class Guerrero extends Personaje{
private int habilidad;
private int punteria;
private static int contadorguerreros=0;

//Constructor solo con los atributos de la clase base
public Guerrero(int vida, int fuerza, int inteligencia, int astucia,int vigor){
super (vida, fuerza, inteligencia, astucia,vigor);

}
//Constructor con todos los atributos
public Guerrero(int vida, int fuerza, int inteligencia, int astucia,int vigor,int habilidad, int punteria){
this(vida, fuerza, inteligencia, astucia,vigor);
this.habilidad=habilidad;
this.punteria=punteria;
contadorguerreros++;
}

//Metodo imprimir
public void imprimir(){
System.out.println(“Características del guerrero: \nVida:”+vida+”\nFuerza: “+fuerza+”\nInteligencia: “+inteligencia+”\nAstucia :” +astucia+”\nVigor :”+vigor+”\nHabilidad :”+habilidad+”\nPuntería :”+punteria+”\nNumero de Guerreros :”+contadorguerreros+”\n\n”);
}
}//Fin clase

CLASE MAGA

//Clase maga hereda de personaje e implementa la interfaz hechicero

public class Maga extends Personaje implements Hechicero{

private int magia;
private int poder;
private static int contadormagas=0;

//Constructor solo con los atributos de la clase base
public Maga(int vida, int fuerza, int inteligencia, int astucia, int vigor){
super (vida, fuerza, inteligencia, astucia, vigor);
}

//Constructor con todos los atributos
public Maga(int vida, int fuerza, int inteligencia, int astucia, int vigor, int magia, int poder){
this(vida, fuerza, inteligencia, astucia, vigor);
this.magia=magia;
this.poder=poder;
contadormagas++;
}

//Método imprimir
public void imprimir(){
System.out.println(“Características de la maga: \nVida:”+vida+”\nFuerza: “+fuerza+”\nInteligencia: “+inteligencia+”\nAstucia :”+astucia+”\nVigor :”+vigor+”\nMagia :”+magia+”\nPoder :”+poder+”\nNumero de Magas :”+contadormagas+”\n\n”);
}

//Implemento los métodos de la interfaz hechicero
public int doblarMagia(){
magia+=magia;
return magia;
}

public int doblarPoder(){
poder+=poder;
return poder;
}
}//Fin clase

INTERFAZ HECHICERO

public interface Hechicero {
public int doblarMagia();
public int doblarPoder();

}

CLASE PRUEBA

//Clase de prueba

public class Prueba{

public void personajeCambiado(Personaje personaje){
/*No hace falta
if(personaje instanceof Guerrero){
personaje.imprimir();
}
if(personaje instanceof Maga){
personaje.imprimir();
}*/
personaje.imprimir();
}

//main
public static void main(String[]args){
Prueba p1=new Prueba();

//damos valor inicial al vigor de todos los personajes
Personaje.vigor=10;

//creamos una maga y un guerrero
Guerrero g1=new Guerrero(1,2,3,4,500,5,6);
Maga m1=new Maga(4,5,6,7,900,8,9);

//imprimimos y vemos que el último vigor que se actualiza es el que se guarda para todos los personajes
p1.personajeCambiado(m1);
p1.personajeCambiado(g1);

//cambiamos el vigor
m1.ponVigor(2);

//vemos que el vigor cambia para ambos personajes
p1.personajeCambiado(m1);
p1.personajeCambiado(g1);
}
}

CONCEPTOS FUNDAMENTALES:

Los conceptos que sobre todo se repasan en este ejercicio son orientación a objetos y herencia.

Recordamos como implementar interfaces(que creo que estaba un poco olvidado), el uso de clases y métodos abstractos, o que indica la palabra static y que efecto tiene tanto en atributos como en métodos.

Aunque ayuda mucho recordar conceptos como los dichos anteriormente, sigo pensando que nuestro principal problema es “descifrar” el enunciado, pero bueno imagino que con algo de práctica lo conseguiremos, no?