Programacion Java

CONTENIDO CONCEPTUALIZACION...................................................................................................................................3 1. LA CLASE ..................................................................................................................................................3 2. LOS ATRIBUTOS ......................................................................................................................................8 3. LOS MÉTODOS .......................................................................................................................................11 3.1 Parámetros:...........................................................................................................................................13 3.2 Tipos de Parámetros:............................................................................................................................14 4. Encapsulado ..............................................................................................................................................14 LA IMPLEMENTACION DE LOS MÉTODOS Y LA INSTANCIAS DE LAS CLASES..........................23 ASIGNACIÓN :.............................................................................................................................................23 Asignación Directa:....................................................................................................................................23 Asignación 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 ingeniería de sistemas, la programación es una herramienta primordial, debido a esto es indispensable que el estudiante de ingeniería tenga sólidas bases de pensamiento lógico computacional que le permita en futuros cursos desempeñarse eficientemente, para ello tiene que comprender la forma como se resuelven problemas reales a través de la aplicación de los objetos. Además comprender todos los datos y operaciones implícitas y explicitas que se plantean en un problema y que son necesarios para su solución. En este curso se llevará a la práctica los conceptos teóricos fundamentales de programación utilizando como herramienta un lenguaje de programación como Java y la técnica de programación orientada a objetos. El estudiante afianzando los conocimientos de la lógica computacional debido a que realizará programas en el computador iniciando el ciclo de cursos de desarrollo de software.

CAPITULO I

CONCEPTUALIZACION La programación orientada a objetos es una técnica 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 diseño 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 programación es el proceso de diseño, que permite modelar la posible solución antes de escribir la primera línea de código que lo empiece a resolver. En el transcurso de este libro trataremos de enfocarnos en el concepto de diseño, dejando algunos temas del lenguaje para que el lector los estudie a satisfacción 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 métodos (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 métodos (acciones) de la clase. Donde los atributos son las características propias del problema (datos necesarios) y los métodos son las acciones que debe ejecutar la clase para resolver el problema (manipulando los datos con las operaciones necesarias). Así por ejemplo: Se quiere diseñar una clase que permita calcular el área y el perímetro de un rectángulo. Recordemos que el Área es igual a la base por altura y el Perímetro es igual a 2 veces la base mas 2 veces la altura.

Altura

Base Caracterizamos los atributos y los métodos identificando cada uno de ellos con un nombre. Atributos: Para el problema son necesarios dos: Los llamaremos Base y Altura que son los datos básicos y suficientes para realizar los cálculos. Tenemos que para calcular el Área: Es necesario un método que se encargue de hacer la operación (multiplicación) Base por Altura y lo llamaremos Calcular área. Para calcular el Perímetro: Se debe crear un método que se encargue de hacer la operación: 2 veces la Base más 2 veces la altura, a este método lo llamaremos Calcular perímetro. Para poder tener la información correspondiente a los valores que se guardan el los atributos es necesario pedirla, para ello creamos un método llamado pedirdatos y para mostrar el resultado de las operaciones que realiza la clase creamos el método mostrarresultados Podemos observar que los datos que se pueden calcular (Área, Perímetro) no se convierten en atributos sino en métodos, además que los atributos correspondientes a la clase no pueden ser más que los datos básicos requeridos para resolver el problema, en este caso los datos necesarios son los de los lados, y como el rectángulo tiene 2 lados iguales (Base) y otros dos lados iguales (altura) podemos diseñar la clase de la siguiente manera: Nota: Al asignarle un nombre a un atributo o a un método recuerde no dejar espacios entre los caracteres de dicho nombre. Los métodos se diferencia porque presentan (), al final del nombre.

Clase Rectángulo Base Altura

Pedir_datos() calcular_area() calcular_perimetro() mostrar_resultados() Plantearemos otro problema para aclarar un poco más. 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 retención en la fuente, calculados a partir del básico ganado, además hay que determinar si recibe subsidio o no. Solución: Número 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 diseñar la y que utilizaremos en los métodos. Las operaciones a realizar: Básico: Genera un método para calcular número de horas por Valor de la hora, Lo llamaremos Básico. Descuento seguro social: Genera un método para calcular un descuento a partir del valor del básico. Lo llamaremos DescuentoIss. Descuento por retención en la fuente: Genera un método para calcular otro descuento que se hace sobre el rango del valor del básico. Lo llamaremos DescuentoRetencion. Subsidio: Genera método que evalúa el valor del básico y determina si recibe subsidio para asignarle el valor correspondiente sino asignara cero. Lo llamaremos Subsidio. Total a pagar: Este concepto es implícito al problema y genera un método que se usará para calcular el pago final a partir del valor básico restándole los dos descuentos. Lo llamaremos Neto. Observación:

Volvemos a resaltar, los valores que se pueden calcular no son atributos (tenga eso en cuenta) sino que se pueden considerar como métodos. Observemos que algunos métodos necesitan utilizar no los atributos sino otros métodos para poder realizar sus operaciones como es el caso de descuentoIss que necesita del método básico para poder calcular su propio valor, de igual manera el método neto necesita de los otros para efectuar la operación. (Esto es una característica del diseño de clases). Además diseñamos los métodos de pedirdatos y mostrardatos. Nótese que aunque podríamos haber diseñado un solo método (Neto) para hacer todos los cálculos correspondientes, no lo hacemos con el fin de acogernos a una regla que más adelante explicaremos (Encapsulado). Veamos el diseño de la clase: ClaseTrabajador Valhoras Numhoras Pedirdatos() Basico() Descuentoiss() Descuentoretencion() Subsidio() Neto() Mostrarresultados() Nota: Los problemas cómo tales tienen unas propiedades que serían las causas de él, los atributos. Los métodos, 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 continuación se plantean 3 problemas y se diseña la solución de ellos, haga un análisis de cada solución.

1. Diseñe una clase que permita conocer el resultado de una elección 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 Votación Votos Pedirdatos() Calcularvotosvalidos() calcularvotoscanA() calcularvotoscanB() calcularvotoscanC() calcularvotosblanco() mostrarresultados () 2. Diseñar 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 población 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 diseñe 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 específica, dependiendo del lenguaje de programación 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 programación 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 (mnemotécnica). 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 términos generales existen tres tipos: Numéricos Alfanuméricos (todo tipo de carácter). Y booleanos (valores lógicos 0 y 1; True, False). Otra característica 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 programación (Tema que abordaremos mas adelante). Tipos de datos elementales en java Tipos Numéricos (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 Carácter Palabra Rango de Valores reservada String cadena de caracteres según usuario Tipos de datos Lógicos Palabra Rango de Valores reservada Boolean Valor lógico 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 números No deben ser palabras reservadas del lenguaje de programación. No deben contener espacios Por cuestiones prácticas deben ser claros y no tan largos. Deben ser mnemotécnicos o sea deben caracterizar al dato que manipularan.

Podríamos enunciar otras pero dejaremos que la experiencia y la práctica con los compiladores les enseñe más.

Comenzaremos ahora un estudio de los métodos y su Caracterización en Java. 3. LOS MÉTODOS

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 método debe realizar una tarea específica de acuerdo al problema que se quiere solucionar con la clase en mención. En una clase podemos definir cuatro tipos de métodos: a)

Constructores:

Estos métodos constituyen operaciones de inicialización de valores para los atributos, como también la inicialización 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 parámetros que se le pasan. b)

Destructores :

Estos tienen como funcionalidad liberar los recursos de memoria utilizados por la clase para su trabajo. Su activación 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 características de los destructores en el lenguaje java es que no es necesario declararlos. Procedimientos : Estos métodos se caracterizan por la ejecución de una o más acciones (operaciones) sobre unos datos o valores que tienen un tipo (dominio) determinado y que se obtienen en algunos casos leyéndose de los atributos, tomándose a partir de parámetros (concepto que definiremos más adelante) o utilizando otros métodos de la clase . Sintaxis: Palabra reservada : ejemplo:

d)

Funciones :

Void Idenfificador; void Pedirdatos();

Al igual que los procedimientos, una función constituye un método que realiza operaciones sobre datos de un tipo específico; datos que son leídos desde los atributos, otros métodos de la clase y/o pasados por parámetros, 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 función. Sintaxis: Palabra reservada :

Tipo de dato Identificador;

Ejemplo: int calculararea() Ahora procederemos a complementar los conceptos anteriores con la definición de parámetros. 3.1 Parámetros:

Para que los métodos puedan ejecutarse deberán tomar valores ya sea a la clase misma o a elementos externos. Cuando un método necesita valores que son externos y estos valores pueden variar al momento de ser manipulados en los procesos mismos del método, estos valores reciben el nombre de parámetros. Observemos el siguiente ejemplo que corresponde a una función matemática: 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 función, es decir, f es el identificador del método y “x” es el valor que f necesita para poder realizarla operación (parámetro). Ahora bien si le asignamos algunos valores a “x” (parámetro) 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 método no varía lo único que varía es el valor de x (parámetro) para calcular la función. Los valores (3,5,10) asignados en el ejemplo son remplazados en la referencia que en la función tiene “x” . Observación: Cada vez que necesitamos valores cambiantes en un método y no conocemos su contenido, debemos hacer la referencia en el método con un parámetro.

3.2 Tipos de Parámetros:

Dependiendo que los parámetros retornen un valor o no al ser manipulados en un método, se clasifican en : a) Parámetros por valor : Cuando el parámetro es utilizado solamente para introducir valores al método que lo procesa. b) Parámetros por referencia: Cuando el parámetro al ser asignada al método puede cambiar o modificar su valor durante su utilización en el método, manteniendo esos cambios de allí en adelante para dar a conocer dicho cambio a los demás miembros de la clase, quienes pueden utilizarlo y modificar de nuevo dicho valor. Para ver cómo trabajan conjuntamente los atributos y los métodos, 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 métodos especializados en dichas operaciones de tal manera que los atributos son manejados por medio de la activación de dichos métodos . La Otra regla está referida sobre los métodos, determinando sobre éstos un criterio de unicidad funcional, es decir, que un método debe encargarse de realizar una tarea (proceso) única ; De esta forma una clase define tantos métodos como tareas deba efectuar. Como notamos en el encapsulado la esencia de proteger los datos con la utilización de métodos implica diferenciar diversas secciones dentro de una clase: Sección Privadas: En esta sección se declaran los atributos y métodos que solo pueden ser accedida por los métodos de la misma clase, los descendientes no tienen acceso a ellos. Sección Protegida: Aquí se declaran los atributos y métodos de la clase que pueden ser accedidos por sus propios métodos y por los métodos de sus descendientes. Sección Pública: Se declaran los métodos que la clase a poner a disposición de quien lo necesite. clase Sección Privada Atributos, Métodos Sección Protegida Atributos, Métodos Sección Publica Métodos Sintaxis Class Identificador

{ private Tipo de dato Identificador de Atributos; public Tipo dato Identificador del metodo() {implementación del método} } Ahora retomaremos los ejercicios planteados al principio y veremos su respectiva solución aplicando todos los conceptos estudiados hasta este momento, la parte de implementación de los métodos la abordamos mas adelante en este capitulo, por ahora nos enfocamos en el diseño de la clase. Para respetar la aplicación del encapsulado los métodos de pedir información y mostrar información se diseñan en la sección pública. Primer ejemplo, hallar el área y el perímetro de un cuadrado . Class rectangulo { private int base, altura public rectangulo() { implementación}; void pedirdatos (int valbase;int valaltura) { implementación }; void MostrarResultados () { implementación }; int Obtenerbase() { implementación }; int Obteneraltura() { implementación } int Calculararea() { implementación } int Calcularperimetro() { implementación }; }; Explicación: 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 razón para ello es que deben ser valores enteros. • Los dos atributos se encuentran en la sección privada atendiendo a la regla del encapsulamiento que nos dice que debemos proteger todos los atributos. En la sección pública tenemos que:

• Trabajamos con un constructor al cual le llamamos como la clase “rectangulo” ,Se diseñan tres métodos para acceder a los atributos : • Para llevar información a los atributos diseñamos el método pedirdatos el cual utilizan dos parámetro un valbase y el otro valaltura los cuales van dentro de los paréntesis del método; y dos para traer información de los atributos que son “Obtenerbase “ y “Obteneraltura” . • Seguidamente se diseñan los métodos que han de ser las acciones para lo cual se ha diseñado la clase, siendo éstos “Calculararea” y “Calcularperimetro”, además un método para mostrar resultados. • Cabe anotar hacer referencia en la sintaxis del lenguaje java definición de los métodos en java implica la implementación del código 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 código en minúsculas ya que el compilador diferencia entre mayúsculas - minúsculas y nos puede ocasionar un mal rato. Cuando este escribiendo código olvídese 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 retención en la fuente, calculados a partir del básico ganado, además 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(){}; }; Explicación: 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 métodos, además tenga en cuenta que para los métodos asignarnhoras y asignarvalor se usan parámetros, esto debido a que se hace necesario que estos métodos interactúen con el medio, para poder adquirir un valor exterior, los parámetros utilizados en dichos métodos son del mismo dominio del atributo ya que ellos lo que harán será guardar los valores que tomen en los atributos. ¿Analice porque no diseñamos un solo método (pedirdatos)? Nótese que para cada acción de la clase, (tarea a realizar), hemos diseñado un método específico con el fin de mantener el encapsulado y poder organizar el diseño. Bien ahora planteáremos algunos ejemplos y diseñaremos su solución, pero la explicación y entendimiento corre por cuenta del lector. Ejemplo 3. El almacén vende más desea en su aniversario hacer una promoción en su variedad de productos, para ello los ha clasificado en 3 categorías de la siguiente manera : Categoría 1 : para los dispositivos de almacenamiento(discos duros, cintas ,tape backup etc..). Categoría 2 : para los periféricos (impresoras, scanners, josticks etc..). Categoría 3 : para los computadores completos. El almacén propone a sus compradores que lleven una cantidad de productos de una sola categoría hacer los siguientes descuentos; 5% para artículos de categoría 1, 8% para artículos de categoría 2 y 12% para artículos de categoría 3.

Diseñe una clase que permita al almacén saber cuanto debe pagar un comprador que lleva solamente artículos del mismo tipo. Observación: 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 método valorneto calculara el valor real de los artículos. El método descuento evaluara el tipo de los articulo que se compra y calcula el valor del descuento utilizando el valorneto . El método totalapagar calcula el valor que el usuario paga realmente. Ejemplo 4. Un estudiante de informática desea controlar las notas de su asignatura de programación, el profesor va a hacer 3 evaluaciones dándole un porcentaje a cada nota de la siguiente manera: Primera evaluación 30% Segunda evaluación 28%

tercera evaluación 42% El profesor plantea que para aprobar la asignatura se debe tener un promedio de 3.5, el estudiante desea saber en que evaluación 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 función calculapromedio se encarga de tomar cada nota y multiplicarla por su porcentaje para luego sumarlas las tres. La función evaluaaprobacion que devuelve un valor lógico determina si aprobó o no la asignatura. La función notamenor evalúa cual de las tres notas fue la menor devolviendo el número de la nota y no su valor.

Practica

Para las clases votacion, colegio y mesa, escriba los diseños aplicando los conceptos vistos y la sintaxis de java. Hasta el momento nos hemos detenido en el proceso de diseño de clases porque es la etapa más importante dentro del desarrollo de una aplicación con un enfoque orientado a objeto. Ha podido observar que solamente con el diseño de la clase se entiende la solución del problema y mas aún se puede saber para que esta hecha dicha clase sin leer el problema como tal. Las recomendaciones más importantes que se hacen entorno a la programación Orientada a Objetos son las siguientes Dedíquele 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 Napoleón “ Vístanme despacio que estoy de prisa”. Analizado el problema proceda a identificar atributos y métodos ( recuerde que si un dato se puede calcular no es un atributo ). Diseñe su clase. Diseñado la clase hágase la siguiente pregunta. Satisface la clase todas las necesidades planteadas en el problema? Si su repuesta es SI ¡felicidades ha logrado diseñar una clase! Y si su respuesta es NO, no se preocupe rediseñe su clase total todavía no ha perdido tiempo escribiendo el código de implementación de los métodos. . Nunca se le olvide las reglas de encapsulado cúmplalas y comenzará a trabajar con una de las técnicas de programación mejor implementadas hoy en día. Recuerde que hasta ahora estamos en diseño una las etapas de la programación orientada a objetos.

Taller 1. Que es un Clase? 2. Que importancia tiene el encapsulado en la Programación Orientada a Objetos ? 3. Cuál es la etapa más importante en la Programación Orientada a Objetos ? 4. Que es una clase ?. 5. Caracterice la sintaxis de java en cuanto a definición 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 métodos ? 9. Determine la importancia de los constructores y destructores ? 10. Para que sirven los parámetros ? 11. Todos los métodos tienen parámetros ? Diseñe las clases para resolver los siguientes problemas: 1. Se desea calcular el área y el perímetro de un círculo. 2. La empresa Cómputos S.A. desea controlar el inventario de los computadores que venden para así mantener en tiempo real información correspondiente a: tipo de computador, cantidad existente, cantidad mínima que debe haber y el valor de cada uno. Además se desea saber el costo total de los computadores existentes. 3. Se desea saber cual es el mayor de tres números dados .

CAPITULO II

LA IMPLEMENTACION DE LOS MÉTODOS Y LA INSTANCIAS DE LAS CLASES Cuando se diseñan las clases y especifican los métodos se sabe cuales son las acciones que puede cumplir dicha clase. Bien ahora profundizaremos en cómo esos métodos son capaces de resolver su propia tarea usando el código necesario para que trabaje adecuadamente. Recuerde que cada método en su diseño ya tiene proyectada una tarea a cumplir. ASIGNACIÓN :

Cuando hay que guardar un valor en algún atributo o hacer operaciones con datos y saber sus resultados es necesario asignar dicho valor. La asignación consiste en guardar valores en los datos, estos se pueden de varias maneras: Asignación Directa:

Consiste en guardar el valor de manera que no dependa sino del dato mismo. Ejemplo: Guardemos 5 en el atributo Número. Numero = 5 Asignación Indirecta :

Ocurre cuando el valor de un dato depende de la operación de otros datos que interactúan. Ejemplo: En a guarde la operación de x + y ,entonces a depende de los valores que tomen x , y.

a=x+y Nota: Cuando usamos los parámetros asignamos al atributo o dato al cual le queremos pasar dicho valor, el identificador del parámetro esto es en tiempo diseño luego cuando se corre el programa se asigna el valor que el usuario le pase por el parámetro. 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 Pérez’; suma = num + can COMO IMPLEMENTAR LOS MÉTODOS Dadas las características del primer ejemplo que calcula el área y el perímetro de un rectángulo (este ejemplo utiliza solo asignaciones para resolver su problema) lo utilizaremos para aplicar la implementación de los métodos . Para efectuar operaciones cuando asignamos valores tengamos en cuenta los operadores aritméticos que los lenguajes nos presentan , ver cuadro Operación Resta Suma División Multiplicar

class rectangulo

Símbolo Ejemplo x = 5-3 + a=a+b / z=3/9 * área = base * altura

{

}

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 perímetro; perímetro = (Obtenerbase() * 2 ) + (Obteneraltura() * 2); return perímetro; }

ANALISIS : 1. Todos los métodos deben comenzar con el tipo de dato que devuelven seguido del nombre del método, entre paréntesis la lista de parámetros , si los hay , teniendo en cuenta que en la declaración de los parámetros va primero el tipo de dato y luego el identificador del

mismo. Si el método no devuelve ningún valor se usa la palabra reservada Void que indica que el método es un procedimiento . Ejemplo: Void Asignarbase (int valbase). Si el método devuelve algún valor, entonces es una función, para esto se utiliza el tipo de dato y el identificador del método. Ejemplo: Int Trectangulo Obtenerbase() . La palabra (return dato indica el valor que el método debe devolver). 2. Todos los métodos contienen un segmento principal que comienza con { y termina en }, dentro del cual se escriben las instrucciones que han de ejecutar dicho método. En algunos casos es necesario declarar variables (datos) locales a un método. Una variable local es aquella que existe solo dentro del método en que se declara, es decir, solo puede ser usada entre el inicio y finalización de dicho método, específicamente entre los símbolos de llave de apertura ({ ) y llave de cierre ( }) del cuerpo del método. El uso de variables locales permite simplificar operaciones para que las instrucciones de una implementación sean menos complejas y consecuentemente más entendibles. Como ejemplo podemos mencionar el caso de la variable local : int área en la implementación de la función Calculararea, así la variable área recibe el valor calculado para el área (obtenerbase() * obteneraltura()) y posteriormente la función Calculararea devuelve dicho valor mediante la instrucción return area . 3. El constructor puede acceder directamente a los atributos. 4. Los métodos de asignación para los atributos utilizan el identificador del parámetro para asignarle su valor a dicho atributo. Ejemplo: El método que le da un valor a la altura : Void Asignaraltura(int valatura), utiliza la siguiente sentencia de asignación en su implementación : altura = valaltura.

2. ESTRUCTURAS CONDICIONALES:

En la implementación de los métodos se escriben una serie de instrucciones que son las que le dan operatividad, es decir, determinan en una forma organizada, detallada, precisa y lógica lo que cada método debe hacer, por lo tanto de acuerdo a cada método así debe ser cuerpo de instrucciones. Hasta ahora hemos visto que estas instrucciones pueden consistir en la declaración de variables, en el llamado o activación de métodos dentro de otros, en la asignación de un dato a una variable, atributo o función y también hemos trabajado con operaciones de calculo matemático. Todas estas instrucciones tratadas hasta el momento se ejecutan en forma secuencial una por una y en orden explícito. Sin embargo muchos casos de implementación 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 implementación de algún método 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 expresión o condición que al ser evaluada arrojará un único valor de verdad que puede se verdadero (true) o falso (false). Si la expresión se evalúa como verdadero se ejecutarán las instrucciones que creamos necesarias para dicho caso, de lo contrario esas mismas instrucciones serán ignoradas. Sin embargo siendo la condición falsa, también podemos establecer la ejecución de otro bloque de instrucciones que alternativamente necesitemos ejecutar en el caso de que la expresión del condicional no sea verdadera. Por ejemplo una frase como esta es una instrucción condicional: “Si mañana llueve, entonces me quedaré en casa”. En ella vemos que la expresión a evaluar es “si mañana llueve” y la acción a ejecutar si dicha condición es cierta será “me quedaré en casa”. Sin embargo podemos hacer algo en caso de que la condición sea falsa, por ejemplo: “Si mañana 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 acción a realizar cuando la expresión a evaluar sea falsa, que para el ejemplo sería “iré a clases”. Veamos como programación.

se

aplican

estos

conceptos

en

términos

de

La expresión o condición que se evalúa en una estructura condicional es una expresión booleana, que toma uno y solo uno de dos valores posibles, True o False. Una expresión booleana se construye por medio de operadores relacionales y/o lógicos que se aplican a unos operandos (datos, variables, atributos y funciones del mismo dominio). Las expresiones lógicas están compuestas de la siguiente manera : operando1

Operador

operando2

Donde operando1 y operando2 son datos sobre los cuales cae el peso de la comparación y el operador es la operación de la comparación que se ha de hacer. Tipo de operadores relacionales básicos : OPERADOR Mayor que Mayor o igual Menor que Menor o igual Diferente Igualdad

SIMBOLO > >= < = ‘B’

Veamos que cada operador requiere dos operandos que se ubican al lado izquierdo y derecho respectivamente. Las expresiones tomarán 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 expresión booleana también puede estar formada por operadores lógicos. Un operador lógico no es más que un conectivo lógico que puede comparar (asociar) dos o más expresiones booleanas simples como las anteriores formando así expresiones booleanas compuestas. Los operadores lógicos requieren como operandos (datos a relacionar o comparar) valores y expresiones booleanas (datos que toman el valor true o false).

Los operadores lógicos en JAVA son los siguientes : Operador Símbolo “Y” Lógico && “O” Lógico ¡¡ Negación Lógica

A excepción de la negación lógica que es un operador unario (que requiere solo un operando) los demás operadores son binarios (requieren dos operandos) y como se ha dicho estos operandos son datos booleanos (true o false), cada operador lógico posee una tabla de verdad mediante la cual se establece que valor asume al relacionar el o los valores lógicos. Las tablas son las siguientes:

Tabla del “Y” Expresión 1 True True False False

Expresión 2 True False Trae False

Expresión 1 Y Expresión 2 True False False False

Expresión 2 True False True False

Expresión 1 O Expresión 2 True True True False

Tabla del “O” Expresión 1 True True False False

Tabla de la “Negacion” Expresión True False

Negacion Expresión False True

En estas tablas debemos anotar que “Expresión - uno” , “Expresión dos” y “Expresión” representan indistintamente cualquier expresión 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 combinación true false para el Y (donde expresión - uno corresponde a true y expresión - dos a false). Así (true) And (false) = false. Es decir, que la expresión booleana(3=5) Y (2=2) = false. Nótese aquí el uso de paréntesis para indicar el comienzo y finalización de cada expresión booleana. Miremos ahora este ejemplo : (‘A’ = ‘A’) ¡¡ (3-1 2). La primera expresión (‘A’ = ‘A’) es true. La segunda expresión (3-1 2) es false. El O entonces relacionará los valores así : (true) O (false). Dándonos como resultado final el valor true para la expresión booleana planteada. Trate de desarrollar el valor lógico para las siguientes expresiones booleanas: a) (true) ¡¡ (2 1) ; b) ! true ;

c) (3 != 3) && (4-1 < 0); d) (1>=2) && (2 400000 { retención = basico( ) * 0.1; } else { retención = 0; }; return retencion; } float Subsidio(){ float valorsub; if basico( ) < 280000 { valorsub = 25000; } else { valorsub = 0; }; return valorsub; } float Neto(){

}

float sneto; sneto = basico( ) - descuentoiss( ) - descuentoretención + subsidio; return sneto; }

Clase almacen Características de los métodos que necesitan evaluar condiciones: • En este clase el método Descuento debe determinar el tipo de artículo que se seleccionó para poder calcular el descuento a realizar. Estructura de evaluación: if condición

Instrucción a ejecutar Por Verdadero

ValorNeto * 0.07

Por Falso

If

ucción a ejecutar

Condición2

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 implementación de método descuento es necesario declarar una variable de ámbito interno al método ( solo se conoce al interior de éste) para capturar el valor resultante de la operación valorneto por porcentaje de descuento con el fin de hacer mas legible y entendible el código que se escriba.

Clase estudiante Características de los métodos que necesitan evaluar condiciones: • El método EvaluarAprobación 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 evaluación: If

Condición

Instrucción a ejecutar Por verdadero

True

Por falso

False

Condición : Si calculapromedio es mayor de 3.5. • El método NotaMenor es algo un poco complejo por que debe evaluar cual de las notas es la menor; debido a que la evaluación debe comprobar varias condiciones, por ende se hace necesario utilizar conectores lógicos (&&) para facilitar la implementación . Estructura de evaluación :

If Condición1

Y Condición2 Por Verdadero

Por Falso

instrucción 1

if Condición3

Y

Condición4

Por Verdadero Instr. 2

Por Falso instrucción 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 método 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()