Practica 9

Empezamos con las aplicaciones graficas.. ains

Ejercicio 1

Bueno esta practica al ser la primera de swing los primeros apartados son de reflexion que si has ido a clase ya tan.
5.En la linea frame.setSize(100,50); multiplicas por 4 listos frame.setSize(100*4,50*4);
6.Lo hacemos con este metodo contentPane.setBackground(Color.BLUE);
8. Lo que sucede es que la ventana tarda mucho en salir.
9. Se lanza la ventana y hasta que esta no se cierre no acaba el programa
10. Fuerzas el cierre del programa y eso mata todos los hilos

Ejercicio 2

2.Para ignorar el cierre de la ventana recurrimos en el metodo setDefaultCloseOperation en vez le pasarle como parametro EXIT_ON_CLOSE, DO_NOTHING_ON_CLOSE. Asi que ahora la unica manera de cerrar el programa es Ctrl+c en la consola.
3.Para hacer una ventana sin decoracion ninguna, antes de hacerla visible usamos frame.setUndecorated(true);
4.Para tener la decoracion por defecto tenemos que usar ANTES de crear la ventana (el metodo es static) JFrame.setDefaultLookAndFeelDecorated(true);

Ejercicio 3

1. Copiar HelloWorldGUIColor pero cambiando el color de fondo y el del texto, eso es como antes. ¿Maximizar? no se, aparte de darle al botoncito como hacerlo, se admiten sugerencias, y la pista no me llevo a ningun sitio.
2.Afortunadamente en el API de BorderLayout te viene un ejemplo que es practicamente igual que lo que tienes que hacer.
contentPane.add(labelN, BorderLayout.NORTH);
contentPane.add(labelS, BorderLayout.SOUTH);
contentPane.add(labelE, BorderLayout.EAST);
contentPane.add(labelO, BorderLayout.WEST);
antes hay que crear las etiquetas y modificar el color, naturalmente. Aqui tengo otro problemilla ya que no se me pone el color de fondo.
3.Este y Oeste se quedan centradas(verticalmente) pero Norte y Sur se alinean a la izquierda(horizontalmente). Quiza Este y Oeste tambien pero al ocupar todo el ancho no se nota.
4. Primero se cambia el color que es lo facil y ahora a buscar algo para centrar...afortunadamente encontramos un metodo al que hay que meterle como parametro la constante(¿?) CENTER, asi queda bien: labelN.setHorizontalAlignment(JLabel.CENTER);\\para norte
labelS.setHorizontalAlignment(JLabel.CENTER);\\para sur
5.Hay que copiar el anterior y insertarle una imagen en el centro, a mi no me sale, mi problema es que no se consruir el JLabel con la imagen
6. Otra vez copiar del anterior y añadir
frame.pack();
despues de size

7.8. Para estos dos apartados escribo lo mismo, no me salen me tendre que mirar lo que me tenga que mirar el caso es que no consigo, se agradecen ayudas.

Ejercicio 4

1. Hago todo excepto el borde con el nombre….. aqui va lo que hay.
Primero creamos el JFrame y todo esto como de costumbre, luego creamos un JPanel con un GridLayout
JPanel grid = new JPanel(new GridLayout(20,1));
a continuacion lo rellenamos con etiquetas depende de la posicion su color, con este for:
for(int i= 0; i<20;i++){
JLabel label =new JLabel(“label “+i);

if(i%2==1){
label.setBackground(Color.WHITE);
label.setForeground(Color.BLACK);
}
else{
label.setBackground(Color.BLACK);
label.setForeground(Color.WHITE);
}

grid.add(label);
}

me sigue faltando lo del fondo de antes…
Por ultimo metemos el panel en la ventana
frame.setContentPane(grid);

y lo hacemos visible como siempre.

2. Pues mas o menos es hacer todo lo de antes junto, en una misma ventana. Como ya te dan la estructura indicada en los bordes esa parte ya la tienes pensada. La estructura es un GridLayout de una fila y dos columnas, la de la izquierda es un BorderLayout como el que ya hemos hecho. La primera es otro GridLayout de una columna y tres filas que contiene un FlowLayout, un BoxLayout y un GridBagLayout con etiquetas dentro. Los iremos uniendo con los add() y haciendolos con lo anterior de la practica, no voy a entrar en mas detalles ya que prefiero solucionar las dudas que tengo antes de hacer este.

PRACTICA 8

Ejercicio 1

En el primer ejercicio vamos a hacer un programa para meter trucos en un videojuego, la verdad es que asi a bote pronto no tengo muy claro que es lo que hacer o mas bien como. Todo esto para aprender a usar una tabla Hash. El los metodos del programa practicamente llaman a los metodos de HashTable

Ejercicio 2

En este todos los apartados son de “estudia al el funcionamiento de:”. Entendidos ya estan, ya que el metodo factorial y el fibonacci son el HelloWorld de los ejercicios recursivos y no hay año que no los mires, estos metodos para facilitarte su comprension puedes mirarlos como si fueran bucles. Para practicar y hacer tu ejercicios, la pagina recomendada tiene ejercicios bastante utiles, ademas de distintos grados de dificultad. Pero Bueno, analicemos los metodos:

1 Factorial: Multiplica un numero con todos los anteriores, esto es, multiplica el numero dado con el factorial del numero anterior. Los va multiplicando todos hasta que llega al 1.

2.P1: Tiene un funcionamiento similar a factorial pero en vez de multiplicar muestra por pantalla.Muestra por pantalla el numero que le metas y hace lo mismo con el anterior, hasta que llega a 0 que sale y muestra FIN.

3.P2: Este metodo muestra la suma del numero que le metas con todos los anteriores, eso siempre que le metas 0 como parametro en b. Va a sumar “a” a “b” y lo va a volver a hacer con el numero anterior a “a”, pero siendo “b” en este caso “a+b”.Todo esto hasta que a sea 0.

4.Suma: Devuelve la suma de todos los numeros del array metido como parametro. Este metodo es especialmente claro visualizarlo como un bucle for. Va recorriendo el array posicion a posicion (clasicamente i++) hasta su ultima posicion, pero como tamaño lo metes como parametro y no es tabla.length se saldra si es mayor que tabla.length y dara error en tiempo de ejecucion.

5.inverso: Te da el numero al reves de como lo metes, si metes el 756 te dara el 657. Muestra por pantalla (sin saltar linea) las unidades del numero que sea y lo divide entre diez, al no quedar con decimales es como si le quitases las unidades y vuelves a hacer lo mismo. En realidad no da el numero inverso, muestra uno a uno los numeros, que, al quedar juntos, se ven como el inverso.

6.Fibonacci: Devuelve la suma de los 2 numeros anteriores al numero dado, que a su vez son la suma de sus dos anteriores.

Ejercicio 3

Se te pide hacer un metodo recursivo para comprovar que una matriz booleana tiene una fila ocupada, tomando true como ocupada.
public boolean linea(boolean[] lin){

return linea(lin,0);
}

Este metodo esta para ser llamado y llamar a linea(mas abajo) ya que si el numero que le metemos como parametro no es 0 no podemos estar seguros de que el metodo esta en lo cierto al devolver true. Por lo mismo el metodo siguiente sera pribado.
private boolean linea(boolean[] lin,int i){

// true == ocupada
if(lin[i]){
if(i==lin.length-1)
return true;
else
return linea(lin,i+1);

}
else
return false;
}

El metodo devuelve false en caso de que haya una casilla en la fila que sea false. Si es true comprueba si es la ultima o no, si es la ultima es que todas son true por lo que devuelve true, si no es la ultima devuelve el resultado de la siguiente, con lo que seguira hasta encontrar una false o llegar al final.

Lo siguiente es un metodo que compruebe ¿? que todas las filas son true¿?, no estoy muy seguro de lo que te pide realmente, yo he hecho eso, comprobar que todas las filas son true, probablemente no sea eso lo que te piden, a ver si alguien me lo puede aclarar.
Asi que este metodo es practicamente igual que el anterior solo que en vez de comprobar que la posicion de el array es true tengo que llamar al metodo anterior para que compruebe que la linea entera es true.
public boolean todas(boolean[][] mun){

return todas(mun,0);
}

private boolean todas(boolean[][] mun,int i){

if(linea(mun[i])){
if(i==mun.length-1)
return true;
else
return todas(mun,i+1);
}
else
return false;
}

Practica 7

En esta práctica lo que se nos pide es comprender el uso y utilizacion de memoria dinamica a partir de la practica anterior en la que usamos una cola estatica.

Modificamos nuestra clase cola,quedando un codigo como este:

import java.util.Vector;
class Cola
{
int primero;
int ultimo;

//* Metodo constructor */

public Cola(int numElementos)
{

Vector nuevo = new Vector(numElementos+1);

primero = 0;
ultimo = 0;
}

/** La cola estará vacía cuando el primero esté en la misma posición que el último */

public boolean vacia()
{
boolean loes=false;
if(primero == ultimo)
loes =true;
return loes;
}

/** Nos permite saber si la cola esta llena */
public boolean llena()
{
boolean loes=false;
if (siguiente(ultimo) == primero);
return loes;
}

/** Inserta una pieza en la cola. No hacemos comprobación de cola llena */
public void encolar(Pieza pieza)
{
nuevo(ultimo) = pieza;
ultimo = siguiente(ultimo); /

}

/** Desencolamos el primer elemento de la cola */
public Pieza desencolar()
{
Pieza elemento = nuevo(primero);
primero = siguiente(primero);
return elemento;
}

/** Recorrido circular */
private int siguiente(int indice)
{
return (indice + 1) % (elementos.length);
}

} // ColaPiezas

Aqui termina la practica de hoy,espero que para aquellos que no hayis llegado os sirva y tambien para aquellos que vean algun error o una posible mejora en nuestro código.

Muchas gracias y buena suerte.

Practica 6

Manos a la obra.

Comenzamos la clase con una breve explicacion de lo que realmente queria el profesor que llevaramos a cabo en esta practica.

El primer paso fue realizar una clase Cola completa,es decir que encolase,desencolase piezas.Para ello realizamos el siguiente codigo:

class Cola

{

private Pieza elementos[];

int primero, ultimo;

public Cola(int numElementos)

{

elementos = new Pieza[numElementos+1];

primero = 0;

ultimo = 0;

}

El metodo vacia nos permitira saber si nuestra cola esta vacia o no.

/** La cola estará vacía cuando el primero esté en la misma posición que el último */

public boolean vacia()

{

boolean ok;

if (primero == ultimo)

ok =true;

else ok =false;

return ok;

}

Realizamos un método que nos indica si la cola esta llena, el metodo es el siguiente:

public boolean llena()

{

return siguiente(ultimo) == primero;

}

Ahora hacemos un metodo que nos permite encolar las piezas:

public void encolar(Pieza pieza)

{

elementos[ultimo] = pieza;

ultimo = siguiente(ultimo);

}

/** Desencolamos el primer elemento de la cola */

public Pieza desencolar()

{

Pieza elemento = elementos[primero];

primero = siguiente(primero);

return elemento;

}

/** Recorrido circular */

private int siguiente(int indice)

{

return (indice + 1) % (elementos.length);

}

}

Y esto es todo lo realizado en las dos horas de practica que dispusimos,y lo único que sabemos hacer,por otro lado hay una cosa que nos queda muy claro ya que en clase el profesor de prácticas nos pidio que realizaramos una clase cola y su metodo main, sin embargo, la practica en si nos pedia diseñar una clase tetris asi como todos sus componentes por lo que aparentemente para muchos puede tener gran relación y asi poder continuar la práctica para nosotros no lo es,asi que, que progresemos en nuestra practica depende de vuestra ayuda un poquito jejeje.

¿alguien nos podría decir como continuar con el resto de clases que quedan?

Practica 5

Ejercicio 1

No hay mucho que hacer aqui pero si de leer y entender. Hacer, solo quitar las referencias al método toString y ya ta.

Ejercicio 2
En este ejercicio hay que hacer un metodo que guarde el valor del método toString() en un fichero. Solo hay que escribir una linea, lo difícil es encontrar en el api el método, el método en cuestión es:

out.write(this.toString());
con esto escribe el metodo toString en un fichero

Ejercicio 3

Este ejercicio es la practica, muuuuuy grande, después de haberte leído lo que vas a hacer, en el apartado 3.1 ya empiezas a tener que hacer algo, después de que el enunciado te destroce mentalmente

3.1

¡Si son tres cosas!, pero encuentralas. Parece el busca a Wally en el api mas empanada mental garantizada. Las lineas de la discordia:

en tercer lugar el método paint(), en el que solamente hay que llamar a los otros 2 métodos pasandoles Graphics g como parámetros tal que asin:

public void paint( Graphics g ) {

S.o.pln();

pintaFondo(g);
pintaBorde(g);

En el segundo puesto el método pintaBorde(); que dibuja un rectángulo y le pone color tal que asin:

protected void pintaBorde( Graphics g ) {
System.out.println(“Componente -pintaBorde() : ” +(ComponenteGrafico)this);
// establecemos el color para pintar el borde
g.setColor(colorBorde);
// Dibujamos un rectángulo del tamaño del componente
g.drawRect(posX,posY,ancho,alto);
}

Y por ultimo y hay que ver lo que me costo encontrar el metodo que rellenara el rectángulo: pintaFondo(); que rellena el rectángulo del colorFondo:

protected void pintaFondo( Graphics g ) {
System.out.println(“Componente -pintaFondo() : ” +(ComponenteGrafico)this);
//Se establece el color de fondo.
g.setColor(colorFondo);
// Se rellena un rectángulo de ese color
g.fillRect(posX,posY,ancho,alto);
}

Por cierto, en los dibujos de la practica aparece el rectángulo en amarillo y el resto en una especie de gris. A mi me sale blanco pero me imagino que estará bien, que sera por pegar la imagen o algo ya que la clase tiene como atributos colorFondo y colorBorde y ningún otro.

Apartado 3.2

Después de acabar con ComponenteGrafico tenemos que hacer las clases hijas (de ComponenteGrafico) Botón y Menú.

Lo primero sera hacer el constructor de cada una de ellas ya que son casi iguales, solo hay que llamar al constructor de ComponenteGrafico con super y dar valores a los dos nuevos atributos que tiene cada una. Todo ello con los parámetros del constructor, lo de siempre.

super(x,y,ancho,alto,colorFondo,colorBorde);
this.colorTexto=colorTexto;
this.texto=texto;

y

super(x,y,ancho,alto,colorFondo,colorBorde);
this.colorTexto= colorTexto;
this.opciones=opciones;

Lo siguiente sera el método paint. Para ello seguimos las instrucciones que vienen en las clases que nos descargamos.

Botón:

Lo primero de todo es llamar la método paint de padre con

super.paint;

lo siguiente es establecer el color del texto con el método utilizado anteriormente setColor(Color c) tal que así

g.setColor(colorTexto);
(asta aqui lo que hay que hacer el lo mismo para menú que para menú)

solo falta dibujar el texto para que “aproximadamente” este centrado. Esto lo puedes ir haciendo a ojimetro viendo como te queda o poner que este en la mitad del ancho y alto, que deberia ser el medio

g.drawString(texto,super.posX+super.ancho/2,super.posY+super.alto/2);

y ya esta botón.

Menú

Es casi lo mismo que Boton, la unica diferencia es que tendremos un array de String en vez de un String. Pero en un comentario nos dicen que hacer, nada mas que convertir ese array en un String concatenando los String del array separados por un espacio. Se hace con un for
String aux= “”;
for(int i=0; i<opciones.length;i++){
aux=aux+opciones[0]+” “;
}
luego en el método drawString ponemos nuestro String auxiliar y listos.

Apartado 3.3

Después de leernos y entender este apartado empezamos con el constructor que, para no variar, no hay que hacer nada especial en el: llamar con super e inicialicar el atributo componente, al darte el tamaño del array lo haremos así:
componente = new ComponenteGrafico[numComponentes];

paint

Lo siguiente en hacer es este método por ser mas fácil mas que nada. Lo único que hay que hacer es recorrer el array de componentes llamando a su método paint. Como lo único que hacemos del array es crearlo antes de llamar a paint mejor comprobamos si hay algo.
for ( int i=0 ; i<componente.length ; i++) {
if ( componente[i] != null){
componente[i].paint(g);
}
}

añade

Dado un ComponenteGrafico c tenemos que añadirlo en la primera posicion libre del array, para ello recorremos el array y en la primera posición libre que encontremos lo dejamos hay. Para que no siga recorriendo el array ya que la siguiente posición también estará libre tenemos que poner algo que lo corte. No se si este método sera muy “elegante” pero a mi, ¡me funciona!. Creo antes del for una variable booleana que se volverá false al meter el componente y cerrara el for.
boolean porponer=true;
for (int i=0; i<componente.length&&porponer ; i++ ){
if ( componente[i] == null ){
componente[i] = c;
porponer=false;
}
}

Apartado 3.4

Aquí ya hemos metido el automático y el constructor sale solo. Después te despiertas y miras lo que estas haciendo (una ventana), los métodos a hacer son…. son no, es paint solamente. En paint tendremos que pintar a la ventana misma y dentro todos los componentes.
Para pintar la ventana recordamos los métodos de los paint anteriores y seguimos las instrucciones.
// Pintamos el fondo de la ventana (Ventana es un Componente)
this.pintaFondo(g);
// Pintamos el título de la ventana en su posición aproximada
// Establecemos el color del texto
g.setColor(colorTexto);

// Pintamos el texto aproximadamente en la esquina superior izquierda
g.drawString(titulo,this.posY,this.posY+1);

// Pintamos el borde de la ventana (Ventana es un Componente)
pintaBorde(g);
Eso debería valer para la ventana, queda pintar los componentes. Como muy bien te recuerdan hereda de GUIContenedor y mirando su método paint y solo hay que llamarlo para obtener lo que queremos. La ultima linea es:
super.paint(g);

Apartado 3.5

BIIIIEEEN. Por fin el ultimo apartado de la practica, aquí vamos a usar todo lo que hemos hecho anteriormente para crear una aplicación gráfica. Tenemos que crear el constructor, que ira llamando a todos los constructores anteriores en orden (en el orden que te digan claro).

Constructor

no es especialmente complicado, primero creamos la ventana con todos los atributos que tenemos mas el titulo que sacamos del dibujo
ventana = new Ventana(X_VENTANA,Y_VENTANA,ANCHO_VENTANA, ALTO_VENTANA, COLOR_FONDO_VENTANA, COLOR_BORDE_VENTANA, COLOR_TEXTO_VENTANA, “Mi primer GUI”, NUM_COMPONENTES);
Lo siguiente es el menu, en este llamamos al constructor con cuidado de sumar las posiciones para que quede dentro de la ventana
menu=new menu(X_VENTANA+X_MENU, Y_VENTANA+Y_MENU, ANCHO_MENU, ALTO_MENU, COLOR_FONDO_MENU, COLOR_BORDE_MENU, COLOR_TEXTO_MENU, opcionesMenu);
Solo faltan dos botones de nombre boton 1 y boton 2. Sumaremos de nuevo las posiciones
boton1 = new Boton(X_VENTANA+X_BOTON1, Y_VENTANA+Y_BOTON1, ANCHO_BOTON1,ALTO_BOTON1, COLOR_FONDO_BOTON1, COLOR_BORDE_BOTON1, COLOR_TEXTO_BOTON1, “boton1″);
boton2 = new Boton(X_VENTANA+X_BOTON2, Y_VENTANA+Y_BOTON2, ANCHO_BOTON2, ALTO_BOTON2, COLOR_FONDO_BOTON2, COLOR_BORDE_BOTON2, COLOR_TEXTO_BOTON2, “boton2″);

Solo falta añadir los componentes a las ventana con el metodo añade:
ventana.añade(menu);
ventana.añade(boton1);
ventana.añade(boton2);

paint

Este es fácil, como dice el enunciado de la practica: Simplemente hay que invocar al método paint() de Ventana.
ventana.paint(g);

y por fin acabamos la practica esta….. no se, a mi se me ha hecho muy larga.

Practica 4

Haber si aplicamos bien el nuevo enfoque…

Ejercicio1:

Nada en especial, solo hacer un constructor clasico inicializando atributos

this.nombre= nombre;
this.modificadores=modificadores;

y un metodo toString(); como los de la anterior practica.

Ejercicio 2:

Crear Atributo ahora partiendo de la clase base Miembro, con modificar un par de cosillas para añadir llamadas al constructor de Miembro y a su metodo toString() ; mediante super lo tenemos.

super(nombre,modificadores);
this.tipo = tipo;

super.toString()+”, TIPO …..

Ejercicio 3:

La clase metodo. El constructor se hace de la misma forma que el de Atributo, lo unico diferente es, en el metodo toString(); añadir los parametros, que, al estar en un array los tienes que recorrer con un for.

Ejercicio 4:

La clase Constructor. Esta clase deriva de Metodo y es casi igual, asi que el metodo toString() lo solucionamos llamando directamente al superior

return super.toString();

y la unica diferencia con metodo la solucionamos llamando al constructor dejando vacio el tipo de retorno

super(nombre,modificadores,”",parametros);

Ejercicio 5:

Aqui es donde esta la mayor dificultad de esta practica:

En la practica anterior tenias tus arrays para cada cosa tan ricamente sin molestar a nadie y aqui tenemos uno solo con todo junto mas apretado que en el metro.

Asi que ahora en los metodos getAtributo,getConstructores y getmetodos tendremos que sacar todos los respectivos de cada clase y juntarlos en un array suyo, lo bueno es que una vez hecho uno, el resto es igual, solo tienes que copiar, pegar y unir los puntos.

Primero calcule el tamaño que tendra el array con:

int contador=0;
for(int i=0;i<miembros.length;i++)
if(miembros[i] instanceof Constructor)
contador++;

la clave de todo va a estar en el instance of que te compara si el miembro de la posicion i es un Constructor y en hacer casting para convertir los miembros salientes en constructores. Lo cual seguiria asi:

Constructor[] aux = new Constructor[contador];
int j =0;
for(int i=0;i<miembros.length;i++){
if(miembros[i] instanceof Constructor){
aux[j]=(Constructor)miembros[i];
j++;
}
}
return aux;

Esto te vale para los otros get, nada mas tienes que cambiar Constructor por Metodo o lo que sea.

Me acabo de dar cuenta de que mi contador es en realidad un atributo que ya te es dado; numAtributos, etc.. bueno, ya que esta hecho no lo voy a borrar.

para el metodo esEjecutable solo habra que comprobar si uno de los metodos se llama main

Metodo[] aux = this.getMetodos();
boolean es = false;
for(int i=0;i<aux.length;i++)
if(aux[i].nombre.equals(“main”) )
es = true;
return es;

asi, si lo encuentra, devuelve true.

Por ultimo, toString, es como todos los toString hechos hasta ahora, ir recorriendo en orden los arrays gracias a nuestros metodos get para llamar a sus respectivos toString, y antes comprobar si es ejecutable o no.

EJercicio6

Facil, no hacer nada, eso lo se hacer

Ejercicio 7

ClasePrueba es basicamente un main para ver si todo funciona crear lo que hay que crear y si todo funciona, ya esta

Practica 3

Muy bien practica 3, empezamos con una introducción en la que necesitamos comprender muy bien dos conceptos,abstracción y encapsulación.

El principio de la abstracción es aquel por el cual la mente humana realiza modelos la realidad en forma de objetos.

El principio de la encapsulación está relacionado con la “ocultación de la información” por la que la información que almacena un objeto debería permanecer aislada del exterior para aislarla de posibles cambios en la misma.

EJERCICIO 1:

Comenzamos bajandonos el archivo necesario (Modificador), nos piden compilar y ejecutar la clase pasándole como argumento un número entero que coincida con alguna de las constantes anteriores y observemos el resultado.

Ok, primero hacemos un metodo main para poder ejecutarla sin problemas.

La linea que debemos introducir en la linea de comandos es la siguiente:

-Javac Modificador.java

Despues de compilar sin problemas introducimos:

-java Modificador.java 32

Nota:32 podira ser cualquier otro numero.

y observamos el resultado :

SYNCHRONIZED

EJERCICIO 2:

En este ejercicio, se pide implementar estos dos métodos. Para ello, descarga el esqueleto de la clases Atributo del siguiente enlace y modifícalo: Atributo.java

Abrimos el archivo e implementamos el codigo de la siguiente forma junto con el metodo main para su posterior comprobacion:
public String toString() {
String to = “ATRIBUTO : NOMBRE=”+this.nombre+” TIPO=”+this.tipo+” MODIFICADOR ACCESO=”+Modificador.toString(this.modificadores)+“\n”;
return to;
}
public static void main(String[] args){
Atributo at = new Atributo(“nombre1″,“cosa”,4);
System.out.println(at.nombre);
System.out.println(at.toString());

y al ejecutarlo obtenmos como resultado lo siguiente:

ATRIBUTO : NOMBRE=nombre1 TIPO=cosa MODIFICADOR ACCESO=protected

 

EJERCICIO3

Para este ejercicio, se pide implementar estos métodos en cada una de las respectivas clases Metodo y Constructor. Descárgalas de los siguientes enlaces y modifícalas: Metodo.java y Constructor.java

Para conseguir lo pedido,es decir que al final de la practica nos muestre constructor y metodo de la siguiente forma:

METODO : NOMBRE=<nombre_MetodoPublico> MODIFICADOR ACCESO= public TIPO RETORNO =void

CONSTRUCTOR : NOMBRE=<nombre_Constructor> MODIFICADOR ACCESO= public

aplicamos el siguiente código para el Constructor:

public Constructor(String nombre, int modificadores) {
this.nombre = nombre;
this.modificadores = modificadores;
} public String toString() {
String to = “CONSTRUCTOR : NOMBRE=”+this.nombre+” MODIFICADOR ACCESO=”+Modificador.toString(this.modificadores)+“\n”;
return to;
}}

y para el Método:

public Metodo(String nombre, int modificadores, String tipoRetorno) {this.nombre= nombre;
this.modificadores= modificadores;
this.tipoRetorno= tipoRetorno;
}

public String toString() {
String to =“METODO :NOMBRE=”+this.nombre+” MODIFICADOR ACCESO=”+Modificador.toString(this.modificadores)+” TIPO RETORNO =”+this.tipoRetorno+“\n”;
return to;}
}

EJERCICIO 5

En este ejercicio, se pide implementar los métodos de acceso y el método toString(). Para ello, descarga el código de la Clase del siguiente enlace y modifícalo de acuerdo a las indicaciones: Clase.java

En primer lugar implementamos los metodos get muy faciles de hacer:

public Atributo[] getAtributos() {

return this.atributos;
}

public Constructor[] getConstructores() {

return this.constructores;
}

public Metodo[] getMetodos() {

return this.metodos;
}

y por ultimo el toString:

public String toString() {
String to = “CLASE : NOMBRE=”+this.nombre+“\nATRIBUTOS:\n”;
for(int i=0;i<atributos.length;i++)
to= to+atributos[i].toString();
to=to+“CONSTRUCTORES:\n”;
for(int i=0;i<constructores.length;i++)
to=to+constructores[i].toString();
to= to+“METODOS:\n”;
for(int i=0;i<metodos.length;i++)
to= to+metodos[i].toString();

return to;

 

EJERCICIO 6

 

 

1. Crear dos objetos respectivamente de la clase ClasePrueba y OtraClasePrueba respectivamente.
2. Crea dos objetos respectivamente de la clase AnalizadorObjeto a partir de los objetos anteriores.
3. Imprimir la información de los objetos que proporciona la clase AnalizadorObjeto.
4. Imprimir el número total de objetos analizados.

El codigo es el siguiente:

/**
 *
 * @author DIT-Uc3M
 */
    public class ClasePrueba {
   
      public String atributoPublico=”publico”;
      protected int atributoProtegido = 0;
      private char atributoPrivado=’a';
   
       public ClasePrueba() {
      }
   
       public ClasePrueba( String param1, int param2 ) {
      
      
      }
   
       public void metodoPublico() {
       
      }
   
       protected void metodoProtegido() {
       
      }
   
       private void metodoPrivado() {
       
      }
      
       public static void main(String[] args){
     
         ClasePrueba cp = new ClasePrueba();
         ClasePrueba cp2 = new ClasePrueba();
         ClasePrueba cp3 = new ClasePrueba();
         AnalizadorObjeto ao = new AnalizadorObjeto(cp);
      
         System.out.println(ao.toString());
         AnalizadorObjeto ao2 = new AnalizadorObjeto(cp2);
         System.out.println(ao2.toString());
      }
   }

 Obteniendo así el resultado pedido en la práctica!!

 

Si teneis alguna duda no dudeis en mandarnos un comentario . 

Un saludo

 

 

 

 

 

 

 

 

 

Práctica 2

Sobre esta práctica,¿qúe podemos decir? la verdad es que mucho y poco a la vez.Poco en cuestion a cosas aprendidas y mucho debido a la gran cantidad de dudas que surgieron por cada linea de lectura del enunciado.

Comenzamos con una parte introductoria de como configurar la maquina virtual de nuestro ordenador,¡¡hasta hora cosa fácil!! simplemente nos limitamos a seguir las explicaciones del profesor,chupado!.

Siguiente paso entender y saber usar las llamadas aserciones y trazas de depuración…creo que se entendio ,digo creo porque hasta prácticas futuras no comprobaré mi verdadero potencial asimilado sobre esta parte,en fin actitud 100% de alumno irresponsable,cosas que nunca cambiaran.

La cosa no parecia muy dificil,todo marchaba sobre ruedas,mi compi y yo nos permitiamos el lujo de jugar y modificar los enunciados propuestos en la práctica en plan “mira como pilotamos”,que panda de ilusos,no muy lejos de esas palabras se hayaba el comienzo de nuestra recesión,de nuestra caida en picado hacia el abismo de las dudas.

¿Qué es una excepción?…si si seguro que algún listillo lo sabe, o mas bien casi todo el mundo lo sabe pero de todos esos quien sabe ¿cómo tratarlas?…try annd catch. Con un par de explicaciones del profesoy y de mis queridos compañeros repetidores que pilotan bastante mas que nosotros conseguimos entender algo,digo algo otra vez porque ya saben como funciona esto,crees saber algo peeeeero…

En fin digamos que con esa parte nuestra practica termino,las excepciones fueron nuestro David mientras que nosotros caiamos como el pobre Goliat nos desplomamos tras un par de arremetidas en los ejercicios 3 y posteriormente el 4.Eso es todo por nuestra parte,no hubo mas contacto con esta practica asi que si lo hay( si lo vuelve haber,poco probable) les mantendremos informados.

Practica -1

 Aqui estamos otro año, con la verdadera intencion de llevar la asignatura al dia, ir a todas las clase, ser bueno, responsable y no volver a tener resaca un lunes (vamos, lo de todos los años)…..  Pero Esta Vez De Verdad¡¡¡¡

Empezamos con la practica 1, o -1 despues de ver en el primer ejercicio el Holamundo… bueno, siempre es util para desentumecerte los dedos despues de un cuatrimestre sin tocarlo.

Especialmente util los 10 mandamientos de java para empezar. En realidad solo habia 9 pero podemos añadir uno a gusto del consumidor para tener un numero mas bonito.

Despues de pasarseme la nostalgia del Holamundo (snif) acamos este apartado sin mayor dificultad. Yujuu , un punto para nuestra memoria, seguimos haber que tal.

Asi que argumentos de entrada…  eh…  y solo transporta materia…. bueno afortunadamente por ahora estamos felices como perdices, pues parece que al final sirvio de algo esas horas hechadas, que dure…

Los ejercicios 3 y 4 los hicimos asi sin querer juntitos, empezamos con; Uy pero si asi es mejor y cuando llegamos al 4 ya estaba practicamente hecho. Nota mental: darme un puñetazo cada vez que piense que esto es facil.

AUUUAAAA, primeras alarmas al ver la palabra “fichero”, bloqueo mental y llamada de socorro al profesor…. para luego darnos cuenta de que en la linea siguiente te dicen lo que tienes que hacer que es poco mas que seguir las instrucciones, buf…. falsa alarma.

Y tras unos pocos deberes para casa acaba esta practica sin novedad. Sin muchas mas ganas de escribir se acaba este comentario, no vemos

¡¡¡¡Bienvenidos!!!!

Al final nos hemos decidido a crear nuestro blog! mucha pereza habia despues de los examenes y las vacaciones tomadas(mucha fiesta,mucho alcohol…,buaah eso ya lo sabeis todos) pero al al final aqui nos teneis para que nos escribais muchas muchas dudas y nosotros a vosotros !! un saludos compis.