La herencia en Java es un concepto fundamental de la programación orientada a objetos que

permite que una clase herede propiedades y comportamientos de otra clase. En Java, se utiliza
la palabra clave "extends" para establecer una relación de herencia entre dos clases.

Cuando una clase hereda de otra clase, la clase hija (también conocida como subclase)
adquiere todos los miembros (campos y métodos) de la clase padre (también conocida como
superclase). Esto significa que la clase hija puede utilizar los campos y métodos heredados de
la clase padre, además de agregar nuevos campos y métodos propios.

// Clase padre o superclase

class Vehiculo {

private String marca;

private String modelo;

public Vehiculo(String marca, String modelo) {

this.marca = marca;

this.modelo = modelo;

public void conducir() {

System.out.println("Conduciendo un vehículo");

// Clase hija o subclase

class Coche extends Vehiculo {

private int numeroPuertas;

public Coche(String marca, String modelo, int numeroPuertas) {

super(marca, modelo);

this.numeroPuertas = numeroPuertas;

}
 public void acelerar() {

System.out.println("El coche está acelerando");

// Uso de las clases

public class Main {

public static void main(String[] args) {

Coche miCoche = new Coche("Toyota", "Corolla", 4);

miCoche.conducir(); // Método heredado de la clase Vehiculo

miCoche.acelerar(); // Método propio de la clase Coche

```

En este ejemplo, tenemos una clase llamada "Vehiculo" que define los campos "marca" y
"modelo", así como el método "conducir". Luego, creamos una clase llamada "Coche" que
hereda de "Vehiculo" utilizando la palabra clave "extends". La clase "Coche" agrega un nuevo
campo "numeroPuertas" y el método "acelerar".

En la función "main" creamos un objeto de la clase "Coche" y lo utilizamos para llamar tanto al
método heredado "conducir" como al método propio "acelerar".

La herencia en Java nos permite reutilizar código y establecer jerarquías de clases para
organizar nuestro código de manera más eficiente. Al heredar de una clase existente, podemos
agregar o modificar comportamientos según nuestras necesidades, sin tener que volver a
escribir todo el código desde cero.

¡Claro! Aquí tienes tres ejercicios relacionados con la explicación anterior sobre herencia en
Java:
Ejercicio 1:

Crea una clase llamada "Animal" con los siguientes atributos: "nombre" (String) y "edad" (int).
Agrega un método llamado "hacerSonido()" que imprima "El animal hace un sonido".

Luego, crea una clase llamada "Perro" que herede de "Animal" y agrega un atributo adicional
llamado "raza" (String). Sobrescribe el método "hacerSonido()" para que imprima "El perro
ladra".

Ejercicio 2:

Crea una clase llamada "Figura" con un atributo "color" (String) y un método "dibujar()" que
imprima "Dibujando una figura de color {color}".

Luego, crea una clase llamada "Circulo" que herede de "Figura" y agrega un atributo adicional
llamado "radio" (double). Sobrescribe el método "dibujar()" para que imprima "Dibujando un
círculo de radio {radio} y color {color}".

Ejercicio 3:

Crea una clase llamada "Fruta" con un atributo "nombre" (String) y un método "mostrarInfo()"
que imprima "Nombre: {nombre}".

Luego, crea una clase llamada

"Manzana" que herede de "Fruta" y agrega un atributo adicional llamado "color" (String).
Sobrescribe el método "mostrarInfo()" para que imprima "Nombre: Manzana, Color: {color}".
En Java, una interfaz es una colección de métodos abstractos (métodos sin implementación)
que definen un conjunto de comportamientos que una clase puede implementar. Las interfaces
en Java se utilizan para establecer un contrato entre las clases que las implementan y el código
que las utiliza.

Una interfaz se define mediante la palabra clave `interface`. Aquí tienes un ejemplo de cómo se
podría definir una interfaz en Java:

public interface Animal {

void hacerSonido();

void moverse();

```

En este ejemplo, hemos definido una interfaz llamada `Animal` que declara dos métodos
abstractos: `hacerSonido()` y `moverse()`. Estos métodos no tienen ninguna implementación en
la interfaz, solo declaran su existencia y firma.

Las clases que implementen la interfaz `Animal` deben proporcionar una implementación para
cada uno de los métodos declarados en la interfaz. Por ejemplo, aquí tienes una
implementación para la interfaz `Animal`:

public class Perro implements Animal {

public void hacerSonido() {

System.out.println("El perro hace 'guau guau'.");

public void moverse() {

System.out.println("El perro corre y camina.");

```
La clase `Perro` implementa la interfaz `Animal` y proporciona una implementación para los
métodos `hacerSonido()` y `moverse()`. En este caso, simplemente imprimimos mensajes en la
consola para representar el sonido y el movimiento del perro.

Las interfaces en Java se utilizan para lograr la abstracción y el polimorfismo. Al definir una
interfaz, podemos establecer un contrato común que las clases pueden cumplir al
implementarla. Esto permite que el código utilice objetos de diferentes clases que
implementen la misma interfaz, sin preocuparse por los detalles específicos de cada
implementación.

Por ejemplo, podríamos tener un método en otra clase que acepte un objeto `Animal` y util