Clases heredadas.

[hugodepino]

Veamos, un amigo y profesional en java me hizo el comentario " ...de que los que venís viciados de otros lenguajes de programación como Basic o Dbase, os cuesta mas..." y me he dado cuenta que tiene toda la razón.
Ha llegado un punto en mis estudios en el que no consigo salir de la clase principal, public static void, y el metodo main. Tengo claro el resto, if, for, while, arrays, excepciones, listas, pilas, variables, etc, etc... pero mi problema es que nada consigue hacerme entender el siguiente caso:

¿Para que sirve una clase heredada?
¿Como se estructura?
¿Y en que situaciones me va a hacer falta utilizarlo?

No le encuentro el sentido a una clase dentro de otra, ¿ no se puede ir saltando de función en función simplemente?, no es cuestión de falta de conocimientos es cuestión de que intentéis metermelo en la cabeza con algún ejemplo gráfico o unas cuantas líneas de código con un simple System.out.println o no se como... pero es imperiosa la necesidad de entenderlo para continuar con mis estudios.
Pasteo un ejercicio que estoy haciendo con el tema de las clases heredadas, por favor no le presteis atención a los this ni a los if ni a las declaraciones de variables, ni nada de eso, lo tengo claro. Que alguien me explique ¿que hace "leches" hace esa clase dentro de otra clase? y que sentido tiene o que parte del libro me he saltado.
Estoy en un punto en el cual no se ni donde empieza la clase principal y solo veo un conglomerado de clases revueltas con funciones sin orden alguno. El ejercicio está sacado de un libro.


Agradecido de antemano

public class Coche {

private final String modelo;
private final String matricula;
private final String color;
private final Cliente cliente;

public Coche(final String modelo, final String matricula, final String color, final String nombre, final String apellidos) {
this.modelo = modelo;
this.matricula = matricula;
this.color = color;
this.cliente = new Cliente(nombre, apellidos);
}

public String getCliente() {
return cliente.datosCliente();
}

public String getDatosCoche() {
return modelo + color + matricula;
}

private static class Cliente {

private final String nombre;
private final String apellidos;

Cliente(final String nombre, final String apellidos) {
this.nombre = nombre;
this.apellidos = apellidos;
}

public String datosCliente() {
return nombre + apellidos;
}
}

public static void main(String[] args) {
Coche coche = new Coche("Renault", "1400BWN", "Blanco", "Perez " Muñoz");
System.out.println(" Datos del coche " + coche.getDatosCoche());
System.out.println(" Datos del cliente " + coche.getCliente());
}
}

[iovan]

Bueno. Pues yo pienso que si te pones a estudiar de algun libro de JAVA básico (Que por internet hay muchos y en español), ya no tendrias dudas.

Bueno como un resumen.

Supongamos que tienes métodos para hacer determinada cosa, pero que éstos métodos los vas a ocupar en otras clases o al momento de instancía un objeto.

Entonces lo que te conviene hacer es crear una clase con estos métodos y despues heredarla a las otras clases.

ejemplo:

Código Java:

public class ConectarMysql(){
 
 
public void conectar(){}
 
public void desconectar(){}
 
}
 

después la heredas en cualquier otra clase en las que necesitaras utilizar conectar() y desconectar()

Código Java:

public class MiClase extends ConectarMysql{
 
 
public void metodo(){
 
super.conectar() //Conecto con mysql
 
..
..
.
.
 
 
super.desconectar() //Desconecto con mysql
 
}
 
 
}
 

Tàmbien otro ejemplo que se me ocurre, cuando instancias un objeto de la clase MiClase como esta extiende de ConectarMysql y ConectarMysql tiene métodos públicos, entonces tendras acceso a estos métodos desde la instancía del objeto en cuestion... bla bla bla perdon si no me entiendes pero ..... te lo buscaste por no estudiar.

ejemplo:

Código Java:

MiClase objeto = new MiClase();
 
objeto.conectar()//totalmente valido
 
objeto.deconectar()//totalmente valido
 
 
objeto.metodo()//totlamente valido
 

[Erickvk]

Sirve sobretodo para el Polimorfismo. Pongo un ejemplo, Tenemos una clase animal que tiene metodos como correr, saltar exceptera. Pero no todos los animales realizan estan acciones igual. Un caballo heredaria de Animal y modificaria el codigo de este metodo, y a lo mejor tiene acciones que otros animales no realizar entonces solo se usarian para los objetos o instancias de esta clase.

En el codigo hay a lo mejor una clase Vector de Animales y cada clase es de un tipo animal, con el polimorfismo puedes usar los metodos de la clase animal sin saber el tipo exacto de este animal.

Un ejemplo practico es por ejemplo una Cola o una Pila que pueden compartir metodos como insertar y leer y las dos estructuras se comportar diferente.

[Xerelo]

Tu primer problema es que ni siquiera conoces los términos, preguntas por clases heredadas cuando en ese ejemplo no hay nada relacionado con ellas.

No sé de que libro habrás sacado ese ejemplo, pero me parece malísimo como ejemplo básico, metiendo por en medio clases estáticas y atributos finales. Seguramente te ayude a entender las cosas mejor si creas una clase Principal que solo tenga el main, y las clases Coche y Cliente cada una en su fichero. La clase con el main sería tu programa principal y las otras dos llamadas a subrutinas (por relacionarlo con la programación estructurada)

O mejor, búscate otro libro o tutorial.

[hugodepino]

Veamos, me explique mal, clases INTERNAS es lo que intento entender, con respecto a los atributos estoy en ello.

El código se me ha quedado así, no entendiendo por que la llamada del main no me funciona:
Gracias

package crearobjetocoche;

public class CrearObjetoCoche { // clase principal
static String modelo;
static String matricula;
static String color;
CrearObjetoCoche coche = new CrearObjetoCoche(); // Creo el obejo

public class prueba extends CrearObjetoCoche{
public void aunNoLoSe(){
super.imprimir(modelo, matricula,color)

}





public void Crear(String modelo,String matricula, String color){
System.out.println("Datos del Vehículo sin llenar " +modelo+matricula+color);

if (modelo == null & color == null & matricula == null ){ // pendiente de corregir
System.out.println(" El objeto está creado y lleno");
}else{
System.out.println(" El objeto creado no contiene nada, Te lo lleno...");
llenaDatosCoche(modelo, matricula, color);

}


}

public void imprimir(String modelo, String matricula, String color){
System.out.println(modelo+matricula+color);
}
public void llenaDatosCoche(String modelo, String matricula, String color) { // Aqui, si está el objeto vacio lo lleno.
CrearObjetoCoche.this.modelo = "Renault ";
CrearObjetoCoche.this.matricula = "1400BWN ";
CrearObjetoCoche.this.color = "Verde ";
return modelo + color + matricula; // ¿este return me volverá a la llamada getDatosCoche(modelo,color, matricula)?
}


}
public static void main(String[] args) {
CrearObjetoCoche.Crear(modelo, matricula, color); // Error

}
}

[Xerelo]

Eso ya es otra cosa.

Para hacer ciertas cosas con las clases internas sí se necesita que las variables sean final (acceder a variables locales de la clase contenedora).

En mi opinión, las clases internas responden más a conceptos teóricos y prácticas de buena programación que a utilidad, creo que se puede programar perfectamente sin utilizarlas, de hecho yo no suelo hacerlo. Tengo que decir que los ejemplos más claros de uso que he visto estaban relacionados con temas de eventos, y como yo con aplicaciones de escritorio no he tratado, pues mi opinión no tiene mucho fundamento.

http://docs.oracle.com/javase/tutori...l#innerClasses

public void llenaDatosCoche(String modelo, String matricula, String color) { // Aqui, si está el objeto vacio lo lleno.
CrearObjetoCoche.this.modelo = "Renault ";
CrearObjetoCoche.this.matricula = "1400BWN ";
CrearObjetoCoche.this.color = "Verde ";
return modelo + color + matricula; // ¿este return me volverá a la llamada getDatosCoche(modelo,color, matricula)?
}

¿Cómo esperas que un método con void devuelva algo?

Del resto del código, veo tantas cosas extrañas que lo extraño sería que funcionase.