Laboratorio 1: Java |
Podeis descargar ejemplos resueltos del lenguaje Java de aquí.
Clase plantilla
class Ejemplo
{
public static void main(String args[])
{
System.out.println("HOLA MUNDO");
}
}
Salida:
System.out.println("HOLA");
Entrada:
DataInputStream din = new DataInputStream(System.in);
String s = din.readLine();
Pero previamente importando java io: import java.io.*;
class Cosa
{
public String nombre;
public void setNombre (String name)
{
nombre = name;
}
public String getNombre()
{
return "COSA";
}
}
class Ejemplo
{
public static void main(String args[])
{
Cosa c = new Cosa();
System.out.println(c.getNombre());
}
}
| Ejercicio 1: ¿ Se puede ahora modificar directamente la propiedad nombre sin utilizar el método
setNombre ? Escribid el código que lo demuestra. Utilizando ocultación de información proteged el código y demostrad ahora con código que ya no se puede acceder a la propiedad. Ejercicio 2. Añadirle un constructor a la clase Cosa. Ejercicio 3. Añadirle a Cosa una propiedad de clase (estatica) patas y dos métodos estáticos de get y set de acceso a la propiedad patas. Mostrar su utilización desde una clase cliente: Cosa.setPatas(3); Ejercicio 4. ¿ Podemos modificar la propiedad de instancia "nombre" desde el metodo de clase "setPatas" ? ¿ Por qué ? |
int a =1;
int b= 2*3;
int lista[] = new int[3];
lista[0] = a;
Integer awrap = new Integer(a);
int x = awrap.intValue();
int y = Integer.parseInt("123");
String z = String.valueOf(y);
| Ejercicio 5, Cread un array de cosas (Cosa) , y recorredlo mostrando por pantalla el valor de cada nombre. Ejercicio 6. Cambiad el tipo del Array para que sea de tipo Object. ¿ Hay alguna diferencia ? ¿ Podemos añadir objetos Cosa a un array de Object ? ¿ Y enteros (int) ? |
import java.awt.Point;
class PassByValue {
public static void modifyPoint(Point pt, int j)
{
pt.setLocation(5,5);
j = 15;
}
public static void main(String args[])
{
Point p = new Point(0,0);
//1
int i = 10;
modifyPoint(p, i);
//2
//3
}
}
import java.awt.Point;
class sample
{
public static void main (String args[])
{
Point p = new Point (1,1);
Point p2 = p;
p2.setLocation(120,120);
//Aliasing
System.out.println("Valor de p:" + p.getX());
System.out.println("Valor de p2:" + p2.getX());
Point p3 = (Point)p.clone();
p3.setLocation(40,40);
System.out.println("Valor de p:" + p.getX());
System.out.println("Valor de p3:" + p3.getX());
}
}
class Animal
{
public void habla()
{
return "Soy un animal";
}
}
class Perro extends Animal
{
public void habla()
{
return "Soy un perro";
}
}
class Ejemplo
{
public static void main(String args[])
{
Animal a = new Animal();
Perro p = new Perro();
Gato g = new Gato ();
Animal granja [] =new Granja [3];
granja[0] = a;
granja[1] = p;
granja[2] = g;
for (int i=0;i<granja.length;i++)
System.out.println(granja[i].habla());
}
}
| Ejercicio 7: Sustituid la clase Animal por una clase abstracta.¿ Cambia en algo ? Sustituid la clase Animal por una interface . ¿ Cambia en algo ? Ejercicio 8. Crear una nueva clase Loro que extienda el método habla para refinarlo ("Soy un animal" "y ademas soy un loro") Ejercicio 9. Crear un constructor que inicialice la edad del animal. ¿ Cambia en algo el problema? Ejercicio 10. Meter todos los animales en un paquete animales. La clase de test que recorre la granja debe pertenecer al paquete por defecto y no al paquete animales. Ejercicio 11. Haced un programa que liste por pantalla todos los metodos de una clase concreta. (recordad Metaclase) Ejercicio 12. Implementar el ejemplo de la granja de Animales con una Coleccción en lugar de un Array. |
// Multiple interfaces
import java.util.*;
interface CanFight {
void fight();
}
interface CanSwim {
void swim();
}
interface CanFly {
void fly();
}
class ActionCharacter {
public void fight() {}
}
class Hero extends ActionCharacter
implements CanFight, CanSwim, CanFly {
public void swim() {}
public void fly() {}
}
public class Adventure {
static void t(CanFight x) { x.fight(); }
static void u(CanSwim x) { x.swim(); }
static void v(CanFly x) { x.fly(); }
static void w(ActionCharacter x) { x.fight(); }
public static void main(String[] args) {
Hero i = new Hero();
t(i); // Treat it as a CanFight
u(i); // Treat it as a CanSwim
v(i); // Treat it as a CanFly
w(i); // Treat it as an ActionCharacter
}
} ///:~
Todas las propiedades de una interface son estáticas y finales -> podemos usarlas como enumeraciones
de valores constantes:
public interface Months {
int
JANUARY = 1, FEBRUARY = 2, MARCH = 3,
APRIL = 4, MAY = 5, JUNE = 6, JULY = 7,
AUGUST = 8, SEPTEMBER = 9, OCTOBER = 10,
NOVEMBER = 11, DECEMBER = 12;
} ///:~
Recorrido de una colección: Iterator
import java.util.*;
public class Test
{
public static void main( String args[] )
{
Collection c;
c = new ArrayList();
test(c);
c = new LinkedList();
test(c);
c = new HashSet();
test(c);
c = new TreeSet();
test(c);
}
public static void test(Collection c)
{
String lista[] = {"uno", "dos" , "tres", "cuatro",
"tres"};
for( int i=0; i < lista.length; i++ )
c.add( lista[i] );
Iterator it = c.iterator();
while( it.hasNext() )
System.out.println( it.next() );
System.out.println( "-------------------------");
}
}
Evaluación de bloque en una colección: sort
import java.util.*;
public class Test2
{
public static void main( String args[] )
{
List c;
c = new ArrayList();
String lista[] = {"uno", "dos" , "tres", "cuatro"};
for( int i=0; i < lista.length; i++ )
c.add( lista[i] );
print(c);
Collections.sort(c);
print(c);
int loc = Collections.binarySearch( c,"dos");
System.out.println( "Posicion de "+"dos"+" = "+loc
);
}
public static void print(Collection c )
{
Iterator it = c.iterator();
while( it.hasNext() )
System.out.println( it.next() );
System.out.println( "-------------------------");
}
}
| class NoHayDineroException extends Exception { private int Dinero; public NoHayDineroException(int n) { super(); Dinero=n; } public int getDinero() { return Dinero; } } |
| class Cuenta { private int saldo; public Cuenta() { saldo=0; } public Cuenta(int n) { saldo=n; } public void meterDinero(int n) { saldo=saldo+n; } public void sacarDinero(int n) throws NoHayDineroException { if (saldo>n) saldo=saldo-n; else // diferencia de dinero throw new NoHayDineroException(n-saldo); } } |
| class Test { public static void main(String a[]) { Cuenta c=new Cuenta(5000); try{ c.sacarDinero(60000); }catch(NoHayDineroException e) { System.out.println("Te has pasao de money="+e.getDinero()); } } } |
public class PedroBean
{
private String nombre = "BUBA";
private RemoteEventListener remoter;
public String getNombre()
{
return nombre;
}
public void setNombre(String name)
{
nombre = name;
remoter.dataChanged(new RemoteEvent(this,"CHAT",name));
}
public void addRemoteEventListener(RemoteEventListener remoter)
{
this.remoter = remoter;
}
public void removeRemoteEventListener (RemoteEventListener remoter)
{
this.remoter = null;
}
}
import java.util.EventListener;
public interface RemoteEventListener
{
void dataChanged(RemoteEvent evt);
}
Etiquetas:
Referencia: Thinking in Java.
//: Property.java
import java.util.*;
/** The first Thinking in Java example program.
* Lists system information on current machine.
* @author Bruce Eckel
* @author http://www.BruceEckel.com
* @version 1.0
*/
public class Property {
/** Sole entry point to class & application
* @param args array of string arguments
* @return No return value
* @exception exceptions No exceptions thrown
*/
public static void main(String[] args) {
System.out.println(new Date());
Properties p = System.getProperties();
p.list(System.out);
System.out.println("--- Memory Usage:");
Runtime rt = Runtime.getRuntime();
System.out.println("Total Memory = "
+ rt.totalMemory()
+ " Free Memory = "
+ rt.freeMemory());
}
} ///:~
java.util.Properties
| import java.util.*; import java.io.*; public class PropsWrite { public static void main(String args[]) { try { FileOutputStream fos = new FileOutputStream("env.properties"); Properties props = new Properties(); props.setProperty("principal","pedro"); props.setProperty("eventUrl","elvin://pgarcia.etse.urv.es:2917"); props.store(fos,"NS"); }catch (IOException e){} } } |
import java.util.*; import java.io.*; public class PropsLoad{ public static void main(String args[]) { try { FileInputStream fis = new FileInputStream("env.properties"); Properties props = new Properties(); props.load(fis); System.out.println(props.getProperty("principal")); }catch (IOException e){} } } |
Creación de clases
| Animal a = Class.forName("Animal").newInstance(); |
Se trata de modelar el problema de un banco. El banco consta de una lista de cuentas y una lista de clientes.
De los clientes tenemos su DNI, nombre y apellidos, dirección
y telefono.
Sobre un banco podemos efectuar una revision de todas las cuentas del mismo.
En cada cuenta podemos ingresar dinero, sacar dinero, consultar saldo, cambiar el cliente, y efectuar una revisión
mensual. Todas las cuentas tienen una comisión de 100 ptas que puede ser modificada. La revisión
mensual hace lo siguiente:
saldo = saldo + saldo* interes_de_la_cuenta -comision
Hay tres tipos de cuenta: CuentaCorriente (CC), CuentaVivienda (CV) y FondoInversion (FI). La CuentaCorriente tiene
un interes del 0.1, la CuentaVivienda de 0.2 y el FondoInversion de 0.3. De la CC no se puede sacar más
dinero del que hay, del FI se pueden sacar hasta 100.000 ptas de numeros rojos, y de la CV no se puede sacar dinero.
La revision mensual de la CV no paga comision bancaria. La revision mensual del FI quita ademas el dinero siguiente
si se esta en numeros rojos: saldo_negativo * 0.2. Si se llega a 100.000 ptas de deuda la cuenta se bloquea y no
se puede sacar dinero de ella.
Hay que implementar el problema en Java, y crear una clase de Test que compruebe la funcionalidad de las clases.
No es necesaria la creación de interfaz gráfica o textual.
Opcional: Incluir en el test un ejemplo de ordenación de cuentas por saldo o titular.
Localizar los conceptos de:
Se valorará la limpieza y elegancia del codigo y APIs.
Se trata de modelar el juego del TurboRisk en Java, adaptándolo a un modelo
orientado a objetos. Las rutinas PProgram, PHuman, Canalysis, CLeader, UMessage,
Ulog, UBufferSet, UBufferGet y URandom son opcionales.
A diferencia del TurboRISK en el que los territorios y continentes están prefijados
de antemano, nuestro Risk permitirá la creación de continentes y paises a medida.
Los jugadores se introducirán a partir de un fichero de Properties.
Es necesario disponer de al menos dos jugadores sencillos de ejemplo y una clase
de Test que pruebe la ejecución de uno o varios turnos del juego.
No es necesario seguir estrictamente el API de TurboRISK. Podeis adaptar las
llamadas para que sigan un modelo más natural de orientacion a objetos. Autodocumentar
el código con JavaDoc.
No es necesaria la creación de interfaz gráfica o textual.