Java - Programación Orientada a Objetos

 
Vista:
sin imagen de perfil
Val: 12
Ha disminuido su posición en 117 puestos en Java (en relación al último mes)
Gráfica de Java

Programación Orientada a Objetos

Publicado por William (5 intervenciones) el 05/06/2020 01:02:38
Hola estoy solicitando ayuda tenque realizar el siguiente ejercio.

Instrucciones:
- Crear un proyecto en java (Eclipse - Netbeans) y desarrollar los ejercicios planteados
- Crear un menú de opciones: Ejericio1, Ejericicio2, Ejercicio3, Ejercicio4
- Crear una clase distinta para cada ejercicio


Tengo problemas a llamar las clases private o encapsuladas al menu


Captura
Captura2



Lo que voy realizando

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.ObjectInputStream.GetField;
import java.io.PrintWriter;
import java.nio.Buffer;
 
import javax.swing.JOptionPane;
 
public class Menu {
 
	//Ejercicio 1
 
	public void Persona() {
 
 
	}
 
	public void Estudiante() {
 
 
	}
 
	public void Docente() {
 
 
	}
 
	//Ejercicio 2
 
	public void Vehiculo() {
 
	}
 
	public void Principal() {
 
	}
 
 
	public static void main(String[] args) {
 
		Menu me = new Menu();
 
		int opcion;
		String op="";
 
		op=JOptionPane.showInputDialog("SELECCIONE UNA OPCION :\n"
 
				+ "1.- Ejercicio 1\n"
				+ "2.- Ejercicio 2\n"
				+ "3.- Ejercicio 3\n"
				+ "4.- Ejercicio 4\n");
 
		opcion=Integer.parseInt(op);
 
		switch (opcion) {
 
		case 1: me.Persona();
				me.Estudiante();
				me.Docente();
 
		  JOptionPane.showMessageDialog(null, "ELIGIO Ejercicio 1");
 
		  Estudiante Objeto1 = new Estudiante(10, "william", "pozo", "est1", 8);
		  JOptionPane.showMessageDialog(null, "El estudiante es " +Objeto1.getNombrePersona());
 
		  Docente Objeto2 = new Docente(1725, "juan", "perez", 001);
 
		  Objeto2.getNombrePersona();
		  Objeto2.getApellidoPersona();
		  Objeto2.getCodigoDocente();
 
		  JOptionPane.showMessageDialog(null, "El docente es " +Objeto2.getNombrePersona());
 
		  Objeto1.getNombrePersona();
		  Objeto1.getApellidoPersona();
		  Objeto1.getCodigoEstudiante();
		  Objeto1.getCedulaIdenditad();
		  Objeto1.getNotaEstudiante();
 
		  //Archivo txt
 
		  File miArchivo;
		  PrintWriter escribirArchivo;
		  miArchivo = new File("C:\\\\Users\\\\William Pozo\\\\Desktop\\\\universidad\\\\Programacion orientada a objetos\\\\archivos\\\\archivos.txt");
		  if (!miArchivo.exists()) {
			  System.out.println("Se creo el archivo");
			  try {
				miArchivo.createNewFile();
 
			} catch (IOException e) {
 
			}
 
 
		  }else {
			  System.out.println("El archivo ya existe");
			  try {
				  escribirArchivo = new PrintWriter(miArchivo);
				  escribirArchivo.println("El estudiante es: " + Objeto1.nombrePersona + Objeto1.getNotaEstudiante());
				  escribirArchivo.append("El docente es: " + Objeto2.nombrePersona + Objeto2.getCodigoDocente());
				  escribirArchivo.close();
			} catch (Exception e) {
 
			}
 
 
 
		}
		  /*try {
			  archivo = new File("C:\\Users\\William Pozo\\Desktop\\universidad\\Programacion orientada a objetos\\archivos\\archivos.txt");
			  if(archivo.createNewFile()) {
				  System.out.println("Se a crado el archivo");
				  PrintWriter pw = new PrintWriter("archivos.txt");
				  pw.write("El nombre del estudiante es :");
				  pw.close();
			  }
		} catch (IOException e) {
			System.err.println("No se a podido crear el archivo" + e);
		}*/
				break;
		case 2:
 
		me.Vehiculo();
		me.Principal();
 
		JOptionPane.showMessageDialog(null, "ELIGIO Ejercicio 2");
 
 
 
			break;
		case 3: JOptionPane.showMessageDialog(null, "ELIGIO Ejercicio 3");
 
			break;
		case 4: JOptionPane.showMessageDialog(null, "ELIGIO Ejercicio 4");
 
			break;
 
		default: JOptionPane.showMessageDialog(null, "NO ES CORRECTO");
		}
 
 
	}
 
}
 
 
////////////////////////////////////////////////////////////////////////////////////////
 
 
public class Persona {
 
	protected int cedulaIdenditad;
	protected String nombrePersona;
	protected String apellidoPersona;
 
	public Persona(int cedulaIdenditad, String nombrePersona, String apellidoPersona) {
		super();
		this.cedulaIdenditad = cedulaIdenditad;
		this.nombrePersona = nombrePersona;
		this.apellidoPersona = apellidoPersona;
	}
 
	public int getCedulaIdenditad() {
		return cedulaIdenditad;
	}
 
	public void setCedulaIdenditad(int cedulaIdenditad) {
		this.cedulaIdenditad = cedulaIdenditad;
	}
 
	public String getNombrePersona() {
		return nombrePersona;
	}
 
	public void setNombrePersona(String nombrePersona) {
		this.nombrePersona = nombrePersona;
	}
 
	public String getApellidoPersona() {
		return apellidoPersona;
	}
 
	public void setApellidoPersona(String apellidoPersona) {
		this.apellidoPersona = apellidoPersona;
	}
 
	public String mostrarDatos() {
		return "Cedula: "+ cedulaIdenditad+"\nNombre: "+nombrePersona+"\nApellido: "+apellidoPersona;
	}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
 
public class Docente extends Persona {
 
	private int codigoDocente;
 
	//Constructor clase Docente
 
	public Docente(int cedulaIdenditad, String nombrePersona, String apellidoPersona, int codigoDocente) {
		super(cedulaIdenditad, nombrePersona, apellidoPersona);
		this.codigoDocente = codigoDocente;
	}
 
	public int getCodigoDocente() {
		return codigoDocente;
	}
 
	public void setCodigoDocente(int codigoDocente) {
		this.codigoDocente = codigoDocente;
	}
 
	public String mostrarDatos() {
		return "Cedula: "+ cedulaIdenditad+"\nNombre: "+nombrePersona+"\nApellido: "+apellidoPersona+
				"\nCodigo Docente: " +codigoDocente;
	}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
public class Estudiante extends Persona {
 
	 private String codigoEstudiante;
	 private float notaEstudiante;
 
	 //Constructor clase estudiante
 
	 public Estudiante(int cedulaIdentidad, String nombrePersona, String apellidoPersona, String codigoEstudiante, float notaEstudiante){
		 super(cedulaIdentidad, nombrePersona, apellidoPersona);
		 this.codigoEstudiante = codigoEstudiante;
		 this.notaEstudiante = notaEstudiante;
	 }
 
	public String getCodigoEstudiante() {
		return codigoEstudiante;
	}
 
	public void setCodigoEstudiante(String codigoEstudiante) {
		this.codigoEstudiante = codigoEstudiante;
	}
 
	public float getNotaEstudiante() {
		return notaEstudiante;
	}
 
	public void setNotaEstudiante(float notaEstudiante) {
		this.notaEstudiante = notaEstudiante;
	}
 
	@Override
	public String mostrarDatos() {
		return "Cedula: "+ cedulaIdenditad+"\nNombre: "+nombrePersona+"\nApellido: "+apellidoPersona+
				"\nCodigo Estudiante: "+ codigoEstudiante+ "\nNota Estudiante: "+ notaEstudiante;
	}
 
	}
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

Programación Orientada a Objetos

Publicado por Kabuto (1381 intervenciones) el 05/06/2020 21:17:56
Mmmmhh, no se exactamente que problema tienes.
Pero podemos intentar simplificar un poco el código.

Creo entender según el enunciado, que por cada ejercicio se ha de crear una clase específica.
Clase Ejercicio1, clase Ejercicio2, etc...

Es un pelín raro, pero puede ser útil para simplificar el main principal.

Mira, esta podría ser la clase para Ejercicio1, que hace más o menos lo que tu hacías en el main.
El código lo pongo en su constructor, así cuando en el main hagamos una instancia de esta clase, se pondrá en marcha este código.

Solo cambio que hago uso del método mostrarDatos() (que para eso está,¿no? ;) ) y que el archivo lo escribo con la clase BufferedWriter.
Tu usa la clase que prefieras.

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
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
 
import javax.swing.JOptionPane;
 
public class Ejercicio1 {
 
	public Ejercicio1() {
		Estudiante estudiante = new Estudiante(10, "william", "pozo", "est1", 8);
		JOptionPane.showMessageDialog(null, "Datos del Estudiante:\n" + estudiante.mostrarDatos());
 
		Docente docente = new Docente(1725, "juan", "perez", 001);
		JOptionPane.showMessageDialog(null, "Datos del Docente:\n" + docente.mostrarDatos());
 
		File archivo = new File("D:\\ejercicio1.txt");
 
		try {
			BufferedWriter bw = new BufferedWriter(new FileWriter(archivo));
			bw.write("Datos del Estudiante:\n" + estudiante.mostrarDatos());
			bw.newLine();
			bw.newLine();
			bw.write("Datos del Docente:\n" + docente.mostrarDatos());
			bw.close();
			JOptionPane.showMessageDialog(null, "Archivo de texto creado en " + archivo.getAbsolutePath(),
					"Ejercicio1", JOptionPane.INFORMATION_MESSAGE);
		} catch (IOException e) {
			JOptionPane.showMessageDialog(null, "Error accediendo al archivo del Ejercicio1",
					"Ejercicio1", JOptionPane.ERROR_MESSAGE);
		}
	}
}

De este modo en el main, como he dicho, nos bastará con hacer una instancia de esta clase, sin necesidad de referenciarla ni nada.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Menu {
 
	public static void main(String[] args) {
 
		int opcion =Integer.parseInt(JOptionPane.showInputDialog("SELECCIONE UNA OPCION :\n"
				+ "1.- Ejercicio 1\n"
				+ "2.- Ejercicio 2\n"
				+ "3.- Ejercicio 3\n"
				+ "4.- Ejercicio 4\n"));
 
		switch (opcion) {
		case 1:
			JOptionPane.showMessageDialog(null, "ELIGIO Ejercicio 1");
			new Ejercicio1(); //Se ejecutan todos los pasos del constructor de Ejercicio1
			break;
		}
 
	}
 
}

Creo que se podría seguir esta metodología con el resto de ejercicios. Así la clase Menu, la que tiene el main, queda más escueta, con menos código, porque estará "modulado" en las distintas clases Ejercicio1, Ejercicio2, etc...
Solo hay que ir añadiendole cases al switch, para instanciar a cada una de estas clases según se escoja en el menú.

Sigue con el resto de ejercicios y si te surgen problemas te ayudamos por aquí.

Un saludo.
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
sin imagen de perfil
Val: 12
Ha disminuido su posición en 117 puestos en Java (en relación al último mes)
Gráfica de Java

Programación Orientada a Objetos

Publicado por William (5 intervenciones) el 06/06/2020 01:11:07
Gracias
y como puedo llenar las matrices
Captura2
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
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

Programación Orientada a Objetos

Publicado por Kabuto (1381 intervenciones) el 06/06/2020 21:55:10
El ejercicio3.

Rellenar la diagonal principal de la matriz con un número determinado es fácil.
Ya sabrás que para recorrer una matriz, al completo, usamos dos bucles anidados para tener dos indices, ya que cada posición de la matriz está representada por dos valores: [0][0], [0][1], [0][2], [0][3],, etc...

Si te fijas, las posiciones de la diagonal principal son:
[0][0], [1][1], [2][2], [3][3], [4][4], [5][5], [6][6]

Así que solo necesitas un bucle for cuyo indice vaya de 0 a hasta el final de la matriz (6 en este caso) y usar el mismo indice para marcar las posiciones.
Tan sencillo como esto:
1
2
3
//Diagonal principal rellenada con 3
for (int in = 0; in < matriz.length; in++)
    matriz[in][in] = 3;

Rellenar la diagonal secundaria, es un poco más difícil, pero solo un poco.
Lo primero es fijarnos de nuevo cuáles son las posiciones de esta diagonal:
[0][6], [1][5], [2][4], [3][3], [4][2], [5][1], [6][0]

Vemos que el primer indice va de 0 a 6, y el otro indice va al inverso, simultáneamente.
Es decir, esta vez si usaremos dos indices, y tenemos que hacer que cuando un indice se incremente, el otro se decremente.
Parece difícil, pero no lo es tanto:
1
2
3
4
5
6
//Diagonal secundaria rellenada con 4
int z = matriz.length - 1;
for (int in = 0; in < matriz.length; in++) {
    matriz[in][z] = 4;
    z--; //Cuando la in se incremente, la z se decrementa
}

Así que la clase para el Ejercicio3 podría quedar así.
La matriz se muestra por consola, si quieres mostrarlo en un JOptionPane, habría que complicar más el código para construir un String con todos los valores de la matriz:
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
public class Ejercicio3 {
 
	public Ejercicio3() {
 
		int[][] matriz = new int[7][7];
 
		//Diagonal principal rellenada con 3
		for (int in = 0; in < matriz.length; in++)
			matriz[in][in] = 3;
 
		//Diagonal secundaria rellenada con 4
		int z = matriz.length - 1;
		for (int in = 0; in < matriz.length; in++) {
			matriz[in][z] = 4;
			z--;
		}
 
		//Mostramos array en pantalla
		System.out.println("Matriz del Ejercicio3:\n");
		for (int in = 0; in < matriz.length; in++) {
			for (int j = 0; j < matriz[0].length; j++)
				System.out.print(matriz[in][j] + " ");
			System.out.println();
		}
 
	}
 
}

Ya solo queda añadirlo al switch del main principal.

Sobre el ejercicio 4, en el ejercicio 3 ya hemos visto como recorrer la diagonal principal. Sería usar el mismo tipo de bucle, pero esta vez en lugar de meter el valor 3, sería hacer la suma de los valores que encontremos en esas posiciones.
Inténtalo por tu cuenta, si te atascas, te ayudaremos a completarlo
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
sin imagen de perfil
Val: 12
Ha disminuido su posición en 117 puestos en Java (en relación al último mes)
Gráfica de Java

Programación Orientada a Objetos

Publicado por William (5 intervenciones) el 07/06/2020 02:07:50
Gracias la verdad me quedaba sin tiempo gracias
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

Programación Orientada a Objetos

Publicado por Kabuto (1381 intervenciones) el 07/06/2020 11:36:21
Si tienes más dudas, pregunta lo que sea.

Quiero comentar que esto que pide el enunciado de usar clases para la ejecución de cada uno de los ejercicios, como dije al principio, es un poco raro.
Funcionar ya hemos visto que funciona, y que todo queda ordenado y simplificado. Pero, aunque como programadores podemos hacer lo que nos de la gana mientras el código funcione y cumpla su cometido, yo diría que no es la forma más apropiada de organizar esta tarea.

Lo que yo hubiera hecho habría sido crear UNA única clase llamada Ejercicios, y que dicha clase tuviera métodos para ejecutar cada uno de esos ejercicios.
De este modo queda igual de organizado, incluso mejor porque tendríamos solo una clase, en lugar de cuatro.
Y es más acorde con la filosofía POO, a mi entender.

Los métodos para estos ejercicios pueden ser declarados como estáticos, así luego en el main no sería necesario crear una instancia de esta clase llamada Ejercicios. Tan solo nombrarla a ella y al ejercicio que queremos ejecutar.
Esta podría ser la clase (solo pongo los ejercicios que he hecho yo)

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
47
48
49
50
51
52
53
54
55
56
57
58
public class Ejercicios {
 
	/**
	 * Realiza la tarea propuesta en Ejercicio1
	 */
	public static void ejercicio1() {
 
		Estudiante estudiante = new Estudiante(10, "william", "pozo", "est1", 8);
		JOptionPane.showMessageDialog(null, "Datos del Estudiante:\n" + estudiante.mostrarDatos());
 
		Docente docente = new Docente(1725, "juan", "perez", 001);
		JOptionPane.showMessageDialog(null, "Datos del Docente:\n" + docente.mostrarDatos());
 
		File archivo = new File("D:\\ejercicio1.txt");
 
		try {
			BufferedWriter bw = new BufferedWriter(new FileWriter(archivo));
			bw.write("Datos del Estudiante:\n" + estudiante.mostrarDatos());
			bw.newLine();
			bw.newLine();
			bw.write("Datos del Docente:\n" + docente.mostrarDatos());
			bw.close();
			JOptionPane.showMessageDialog(null, "Archivo de texto creado en " + archivo.getAbsolutePath(),
					"Ejercicio1", JOptionPane.INFORMATION_MESSAGE);
		} catch (IOException e) {
			JOptionPane.showMessageDialog(null, "Error accediendo al archivo del Ejercicio1",
					"Ejercicio1", JOptionPane.ERROR_MESSAGE);
		}
	}
 
 
	/**
	 * Realiza la tarea propuesta en Ejercicio3
	 */
	public static void ejercicio3() {
 
		int[][] matriz = new int[7][7];
 
		//Diagonal principal rellenada con 3
		for (int in = 0; in< matriz.length; in++)
			matriz[in] = 3;
 
		//Diagonal secundaria rellenada con 4
		int z = matriz.length - 1;
		for (int in = 0; in < matriz.length; in++) {
			matriz[in][z] = 4;
			z--;
		}
 
		//Mostramos array en pantalla
		System.out.println("Matriz del Ejercicio3:\n");
		for (int in = 0; in < matriz.length; in++) {
			for (int j = 0; j < matriz[0].length; j++)
				System.out.print(matriz[in][j] + " ");
			System.out.println();
		}
	}
}

Y luego en el switch del main, los llamamos sin tener que instanciar nada (no hay que hacer un [i]new Ejercicios()
)

1
2
3
4
5
6
7
8
9
10
switch (opcion) {
		case 1:
			JOptionPane.showMessageDialog(null, "ELIGIO Ejercicio 1");
			Ejercicios.ejercicio1();
			break;
		case 3:
			JOptionPane.showMessageDialog(null, "ELIGIO Ejercicio 3");
			Ejercicios.ejercicio3();
			break;
		}

De este modo una sola clase puede aglutinar todos los ejercicios que necesitemos.
Y es más acorde con la filosofía POO porque para realizar una determinada tarea (un ejercicio), estamos llamando a métodos, que son quienes deben llevar a cabo estos procedimientos.

Usar el constructor de distintas clases para ejecutar estos procedimientos, funcionar sí que funciona, pero no es lo correcto.

Solo quería comentarlo, tu aplica la forma que creas que se adapta mejor a lo que pide el enunciado.

Un saludo.
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
sin imagen de perfil
Val: 12
Ha disminuido su posición en 117 puestos en Java (en relación al último mes)
Gráfica de Java

Programación Orientada a Objetos

Publicado por William (5 intervenciones) el 02/07/2020 09:21:28
Comparto proyecto si a alguien le interesa o le vale de algo
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
sin imagen de perfil
Val: 12
Ha disminuido su posición en 117 puestos en Java (en relación al último mes)
Gráfica de Java

Programación Orientada a Objetos

Publicado por William (5 intervenciones) el 06/06/2020 01:16:15
Veo que con ese codigo se organiza mejor y para crear las matrices como podria hacer.
Igual con paquetes y clases.
Me podria ayudar a llenar las matrices
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