Autor: Juan Pablo Fuentes

https://beginnersbook.com/java-collections-tutorials/

https://www.geeksforgeeks.org/collections-in-java-2/

https://www.journaldev.com/1260/collections-in-java-tutorial

https://howtodoinjava.com/

https://stackoverflow.com/questions/21974361/which-java-collection-should-i-use

Vamos a crear las siguientes clases

Una clase llamada ManipularCadenas que sólo tendrá una variable String privada que se incializa en el contructor.

Tendrá los siguientes métodos públicos:

String getCadena()-> Getter de la cadena (pero no setter)

void repetir(String cadena)

Si nuestra cadena tiene dentro la cadena que le pasamos, la repite. Si no, no hace nada.
Ejemplo: Si mi cadena es ‘hola que tal’
repetir(«cacahuete»)-> No modifica la cadena
repetir(‘que’)-> Mi cadena pasa a valer ‘hola queque tal’
Sólo la primera aparición

void erosionar()

Nos elimina el primer y el último carácter de la cadena si tiene una longitud mayor o igual a 2

Si mi cadena es ‘hola que tal’->’ola que ta’

void agujero

Nos elimina el caracter que están en el medio. Si la longitud es par, los dos que están en el medio

Si mi cadena es ‘hola que tal’->’hola e tal’

Todas estas funciones modifican el valor de la cadena dentro de la clase. Ni imprimen por pantalla ni devuelven nada. Si queremos ver si funcionan necesitaremos llamar al getter para ver el valor.

Estamos dentro de una clase, que tendrá su propio archivo. Para probarla vamos a crear en otra parte un Main y crearemos una instancia de la clase.

Vamos a crear una clase CitasMedico que va a tener como propiedades un array de Fechas.

Vamos a tener un constructor sobrecargado de tres maneras:
Sin parámetros
Parámetro String
Parámetro LocalDate

En este último crearemos en el array de fechas 12 fechas de la manera siguiente:
El primer elemento es la fecha que nos pasan.
El segundo elemento es la fecha que nos pasan mas 15 días.
El tercero lo mismo más 15 días.
Y así sucesivamente.

Si alguno de los elementos cae en fin de semana se pasa al lunes siguiente.
Imaginemos que lo hacemos con la fecha de hoy. Tendríamos las siguientes fechas:
6/4/2021
21/4/2021
6/5/2021
21/5/2021
5/6/2021–> Es sábado, así que pasa a ser 7/6/2021
20/5/2021–>Es domingo, así que pasa a ser 21/5/2021

El constructor con un string parsea el string a fecha y llama al constructor de fecha.
EL constructor sin parámetros llama al constructor de fecha con fecha de hoy.

Además crearemos un método público próxima cita que nos devuelva, de nuestro array de fechas, la siguiente que nos tocaría.

LocalDate proximaCita()

La clase ManipulaCadena:

package com.trifulcas.ejercicio01;

public class ManipulaCadenas {
	private String cadena;

	public ManipulaCadenas(String cadena) {
		this.cadena = cadena;
	}

	public String getCadena() {
		return cadena;
	}

	/**
	 * Busca la cadena dentro de la propiedad de la clase Y si está, la repite
	 * 
	 * @param cad La cadena a buscar
	 * 
	 */
	public void repetir(String cad) {
		// Averiguar si la cadena que me pasan como parámetro
		// Está dentro de la cadena de la clase
		// Si no está no hago nada
		// Si está inserto la cadena que me pasan en la posición
		// de la cadena
		int pos = cadena.indexOf(cad);
		if (pos != -1) {
			// '123456789' y busco '34' está en la posición '2'
			// Yo tengo que insertar '34' en la posición 2
			// Manera 1 usando insert de StringBuilder
			StringBuilder temp = new StringBuilder(cadena);
			temp.insert(pos, cad); // '12343456789'
			// cadena = temp.toString();
			// Manera 2 lo mismo pero compacto
			cadena = new StringBuilder(cadena).insert(pos, cad).toString();

			// Manera 3 usando substring
			// cadena = cadena.substring(0, pos) + cad + cadena.substring(pos);
		}

	}

	/**
	 * Elimina el primer carácter y el último de la cadena si su longitud es mayor a
	 * 2
	 */
	public void erosionar() {
		// Compruebo si tiene longitud>2
		// Si es así quito el caracter 1º y último
		if (cadena.length() >= 2) {
			// No me complico y uso substring
			// cadena = cadena.substring(1, cadena.length() - 1);

			// Me aprovecho de las funcionalidades de StringBuilder
			cadena = new StringBuilder(cadena).deleteCharAt(cadena.length() - 1).deleteCharAt(0).toString();
		}
	}

	/**
	 * Elimina los carcateres centrales Si la longitud de la cadena es par, los dos
	 * del medio Si es impar el carácter central
	 */
	public void agujero() {
		if (cadena.length() > 0) {
			// Par o impar
			// Si es par quitar los caracteres del medio
			// Si es impar quitar el carácter del medio
			if (cadena.length() % 2 == 0) {
				// Es par: los dos del medio
				// 'abcdef' 2,3 longitud: 6 6/2-1
				// 'abcd' 1,2 longitud 4 4/2-1
				// 'abcdefgh' 3,4 longitud 8 8/2-1
				int pos = cadena.length() / 2 - 1;
				cadena = new StringBuilder(cadena).delete(pos, pos + 2).toString();

			} else {
				// Es impar: el del medio
				// 'abcde' 2 longitud 5 5/2->2
				// 'abcdefg' 3 longitud es 7/2 ->3
				int pos = (cadena.length() - 1) / 2;
				cadena = new StringBuilder(cadena).deleteCharAt(pos).toString();
			}
		}
	}
}

Probar esta clase:

package com.trifulcas.ejercicio01;

public class Test {

	public static void main(String[] args) {
		ManipulaCadenas temp=new ManipulaCadenas("Hola que tal");
	
		ManipulaCadenas numeros=new ManipulaCadenas("123456789");

		temp.repetir("que");
		System.out.println(temp.getCadena());
		temp.erosionar();
		System.out.println(temp.getCadena());
		temp.agujero();
		System.out.println(temp.getCadena());
		numeros.agujero();
		System.out.println(numeros.getCadena());
	}

}

package com.trifulcas.ejercicio01;

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.util.Arrays;

public class CitasMedico {
	private LocalDate[] fechas;

	public CitasMedico() {
		// LLamo al constructor con parámetro fecha con la fecha de hoy
		this(LocalDate.now());
	}

	public CitasMedico(String fecha) {
		// Parseo la fecha y llamo al constructor con parámetro fecha
		this(LocalDate.parse(fecha));
	}

	public CitasMedico(LocalDate fecha) {
		// Crearé el array con un tamaño de 12
		// Voy a ir añadiendo las fechas sumando 15 días
		// Hay que comprobar que no sea fin de semana
		this(fecha, 15);
	}

	public CitasMedico(LocalDate fecha, int dias) {
		// Crearé el array con un tamaño de 12
		// Voy a ir añadiendo las fechas sumando 15 días
		// Hay que comprobar que no sea fin de semana
		fechas = new LocalDate[12];
		fechas[0] = siguienteLaborable(fecha);
		for (int i = 1; i < fechas.length; i++) {
			fechas[i] = siguienteLaborable(fechas[i - 1].plusDays(dias));
		}
	}

	/**
	 * Busca el siguiente día laborable. Si la fecha es sábado o domingo pasa al
	 * lunes
	 * 
	 * @param fecha La fecha a comprobar
	 * @return El siguiente día laborable a la fecha
	 */
	private LocalDate siguienteLaborable(LocalDate fecha) {

		// Si es sábado pasamos al lunes sumando dos días
		if (fecha.getDayOfWeek() == DayOfWeek.SATURDAY) {
			fecha = fecha.plusDays(2);
		}
		// Si es domingo pasamos al lunes sumando 1 día
		if (fecha.getDayOfWeek() == DayOfWeek.SUNDAY) {
			fecha = fecha.plusDays(1);
		}
		return fecha;
	}

	public LocalDate proximaCita() {
		// Devolveremos la próxima cita a partir de hoy	
		for(int i=0;i<fechas.length;i++) {
			if (fechas[i].isAfter(LocalDate.now())) {
				return fechas[i];
			}
		}
		return null;
	}

	public LocalDate proximaCitaFeten() {
		// Devolveremos la próxima cita a partir de hoy	
		LocalDate res=null;
		for(int i=0;i<fechas.length;i++) {
			if (fechas[i].isAfter(LocalDate.now())) {
				res=fechas[i];
				break;
			}
		}
		return res;
	}
	
	public LocalDate proximaCitaDesordenada() {
		// Devolveremos la próxima cita a partir de hoy	
		LocalDate res=null;
		for(int i=0;i<fechas.length;i++) {
			if (fechas[i].isAfter(LocalDate.now())) {
				if (res==null || res.isAfter(fechas[i]))
				res=fechas[i];
			}
		}
		return res;
	}
	public String toString() {
		return Arrays.toString(fechas);
	}
}

Probar la clase:

public static void main(String[] args) {
		CitasMedico temp = new CitasMedico(LocalDate.now());
		CitasMedico temp2 = new CitasMedico("2021-03-02");
		CitasMedico temp3=new CitasMedico();

		CitasMedico temp4 = new CitasMedico(LocalDate.now(),20);

		System.out.println(temp2);
		System.out.println(temp2.proximaCita());
	}

Haced una función a la que le pasemos una fecha y nos diga si es un día par o impar.

public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		
		
		System.out.println("Introduce fecha para saberlo");
		String f=in.next();
		LocalDate fecha=LocalDate.parse(f);
		System.out.println(esDiaPar(fecha));
		System.out.println(esDiaPar(LocalDate.parse("2020-01-09")));
		System.out.println(esDiaPar(LocalDate.parse("2020-01-10")));
	}
	
	// Función que nos diga si un día concreto es un fin de semana
	
	public static boolean finDeSemana(LocalDate fecha) {
		return fecha.getDayOfWeek()==DayOfWeek.SATURDAY ||
				fecha.getDayOfWeek()==DayOfWeek.SUNDAY;
	}
	public static int dia(LocalDate fecha) {
		return fecha.getDayOfMonth();
	}
	
	
	public static String esDiaPar(LocalDate fecha) {
		// Obtener el día
		int dia=fecha.getDayOfMonth();
		if (dia%2==0) {
			return "Par";
		} else {
			return "Impar";
		}
	}

public static void main(String[] args) {
Scanner in=new Scanner(System.in);
System.out.println("Introduce tu fecha de cumpleaños en formato ISO");
String f=in.next();
LocalDate fecha = LocalDate.parse(f);

System.out.println("Naciste en "+fecha.getDayOfWeek());
fecha=LocalDate.now();
System.out.println("Mañana será "+fecha.plusDays(1));
System.out.println("La semana que viene será "+fecha.plusWeeks(1));
System.out.println("El año que viene será "+fecha.plusYears(1));
System.out.println("Hoy es el dia "+dia(LocalDate.now())+" del mes");


}

public static int dia(LocalDate fecha) {
return fecha.getDayOfMonth();
}

public static void main(String[] args) {

// Para crear una variable que permita guardar una fecha usamos
// LocalDate
// fecha Tiene el día de hoy LocalDate tiene algunos métodos estáticos
// Y uno de ellos es now() que nos devuelve la fecha de hoy
LocalDate fecha = LocalDate.now();
// Otra manera de crear una fecha es utilizar of
// Usa de parámetros: año, mes y día
LocalDate fecha2 = LocalDate.of(2019, 02, 20);
// Otra manera más es utilizar parse que intenta convertir
// Una cadena en una fecha
LocalDate fecha3 = LocalDate.parse("2015-08-10");

System.out.println(fecha);
// Imprimir en formato ISO (estándar, como el mysql)
System.out.println(fecha.format(DateTimeFormatter.ISO_DATE));
System.out.println(fecha.format(DateTimeFormatter.ISO_LOCAL_DATE));
// Formatear con un patrón definido (dd-MM-yyy)
System.out.println(fecha.format(DateTimeFormatter.ofPattern("dd-MM-yyy")));
// Formatear como lo tengamos configurado en el sistema (y tenemos largo, medio
// o corto)
System.out.println(fecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL)));
System.out.println(fecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM)));
System.out.println(fecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT)));

System.out.println(fecha2);
System.out.println(fecha3);

// A una fecha le puedo añadir o quitar días, meses, semanas y años
LocalDate manyana = LocalDate.now().plusDays(1);
LocalDate ayer = LocalDate.now().minusDays(1);
LocalDate semana_que_viene = LocalDate.now().plusWeeks(1);
System.out.println(manyana);
System.out.println(ayer);
System.out.println(semana_que_viene);

// Puedo añadir o restar unidades de tiempo
LocalDate mesAnterior = LocalDate.now().minus(1, ChronoUnit.MONTHS);
// Podemos añadir Periodos que es parecido: permite añadir
// meses, dias, años o combinaciones
LocalDate finalDate = manyana.plus(Period.ofDays(5));

System.out.println(finalDate);
System.out.println(mesAnterior);

// Puedo obtener de una fecha cualquier valor que me interese
// El día de la semana es una clase que nos permite obtener el nombre
// Y el número
DayOfWeek dia = LocalDate.parse("2016-06-12").getDayOfWeek();
// El día del mes es un entero
int mes = LocalDate.parse("2016-06-12").getDayOfMonth();

// En el caso de los meses
int m = LocalDate.parse("2016-06-12").getMonthValue();
Month mon = LocalDate.parse("2016-06-12").getMonth();

// Las clases DayOfWeek y Month nos permiten recuperar el nombre
// Del día de la semana y del mes (en inglés) pero también
// Su número
System.out.println(dia);
System.out.println(dia.ordinal());
System.out.println(mes);
System.out.println(m);
System.out.println(mon);
System.out.println(mon.ordinal());

// Saber si un año es bisiesto
boolean bisiesto = LocalDate.now().isLeapYear();
System.out.println(bisiesto);
boolean antes = LocalDate.parse("2016-06-12").isBefore(LocalDate.parse("2016-06-11"));
System.out.println(antes);
boolean despues = LocalDate.parse("2016-06-12").isAfter(LocalDate.parse("2016-06-11"));
System.out.println(despues);
// El with nos permite obtener el primer día y el último del mes
LocalDate primerDiaMes = LocalDate.parse("2016-06-12").with(TemporalAdjusters.firstDayOfMonth());
System.out.println(primerDiaMes);

// Formato de fecha Y hora
LocalDateTime fechaHora = LocalDateTime.parse("2016-06-12T10:00");
System.out.println(fechaHora);
System.out.println(fechaHora.format(DateTimeFormatter.ofPattern("dd-MM-yyy HH:mm")));
System.out.println(fechaHora.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM)));
System.out.println(fechaHora.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT)));
LocalDateTime inicioDia = LocalDate.parse("2016-06-12").atStartOfDay();
System.out.println(inicioDia);

// También tenemos la clase sólo para la hora
LocalTime ahora = LocalTime.now();
System.out.println(ahora);
// Podemos obtenerla de una cadena
LocalTime seisYMedia = LocalTime.parse("06:30");
System.out.println(seisYMedia);
// Podemos indicar hora, minutos y segundos
LocalTime seisYMedia2 = LocalTime.of(6, 30);
System.out.println(seisYMedia2);
LocalTime seisYMedia3 = LocalTime.of(6, 30,15);
System.out.println(seisYMedia3);
//Podemos añadir Cronounidades
LocalTime sieteYMedia = LocalTime.parse("06:30").plus(1, ChronoUnit.HOURS);
System.out.println(sieteYMedia);

// Podemos añadir duraciones, lo que en Date es Period
LocalTime siete = seisYMedia.plus(Duration.ofMinutes(30));
System.out.println(siete);

}

public static void main(String[] args) {
Scanner in=new Scanner(System.in);

// ¿En qué día caen los primeros de cada mes este año?
for(int i=1;i<12;i++) {
LocalDate fecha= LocalDate.of(2021, i, 1);
System.out.println(fecha.getDayOfWeek());
System.out.println(finDeSemana(fecha));
}

System.out.println("Introduce fecha factura");
String f=in.next();
System.out.println("El vencimiento es dentro de 15 días:");
LocalDate fecha=LocalDate.parse(f).plusDays(15);
System.out.println(fecha.format(DateTimeFormatter.ofPattern("dd/MM/yyyy")));
System.out.println(fecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL)));
System.out.println(fecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG)));
System.out.println(fecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM)));
System.out.println(fecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT)));
if (finDeSemana(fecha)) {
System.out.println("Que cae en fin de semana");
}

}

// Función que nos diga si un día concreto es un fin de semana

public static boolean finDeSemana(LocalDate fecha) {
return fecha.getDayOfWeek()==DayOfWeek.SATURDAY ||
fecha.getDayOfWeek()==DayOfWeek.SUNDAY;
}
public static int dia(LocalDate fecha) {
return fecha.getDayOfMonth();
}

https://www.campusmvp.es/recursos/post/como-manejar-correctamente-fechas-en-java-el-paquete-java-time.aspx

https://www.javatpoint.com/java-date

https://www.baeldung.com/java-8-date-time-intro

https://javautodidacta.es/tiempo-en-java-localdate-localtime/

Formatos:

Crear una función esPalindromo que nos diga si una cadena es palíndroma:

boolean esPalindromo(String cadena)

esPalindromo(«Viva la paella»)->false
esPalindromo(«Sara Baras»)->true

public static void main(String[] args) {
		String[] cadenas= {"No subas, abusón","Yo dono rosas, oro no doy","No traces en ese cartón"};
		System.out.println(esPalindromo("Viva la paella"));
		System.out.println(esPalindromo("Sara Baras"));
		System.out.println(esPalindromo("Isaac no ronca así"));
		for(String cadena:cadenas) {
			System.out.println(esPalindromo(cadena));
		}
		System.out.println("Con clase");
		Palindromo pal=new Palindromo("Dábale arroz a la zorra el abad");
		System.out.println(pal.esPalindromo());

	}

	// Una cadena es palíndromo si es igual a ella misma invertida
	public static boolean esPalindromo(String cadena) {
		cadena = normalizar(cadena);
		StringBuilder foo = new StringBuilder(cadena);
		return cadena.equals(foo.reverse().toString());
	}
	
	// He creado una función normalizar para otros caracteres
	public static String normalizar(String cadena) {
		return cadena.toLowerCase().replace("á", "a").replace("é", "e").replace("í", "i").replace("ó", "o")
				.replace("ú", "u").replace("ü","u").replace(" ", "").replace(".", "").replace(",", "");
	}
	
	// La estructura if (condicion) return true else return false es igual a:
	// return condicion

public class Palindromo {
	private String cadena;
	
	public Palindromo(String cadena) {
		this.cadena=cadena;
	}
	
	public boolean esPalindromo() {
		String cad = normalizar(cadena);
		StringBuilder foo = new StringBuilder(cad);
		return cad.equals(foo.reverse().toString());
	}
	private String normalizar(String cadena) {
		return cadena.toLowerCase().replace("á", "a").replace("é", "e").replace("í", "i").replace("ó", "o")
				.replace("ú", "u").replace("ü","u").replace(" ", "").replace(".", "").replace(",", "");
	}
}

https://www.journaldev.com/538/string-vs-stringbuffer-vs-stringbuilder

https://stackabuse.com/string-vs-stringbuilder-vs-stringbuffer-in-java/

https://www.javatpoint.com/StringBuffer-class

https://www.javatpoint.com/StringBuilder-class

Ejemplo funciones de cadena:

String s = "JavadesdeCero";
		// o String s= new String ("JavadesdeCero");
		// Devuelve la cantidad de caracteres en la Cadena.
		System.out.println("String length = " + s.length());
		// Devuelve el carácter en el índice i.
		System.out.println("Character at 3rd position = " + s.charAt(3));
		// Devuelve la subcadena del carácter índice i-ésimo
		// al final de la cadena
		System.out.println("Substring " + s.substring(3));
		// Devuelve la subcadena del índice i a j-1.
		System.out.println("Substring  = " + s.substring(2, 5));
		// Concatena string2 hasta el final de string1.
		String s1 = "Java";
		String s2 = "desdeCero";
		String s3="Ja";
		s3+="va";
		System.out.println(s1==s3);
		System.out.println(s1.equals(s3));
		System.out.println(s1.compareTo(s3));
		System.out.println("String concatenado  = " + s1.concat(s2));
		// Devuelve el índice dentro de la cadena de
		// la primera aparición de la cadena especificada.
		String s4 = "Java desde Cero";
		System.out.println("Índice de Cero: " + s4.indexOf("Cero"));
		// Devuelve el índice dentro de la cadena de
		// la primera aparición de la cadena especificada,
		// comenzando en el índice especificado.
		System.out.println("Índice de a  = " + s4.indexOf('a', 4));
		// Comprobando la igualdad de cadenas
		Boolean out = "Java".equals("java");
		System.out.println("Comprobando la igualdad: " + out);
		out = "Java".equals("Java");
		System.out.println("Comprobando la igualdad: " + out);
		out = "Java".equalsIgnoreCase("jaVA");
		System.out.println("Comprobando la igualdad: " + out);
		int out1 = s1.compareTo(s2);
		System.out.println("Si s1 = s2: " + out1);
		// Conversión de cases
		String palabra1 = "JavadesdeCero";
		System.out.println("Cambiando a minúsculas: " + palabra1.toLowerCase());
		// Conversión de cases
		String palabra2 = "JavadesdeCero";
		System.out.println("Cambiando a MAYÚSCULAS: " + palabra1.toUpperCase());
		// Recortando la palabra
		String word4 = " JavadesdeCero ";
		System.out.println("Recortando la palabra: " + word4.trim());
		// Reemplazar caracteres
		String str1 = "YavadesdeCero";
		System.out.println("String Original: " + str1);
		String str2 = "YavadesdeCero".replace('Y', 'J');
		System.out.println("Reemplazando Y por J -> " + str2);

Ejemplos de StringBuffer:

// Siempre es con constructor
		StringBuffer sb=new StringBuffer("Hola ");
		// Añadir cadenas a una cadena con append
		sb.append("que tal"); 
		// Ni StringBuffer ni StringBuilder tienen el operador +
		//sb+=" Mu bien";
		System.out.println(sb);
		// Inserta 'Java' en la posición 1 : HJavaola que tal
		sb.insert(1,"Java");  
		System.out.println(sb);
		// Reemplaza lo que hay entre las posiciones 4 y 6 con '###'
		// El resultado es HJav###la que tal
		sb.replace(4,6,"###");  
		System.out.println(sb);
		// Borra lo que hay entre las posiciones 1 y 3: Hv###la que tal
		sb.delete(1,3);  
		System.out.println(sb);
		// Invertir cadena: lat euq al###vH
		sb.reverse();  
		System.out.println(sb);
		
		String nombre="Eva Pi";
		
		StringBuffer temp=new StringBuffer(nombre);
		nombre=temp.reverse().toString();
		System.out.println(nombre);

Ejemplos de StringBuilder:

	// Creo una cadena con el constructor
		StringBuilder sb = new StringBuilder("Hola ");
		// Añado con append (nunca con el operador +)
		sb.append("que tal");
		System.out.println(sb);
		// Inserto 'Java' en la posición 1
		sb.insert(1, "Java");
		System.out.println(sb);
		// Reemplazo entre la posición 4 y 6 con '###'
		sb.replace(4, 6, "###");
		System.out.println(sb);
		// Elimino lo que hay entre 1 y 3
		sb.delete(1, 3);
		System.out.println(sb);
		// Invierto la cadena
		sb.reverse();
		System.out.println(sb);

		String nombre = "Eva Pi";

		StringBuilder temp = new StringBuilder(nombre);
		nombre = temp.reverse().toString();
		System.out.println(nombre);

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) {
		if (fortaleza >= 0) {
			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 public void cargar();
	abstract public void retroceder();

}

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());
	}
	public void ataqueLanza() {
		System.out.println("Ataque con lanza "+getDanyo());
	}

	@Override
	public void retroceder() {
		System.out.println("¡¡Retirada!!!!");
		// Si usamos el setter para modificar el valor centralizamos
		// la modificación y es más fácil controlar las restricciones
		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 {

	private Infanteria[] infanteria;

	public Ejercito() {
		// Me aprovecho del mismo constructor: palabra clave this
		// La usamos para llamar a los constructores de la clase
		this(10,4,1);
	}

	public Ejercito(int soldados, int lanceros, int capitanes) {
		int total = soldados + lanceros + capitanes;
		infanteria = new Infanteria[total];
		for (int i = 0; i < soldados; i++) {
			infanteria[i] = new Soldado();
		}
		for (int i = soldados; i < soldados+lanceros; i++) {
			infanteria[i] = new Lancero();
		}
		for (int i = soldados+lanceros; i < total; i++) {
			infanteria[i] = new Capitan();
		}
	}

	public int getTotalUnidades() {
		return infanteria.length;
	}
	public int totalDanyo() {
		int total = 0;
		for (Infanteria unidad : infanteria) {
			total += unidad.getDanyo();
		}
		return total;
	}

	public void aLaCarga() {
		for (Infanteria unidad : infanteria) {
			// Si tiene daño ataca, si no no
			if (unidad.getDanyo() > 0) {
				unidad.cargar();
				// Compruebo si unidad es una instancia de Lancero
				if (unidad instanceof Lancero) {
					// Conversión implícita 'al vuelo'
					((Lancero) unidad).ataqueLanza();

					// Implícita sin hacerlo al vuelo
					// Lancero temp=(Lancero) unidad;
					// temp.ataqueLanza();
				}
			}
		}
		System.out.println("Total daño: " + totalDanyo());
	}

	public void retirada() {
		for (Infanteria unidad : infanteria) {
			unidad.retroceder();
		}
	}
	public Infanteria getUnidad(int i) {
		return infanteria[i];
	}
	public void cargarUnidad(int i) {
		infanteria[i].cargar();
	}
}

package com.trifulcas.testEjercito;

import java.util.Scanner;

import com.trifulcas.ejercitos.Ejercito;

public class Test {
	static Scanner in;

	public static void main(String[] args) {
		in = new Scanner(System.in);
		System.out.println("Bienvenido al simulador. Vamos a crear un ejército");
		System.out.println("¿Cuantos soldados quieres?");
		int soldados = in.nextInt();
		System.out.println("¿Cuantos lanceros quieres?");
		int lanceros = in.nextInt();
		System.out.println("¿Cuantos capitanes quieres?");
		int capitanes = in.nextInt();
		Ejercito miEjercito = new Ejercito(soldados, lanceros, capitanes);
		System.out.println("Ejercito creado con " + soldados + " soldados " + lanceros + " lanceros y " + capitanes
				+ " capitanes");
		System.out.println("El daño total es " + miEjercito.totalDanyo());
		int respuesta;
		do {
			respuesta = menu("¿Qué quieres hacer?\r\n" + "1- Atacar\r\n" + "2.- Retirada\r\n" + "0.- Salir");
			if (respuesta == 1) {
				atacar(miEjercito);
			} else if (respuesta == 2) {
				retroceder(miEjercito);
			} else if (respuesta != 0) {
				System.out.println("Los valores válidos son 1,2 y 0");
			}
		} while (respuesta != 0);
	}

	public static int menu(String texto) {
		System.out.println(texto);
		int respuesta = in.nextInt();
		return respuesta;
	}

	public static void atacar(Ejercito miEjercito) {
		int respuesta;
		do {
			respuesta = menu(
					"Has decido atacar\r\n" + "1- Con todas las unidades\r\n" + "2.- Con una unidad\r\n" + "0.- Salir");

			if (respuesta == 1) {
				miEjercito.aLaCarga();
			} else if (respuesta == 2) {
				System.out.println("¿Con qué unidad quieres atacar (1-" + miEjercito.getTotalUnidades() + ") ?");
				int unidad = in.nextInt();
				if (unidad >= 1 && unidad <= miEjercito.getTotalUnidades()) {
					miEjercito.getUnidad(unidad - 1).cargar();
				} else {
					System.out.println("Unidad fuera de rango");
				}
				// Otra manera: miEjercito.cargarUnidad(unidad);)
			} else if (respuesta != 0) {
				System.out.println("Los valores válidos son 1,2 y 0");
			}
		} while (respuesta != 0);
	}

	public static void retroceder(Ejercito miEjercito) {
		int respuesta;
		do {
			respuesta = menu("Has decido retroceder\r\n" + "1- Con todas las unidades\r\n" + "2.- Con una unidad\r\n"
					+ "0.- Salir");

			if (respuesta == 1) {
				miEjercito.retirada();
				;
			} else if (respuesta == 2) {
				System.out.println("¿Con qué unidad quieres retroceder (1-" + miEjercito.getTotalUnidades() + ") ?");
				int unidad = in.nextInt();
				if (unidad >= 1 && unidad <= miEjercito.getTotalUnidades()) {
					miEjercito.getUnidad(unidad-1).retroceder();
				} else {
					System.out.println("Unidad fuera de rango");
				}
			} else if (respuesta != 0) {
				System.out.println("Los valores válidos son 1,2 y 0");
			}
		} while (respuesta != 0);
	}
}

https://www.javatpoint.com/interface-in-java

https://javadesdecero.es/intermedio/interfaces-ejemplos/

https://www.w3schools.com/java/java_interface.asp

https://www.geeksforgeeks.org/interfaces-in-java/