CONTENIDO CONCEPTUALIZACION...................................................................................................................................3 1. LA CLASE ..................................................................................................................................................3 2. LOS ATRIBUTOS ......................................................................................................................................8 3. LOS MTODOS .......................................................................................................................................11 3.1 Parmetros:...........................................................................................................................................13 3.2 Tipos de Parmetros:............................................................................................................................

14 4. Encapsulado ..............................................................................................................................................14 LA IMPLEMENTACION DE LOS MTODOS Y LA INSTANCIAS DE LAS CLASES..........................23 ASIGNACIN :.............................................................................................................................................23 Asignacin Directa:....................................................................................................................................23 Asignacin Indirecta : ...............................................................................................................................23 2. ESTRUCTURAS CONDICIONALES:.....................................................................................................27 3. INSTANCIANDO CLASES......................................................................................................................45 CICLOS Y ARREGLOS ...................................................................................................................................55 1. CICLO FOR ..............................................................................................................................................55 2. CICLO WHILE..........................................................................................................................................56 3. ARREGLOS...............................................................................................................................................59

INTRODUCCION

En el mbito de la ingeniera de sistemas, la programacin es una herramienta primordial, debido a esto es indispensable que el estudiante de ingeniera tenga slidas bases de pensamiento lgico computacional que le permita en futuros cursos desempearse eficientemente, para ello tiene que comprender la forma como se resuelven problemas reales a travs de la aplicacin de los objetos. Adems comprender todos los datos y operaciones implcitas y explicitas que se plantean en un problema y que son necesarios para su solucin. En este curso se llevar a la prctica los conceptos tericos fundamentales de programacin utilizando como herramienta un lenguaje de programacin como Java y la tcnica de programacin orientada a objetos. El estudiante afianzando los conocimientos de la lgica computacional debido a que realizar programas en el computador iniciando el ciclo de cursos de desarrollo de software.

CAPITULO I

CONCEPTUALIZACION La programacin orientada a objetos es una tcnica que permite optimizar los recursos usados en el desarrollo de un software, que satisface una necesidad, utilizando en el modelamiento de los problemas una herramienta de diseo llamadas clases, haciendo nfasis en el problema en general para resolverlo de manera particular para una mejor eficiencia y mantenimiento futuro. Hay que resaltar que la base de esta programacin es el proceso de diseo, que permite modelar la posible solucin antes de escribir la primera lnea de cdigo que lo empiece a resolver. En el transcurso de este libro trataremos de enfocarnos en el concepto de diseo, dejando algunos temas del lenguaje para que el lector los estudie a satisfaccin y no desenfocarnos del objetivo que nos concierne.
1. LA CLASE

Es un ente que se usa para modelar un problema de la realidad, caracterizado por unos atributos (propiedades) y unos mtodos (acciones) que le permiten resolver dicho problema. Es debido anotar que es el problema quien genera la clase y no lo contrario, dado que de las particularidades del problema y de su contexto mismo es de donde se abstraen las propiedades (atributos) y mtodos (acciones) de la clase. Donde los atributos son las caractersticas propias del problema (datos necesarios) y los mtodos son las acciones que debe ejecutar la clase para resolver el problema (manipulando los datos con las operaciones necesarias). As por ejemplo: Se quiere disear una clase que permita calcular el rea y el permetro de un rectngulo. Recordemos que el rea es igual a la base por altura y el Permetro es igual a 2 veces la base mas 2 veces la altura.

Altura

Base Caracterizamos los atributos y los mtodos identificando cada uno de ellos con un nombre. Atributos: Para el problema son necesarios dos: Los llamaremos Base y Altura que son los datos bsicos y suficientes para realizar los clculos. Tenemos que para calcular el rea: Es necesario un mtodo que se encargue de hacer la operacin (multiplicacin) Base por Altura y lo llamaremos Calcular rea. Para calcular el Permetro: Se debe crear un mtodo que se encargue de hacer la operacin: 2 veces la Base ms 2 veces la altura, a este mtodo lo llamaremos Calcular permetro. Para poder tener la informacin correspondiente a los valores que se guardan el los atributos es necesario pedirla, para ello creamos un mtodo llamado pedirdatos y para mostrar el resultado de las operaciones que realiza la clase creamos el mtodo mostrarresultados Podemos observar que los datos que se pueden calcular (rea, Permetro) no se convierten en atributos sino en mtodos, adems que los atributos correspondientes a la clase no pueden ser ms que los datos bsicos requeridos para resolver el problema, en este caso los datos necesarios son los de los lados, y como el rectngulo tiene 2 lados iguales (Base) y otros dos lados iguales (altura) podemos disear la clase de la siguiente manera: Nota: Al asignarle un nombre a un atributo o a un mtodo recuerde no dejar espacios entre los caracteres de dicho nombre. Los mtodos se diferencia porque presentan (), al final del nombre.

Clase Rectngulo Base Altura

Pedir_datos() calcular_area() calcular_perimetro() mostrar_resultados() Plantearemos otro problema para aclarar un poco ms. Se quiere calcular el sueldo a pagar de un empleado, se tiene para ello las horas trabajadas y el valor de la hora. Hay que tener en cuenta los descuentos ocasionados por el seguro social y por la retencin en la fuente, calculados a partir del bsico ganado, adems hay que determinar si recibe subsidio o no. Solucin: Nmero de horas: Genera un atributo que llamaremos NumHoras. Valor de la hora: Genera un atributo que llamaremos ValHoras. Estos son los datos que el problema nos ofrece y que utilizaremos para poder disear la y que utilizaremos en los mtodos. Las operaciones a realizar: Bsico: Genera un mtodo para calcular nmero de horas por Valor de la hora, Lo llamaremos Bsico. Descuento seguro social: Genera un mtodo para calcular un descuento a partir del valor del bsico. Lo llamaremos DescuentoIss. Descuento por retencin en la fuente: Genera un mtodo para calcular otro descuento que se hace sobre el rango del valor del bsico. Lo llamaremos DescuentoRetencion. Subsidio: Genera mtodo que evala el valor del bsico y determina si recibe subsidio para asignarle el valor correspondiente sino asignara cero. Lo llamaremos Subsidio. Total a pagar: Este concepto es implcito al problema y genera un mtodo que se usar para calcular el pago final a partir del valor bsico restndole los dos descuentos. Lo llamaremos Neto. Observacin:

Volvemos a resaltar, los valores que se pueden calcular no son atributos (tenga eso en cuenta) sino que se pueden considerar como mtodos. Observemos que algunos mtodos necesitan utilizar no los atributos sino otros mtodos para poder realizar sus operaciones como es el caso de descuentoIss que necesita del mtodo bsico para poder calcular su propio valor, de igual manera el mtodo neto necesita de los otros para efectuar la operacin. (Esto es una caracterstica del diseo de clases). Adems diseamos los mtodos de pedirdatos y mostrardatos. Ntese que aunque podramos haber diseado un solo mtodo (Neto) para hacer todos los clculos correspondientes, no lo hacemos con el fin de acogernos a una regla que ms adelante explicaremos (Encapsulado). Veamos el diseo de la clase: ClaseTrabajador Valhoras Numhoras Pedirdatos() Basico() Descuentoiss() Descuentoretencion() Subsidio() Neto() Mostrarresultados() Nota: Los problemas cmo tales tienen unas propiedades que seran las causas de l, los atributos. Los mtodos, que son acciones del problema, se modelan de tal forma que se piensa en ellos como lo que se hace con los atributos. Ejercicios Resueltos A continuacin se plantean 3 problemas y se disea la solucin de ellos, haga un anlisis de cada solucin.

1. Disee una clase que permita conocer el resultado de una eleccin de alcalde puesto que el resultado es el siguiente: El candidato A tiene el 35% de los votos validos, el candidato B tiene el 12% de los votos validos y el candidato C tiene el 42% de votos validos. Los votos en blanco corresponden al resto de los votos validos. Los votos totales son X y el 78% de estos votos son validos. Clase Votacin Votos Pedirdatos() Calcularvotosvalidos() calcularvotoscanA() calcularvotoscanB() calcularvotoscanC() calcularvotosblanco() mostrarresultados () 2. Disear una clase que permita calcular el total de estudiantes de un colegio teniendo en cuenta que el colegio tiene 6 salones los cuales se distribuyen de la siguiente manera. El grado primero tiene X estudiantes, el grado segundo tiene 1/3 que el grado primero, el grado tercero es dos veces el grado 2, el grado cuarto tiene Y estudiantes, el quito grado tiene de cuarto grado mas el total de segundo, 6 tiene1/8 de la poblacin estudiantil anterior. Clase Colegio E_1 E_4 pedir_datos() calcular_Est_2() calcular_Est_3() calcular_Est_5() calcular_Est_6() calcular_Total_Est() mostrar_Resultados()

3. Dados A, B, C y D que corresponden a medidas de trozos de madera disee una clase que determine si se puede construir una mesa de: 2 patas, 3 patas y 4 patas. Clase Mesa A, B, C, D pedir_datos() calcular_mesa_2() calcular_mesa_3() calcular_mesa_4() mostrar_Resultados()

2. LOS ATRIBUTOS

Pueden contener datos que toman valores diferentes, los cuales pertenecen a un conjunto o rango determinado que a su vez pueden ser datos discretos o continuos de una naturaleza especfica, dependiendo del lenguaje de programacin con el que se trabaja. Dado que un atributo posee un dato de un tipo determinado, es necesario diferenciar entre el identificador del atributo y el contenido que albergar, veamos: Crearemos un atributo Sueldo y le daremos un valor de 1500 Identificador

sueldo |

1500

Contenido Actual

Observemos que el identificador (Sueldo) hace referencia a un valor dado (1500) que es el contenido que en este momento le fue asignado, tengamos en cuenta que podemos asignarle otro valor (en Sueldo guarde ahora el valor de 300). Identificador Sueldo 300 Contenido Actual

Esto caracteriza el contenido como el valor cambiante que depende de las operaciones que se hagan en el, pero el identificador que se le asigno no cambia nunca. Para poder accesar al contenido del atributo hay que hacer referencia a su identificador. El concepto de es asociado en programacin estructurada con el concepto de variable. Hay que tener en cuenta al momento de darle un identificador (nombre) a un atributo es recomendable relacionarlo con el concepto que queremos referenciar (mnemotcnica). Como regla general no es permitido mezclar los tipos de datos, es decir, un atributo puede manejar solo un tipo de dato a la vez, tomando valores que no deben violar el rango o dominio que se define para dicho tipo de dato. En trminos generales existen tres tipos: Numricos Alfanumricos (todo tipo de carcter). Y booleanos (valores lgicos 0 y 1; True, False). Otra caracterstica de los tipos de datos que podemos mencionar es que tienen definida una serie de operaciones, es decir, tienen definido lo que podemos hacer con ellos; operaciones que requieren el uso de operadores. Finalmente cabe anotar que el usuario (programador)

puede definir sus propios datos a partir de los datos primitivos definidos por el lenguaje de programacin (Tema que abordaremos mas adelante). Tipos de datos elementales en java Tipos Numricos (sin valores decimales) Palabra Rango de Valores reservada Byte Desde - 128 hasta 127 Short Desde -32768 hasta 32767 Int Desde -2147483648 hasta 2147483647 Long Desde -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807 Tipos de Datos Carcter Palabra Rango de Valores reservada String cadena de caracteres segn usuario Tipos de datos Lgicos Palabra Rango de Valores reservada Boolean Valor lgico True o False Aplicando el concepto de tipos de datos, sobre los atributos al definir stos se le debe indicar su dominio, es decir, el tipo de dato que va a manipular. Tipo de Dato Identificador; Ejemplo: String nombres; Int Sueldo;

Observaciones generales sobre los identificadores de los atributos en cualquier lenguaje:

No deben comenzar con nmeros No deben ser palabras reservadas del lenguaje de programacin. No deben contener espacios Por cuestiones prcticas deben ser claros y no tan largos. Deben ser mnemotcnicos o sea deben caracterizar al dato que manipularan.

Podramos enunciar otras pero dejaremos que la experiencia y la prctica con los compiladores les ensee ms.

Comenzaremos ahora un estudio de los mtodos y su Caracterizacin en Java.

3. LOS MTODOS

Son acciones que le dan la funcionalidad a la clase, y como tal definen el comportamiento que stos exhiben al momento de ser activados (usados). De este modo cada mtodo debe realizar una tarea especfica de acuerdo al problema que se quiere solucionar con la clase en mencin. En una clase podemos definir cuatro tipos de mtodos:
a)

Constructores:

Estos mtodos constituyen operaciones de inicializacin de valores para los atributos, como tambin la inicializacin de las estructuras internas de las clases (direccionamiento de memoria), por ende deben ser los primeros en ser activados al momento de utilizar la clase. Sintaxis:

Palabra reservada: Ejemplo:

Nombre clase () personas();

En Java los constructores tiene el mismo nombre de la clase y una clase puede tener varios constructores cambiando solamente los parmetros que se le pasan.
b)

Destructores :

Estos tienen como funcionalidad liberar los recursos de memoria utilizados por la clase para su trabajo. Su activacin implica que el objeto no podr ser usado para tareas posteriores en el mbito del programa que est haciendo uso de l . Sintaxis: Palabra reservada : finalize() ejemplo: protected void finalize() Otras caractersticas de los destructores en el lenguaje java es que no es necesario declararlos. Procedimientos : Estos mtodos se caracterizan por la ejecucin de una o ms acciones (operaciones) sobre unos datos o valores que tienen un tipo (dominio) determinado y que se obtienen en algunos casos leyndose de los atributos, tomndose a partir de parmetros (concepto que definiremos ms adelante) o utilizando otros mtodos de la clase . Sintaxis: Palabra reservada : ejemplo: Void Idenfificador; void Pedirdatos();

d)

Funciones :

Al igual que los procedimientos, una funcin constituye un mtodo que realiza operaciones sobre datos de un tipo especfico; datos que son ledos desde los atributos, otros mtodos de la clase y/o pasados por parmetros, pero que a diferencia de los procedimientos, las operaciones efectuadas sobre dichos datos devuelven uno y solo un valor que por supuesto tiene un tipo definido y el cual caracteriza el tipo de la funcin. Sintaxis: Palabra reservada : Tipo de dato Identificador;

Ejemplo: int calculararea() Ahora procederemos a complementar los conceptos anteriores con la definicin de parmetros.
3.1 Parmetros:

Para que los mtodos puedan ejecutarse debern tomar valores ya sea a la clase misma o a elementos externos. Cuando un mtodo necesita valores que son externos y estos valores pueden variar al momento de ser manipulados en los procesos mismos del mtodo, estos valores reciben el nombre de parmetros. Observemos el siguiente ejemplo que corresponde a una funcin matemtica: f(x) = 3x + 10 Podemos observar que x es un valor que no hemos definido, pero que se hace necesario al momento de calcular la funcin, es decir, f es el identificador del mtodo y x es el valor que f necesita para poder realizarla operacin (parmetro). Ahora bien si le asignamos algunos valores a x (parmetro) de f, tenemos que: f(3)= 3*3+10 f(5) = 3*5+10

f(10)=3*10+10 De sta manera vemos que la estructura del mtodo no vara lo nico que vara es el valor de x (parmetro) para calcular la funcin. Los valores (3,5,10) asignados en el ejemplo son remplazados en la referencia que en la funcin tiene x . Observacin: Cada vez que necesitamos valores cambiantes en un mtodo y no conocemos su contenido, debemos hacer la referencia en el mtodo con un parmetro.

3.2 Tipos de Parmetros:

Dependiendo que los parmetros retornen un valor o no al ser manipulados en un mtodo, se clasifican en : a) Parmetros por valor : Cuando el parmetro es utilizado solamente para introducir valores al mtodo que lo procesa. b) Parmetros por referencia: Cuando el parmetro al ser asignada al mtodo puede cambiar o modificar su valor durante su utilizacin en el mtodo, manteniendo esos cambios de all en adelante para dar a conocer dicho cambio a los dems miembros de la clase, quienes pueden utilizarlo y modificar de nuevo dicho valor. Para ver cmo trabajan conjuntamente los atributos y los mtodos, debemos comprender primeramente el concepto de encapsulado.

4. Encapsulado

El encapsulamiento define dos reglas, Una aplicada sobre los atributos que establece que para acceder a ellos (asignarles valores o leer los mismos), se deben definir mtodos especializados en dichas operaciones de tal manera que los atributos son manejados por medio de la activacin de dichos mtodos . La Otra regla est referida sobre los mtodos, determinando sobre stos un criterio de unicidad funcional, es decir, que un mtodo debe encargarse de realizar una tarea (proceso) nica ; De esta forma una clase define tantos mtodos como tareas deba efectuar. Como notamos en el encapsulado la esencia de proteger los datos con la utilizacin de mtodos implica diferenciar diversas secciones dentro de una clase: Seccin Privadas: En esta seccin se declaran los atributos y mtodos que solo pueden ser accedida por los mtodos de la misma clase, los descendientes no tienen acceso a ellos. Seccin Protegida: Aqu se declaran los atributos y mtodos de la clase que pueden ser accedidos por sus propios mtodos y por los mtodos de sus descendientes. Seccin Pblica: Se declaran los mtodos que la clase a poner a disposicin de quien lo necesite. clase Seccin Privada Atributos, Mtodos Seccin Protegida Atributos, Mtodos Seccin Publica Mtodos Sintaxis Class Identificador

{ private Tipo de dato Identificador de Atributos; public Tipo dato Identificador del metodo() {implementacin del mtodo} } Ahora retomaremos los ejercicios planteados al principio y veremos su respectiva solucin aplicando todos los conceptos estudiados hasta este momento, la parte de implementacin de los mtodos la abordamos mas adelante en este capitulo, por ahora nos enfocamos en el diseo de la clase. Para respetar la aplicacin del encapsulado los mtodos de pedir informacin y mostrar informacin se disean en la seccin pblica. Primer ejemplo, hallar el rea y el permetro de un cuadrado . Class rectangulo { private int base, altura public rectangulo() { implementacin}; void pedirdatos (int valbase;int valaltura) { implementacin }; void MostrarResultados () { implementacin }; int Obtenerbase() { implementacin }; int Obteneraltura() { implementacin } int Calculararea() { implementacin } int Calcularperimetro() { implementacin }; }; Explicacin: En la estructura definida en la clase notamos varios aspectos de importancia: Existen dos atributos (base, altura) que como se defini deben poseer un dominio (tipo de dato) que para el caso es int, la razn para ello es que deben ser valores enteros. Los dos atributos se encuentran en la seccin privada atendiendo a la regla del encapsulamiento que nos dice que debemos proteger todos los atributos. En la seccin pblica tenemos que:

 Trabajamos con un constructor al cual le llamamos como la clase rectangulo ,Se disean tres mtodos para acceder a los atributos : Para llevar informacin a los atributos diseamos el mtodo pedirdatos el cual utilizan dos parmetro un valbase y el otro valaltura los cuales van dentro de los parntesis del mtodo; y dos para traer informacin de los atributos que son Obtenerbase y Obteneraltura . Seguidamente se disean los mtodos que han de ser las acciones para lo cual se ha diseado la clase, siendo stos Calculararea y Calcularperimetro, adems un mtodo para mostrar resultados. Cabe anotar hacer referencia en la sintaxis del lenguaje java definicin de los mtodos en java implica la implementacin del cdigo de los mismo dentro de la clase, algo que omitimos ahora pero mas adelante atenderemos.. Nota: por sintaxis es recomendable en JAVA escribir todo el cdigo en minsculas ya que el compilador diferencia entre maysculas - minsculas y nos puede ocasionar un mal rato. Cuando este escribiendo cdigo olvdese de escribir alguna tilde. Trataremos ahora el segundo ejemplo planteado al comienzo del capitulo. Se quiere calcular el sueldo a pagar de un empleado, se tiene para ello las horas trabajadas y el valor de la hora. Hay que tener en cuenta los descuentos ocasionados por el seguro social y por la retencin en la fuente, calculados a partir del bsico ganado, adems hay que determinar si recibe subsidio o no. class trabajador { private: int numerohoras; float valorhora; public trabajador(){}; void asignarnhoras(int valhoras){}; void asignarvalor(float valvalor){}; int obtenernhoras (){}; float obtenervalor(){}; float Basico(){}; float descuentoiss(){};

float descuentoretencion(){}; float Subsidio(){}; float Neto(){}; }; Explicacin: En este ejemplo utilizamos 2 atributos con dominio distinto, numerohoras de tipo entero y valorhora de tipo real, esto con el fin de especificar el valor que puede contener cada atributo. Observe la sintaxis de los mtodos, adems tenga en cuenta que para los mtodos asignarnhoras y asignarvalor se usan parmetros, esto debido a que se hace necesario que estos mtodos interacten con el medio, para poder adquirir un valor exterior, los parmetros utilizados en dichos mtodos son del mismo dominio del atributo ya que ellos lo que harn ser guardar los valores que tomen en los atributos. Analice porque no diseamos un solo mtodo (pedirdatos)? Ntese que para cada accin de la clase, (tarea a realizar), hemos diseado un mtodo especfico con el fin de mantener el encapsulado y poder organizar el diseo. Bien ahora planteremos algunos ejemplos y disearemos su solucin, pero la explicacin y entendimiento corre por cuenta del lector. Ejemplo 3. El almacn vende ms desea en su aniversario hacer una promocin en su variedad de productos, para ello los ha clasificado en 3 categoras de la siguiente manera : Categora 1 : para los dispositivos de almacenamiento(discos duros, cintas ,tape backup etc..). Categora 2 : para los perifricos (impresoras, scanners, josticks etc..). Categora 3 : para los computadores completos. El almacn propone a sus compradores que lleven una cantidad de productos de una sola categora hacer los siguientes descuentos; 5% para artculos de categora 1, 8% para artculos de categora 2 y 12% para artculos de categora 3.

Disee una clase que permita al almacn saber cuanto debe pagar un comprador que lleva solamente artculos del mismo tipo. Observacin: Tenga en cuenta los valores que le dan en el problema y las acciones que deben hacer para lograr el resultado. class almacen{ Private int Cantidad ; int Valor; string Tipo ; public : almacen(){}; void Asignarcantidad(int valcant){}; void AsignarValor(int valvalor){}; void Asignatipo(string valtipo){}; int Obtenercantidad(){}; int ObtenerValor(){}; string Obtenertipo(){}; int Descuento(){}; int Valorneto(){}; int TotalaPagar(){}; }; Observaciones: El mtodo valorneto calculara el valor real de los artculos. El mtodo descuento evaluara el tipo de los articulo que se compra y calcula el valor del descuento utilizando el valorneto . El mtodo totalapagar calcula el valor que el usuario paga realmente. Ejemplo 4. Un estudiante de informtica desea controlar las notas de su asignatura de programacin, el profesor va a hacer 3 evaluaciones dndole un porcentaje a cada nota de la siguiente manera: Primera evaluacin 30% Segunda evaluacin 28%

tercera evaluacin 42% El profesor plantea que para aprobar la asignatura se debe tener un promedio de 3.5, el estudiante desea saber en que evaluacin le fue mal para reforzar los temas evaluados. class testudiante { private float primeranota; float segundanota; float terceranota; Public testudiante() { implementacion}; void AsignarNota1(float valnota1) { implementacion}; void AsignarNota2(float valnota2) { implementacion}; void AsignarNota3(float valnota3) { implementacion}; float obtenernota1(){ implementacion}; float obtenernota2(){ implementacion}; float obtenernota3(){ implementacion}; float calculapromedio(){ implementacion}; bool evaluaaprobacion(){ implementacion}; string notamenor(){ implementacion}; }; Observaciones La funcin calculapromedio se encarga de tomar cada nota y multiplicarla por su porcentaje para luego sumarlas las tres. La funcin evaluaaprobacion que devuelve un valor lgico determina si aprob o no la asignatura. La funcin notamenor evala cual de las tres notas fue la menor devolviendo el nmero de la nota y no su valor.

Practica

Para las clases votacion, colegio y mesa, escriba los diseos aplicando los conceptos vistos y la sintaxis de java. Hasta el momento nos hemos detenido en el proceso de diseo de clases porque es la etapa ms importante dentro del desarrollo de una aplicacin con un enfoque orientado a objeto. Ha podido observar que solamente con el diseo de la clase se entiende la solucin del problema y mas an se puede saber para que esta hecha dicha clase sin leer el problema como tal. Las recomendaciones ms importantes que se hacen entorno a la programacin Orientada a Objetos son las siguientes Dedquele buen tiempo a entender el problema , esto quiere decir analice todos los factores que se involucran dentro del problema planteado. No se apresure recuerde la celebre frase de Napolen Vstanme despacio que estoy de prisa. Analizado el problema proceda a identificar atributos y mtodos ( recuerde que si un dato se puede calcular no es un atributo ). Disee su clase. Diseado la clase hgase la siguiente pregunta. Satisface la clase todas las necesidades planteadas en el problema? Si su repuesta es SI felicidades ha logrado disear una clase! Y si su respuesta es NO, no se preocupe redisee su clase total todava no ha perdido tiempo escribiendo el cdigo de implementacin de los mtodos. . Nunca se le olvide las reglas de encapsulado cmplalas y comenzar a trabajar con una de las tcnicas de programacin mejor implementadas hoy en da. Recuerde que hasta ahora estamos en diseo una las etapas de la programacin orientada a objetos.

Taller 1. Que es un Clase? 2. Que importancia tiene el encapsulado en la Programacin Orientada a Objetos ? 3. Cul es la etapa ms importante en la Programacin Orientada a Objetos ? 4. Que es una clase ?. 5. Caracterice la sintaxis de java en cuanto a definicin de atributos. 6. Diferencie entre identificador de un atributo y su contenido . 7. Haga un breve resumen de la sintaxis de java en los tipos de datos. 8. Que son los mtodos ? 9. Determine la importancia de los constructores y destructores ? 10. Para que sirven los parmetros ? 11. Todos los mtodos tienen parmetros ? Disee las clases para resolver los siguientes problemas: 1. Se desea calcular el rea y el permetro de un crculo. 2. La empresa Cmputos S.A. desea controlar el inventario de los computadores que venden para as mantener en tiempo real informacin correspondiente a: tipo de computador, cantidad existente, cantidad mnima que debe haber y el valor de cada uno. Adems se desea saber el costo total de los computadores existentes. 3. Se desea saber cual es el mayor de tres nmeros dados .

CAPITULO II

LA IMPLEMENTACION DE LOS MTODOS Y LA INSTANCIAS DE LAS CLASES Cuando se disean las clases y especifican los mtodos se sabe cuales son las acciones que puede cumplir dicha clase. Bien ahora profundizaremos en cmo esos mtodos son capaces de resolver su propia tarea usando el cdigo necesario para que trabaje adecuadamente. Recuerde que cada mtodo en su diseo ya tiene proyectada una tarea a cumplir.
ASIGNACIN :

Cuando hay que guardar un valor en algn atributo o hacer operaciones con datos y saber sus resultados es necesario asignar dicho valor. La asignacin consiste en guardar valores en los datos, estos se pueden de varias maneras:
Asignacin Directa:

Consiste en guardar el valor de manera que no dependa sino del dato mismo. Ejemplo: Guardemos 5 en el atributo Nmero. Numero = 5
Asignacin Indirecta :

Ocurre cuando el valor de un dato depende de la operacin de otros datos que interactan. Ejemplo: En a guarde la operacin de x + y ,entonces a depende de los valores que tomen x , y.

a=x+y Nota: Cuando usamos los parmetros asignamos al atributo o dato al cual le queremos pasar dicho valor, el identificador del parmetro esto es en tiempo diseo luego cuando se corre el programa se asigna el valor que el usuario le pase por el parmetro. Regla : Para asignar un valor se debe ubicar el identificador del dato en el que queremos guardar al lado izquierdo y los valores de los datos que se quieren guardar al lado derecho . Sintaxis can=3; num = 10; nombre = Juan Prez; suma = num + can COMO IMPLEMENTAR LOS MTODOS Dadas las caractersticas del primer ejemplo que calcula el rea y el permetro de un rectngulo (este ejemplo utiliza solo asignaciones para resolver su problema) lo utilizaremos para aplicar la implementacin de los mtodos . Para efectuar operaciones cuando asignamos valores tengamos en cuenta los operadores aritmticos que los lenguajes nos presentan , ver cuadro Operacin Resta Suma Divisin Multiplicar Smbolo Ejemplo x = 5-3 + a=a+b / z=3/9 * rea = base * altura

class rectangulo

Private int base, altura; Public rectangulo (){ base = 0; altura = 0; } void asignarbase (int valbase ) { base = valvase; } void asignaraltura (int valaltura ) { altura = valaltura; } int obtenerbase () { return base; } int obteneraltura (){ return altura; } int calculararea () { int area; area = Obtenerbase() * Obteneraltura() ; return area; } int calcularperimetro (){ int permetro; permetro = (Obtenerbase() * 2 ) + (Obteneraltura() * 2); return permetro; }

ANALISIS : 1. Todos los mtodos deben comenzar con el tipo de dato que devuelven seguido del nombre del mtodo, entre parntesis la lista de parmetros , si los hay , teniendo en cuenta que en la declaracin de los parmetros va primero el tipo de dato y luego el identificador del

mismo. Si el mtodo no devuelve ningn valor se usa la palabra reservada Void que indica que el mtodo es un procedimiento . Ejemplo: Void Asignarbase (int valbase). Si el mtodo devuelve algn valor, entonces es una funcin, para esto se utiliza el tipo de dato y el identificador del mtodo. Ejemplo: Int Trectangulo Obtenerbase() . La palabra (return dato indica el valor que el mtodo debe devolver). 2. Todos los mtodos contienen un segmento principal que comienza con { y termina en }, dentro del cual se escriben las instrucciones que han de ejecutar dicho mtodo. En algunos casos es necesario declarar variables (datos) locales a un mtodo. Una variable local es aquella que existe solo dentro del mtodo en que se declara, es decir, solo puede ser usada entre el inicio y finalizacin de dicho mtodo, especficamente entre los smbolos de llave de apertura ({ ) y llave de cierre ( }) del cuerpo del mtodo. El uso de variables locales permite simplificar operaciones para que las instrucciones de una implementacin sean menos complejas y consecuentemente ms entendibles. Como ejemplo podemos mencionar el caso de la variable local : int rea en la implementacin de la funcin Calculararea, as la variable rea recibe el valor calculado para el rea (obtenerbase() * obteneraltura()) y posteriormente la funcin Calculararea devuelve dicho valor mediante la instruccin return area . 3. El constructor puede acceder directamente a los atributos. 4. Los mtodos de asignacin para los atributos utilizan el identificador del parmetro para asignarle su valor a dicho atributo. Ejemplo: El mtodo que le da un valor a la altura : Void Asignaraltura(int valatura), utiliza la siguiente sentencia de asignacin en su implementacin : altura = valaltura.

2. ESTRUCTURAS CONDICIONALES:

En la implementacin de los mtodos se escriben una serie de instrucciones que son las que le dan operatividad, es decir, determinan en una forma organizada, detallada, precisa y lgica lo que cada mtodo debe hacer, por lo tanto de acuerdo a cada mtodo as debe ser cuerpo de instrucciones. Hasta ahora hemos visto que estas instrucciones pueden consistir en la declaracin de variables, en el llamado o activacin de mtodos dentro de otros, en la asignacin de un dato a una variable, atributo o funcin y tambin hemos trabajado con operaciones de calculo matemtico. Todas estas instrucciones tratadas hasta el momento se ejecutan en forma secuencial una por una y en orden explcito. Sin embargo muchos casos de implementacin nos plantean el rompimiento de esta secuencialidad de tal manera que podamos ejecutar o no ciertas instrucciones de acuerdo a unas condiciones determinadas; pudiendo as tomar decisiones dentro de la implementacin de algn mtodo de nuestras clases. A estas instrucciones que nos permiten evaluar condiciones para tomar decisiones se les denomina Estructuras Condicionales . Una estructura condicional requiere de una expresin o condicin que al ser evaluada arrojar un nico valor de verdad que puede se verdadero (true) o falso (false). Si la expresin se evala como verdadero se ejecutarn las instrucciones que creamos necesarias para dicho caso, de lo contrario esas mismas instrucciones sern ignoradas. Sin embargo siendo la condicin falsa, tambin podemos establecer la ejecucin de otro bloque de instrucciones que alternativamente necesitemos ejecutar en el caso de que la expresin del condicional no sea verdadera. Por ejemplo una frase como esta es una instruccin condicional: Si maana llueve, entonces me quedar en casa. En ella vemos que la expresin a evaluar es si maana llueve y la accin a ejecutar si dicha condicin es cierta ser me quedar en casa. Sin embargo podemos hacer algo en caso de que la condicin sea falsa, por ejemplo: Si maana llueve entonces me quedar en casa,

sino ir a clases. Aqu podemos apreciar que se incluye una nueva parte en el condicional (sino) que indica que se va expresar la accin a realizar cuando la expresin a evaluar sea falsa, que para el ejemplo sera ir a clases. Veamos como programacin. se aplican estos conceptos en trminos de

La expresin o condicin que se evala en una estructura condicional es una expresin booleana, que toma uno y solo uno de dos valores posibles, True o False. Una expresin booleana se construye por medio de operadores relacionales y/o lgicos que se aplican a unos operandos (datos, variables, atributos y funciones del mismo dominio). Las expresiones lgicas estn compuestas de la siguiente manera : operando1 Operador operando2

Donde operando1 y operando2 son datos sobre los cuales cae el peso de la comparacin y el operador es la operacin de la comparacin que se ha de hacer. Tipo de operadores relacionales bsicos : OPERADOR Mayor que Mayor o igual Menor que Menor o igual Diferente Igualdad SIMBOLO > >= < <= != ==

Estos son operadores binarios, es decir, necesitan dos operandos que sern los dos datos que ellos han de comparar. Si la expresin es cierta, la expresin booleana retorna el valor true, en caso contrario, asume un valor de false. Por ejemplo, las siguientes son expresiones booleanas : a) 3 = = 3; b) 4+2 < 8; c) A > = B

Veamos que cada operador requiere dos operandos que se ubican al lado izquierdo y derecho respectivamente. Las expresiones tomarn los siguientes valores de verdad: a) 3 == 3 verdadero (true) b) 4+2 < 8 verdadero (true) c) A> = B falso (false) por que la letra A tiene un valor Ascci menor que el de la letra B. Como ejercicio intente determinar el valor de verdad de las siguientes expresiones booleanas: a) 4*2+1 <> 3*3-2 b) 3/2 != 6/4 c) m < e d) 5 != (3-2)*2 Como es de esperar la expresin booleana tambin puede estar formada por operadores lgicos. Un operador lgico no es ms que un conectivo lgico que puede comparar (asociar) dos o ms expresiones booleanas simples como las anteriores formando as expresiones booleanas compuestas. Los operadores lgicos requieren como operandos (datos a relacionar o comparar) valores y expresiones booleanas (datos que toman el valor true o false).

Los operadores lgicos en JAVA son los siguientes : Operador Smbolo Y Lgico && O Lgico Negacin Lgica

A excepcin de la negacin lgica que es un operador unario (que requiere solo un operando) los dems operadores son binarios (requieren dos operandos) y como se ha dicho estos operandos son datos booleanos (true o false), cada operador lgico posee una tabla de verdad mediante la cual se establece que valor asume al relacionar el o los valores lgicos. Las tablas son las siguientes:

Tabla del Y Expresin 1 True True False False Expresin 2 True False Trae False Expresin 1 Y Expresin 2 True False False False

Tabla del O Expresin 1 True True False False Expresin 2 True False True False Expresin 1 O Expresin 2 True True True False

Tabla de la Negacion Expresin True False Negacion Expresin False True

En estas tablas debemos anotar que Expresin - uno , Expresin dos y Expresin representan indistintamente cualquier expresin u operando de tipo booleano y que los operadores se encargan de

relacionar por medio de su tabla de verdad los valores correspondiente u operandos, arrojando un nico valor de verdad. Por ejemplo: (3 = 5) && (2 = 2) Existen dos expresiones booleanas (3 =5); (2 = 2). Debemos evaluar cada una independiente de la otra as : (3 = 5) = false y (2 = 2) = true.

Con estos valores booleanos procedemos a aplicar el operador and as :(True) && (False). Buscamos en la tabla de verdad la combinacin true false para el Y (donde expresin - uno corresponde a true y expresin - dos a false). As (true) And (false) = false. Es decir, que la expresin booleana(3=5) Y (2=2) = false. Ntese aqu el uso de parntesis para indicar el comienzo y finalizacin de cada expresin booleana. Miremos ahora este ejemplo : (A = A) (3-1 <> 2). La primera expresin (A = A) es true. La segunda expresin (3-1 <> 2) es false. El O entonces relacionar los valores as : (true) O (false). Dndonos como resultado final el valor true para la expresin booleana planteada. Trate de desarrollar el valor lgico para las siguientes expresiones booleanas: a) (true) (2 <> 1) ; b) ! true ;

c) (3 != 3) && (4-1 < 0); d) (1>=2) && (2<=1); e) ! false; f) ! (true !! false) g) (A !=B) !! (true); h) !(5 != 5) Como podemos pensar la construccin de expresiones booleanas compuestas requieren el uso de parntesis. Existe un concepto llamado procedencia de operadores (lgicos y/o relacionales) que es afectada por el uso de los parntesis. Esta procedencia indica que parte de la expresin booleana compuesta se empieza primero y en que orden se evalan las siguientes as como tambin se van relacionando cada expresin simple conectada con otras por medio del operador lgico respectivo. Bien , ahora estudiaremos las estructuras condicionales que presentan el siguiente formato : a) Condicional Simple : Palabra Condicional ( Expresin ) Por Verdadero Instruccin 1 Instruccin n

En caso que la expresin sea verdadera al momento de evaluarse se ejecutarn las instrucciones de 1..n , pero en caso de ser falso no ejecutar ninguna, el compilador seguir ejecutando las otras instrucciones. Estructura condicional simple if (condicin) { instrucciones a ejecutar; };

El condicional tambin permite evaluar una expresin y determinar las acciones a seguir por verdadero o por falso de la siguiente manera :
b) Condicional Compuesto :

Palabra ( Expresin ) Condicional

Por Verdadero Instruccin 1 Instruccin n

Por Falso Instruccin a Instruccin z

En dicho caso se ejecutarn las instrucciones que se encuentran en el condicional dependiendo del resultado de la evaluacin ya sea por verdadero o por falso ( recuerde que se ejecutara un conjunto de instrucciones ). En el condicional simple si no era verdadero el compilador no ejecutaba ninguna de las instrucciones del condicional. Estructura condicional compuesta if condicin { instrucciones a ejecutar por verdadero ; } else { instrucciones a ejecutar por falso; }; Nota :Observe la ausencia de punto y coma antes del else, esto se debe a la sintaxis del lenguaje. Veamos la implementacin de algunos ejemplos donde los mtodos necesitan evaluar ciertas condiciones para poder ejecutarse adecuadamente. Al resolver los problemas algunos mtodos evalan condiciones, analice la forma como se evala y luego identifique en la implementacin del mtodo el cdigo correspondiente:

Repase los planteamientos de los problemas del capitulo anterior y observe el diseo de cada una de las clases para que puede

entender a cabalidad la implementacin que iniciaremos a continuacin. TRABAJADOR : Caractersticas de los mtodos que necesitan evaluar condiciones. El mtodo DescuentoIss deben saber el rango del salario para determinar el porcentaje a calcular como descuento y valor a descontar. Estructura de evaluacin: if Condicin Por Verdadero Por Falso Instruccin a ejecutar bsico * 0.08 bsico * 0.12

Condicin : Que basico sea menor de 280000 El mtodo DescuentoRetencin debe determinar si el salario bsico est en el rango para saber si tiene descuento o n. Estructura de evaluacin: If Condicin Por verdadero Por falso Instruccin a ejecutar bsico * 0.10 0

Condicin : Que bsico sea mayor de 400000

 El mtodo Subsidio de igual manera debe determinar el rango del salario bsico para poder asignar un subsidio o no. Estructura de evaluacin if Condicin Por verdadero Por falso Instruccin a ejecutar 25000 0

Condicin : Que bsico sea menor de 280000. Ntese que en este problema utilizamos el mtodo llamado Bsico en la mayora de los otros mtodos (imagnese que tendr que hacer si no lo hubiese diseado). class trabajador { private : int numerohoras ; float valorhora ; public trabajador(){}; void asignarnhoras(int valhoras){ numerohoras=valhoras; } void asignarvalor(float valvalor){ valorhora=valvalor; } int obtenernhoras (){ return numerohoras; } float obtenervalor(){ return valorhora;

} float basico(){ float sueldo; sueldo = obtenerhoras ( ) * obtenervalor ( ); return sueldo; } float descuentoiss(){ float descuento; if bsico() < 280000 { descuento = basico( ) * 0.08; } else { descuento = basico( ) * 0.12; }; return descuento; } float descuentoretencion(){ float retencin; if basico() > 400000 { retencin = basico( ) * 0.1; } else { retencin = 0; }; return retencion; } float Subsidio(){ float valorsub; if basico( ) < 280000 { valorsub = 25000; } else { valorsub = 0; }; return valorsub; } float Neto(){

float sneto; sneto = basico( ) - descuentoiss( ) - descuentoretencin + subsidio; return sneto; }

Clase almacen Caractersticas de los mtodos que necesitan evaluar condiciones: En este clase el mtodo Descuento debe determinar el tipo de artculo que se seleccion para poder calcular el descuento a realizar. Estructura de evaluacin: if condicin Por Verdadero Instruccin a ejecutar ValorNeto * 0.07

Por Falso uccin a ejecutar

If

Condicin2

Instr

Por Verdadero ValorNeto * 0.08

Por Falso

ValorNeto * 0.12

Condicion1 : Si obtenertipo es igual a 1 Condicion2 : Si obtenertipo es igual a 2 Nota : No es necesario evaluar si obtenertipo es igual a 3 dado que no existen mas tipos y el falso de Condicion2 asume que es de tipo 3. class almacen{ Private int Cantidad ; float Valor; string Tipo ; public : almacen(){ cantidad=0; valor=0; tipo= ; } void Asignarcantidad(int valcant){ cantidad=valcant; } void AsignarValor(int valvalor){ valor=valvalor; } void Asignatipo(string valtipo){ tipo=valtipo; }

int Obtenercantidad(){ return cantidad; } float ObtenerValor(){ return valor } string Obtenertipo(){ return tipo; } float Descuento(){ float desc; If obtenertipo( ) = = 1 { desc = Valorneto( ) * 0.05; } Else If obtenertipo( ) = = 2 { desc = valorneto ( )* 0.08 } Else { desc = valorneto( ) * 0.12; } return desc; } float Valorneto(){ return (obtenervalor( )*obtenercantidad( )); } float TotalaPagar(){ float pago; pago= valorneto( )-descuento( ); return pago; } }

Cabe destacar que en la implementacin de mtodo descuento es necesario declarar una variable de mbito interno al mtodo ( solo se conoce al interior de ste) para capturar el valor resultante de la operacin valorneto por porcentaje de descuento con el fin de hacer mas legible y entendible el cdigo que se escriba.

Clase estudiante Caractersticas de los mtodos que necesitan evaluar condiciones: El mtodo EvaluarAprobacin debe determinar si el promedio obtenido (CalcularPromedio) es mayor que 3.5 para saber si aprob o no. Note que devuelve falso o verdadero. Estructura de evaluacin: If Condicin Por verdadero Por falso Instruccin a ejecutar True False

Condicin : Si calculapromedio es mayor de 3.5. El mtodo NotaMenor es algo un poco complejo por que debe evaluar cual de las notas es la menor; debido a que la evaluacin debe comprobar varias condiciones, por ende se hace necesario utilizar conectores lgicos (&&) para facilitar la implementacin . Estructura de evaluacin :

If Condicin1

Y Condicin2 Por Verdadero instruccin 1

Por Falso

if Condicin3

Condicin4

Por Verdadero Instr. 2

Por Falso instruccin 3

Condicion1: obtenernota1 es menor que obtenernota2. Condicion2: obtenernota1 es menor que obtenernota3. Condicion3: obtenernota2 es menor que obtenernota1. Condicion3: obtenernota2 es menor que obtenernota3. Analice porque no es necesario evaluar si obtenernota3 es menor. Nota: Observando la tabla Y, teniendo en cuenta la estructura del condicional compuesto, analice cuidadosamente el mtodo NotaMenor y saque sus propias conclusiones . class testudiante { private float primeranota; float segundanota;

float terceranota; Public testudiante() { primeranota=0; segundadota=0; terceranota=0; } void AsignarNota1(float valnota) { primeranota=valnota; } void AsignarNota2(float valnota) { segundadota=valnota; } void AsignarNota3(float valnota) { terceranota=valnota; } float obtenernota1(){ return primeranota; } float obtenernota2(){ return segundadota; } float obtenernota3(){ return terceranota; } { float calculapromedio() float suma; suma = obtenernota1( ) + obtenernota2( ) + obtenernota3( ); return (suma /3); } bool evaluaaprobacion() if calcularpromedio( ) >= 3.5 then

return(true); else return(false);

int notamenor(){ if((obtenernota1()<obtenernota2())&&(obtenernota1()<obtenernota3( )) { return(1);} else if((obtenernota2()<obtenernota1())&& (obtenernota2()<obtenernota3()) { return(2);} else { return(3);}

3. INSTANCIANDO CLASES

Hasta ahora nos hemos dedicado a disear e implementar clases que son solucin a problemas, pero nos embargan unas preguntas: bueno y como se usan esas clases? Si funcionan ? Como las pruebo ? Bien para poder utilizar una clase debemos : Primero definir una instancia de la clase, lo cual es crear una o varias referencias a la clase a travs de nombres o identificadores que definimos, como lo hacemos cuando definimos los atributos : int sueldo; Para definir una instancia seguimos la misma regla: testudiante alumno; Donde testudiante es la clase y alumno es la instancia de la clase. Segundo crear la instancia alumno de la siguiente manera: alumno= new testudiante(); Donde new es una palabra reservada de java que permite crear el espacio de memoria para la instancia. Hay que tener en cuenta que en java cuando se crea la instancia automticamente se llama el constructor y ejecuta las instrucciones que hallamos definido en el, lo cual indica que si lo definimos en la clase con parmetros debemos pasarle los valores en el mismo momento de crear dicha instancia. Tercero hacer el llamado de los mtodos asi: alumno.AsisgnarNota1(10); alumno.AsisgnarNota2(50); alumno.AsisgnarNota3(17); Cuando los mtodos devuelven valores debemos guardar los valores que devuelven en variables previamente definidas: float promedio; promedio = alumno.calculapromedio();

El orden de llamado de los mtodos depende exclusivamente de como se requiere resolver el problema, pero tenga en cuenta de llamar los mtodos que guardan valores antes de llamar mtodos que efecten operaciones con dichos valores. Ejemplo : A continuacin instaciamos la clase trabajador y activaremos sus mtodos, y haremos anlisis de lo que sucede. trabajador empleado; float total; empleado= new trabajador(); empleado.asignarhoras(36); empleado.asignavalor(3546); total=empleado.Neto(); Analisis 1. Definimos la instancia empleado de tipo de clase trabajador. 2. Creamos la instancia con new, ntese que el constructor no ejecuta instruccin alguna ni tampoco recibe valores como parmetros. 3. Enviamos el valor 36 al atributo numerohoras a travs del mtodo asignarhoras. 4. Enviamos el valor 3546 al atributo valor a travs del mtodo asignavalor. 5. A la variable total le asignamos el resultado de las operaciones que realiza el mtodo neto. Operaciones del mtodo neto: llama al mtodo basico, el cual obtiene el valor de los atributos por intermedio de sus mtodos. Llama el mtodo descuentoiss y se lo resta a basico. Llama a descuentoretencion y tambin se lo resta al valor devuelto por el bsico. Llama al mtodo subsidio y se lo suma al bsico. Despus de analizar como se usan las clases a travs de su instancia al lector le pueden embargar otras preguntas como:

Donde escribo el cdigo que define y crea las instancias? Por que se dan valores directamente o es que no se pueden ser definidos por el usuario? Para responder la primera pregunta lo que se debe realizar es crear una clase en java que implemente el siguiente mtodo: public static void main(String args[]) Escribiendo dentro de el cdigo correspondiente a la definicin de la instancia y al llamado de los mtodos respectivos. Ejemplo de uso de la clase trabajador import java.io.*; class Principal { public static void main(String args[]) { trabajador empleado = new trabajador(); empleado.asignarhoras(36); empleado.asignavalor(3546); System.out.println(empleado.Neto()); } } Nota: observe que encabezado incluye la instruccin import java.io.*; Esto es para poder utilizar las clases de entrada y salida. Adems la instruccin System.out.println se usa para mostrar por pantalla el resultado de cualquier operacin o para mostrar mensajes al usuario. Ahora planteamos un problema y desarrollamos su solucin donde se involucren todos los elementos hasta ahora tratados y responda el interrogante de la segunda pregunta de interfaz con el usuario. Problema

Disear una clase que permita manejar la informacin de llamadas en un sai teniendo como base la duracin de la llamada y el valor del minuto. Solucin class Llamada{ int ValMin,Tiempo; Llamada(){ } public void LlevaMinuto(int Val) { ValMin = Val; } public void LlevaTiempo(int Ti) { Tiempo = Ti; } int TraeMinuto() { return ValMin; } int TraeTiempo() { return Tiempo; } int ValorLlamada() { int Calcula; Calcula = TraeMinuto()*TraeTiempo(); return Calcula;} } Clase que instancia import java.io.*;

class Principal{ public static void main(String args[]){ Llamada Llamar = new Llamada(); int Vmin = 0; int Tiem = 0; BufferedReader Tecla = InputStreamReader(System.in)); try { new BufferedReader(new

System.out.print("Digite el valor del minuto :"); Vmin =Integer.parseInt(Tecla.readLine()); Llamar.LlevaMinuto(Vmin); System.out.print("Digite el tiempo :"); Tiem =Integer.parseInt(Tecla.readLine()); Llamar.LlevaTiempo(Tiem); } catch (IOException varerror) {System.out.println("Error");}

System.out.println(" ");//mostrar el valor de la llamada System.out.println("El valor de la llamada "+Llamar.ValorLlamada()); System.out.println(" "); } } Anlisis La instruccin try { }catch Permite capturar algn error ocurrido al escribir los datos y evitamos que se bloquee el programa cuando estemos cargando datos desde el teclado.
BufferedReader Tecla InputStreamReader(System.in)); = new BufferedReader(new

En esta instruccin se crea una instancia de la clase bufferedReader que java tiene implementada llamada tecla la cual es capaz de leer caracteres desde el teclado. Tecla.readLine() Se hace un llamado al mtodo readline que permite leer una lnea de caracteres por pantalla y guardarla en los atributos donde se asigne. Integer.parseInt Convierte la cadena leda en datos enteros y este valor convertido debe asignarse a un datos de tipo integer. Todo esto se debe realizar dado que en java lo que se captura son cadenas de caracteres y debemos hacer las conversiones a sus valores numericos correspondientes.

Taller 1. Explique para que son los parmetros en los mtodos. 2. Concluya para que sirve el encapsulado. 3. Que diferencias existen entre cada uno de los mtodos. 4. Explique para que sirven los conectores lgicos 5. Para que se usan las estructuras condicionales. 6. Que es una instancia? 7. Hay diferencia entre instancia y clase? 8. Se puede instanciar una clase varias veces?, como? Disee e implemente: 1. Dados tres nmeros calcular el mayor, el menor y el nmero medio, disear e implementar la clase pertinente.

2. Dado el nombre, la edad y sexo de una persona disee e implemente una clase en la que el constructor inicialice los atributos, adems que determine si la persona es apta para votar teniendo en cuenta que solo votan las personas que cumplan las siguientes condiciones: mujeres mayores de 21 aos, hombres mayores de 18 aos. 3. disee e implemente una clase que dado el nombre, estatura, edad, peso. Determine si esa persona puede practicar o no los siguientes deportes teniendo en cuenta las restricciones: a. Ftbol : estatura mnima 170, edad mxima 17 aos b. Bsquet: estatura mnima 180, edad mnima 16 aos mxima 19 aos c. Softbol : peso mnimo 70 kilos , edad mnima 18 aos. d. Boxeo : peso mximo 100 kilos, estatura mnima 170. 4. Cree la instancia que utilice la solucin del ejercicio 3. 5. Cree una clase que utilice y aplique dos instancias para le solucin planteada en el ejercicio 2 y de valores que cumplan para cada condicin.

Para consulta se presentan dos ejemplos de clases, una para manejo de ventanas y otra clase para manejo de texto y conversin de nmeros que pueden usar y complementar en el futuro. import java.awt.*; import java.lang.*; import java.awt.event.*; class MiVentana { static Frame ventana=new Frame(); static Label Eventana=new Label("Digite un nombre"); static TextField Tventana=new TextField(15); static Button boton1=new Button("Guardar"); static Button boton2=new Button("Otro"); static int dato=0; public static void main(String args[]) { ventana.setTitle("manejo de ventanas"); ventana.setLayout(new FlowLayout()); ventana.add(Eventana); ventana.add(Tventana); ventana.add(boton1); ventana.add(boton2); ventana.pack(); ventana.setVisible(true); boton1.addMouseListener( new MouseAdapter() {public void mousePressed(MouseEvent e) { dato=Integer.parseInt(Tventana.getText()); if (dato <100) dato =dato+20; else dato =200;}});

boton2.addMouseListener( new MouseAdapter() {public void mousePressed(MouseEvent e) {Tventana.setText(String.valueOf(dato));}}); ventana.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) { System.exit(0);}});

} } Import java.io.*;

public class LeeTeclado { InputStreamReader tecla; BufferedReader teclado; public LeeTeclado() { tecla = new InputStreamReader(System.in); teclado = new BufferedReader( tecla );

} public String leerString(){ String valor = new String(); try{ valor = teclado.readLine(); }catch(IOException ioe){ System.out.println("Error de lectura de datos"); valor = ""; } } return valor; public int leerEntero(){ int valor = 0; try{ String valorLeido = teclado.readLine(); Integer convierte = new Integer(valorLeido); valor = convierte.intValue(); }catch(IOException ioe){ System.out.println("Error de lectura de datos"); valor = 0;

} return valor;

CAPITULO III

CICLOS Y ARREGLOS Una de las situaciones mas comunes que nos encontramos en el mbito de la programacin, consiste en la necesidad de repetir dentro de un mtodo un conjunto de instrucciones o repetir varias veces la activacin de un mtodo. Todo esto se puede realizar utilizando instrucciones repetitivas llamadas ciclos, las cuales vamos a estudiar y analizar a continuacin. Ciclos con numero de iteraciones definidas:
1. CICLO FOR

Este se caracteriza por ejecutar las instrucciones que se encuentran dentro de a partir de un dato inicial, con un incremento automtico de uno en uno hasta un valor final o sea el numero de iteraciones que necesitamos en el problema. Sintaxis del ciclo for for (i=1;i<tamao;i++) { conjunto de instrucciones } Estructura i=1: Donde i es un controlador del ciclo que le inicializa con un valor. i<tamao: Expresin que se evala automticamente antes de cada vuelta de ciclo para determinar si repite nuevamente el conjunto de instrucciones teniendo en cuenta si es verdadero el resultado de la evaluacion. i++: Expresin de auto incremento de uno en uno, esto con el objetivo de acercase a un valor false, que determine la parada del ciclo.

Ejemplo Mostrar los nmeros del 1 al 10 for (i=1;i<=10;i++) { System.out.println(i); } El resultado ser 12345678910. Preguntas Cual ser el resultado si se remplazamos la expresin de condicin i<= 10 por la expresin i>10 ? Cual seria el resultado si se cambiara el operador operador < ? Cual seria el resultado si se cambiara el operador operador == ? <= <= por el por el

Tenga en cuenta el operador que usa, dado que le puede hacer una o mas iteraciones de las presupuestadas. Algunas veces no podemos definir explcitamente el numero de iteraciones que puede llegar a hacer un ciclo pero podemos contar con condiciones que deben cumplirse para que contine iterando o para que deje de iterar un ciclo.

2. CICLO WHILE

Este ciclo tiene como caracterstica que debe cumplirse una condicin inicial de entrada (valor booleano true) y se repite el conjunto de instrucciones que se encuadran dentro de el mientras esta condicin se mantenga en verdadero, esto quiere decir que es funcin de nosotros determinar dentro de el conjunto de instrucciones definidas dentro del ciclo, una que garantice que en algn momento ese valor booleano true se convierte en false para dar por terminado el ciclo. Sintaxis del ciclo while

While (condicion=true) { conjunto de instrucciones condicion = false } Estructura del ciclo while Condicin =true : Es una expresin lgica que se argumenta con valor inicial de verdadero porque sino el ciclo no ejecutara ninguna instruccin que se encuentre dentro de el. Condicin =false: Es una expresin lgica que debe resulta de evaluar alguna de las instrucciones dentro del ciclo y adems debe tomar el valor del false en cualquier iteracin del ciclo, para garantizar la terminacin del ciclo y no convertir el proceso en algo indefinido. Esta puede ser la asignacin de un valor determinado, el incremento de un contador o simplemente el resultado de una operacin aritmtica, asociadas con el operador utilizado en la condicin de control del ciclo. Ejemplo: Mostrar los primeros nmeros que su suma sea menor o igual a 25 i=0; maximo=25; suma=0; while(suma<=maximo) { System.out.println(i); I++; suma=suma+i; } El resultado seria 0123456

Anlisis

Con valores iniciales i=0, suma=0 , maximo =25 Evaluamos suma<=maximo (0<=25) Como es verdadero mostramos el contenido de i que es 0, incrementamos el valor de i en 1, y a suma asignamos 1 Evaluamos suma<=maximo (1<=25) Como es verdadero mostramos el contenido de i que es 1 Incrementamos i en 1(i es 2) ; en suma sumamos el 1 que tenia mas el valor de i que es 2 (suma 3). Evaluamos suma<=maximo (3<=25) Como es verdadero mostramos el contenido de i que es 2 Incrementamos i en 1 (i es 3) ; en suma sumamos el 3 que tenia mas el valor de i que es 3 (suma 6). Evaluamos suma<=maximo (6<=25) Como es verdadero mostramos el contenido de i que es 3 Incrementamos i en 1 (i es 4) ; en suma sumamos el 6 que tenia mas el valor de i que es 4 (suma 10). Evaluamos suma<=maximo (10<=25) Como es verdadero mostramos el contenido de i que es 4 Incrementamos i en 1 (i es 5) ; en suma sumamos el 10 que tenia mas el valor de i que es 5 (suma 15). Evaluamos suma<=maximo (15<=25) Como es verdadero mostramos el contenido de i que es 5 Incrementamos i en 1 (i es 6) ; en suma sumamos el 15 que tenia mas el valor de i que es 6 (suma 21). Evaluamos suma<=maximo (21<=25) Como es verdadero mostramos el contenido de i que es 6 Incrementamos i en 1 (i es 7) ; en suma sumamos el 21 que tenia mas el valor de i que es 7 (suma 28). Evaluamos suma<mximo (28<=25)

Como es falso termina el ciclo y ninguna de las instrucciones que se encuentran dentro de el se vuelven a ejecutar por ende el 7 no se muestra. Ntese que suma se va incrementando hasta que toma un valor que no cumple con la condicin de control del ciclo. que resultado mostrara si invierte las instrucciones dentro del ciclo de la siguiente manera:? i=0; suma=0; while(i<=suma) { Suma=suma+i; System.out.println(i); } Nota: hay que tener cuidado con el orden en que escribimos las instrucciones y la condicin de salida dentro de un ciclo while Un ciclo que nunca se ejecuta I=3; While ((i>3) (i<3)) { i++; System.out.println(i); } Un ciclo que nunca termina I=3; While (i>=3) { i++; System.out.println(i); } Recuerde el ciclo while primero evala la condicin antes de ejecutar cualquier instruccin.
3. ARREGLOS

Los arreglos son colecciones de datos del mismo tipo que se almacenan secuencialmente, los cuales se manipulan con un identificador o nombre. Caracterizacin de un arreglo. 0 34 Donde 1 35 45 2 Notas 3 4 10 18 5 50 6 32 7 25 8 39 9 24

Notas es el nombre del arreglo 0,1,2,3.9 son cada uno de los ndices o posiciones de los elemento del arreglo. Siendo 0 el primer elemento del arreglo y 9 el ultimo elemento del arreglo.

34, 35,4524 son los datos almacenados en cada posicin del arreglos, o sea el valor de cada elemento del arreglo todos son del mismo tipo o dominio. El tamao del arreglo es el numero mximo de elementos que se pueden almacenar, en este caso es 10 Nota A los arreglos solo se puede acceder a travs de la posicin individual de cada uno de sus elementos la cual esta indicada por el ndice o posicin. Como acceder a un arreglo? Para manejar un arreglo solo puede ser de un elemento a la vez, de la siguiente forma: Para guardar informacin Nombrearreglo [ posicion] = valor Notas[0]=34;

Esto indica que en el arreglo Notas en la posicin 0 se guarda el numero 34 Para extraer la informacin Variable= Nombrearreglo [ posicion] Int dato; Dato=Notas[5]; Esto nos indica que en dato se guarda el valor almacenado en la posicin 5 del arreglo Notas, en este caso dato guardar 50. No es necesario que tengamos que acceder directamente al arreglo indicando explcitamente cual es la posicin del elemento, tambin lo podemos hacer haciendo uso de las variables controladoras de los ciclos, garantizando recorrer todo el arreglo de elemento en elemento con menos instrucciones. Por ejemplo : Sacar el promedio de notas del arreglo Notas usando un ciclo for; Suma=0; Promedio=0; For (i=0;i<10;i++) Suma=suma+Notas[i] Promedio = suma/10 System.out.println(promedio)

Observe: 1. La condicin del ciclo i<10 no incluye el igual, dado que la posicin 10 dentro del arreglo no existe. 2. la instruccin notas[i] hace que cada vez que i cambie de valor, ose se incremente, se puede acceder a cada elemento del arreglo.

3. hay una sola instruccin dentro del ciclo Suma=suma+Notas[i] por ello no se hace necesario el uso de llaves{} para indicar comienzo y fin del ciclo. Mtodos de bsqueda Planteamiento 1 Problema en el arreglo notas queremos hallar cual es numero mayor: 0 34 Notas 1 2 35 45 3 10 4 18 5 50 6 32 7 25 8 39 9 24

Para implementar un mtodo capaz de resolver el problema se analizan las situaciones: 1. Como empezar; 2. como comparar y buscar; Para comenzar asumimos una hiptesis el primer elemento del arreglo lo tomamos como si fuera el mayor. Mayor=notas[0] Segundo recorremos todo el arreglo peguntando si el valor guardado en mayor es menor que el valor en cada posicin del arreglo, en caso de ser verdadero se debe actualizar el valor del mayor con el contenido del elemento correspondiente For i=0;i<tamao del arreglo;i++ If mayor < notas[i] { mayor=notas[i] } Planteamiento 2 Deseamos implementar un mtodo que nos busque un elemento dado dentro del arreglo y nos devuelva la posicin donde se encuentra si esta. Para implementar un mtodo capaz de resolver el problema se analizan las situaciones:

1. Como empezar; 2. Como comparar y buscar; 3. Como parar la bsqueda 4. Como saber que encontramos Para iniciar el mtodo deber recibir el valor a buscar como parmetro dado que el usuario es quien va a decidir cual numero buscar. Segundo debemos preguntar si el elemento dado es igual a cada uno de los elementos en el arreglo. elemento == notas[i] Tercero Que ciclo usamos y como paramos ? Como no sabemos cuantas iteraciones tendremos que hacer antes de encontrar el dato, el ciclo ideal es el while. El ciclo deber detenerse con las siguientes condiciones: Cuando no este el elemento en el arreglo y se llegue al final del mismo i<tamao, o cuando lo encuentre elemento==notas[i], esto quiere decir que busque mientras sea diferente. I=0; while ( i < Tamao)&& (elemento != notas[i]) i++; Cuarto para saber que encontramos es necesario preguntar porque se termino el ciclo? , lo cual logramos preguntando si i es igual al tamao. En caso afirmativo quiere decir que i tomo el valor del tamao del arreglo por ende el elemento no se encuentra y devolvemos un valor que no corresponda a ningn ndice del arreglo (-1). En caso contrario i nos indica cual es la posicin en donde esta el elemento. if (i==Tamao) return -1 else return i; Clase que manipula un arreglo de nmeros Para manipular arreglos en java hay que tener en cuenta que siempre debe existir una instancia del arreglo antes de usarlos, esto debido a

que java considera a los arreglos como una clase y as los tiene implementados. A continuacin disearemos una clase para el manejo de un arreglo de nmeros implementando los mtodos necesarios. class Arreglo{ int ArrNum[]; int CantNum; public Arreglo(int c) { CantNum = c; ArrNum = new int [CantNum]; } void LlevaNumArr(int Num, int pos) { ArrNum[pos]= Num; } int TraeNumArr(int pos) { return ArrNum[pos]; } int TraeCantNum() { return CantNum; } public int BuscaMayor() { int Mayor = 0; for (int i=0; i < TraeCantNum(); i++) { if(ArrNum[i] > May) { Mayor = ArrNum[i]; }

} return Mayor; } public int BuscaPos() { int Mayor = 0; int pos = 0; for (int i=0; i < TraeCantNum(); i++) { if(ArrNum[i] > Mayor) { Mayor = ArrNum[i]; pos = (i); } } return p; } public int BuscaNumero(int Val) { int i = 0; while ( i < TraeCantNum())&& (val != ArrNum[i]) i++; if (i==TraeCantNum()) return -1 else return i; } public void OrdenaNumeros(){ int j = 0; int Temp = 0; int inc = 1; while (j < TraeCantNum()){ for (int i=0; i < TraeCantNum() - j; i++) { if(TraeNumArr(i) < TraeNumArr(j)){ Temp = TraeNumArr(j);l LlevaNumArr(TraeNumArr(i),j); LlevaNumArr(Temp,i); }

} } } } El mtodo ordenanumeros() permite organizar el arreglo de manera ascendente, utilizando el popular mtodo de burbuja, el cual consiste en llevar el elemento mas pesado a su posicin real, y as sucesivamente con cada uno de sus elementos. Como ejercicio complementario investigue en que consiste y como funciona el mtodo burbuja de ordenamiento que esta implementado en la clase. j++

Clase que instancia arreglo import java.io.*; import java.lang.*; class LlenaArreglo { public static void main(String args[]) { int Nume = 0; BufferedReader tecla new BufferedReader(new InputStreamReader(System.in)); try { System.out.println("*************** arreglos **************"); System.out.println(" "); System.out.print("Digita la dimension del arreglo ==> "); Nume = Integer.parseInt(tecla.readLine()); Arreglo Llena = new Arreglo(Nume);

System.out.println("Digita numeros "); for (int i=0; i < Llena.TraeCantNum(); i++) { System.out.print("Posicion " + (i+1) + ": "); Nume=Integer.parseInt(tecla.readLine()); Llena.LlevaNumArr(Nume,i); } System.out.println(" "); System.out.print("Digita el numero a buscar ==> "); Nume = Integer.parseInt(tecla.readLine()); if (Llena.BuscaNumero(Nume) != 0) { System.out.println(" "); System.out.println("El numero " + Nume + " se encuentra en al posicion ==> "+Llena.BuscaNumero(Nume)); System.out.println(" "); } System.out.println("El numero mayor es " +Llena.BuscaMayor()+ " en la posicion "+Llena.BuscaPos()); System.out.println(" "); System.out.println(" "); Llena.OrdenaNumeros(); System.out.println("Arreglo Ordenado "); System.out.println(" "); for (int i=0; i < Llena.TraeCantNum(); i++) { System.out.print(" "+Llena.TraeNumArr(i)+" "); } System.out.println(" "); System.out.println(" "); } catch (IOException varerror) {System.out.println("Error"); } } }

Taller Haga un anlisis exhaustivo de el cdigo de la clase Llenaarreglo y conteste los siguientes enunciados: 1. Donde se hace la instancia de la clase 2. Que mtodo enva la dimensin del arreglo. 3. En que seccin se captura de los nmeros que se han de guardar en el arreglo. 4. Ubique donde se busca un numero muestra como resultado. dado por el usuario y que

5. Haga un seguimiento al segmento donde muestra el numero mayor del arreglo. 6. explique el cdigo donde se muestra el arreglo ordenado

Disee e implemente las clases correspondiente para resolver los siguientes planteamientos utilizando uno o varios arreglos. 1.El manejo de un sai donde varios usuarios hacen varias llamadas en el da, tenga en cuenta que es necesario saber: a. La cuenta de un solo usuario. b. Cual fue el usuario que hizo mas llamadas. c. Cual es costo de la cuenta mas grande en trminos de valor y que usuario la hizo. d. La cuenta total del da. 2. El Departamento de ingeniera de sistemas desea mantener un control de las notas de cada estudiante en cada materia del primer semestre. Se debe guardar por cada estudiante en cada una de sus materias las 3 notas parciales, y se calcula la definitiva de la siguiente manera (la primera nota corresponde al 25%, la segunda nota corresponde al 35% y la cuarta nota corresponde al 40%). Se desea saber la siguiente informacin: a. Cual es el promedio de cada estudiante en el semestre. b. El nombre del estudiante de mejor promedio. c. Que materias perdi cada estudiante y con que calificacin (para aprobar una materia la nota mnima es 3.0). d. Cantos estudiantes perdieron 1 materia, cuantos perdieron 2 materia y cuantos perdieron mas de 2 materias. e. Cual fue la nota mas alta en cada materia y que estudiante la obtuvo. A continuacion se presentan dos ejemplos resueltos prar que los analice y le sirva de guia, note que por transcripcion puede faltar o sobrar simbolos(; , {, }). El ejemplo 1: involucra 2 clases (TotalEst y LlenaEstudiantes) El ejempo 2 involucra 3 clases (Nomina, ArregloNomina y Principal)

EJEMPLO 1 Clase que manipula varios arreglos en paralelo por su posicin. class TotalEst { int CantEst; int ArrCod[]; String ArrNom[]; String ArrMat[]; int ArrSem[]; float ArrNot[]; public TotalEst(int c){ CantEst = c; ArrCod = new int [CantEst]; ArrNom = new String [CantEst]; ArrMat = new String [CantEst]; ArrSem = new int [CantEst]; ArrNot = new float [CantEst];

void LlevaCodigo(int Cod, int pos) { ArrCod[pos]= Cod; }

void LlevaNombre(String Nom, int pos) { ArrNom[pos]= Nom; } void LlevaMateria(Sring Mat, int pos) { ArrMat[pos]= Mat; } void LlevaSemestre(int Sem, int pos) { ArrSem[pos]= Sem; } void LlevaNota(float Not, int pos) { ArrNot[pos]= Not; } int TraeCantEst() { return CantEst; int TraeCodigo(int pos) { return ArrCod[pos];

String TraeNombre(int pos) { return ArrNom[pos]; } String TraeMateria(int pos) { return ArrMat[pos]; } int TraeSemestre(int pos) { return ArrSem[pos]; } float TraeNota(int pos) { return ArrNot[pos];

public float BuscaNotaMayor() { float Mayor = 0; for (int i=0; i < TraeCantEst(); i++) if (ArrNot[i] > Mayor) Mayor = ArrNot[i]; return Mayor; } public int BuscaCodigo(int Codi) { int Posicion = -1; int i=0; while (i < TraeCantEst())&&(posicion ==-1) if (ArrCod[i] == Codi) Posicion = i Else i++ return Posicion; } }

Clase que instancia y activa a TotalEst. import java.io.*; import java.lang.*; class LlenaEstudiantes { public static void main(String args[]) { int NEst=0; int Nume=0; String Cade = null; float Nota=0; BufferedReader tecla = new BufferedReader(new InputStreamReader(System.in)); try {

System.out.println("** Programa que captura datos de un grupo de estudiantes **"); System.out.println(" "); System.out.print("Digite Numero de estudiantes ==> "); NEst = Integer.parseInt(tecla.readLine()); TotalEst Llena = new TotalEst(NEst); System.out.println(" "); for (int i=0; i < Llena.TraeCantEst(); i++) { System.out.println("Estudiante "+(i+1)); System.out.print("Codigo "); Nume=Integer.parseInt(tecla.readLine()); Llena.LlevaCodigo(Nume,i); System.out.print("Nombre "); Cade = (tecla.readLine()); Llena.LlevaNombre(Cade,i); System.out.print("Materia "); Cade = (tecla.readLine()); Llena.LlevaMateria(Cade,i); System.out.print("Semestre "); Nume = Integer.parseInt(tecla.readLine()); Llena.LlevaSemestre(Nume,i); System.out.print("Nota "); Nota = Float.parseFloat(tecla.readLine()); Llena.LlevaNota(Nota,i); System.out.println(" "); } for (int i=0; i < Llena.TraeCantEst(); i++) { System.out.println("Etudiante "+(i+1)); System.out.print(Llena.TraeCodigo(i)+" "+Llena.TraeNombre(i)+" "+Llena.TraeMateria(i)+" "+Llena.TraeSemestre(i)+" "+Llena.TraeNota(i)); System.out.println(" "); System.out.println(" "); } System.out.println(" "); System.out.print("Digita el codigo a buscar ==> "); Nume = Integer.parseInt(tecla.readLine()); if (Llena.BuscaCodigo(Nume) > -1) { System.out.println(" "); System.out.println("El Codigo " + Nume + " es la posicion ==>" (Llena.BuscaCodigo(Nume)+1));

System.out.println("Pertenece a: "); System.out.println("Nombre: "+Llena.TraeNombre(Llena.BuscaCodigo(Nume))); System.out.println("Materia: "+Llena.TraeMateria(Llena.BuscaCodigo(Nume))); System.out.println("Semestre: "+Llena.TraeSemestre(Llena.BuscaCodigo(Nume))); System.out.println("Nota "+Llena.TraeNota(Llena.BuscaCodigo(Nume)));} System.out.println(" "); System.out.println("La nota mayor es " +Llena.BuscaNotaMayor()); System.out.println(" "); System.out.println(" "); } } catch (IOException varerror) { System.out.println("Error"); } } }

EJEMPLO 2 Clase que manipula la nomina de un solo empleado public class Nomina{ String Nombre; String Direccion; int NroHoras; int ValHora; public Nomina(){ } public void LlevaNombre(String Nom){ Nombre = Nom; } public void LlevaDireccion(String Dir){ Direccion = Dir; } public void LlevaNroHoras(int Nh){ NroHoras = Nh; } public void LlevaValHora(int Vh){ ValHora = Vh; } String TraeNombre(){ return Nombre; } String TraeDireccion(){ return Direccion;

} int TraeHoras(){ return NroHoras; int TraeValor(){ return ValHora; } }

double SalarioBasico(){ double Calcula; Calcula = TraeHoras()*TraeValor(); return Calcula; } double Subsidio(){ double Calcula; if (SalarioBasico() > 300000) Calcula = 0 else Calcula = 30000; return Calcula; } double Retencion(){ double Calcula; if (SalarioBasico() >= 300000) Calcula = SalarioBasico() * 0.10 else Calcula = SalarioBasico() * 0.05; return Calcula; } double Iss(){ double Calcula; Calcula = SalarioBasico() * 0.03; return Calcula; } double SueldoNeto(){ double Calcula; Calcula = SalarioBasico() + Subsidio() - Retencion() - Iss(); return Calcula; }

} Clase que maneja un arreglo de objetos tipo nomina import java.lang.*; import java.io.*; public class ArregloNomina { Nomina ANomina[]; Nomina Nom = new Nomina(); public ArregloNomina() { ANomina = new Nomina[10]; int i; for (i = 0; i < 10; i++){ ANomina[i] = new Nomina(); } } public void LlevaNombres (String Nom, int Pos) { ANomina[Pos].LlevaNombre(Nom); } public void LlevaDirecciones (String Dir, int Pos) { ANomina[Pos].LlevaDireccion(Dir); } public void LlevaNroHoras (int Nh, int Pos) { ANomina[Pos].LlevaNroHoras(Nh); } public void LlevaValHora (int Vh, int Pos) { ANomina[Pos].LlevaValHora(Vh); } public String TraeNombres (int Pos) { return ANomina[Pos].TraeNombre(); }

public String TraeDirecciones (int Pos) { return ANomina[Pos].TraeDireccion(); } public double TraeNroHoras (int Pos) { return ANomina[Pos].TraeHoras(); } public double TraeValHora (int Pos) { return ANomina[Pos].TraeValor(); } public double NominaTotal(int Ne){ double Calcula = 0;; int Pos; for(Pos=0; Pos < Ne; Pos++){ Calcula = Calcula + ANomina[Pos].SueldoNeto(); } return Calcula; } public double SueldoMayor(int SM){ double Mayor = 0; int i = 0; for(i=0; i < SM; i++){ if( ANomina[i].SueldoNeto() > Mayor ){ Mayor = ANomina[i].SueldoNeto(); } } return Mayor; } }

Clase que utiliza e instancia la clase del tipo arreglonomina

import java.io.*; import java.lang.*; public class Principal{ public static void main (String args[]){ Nomina Nomi = new Nomina(); ArregloNomina LlenaNomina = new ArregloNomina(); int Nume = 0; int NEmp = 0; String Cade = null; int i = 0; BufferedReader Tecla = new BufferedReader(new InputStreamReader(System.in)); try { System.out.println( ); System.out.println(" "); System.out.print ("Digite el numero de empleados "); NEmp = Integer.parseInt(Tecla.readLine()); System.out.println(" "); for (i=0; i<NEmp; i++){ System.out.print("Nombre "); Cade = Tecla.readLine(); LlenaNomina.LlevaNombres(Cade, i); System.out.print("Direccion "); Cade = Tecla.readLine(); LlenaNomina.LlevaDirecciones(Cade, i); System.out.print("Numero de Horas "); Nume = Integer.parseInt(Tecla.readLine()); LlenaNomina.LlevaNroHoras(Nume, i); System.out.print("Valor de la Hora "); Nume = Integer.parseInt(Tecla.readLine()); LlenaNomina.LlevaValHora(Nume, i); System.out.println(" "); } System.out.println("El sueldo mayor es "+LlenaNomina.SueldoMayor(NEmp)); System.out.println( ); System.out.println("El valor total de la nomina es" +LlenaNomina.NominaTotal(NEmp)); System.out.println( );

System.out.println(); for (int j=0; j < NEmp; j++){ System.out.println("Nombre " + (j+1) + " " + LlenaNomina.TraeNombres(j)); System.out.println("Direccion " + (j+1) + " " + LlenaNomina.TraeDirecciones(j)); System.out.println("Nro Horas " + (j+1) + " " + LlenaNomina.TraeNroHoras(j)); System.out.println("Val Horas " + (j+1) + " " + LlenaNomina.TraeValHora(j)); System.out.println("Salario Neto "+ LlenaNomina.NominaTotal(j)); System.out.println(" "); } } catch(IOException varerror){ System.out.println("Error... "); } } }

Pgina inicial de NetBeans.

En NetBeans es necesario crear una aplicacin, que es donde debemos crear la clase que implementa el mtodo public stactic void main[args] , y dentro de este es donde instanciamos las clases que hemos creados, a continuacin estudiaremos como crear la aplicacin y como agregar las clases que implementaremos, recuerde que las instancias deben ir el la aplicacin.

Para crear una nueva aplicacin con NetBeans debemos ir al men File a la Opcin New Project, como aparece en la imagen siguiente.

A continuacin dentro Seleccionamos General dentro de las categoras y Java Application en la seccin de proyectos

Escribimos el nombre del proyecto, damos click en el botn finalizar.

A continuacin vamos al men File -> New File, para una nueva clase de Java

Dentro de la seccin categoras escogemos Java Clases y dentro de la seccin tipos de archivo seleccionamos Java Class

Se le da el nombre a la clase, en este caso HolaMundo y damos click en finalizar, recuerde que el nombre que aqu de sea el nombre que le ha dado a su clase.

Entorno NetBeans preparado para empezar a programar., en estos momentos podemos escribir el cdigo correspondiente a la clase.

reas del editor

El recuadro pequeo que contiene las flechas ubicado en la parte superior es donde se encuentran las opciones para compilar y ejecutar la aplicacin. El recuadro mediano ubicado en la zona izquierda es donde encontramos los archivos que contiene el proyecto HolaMundo. Aqui se encuentra la lista de clases que tiene el proyecto, en este caso contiene la clase principal del proyecto llamada HolaMundo.java y otra clase creada que se llama Miclase.java, recuerde que debe crear un archivo para cada clase como se indico anteriormente El recuadro del grande del centro, es el rea de edicin del cdigo fuente del programa, donde podremos escribir y modificar el cdigo de cada una de las clases creadas.

BIBLIOGRAFIA

CORREA, Guillermo. Desarrollo de algoritmo y sus aplicaciones en Basic, Pascal, Cobol y C. McGraw Hill, 1977. MULLER, Pierre Alain, Modelado de objetos con UML. Eyroles Gestin 2000. KAM, Weis. HAMIY, Hein. Programacin orientada a objetos con turbo C++. Megabite, Omega editores. SANCHEZ ALLENDE, Jess. Java 2 iniciacin y referencia. McGraw Hill 2005. SCHILT, Helbert. Java 2 Manual de referencia. McGraw Hill 2001.