Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » Ayuda con la programación

Java - Ayuda con la programación

Volver
Nuevo Tema
<<>>
 
Vista:

Ayuda con la programación

Publicado por Lolita (2 intervenciones) el 15/04/2019 21:17:27
Hola, necesito ayuda con la programación de este problema. He definido las clases pero ya no entiendo nada más. ¿Me echáis un cable, por favor? Millones de gracias!!!



El proyecto deberá estar organizado por paquetes de modo que tengas, al menos, los paquetes clase, clase_abstracta, interf y lanzador.

Dentro del paquete lanzador deberás crear una clase llamada Principal. En esta clase estará el método main.

Vamos a modelizar un tienda de bicicletas.

Tendrás una clase abstracta llamada Bicicleta

Tendrás unas subclases de Bicicleta llamadas BiciMontania, BiciPaseo, Tandem. Estas subclases deberán sobreescribir al método toString de Object haciendo que digan de que tipo son, su color y precio.

Todas las bicicletas tendrán dos campos comunes color (String) y precio (double).

Quiero que todas las bicicletas implementen el método pintar, que lo que hará será cambiar el color pero me interesa que este método pintar también se pueda aplicar a otras posibles modelizaciones futuras que pudiera hacer, no debe ser exclusivo de las bicicletas. Además quiero que el coste de pintar (lo que sea) sea fijo y sea 90.

Las bicicletas de montaña deberán almacenar la marcha que tiene la bici (pudiendo tomar valores únicamente entre 1 y 6).

Las bicicletas de paseo deberán almacenar la velocidad a la que se circula.

Los tandem deberán almacenar el número de asientos (pudiendo tomar únicamente los valores 2 y 3).

Todos los campos de todas las clases deberán seguir los principios de encapsulamiento.

La clase BiciMontania deberá tener un único constructor a través del cual se establezca el valor del color, precio y marcha.

La clase BiciPaseo deberá tener 2 constructores, uno a través del cual se establezca el valor del color, precio y velocidad y otro a través del cual se establezca el color y precio.

La clase Tandem deberá tener un único constructor a través del cual se establezca el valor del color, precio y número de asientos.

Los constructores deberán controlar las condiciones existentes.

La BiciMontania tendrá un método llamado aumentarMarcha que no tendrá parámetros y aumentará en 1 la marcha actual (siempre que cumpla las condiciones anteriores). También tendrá un método llamado disminuirMarcha que no tendrá parámetros y reducirá en 1 la marcha actual (siempre que cumpla las condiciones anteriores). No se podrá modificar la marcha desde ningún otro lugar.

En la clase Principal deberás crear una lista con todas las bicicletas que tengas en la tienda. En este momento tienes 2 bicicletas de montaña, 1 bici de paseo y 2 tandems. Crea los objetos y añádelos a la lista.

Posteriormente interacciona con ellos y al final recorre la lista para llamar al método toString de cada objeto.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Ayuda con la programación

Publicado por Kabuto (1381 intervenciones) el 16/04/2019 14:36:53
Hola.
Sería interesante que mostrases lo que tienes hecho y que a partir de ahí te ayudasemos a completarlo.
De todos modos, te muestro como lo he resuelto yo.

Primero definimos la clase abstracta, con los dos atributos básicos que tendrán todas los tipos de bicicletas.
Incluyo getters y setters.

Clase Abstracta Bicicleta
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public abstract class Bicicleta {
 
	private String color;
	private Double precio;
 
	public Bicicleta(String color, Double precio) {
		this.color = color;
		this.precio = precio;
	}
 
	public String getColor() {
		return color;
	}
 
	public void setColor(String color) {
		this.color = color;
	}
 
	public Double getPrecio() {
		return precio;
	}
 
	public void setPrecio(Double precio) {
		this.precio = precio;
	}
 
}

Para el atributo precio he usado la clase Double, en lugar de su equivalente tipo primitivo double, como suele ser más habitual.
Tú usa el que quieras, para este ejercicio, nos da igual uno que otro.

Bien, el enunciado del ejercicio dice que todos los tipos de bicicletas van a tener que IMPLEMENTAR (esta palabra ya nos da una pista de lo que nos quieren pedir) un metodo para cambiar el color de la pintura. Pero dice que dicho método no ha de ser algo que se limite a solo bicicletas, si no que debería ser IMPLEMENTABLE por cualquier otra clase que quisieramos modelar en el futuro.

Es evidente que nos están pidiendo que escribamos una "interfaz" (interface). Una interfaz es parecido a una clase abstracta.
La diferencia es que una interfaz no se "hereda", se "implementa".
Además nos piden que establezcamos un coste fijo para el cambio de pintura. Podríamos modelar la siguiente interfaz:

Interfaz Pintar
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public interface Pintar {
 
	final Double COSTE = 90d;
 
	/**

	 * Método para cambiar color de la pintura.

	 * Recibe como parametro el nuevo color que queremos aplicar

	 * y retorna un valor que representa el coste del cambio de pintura.

	 * 

	 * La interfaz Pintar dispone del valor constante Pintar.COSTE para representar el

	 * coste del cambio de pintura.

	 * La clase que implemente este método, puede escoger entre usar este valor constante

	 * como valor de retorno o bien usar otro.

	 * @param color String con el nombre del nuevo color de pintura.

	 * @return Coste del servicio de cambio de pintura.

	 */
	public Double cambiarPintura(String color);
 
}

En la interfaz declaramos una constante que representa el coste del cambio de pintura. Luego el programador que implemente esta interfaz en sus clases puede tomar este valor como referencia de coste o usar cualquie otro.
Luego declaramos un método que recibe el nombre del nuevo color para pintar y retorna un valor que representa el coste del servicio de cambio de pintura.

En la interfaz, el método solo se declara, no se define su código. Entonces, la clase que luego vaya a implementar esta interfaz, estará obligada a incluir este método y ahí ya se decidirá como será su código.


Ahora que ya tenemos la clase abstracta de la que van a heredar las otras clases y la interfaz que han de implementar, vamos a crear dichas clases.

Clase BiciMontania
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public class BiciMontania extends Bicicleta implements Pintar{
 
	private Byte marchaActual;
 
	public BiciMontania(String color, Double precio, Byte marcha) {
		super(color, precio);
		setMarchaActual(marcha);
	}
 
	public Byte getMarchaActual() {
		return marchaActual;
	}
 
	public void setMarchaActual(Byte marcha) {
		if (marcha < 1) //Nos han pasado un valor de marcha demasiado bajo

			marchaActual = 1;
		else if (marcha > 6) //Valor de marcha demasiado alto

			marchaActual = 6;
		else
			marchaActual = marcha;
	}
 
	public void aumentarMarcha() {
		if (marchaActual < 6) //Solo puede aumentar si es menor de 6

			marchaActual++;
	}
 
	public void disminuirMarcha() {
		if (marchaActual > 1) //Solo puede disminuir si es mayor que 1

			marchaActual--;
	}
 
	@Override
	public Double cambiarPintura(String color) {
		super.setColor(color);
		return Pintar.COSTE;
	}
 
	@Override
	public String toString() {
		return String.format("Tipo Bicicleta: Montaña\nColor: %s\nPrecio: %.2f €\n",
				super.getColor(), super.getPrecio());
	}
}

Esta clase incorpora un nuevo atributo a los dos que hereda de su clase padre.
Para este atributo llamado marchaActual yo he escogido la clase Byte, tú elige el que prefieras, siendo probablemente el tipo int el que se habría escogido habitualmente.

El método que setea este atributo comprueba que el valor recibido entre dentro de los parámetros exigidos, entre 1 y 6, de lo contrario lo corrige al valos admitido más cercano.

Hay dos métodos más para aumentar y disminuir marcha, ambos siempre comprobando que este atributo se mantiene dentro de los parámetros correctos.

Finalmente se sobreescriben dos métodos.
Uno es el que se implementa desde la interfaz Pintar y ahora ya sí definimos su código.
Otro es el método toString() que se hereda de la clase Object donde debemos retorna un String mostrando el tipo de bicicleta y el valor de los atributos básicos. Tú puedes construir este String como quieras, no tienes porque hacerlo como yo.

Clase BiciPaseo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class BiciPaseo extends Bicicleta implements Pintar{
 
	private Float velocidadActual;
 
	public BiciPaseo(String color, Double precio) {
		super(color, precio);
	}
 
	public BiciPaseo(String color, Double precio, Float velocidad) {
		super(color, precio);
		velocidadActual = velocidad;
	}
 
	public Float getVelocidadActual() {
		return velocidadActual;
	}
 
	public void setVelocidadActual(Float velocidad) {
		velocidadActual = velocidad;
	}
 
	@Override
	public Double cambiarPintura(String color) {
		super.setColor(color);
		return Pintar.COSTE;
	}
 
	@Override
	public String toString() {
		return String.format("Tipo Bicicleta: Paseo\nColor: %s\nPrecio: %.2f €\n",
				super.getColor(), super.getPrecio());
	}
 
}

Nada importante a destacar. Tiene los dos constructores que solicita el enunciado y por supuesto sobreescribe los dos métodos al igual que la clase anterior

Clase Tandem
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class Tandem extends Bicicleta implements Pintar{
 
	private Byte asientos;
 
	public Tandem(String color, Double precio, Byte numAsientos) {
		super(color, precio);
		setAsientos(numAsientos);
	}
 
	public Byte getAsientos() {
		return asientos;
	}
 
	public void setAsientos(Byte asientos) {
		if (asientos < 2) //Valor de asientos demasiado bajo

			this.asientos = 2;
		else if (asientos > 3) //Valor de asientos demasiado alto

			this.asientos = 3;
		else
			this.asientos = asientos;
	}
 
	@Override
	public Double cambiarPintura(String color) {
		super.setColor(color);
		return Pintar.COSTE;
	}
 
	@Override
	public String toString() {
		return String.format("Tipo Bicicleta: Tandem\nColor: %s\nPrecio: %.2f €\n",
				super.getColor(), super.getPrecio());
	}
 
}

Incluye control de valor para el atributo asientos.


Ya tenemos todas las clases que nos piden, solo falta la principal que lanzará la ejecución del programa.
Para esta clase he utilizado un ArrayList para albergar las distintas bicicletas que nos piden.

A algunas de estas bicicletas les he dado valores absurdos para algunos atributos y comprobar que son corregidos correctamente.

Para poder tener todos los objetos juntos en un único listado, al ArrayList hay que decirle que guarde los objetos que va a recibir bajo la clase Bicicleta, que es la clase padre de la que todas las otras clases son hijas.
Esto permite agruparlas pero tiene el inconveniente que al estar guardadas así, no podemos acceder directamente a los métodos específicos de cada clase hija.

Para poder acceder a dichos métodos, hay que "castear" los objetos para referenciarlos bajo la clase en la que realmente fueron instanciados.
Así para poder consultar y modificar las marchas, habrá que hacer un casting a la clase BiciMontania

Y para comprobar el número de asientos habrá que hacer lo mismo bajo la clase Tandem


Por último se muestra un listado de las bicicletas instanciadas llamando a su método toString().
Para invocar este método no hay que hacer ningún casting porque, aunque es ligeramente distinto para cada clase, es un método que se hereda de Object (la superclase que es padre de TODAS las clases) así que se puede invocar desde cualquier estado.

Aquí el código final.
Clase Principal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public class Principal {
 
	static ArrayList<Bicicleta> bicicletas = new ArrayList<Bicicleta>();
 
	public static void main(String[] args) {
 
		bicicletas.add(new BiciMontania("Rojo", 399.95, (byte)1));
		bicicletas.add(new BiciMontania("Negro", 349.95, (byte)84)); //Comprobamos que pasa si indicamos número de marcha absurdo

		bicicletas.add(new BiciPaseo("Verde", 249.95, 14.5f));
		bicicletas.add(new Tandem("Azul", 449.95, (byte)2));
		bicicletas.add(new Tandem("Marrón", 469.95, (byte)56)); //Numero asientos absurdo

 
		/*

		 * Comprobamos si las bicicletas inicializadas con valores absurdos han corregido dichos atributos

		 * y probamos interacciones

		 * Los objetos de la lista están instanciados como "Bicicleta", es decir, su clase padre.

		 * Para poder acceder a los métodos propios de cada clase hija, habrá que hacer casting.

		 */
 
		System.out.println("Bicicleta inicializada con valor marcha 84.");
		BiciMontania monte = (BiciMontania)bicicletas.get(1);
		System.out.println("Valor de marcha corregido a " + monte.getMarchaActual() );
		System.out.println("Intentamos aumentar marcha...");
		monte.aumentarMarcha();
		System.out.println("Valor marcha actual: " + monte.getMarchaActual());
		System.out.println("Intentamos reducir marcha...");
		monte.disminuirMarcha();
		System.out.println("Valor marcha actual: " + monte.getMarchaActual());
 
		System.out.println("\n\nTándem inicializado con valor de asientos 56");
		Tandem tandem = (Tandem)bicicletas.get(4);
		System.out.println("Valor de asientos corregido a " + tandem.getAsientos() );
		System.out.println("Intentamos setear valor de asientos a 1");
		tandem.setAsientos((byte)1);
		System.out.println("Valor de asientos corregido a " + tandem.getAsientos() );
 
 
		//Mostramos listado bicicletas

		System.out.println("\n\n\t\tLISTADO BICICLETAS");
		for (int i = 0; i < bicicletas.size(); i++) {
			System.out.println(bicicletas.get(i).toString());
		}
 
	}
 
}

Y por último muestro el resultado que obtengo en pantalla.
Si tienes dudas pregunta lo que sea. Un saludo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
Bicicleta inicializada con valor marcha 84.
Valor de marcha corregido a 6
Intentamos aumentar marcha...
Valor marcha actual: 6
Intentamos reducir marcha...
Valor marcha actual: 5
 
 
Tándem inicializado con valor de asientos 56
Valor de asientos corregido a 3
Intentamos setear valor de asientos a 1
Valor de asientos corregido a 2
 
 
		LISTADO BICICLETAS
Tipo Bicicleta: Montaña
Color: Rojo
Precio: 399,95 €
 
Tipo Bicicleta: Montaña
Color: Negro
Precio: 349,95 €
 
Tipo Bicicleta: Paseo
Color: Verde
Precio: 249,95 €
 
Tipo Bicicleta: Tandem
Color: Azul
Precio: 449,95 €
 
Tipo Bicicleta: Tandem
Color: Marrón
Precio: 469,95 €
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
2
Comentar

Ayuda con la programación

Publicado por Lolita (2 intervenciones) el 16/04/2019 21:34:01
No sé cómo darte las gracias!!! Habría sido incapaz de terminarlo. Y he conseguido entenderlo!! Lo has explicado de una manera excelente. Muchas gracias de nuevo, de verdad.

Un fuerte abrazo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Ayuda con la programación

Publicado por Kabuto (1381 intervenciones) el 17/04/2019 01:23:27
Me alegro.
Cuenta con la gente de este foro siempre que necesites ayuda. Ciaoo
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar