Folleto Java

Instituto Tecnológico RumiñahuiProgramación Orientada a Objetos

PROGRAMACIÓN ORIENTADA A OBJETOS

La programación orientada a objetos mira los fenómenos de la vida real de diferente perspectiva.

PROGRAMACIÓN ESTRUCTURADA

Tenemos la programación estructurada, en la que se trabaja a través de módulos y procesos, dentro de los cuales se especifica lo que el usuario necesita. Por esto se la llama Programación Modular. Consistía en llenar líneas y líneas de código, con el fin de encontrar solución a los problemas. Sin embargo, ésta soluciona muchas de las interrogantes que se presentan a menudo. La verdadera desventaja de este tipo de programación es que se convierte en un código no reutilizable, y con el ajetreo de hoy en día se requiere no sólo un solucionador de problemas sino también una herramienta adecuada y rápida.

PROGRAMACIÓN ORIENTADA A OBJETOS

La programación orientada a objetos (POO), a diferencia de la estructurada, trabaja con División por módulos (llamados módulos a entidades u objetos). Ahora, la visión de la realidad se torna distinta, el programador visualiza la realidad a través de objetos. Cada parte importante de algo es un objeto. Por ejemplo, piense en usted mismo y sus características que lo identifican: USTED es ya un objeto, que contiene objetos más “pequeños” como su nombre, su dirección, su número de cédula, su edad, tu talla, su color, etc. La gran ventaja de este tipo de programación es que, por su forma de ver las cosas, se convierte en una herramienta reutilizable para todos los casos. Piense en un rector de una universidad X. Él posee características propias y además sabe administrar dicha universidad. Cuando necesitemos analizar otro rector en una universidad Y, podremos utilizar al rector en X para simular uno en Y, lógicamente con diferente forma de administrar.

MODELADO DE ENTIDADES DEL MUNDO REAL

Antes de saber cómo modelar con entidades del mundo real, se debe entender de qué se trata una entidad del mundo real.

Entidad del mundo real: Es un objeto que tiene funcionalidad y características propias.

Objeto: Es una entidad del mundo real que tiene funcionalidad y características propias.

Funcionalidad: Todo lo que un objeto es capaz de hacer.

Nos referimos a una entidad como a cualquier ser propio del mundo real, que puede ser diferenciado uno de otro por sus atributos y funciones que puede desempeñar. Por ejemplo, un árbol, que es identificado por su tamaño, especie, edad, y que además cumple con varias funciones, tales como: dar fruto, alojar nidos de pájaros, proporcionar sombra, purificar el aire, etc. Una solicitud de ingreso posee atributos tales como: Número de folio, datos del aplicante, y cumple las funciones de devolver los datos en él ingresados, a la persona que autoriza dicho documento.

Para que un objeto manifieste su funcionalidad, necesita ser invocado a través de mensajes emitidos por otros objetos.

Manual de POO 1


Mensaje: Petición o llamado a una funcionalidad de un objeto. El mensaje puede estar expresado en cualquier lenguaje, siempre y cuando éste sea entendido por el objeto emisor y el receptor.

Para analizar la comunicación entre objetos y funcionalidades, es necesario recurrir al proceso de abstracción.

PROCESO DE ABSTRACCION

Es el proceso de agrupar objetos por su funcionalidad y atributos comunes. Se compone de los siguientes subprocesos:

- Identificación de objetos- Abstracción de objetos- Encapsulamiento- Relación de clases

Identificación de Objetos: Se trata de indicar los objetos que van a interactuar en la utilización de un sistema determinado. Dentro de este subproceso se encuentra el análisis de las características de dicho objeto y de las funcionalidades requeridas para el efecto.

Abstracción: Consiste en agrupar los objetos identificados por funcionalidad y características comunes. Esta agrupación será denominada de ahora en adelante como: CLASE. Así, definiremos Clase como la abstracción de un conjunto de objetos.

Respecto a la clase a la que pertenece, se define a un objeto como una variable o instancia perteneciente a una clase definida.

Encapsulamiento: Consiste en esquematizar cada una de las abstracciones definidas previamente, luego de agrupar sus características y funcionalidades. Esto permite la realización de un diagrama de clases.

Diagrama de clases: Representación gráfica de las clases o abstracciones previamente definidas. Estas serán expresadas como rectángulos que contengan el nombre de la clase.

Relacionar clases: Definir las interacciones entre clases, luego de determinar la dependencia entre ellas. Por ejemplo, una clase llamada Alumno, se relaciona automáticamente con una clase Curso y ésta a su vez, con una clase Materia, ya que un alumno se inscribe un curso determinado para recibir una o varias materias en dicho curso.

Ejercicio Resuelto

Realice el diagrama de clases para un Sistema de Inventario para una farmacia.

Manual de POO 2


Ejercicios Propuestos

1.- Realice el diagrama de clases especificando las funcionalidades de cada clase, para un local de venta de computadores.

2.- Realice el diagrama de clases especificando las funcionalidades de cada clase, para una gasolinera.

3.- Realice el diagrama de clases especificando las funcionalidades de cada clase, para un sistema de facturación.

4.- Realice el diagrama de clases especificando las funcionalidades de cada clase, para un sistema de biblioteca.

UML (Lenguaje de Modelado Unificado)

El UML es un lenguaje gráfico que nos permite representar clases, atributos, funciones y relaciones entre clases. Se trata de una síntesis de la abstracción.

Se tiene como estándar el siguiente:

Firma de método: Cada línea en la definición de la clase que establece cada método se denomina firma o declaración del método.

Tipos de Atributos: Existen atributos privados y públicos. Son atributos privados aquellos que son propios de una clase y no pueden ser compartidos para las demás.

Manual de POO 3

Clase- atributoPrivado: tipo+ atributoPúblico: tipo- metodoPrivado(nombreVariable: tipo): tipoDelMetodo+ metodoPúblico(nombreVariable: tipo): tipoDelMetodo

Medicamento

TipoMedicamento

ArticulosUsoPersonal

Proveedor

EquiposOficina

CatalogoMed CatalogoEquCatalogoArtCatalogoTipoMed

SISTEMA DE INVENTARIO


Son atributos públicos, en cambio, aquellos cuya característica principal es tener la capacidad de ser modificados y compartidos por otras clases.

Métodos: Son la interfaz de la clase, modifican los atributos privados de la clase.

Existen métodos privados y públicos, son métodos privados aquellos que se ejecutan por la clase en la que están definidos.

Si modelamos atributos públicos, nos ahorramos métodos, pero se pierde seguridad.

Por ejemplo:

Métodos Accesorios

Existe una convención de Java que establece que los métodos que sirvan para devolver un valor a un atributo se denominen accesorios selectores y se escribirán getAtributo() donde Atributo es el nombre del atributo a devolverse, p.ej. getX( ): int; y los métodos que sirvan para fijar un valor a un atributo se denominen accesorios modificadores o mutantes, y se escriban como setAtributo(), p.ej. setY(valorY: int): void.

Para las aplicaciones, es decir la clase donde se ejecuta el programa, Aplicación.Java, contiene la sentencia public static void main(String []args) y a partir de ésta se va construyendo el código en la aplicación. Y sólo ésta clase es la principal, lo contrario de las otras clases donde hay más clases principales sin embargo la clase toma el nombre de la clase pública.

Al grupo de clases que tienen algo en común se les denomina package y éstos pueden contener varios archivos de clases.Es aconsejable tener cada clase en un archivo diferente.

La agrupación de package, se le denomina Project el cual puede tener varias carpetas, incluso clases.

Manual de POO 4

Punto- x: int- y: int+ moverX(incrementoX: int): void+ moverY(incrementoY: int): void+ devolverX( ): int+ calcularDistancia( ): double+ imprimirDatos( ): void


PROJECT

Ejercicio Propuesto

1.- Complete el ejemplo con los métodos que se refieran al atributo, tanto selectores, como modificadores.

Wrapper Classes.- Clases de envoltura que permiten manipular datos y vienen incorporadas en el lenguaje programador (p.ej. Java)

String clase formada por chars.Integer clase formada por ints.

Atributos propios, muy propios e invariantes, como el nombre de un Estudiante o su número de cédula, pueden no tener accesorio set, y otro tipo de atributos como el número de folio en una Solicitud, puede no tener accesorio get.

Ejercicio propuesto

Modele las clases Estudiante, Curso y Fecha, con los atributos y métodos que usted considere necesarios para acceder y modificar su información.

Nota: Es más eficiente modelar al número de cédula y al número único como String, ya que modelarlos como double o float ocupa mucho más espacio, p.ej. un double ocupa 64 bytes, mientras que un String de 10 caracteres ocupa 10 bytes.

MÉTODOS CONSTRUCTORES.-

En programación estructurada se requería reservar memoria, para poder crear variables en tiempo de ejecución, y luego borrar esa porción de memoria. En la Programación Orientada a Objetos el Garbage Collector (recolector de basura) se encarga de eliminar la memoria que ya no será necesaria en el futuro de manera automática.

Manual de POO 5

Clases Clases

PACKAGEPACKAGE

Círculo Punto Esfera

Cilindro

ConoLínea


Gracias a esta característica tan útil se pueden definir ciertos métodos llamados Constructores.

// para sumar dos puntos public void suma(Punto op1, Punto op2) {

X = op1.x + op2.x;Y = op1.y + op2.y;

} public Punto suma (Punto op2) {

Punto res = new Punto ();

res.x = x + op2.x;res.y = y + op2.y;

return res; }

En el caso de asignación de memoria, en el ejemplo anterior la variable c es una referencia de res. Cuando se termina la función se elimina res y queda el nombre c. Esto se realiza mediante el garbage colector.

c se elimina y queda res, así no se ocupa espacio con la misma variable.

Constructores.- Métodos que sirven para inicializar los valores de los atributos de un objeto al momento de crearlos (instanciarlos).

Se ejecutan una sola vez por cada objeto, y no retorna valores. Su retorno no es void, ya que void ya es un tipo de retorno.

Los métodos constructores deben tener el mismo nombre de la clase a la que pertenecen, para crear el objeto de dicha clase. Además se puede tener más de un constructor para una clase, es decir que en programación orientada a objetos se puede tener más de un método con el mismo nombre, con la condición que los parámetros a ingresar en los métodos no sean del mismo tipo, ni en el mismo número.Se debe escribir la clase tal como está en su definición, empezando por una letra mayúscula, ya que Java es sensible a mayúsculas.

Así una clase Estudiante puede definir varios métodos, por ejemplo:

Estudiante ( ): Se llama constructor por default, no tiene parámetros y crea objetos con todos los valores de sus atributos nulos. Siempre es bueno definir un constructor por default, para facilidad en tiempo de programación.

Manual de POO 6

res

c

Memoria


Estudiante (initialNumeroUnico: String,initialNombre: String,initialFechaNacimiento: Fecha) Se llama constructor con parámetros, y sirve para instanciar objetos donde los valores ingresados son los valores de los atributos que se especifican en la firma del método.

Estudiante (initialEstudiante: Estudiante): Se llama constructor copia, porque se ingresa como parámetro un objeto de la misma clase que el que se va a crear, y consecuentemente el nuevo objeto creado tiene los mismos valores de los atributos que el objeto que lo originó.

Nota: Se establece en la convención Java que las variables que corresponden a los parámetros de los constructores se escriban initialAtributo.

Aquí se da un ejemplo del uso de los constructores:

Estudiante a Se hace una referencia a un Estudiante.Estudiante b = new Estudiante() Se crea un objeto de clase Estudiante, de nombre

b, con sus atributos de valor nulo.Estudiante c = new Estudiante(200510236,Carolina,1986/09/26) Se crea un objeto de

clase Estudiante, de nombre c, con valores para sus atributos.

Estudiante d = new Estudiante(c) Se crea un objeto de clase Estudiante, de nombre d, con los valores de sus atributos iguales a los del objeto c.

USO DE LOS MÉTODOS.-

En programación orientada a objetos se declaran métodos, para usarlos y especificar a qué objeto corresponde cada uno de ellos se utiliza la notación Punto.

En la notación punto se sigue la siguiente estructura: objeto.Metodo(Parametros)

Por ejemplo se definen las siguientes clases:

Se crea un objeto Punto de nombre q: Punto q = new Punto(3,4)Se crea un objeto Círculo de nombre z: Circulo z = new Circulo(q,5)Se desea que el radio del círculo z cambie a 10 z.setRadio(10)Se desea que cambie la coordenada x del centro de z a 20 z.getCentro().setX(20)

Manual de POO 7

Punto- x: double- y: double+ setX(valueX: double): void+ getX( ): double+ setY(valueY: double):void+ getY( ): double+ moverX(newX: double): void+ moverY(newY: double): void+ Punto(initialX: double,initially: double)

Circulo- centro: Punto- radio: double+ setCentro(valueCentro: Punto): void+ getRadio( ): double+ setRadio(valueRadio : double):void+ getCentro( ): Punto+ Circulo(initialCentro:Punto,initialRadio: double)


El momento que escribimos z.getCentro() estamos manipulando a un objeto de tipo punto en este caso el punto q, y se puede utilizar cualquiera de los métodos definidos para la clase Punto

En este caso fecha no es un tipo de dato común y corriente, que es asignado a un atributo, razonando con respecto a objetos, es otra clase, pues contiene un día, un mes determinado, y un año, por lo que no puede ser del tipo String, ni int, ni tampoco es un número como double.

En este caso se dice que existe una referencia entre las clases Alumno y Fecha, cuando se habla de referencia, nos estamos refiriendo a clases, más no objetos.

Cuando se habla de atributos, se habla de objetos, ya que un objeto contiene a otro objeto de otra clase. Como en el caso de dia: int.

Un constructor solo se ejecuta 1 vez en 1 objeto y se puede tener varios constructores en1 clase. Es aconsejable tener un constructor por default.

CONVENCIONES EN JAVA

Para programar en lenguaje java, se deben seguir ciertas convenciones o reglas previstas con anterioridad. Entre estas tenemos:

Manual de POO 8

Alumno

- nombre: String- numeroUnico: String- cedula: String- fechaNacimiento: Fecha

Fecha

- dia: int- mes: int- anio: int

+ getDia(): int+ setDia (valorDia:int):void


El archivo .java dentro del cual se almacena el contenido de la programación de una clase Nombre, se llamará Nombre. Java. Si dentro del archivo se programa varias clases, se tomará en cuenta el nombre de la clase pública o principal. Se puede definir como pública a cualquier clase, siempre y cuando sea Clase Principal o Aplicación Principal.

Una clase principal se define con un método main dentro de sí. Ésta será la que haga interactuar los objetos y los aplique.

Definición de una clase principal:

Public Aplica {Main() {

}}

Como se puede observar, dentro de un mismo archivo pueden estar definidas varias funciones main, pero una sola clase pública. Es aconsejable tener cada clase en un archivo diferente.

Package: Es un fólder común y corriente que contiene una agrupación de clases. Para que los .java se ejecuten directamente, deberán estar almacenados en un mismo package.

Project: Es una agrupación de Packages. Puede contener también clases o cualquier otra carpeta.

Para las aplicaciones, es decir la clase donde se ejecuta el programa, Aplicación.Java, contiene la sentencia public static void main(String []args) y a partir de ésta se va construyendo el código en la aplicación. Y sólo ésta clase es la principal, lo contrario de las otras clases donde hay más clases principales sin embargo la clase toma el nombre de la clase pública.

IMPLEMENTACIÓN

Consiste en traducir a lenguaje java el diagrama UML del modelo orientado a objetos que escojamos.

Implementemos la clase Punto:

package figuras; // Guarda este archivo .java en el package figuraspublic class Punto {

private double x; // declara como variable privada de tipo double a xprivate double y;//El anterior se llama Bloque de Declaraciones

// Declaración de Funciones//Constructores

public Punto() { // Función por default

x = 0;y = 0;

}

Manual de POO 9


public Punto (double initialX, double initialY) { //Función con parámetrosx = initialX;y = initialY;

}

public Punto (Punto initialP) { //Función copiax = initialX;y = initialY;

}

public void setY (double valueY) { // Función que asigna valores a Yx = valueX;

}

public double getX() { // Devuelve el valor de la coord. xreturn x;

}

public void mover (double cambioX) { // Función que mueve la coord. Xx = x + cambioX;

}

public void mover (double cambioY) { // Función que mueve la coord. Yx += cambioX;

}

public void imprimir() { //Imprime las coordenadas x y y del puntoSystem.out.println (“x = ” + x );System.out.println (“y = ” + y );

public void setPunto (Punto valueP) {x += valueP.xy += valueP.y

}}

Nota: En la setencia System.out.println(“x = ” + x ); es espacio es del tipo String, y x es del tipo double por lo tanto se concatenan, si en lugar fuesen 2 doubles, se sumarían, de igual manera 2 int.

Así, pueden haber varias funciones con un mismo nombre, cuya diferencia será solamente sus argumentos. Este es el caso de SOBRECARGA DE FUNCIONES.

También, se puede manipular objetos desde una nueva clase, si es preciso, misma que, para este ejemplo, declararemos como clase de aplicación o principal.

public class AplicaPunto {

public static void main (String [ ]args ) { //Declaración de una función mainPunto a = new Punto();Punto b = new Punto(10,20);b.moverPunto (10,10); //Mueve el punto b en (10,10)b.setX(0); //Asigna a la coordenada x el valor de 0b.imprimir(); //Imprime las coordenadas del punto bdouble valor = a.getX(); //Devuelve en la variable valor la coordenada

en x del punto ab.moverPunto(a); //Mueve las coord. del punto b en a (Increm. en a)b.moverY(a.getX()); //Mueve la coord. Y de b en X de aPunto c = new Punto (a); //Crea un nuevo punto c con atributos de aSystem.out.println(c.getX()); //Imprime la coord. X del punto c.

Manual de POO 10


Para hacer explícito el package en el que deseo que esté contenido Punto, utilizo:

package figuras;

Ejercicio Resuelto: 1.- Implemente una clase Complejos que realice todas las operaciones que con ellos se puede realizar. También una clase de Aplicación de complejos donde se manejen objetos.

Esta clase tendrá sus respectivos atributos y métodos. Para ejecutar dicha clase se creará una clase AplicaComplejo, cuya función es de alguna manera, llevar a cabo la clase Complejo.

CLASE COMPLEJOSpackage complejos;

public class Complejo {

//Declaración de atributosprivate double real;private double imag;

//Funciones Constructoraspublic Complejo() {

real = 0;imag = 0;

}

public Complejo(double initialReal, double initialImag) {

real = initialReal;imag = initialImag;

}

//Funciones Accesoriaspublic void setReal(double valueReal) {

real = valueReal;}

public double getReal() {

return real;}

public void setImag(double valueImag) {

imag = valueImag;}

public double getImag() {

return imag;}

Manual de POO 11


//Funciones definidas por el usuariopublic void imprimirDatos() {

System.out.println("Numero real: " + real);System.out.println("Numero imaginario: " + imag);System.out.println("Numero complejo: " + "(" + real + "," + imag + ")");

}

public void incrementarEnUno() {

real ++;imag ++;

}

//Función que sume dos complejos y retorne un complejopublic Complejo sumaComplejos(Complejo valor1) {

Complejo suma = new Complejo();suma.real = real + valor1.real;suma.imag = imag + valor1.imag;return suma;

}

public void imprimirFormaCompleja() {if(imag < 0) System.out.println(real + "" + imag + "i");else System.out.println(real + "+" + imag + "i");

}}

Los métodos anteriormente implementados incluyen la definición de datos, las funciones constructoras y accesorias para cada atributo, funciones definidas por el usuario, tales como la de imprimir datos en dos o más formatos, sumar complejos devolviendo un complejo, imprimir datos bajo ciertas condiciones, etc.

CLASE APLICACOMPLEJOpackage complejos;

public class AplicaComplejo {

/** * @param args */public static void main(String[] args) {

Complejo a = new Complejo(10,20); //Creación de nuevos complejosComplejo b = new Complejo();b.setReal(100); //Asignación del valor 100 a la parte real del complejo bb.imprimirDatos(); //Impresión de los datos del complejo ba.incrementarEnUno(); //Incremento en uno al complejo aa.imprimirDatos(); Complejo c = new Complejo();c.setReal(10);c.setImag(15); //Asignación del valor 15 a la parte imag. del complejo c//Suma del complejo b al a e impresión de resultadosa.sumaComplejos(b).imprimirDatos();a.sumaComplejos(b).imprimirDatos();//Impresión de datos con diferente formatoa.imprimirFormaCompleja();b.imprimirFormaCompleja();c.imprimirFormaCompleja();

Manual de POO 12


a.setImag(-100);a.imprimirFormaCompleja();

}}

Como podemos notar, la clase AplicaComplejo, trabaja con objetos, realizando llamadas o invocando a los métodos de la clase Complejo de acuerdo con lo que necesite. Esto permite que la manipulación de los métodos y atributos sea mucho más fácil y rápida.

Nota:

Una operación binaria siempre tendrá 1 parámetro cuando retorna algo. Una operación binaria que no retorna algo tiene 2 parámetros. Una operación unaria no necesita parámetros.

a.incrementoUno() {public void incrementoUno() {

x++;y++;

}

ASIGNACIÓN DE MEMORIA

En el caso de asignación de memoria, en el ejemplo anterior la variable c es una referencia de res. Cuando se termina la función se elimina res y queda el nombre c.

Esto se realiza mediante el garbage colector.

c se elimina y queda res, así no se ocupa espacio con la misma variable.

Ejercicio Resuelto:

1.- Implemente una clase Carta que valide que las cartas que se ingresen estén dentro del rango determinado.

public class Carta {

private String palo;private String numero;

private String[] palos = {"C","D","T","E"};private String[] numeros = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

public Carta() {

palo = null;numero = null;

}

public Carta( String initialNumero, String initialPalo) {

Manual de POO 13


numero = initialNumero;palo = initialPalo;

}

public void setNumero(String valueNumero) {

numero = valueNumero;}

public void setPalo(String valuePalo) {

palo = valuePalo;}

public int getNumero() {

int numero1;numero1 = Integer.parseInt(numero); return numero1;

}// como numero es String se convierte en Integer para poder // realizar operaciones sobre él.

public String getPalo() {return palo;

}

public void imprimir() {

System.out.println("La Carta es: "+ numero + "de" + palo);}

public boolean validaCarta() {

int contp = 0;while (contp < palos.length) {

int contn = 0;if (palo.toUpperCase().equals(palos[contp])) {

while (contn < numeros.length) {if (numero.toUpperCase().equals(numeros[contn])) {

return true;}contn++;

}}contp++;

}return false;

}

}

Como otra convención de Java, se debe saber que cuando se trabaja con objetos no se utiliza (==) para comparar, sino equals y el objeto.

EXCEPCIONES

Es un error inesperado en tiempo de ejecución.

Manual de POO 14


Cuando el programa detecta un error, dispara un objeto excepción éste debe ser capturado para determinar la causa del error.

Ejemplo:

public class mYEXception {

public Static void main (String []args) {

int n = 5;int d = 0;int r = n/d;System.out.println(“RES” r);

}}

En este caso el error se produce en la división por 0 cero que es de tipo aritmético.

Cuadro de Excepciones:

Try: “Sabe” el errorCatch: “Captura” el error

Ejemplo:

Try {int n = 5;int d = 0;int r = n/d; //captura el errorSystem.out.println(“RES” r);

}Catch (ArithmeticException) {

System.out.println(“ERROR div 0”); }

El catch evita que se caiga el programa capturando el objeto se puede tomar medidas sobre el error.

También funcionaría la excepción escribiendo Exception en lugar de ArithmeticException, pero no se sabría el detalle del error.

Manual de POO 15

Exception

ArithmeticException NumberFormatException IOException ArgIndezOrtof


El error debe capturarse en la fundón porque si se captura en el main, y se vuelve a usar el main se tendría que usar el capturador en cada main.

El error es tratado por el programador ya no por el Sistema Operativo y es el usuario quien decide que hacer con el error.

public Static void main (String []args) {

int n = 5;int d = 0;int r = n/d;System.out.println(“RES” r);

}Public Static int div (int rn, int rd) {

If (rd == 0) {Throw new ArithmeticException (“ERROR 0”);

}

return rn/rd;

}}

Throw new ArithmeticException, realiza casi la misma función que el try y catch con la diferencia de que el error no se captura.

El throws exception se utiliza en la función para que llame y capture. Y de esta manera en cierta forma actúa como un aviso dentro de la función advirtiendo que existe una excepción.

CARDINALIDAD

La cardinalidad hace referencia a un conjunto de objetos que son contenidos por otro. Entre los conceptos más importantes dentro de este tema tenemos:

Colección: Conjunto de objetos de un mismo tipo.

Como ejemplo:

De esta manera se representa la cardinalidad entre dos clases. En este caso demuestra que un CURSO TIENE VARIOS ALUMNOS. De esta manera CURSO se constituye como una COLECCIÓN DE ALUMNOS.

Al ser una colección de alumnos, Curso debe tener un arreglo que contenga objetos tipo Alumno. Estos e consigue implementando un arreglo de alumnos, que sería un array de referencias.

Manual de POO 16

Alumno Curso


Cada casillero del arreglo contendrá un alumno distinto, de esta manera podremos manejar cada uno de los índices que indican la posición de cada alumno, de forma menos compleja.

Para la implementación:

Alumno alumnos[] = new Alumno[ 10 ] // De esta manera se crea un objeto arreglo

Número de posiciones del arreglo

alumno[0] = new Alumno() ; // Coloco un objeto en el arreglo

Como se puede ver, primero se debe instanciar el objeto, para luego poder usar el arreglo como desee.

Ejercicio Propuesto

1.- Implemente una clase Curso que contenga un número máximo de alumnos, que sume su edad, imprima sus datos. Además añada funciones para realizar lo siguiente:

Añadir un alumno Buscar un alumno Eliminar un alumno Cambiar o modificar los datos de un alumno Función que devuelva un arreglo que contenga todos los nombres de los

alumnos del curso. Función que calcule el promedio de iras de los alumnos del curso Función que devuelva un arreglo con el número único, nombre e IRA de todos

los alumnos del curso. Función que imprima todos loa alumnos de un curso.

HERENCIA

Es una relación que se da entre dos clases de la misma índole que permite compartir atributos y funciones entre ellas. Nos permite crear clases a partir de otras ya creadas.

Si quisiéramos implementar una clase Alumno, pero existen alumnos de tecnología, de ingeniería, de costura, etc., para cada una de las clases tendríamos que digitar el código con todos los atributos y a su vez, los métodos accesorios para cada uno de ellos.

Manual de POO 17

Referencia a un objeto

Alumno AlumnoTecnol-NumUnico-Nombre-Edad-IRA-CI

-NumUnico-Nombre-Edad-IRA-CI-noHorasLab


Con una relación de herencia podremos evitar este inconveniente, reduciendo el código de manera notoria. Las clases AlumnoIng, AlumnoTecnol y AlumnoCostura heredarían de la clase Alumno todos sus atributos ya demás cada una de ellas tendría algunos extras que son específicos para cada clase. Para esto aplicamos implícitamente el concepto de GENERALIZACIÓN, que consiste en partir desde lo específico e ir a lo general, como es abreviar las clases e implementar solamente una clase Alumno que tenga los atributos y funciones en común para todas las demás, y luego heredarlos a las demás clases. Así:

Esta sería la representación en UML de una relación de herencia. Alumno constituye la Clase Base o Superclase y Las demás se llamarán Clases Derivadas o Subclases.

En este momento las clases heredadas comparten todos los miembros de Alumno excepto los MIEMBROS PRIVADOS. Éstos podrán ser vistos de forma indirecta, por medio de los métodos get() y set().

Condición de Herencia: Una clase puede ser herencia de otra siempre y cuando cumpla con la afirmación:

ClaseHeredada “ES UN /A” ClaseBase

Tipos de protección de Atributos

Como sabemos, los tipos de protección que se han utilizado hasta hoy han sido privado y público. Sin embargo, se han ocasionado insuficiencias en la seguridad interna de los sistemas, de modo que se necesitaba tener una protección que permita compartir miembros completamente a las subclases y mantener totalmente privados los miembros para las clases enlazadas por asociación.

Manual de POO 18

AlumnoIngAlumnoCostura

-NumUnico-Nombre-Edad-IRA-CI-NCA

-NumUnico-Nombre-Edad-IRA-CIhorasCostura

Alumno

AlumnoIng AlumnoCosturaAlumnoTecnol


De esta manera se crea un tipo de protección que realice lo que se necesitaba, éste se llama: protected o tipo protegido.

Ejercicio Resuelto

1.- Supongamos una tienda de animales que tiene los siguientes animales: perro, ballena gris, tiburón, águilas, cóndores, ballena jorobada. Realice el respectivo UML que represente el fenómeno.

Ejercicio Propuesto

1.- Considere una empresa de contenedores. Se tiene contenedores rectangulares y cilíndricos. Cada contenedor tiene una placa, color, profundidad. El contenedor rectangular tiene largo, ancho y profundidad, mientras que el cilíndrico tiene radio y profundidad. Calcular el volumen, área y perímetro de los contenedores. Para el contenedor cuadrado se requiere un número de autorización municipal y para el cilíndrico un número de patente del material (tipo enteros). Implemente el ejemplo.

STRING TOKENIZER

Son objetos que se pueden separar en Strings más pequeños, conocidos como “tokens”. Por ejemplo si se tiene la cadena “DISK_40_1970” se la puede separar en “DISK”, “40” Y “1970”.

Para emplear los StringTokenizer es necesario separar los tokens mediante un guión “-” o un subguión “_”.

Métodos:

StringTokenizer(cadena, “-”) este constructor indica que el carácter que separa los tokens es el guión.

void nextToken() apunta hacia el siguiente token dentro de un objeto StringTokenizer.

Manual de POO 19

Mamífero Ave Pez

Perro Ballena Águila Cóndor Tiburón

BallenaGris BallebaJorobada

Animal


Ejemplo:

Este programa permite ingresar una cadena de caracteres separados por un “_” los separa y los lee uno por uno, también tiene un menú para que el usuario escoja la opción que desee realizar.

package yoi;

public class Cliente {

private String nombre;private int edad;private double sueldo;

/** * */public Cliente() {

// TODO Auto-generated constructor stub}

/** * @param nombre * @param edad * @param sueldo */public Cliente(String nombre, int edad, double sueldo) {

// TODO Auto-generated constructor stubthis.nombre = nombre;this.edad = edad;this.sueldo = sueldo;

}

/** * @return Returns the edad. */public int getEdad() {

return edad;}

/** * @return Returns the nombre. */public String getNombre() {

return nombre;}

/** * @return Returns the sueldo. */public double getSueldo() {

return sueldo;}

/** * @param edad The edad to set. */public void setEdad(int edad) {

this.edad = edad;}

/** * @param nombre The nombre to set. */public void setNombre(String nombre) {

this.nombre = nombre;}

/** * @param sueldo The sueldo to set. */public void setSueldo(double sueldo) {

this.sueldo = sueldo;

Manual de POO 20


}

public void imprimir() {

System.out.println("\n*********\n" + "*CLIENTE*\n"+ "*********\n");

System.out.println("Nombre : "+this.nombre);System.out.println("Edad : "+this.edad);System.out.println("Sueldo : "+this.sueldo);

}

}

Para la aplicación

package yoi;

import java.util.*;import java.io.*;

public class Aplica {

static BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));

/** * @param args */public static void main(String[] args) {

// TODO Auto-generated method stub

int op = 0;

Cliente cliente = null;

do{

menu();

op = leerDatoNumerico(1,3);

switch(op) {

case 1:

cls();cliente = leerCliente();break;

case 2:

cls();if(cliente != null){

cliente.imprimir();

}

break;

default:cls();cls();System.exit(0);

}

}while(op != 3);

}

public static Cliente leerCliente() {

Manual de POO 21


Cliente nuevoCliente = new Cliente();

String cliente = null;

String cadena[] = new String[3];

int verif = 0;

do{try{

System.out.println("\nNUEVO CLIENTE " + "[(nombre)_(edad)_(sueldo)]");

System.out.println("\nEjemplo: Juan_15_1500");System.out.println("\nINGRESE: ");cliente = stdIn.readLine().toUpperCase();

StringTokenizer str = new StringTokenizer(cliente, "_");

if(str.countTokens() == 3){

for(int i = 0; i < 3; i++){

cadena[i] = str.nextToken();

}

if(Integer.parseInt(cadena[1]) > 0 && Integer.parseInt(cadena[1]) < 100) {

nuevoCliente.setEdad(Integer.parseInt(cadena[1]));

if(Double.parseDouble(cadena[2]) > 220 && Double.parseDouble(cadena[2]) < 2000){

nuevoCliente.setNombre(cadena[0]);

nuevoCliente.setSueldo(Double.parseDouble(cadena[2]));verif++;cls();System.out.println("Cliente

ingresado exitosamente");

}else {

cls();System.out.println("El sueldo es

incorrecto");

}

}else{

cls();System.out.println("La edad es incorrecta");

}

}else{

cls();System.out.println("El número de campos es

incorrecto");

}

Manual de POO 22


}catch(Exception e){

cls();System.out.println("Error: " + e.getMessage());System.out.println("Uno o más campos fueron ingresados" +

" incorrectamente");

}

}while(verif == 0);

return nuevoCliente;

}

public static int leerDatoNumerico(int numInicio, int numFinal) {

int opcion = 0;int verif = 0;

do{try{

System.out.println("\nINGRESE: ");opcion = Integer.parseInt(stdIn.readLine());

if(opcion >= numInicio && opcion <= numFinal){

verif++;

}else{

System.out.println("Su opcion debe estar entre "+ numInicio+" y

"+numFinal);

}

}catch(Exception e){

System.out.println("Error: " + e.getMessage());

}

}while(verif == 0);

return opcion;

}

public static void menu() {

System.out.println("\n\n**************\n" + "*MENU CLIENTE*\n" + "**************\n\n");

System.out.println("(1) Ingresar Cliente\n" + "(2) Consultar Cliente\n" + "(3) Salir");

}

public static void cls(){

for(int i = 0; i < 27; i++){

System.out.println("\n");

}

}

}

Manual de POO 23


ARRAYLIST

Los ArrayList son arreglos dinámicos; a manera de una lista enlazada, donde no tiene posición fija en la memoria. Para manejarlo debe tener un apuntador al siguiente elemento guardado en memoria

Los Arraylist son de tipo genérico, contienen objetos, y no pueden contener tipos de datos primitivos. Son tipos de datos Objetos: Integer, String, Double, Persona, Fecha, etc.

Para manejar elementos ArrayList se necesita importar el package java.util.

Tenemos por ejemplo una instanciación de de un objeto ArrayList:

ArrayList <Producto> arreglo = new ArrayList<Producto>();arreglo.add(new Producto("x","y"));arreglo.add(new Producto("z","w"));

MÉTODOS DEL ARRAYLIST

A continuación se muestran los métodos que sirven para manipular objetos ArrayList:

int size()boolean isEmpty()boolean contains(Object o)void add(E o)void add(int index, e O)E get(int index)public E set()public boolean remove(Object o)E remove(int index)

OBJETO ITERADOR

Para manejar ArrayList se puede crear un objeto Iterador que permite recorrer de principio a fin la lista, para poder eliminar o insertar un elemento en cualquier lugar determinado. Este objeto iterador devuelve la dirección del primer elemento del ArrayList.

Métodos:

Iterator<E>: Devuelve el primer elemento de la listaboolean hasNext(): devuelve true si hay un elemento siguiente en la listaE next(): retorna el siguiente elemento de la iteraciónvoid remove: Elimina el elemento en el que se encuentra el iterador en ese momento

Ejercicio Resuelto:Devolver lo que se encuentra en el arreglo:

ArrayList<String> arreglo = new ArrayList<String>();arreglo.add("HOLA");arreglo.add("COMO");arreglo.add("ESTAN");

Manual de POO 24


for(Iterator<String> i = arreglo.iterator();i.hasNext();) {resul = resul + "" + i.next();

}System.out.print(resul);

POLIMORFISMO

Definición: Son métodos iguales pero con distinta implementación en una relación de herencia.

La principal característica del polimorfismo es que el método que está en la superclase “obliga” a la subclase a que también lo implemente; de esta manera se tiene mayor seguridad en cuanto al sistema ya que la subclase necesariamente necesita implementar el método de la subclase, por que de lo contrario existe un error y la subclase se atiene a las condiciones que la superclase tenga.

En el caso de que se añada otra clase al package esta nueva clase tiene calcular precio por defecto.

Ejemplo:

Public double calcularPrecio() es el método de polimorfismo.

CLASES ABSTRACTAS

Clase abstracta: Una clase es abstracta si tiene al menos un método abstracto.

Método Abstracto: Es un método sin cuerpo.

Supongamos que se desea implementar una aplicación para manipular empleados de una institución educativa. Existen empleados a tiempo completo y a tiempo parcial, todos los empleados registran cédula y sueldo base. Los empleados a tiempo completo tienen como atributo sueldo de ingreso y una bonificación. Los empleados a tiempo parcial registran el número de horas trabajadas y un sueldo por hora.

Cabe indicar que todos los empleados tendrán un cálculo de sueldo. Para el empleado a tiempo completo el sueldo será su sueldo base + bonificación. Mientras que para el empleado de tiempo parcial será el sueldo base + nro de horas trabajadas * sueldo/hora.

Manual de POO 25

PRODUCTO

Producto de PrimeraNecesidad

Producto de Lujo

Public double calcularPrecio()

Public double calcularPrecio()


El momento en el que queremos crear la aplicación pensamos en una jerarquía de clases de la siguiente forma:

Nos encontramos con la siguiente incógnita: ¿qué tipo de implementación deberá tener el método calcularSueldo() de la clase Empleado?

Existe la opción (no recomendada) de no incluir el método en la clase empleado, lo que conllevaría al error de permitir que si se agrega un nuevo tipo de empleado, éste no tenga un método calcularSueldo() lo que es incoherente, puesto que todos los empleados deben tener un sueldo.

Existe otra opción tampoco recomendada de implementar el método calcularSueldo() en Empleado con una programación arbitraria para dar lugar al Polimorfismo en las subclases de empleado. Hacer esto sería otro error, puesto que no es lógico dar lugar a implementaciones arbitrarias.

La opción recomendada es la de utilizar métodos abstractos. Así, en Empleado, se declararía el método calcularSueldo() como un método abstracto, obteniendo así las siguientes ventajas:

Convertir a la clase Empleado en abstracta al declarar el método como abstracto, y con esto no permitir instanciar objetos de tipo Empleado, lo que se ajusta a la realidad, debido a que no existen empleados que no sean de tiempo parcial ni de tiempo completo.

Obligar a las subclases de Empleado a implementar el método calcularSueldo(), a menos que se defina a la subclase como abstracta también.

Una clase abstracta sí puede tener constructores, atributos y accesorios.

INTERFACES

Definición: Se llama interface a la clase que consta todos sus métodos abstractos.

La interfaz únicamente consta de constantes más no de atributos.

En el caso de: Empleado implements SRI, SRI es una interfaz y Empleado es una clase normal.

Una ventaja de las interfaces, es que si puede haber una relación de herencia múltiple.

Para la implementación de una interfaz:

Constantes: public static final

Manual de POO 26

INSTITUCIÓN EDUCATIVA

EMPLEADO

TiempoCompleto TiempoParcial


Clases: public abstract Interface : public Interface Relación de una clase con una interface: Clase implements Interface

Aunque para la implementación de las clases no es necesario escribir abstract.

En la interfaz, las constantes generalmente son públicas.

Importante: Una interfaz no puede instanciar objetos.

Ejemplo:

public abstract class Empleado implements Sri,Iess,MinisTrabajo {

private String cedula;private double sueldoBase;

public Empleado(String cedula, double sueldoBase) {

this.cedula = cedula;this.sueldoBase = sueldoBase;

}

public Empleado() {

this.cedula = "";this.sueldoBase = 0.0;

}

public String getCedula() {

return cedula;}

public void setCedula(String cedula) {

this.cedula = cedula;}

public double getSueldoBase() {

return sueldoBase;}

public void setSueldoBase(double sueldoBase) {this.sueldoBase = sueldoBase;

}

public abstract double calcularSueldo();

public double aporte() {

return 0.05 * this.getSueldoBase(); }

public double aporteMedico() {

return 0.07 * this.getSueldoBase(); }

Manual de POO 27


}

La clase Empleado implementa las Interfaces SRI, IESS, MinisTrabajo.

public interface Sri {

public static final double ir = 0.5;public static final double iva = 0.12;

public abstract double calcularIva(); //Método que me sirve para calcular el IVApublic abstract double calcularRenta();

}

MANEJO DE ARCHIVOS

A continuación se muestra un ejemplo de cómo se manejan los archivos:

import java.io.*;

public class Archivo {

public static BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in)); public static PrintWriter stdout = new PrintWriter(System.out,true);

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

stdout.println("Archivo Origen");stdout.flush(); // Borra la localidad de memoriaBufferedReader input = new BufferedReader(new FileReader(stdin.readLine()));

// Creación de un lector de archivo, que en este caso se ingresa por teclado.

stdout.println("Archivo Destino");stdout.flush();PrintWriter output = new PrintWriter(new FileWriter(stdin.readLine())); //Creación de un escritor de archivo.

String linea = input.readLine();while(linea != null) {

output.println(linea); //Copia la información del archivo input al outputlinea = input.readLine();

}input.close(); //Cierra el archivo de origenoutput.close();}

}

Se debe importar la librería java.io para manejar los objetos de manipulación de archivos.

BIBLIOGRAFÍA

http://www.monografias.com/trabajos7/impu/impu.shtmlhttp://es.wikipedia.org/wiki/ProgramaciÃ³n_orientada_a_objetos

Manual de POO 28

Folleto Java

Documents

Transcript of Folleto Java