Mes: marzo 2021

Vamos a usar la clase que hemos hecho dentro de un programa.

El programa nos va a decir lo siguiente:

Bienvenido al simulador. Vamos a crear un ejército
¿Cuantos soldados quieres?
¿Cuantos lanceros quieres?
¿Cuantos capitanes quieres?

Creado el ejército con N soldados, N lanceros y N capitanes. El daño total de tu ejército es: Daño
¿Qué quieres hacer?
1- Atacar
2.- Retirada
0.- Salir

Has decidido ATACAR
1.- Adelante con todas las unidades
2.- Atacar con una sóla unidad
0.- Salir

¿Con qué unidad quieres atacar?
Has atacado con la unidad X que es un YY y has causado D daño

Has decidido RETIRADA
1.- Retirar todas las unidades
2.- Retirar una sóla unidad
0.- Salir

¿Qué unidad quieres retirar?
Has retirado la unidad XX que ahora causa D de daño

Vamos a modificar la clase Lancero y añadir un método ‘ataqueLanza’ void, sin parámetros y que simplemente nos muestra ‘Ataque con lanza’+danyo.

Una vez hecho esto en nuestro método ‘aLaCarga’ si la unidad es un Lancero, además de llamar a ‘carga’ llamamos a ‘ataqueLanza’

Vamos a modificar ‘aLaCarga’ y si una unidad tiene danyo 0 o menor que no ataque.

Vamos a comprobar en fortaleza y danyo que no puedan tener valores negativos.

Vamos a modificar el constructor de Ejército para que le pasemos el número de soldados, lanceros y capitanes. Haremos una sobrecarga: Si no nos pasan parámetros, como antes. Si nos pasan los parámetros ej: new Ejercito(3,2,1)-> Creará 3 soldados, 2 lanceros y 1 Capitan.

package com.trifulcas.ejercitos;

abstract public class Enemigo {
	private String nombre;
	private int fortaleza;
	private int danyo;

	/**
	 * @param nombre the nombre to set
	 */
	protected void setNombre(String nombre) {
		this.nombre = nombre;
	}

	/**
	 * @param fortaleza the fortaleza to set
	 */
	protected void setFortaleza(int fortaleza) {
		this.fortaleza = fortaleza;
	}

	/**
	 * @param danyo the danyo to set
	 */
	protected void setDanyo(int danyo) {
		if (danyo >= 0) {
			this.danyo = danyo;
		}
	}

	/**
	 * @return the nombre
	 */
	public String getNombre() {
		return nombre;
	}

	/**
	 * @return the fortaleza
	 */
	public int getFortaleza() {
		return fortaleza;
	}

	/**
	 * @return the danyo
	 */
	public int getDanyo() {
		return danyo;
	}

	public Enemigo() {
		// TODO Auto-generated constructor stub
	}

}

package com.trifulcas.ejercitos;

abstract public class Infanteria extends Enemigo {
	private int armadura;
	
	
	
	/**
	 * @param armadura the armadura to set
	 */
	protected void setArmadura(int armadura) {
		this.armadura = armadura;
	}

	public Infanteria() {
		// TODO Auto-generated constructor stub
	}
	
	abstract void cargar();
	abstract void retroceder();

}

package com.trifulcas.ejercitos;

abstract public class Caballeria extends Enemigo {
	private int velocidad;

	public Caballeria() {
		// TODO Auto-generated constructor stub
	}

}

package com.trifulcas.ejercitos;

abstract public class Arqueros extends Enemigo {
	private int distancia;

	public Arqueros() {
		// TODO Auto-generated constructor stub
	}

}

package com.trifulcas.ejercitos;

public class Soldado extends Infanteria {

	public Soldado() {
		setNombre("Soldado");
		setFortaleza(50);
		setDanyo(5);
		setArmadura(20);
	}

	@Override
	public void cargar() {
		System.out.println("Ataque de soldados "+getDanyo());
	}

	@Override
	public void retroceder() {
		System.out.println("¡¡Retirada!!!!");
		setFortaleza(getFortaleza()-5);
		setDanyo(getDanyo()-1);
	}

}

package com.trifulcas.ejercitos;

public class Lancero extends Infanteria {

	public Lancero() {
		setNombre("Lancero");
		setFortaleza(60);
		setDanyo(15);
		setArmadura(10);
	}

	@Override
	public void cargar() {
		System.out.println("Ataque de lanceros "+getDanyo());
	}

	@Override
	public void retroceder() {
		System.out.println("¡¡Retirada!!!!");
		setFortaleza(getFortaleza()-4);
		setDanyo(getDanyo()-2);
	}

}

package com.trifulcas.ejercitos;

public class Capitan extends Infanteria {

	public Capitan() {
		setNombre("Capitán");
		setFortaleza(70);
		setDanyo(10);
		setArmadura(40);
	}

	@Override
	public void cargar() {
		System.out.println("Ataque de capitán "+getDanyo());
	}

	@Override
	public void retroceder() {
		System.out.println("¡¡Retirada!!!!");
		setFortaleza(getFortaleza()-5);
		setDanyo(getDanyo()-2);
	}

}

package com.trifulcas.ejercitos;

public class Ejercito {

	Infanteria[] infanteria;
	
	public Ejercito() {
		infanteria=new Infanteria[15];
		for(int i=0;i<10;i++) {
			infanteria[i]=new Soldado();
		}
		for(int i=10;i<14;i++) {
			infanteria[i]=new Lancero();
		}
		infanteria[14]=new Capitan();
	}

}

Vamos a crear una clase ‘Ejercito’ que, de momento, va a tener como propiedad un array de Infanteria

En el constructor vamos a crear, en ese array, 10 soldados, 4 lanceros y 1 capitan.

Vamos a crear un método totalDanyo que nos devuelva el daño total de todas nuestras unidades.

Vamos a crear un método aLaCarga que activa el método cargar de todas nuestras unidades y nos muestre el daño total

Vamos a crear un método retirada que activa el método retirada de todas nuestras unidades.

Para probarlo en el main creamos un ejército y ejecutamos alguna vez los métodos a ver si hacen lo que tienen que hacer.

En la clase Infanteria vamos a poner los siguientes métodos ABSTRACTOS:

void cargar()

void retroceder()

De la clase Infanteria vamos a derivar las siguientes clases que no son abstractas.

Soldado
Tiene un constructor sin parámetros. En el nombre vamos a poner ‘Soldado’ en fortaleza 50, en danyo 5 y en armadura 20.

En el método cargar pondremos un mensaje que ponga ‘Ataque de soldados ‘+ lo que tenga en la popiedad danyo

En el método retroceder que escriba ‘Retirada!!!!’ y que disminuya 5 a la fortaleza y 1 al danyo.

Lancero
Tiene un constructor sin parámetros. En el nombre vamos a poner ‘Lancero’ en fortaleza 60, en danyo 15 y en armadura 10.

En el método cargar pondremos un mensaje que ponga ‘Ataque de lanceros’+ lo que tenga en la popiedad danyo

En el método retroceder que escriba ‘Retirada!!!!’ y que disminuya 4 a la fortaleza y 2 al danyo.

Capitan
Tiene un constructor sin parámetros. En el nombre vamos a poner ‘Capitan’ en fortaleza 70, en danyo 10 y en armadura 40.

En el método cargar pondremos un mensaje que ponga ‘Ataque de soldados ‘+ lo que tenga en la popiedad danyo

En el método retroceder que escriba ‘Retirada!!!!’ y que disminuya 5 a la fortaleza y 2 al danyo.

Vamos a crear unas clases para almacenar información de un juego.

Crearemos la clase ‘Enemigo’ con las siguientes propiedades:

String nombre
int fortaleza
int danyo

Todas privadas y con getters pero no con setters.

De ahí vamos a derivar las siguientes clases: ‘Infanteria’ ‘Caballeria’ ‘Arqueros’

Infanteria tendrá la propiedad:
int armadura
Caballeria tendrá la propiedad:
int velocidad
Arqueros tendrá la propiedad:
int distancia.

Todas las clases son ABSTRACTAS.

package com.trifulcas.clases;


abstract public class Repaso {

	private String nombre;
	
	public void saludo() {
		System.out.println("Hola");
	}

	// Método abstracto: contrato de obligación de implementar
	abstract public void despedida();
}

class RepasoExt extends Repaso{
	public void tonteria() {
		System.out.println("Probando");
	}
	public void despedida() {
		System.out.println("Adios");
	}
}
class RepasoExt2 extends Repaso{
	public void otraTonteria() {
		System.out.println("Buuu");
	}

	@Override
	public void despedida() {
		System.out.println("Chao");
		
	}
	
}

Uso:

package com.trifulcas.clases;

public class ProbarClases {

	public static void main(String[] args) {

		RepasoExt r = new RepasoExt();
		RepasoExt2 r2 = new RepasoExt2();

		// Esto da error porque es una clase abstracta
		// Y no se pueden instanciar
		// Repaso r3=new Repaso();

		r.saludo();
		r.tonteria();

		r.despedida();
		r2.saludo();
		r2.otraTonteria();
		r2.despedida();
		System.out.println("----------");
		Repaso[] lista= {new RepasoExt(),new RepasoExt2(),new RepasoExt()};
		for(Repaso el:lista) {
			el.despedida();
		}
	}

}

package com.trifulcas.clases;

public class Repaso {

	private String nombre;

	// COnstructor se invoca cuando instanciamos la clase
	// Ej. Repaso foo=new Repaso("pepe")
	public Repaso(String nombre) {
		this.nombre = nombre;
	}

	private void saludo() {
		System.out.println("Hola me llamo " + nombre);
	}

	private void despedida() {
		System.out.println("Chao pescao");
	}

	public void holayAdios() {
		saludo();
		despedida();
	}

	/**
	 * @return the nombre
	 */
	public String getNombre() {
		return nombre;
	}

	/**
	 * @param nombre the nombre to set
	 */
	public void setNombre(String nombre) {
		if (nombre.length() >= 4) {
			this.nombre = nombre;
		}
	}

}

class RepasoExtendida extends Repaso {
	private int veces;

	public RepasoExtendida(String nombre) {
		// super llama a la clase madre, en este caso al constructor
		super(nombre);
		veces = 4;
	}

	// Sobreescribo el método holayAdios
	public void holayAdios() {
		for (int i = 0; i < veces; i++) {
			// LLamo a la función holaYAdios de la clase madre
			super.holayAdios();
		}
	}
}

class RepasoExtendida2 extends Repaso {
	private int veces;

	public RepasoExtendida2(String nombre) {
		// super llama a la clase madre, en este caso al constructor
		super(nombre);
		veces = 4;
	}

	// Sobreescribo el método holayAdios
	public void holayAdios() {
		System.out.println("Soy la 2 y digo hola");
	}
}

class RepasoExtendida3 extends Repaso {
	private int veces;

	public RepasoExtendida3(String nombre) {
		// super llama a la clase madre, en este caso al constructor
		super(nombre);
		veces = 4;
	}

	// Sobreescribo el método holayAdios
	public void holayAdios() {
		System.out.println("Hola y adios");
	}
}

Uso:

package com.trifulcas.clases;

public class Repaso {

	private String nombre;

	// COnstructor se invoca cuando instanciamos la clase
	// Ej. Repaso foo=new Repaso("pepe")
	public Repaso(String nombre) {
		this.nombre = nombre;
	}

	private void saludo() {
		System.out.println("Hola me llamo " + nombre);
	}

	private void despedida() {
		System.out.println("Chao pescao");
	}

	public void holayAdios() {
		saludo();
		despedida();
	}

	/**
	 * @return the nombre
	 */
	public String getNombre() {
		return nombre;
	}

	/**
	 * @param nombre the nombre to set
	 */
	public void setNombre(String nombre) {
		if (nombre.length() >= 4) {
			this.nombre = nombre;
		}
	}

}

class RepasoExtendida extends Repaso {
	private int veces;

	public RepasoExtendida(String nombre) {
		// super llama a la clase madre, en este caso al constructor
		super(nombre);
		veces = 4;
	}

	// Sobreescribo el método holayAdios
	public void holayAdios() {
		for (int i = 0; i < veces; i++) {
			// LLamo a la función holaYAdios de la clase madre
			super.holayAdios();
		}
	}
}

class RepasoExtendida2 extends Repaso {
	private int veces;

	public RepasoExtendida2(String nombre) {
		// super llama a la clase madre, en este caso al constructor
		super(nombre);
		veces = 4;
	}

	// Sobreescribo el método holayAdios
	public void holayAdios() {
		System.out.println("Soy la 2 y digo hola");
	}
}

class RepasoExtendida3 extends Repaso {
	private int veces;

	public RepasoExtendida3(String nombre) {
		// super llama a la clase madre, en este caso al constructor
		super(nombre);
		veces = 4;
	}

	// Sobreescribo el método holayAdios
	public void holayAdios() {
		System.out.println("Hola y adios");
	}
}

package com.trifulcas.clases;


// Una clase abstracta no se puede instanciar
// Puede tener propiedades y métodos no abstractos
// Puede tener métodos abstractos
abstract public class Figura {
	private String nombre;
	/**
	 * @param nombre the nombre to set
	 */
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
	public String getNombre() {
		return nombre;
	}
	// Puede tener métodos abstractos
	// Un contrato para que las clases derivadas implementen el método
	// Los métodos abstractos no incorporan código
	abstract public double area();

}

class Cuadrado extends Figura{
	private int lado;

	public Cuadrado(int lado) {
		super();
		this.lado = lado;
		setNombre("cuadrado");
	}

	@Override
	public double area() {
		
		return lado*lado;
	}
	
}
class Circulo extends Figura{
	private int radio;

	public Circulo(int radio) {
		super();
		this.radio = radio;
		setNombre("círculo");

	}

	@Override
	public double area() {
		return Math.PI*radio*radio;
	}
	
}

Uso:

Figura[] ejercicios= {new Cuadrado(2),new Circulo(3),new Cuadrado(4)};
		
		for(Figura f:ejercicios) {
			System.out.println(f.getNombre()+" | "+f.area());
		}

package com.trifulcas.clases;

public class Animal {

	public void sonido() {
		System.out.println("Sonido del animal");
	}
}

class Perro extends Animal{
	public void sonido() {
		System.out.println("Guau");
	}
	public void aullido() {
		System.out.println("Auuuuuu");
	}
}
class Gato extends Animal{
	public void sonido() {
		System.out.println("Miau");
	}
	public void ronroneo() {
		System.out.println("Rrrrrr");
	}
}
class Pato extends Animal{
	public void sonido() {
		System.out.println("CuaCua");
	}
}
class Ornitorrinco extends Animal{
	
}

Prueba:

public static void main(String[] args) {

		Animal misifu = new Gato();  // Yo puedo asignar a una variable Animal una de tipo Gato
		misifu.sonido();
		
		Animal[] granja= {new Perro(),new Gato(),new Pato(),new Pato()};
		
		// Polimorfismo porque aunque llamo al mismo método (sonido)
		// Tiene un comportamiento diferente dependiendo de la clase
		for(int i=0;i<granja.length;i++) {
			granja[i].sonido();
		}

	}

Otra prueba:

public static void main(String[] args) {

	Animal chucho=new Perro(); // Se puede hacer porque los perros son animales
	// Porque la clase Perro deriva de la clase Animal
	Animal gatito=new Gato();
	Gato misifu=new Gato();
	Animal pato= new Pato();
	
	Ornitorrinco or=new Ornitorrinco();
	
	jaleo(chucho);
	jaleo(gatito);
	jaleo(misifu);
	jaleo(pato);
	jaleo(or);
	
	}
	public static void jaleo(Animal animal) {
		// El método sonido hace uso del polimorfismo. Es el mismo para todos
		// Pero cada tipo de animal hace algo diferente
		// ¿Cómo haría yo para que, si es un ornitorrinco, no haga sonido?
		if (!(animal instanceof Ornitorrinco)) {
			animal.sonido();
		}
		// Yo en animal no tengo aullido pero....
		// Puedo saber si me están pasando como parámetro un perro
		// Y si es así hacer un aullido
		if (animal instanceof Perro) {
			// Son dos maneras de hacer lo mismo
			Perro temp=(Perro) animal; //Conversión implícita que puedo hacer de manera segura porque sé que es un Perro gracias al instanceof
			temp.aullido();
			
			((Perro) animal).aullido();
		}
		
		if (animal instanceof Gato) {
			((Gato) animal).ronroneo();
		}
	}

Otro ejemplo con las clases que hemos visto en el ejercicio anterior:

	Empleado[] empresa=new Empleado[3];
		
		empresa[0]=new Comercial("Eva","111",1000);
		empresa[1]=new Comercial("Ana","222",1200);
		empresa[2]=new Administrativo("Juan","333",2000,3);
		
		for(Empleado empleado:empresa) {
			System.out.println(empleado.getNombre()+" | "+empleado.sueldoNeto());
		}