miércoles, 17 de marzo de 2010

Laboratorio sobre cadenas y arreglos en Java, Segunda parte (04.07.02)

Segunda parte

Modifique la clase Pelicula y agregue el atributo: cliente (Cliente) que sera quien alquile la pelicula, implemente el método set y get correspondientes.
Modifique la clase Cliente y agregue el atributo: importeAlquiler (float) implemente su métodos set y get correspondiente.
Modifique la clase BaseDeDatos y agregue un método que permite calcular el importe de alquiler de un cliente. La aplicación debe permitir realizar el alquiler de 3 películas al cliente 2002 y muestre su costo.

Pelicula.java
package tacora;
public class Pelicula {
         private Cliente cliente;
        //...
          public void setCliente(Cliente alquiladoPor) {
        cliente = alquiladoPor;
         }
}

Cliente.java
package tacora;
public class Cliente {

private float importeAlquiler;
//...
}
BaseDeDatos.java
package tacora;
public class BaseDeDatos {
//...
public static float getImporte(Cliente cliente) {

Pelicula pelicula = null;
float importe = 0;
for (int i = 0;...) {
if (pelicula[i].getCliente().getId() == cliente.getId()) {
importe += pelicula[i].getPrecio();
}
}
return importe;
}
}

TacoraArreglos.java
package tacora;
public class TacoraArreglos {

public static void main (String[] args) {

int clienteId;
int peliculaId1;
int peliculaId2;
int peliculaId3;

if (args.length != 4)
System.out.println("java TacoraArreglos 2002 9001 9002 9003");
else {
clienteId = args[0];
peliculaId1= args[1];
peliculaId2= args[2];
peliculaId3= args[3];
}
BaseDeDatos bd = new BaseDeDatos();

Cliente cliente = bd.getCliente(clienteId);
Pelicula pelicula1 = bd.getPelicula(peliculaId1);
pelicula1.setCliente(cliente);
Pelicula pelicula2 = bd.getPelicula(peliculaId2);
pelicula2.setCliente(cliente);
bd.getPelicula(peliculaId3).setCliente(cliente);

System.out.println(cliente);

System.out.println(pelicula1);
System.out.println(pelicula2);
System.out.println(bd.getPelicula(peliculaId3));

System.out.println(bd.getImporte(cliente));
}
}
Compartir:

Laboratorio sobre cadenas/String y arreglos/array en Java. (04.07.01)

Primera Parte

Cree la clase Cliente que tendrá los siguiente datos id (int) nombre, direccion, telefono (String)
La clase debe contar con dos constructores.
Uno sin argumentos para autogenerar el id (que inicia en cero).
Otro que aceptara los datos nombre, dirección, teléfono.
El código del cliente debe ser automático e incrementarse en uno cada vez que se cree una instancia. Los códigos inician en 2001
Opcionalmente agregue los métodos set y get para estos atributos.
También agregue el método toString() para mostrar los datos del cliente así como el código creado automáticamente.

Cree la clase Pelicula con los siguientes datos: id (int) titulo, tipo (String) precio (float),
La clase debe contar con dos constructores.
Uno sin argumentos para autogenerar el id (que inicia en 1).
Otro que aceptara los datos titulo, tipo, precio .
El código de la Pelicula debe ser automático e incrementarse en uno cada vez que se cree una instancia. Los códigos inician en 9001
Opcionalmente agregue los métodos set y get para estos atributos.
También agregue el método toString() para mostrar los datos de la pelicula incluido el código autogenerado.

Cliente.java
public class Cliente {

private int id;
private static int ultimoId=2000;
private String nombre;
private String direccion;
private String telefono;

public Cliente() {
this.id = ultimoId;
ultimoId++;
}

public Cliente(String nombre, String nuevaDireccion, String nuevoTelefono) {
this();
this.nombre = nombre;
this.direccion = nuevaDireccion;
this.telefono = nuevoTelefono;
}
public void setNombre(String nuevoNombre) {
nombre = nuevoNombre;

}
public void setDireccion(String nuevoDireccion) {
direccion = nuevoDireccion;
}
public void setTelefono(String nuevoTelefono) {
telefono = nuevoTelefono;
}
public int getId() {
return id;
}
public static int getUltimoId() {
return ultimoId;
}
public String getNombre() {
return nombre;
}
public String getDireccion() {
return direccion;
}
public String getTelefono() {
return telefono;
}
public String toString(){
return ("Codigo : "+id+" "+nombre+" "+direccion+" "+telefono);
}
}
//...
Pelicula.java
public class Pelicula {

private int id;
private static int ultimoId=9000;
private String titulo;
private String tipo;
private float precio;

public Pelicula() {
this.id = ultimoId;
ultimoId++;
}
public Pelicula(String nuevoTitulo,String nuevoTipo) {
this();
this.titulo = nuevoTitulo;
this.tipo = nuevoTipo;
}
public void setTitulo(String nuevoTitulo) {
titulo = nuevoTitulo;
}
public void setTipo(String nuevoTipo) {
tipo = nuevoTipo;
}
public void setPrecio(float nuevoPrecio) {
precio = nuevoPrecio;
}
public String getTitulo() {
return titulo;
}
public String getTipo() {
return tipo;
}
public int getId() {
return id;
}
public float getPrecio() {
return id;
}
public static int getUltimoId() {
return ultimoId;
}
public String toString() {
return ("Codigo : "+id+" "+titulo+" "+tipo);
}
}

Defina la clase BaseDeDatos con tres métodos: en el primero creara 4 clientes (nombres familiares) y 6 peliculas (que haya visto en cine o televisión). Los clientes y las películas se encontraran en un arreglo. El segundo devolvera el objeto cliente ingresando el id del cliente. El tercero realizara lo mismo con el id de una pelicula.

BaseDeDatos.java
package tacora;
public class BaseDeDatos {

private static Cliente[] cliente = new Cliente[4];
private static Pelicula[] pelicula = new Pelicula[6];

public BaseDeDatos() {
cliente[0] = new Cliente("Daneel Olivaw","Solaria 4", "511-711-2542");
//...
pelicula[0] = new Pelicula("Neverland","Drama",10.0f);
//...
}

public static Cliente getCliente(int id) {
for (...) {
break;
}
return cliente[];
}
public static Pelicula getPelicula(int id) ...

}

Cree la aplicación Arreglos que permita Cargar la base de datos y mostrar los datos del cliente con codigo 2002 y la pelicula con codigo 9003

TacoraArreglos.java
package tacora;
public class TacoraArreglos {

public static void main (String[] args) {

int clienteId;
int peliculaId;

if (args.length != 2)
System.out.println("java TacoraArreglos 2002 9003");
else {
clienteId = Integer.parseInt(args[0]);
peliculaId = Integer.parseInt(args[1]);
}
BaseDeDatos bd = new BaseDeDatos();
System.out.println(BaseDeDatos.getCliente(clienteId ));
System.out.println(BaseDeDatos.getPelicula(peliculaId));
}

}
Compartir:

El metodo main en Java (04.06.02)

main() cuenta con un único parámetro que es un arreglo de cadenas.
Este arreglo de cadenas son los parámetros de la linea de comandos.

C:\> java Eco Hola Mundo
// Eco.java
package ejercicios;
public class Eco {

public static void main (String [] args) {

if (args.length != 2)
System.out.println("Uso: java Eco Arg1 Arg2");
else
System.out.println(args[0] + " " + args[1]);

}

}
Compartir:

Arreglos de cadenas en Java (04.06.01)

Un arreglo de cadenas también sigue los pasos de creación de arreglos.

Declaracion

String [] categorías;
Creación

categorias = new String[3];
Iniciación.

categorias[0] = "Drama";

// Creando una arreglo de cadenas vacias.
String [] arreglo = new String [4];
for ( int i = 0; i < arreglo.length; i++ ) {
arreglo[i] = new String();
}

// Creando e iniciando un arreglo.
String [] categorias = {"Drama", "Comedia", "Accion"};

// Accesando los elementos del arreglo
String [] categorias = {"Drama", "Comedia", "Accion"};
System.out.println(" Comedia = "+ categorías[1].length() );

Ejercicios sobre cadenas/String en Java (04.06.01)

Cual es el resultado de:

//
String [] categorias = {"Drama", "Comedia", "Accion", "Infantil"};
int indice = categorías.length – 2;
System.out.println(categorías[indice].length() );
Compartir:

Ejercicios sobre cadenas String en Java (04.05.11)

Cual es la respuesta de:

public class Cadenas {

public static void main (String [] args) {

// Bloque 1
String s = new String("Viernes");
if (s=="Viernes")
System.out.println("Respuesta A");

if (s.equals("Viernes"))
System.out.println("Respuesta B");

// Bloque 2
int num1 = 1234567;
System.out.println(String.valueOf(num1).charAt(3));

// Bloque 3
String s1 = "Lunes";
String s2 = "Martes";
System.out.println(s1.concat(s2).substring(4,8));

// Bloque 4
// s3 inicia con 2 espacios y tambien termina con 2.
String s3 = " Lunes ";
System.out.println(s3.indexOf("es"));
System.out.println(s3.trim().indexOf("es"));

}
}
Compartir:

Comparando regiones de una cadena en Java (04.05.08)

String url = "http://www.uni.edu.pe";

if (url.endsWith(".pe"))
System.out.println("Pagina Nacional");
else
System.out.println("Pagina Extranjera");


String parametro = "ip = 192.100.51.2";
if (parametro.startsWith("ip"))
System.out.println("La direccion "+parametro);
else
System.out.println("El parámetro no es una ip");
Compartir:

Concatenacion de cadenas en Java (04.04.03)

Para concatenar cadenas puede usar lo siguiente:
// Usando el operador +
System.out.println(" Nombre = " + nombreEmpleado );
// Puede concatenar primitivas y cadenas.
int edad = 22;
System.out.println(" Edad = " + edad );
// Mediante la función concat()
String nombre = "Elijah ";
String apellidos = "Baley ";
String nombreCompleto = nombre.concat(apellidos);
Compartir:

Construccion de cadenas en Java (04.04.02)

También se puede usar la siguiente sintaxis para construir cadenas.
// con una constante
String nombreEmpleado = new String("R. Daneel Olivaw");
// con una cadena vacia
String inicio = new String();
// copiando una cadena
String copiaEmpleado = new String(nombreEmpleado);
// con un arreglo de char
char[] vocales = {'a','e','i','o','u'};
String cadenaVocales = new String(vocales);
Compartir:

Cadenas String en Java (04.04.01)

Una cadena es una secuencia de caracteres
La librería String (o clase String) se usa para definir todas las cadenas en Java.
Las cadenas se delimitan con comillas dobles.

//
System.out.println("Hola Mundo.");
String camara = "Camara";
String luces = camara +" Accion";
String vacio = "";
//
Compartir:

Problema con arreglos en java (04.03.02)

Se cuenta con los arreglos siete y ocho
Multiplicar el primer elemento del arreglo siete con el primer elemento del arreglo ocho y así sucesivamente. Almacenar el resultado en otro arreglo y muéstrelo.
Matriz.java
package ejercicios;
public class Matriz {
public static void main(String[] args) {
int[] siete = {7,17,27,37,47,57,67,77,87,97,107};
int[] ocho = {8,18,28,38,48,58,68,98,108,118,198};
...
}
}
Compartir:

Ejercicio con arreglos en java (04.03.01)

Se tiene en un arreglo las notas del examen parcial de 10 alumnos. Encuentre la mínima y máxima nota.

Notas.java
package ejercicios;
public class Notas {

public static void main(String[] args) {
int[] notas = {12, 04, 07, 18, 10, 15, 05, 16, 18, 11};

int i = 0;
double min= 20.1;
double max= 00.0;
while (i < 10) {
...
i++;
}
System.out.println(max);
System.out.println(min);
}
}
Compartir:

Arreglos multidimensionales (04.02.01)

Se trata de arreglos de arreglos y se declara de la siguiente forma:

tipo[][] nombreArreglo = new tipo[cantidadFilas][cantidadColumnas];
int[][] tabla = new int[4][2];
tabla[0][0] = 1;
tabla[0][1] = 7;
tabla[1][0] = 3;
tabla[1][1] = 5;
tabla[2][0] = 4;
tabla[2][1] = 8;


Definir una matriz de enteros colocando como valores la suma de su numero de fila y columna en la matriz
{
int n= 10;
int p= 20;
double[][] m = new double[n][p];
for (int i= 0; i<n; i++)
for (int j= 0; j<p; j++)
m[i][j]= i+j;
}
Compartir:

Ejercicio sobre arreglos Java (04.01.03)

Encuentre cuatro errores en el siguiente código

1. int[] a= new int[20];
2. float[] b= new float[10];
3. int a2 = new int[20];
4. int[] b2 = new float[10];
5. a[2] = -5;
6. a[4] = 10;
7. int k = a[6];
8. a[k] = 20;
9. a[20] = 0;
10. a[3] = 1.1;

Errores:
Ocurre ArrayIndexOutOfBoundsException cuando el índice del arreglo es incorrecto.
Ocurre NullPointerException cuando se intenta acceder a un elemento no inicializado.
Una primitiva no se puede comparar o asignar con un valor null.
Solo las referencias se comparan con null
Compartir:

Longitud de un arreglo/array en Java (04.01.02)

Los elementos de un arreglo inician con el valor por defecto de una primitiva.
La propiedad length del arreglo es su longitud.

Encuentre 3 errores en el siguiente código.
// bloque 1
int[] numeros = new int[5];
System.out.println(numeros.length-1);
// bloque 2
int[] truco = new int[3];
System.out.println(truco[0]);
// bloque 3
int[] cubos = {1, 8, 27, 64, 125};
int indice = cubos.length;
System.out.println(cubos[indice]);
// bloque 4
int[] pares = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20};
int cantidad = 0;
while (pares[cantidad] != null) {
cantidad++;
}
// bloque 5
char[] vocales;
System.out.println(vocales.length);
Compartir:

Arreglos array en Java (04.01.01)

Un arreglo es una colección de variables del mismo tipo. La longitud de un arreglo es fijo cuando se crea.

Los arreglos son muy usados para buscar datos, especialmente si se conocen sus valores cuando se crean. int[] diasMesesAnioBisiesto = {31,29,31,30,31,30,31,31,30,31,30,31};

Pasos de la creación de arreglos de primitivas
Se declara el arreglo
Inicialmente la variable referencia un valor nulo
int[] potencias; //forma mas usada
int potencias[];


Frame2
Se crea el arreglo
Se requiere la longitud del arreglo
potencias = new int[4];
En caso de variables primitivas se inician en 0 o false. Las primitivas no se pueden operar con el valor null.
En caso de variables referencia se inician en null. No referencian a ningún objeto.
Frame3
Se inicia los valores del arreglo
Se asignan valores elemento por elemento
potencias[0] = 1;
potencias[1] = 2;
potencias[2] = 4;
potencias[3] = 8;
Los arreglos pueden ser creados e iniciados al mismo tiempo
int[] potencias = {1,2,4,8};

Frame5
Compartir:

viernes, 5 de marzo de 2010

Problema sobre herencia y polimorfismo en Java (05.07.01)

Cree una clase Item.java con los siguientes atributos: id (int); titulo, descripción, ranking, categoría (String) , precio de alquiler por dia (double).
Todos estos atributos seran protected.
Agregue un atributo entero privado estático que inicia en 1000 para autogenerar el Id del item.
Agregue un constructor sin parámetros que autogenere un id para el item en base al atributo estático.
Agregue un segundo constructor con argumentos titulo, descripción, precio, ranking y categoría.
Este constructor invocara al primer constructor para asignar el id. Ademas asignara los argumentos a los atributos.
Agregue todos los métodos set y get para cada atributo.

Item.java
public class Item {
private static int siguienteId = 1000;
protected int id;
...
public Item() {
this.id = ++siguienteId;
}
public Item(String titulo... ) {
this();
this.titulo = titulo...
}
public int getId()...
...
public void setTitulo(String titulo)...
public String getTitulo()...
...
public static int getSiguienteId()...
}

La clase Cliente contara con 2 atributos, su id y su nombre. El id se generara automáticamente.
Cliente.java
public class Cliente {
private static int siguienteId = 2000;
protected int id;
...
public Cliente() {
this.id = ++siguienteId;
}
public Cliente(String nombre) {
this();
this.nombre...
}
public int getId()...
public String getNombre()...
}

Cree una clase Pelicula.java que herede de Item.java con los siguientes atributos: duracion (int) y director (String). Estos atributos seran privados.
Agregue un constructor con argumentos titulo, descripción, precio, ranking, numero de dias, categoría, duración y director.
Este constructor invocara al constructor de la superclase y luego asignara los dos ultimos argumentos a sus atributos privados.
Agregue todos los métodos set y get para sus dos atributos privados.
Agregue el método toString() que devuelva todos los atributos privados y heredados

Pelicula.java
public class Pelicula extends Item {
private String director;
private int duracion;
public Pelicula(String titulo ... int duracion) {
super(...);
this.director = director;
this.duracion = duracion;
}
public void setDirector...
public String getDirector...
public void setDuracion...
public String getDuracion...
public String toString...
}

Cree una clase Juego.java que herede de Item.java con los siguientes atributos: memoria (int) y tipo (String). Estos atributos seran privados.
Agregue un constructor con argumentos titulo, descripción, precio, ranking, numero de dias, categoría, memoria y tipo.
Este constructor invocara al constructor de la superclase y luego asignara los dos últimos argumentos a sus atributos privados.
Agregue todos los métodos set y get para sus dos atributos privados.
Agregue el método toString() que devuelva todos los atributos privados y heredados

Juego.java
public class Juego extends Item {
private int memoria;
private String tipo;
public Juego(String titulo ... String tipo) {
super(...);
this.memoria=...;
this.tipo=...;
}
...setMemoria...
...getMemoria...
...setTipo...
...getTipo...
public String toString...
}

En la base de datos se encontraran la lista de películas y los juegos.

BaseDeDatos.java
public class BaseDeDatos {

Cliente[] cliente = new Cliente [4];
Items[] item = new Item [4];

public BaseDeDatos() {

cliente[0] = new Cliente("Daneel Olivaw");
//...
item[0] = new Pelicula("La caravana del valor",...);
item[1] = new Pelicula("En las lunas de Endor",...);
item[2] = new Juego("Mu Online",...);
item[3] = new Juego("War Craft",...);
//...
}

public static Cliente getCliente(int id) {
Cliente cliente1 = null;
for (...) {
break;
}
return cliente1;
}

public static Item getItem(int id) ...
}


La clase Alquiler.java contara con los siguientes atributos: un arreglo de Ítems que se alquilaran (Item) el cliente que alquila (Cliente) un numero de alquiler id (int), la cantidad de ítems alquilados (int) y la cantidad de dias de alquiler (int).
Un atributo de clase privado estático entero será el contador de id que iniciara en 500.
Una constante será el máximo numero de ítems a alquilar que es 10.
Una constante será el impuesto del alquiler de 19%.
Un constructor asignara el cliente por argumento y el numero de dias de alquiler. También creara el arreglo de ítems, y su numero de alquiler.
Un método para agregar ítems al arreglo de ítems del alquiler.
Un método imprimira todo el detalle del alquiler en pantalla.
Alquiler.java
public class Alquiler {
private static int siguienteAlquilerId = 500;
private int alquilerId;
private int numeroDias;
private int clienteId;
private int cantidadItems;
private int[] itemId;
private final static int MAXITEMS = 10;
private final static double IMPUESTO = 0.19;
...
public Alquiler(int clienteId, int numeroDias) {
this.alquilerId = ...
this.clienteId = ...
...
itemId = new int[MAXITEMS];
}
public void agregarItem(int item) {
if (...) {
itemId[...] = item;
cantidadItems++;
}
else System.out.println("Demasiados ítems!");
}
public void imprimirReporte() {
/*
Cliente Id: 2000 Nombre: Salvor Hardin
Dias alquiler: 5
Detalle
1. El Padrino Precio = 1.10
2. Odisea 2001 Precio = 2.20
3. Aeropuerto 77 Precio = 3.30
Importe venta = 33.00
Importe total = 39.27
*/
}
}

El programa TacoraFilms realizara el alquiler
public class TacoraFilms {
public static void main(String[] args) {
Alquiler alquiler = new Alquiler(2001,5);
alquiler.agregarItem(1001);
alquiler.agregarItem(1002);
alquiler.agregarItem(1003);
alquiler.imprimerReporte();
}
}
Compartir:

Ejercicio sobre herencia en Java (05.06.01)

Encuentre los errores en el siguiente código.

Item.java
package alquiler;

public class Item {
public final int MAXIMO = 5;
public String getNombre() return "";
private String getColor() return "";
protected String getImporte() return "";
String getAlias() return "";
public final String getFabricante() return "";
}

Pelicula.java
package alquiler;
public class Pelicula extends Item {
public final int MAXIMO = 5;
public String getNombre() return super.getNombre();
private String getColor() return super.getColor();
protected String getImporte() return super.getImporte();
String getAlias() return super.getAlias();
public final String getFabricante()
return super.getFabricante();
}

Juguete.java
package almacen;
public final class Juguete {
Item item = new Item("");
public String getNombre() return item.getNombre();
public String getColor() return item.getColor();
protected String getImporte() return item.getImporte();
String getAlias() return item.getAlias();
}

Pelota.java
package almacen;
public final class Pelota extends Juguete {
public String getNombre() return super.getNombre();
public String getColor() return super.getColor();
protected String getImporte() return super.getImporte();
String getAlias() return super.getAlias();
}
Compartir:

El método finalize() en Java (05.05.01)

Cuando todas las referencias de un objeto se pierden, se marcan para que el Garbage Collector los recoja y libere ese espacio en memoria.

Pelicula pelicula = new Pelicula("Zelig");
pelicula = null;

El objeto "Zelig" que estaba referenciado por pelicula ha perdido todas sus referencias.

Luego el Garbage Collector liberara el espacio ocupado por "Zelig"

El método finalize es llamado justo antes que el Garbage Collector libere la memoria. En este instante se puede aprovechar para realizar otras operaciones.

public class Pelicula4 {
private String titulo;
public Pelicula4(String titulo) {
this.titulo = titulo;
}
public void finalize()
{
System.out.println("Se acabo "+titulo);
}
}

public class TestFinalize {

public static void main (String[] args) {
Pelicula4 globo = new Pelicula4("Zelig");
globo = null;
}
}
Compartir:

Clases final en Java (05.04.03)

Una clase final no puede ser padre de otra clase.
Una clase puede ser definida como final para evitar la herencia.
El compilador es mas eficiente con definiciones final por que no buscara estas clases o métodos al tratar clases heredadas.

Aqui no se puede extender ninguna clase de Color.java

Color.java
public final class Color {
public final static String NEGRO = "FFFFFF";
public final static String getBlanco() {
return "000000";
}
}

/* Paleta.java
public final class Paleta.java extends Color.java {
...
}
*/

Ejercicio sobre final (metodo, clase, atributo) en Java (05.04.01)

Ejercicio: Realizar lo siguiente.

Librería.java
public final class Libreria {
public final static String BLANCO = "000000";
public final static float PI = 3.141592f;

public final static int getModulo10(int numero)
{
// Obtiene el modulo 10 de la suma de digitos
if (numero < 0) numero = -numero;
String cadena = String.valueOf(numero);
int suma = 0;
for (int i=1; i < cadena.length(); i++) {
String caracter = cadena.substring(i-1,i);
int digito = Integer.parseInt(caracter);
suma += digito;
}
int residuo = suma%10;
return residuo;
}
}

TestLibreria.java
public class TestLibreria {
public static void main (String[] args) {
System.out.println(Libreria.BLANCO);
System.out.println(Libreria.PI);
System.out.println(Libreria.getModulo10(11));
System.out.println(Libreria.getModulo10(880385));
}
}
Compartir:

Métodos final en Java (05.04.02)

Un método puede ser definida como final para evitar la sobre-escritura en una subclase.
Un método final no se puede redefinir en una clase hijo.

public final static String getBlanco() {
return "000000";
}
public final boolean verificarPassword(String password) {
if (password.equals(...
}

Aqui no se puede sobreescribir el metodo calcularImporte en la clase Pelicula4 por que calcularImporte de su clase padre es final.Item4.java
public class Item4 {
public final float calcularImporte(int cliente) {
return 50;
}
}
Pelicula4.java
public class Pelicula4 extends Item4 {
/* public float calcularImporte(int cliente) {
if (cliente < 500)
return 10;
else
return 30;
} */
}
Compartir:

Variables final en Java (05.04.01)

Una variable final es una constante
Una variable final no puede ser modificada
Una variable final debe ser iniciada
Una variable final por lo general es publica para que pueda ser accesada externamente.

Aqui no se puede cambiar los valores de las constantes

public class Constantes {
public final static String NEGRO = "FFFFFF";
public final static float PI = 3.141592f;
public final static int MAXIMO_ITEMS = 10;

Constantes() {
/*
NEGRO = '000000';
PI = 3.1416;
MAXIMO_ITEMS = 0;
*/
}
}
Compartir:

Cast implicito y explicito en Java (05.03.02)

El cast es implicito al convertir una clase hijo a una la clase padre.
El cast debe ser explicito al convertir de una clase padre a una clase hijo.

public class Movil {
String nombre;
Movil() { nombre = "Movil"; }
}
public class MovilPesado extends Movil {
MovilPesado() { nombre = "MovilPesado"; }
}
public class Camion extends MovilPesado {
Camion() { nombre = "Camion"; }
}
public class MovilLigero extends Movil {
MovilLigero() { nombre = "MovilLigero"; }
}
public class TestInstanceOfCast {
public static void main(String[] args) {
static boolean resultado;
static MovilPesado pesado = new MovilPesado();
static Camion volvo = new Camion();
static MovilPesado tren = null;
resultado = pesado instanceof MovilPesado;
System.out.print("pesado es un MovilPesado: " + resultado + "\n");
resultado = volvo instanceof MovilPesado;
System.out.print("volvo es un MovilPesado: " + resultado + "\n");
resultado = pesado instanceof Camion;
System.out.print("pesado is a Camion: " + resultado + "\n");
resultado = tren instanceof MovilPesado;
System.out.print("tren es un MovilPesado: " + resultado + "\n");
pesado = volvo; //Cast implicito. Un hijo se convierte en padre.
volvo = (Camion) pesado; //Cast explicito. Un padre se convierte en hijo.
}
}

Cast implicito en Java (05.03.03)

El cast es implicito al convertir un hijo en padre. Revise aqui el paso de parametros al metodo testOperador.
Para convertir un padre a hijo, se usa cast explicito

public class TestOperador {
public static void main (String[] args) {
Pelicula3 oscar = new Pelicula3();
Equipo3 vhs = new Equipo3();
Juego3 mu = new Juego3("Nintendo");
Libro3 quijote = new Libro3();
testOperador(oscar);
testOperador(vhs);
testOperador(mu);
testOperador(agua);
}
public static void testOperador (Item3 articulo) {
if (articulo instanceof Juego3) {
Juego3 juego = (Juego3) articulo;
System.out.println(juego.getFabricante());
}
else {
System.out.println("No tiene Fabricante");
}
}
}
Compartir:

El operador instanceof y cast en Java (05.03.01)

El operador instanceof permite determinar la clase de un objeto en tiempo de ejecución.
La operación cast permite modificar la clase de un objeto.

El siguiente ejemplo muestra el uso de instanceOf y como el metodo is3D(Punto p) puede reconocerlo

Punto.java
import java.lang.Math;
public class Punto {
protected int x, y;
public Punto ( int x, int y ) {
this.x = x;
this.y = y;
}
// Distancia al eje de coordenadas
public float distancia() {
return Math.sqrt(Math.pow(x,2.0)+Math.pow(y,2.0));
}
}

Punto3D.java

import java.lang.Math;
public class Punto3D extends Punto {
private int z;
public Punto3D ( int x, int y, int z ) {
super(x,y);
this.z = z;
}
// Distancia al eje de coordenadas
public float distancia() {
return Math.sqrt(Math.pow(x,2.0)+Math.pow(y,2.0)+Math.pow(z,2.0));
}
}


TestInstanceOf.java

public class TestInstanceOf {
public static boolean is3D(Punto p) {
return (p instanceof Punto3D);
}
public static void main(String[] args) {
Punto p2 = new Punto(0,0);
Punto p3 = new Punto3D(0,0,10);
System.out.println(is3D(p2));
}
}
Compartir:

Ejercicio de Polimorfismo en Java (05.02.02)

Agregue una nueva clase llamada Revista.java cuyo importe se basara en el día de la semana que se alquila.
Si es Sábado o Domingo el alquiler de las revistas será 5, en otro días será 2.

Alquiler3.java
public class Alquiler3 {
private int dias;
public Alquiler3(int dias) {
this.dias = dias;
}
public int getDias () {
return dias;
}
}
Item3.java
public class Item3 {
protected float calcularImporte(Alquiler3 contrato) {
return 0;
}
}
Pelicula3.java
public class Pelicula3 extends Item3 {
protected float calcularImporte(Alquiler3 contrato) {
int importe = 2*contrato.getDias();
return importe;
}
}
Equipo3.java
public class Equipo3 extends Item3 {
protected float calcularImporte(Alquiler3 contrato) {
int seguroEquipo = 50;
int importe = 5*contrato.getDias();
return seguroEquipo + importe;
}
}
Juego3.java
public class Juego3 extends Item3 {
String fabricante;
public Juego3(String fabricante) {
this.fabricante = fabricante;
}
public String getFabricante() {
return fabricante;
}
protected float calcularImporte(Alquiler3 contrato) {
String fabricante = this.fabricante;
int tasa = 0;
if (fabricante.equals("PlayStation")) tasa = 2;
if (fabricante.equals("Nintendo")) tasa = 1;
int importe = tasa*contrato.getDias();
return importe;
}
}
Libro3.java
public class Libro3 extends Item3 {
protected float calcularImporte(Alquiler3 contrato) {
return 0;
}
}
TestPolimorfismo.java
public class TestPolimorfismo {
public static void main (String[] args) {
Alquiler3 contrato = new Alquiler3(10);
Pelicula3 oscar = new Pelicula3();
System.out.println( oscar.calcularImporte(contrato) );
Equipo3 vhs = new Equipo3();
System.out.println( vhs.calcularImporte(contrato) );
Juego3 mu = new Juego3("Nintendo");
System.out.println( mu.calcularImporte(contrato) );
Libro3 quijote = new Libro3();
System.out.println( quijote.calcularImporte(contrato) );
}
}
Compartir:

Polimorfismo en Java (05.02.01)

Permite efectuar una misma operación dependiendo del tipo de objeto.
Ejemplo
TacoraFilms inicia sus operaciones alquilando únicamente películas.
Tres meses después amplia el alquiler a equipos, juegos y libros.
El alquiler de una pelicula es 2 soles por día de alquiler.
El alquiler de un equipo consta de un seguro de 50 soles además de 5 soles por día.
El alquiler de juegos depende del fabricante. PlayStation 2soles/día Nintendo 1sol/día
Los libros no se alquilan, se prestan uno a la vez, mientras sean clientes de la tienda.
Explique por que se obtienen los resultados

Alquiler3.java
public class Alquiler3 {
private int dias;
public Alquiler3(int dias) {
this.dias = dias;
}
public int getDias () {
return dias;
}
}
Item3.java
public class Item3 {
protected float calcularImporte(Alquiler3 contrato) {
return 0;
}
}
Pelicula3.java
public class Pelicula3 extends Item3 {
protected float calcularImporte(Alquiler3 contrato) {
int importe = 2*contrato.getDias();
return importe;
}
}
Equipo3.java
public class Equipo3 extends Item3 {
protected float calcularImporte(Alquiler3 contrato) {
int seguroEquipo = 50;
int importe = 5*contrato.getDias();
return seguroEquipo + importe;
}
}
Juego3.java
public class Juego3 extends Item3 {
String fabricante;
public Juego3(String fabricante) {
this.fabricante = fabricante;
}
public String getFabricante() {
return fabricante;
}
protected float calcularImporte(Alquiler3 contrato) {
String fabricante = this.fabricante;
int tasa = 0;
if (fabricante.equals("PlayStation")) tasa = 2;
if (fabricante.equals("Nintendo")) tasa = 1;
int importe = tasa*contrato.getDias();
return importe;
}
}
Libro3.java
public class Libro3 extends Item3 {
protected float calcularImporte(Alquiler3 contrato) {
return 0;
}
}
TestPolimorfismo.java
public class TestPolimorfismo {
public static void main (String[] args) {
Alquiler3 contrato = new Alquiler3(10);
Pelicula3 oscar = new Pelicula3();
System.out.println( oscar.calcularImporte(contrato) );
Equipo3 vhs = new Equipo3();
System.out.println( vhs.calcularImporte(contrato) );
Juego3 mu = new Juego3("Nintendo");
System.out.println( mu.calcularImporte(contrato) );
Libro3 quijote = new Libro3();
System.out.println( quijote.calcularImporte(contrato) );
}
}
Compartir:

La referencia super en Java (05.01.05)

Si una subclase sobrescribe un método de la superclase; el método de la superclase se puede invocar con la referencia super.
Item2.java
public class Item2 {
public float calcularImporte(int cliente) {
return 50;
}
}
Equipo2.java
public class Equipo2 extends Item2 {
public float calcularImporte(int cliente) {
float seguroEquipo = 25;
float alquiler = super.calcularImporte(cliente);
return seguroEquipo + alquiler;
}
}
TestSuper2.java
public class TestSuper2 {
public static void main (String[] args) {
Item2 articulo = new Item2();
System.out.println( articulo.calcularImporte(599) );
Equipo2 vhs = new Equipo2();
System.out.println( vhs.calcularImporte(599) );
}
}
Compartir:

Métodos heredados, this y super en Java (05.01.04)

La superclase define los métodos para todas las subclases.
La subclase puede especificar métodos propios.
Item0.java
public class Item0 {
protected float precio = 0;
Item0 (float precio) {
this.precio = precio;
}
public float getPrecio() {
return precio;
}
}
Pelicula0.java
public class Pelicula0 extends Item0
{
private String titulo = "";
Pelicula0 (float precio, String titulo) {
super(precio);
this.titulo = titulo;
}
public String getTitulo()
{
return titulo;
}
}

TestSuper.java
public class TestSuper {
public static void main (String[] args) {
Item0 item = new Item0(1.1f);
System.out.println( item.getPrecio() );
Pelicula0 pelicula = new Pelicula0(2.2f,"Zelig");
System.out.println( pelicula.getPrecio() );
System.out.println( pelicula.getTitulo() );
}
}

Que diferencia existe entre this y super?
Se puede reemplazar super(precio); por this.precio = precio; ?
Que métodos puede invocar una subclase?
La subclase hereda todos los métodos del padre.
La subclase puede re-escribir un método del padre.

Item1.java
public class Item1 {
public float calcularImporte(int cliente) {
return 50;
}
}
Pelicula1.java
public class Pelicula1 extends Item1 {
public float calcularImporte(int cliente) {
if (cliente < 500)
return 10;
else
return 30;
}
}

TestSobrescribir.java
public class TestSobrescribir {
public static void main (String[] args) {
Item1 item1 = new Item1();
System.out.println( item1.calcularImporte(599) )
Pelicula1 pelicula1 = new Pelicula1();
System.out.println( pelicula1.calcularImporte(399) );
System.out.println( pelicula1.calcularImporte(599) );
}
}
Cual es la diferencia entre sobre-carga de métodos y sobre-escritura de métodos?
Compartir:

La referencia super en Java (05.01.03)

Se refiere a la clase padre
Se usa para invocar constructores de la clase padre
Debe ser la primera sentencia del constructor de la clase hijo
Esta referencia también se usa para invocar cualquier método del padre.
public class Item {
protected float precio = 0;
Item (float precio) {
this.precio = precio;
}
}

public class Pelicula extends Item {
private String titulo = "";
Pelicula (float precio, String titulo) {
super(precio);
this.titulo = titulo;
}
}
Una subclase no hereda ningún constructor de la superclase, debe declararse explícitamente.
Solo en caso no se declare explícitamente, se ejecutaran los constructores por defecto de las superclases y finalmente de la subclase.

Pelicula pelicula = new Pelicula ();
// Inicia variables de la clase Item. Constructor por defecto.
// Inicia variables de la clase Pelicula. Constructor por defecto.
Compartir:

La herencia en Java (05.01.02)

Una subclase se define indicando a que superclase extiende.

public class Item {
// Definición de la superclase Item.
}
public class Pelicula extends Item {
// Atributos y métodos adicionales para distinguir una
// pelicula de otros tipos de item
}

Una subclase hereda todas las variables instancia de la superclase.
Las variables de instancia deben ser private para que instancias de la subclase hereden sus valores.

public class Item {
protected float precio = 0;
protected String estado = "Excelente";
}
public class Pelicula extends Item {
private String titulo = "";
private int duracion = 0;
}
Compartir:

La herencia (05.01.01)

Definición
Permite a una clase compartir la misma estructura de datos y comportamiento de otra clase.
La herencia minimiza la necesidad de duplicar código.
El Polimorfismo permite utilizar el método de acuerdo al objeto heredado.

Superclase : Item
Subclase : Pelicula , Libro , Equipo (DVD, VHS)

Que atributos tienen en común las subclases?

Que atributos no tienen en común las subclases?

Que método no tienen en común las subclases? Defina las subclases Libro y Equipo.
Como declararía las clases:
Hombre > Homínido > Primate > Placentario
Perro > Canino > Carnivoro > Placentario
Placentario > Mamífero > Vertebrado > Animal > Ser Vivo.
Compartir:

jueves, 4 de marzo de 2010

NumberFormat Formatear Numeros en Java (06.03.01)

public abstract class NumberFormat
extends Format
NumberFormat es una clase abstracta para formatear numeros permitiendo que el código sea independiente de las convenciones propias de cada pais.

TestNumberFormat.java
import java.text.*;
import java.util.*;
public class TestNumberFormat {

    public static void main(String[] args) {

        //Locale.setDefault(Locale.CANADA);

        //El simbolo 0 muestra un cero cuando no exista un digito.
        NumberFormat formatter = new DecimalFormat("000000");
        String s = formatter.format(-1234.567); // -001235
        System.out.println("000000 : "+s);
        //notese que el numero se ha redondeado

        //El simbolo # muestra un digito nada sino existe un digito
        formatter = new DecimalFormat("##");
        s = formatter.format(-1234.567); // -1235
        System.out.println("## : "+s);
        formatter = new DecimalFormat("##00");
        s = formatter.format(0); // 00
        System.out.println("##00 : "+s);

         //El simbolo . muestra el punto decimal
         formatter = new DecimalFormat(".00");
         s = formatter.format(-.567); // -.57
         System.out.println(".00 : "+s);
         formatter = new DecimalFormat("0.00");
         s = formatter.format(-.567); // -0.57
         System.out.println("0.00 : "+s);
         formatter = new DecimalFormat("#.#");
         s = formatter.format(-1234.567); // -1234.6
         System.out.println("#.# : "+s);
         formatter = new DecimalFormat("#.######");
         s = formatter.format(-1234.567); // -1234.567
         System.out.println("#.###### : "+s);
         formatter = new DecimalFormat(".######");
         s = formatter.format(-1234.567); // -1234.567
         System.out.println(".###### : "+s);
         formatter = new DecimalFormat("#.000000");
         s = formatter.format(-1234.567); // -1234.567000
         System.out.println("#.000000 : "+s);

         //El simbolo , se usa para agrupar numeros

formatter = new DecimalFormat("#,###,###");
s = formatter.format(-1234.567); // -1,235
System.out.println("#,###,### : "+s);
s = formatter.format(-1234567.890); // -1,234,568
System.out.println("#,###,### : "+s);
    }
}
Compartir:

SimpleDateFormat Fechas en Java (06.03.03)

public class SimpleDateFormat
extends DateFormat
SimpleDateFormat es una clase para formatear y parsear fechas permitiendo convetir datos fechas en texto y viceversa.

TestDateFormater.java
import java.text.*;
import java.util.*;
public class TestDateFormater {

    public static void main(String[] args)
    throws Exception
    {
        //Fecha -> String
        Calendar now = new GregorianCalendar();
        SimpleDateFormat name, standar;
        String nameFormat, standarFormat;

        //Obtener la fecha actual en un calendario
        Date nowDate = now.getTime();

        //Definimos dos formatos para mostrar fechas
        name = new SimpleDateFormat("EEEE, dd MMMM yyyy");
        standar = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
        //Aplicamos el formato a la fecha actual.
        nameFormat = name.format( nowDate );
        standarFormat = standar.format( nowDate );

        System.out.println(nameFormat);
        System.out.println(standarFormat);

        //Aplicamos un formato en otro idioma.
        name = new SimpleDateFormat("EEEE, dd MMMM yyyy", Locale.FRENCH);

        nameFormat = name.format(nowDate);

        System.out.println(nameFormat);
        //String -> Fecha
        Calendar cal = new GregorianCalendar();
        SimpleDateFormat format;

        //Definimos un formato
        format = new SimpleDateFormat("dd/MM/yyyy");
        //Se realiza parse al texto en base al formato
        Date calDate = format.parse("25/12/2005");

        //Se asigna la fecha al calendario.
        cal.setTime( calDate );

        int dayOfYear = cal.get(Calendar.DAY_OF_YEAR);
        int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);
        System.out.println("DAY_OF_YEAR: " + dayOfYear);
        System.out.println("DAY_OF_WEEK: " + dayOfWeek);
    }
}
Compartir:

GregorianCalendar Fechas en Java (06.03.02)

package java.util.*
public class GregorianCalendar
extends Calendar
La clase GregorianCalendar es una subclase de Calendar y maneja el calendario estandar usado en el mundo.

TestGregorianCalendar.java
import java.util.*;
public class TestGregorianCalendar {

    public static void main(String[] args) {

        //Que dia de la semana es navidad
        Calendar xmas = new GregorianCalendar(2005, Calendar.DECEMBER, 25);
        int dayOfWeek = xmas.get(Calendar.DAY_OF_WEEK);
        System.out.println("Dia (1=Domingo): " + dayOfWeek );

        //Cuantos dias tuvo febrero de 2005
        Calendar feb = new GregorianCalendar(2005, Calendar.FEBRUARY, 1);
        int days = feb.getActualMaximum(Calendar.DAY_OF_MONTH);
        System.out.println("dias en Feb 2005: " + days );

        //Cuantos dias tuvo febrero de 2000
        Calendar cal = new GregorianCalendar(2000, Calendar.FEBRUARY, 1);
        days = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
        System.out.println("dias en Feb 2000: " + days );

        //Determinar cual fue primero navidad o febrero
        boolean after = xmas.after(feb);
        boolean before = xmas.before(feb);

        System.out.println("xmas.after(feb): " + after );
        System.out.println("xmas.before(feb): " + before );
        //Obtener la diferencia en milisegundos
        long diffMillis = xmas.getTimeInMillis() - feb.getTimeInMillis();

        //Obtener la diferencia en segundos
        long diffSecs = diffMillis/1000;

        //Obtener la diferencia en minutos
        long diffMins = diffSecs/60;

        //Obtener la diferencia en horas
        long diffHours = diffMins/60;

        //Obtener la diferencia en dias
        long diffDays = diffHours/24;
        //Obtener la diferencia en meses
        long diffMonths = diffDays/30;

        System.out.println("diffMillis: " + diffMillis );
        System.out.println("diffSecs: " + diffSecs );
        System.out.println("diffMins: " + diffMins );
        System.out.println("diffHours: " + diffHours );
        System.out.println("diffDays: " + diffDays );
        System.out.println("diffMonths: " + diffMonths );
    }
}
Compartir:

Calendar Fechas en Java (06.03.01)

package java.util.*
public abstract class Calendar
extends Object
implements Serializable, Cloneable

Calendar es un clase abstracta para obtener de un dato tipo fecha, datos enteros como YEAR, MONTH, DAY, HOUR, entre otros.
(Un objeto Date representa un instante especifico de tiempo con presicion de milisegundos.)

Las subclases de Calendar interpretan un Date de acuerdo a las reglas de un calendario. Java provee la subclase GregorianCalendar.
Estan pendientes de desarrollar otros calendarios.
La clase Calendar provee una método de clase llamado getInstance que retorna un objeto inicializado con la fecha y hora actual.

TestCalendar.java

import java.util.*;
public class TestCalendar {
public static void main(String[] args) {
    // Obtener la fecha actual
    Calendar cal = Calendar.getInstance();
    // Obtener los componentes de la fecha.
    int era = cal.get(Calendar.ERA); // 0=BC, 1=AD
    int year = cal.get(Calendar.YEAR); // 2002
    int month = cal.get(Calendar.MONTH); // 0=Ene, 1=Feb, ...
    int weekOfYear = cal.get(Calendar.WEEK_OF_YEAR);
    int weekOfMonth = cal.get(Calendar.WEEK_OF_MONTH);
    int day = cal.get(Calendar.DAY_OF_MONTH); // 1...
    int dayOfYear = cal.get(Calendar.DAY_OF_YEAR); //
    int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK); //1=Domingo,2=Lunes...
    int dayOfWeekInMonth = cal.get(Calendar.DAY_OF_WEEK_IN_MONTH);
    System.out.println("ERA: " + era);
    System.out.println("YEAR: " + year);
    System.out.println("MONTH: " + month);
    System.out.println("WEEK_OF_YEAR: " + weekOfYear);
    System.out.println("WEEK_OF_MONTH: " + weekOfMonth);
    System.out.println("DAY_OF_MONTH: " + day);
    System.out.println("DAY_OF_YEAR: " + dayOfYear);
    System.out.println("DAY_OF_WEEK: " + dayOfWeek);
    System.out.println("DAY_OF_WEEK_IN_MONTH: "+dayOfWeekInMonth);
    // Obtener hora actual
    int ampm = cal.get(Calendar.AM_PM); // 0=am 1=pm
    int hour = cal.get(Calendar.HOUR); // 0..23
    int hourOfDay = cal.get(Calendar.HOUR_OF_DAY);
    int minute = cal.get(Calendar.MINUTE); // 0..60
    int second = cal.get(Calendar.SECOND); // 0..60
    int miliSecond = cal.get(Calendar.MILLISECOND);
    System.out.println("AM_PM: " + ampm );
    System.out.println("HOUR: " + hour);
    System.out.println("HOUR_OF_DAY: " + hourOfDay);
    System.out.println("MINUTE: " + minute);
    System.out.println("SECOND: " + second);
    System.out.println("MILLISECOND: " + miliSecond);
    }
}
Compartir:

Ejercicios sobre Interfaces en Java (06.02.02)

Ejercicio 1
Crear la interfaz PuedeCantar (que es capaz de cantar), un interfaz muy simple que sólo posee un método cantar.

PuedeCantar.java

public interface PuedeCantar {
    public void cantar();
}
Crear la clase Persona que implemente el interfaz PuedeCantar y que cuando cante lo haga con las notas musicales.

Persona.java

public class Persona implements PuedeCantar {
    public void cantar() {
        System.out.println("do re mi fa sol la si");
    }
}
Crear la clase Canario y Gallo que implemente el interfaz PuedeCantar y que muestre como cantan
Canario.java
    ... System.out.println("pio pio pio") ...
Gallo.java
    ... System.out.println("ki ki ri ki") ...

Realice el programa que haga cantar a un canario y un tenor.

ProgramaInterfaz.java

public class ProgramaInterfaz {
     public static void main(String arg[]) {
        Persona pavaroti = new Persona();
        hacerCantar(pavaroti);
        Canario piolin = new Canario();
        hacerCantar(piolin);
        Gallo claudio = new Gallo();
        hacerCantar(claudio);
    }
    public static void hacerCantar(PuedeCantar cantor) {
        cantor.cantar();
    }
}

Ejercicio 2
Algunos seres pueden caminar y puede nadar estas dos capacidades son interfaces (PuedeCaminar.java y PuedeNadar.java).
Los mamiferos son animales que pueden moverse (Mamifero.java). El gato es un mamifero que puede nadar y moverse (Gato.java).
Un Loro puede caminar pero no puede nadar.

PuedeCaminar.java

public interface PuedeCaminar{
    public void caminar();
}
PuedeNadar.java
public interface PuedeNadar {
    public void nadar();
}
Mamifero.java
public class Mamifero {
    String especie, color;
    public void caminar() {
        System.out.println("El mamífero camina");
    }
}
Gato.java
public class Gato extends Mamifero implements PuedeCaminar, PuedeNadar {
    private int numeroPatas = 4;
    public void nadar() {
        System.out.println("El gato nada");
    }
}
Loro.java
public class Loro implements PuedeCaminar...
    ...System.out.println("El loro camina");
    ...

Interfaces.java
public class Interfaces {
    public static void main(String[] args) {
        Gato felix = new Gato();
        felix.caminar();
        felix.nadar();
        Loro pepe = new Loro();
        pepe.caminar();
    }
}
Por que no se requiere escribir todos los métodos de las interfaces en la clase Gato?

Ejercicios adicionales
Agregue al ejercicio anterior la interface PuedeVolar.java
Agregue la superclase Aves.java
Herede la clase Avestruz.java (ave que solo camina)
Herede la clase Loro.java (ave que camina y vuela)
Herede la clase Murciélago.java (es un mamífero que vuela y camina)
Cree la clase Felino.java (es un mamifero que camina y puede nadar).
Modifique la clase Gato.java (es un Felino)
Cree la clase Tigre.java
Compartir:

Interfases en Java (06.02.01)

Una interfase es totalmente abstracta; todos sus métodos son abstractos, sus atributos son públicos estáticos y final.
Una interfase define los métodos que otras clases pueden implementar pero no provee ninguna línea de código.
Una clase solo puede heredar de una superclase.
Una clase puede implementar muchas interfases; por lo que las interfases permiten herencia múltiple.

Ejemplos de interfases:
Las interfases describen la conducta que requiere muchas clases.
El nombre de una interfase por lo general es un adjetivo como Conducible, Ordenable, Ubicable.
Aquí se diferencia de una clase que usualmente es un sustantivo como Pelicula, Cliente, Alquiler
Las clases implementadas por una interfase pueden ser no tener ninguna relación unas con otras.
A diferencia de las clases heredadas de una superclase tiene similitudes.
Las clases que implementan una interface deben definir todos los métodos de la interface.

Conducible.java
public interface Conducible {
    public static final int MAXIMO_GIRO = 45;
    public abstract void girarIzquierda(int grados);
    public abstract void girarDerecha(int grados);
}

También se puede definir la interfase sin los calificadores public static final abstract, puesto que son implícitos.
Para declarar que una clase que implementa una interfase se usa implements

Laboratorio.
Que falta en el siguiente código?
Conducible.java
public interface Conducible {
    int MAXIMO_GIRO = 90;
    void girarIzquierda(int grados);
    void girarDerecha(int grados);
}
NaveArea.java
public class NaveAerea {
    protected char direccion;
    protected int altura;
    public void setDireccion(char direccion) {
        this.direccion= direccion;
    }
    public char getDireccion() {
        return this.direccion;
    }
}
Globo.java
public class Globo extends NaveAerea implements Conducible {
    private int volumenGas;
    public void setVolumenGas(int volumenGas) {
        this.volumenGas= volumenGas;
    }
    public int getVolumenGas() {
        return this.volumenGas;
    }
    public void girarDerecha(int grados) {
        if (getDireccion()=='N' && grados==90) setDireccion('E');
    }
}
Patin.java
public class Patin implements Conducible {
    public void girarDerecha(int grados) {
        System.out.println("Giro de "+grados+" grados a la derecha");
    }
    public void girarIzquierda(int grados) {
        System.out.println("Giro de "+grados+" grados a la izquierda");
    }
}
TestInterface.java
public class TestInterface {
    public static void main (String[] args) {
        Globo zepelin = new Globo();
        zepelin.setDireccion('N');
        zepelin.girarDerecha(90);
        System.out.println(zepelin.getDireccion());
        Patin patin = new Patin();
        patin.girarDerecha(90);
    }
}
Compartir: