Sistemas Operativos en Tiempo Real Ing. Electrónica-UPC Mag. Ing. Sergio Salas A.

1. Ejemplo básico de Boxing y Unboxing en Java.

En Java existen clases equivalentes a los datos primitivos. Es posible convertir un dato
primitivo a su clase respectiva (Boxing) o viceversa (Unboxing). Primero cree un nuevo
proyecto en Netbeans de nombre Ejemploclases. Luego cree una MainClass de nombre Boxing
y pruebe el siguiente código:

public class Boxing {

public static void main(String[] args) {

int num = 50;
Integer numero = 60;
numero = [Link](num);
numero +=5;
num = [Link]();
String texto = [Link]();
[Link](numero);
[Link](texto);
[Link](num);
}
}

2. Ejemplo de Herencia y Polimorfismo

A continuación cree una clase de nombre Persona:

public class Persona {

private String nombre;
private int edad;
private String sexo;

public Persona(String nombre,int edad,String sexo)

{
[Link]=nombre;
[Link] = edad;
[Link]=sexo;
}
public String getSexo(){
return [Link];
}
public void setEdad(int nuevaedad){
[Link]=nuevaedad;
}
public int getEdad(){
return [Link];
}
}

Posteriormente, se creará la clase Empleado, la cual heredará de Persona y utilizará el

constructor de Persona para poder inicializar las propiedades privadas:

1
Sistemas Operativos en Tiempo Real Ing. Electrónica-UPC Mag. Ing. Sergio Salas A.

public class Empleado extends Persona{

private String mPuesto;
private float mSueldo;
private String mFechaIngreso;

public Empleado(String nombre,int edad, String genero, String puesto,

float sueldo, String fechaingreso){
super(nombre,edad,genero);
[Link]=puesto;
[Link]=sueldo;
[Link]=fechaingreso;
}
}

Finalmente, instancie un objeto de la clase Empleado y obtenga la edad proveniente del

método de la clase padre en la clase MainClass:

public class Colecciones {

public static void main(String[] args) {

Empleado juan = new Empleado("Juan Perez",25,"M","Asistente administrativo",
2800,"14-10-2017");
[Link]([Link]());
}
}

3. Interfaces

Una interface es la definición del comportamiento de una clase que contiene métodos
abstractos. La clase que implementa dicha interfaz hereda estos métodos:

public interface Animal {

public void comer(String comida);
public void caminar(int distancia);
}

La interfaz Animal que se presenta implementa dos métodos abstractos. Luego, se creará la
Clase Perro a partir de la implementación:

public class Perro implements Animal{

@Override
public void comer(String comida)
{
[Link]("El perro come "+comida);
}
@Override
public void caminar(int distancia)
{
[Link]("El perro camina "+distancia+" kms.");
}

2
Sistemas Operativos en Tiempo Real Ing. Electrónica-UPC Mag. Ing. Sergio Salas A.

Luego, implementar la clase Mono a partir de la implementación de la interfaz Animal:

public class Mono implements Animal{

@Override
public void comer(String comida){
[Link]("El mono come "+comida);

}
@Override
public void caminar(int distance){
[Link]("El mono camina "+distance+ "kms.");
}
}

Finalmente instanciar dos objetos de la clase Perro y Mono y verificar el resultado:

public class Colecciones {

public static void main(String[] args) {

Animal fido = new Perro();
Animal cornelio = new Mono();
[Link]("Ricocan");
[Link](3);
[Link]("platano");
[Link](10);
}
}

El hecho que dos clases puedan modificar el funcionamiento de un método padre abstracto se
conoce como Polimorfismo.

4. Sobrecarga de métodos

Cree una clase de nombre Area cuyos métodos tengan el mismo nombre. Pero, difieran en el
número de parámetros que reciben:

public class Area {

public double superficie(double lado, double alto){
return lado*alto;
}
public double superficie(double radio)
{
return [Link]*radio*radio;
}
}

Observe que sucede al instanciar el objeto Area y ejecutar ambos métodos en el MainClass:

3
Sistemas Operativos en Tiempo Real Ing. Electrónica-UPC Mag. Ing. Sergio Salas A.

public class Colecciones {

public static void main(String[] args) {

Area sup = new Area();
[Link]([Link](5,4));
[Link]([Link](3));
}
}

5. Sobre escritura de métodos

Cree la clase padre Persona tal como se muestra:

public class Persona {

public float calcularImpuestos(){
return 0.2f;
}
}

Luego, genere la clase hija Empleado pero sobre escriba el método calcularImpuestos()

public class Empleado extends Persona{

@Override
public float calcularImpuestos(){
float impuestoSuperClase = [Link]();
return 0.9f*impuestoSuperClase;
}
}

6. Clases abstractas

Una clase abstracta es como una interfaz, ya que no se puede instanciar un objeto de esa
clase, pero si se puede heredar de ella. La clase abstracta puede tener métodos propios y
métodos abstractos así como propiedades:

public abstract class Poligono {

public int largoLado;
public abstract double calcularSuperficie();
public abstract double calcularPerimetro();
public double calcularVolumen(double altura)
{
return calcularSuperficie()*altura;
}

Luego, se creará la clase heredada Cuadrado, la cual sobrescribirá los métodos abstractos:

public class Cuadrado extends Poligono {

@Override

4
Sistemas Operativos en Tiempo Real Ing. Electrónica-UPC Mag. Ing. Sergio Salas A.

public double calcularSuperficie(){

return [Link]*largoLado;
}

@Override
public double calcularPerimetro() {
return [Link]*4;
}
}

Ahora verifique el funcionamiento en el MainClass:

public class Colecciones {

public static void main(String[] args) {
Cuadrado square = new Cuadrado();
[Link]=4;
[Link]([Link]());
[Link]([Link]());
[Link]([Link](1.2));
}
}

7. Comparar objetos

A continuación cree tres objetos de la clase Persona y compárelos para verificar si son iguales.
Observe que la igualdad tiene que ver con la asignación de espacios de memoria para cada
objeto, más no con el contenido de estos.

Utilice primero, la siguiente clase Persona:

public class Persona {

private String nombre;
private int edad;
private String sexo;
public Persona(String nombre,int edad,String sexo)
{
[Link]=nombre;
[Link] = edad;
[Link]=sexo;
}
public String getSexo(){
return [Link];
}
public void setEdad(int nuevaedad){
[Link]=nuevaedad;
}
public int getEdad(){
return [Link];
}
public String getNombre(){
return [Link];

5
Sistemas Operativos en Tiempo Real Ing. Electrónica-UPC Mag. Ing. Sergio Salas A.

}
}

Luego, en el MainClass instancie 3 objetos y compárelos:

public class Colecciones {

public static void main(String[] args) {
Persona p1 = new Persona("Juan",25,"M");
Persona p2 = new Persona("Juan",25,"M");
Persona p3 = p2;
if(p2 == p1)
{
[Link]("p1 es p2");
}
else
{
[Link]("p1 no es p2");
}
if(p3==p2)
{
[Link]("p2 es p3");
}
else
{
[Link]("p2 no es p3");
}
}
}

Si se quieren comparar los textos de un objeto se puede utilizar el método equals() el cual se
encuentra presente en todos los objetos Java:

public class Colecciones {

public static void main(String[] args) {

String c1 = new String("sistemas operativos");
String c2 = new String("sistemas operativos");

if(c1==c2)
{
[Link]("Las cadenas apuntan a las mismas direcciones de memoria");
}
else
{
[Link]("c1 y c2 son instancias diferentes");
}

if([Link](c2))
{
[Link]("Los textos de c1 y c2 son iguales");
}

6
Sistemas Operativos en Tiempo Real Ing. Electrónica-UPC Mag. Ing. Sergio Salas A.

else{
[Link]("Los textos son diferentes");
}
}
}
8. Métodos o variables estáticas

Un método estático es aquel que no requiere instanciar un objeto para ser utilizado. Para esto
cree una clase de nombre Matemáticas y dentro declare un método estático:

public class Matematicas {

public static double superficieCuadrado(double lado){
return lado*lado;
}
}

Luego, en el MainClass utilice el método estático sin instanciar un objeto de la clase

Matemáticas:

public class Colecciones {

public static void main(String[] args) {

double resultado=[Link](2.5);
[Link](resultado);
}
}

Ahora también es posible crear propiedades estáticas, las cuales se pueden acceder desde la
clase. Pero, para tal motivo, es necesario que estas propiedades también sean constantes, dado
que tengan valores conocidos. Observe la clase Vehículo que posee tres propiedades tipo static
y final para indicar que son constantes.

public class Vehiculo {

public final static int TIPO_AUTO = 1;
public final static int TIPO_CAMION = 2;
public final static int TIPO_MOTO = 3;

private int mTipo;

public int getTipoVehiculo(){
return mTipo;
}
}

Luego, en el MainClass se puede hacer uso de las propiedades estáticas:

public class Colecciones {

public static void main(String[] args) {

Vehiculo auto = new Vehiculo();
if([Link]()==Vehiculo.TIPO_AUTO)

7
Sistemas Operativos en Tiempo Real Ing. Electrónica-UPC Mag. Ing. Sergio Salas A.

{
[Link]("Es un auto");
}
else if([Link]() == Vehiculo.TIPO_CAMION)
{
[Link]("Es un camion");
}
else if([Link]() == Vehiculo.TIPO_MOTO)
{
[Link]("Es una moto");
}
else
{
[Link]("Vehiculo desconocido");
}
}
}

9. Singletones

Usted recordará de PHP que mediante las variables de $_SESSION se podía determinar por
ejemplo si un usuario había validado sus datos en la página de acceso. Una vez generadas las
variables de sesión estas permitían navegar por el resto de archivos PHP. Una patrón Singletone
es una clase que solo puede ser instanciada una vez. Para esto su constructor debe ser de tipo
protected (inaccesible) y una vez generada la única instancia de la clase se podrá validar su
estado en toda la aplicación, entendiendo que dicha instancia representa una conexión
satisfactoria a una base de datos, un acceso a mediante usuario y contraseña o la conexión a un
Web Service. Cree la clase Configuracion tal como se muestra a continuación:

public class Configuracion {

private static Configuracion instancia = null;
/*Constructor de tipo protected para evitar que se instancia la clase en
forma externa*/
private String usuario;
protected Configuracion(String usuario){
//Código de inicialización
[Link] = usuario;
[Link]("Se ha instanciado la configuracion con el usuario "+usuario);
}
//Método estático para acceder a la instancia
public static Configuracion getInstancia(String usuario){
/*Verificamos si aún no se ha creado ninguna instancia, en tal caso
se instancia la única instancia*/
if(instancia==null)
instancia = new Configuracion(usuario);
else
[Link]("No se puede crear el objeto "+usuario+" porque ya "
+ "existe un objeto de la clase Configuracion");
return instancia;
}

8
Sistemas Operativos en Tiempo Real Ing. Electrónica-UPC Mag. Ing. Sergio Salas A.

public String getUsuario()

{
return([Link]);
}
}

Luego, en el MainClass trate de utilizar el método para instanciar dos referencias a la clase
Configuración y vea lo que ocurre:

public class Colecciones {

public static void main(String[] args) {

Configuracion config = [Link]("ssalas");
Configuracion config2= [Link]("jpardo");
[Link]([Link]());
[Link]([Link]());

}
}

10. Encapsulación

El anidamiento de clases es un claro ejemplo de encapsulamiento. Por ejemplo, si tenemos una

clase que en su interior requiere el uso de otra clase muy específica podemos declarar la clase
dentro de la clase principal. Esto se conoce como anidamiento de clases. La clase anidada solo
puede ser utilizada por la clase Externa. Observe el siguiente código y pruébelo:

public class ClaseExterna {

/*Para acceder a un clase anidada se debe declarar un objeto de este tipo*/
private ClaseAnidada mObjAnidado = new ClaseAnidada();
private int result;
//Método de la ClaseExterna
private void calcular()
{
[Link]=[Link]();
}
public int getResultado(){
calcular();
return [Link];
}
public class ClaseAnidada{
/*Desde la clase anidada podemos acceder a los métodos de la clase
externa así sean privados*/
private void miMetodo(){
calcular();
}
private int getResultado(){
return 2;
}
}
}

9
Sistemas Operativos en Tiempo Real Ing. Electrónica-UPC Mag. Ing. Sergio Salas A.

Posteriormente, en el MainClass cree un objeto de la ClaseExterna y verifique el funcionamiento:

public class Colecciones {

public static void main(String[] args) {

ClaseExterna obj = new ClaseExterna();
[Link]([Link]());

}
}

11. Try-catch-finally

En algunas situaciones nuestro código puede producir errores en tiempo de ejecución que
durante la programación no pudo ser contemplado. A estos errores se le conocen como
Excepciones. Por ejemplo, se puede dar una división entre 0, un acceso a un índice de una
colección fuera de rango, acceso a una memoria inexistente, búsqueda a un servidor no
disponible, etc. Todo esto puede causar que la aplicación colapse y se cierre, lo cual no resulta
agradable al usuario y deja una mala imagen del programador.

Por ejemplo, ejecute este código y analice qué sucede:

public class Colecciones {

public static void main(String[] args) {

int[] mi_arreglo = {1,2,5,3,1,2,3,5,6,19,-9};
for(int i=0;i<12;i++)
{
[Link](mi_arreglo[i]);
}
}
}

Aparecerá el siguiente mensaje en la ventana de salida de Netbeans:

Exception in thread "main" [Link]: 11

at [Link]([Link])
Java Result: 1

Otro caso, por ejemplo sería convertir un dato tipo String ingresado por teclado a una variable
int para poder operarlo matemáticamente. Ejecute el siguiente código e ingrese por teclado una
cifra 12k:

public class Colecciones {

public static void main(String[] args) {
Scanner teclado = new Scanner([Link]);
[Link]("Ingrese un numero entero: ");
String valor = [Link]();
int num = [Link](valor);

10
Sistemas Operativos en Tiempo Real Ing. Electrónica-UPC Mag. Ing. Sergio Salas A.

[Link](num);
}
}

El resultado sería la siguiente excepción:

Exception in thread "main" [Link]: For input string: "12a"

at
[Link]([Link])
at [Link]([Link])
at [Link]([Link])
at [Link]([Link])
Java Result: 1

Para evitar que las excepciones hagan colapsar el programa se puede utilizar el bloque try-
catch-finally. Ahora el último programa podría reescribirse de la siguiente manera:

public class Colecciones {

public static void main(String[] args) {
Scanner teclado = new Scanner([Link]);
[Link]("Ingrese un numero entero: ");
String valor = [Link]();
int num = 0;
try
{
num = [Link](valor);
}catch(Exception ex){
[Link]("Hubo un error "+[Link]());
}
finally{
[Link]("El numero es: "+num);
}
}
}

Intente introducir un número por teclado como 13j y vea qué sucede.

Por ejemplo, para el caso específico del primer programa en el cual se accedió a un índice fuera
de rango se puede realizar el siguiente control de excepciones:

public class Colecciones {

public static void main(String[] args) {

int[] mi_arreglo = {1,2,5,3,1,2,3,5,6,19,-9};
for(int i=0;i<12;i++)
{
try{
[Link](mi_arreglo[i]);
}catch(ArrayIndexOutOfBoundsException ex){
[Link]("El índice "+i+" está fuera de rango");

11
Sistemas Operativos en Tiempo Real Ing. Electrónica-UPC Mag. Ing. Sergio Salas A.

}
}
}
}

12. Throws

También es posible crear un método que pueda lanzar una excepción cuando se produce una
condición definida por nosotros. Considere la siguiente clase Operaciones:

public class Operaciones {

public double suma(double a, double b)
{
return (a+b);
}
public double dividir(int a, int b) throws Exception{
if(b!=0)
{
return a/b;
}
else{
Exception ex = new Exception("Indeterminado");
throw ex;
}
}
}

Luego, en el MainClass se hará uso de la clase, teniendo en cuenta que el método principal
debe lanzar la excepción:

public class Colecciones {

public static void main(String[] args) throws Exception {

Operaciones op = new Operaciones();
[Link](2.3,1.3);
[Link](100,0);
}
}

13. Generics

Un Generic es una clase que permite recibir otra clase como parámetro en el instanciamiento
de un objeto. De esta manera la clase Generic puede contener y manipular un tipo de objeto sin
necesidad de tener que especificar la clase. Observe la siguiente clase:

public class CajaGenerica<T> {

private T mObjeto;
public void poner(T obj)
{
mObjeto = obj;

12
Sistemas Operativos en Tiempo Real Ing. Electrónica-UPC Mag. Ing. Sergio Salas A.

}
public T sacar(){
return mObjeto;
}
}

Como se observa, el parámetro <T> es la clase que se recibirá durante el instanciamiento de un

objeto, tal como se observa en la MainClass:

public class Colecciones {

public static void main(String[] args) throws Exception {

CajaGenerica<String> miCajaString = new CajaGenerica<String>();
[Link]("Hola Mundo");
CajaGenerica<Integer> miCajaint = new CajaGenerica<Integer>();
[Link](30);
[Link]([Link]());
[Link]([Link]());

}
}

14. Listeners

Las clases anónimas (en Android conocidas como Listeners) nos permiten declarar e instanciar
una clase en una sola sentencia. Son útiles para adicionar métodos a clases existentes. En
Android es muy común encontrar este tipo de clases en conexiones a servidores como en
manejo de gráficos. Para manejar un Listener puede utilizar una clase ya existente como una
interfaz. A continuación cree la interfaz Saludar:

public interface Saludar {

public void saludo(String nombre);
}

Luego, en el MainClass complete el método de dicha interfaz y pruébelo:

public class Colecciones {

public static void main(String[] args) throws Exception {

Saludar saludarEnIngles = new Saludar(){
@Override
public void saludo(String nombre)
{
[Link]("Hello "+nombre);
}
};
Saludar saludarEnPortugues = new Saludar(){
@Override
public void saludo(String nombre)
{

13
Sistemas Operativos en Tiempo Real Ing. Electrónica-UPC Mag. Ing. Sergio Salas A.

[Link]("Oi "+nombre);
}
};
[Link]("Peter");
[Link]("Dilma");
}
}

14