Lenguaje de Programación Orientada a Objetos JAVA

Transcripción

1 Lenguaje de Programación Orientada a Objetos JAVA

2 3. LENGUAJE DE PROGRAMACIÓN ORIENTADA A OBJETO JAVA 3.1 Introducción Java es un lenguaje de programación orientado a objetos, desarrollado por Sun MicroSystems a principios de la década de Este lenguaje toma la estructura de sintaxis (escritura de código fuente) de C y C++ incorporando un modelo de objetos más simples y eliminando las herramientas de bajo nivel (que suele inducir muchos errores como la manipulación de punteros en C y C++). El surgimiento de Java es propiciado porque en la década de 1980 aparecieron varios lenguajes orientados a objetos y también se realizaron versiones orientadas a objetos (o semi-orientados a objetos) de lenguajes clásicos. Una de las más famosas fue el lenguaje orientado a objetos creado a partir del C tradicional; se le llamó C++ indicando con esa simbología que era un incremento del lenguaje C (en el lenguaje C, como en Java, los símbolos ++ significan incrementar) (Sánchez, 2004). La Programación Orientada a Objetos (POO) permite desarrollar aplicaciones de forma más parecida al pensamiento humano, de hecho simplifica el problema de programación (principalmente en el desarrollo de aplicaciones de código largo) dividiéndolo en objetos, permitiendo centrarse en cada objeto, de esa manera se elimina la complejidad de escribir código largo. 3.2 Historia de Java Java se creó como una herramienta de programación para ser usada en un proyecto en Sun Microsystems en el año El propósito de Sun Microsystems era introducirse en el mercado de la electrónica de consumo y desarrollar programas para pequeños dispositivos electrónicos. El equipo de desarrollo estaba compuesto por trece personas y dirigido por James Gosling, trabajaron durante 18 meses en su desarrollo. Los objetivos de Gosling eran implementar una máquina virtual y un lenguaje con una estructura y sintaxis similar a C++. El lenguaje se denominó inicialmente Oak, luego pasó a denominarse Green tras descubrir que Oak era ya una marca comercial registrada para adaptadores de tarjetas gráficas y finalmente se renombró a Java. La promesa inicial de del equipo era - Write Once, Run Anywhere - (Escríbelo una vez, ejecútalo en cualquier lugar), proporcionando un lenguaje independiente de la plataforma y un entorno de ejecución (la Java Virtual Machine) ligero y gratuito para las plataformas más populares de forma que los binarios (bytecode) de las aplicaciones Java pudiesen ejecutarse en cualquier plataforma. El entorno de ejecución era relativamente seguro y los principales navegadores web pronto incorporaron la posibilidad de ejecutar applets Java incrustadas en las páginas web. 3.3 Características del Lenguaje Orientado a objetos: La primera característica, orientado a objetos (OO), se refiere a un método de programación y al diseño del lenguaje. Simple: Java reduce hasta en un 50% los errores más comunes de programación respecto a otros lenguajes (elimina la Aritmética de punteros, Registros, Macros, definición de tipos, liberar memoria entre otros). Distribuido: Java proporciona librerías y herramientas para que los programas sean distribuidos, es decir, para que se ejecuten en varias máquinas e interactuando entre ellas. Multiplataforma (arquitectura neutral): Las aplicaciones java (.java) para poder ser ejecutadas, antes deberán ser compiladas dando como resultado un código intermedio denominado bytecode (.class). los bytecode son ejecutados por la Java Virtual Machine (JVM) donde son interpretados y luego traducidos al lenguaje máquina según la plataforma 1

3 donde se ejecute. La ventaja de la JVM es la portabilidad del lenguaje. Por ejemplo, un programa desarrollado en un entorno Windows puede ser interpretado y ejecutado en cualquier entorno ya sea Linux o Mac, solo dependerá de que dichos entornos posean las JVM específicos para cada uno. Este es el significado de ser capaz de escribir un programa una vez y que pueda ejecutarse en cualquier dispositivo, tal como reza el axioma de Java, Write Once, Run Anywhere - (Escríbelo una vez, ejecútalo en cualquier lugar). El proceso consiste: i) primero se compila el código fuente escrito en lenguaje Java, para generar un código conocido como bytecode ii) Esta pieza está a medio camino entre el código fuente y el código máquina que entiende el dispositivo destino; iii) El bytecode es ejecutado entonces en la máquina virtual (JVM), un programa escrito en código nativo de la plataforma destino (que es el que entiende su hardware), que interpreta y ejecuta el código. 2

4 Es Robusto: Java realiza verificaciones en busca de problemas tanto en tiempo de compilación como en tiempo de ejecución, estas comprobaciones ayudan a detectar errores en ciclo de desarrollo: obligando la declaración explícita de métodos. Es Seguro: a nivel de lenguaje, se eliminan punteros y casting implícito de los compiladores de lenguajes convencionales para prevenir el accesos ilegales. A nivel de ejecución, el código Java pasa una serie de pruebas (test) antes de ejecutarse en la máquina. A nivel de código fuente, el JDK proporciona un desensamblador de bytecode que permite que cualquier aplicación (programa desarrollado en java) pueda ser convertido a código fuente, esta es sin duda una desventaja para el desarrollador, no obstante, existen alternativas para impedir que el código se expuesto. Es portable: más allá de la portabilidad intrínseca a la multiplataforma (arquitectura neutral), Java implementa otros estándares de portabilidad, Java construye sus interfaces de usuario a través de un sistema abstracto de ventanas de manera que las ventanas pueden ser implementadas en entornos Unix, Mac o Windows. Es interpretado: El intérprete de java puede ejecutar directamente el código objeto, sin embargo, debido a que no existen JDK específicos para las diversas plataformas, java es lento respecto a otros lenguajes ya que primero deberá ser interpretado y no ejecutado como en C++. Es Multihilo: Java permite muchas funciones simultáneas en una aplicación, se tiene mejor rendimiento interactivo y mejor comportamiento en tiempo real (pero limitado a las capacidades del Sistema Operativo, Ejm. al navegar, java puede acceder a la información de la página sin tener que esperar a que el navegador cargue tediosamente figuras u animaciones (Coronel, 2010). Es Dinámico: Java no intenta conectar todos los módulos que comprenden una aplicación hasta el mismo tiempo de ejecución. Las nuevas librerías no paralizan el tiempo de ejecución siempre que contengan el API anterior. También simplifica el uso de protocolos nuevos o actualizados; si uno ejecuta una aplicación java sobre la red, java es capaz de importar automáticamente cualquier pieza que el sistema necesite para funcionar. 3.4 Entornos de funcionamiento El diseño de Java, su robustez, el respaldo de la industria y su fácil portabilidad han hecho de Java uno de los lenguajes con un mayor crecimiento y amplitud de uso en distintos ámbitos de la industria de la informática. 3

5 En dispositivos móviles y sistemas empotrados: Es posible encontrar microprocesadores específicamente diseñados para ejecutar Java en teléfonos móviles. El modelo de desarrollo de estas aplicaciones es muy semejante a la de los navegadores. En el navegador web: Desde la primera versión de java existe la posibilidad de desarrollar pequeñas aplicaciones (Applets) en Java que luego pueden ser incrustadas en una página HTML para que sean descargadas y ejecutadas por el navegador web. Estas miniaplicaciones se ejecutan en una JVM que el navegador tiene configurada como extensión (plug-in) en un contexto de seguridad restringido configurable para impedir la ejecución local de código potencialmente malicioso. En sistemas de servidor: En la parte del servidor, Java es más popular que nunca, desde la aparición de la especificación de Servlets y JSP (Java Server Pages). En aplicaciones de escritorio: Hoy en día existen multitud de aplicaciones gráficas de usuario basadas en Java. El entorno de ejecución Java (JRE) se ha convertido en un componente habitual en los PC de usuario de los sistemas operativos más usados en el mundo. Además, muchas aplicaciones Java lo incluyen dentro del propio paquete de la aplicación de modo que se ejecuten en cualquier PC. 3.5 Recursos JRE (Java Runtime Environment: o Entorno en Tiempo de Ejecución de Java, es el software necesario para ejecutar cualquier aplicación desarrollada para la plataforma Java. El usuario final usa el JRE como parte de paquetes software o plugins en un navegador Web. Bibliotecas de Java: que son el resultado de compilar el código fuente desarrollado por quien implementa la JRE, y que ofrecen apoyo para el desarrollo en Java. APIs: Sun define tres plataformas en un intento por cubrir distintos entornos de aplicación. Así, ha distribuido muchas de sus APIs (Application Program Interface) de forma que pertenezcan a cada una de las plataformas: - Java ME (Java Plataform, Micro Edition) o J2ME orientada a entornos de limitados recursos, como teléfonos móviles, PDAs (Personal Digital Assistant), etc. - Java SE (Java Plataform, Standard Edition) o J2SE para entornos de gama media y estaciones de trabajo. Aquí se sitúa al usuario medio en un PC de escritorio. - Java EE (Java Plataform, Enterprise Edition) o J2EE orientada a entornos distribuidos empresariales o de Internet. Las clases en las APIs de Java se organizan en grupos disjuntos llamados paquetes. Cada paquete contiene un conjunto de interfaces, clases y excepciones relacionadas. La información sobre los paquetes que ofrece cada plataforma puede encontrarse en la documentación de ésta. El conjunto de las APIs es controlado por Sun Microsystems junto con otras entidades o personas a través del programa JCP (Java Community Process). Las compañías o individuos participantes del JCP pueden influir de forma activa en el diseño y desarrollo de las APIs, algo que ha sido motivo de controversia. Extensiones y arquitecturas relacionadas; Las extensiones de Java están en paquetes que cuelgan de la raíz javax: javax.*. No se incluyen en la JDK o el JRE. Algunas de las extensiones y arquitecturas ligadas estrechamente al lenguaje Java es: - Java EE (Java Plataform, Enterprise Edition; antes J2EE) para aplicaciones distribuidas orientadas al entorno empresarial 4

6 3.6 Elementos de java La sintaxis de un lenguaje define los elementos de dicho lenguaje y cómo se combinan para formar un programa. Los elementos típicos de cualquier lenguaje son los siguientes: Identificadores: los nombres que se dan a las variables Palabras reservadas: las palabras que utiliza el propio lenguaje Tipos de datos Sentencias Bloques de código Comentarios Expresiones Operadores Identificadores Un identificador es un nombre que identifica a una variable, a un método o función miembro, a una clase. Todos los lenguajes tienen ciertas reglas para componer los identificadores: - No pueden coincidir con palabras reservadas de Java. - Todos los identificadores han de comenzar con una letra, el carácter subrayado ( _ ) o el carácter dólar ( $ ). - Puede incluir, pero no comenzar por un número - No puede incluir el carácter espacio en blanco - Distingue entre letras mayúsculas y minúsculas Ejemplos de identificadores válidos son los siguientes: tiempo, distancia1, caso_a, PI, velocidad_de_la_luz Por el contrario, los siguientes nombres no son válidos ( Por qué?) 1_valor, tiempo-total, dolares$, %final En general, es muy aconsejable elegir los nombres de los identificadores de forma que permitan conocer a simple vista qué representan, utilizando para ello tantos caracteres como sean necesarios. Esto simplifica enormemente la tarea de programación y sobre todo de corrección y mantenimiento de los programas. Es cierto que los nombres largos son más laboriosos de teclear, pero, en general, resulta rentable tomarse esa pequeña molestia. Unas reglas aconsejables para los identificadores son las siguientes: Las variables normalmente tendrán nombres de sustantivos y se escribirán con minúsculas, salvo cuando estén formadas por dos o más palabras, en cuyo caso, el primer carácter de la segunda palabra se escribirá en mayúscula. Por ejemplo: salario, salariobase, edadjubilacion. Los identificadores de constantes (datos que no van a cambiar durante la ejecución del programa) se deben escribir con todos los caracteres con mayúsculas. Por ejemplo: PI, PRIMER_VALOR, EDADMINIMA. Los identificadores de métodos tendrán la primera letra en minúscula, y la primera letra de las siguientes palabras en mayúscula: getx, setx, incrementarvolumen, etc. Los identificadores de clases e interfaces se deben escribir con el primer carácter de cada palabra en mayúsculas y el resto en minúsculas: Punto, PuntoImpl, etc. 5

7 Tipo de identificador Convención Ejemplo nombre de una clase Comienza por letra mayúscula String, Rectangulo, CinematicaApplet nombre de función comienza con letra minúscula calculararea, getvalue, setcolor nombre de variable comienza por letra minúscula area, color, appletsize nombre de constante En letras mayúsculas PI, MAX_ANCHO Variables Son elementos del lenguaje que permiten guardar y acceder a los datos que se manejan. Es necesario declararlas antes de usarlas en cualquier parte del código y, por convenio, se escriben en minúsculas. Mediante la declaración indicamos que la variable guardará un valor del tipo declarado. Mediante una asignación podemos dar un nuevo valor a la variable. La sintaxis responde al siguiente patrón: Ejemplo: tipo nombredevariable [=valor] [, nombredevariable ]; int valor; Double a1= 2.25, a2= 7.0; char c= T ; String cadena= Curso Java ; En la primera línea del ejemplo se declara una variable, valor, de tipo entero; en la segunda línea se declaran e inicializan dos variables, a1 y a2, de tipo Double; en la tercera, se declara una variable, c, de tipo char y se inicializa; finalmente, se declara e inicializa la variable cadena de tipo String. Java tiene tres tipos de variables: 1) De instancia Las variables de instancia o miembros dato se usan para guardar los atributos de un objeto particular. 2) De clase Las variables de clase o miembros dato estáticos : son similares a las variables de instancia, con la excepción de que los valores que guardan son los mismos para todos los objetos de una determinada clase. En el siguiente ejemplo, PI es una variable de clase y radio es una variable de instancia. PI guarda el mismo valor para todos los objetos de la clase Circulo, pero el radio de cada círculo(objeto) puede ser diferente. class Circulo{ static final double PI=3.1416; double radio; 6

8 3) Locales Las variables locales: se utilizan dentro de las funciones miembro o métodos. En el siguiente ejemplo area es una variable local a la función calculararea en la que se guarda el valor del área de un objeto de la clase Círculo. class Circulo{ double calculararea(){ double area=pi*radio*radio; return area; Las variables locales se declaran en el momento en el que son necesarias. También se pueden inicializar en el momento en el que son declaradas. int x=0; String nombre="angel"; double a=3.5, b=0.0, c=-2.4; boolean bnuevo=true; int[] datos; Delante del nombre de cada variable se ha de especificar el tipo de variable que hemos destacado en letra negrita. Las variables pueden ser: Un tipo de dato primitivo El nombre de una clase Un array Las variables son uno de los elementos básicos de un programa, y se deben: Constantes Declarar Inicializar Usar int i; // declarar int i=2; // inicializar i+i; // usar Son elementos del lenguaje que permiten guardar y referenciar datos que van a permanecer invariables durante la ejecución del código. La declaración de una constante comienza por la palabra reservada final. Es necesario declararlas y por convenio se hace con todas sus letras en mayúsculas. La sintaxis responde al siguiente patrón: Ejemplo: tipo NOMBREDECONSTANTE = valor; final int DIAS_SEMANA =7; final Double PI = ; final String TITULO = E.T.S. de Ingeniería Informática ; 7

9 En este ejemplo se declaran tres constantes, DIAS_SEMANA, PI, y TITULO, de tipo int, Double y String, respectivamente. Note que, por convención, los nombres de constantes se escriben en mayúsculas Palabras reservadas de Java Una palabra reservada es una palabra que tiene un significado especial para el compilador de un lenguaje, y, por lo tanto, no puede ser utilizada como identificador. El conjunto de palabras reservadas que maneja Java se muestra en la siguiente tabla: Tipos de datos Los tipos de datos básicos, nativos o primitivos de Java son: Sentencias Tipo de variable Rango boolean true, false byte -128 a 127 short a int a long a double -1, a 1, float -3, a 3, char Caracteres Una sentencia es una orden que se le da al programa par a realizar una tarea específica, estas pueden ser: int i=1; // declarar una variable e inicializarla import java.awt.*; // importar clases System.out.println("El primer programa"); // mostrar un mensaje en pantalla rect.mover(10, 20); // llamar a una función Las sentencias acaban con ; este carácter separa una sentencia de la siguiente. 8

10 3.6.5 Bloques de código Un bloque de código es un grupo de sentencias que se comportan como una unidad. Un bloque de código está limitado por las llaves de apertura { y cierre. class Circulo{ double calculararea(){ Comentarios double area=pi*radio*radio; return area; Los comentarios son un tipo especial de separadores que sirven para explicar o aclarar algunas sentencias del código, por parte del programador, y ayudar a su prueba y mantenimiento. De esta forma, se intenta que el código pueda ser entendido por una persona diferente o por el propio programador algún tiempo después. Los comentarios son ignorados por el compilador. En Java existen comentarios de línea, que se marcan con //, y bloques de comentarios, que comienzan con /* y terminan con */. Ejemplo: // Este es un comentario de una línea /* Este es un bloque de comentario que ocupa varias líneas */ Expresiones Una expresión es todo aquello que se puede poner a la derecha del operador asignación =. Por ejemplo: x=123; y=(x+100)/4; area=circulo.calculararea(2.5); La primera expresión asigna un valor a la variable x. La segunda, realiza una operación. La tercera, es una llamada a una función miembro calculararea desde un objeto circulo de una clase determinada. 9

11 3.6.8 Operadores Los datos se manipulan muchas veces utilizando operaciones con ellos. Los datos se suman, se restan, multiplican, dividen y a veces se realizan operaciones más complejas Operadores Aritméticos Java tiene cinco operadores aritméticos cuyo significado se muestra en la tabla adjunta Operador Significado + Suma - Resta * Multiplicación / División % Resto Hay que tener en cuenta que el resultado de estos operadores varía notablemente si usamos enteros o si usamos números de coma flotante. Ejemplo: double resultado1, d1=14, d2=5; int resultado2, i1=14, i2=5; resultado1= d1 / d2; resultado2= i1 / i2; resultado1 valdrá 2.8 mientras que resultado2 valdrá 2. El operador del módulo (%) sirve para calcular el resto de una división entera. Ejemplo: int resultado, i1=14, i2=5; resultado = i1 % i2; //El resultado será 4 El módulo sólo se puede utilizar con tipos enteros Operadores de Asignación Nos habremos dado cuenta que el operador más importante y más frecuentemente usado es el operador asignación =, que hemos empleado para la inicialización de las variables. Así, int numero; numero=20; la primera sentencia declara una variable entera de tipo int y le da un nombre (numero). La segunda sentencia usa el operador asignación para inicializar la variable con el número 20. Consideremos ahora, la siguiente sentencia. a=b; 10

12 que asigna a a el valor de b. A la izquierda siempre tendremos una variable tal como a, que recibe valores, a la derecha otra variable b, o expresión que tiene un valor. Las asignaciones múltiples son también posibles. Por ejemplo, es válida la sentencia c=a=b; // equivalente a c=(a=b); la cual puede ser empleada para inicializar en la misma línea varias variables c=a=b=321; // asigna 321 a a, b y c El operador asignación se puede combinar con los operadores aritméticos: Así, la sentencia Expresión x+=y x-=y x*=y x/=y x=x+23; equivale a x+=23; Los operadores unarios Los operadores unarios son: ++ Incremento -- Decremento Significado x=x+y x=x-y x=x*y x=x/y actúan sobre un único operando y el resultado de la operación depende de que el operador esté a la derecha i++ o a la izquierda ++i. Conoceremos, primero el significado de estos dos operadores a partir de las sentencias equivalentes: i=i+1; //añadir 1 a i i++; Del mismo modo, lo son i=i-1; //restar 1 a i i--; Examinemos ahora, la posición del operador respecto del operando. Consideremos en primer lugar que el operador unario ++ está a la derecha del operando. La sentencia j=i++; asigna a j, el valor que tenía i. Por ejemplo, si i valía 3, después de ejecutar la sentencia, j toma el valor de 3 e i el valor de 4. Lo que es equivalente a las dos sentencias j=i; i++; Un resultado distinto se obtiene si el operador ++ está a la izquierda del operando j=++i; 11

13 asigna a j el valor incrementado de i. Por ejemplo, si i valía 3, después de ejecutar la sentencia j e i toman el valor de 4. Lo que es equivalente a las dos sentencias ++i; j=i; Los operadores relacionales Los operadores relacionales son símbolos que se usan para comparar dos valores. Si el resultado de la comparación es correcto la expresión considerada es verdadera, en caso contrario es falsa Los operadores lógicos Operador Significado < Menor > Mayor >= Mayor o igual <= Menor o igual == Igual!= Distinto Operador Significado! No lógico (NOT) && Y lógico (AND) O lógico (OR) AND y OR trabajan con dos operandos y retornan un valor lógico basadas en las denominadas tablas de verdad. Operador AND Operador OR Operador NOT x y Resultado x y Resultado x Resultado true true true true true true true false true false false true false true false true false true false false true true false false false false false false Los operadores AND y OR combinan expresiones relacionales cuyo resultado viene dado por la última columna de sus tablas de verdad. Por ejemplo: (a<b) && (b<c) es verdadero (true), si ambas son verdaderas. Si alguna o ambas son falsas el resultado es falso (false). En cambio, la expresión (a<b) (b<c) es verdadera si una de las dos comparaciones lo es. Si ambas, son falsas, el resultado es falso. La expresión " NO a es menor que b"!(a<b) 12

14 es falsa si (a<b) es verdadero, y es verdadera si la comparación es falsa. Por tanto, el operador NOT actuando sobre (a<b) es equivalente a (a>=b) La expresión "NO a es igual a b"!(a==b) es verdadera si a es distinto de b, y es falsa si a es igual a b. Esta expresión es equivalente a (a!=b) Precedencia A veces hay expresiones con operadores que resultan confusas. Por ejemplo en: resultado = / 2; Es difícil saber el resultado. Cuál es? seis o diez? La respuesta es 10 y la razón es que el operador de división siempre precede en el orden de ejecución al de la suma. Es decir, siempre se ejecuta antes la división que la suma. Siempre se pueden usar paréntesis para forzar el orden deseado: resultado = (8 + 4) / 2; Ahora no hay duda, el resultado es seis. No obstante el orden de precedencia de los operadores Java es: Nivel Operadores 1 ( ) [ ] ~! 3 * / % > >= < <= 6 ==!= 7 & 8 ^ 9 10 && 11 12?: 13 = +=, -=, *=,... En la tabla anterior los operadores con mayor precedencia está en la parte superior, los de menor precedencia en la parte inferior. De izquierda a derecha la precedencia es la misma. Es decir, tiene la misma precedencia el operador de suma que el de resta. Esto último provoca conflictos, por ejemplo en: resultado = 9 / 3 * 3; El resultado podría ser uno ó nueve. En este caso el resultado es nueve, porque la división y el producto tienen la misma precedencia; por ello el compilador de Java realiza primero la operación que este más a la izquierda, que en este caso es la división. Una vez más los paréntesis podrían evitar estos conflictos. 13

15 3.7 El primer programa en Java public class PrimerPrograma { public static void main(string[] args) { System.out.println( Mi primer programa! ); Este código sirve para escribir Mi primer programa! en la pantalla. Para empezar a entender el código: La primera línea (public class PrimerPrograma) declara el nombre de la clase del código. La línea public static void main(string args[]), sirve para indicar el inicio del método main. Este método contiene las instrucciones que se ejecutarán cuando el programa arranque. Es decir lo que está tras las llaves del main, es el programa en sí. La instrucción System.out.println sirve para escribir en pantalla. Como lo que escribimos es un texto, se encierra entre comillas. Además, el archivo tiene que llamarse obligatoriamente PrimerPrograma.java ya que el nombre del programa (en realidad el nombre de la clase) y el del archivo deben coincidir. Por último, aunque no es obligatorio, es más que aconsejable que el nombre del programa comience con una letra mayúscula y le sigan letras en minúsculas. Si consta de varias palabras no pueden utilizarse espacios en blanco, por lo que se suelen juntar las palabras poniendo cada inicial de la palabra en mayúsculas. Éste tipo de reglas no obligatorias sino aconsejables (como por ejemplo el hecho de que las instrucciones interiores a un bloque dejen espacio a su izquierda) producen un código más legible y sobre todo hace que todos los programadores del planeta adoptemos la misma forma de escribir, simplificando el entendimiento del código. 3.8 Lectura y escritura por teclado Escritura Ya hemos visto que hay una función para escribir que es System.out.println. Dicha función puede recibir como parámetro cualquier tipo básico de datos: es decir puede recibir un texto literal (siempre entre comillas), pero también puede escribir expresiones enteras, booleanas, decimales y caracteres simples. Ejemplo: int a=5, b=9; double c=5.5; System.out.println("Este es un texto literal"); System.out.println(a+b); //Escribe 14 System.out.println(c*c); //Escribe System.out.println(a<c);//Escribe true 14

16 Esta función tras escribir añade un salto de línea, de modo que lo siguiente que se escriba saldrá en otra línea. Existe una variante de esta función que no inserta el salto de línea es System.out.print: System.out.print("todo en la"); System.out.print("misma línea"); Si deseamos que el mismo println o print escriba varios valores en la misma instrucción, podemos usar el operador de encadenar textos, ejemplo: int a=5, b=9; System.out.println("La suma es "+(a+b)); Es necesario usar paréntesis ya que se utiliza en la expresión el operador + con dos significados. Este operador concatena cuando al menos hay un texto a la izquierda o derecha del operador; y suma cuando tenemos dos números (del tipo que sea) Lectura Para la Lectura de datos existen algunos métodos, los más importantes son: a. Streams I/O b. Lectura de datos desde teclado a. Uso de la clase BufferedReader b. Uso de la clase Scanner c. Uso de la clase JOptionPane Streams I/O Un stream es una secuencia de caracteres o bytes utilizados para la entrada o salida de un programa. Java proporciona varias clases Stream diferentes de entrada y salida en la API java.io. Los objetos I/O más utilizados son: o System.in (input stream, conectado al teclado) o System.out (output stream, resultados normales en monitor) Lectura de datos desde teclado Existen tres métodos de lectura: a. Clase BufferedReader (consola) b. Clase Scanner (consola) c. Clase JOptionPane (interfaz gráfica de usuario) a. Clase BufferedReader Se encuentra en el paquete java.io Se usa para lectura de datos 15

17 Pasos para leer datos con BufferedReader Añadir la siguiente línea al inicio del código: import java.io.*; Añadir la siguiente instrucción: BufferedReader datain = new BufferedReader( new InputStreamReader(System.in) ); Declarar una variable temporal de tipo String para almacenar la entrada, e invocar el método readline() para leer del teclado. Es necesario escribirlo dentro de un bloque trycatch: try { String temp = datain.readline(); catch( IOException e ){ System.out.println(_Error de lectura_); Ejemplo de lectura con BufferedReader import java.io.*; public class GetInputFromKeyboard { public static void main( String[] args ){ BufferedReader datain = new BufferedReader(new InputStreamReader( System.in ) ); String name = ""; System.out.print("Escribe tu nombre:"); try{ name = datain.readline(); catch( IOException e ){ System.out.println("Error!"); System.out.println("Hola " + name +"!"); Las intruccion import java.io.* es el resumen de las instucciones import java.io.bufferedreader; import java.io.inputstreamreader; import java.io.ioexception; import java.io.*; indican que deseamos usar las clases BufferedReader, InputStreamReader y IOException que están dentro del paquete (package) java.io. Estas instrucciones también se pueden escribir como import java.io.*; La sentencia public class GetInputFromKeyboard { declara una clase llamada GetInputFromKeyboard La siguiente sentencia declara el método main 16

18 public static void main( String[] args ){ La sentencia BufferedReader datain = new BufferedReader(new InputStreamReader( System.in) ); declara una variable datain con el tipo de clase BufferedReader. La sentencia String name = ""; declara una variable name de tipo String. La siguiente sentencia System.out.print("Escribe tu nombre:"); imprime la cadena ;Escribe tu nombre; en pantalla. El bloque siguiente define un bloque try-catch try{ name = datain.readline(); catch( IOException e ){ System.out.println("Error!"); Esto asegura que las posibles excepciones que pueden ocurrir en la sentencia name = datain.readline(); serán capturadas. En la sentencia name = datain.readline(); la llamada al método datain.readline(), lee la entrada del usuario y devuelve un String que se asigna a la variable name. El contenido de la variable name se usa para saludar al usuario en la sentencia System.out.println("Hola " + name +"!"); b. Clase Scanner Otra manera de leer la entrada de usuario es usar la clase Scanner que se encuentra en el paquete java.util La clase Scanner permite leer valores de varios tipos. Algunos de los métodos más usados de Scanner son: Método nextint() nextdouble() next() nextline() Valor devuelto siguiente ingreso como un integer siguiente ingreso como un double siguiente ingreso como un String línea entera (o el resto de la línea) como un String 17

19 Pasos para el uso de la clase Scanner Importar la clase Scanner que está en el paquete java.util import java.util.scanner; Declarar un objecto de la clase Scanner Scanner in = new Scanner(System.in); Usar métodos del objeto Scanner para leer: int piezas = in.nextint(); double volumen = in.nextdouble(); String mensaje = in.next(); Ejemplo de lectura con Scanner import java.util.scanner; public class InputwithScanner { public static void main(string[] args) { final double LITROS_POR_ONZA = ; final double VOLUMEN_DEPOS = 12 * LITROS_POR_ONZA; // Mensaje System.out.print("Ingresar numero de depositos: "); // Lectura del numero de depositos 1 Scanner in = new Scanner(System.in); int depositos = in.nextint(); // Calculo del volumen total double Volumentotal = depositos * VOLUMEN_DEPOS; // Impresion de resultados System.out.print("Volumen del deposito: " + Volumentotal); c. Uso de la clase JOptionPane Otra manera de leer la entrada de usuario es usar la clase JOptionPane que se encuentra en el paquete javax.swing Con JOptionPane es fácil crear una ventana de diálogo estándar que solicita al usuario por un valor o informa de algo. 18

20 Ejemplo de lectura con JOptionPane import javax.swing.joptionpane; public class InputwithJOptionPane { public static void main( String[] args ){ String name = ""; name = JOptionPane.showInputDialog( "Escribe tu nombre"); String msg = "Hola " + name + "!"; JOptionPane.showMessageDialog(null, msg); La sentencia import javax.swing.joptionpane; indica que queremos importar la clase JOptionPane del paquete javax.swing. También puede escribirse como: import javax.swing.*; La sentencia name = JOptionPane.showInputDialog("Escribe tu nombre"); crea un diálogo de entrada JOptionPane, que muestra un diálogo con un mensaje, un campo de texto (textfield) y dos botones (Aceptar, Cancelar). La cadena de caracteres que escribe el usuario se devolverá y asignará a la variable name. La sentencia String msg = "Hola " + name + "!"; crea un mensaje de bienvenida que se almacena en la variable msg. La sentencia JOptionPane.showMessageDialog(null, msg); muestra un diálogo que contiene un mensaje y un botón de Aceptar. 19

21 3.9 Sentencias de Control de Flujo Sentencias Condicionales a) La sentencia IF Si la condición es verdadera, la sentencia se ejecuta, de otro modo, se salta dicha sentencia, continuando la ejecución de l programa saltando a otras sentencias. La forma general de la sentencia if es: if (condición) sentencia; Si el resultado del test es verdadero (true) se ejecuta la sentencia que sigue a continuación de if, en caso contrario, falso (false), se salta dicha sentencia, tal como se indica en la figura. La sentencia puede consistir a su vez, en un conjunto de sentencias agrupadas en un bloque. if (condición){ sentencias; En el siguiente ejemplo, si el número del boleto que hemos adquirido coincide con el número aparecido en el sorteo, nos dicen que hemos obtenido un premio. if(numeroboleto==numerosorteo) System.out.println("has obtenido un premio"); b) La sentencia IF... ELSE La sentencia if...else completa la sentencia if, para realizar una acción alternativa if (condición) sentencia1; else sentencia2; Las dos primeras líneas indican que si la condición es verdadera se ejecuta la sentencia 1. La palabra clave else, significa que si la condición no es verdadera se ejecuta la sentencia 2, tal como se ve en la figura. Dado que las sentencias pueden ser simples o compuestas la forma general de if...else es 20

22 if (condición){ sentencia1; sentencia2; else{ sentencia3 sentencia4; sentencia5; Existe una forma abreviada de escribir una sentencia condicional if...else como la siguiente: if (numeroboleto==numerosorteo) premio=1000; else premio=0; en una sola línea premio=(numeroboleto==numerosoreteo)? 1000 : 0; c) La sentencia SWITCH A veces, es necesario, elegir entre varias alternativas, como se muestra en la siguiente figura. Considerando la siguiente serie de sentencias if...else if(expresion==valor1) sentencia1; else if(expresion==valor2) sentencia2; else if(expresion==valor3) sentencia3; else sentencia4; 21

23 El código resultante puede ser difícil de seguir. El lenguaje Java proporciona una solución elegante a este problema mediante la sentencia condicional switch para agrupar a un conjunto de sentencias if...else. switch(expresion){ case valor1: sentencia1; break; //sale de switch case valor2: sentencia2; break; //sale switch case valor3: sentencia3; break; //sale de switch default: sentencia4; En la sentencia switch, se compara el valor de una variable o el resultado de evaluar una expresión, con un conjunto de números enteros valor1, valor2, valor3,...o con un conjunto de caracteres, cuando coinciden se ejecuta el bloque de sentencias que están asociadas con dicho número o carácter constante. Dicho bloque de sentencias no está entre llaves sino que empieza en la palabra reservada case y termina en su asociado break. Si el compilador no encuentra coincidencia, se ejecuta la sentencia default, si es que está presente en el código. Ejemplo: dado el número que identifica al mes (del 1 al 12) imprimir el nombre del mes. public class SwitchApp1 { public static void main(string[] args) { int mes=3; switch (mes) { case 1: System.out.println("Enero"); break; case 2: System.out.println("Febrero"); break; case 3: System.out.println("Marzo"); break; case 4: System.out.println("Abril"); break; case 5: System.out.println("Mayo"); break; case 6: System.out.println("Junio"); break; case 7: System.out.println("Julio"); break; case 8: System.out.println("Agosto"); break; case 9: System.out.println("Septiembre"); break; case 10: System.out.println("Octubre"); break; case 11: System.out.println("Noviembre"); break; case 12: System.out.println("Diciembre"); break; default: System.out.println("Este mes no existe"); break; 22

24 3.9.2 Sentencias Iterativas a) La sentencia WHILE A la palabra reservada while le sigue una condición encerrada entre paréntesis. El bloque de sentencias que le siguen se ejecuta siempre que la condición sea verdadera tal como se ve en la figura. La forma general que adopta la sentencia while es: while (condición) sentencia; Ejemplo: Escribir un programa que imprima los primeros 10 primeros números enteros empezando por el cero, empleando la sentencia iterativa while. int i=0; while (i<10) { System.out.println(i); i++; b) La sentencia do...while En la condición do...while la condición está al final del bucle, por lo que el bucle se ejecuta por lo menos una vez tal como se ve en la figura. do marca el comienzo del bucle y while el final del mismo. La forma general es: do{ sentencia; while(condición); Ejemplo: Escribir un programa que imprima los primeros 10 primeros números enteros empezando por el cero, empleando la sentencia iterativa do..while. int i=0; do{ System.out.println(i); i++; while(i < 10); 23

25 El bucle do...while, se usa menos que el bucle while, ya que habitualmente evaluamos la expresión que controla el bucle al comienzo, no al final. c) La sentencia FOR Esta sentencia se encuentra en la mayoría de los lenguajes de programación. El bucle for se empleará cuando conocemos el número de veces que se ejecutará una sentencia o un bloque de sentencias. La forma general que adopta la sentencia for es: for(inicialización; condición; incremento) sentencia; El primer término inicialización, se usa para inicializar una variable índice, que controla el número de veces que se ejecutará el bucle. La condición representa la condición que ha de ser satisfecha para que el bucle continúe su ejecución. El incremento representa la cantidad que se incrementa la variable índice en cada repetición. Ejemplo: Escribir un programa que imprima los primeros 10 primeros números enteros empezando por el cero. for (int i = 0; i < 10; i++) { System.out.println(i); El resultado será: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 d) La sentencia break A veces es necesario interrumpir la ejecución de un bucle for, while, o do...while. for(int i = 0; i < 10; i++){ if (i == 8) break; System.out.println(i); Consideremos de nuevo el ejemplo del bucle for, que imprime los 10 primeros números enteros, se interrumpe la ejecución del bucle cuando se cumple la condición de que la variable contador i valga 8. El código se leerá: "salir del bucle cuando la variable contador i, sea igual a 8". El código anterior es equivalente a for(int i = 0; i <=8; i++) System.out.println(i); e) La sentencia continue La sentencia continue, fuerza al bucle a comenzar la siguiente iteración desde el principio. En la siguiente porción de código, se imprimen todos los números del 0 al 9 excepto el número 8. for(int i = 0; i < 10; i++){ if (i == 8) continue; System.out.println(i); 24

26 3.10 Instalación de Java e IDE (Entorno de desarrollo integrado) Java Instalación de Java Para poder hacer este curso debemos instalar el compilador de Java y la máquina virtual de Java. Estas herramientas las podemos descargar de: Java SE Development Kit (JDK). Una vez que tenemos el JDK (Java Development Kit) procedemos a instalarlo: La versión a instalar conviene que sea la última (en este momento disponemos la versión 6) Aceptamos los términos: Haremos la instalación por defecto por lo que presionamos el botón next: 25

27 Esperamos unos minutos mientras se procede a la instalación de Java: Luego aparece un diálogo donde debemos especificar el directorio donde almacenar el JRE y también procedemos a efectuar la instalación por defecto presionando el botón "next": 26

28 Una vez finalizado el proceso de instalación debe aparecer un diálogo similar a este: 27

29 Instalación del IDE Eclipse Una vez que descargamos el Eclipse su instalación es muy sencilla, creamos una carpeta llamada eclipse y procedemos a descomprimir el archivo descargado indicando solamente la unidad donde se instala (ejemplo c:). Ahora nos dirigimos a la carpeta donde se instalaron los archivos y procedemos a ejecutar el programa eclipse.exe Primero aparece un mensaje de inicio del Eclipse: Luego la primera vez que ejecutemos el editor Eclipse aparece un diálogo para seleccionar la carpeta donde se almacenarán los programas que desarrollaremos (podemos crear una carpeta donde almacenaremos todos los proyectos que desarrollaremos en el curso): Luego de configurar la carpeta donde se crearán los proyecto aparece el editor con una pantalla de presentación (Welcome): 28

30 Esta ventana de bienvenida la podemos cerrar seleccionando el ícono: "Workbench", con lo que aparece el entorno de trabajo del Eclipse (si queremos nuevamente ver la ventana de bienvenida podemos activarla desde el menú de opciones: Help -> Welcome" El entorno de trabajo del Eclipse es: 29

31 Pasos para crear un programa con Eclipse Todo programa en Eclipse requiere la creación de un "Proyecto", para esto debemos seleccionar desde el menú de opciones o desde la barra de íconos del Eclipse: Ahora aparece el diálogo donde debemos definir el nombre de nuestro proyecto: 30

32 En el campo de texto "Project Name" ingresamos como nombre: Proyecto1 y dejamos todas las otras opciones del diálogo con los valores por defecto. Presionamos el botón "Finish". Ahora en la ventana de "Package" aparece el proyecto que acabamos de crear: Como segundo paso veremos que todo programa en Java requiere como mínimo una clase. Para crear una clase debemos seleccionar desde el menú de opciones: O desde la barra de íconos del Eclipse: En el diálogo que aparece debemos definir el nombre de la clase (en nuestro primer ejemplo la llamaremos Clase1, luego veremos que es importante definir un nombre que represente al objetivo de la misma), los otros datos del diálogo los dejamos con los valores por defecto: 31

33 Luego de presionar el botón "Finish" tenemos el archivo donde podemos codificar nuestro primer programa: 32

34 En la ventana de edición ya tenemos el esqueleto de una clase de Java que el entorno Eclipse nos creó automáticamente. public class Clase1 { Todo programa en Java debe definir la función main. Esta función la debemos codificar dentro de la clase: "Clase1". Procedemos a tipear lo siguiente: public class Clase1 { public static void main(string[] parametro) { System.out.println("Hola Mundo Java"); Es decir tenemos codificado en el entorno del Eclipse nuestro primer programa: Como último paso debemos compilar y ejecutar el programa, esto lo podemos hacer desde el menú de opciones: 33

35 O desde la barra de íconos del Eclipse: Si no hay errores de codificación debemos ver el resultado de la ejecución en una ventana del Eclipse llamada "Console" que aparece en la parte inferior: Lo más importante es que quede claro los pasos que debemos dar para crear un proyecto en Java. 34

36 3.11 Consideraciones a tener en cuenta en cada proyecto. Codificaremos el problema que calcule el sueldo de un operario en base a las horas trabajadas y el costo de la hora trabajada. Pasos. 1. Creación del proyecto. Podemos asignarle como nombre: SueldoOperario, normalmente uno busca un nombre representativo al programa que desarrolla. 2. Creación de la clase. Definiremos como nombre el mismo que le asignamos al proyecto, es decir disponemos como nombre de la clase: SueldoOperario. 3. Codificamos el algoritmo en la clase: SueldoOperario. import java.util.scanner; public class SueldoOperario { public static void main(string[] arg) { Scanner teclado=new Scanner(System.in); int horastrabajadas; float costohora; float sueldo; System.out.print("Ingrese la cantidad de horas trabajadas por el empleado:"); horastrabajadas=teclado.nextint(); System.out.print("Ingrese el valor de la hora:"); costohora=teclado.nextfloat(); sueldo=horastrabajadas * costohora; System.out.print("El empleado debe cobrar:"); System.out.print(sueldo); 4. Ejecutamos el programa: 5. Si no hay errores sintácticos procedemos a activar la ventana de la "Console" con el mouse y cargamos por teclado los dos datos que se solicitan (la cantidad de horas trabajadas y el precio de la hora): Estos cinco pasos fundamentales debemos llevar a cabo cada vez que desarrollemos un nuevo programa en Java. Explicación. Para declarar una clase utilizamos la sintaxis: public class SueldoOperario { El nombre de la clase no puede tener espacios en blanco, comienza con una letra mayúscula y en caso de estar constituida por dos o más palabras el primer carácter va en mayúsculas, no puede empezar con un número, pero si puede llevar números a partir del segundo carácter. Toda clase debe tener una llave de apertura y una llave de cierre. Todo programa constituido por una única clase debe tener definida la función main: public static void main(string[] arg) { La función main es la primera que se ejecuta, la función main tiene una llave de apertura y una llave de cierre (similar a la clase). La función main debe estar contenida en la clase. 35

37 Cuando se requieren utilizar otras clases debemos importarlas previo a la declaración de la clase, en nuestro problema utilizamos la clase Scanner que se encuentra en el paquete java.util por lo que la importamos con la siguiente sintaxis: import java.util.scanner; En la main creamos un objeto de la clase Scanner que nos permitirá ingresar por teclado los valores: Scanner teclado=new Scanner(System.in); La definición de las variables la hacemos en la main: int horastrabajadas; float costohora; float sueldo; Para mostrar mensajes en la "Console" utilizamos la siguiente sintaxis: System.out.print("Ingrese la cantidad de horas trabajadas por el empleado:"); Con esta sintaxis todo lo que se encuentra contenido entre comillas aparecerá exactamente en la ventana de la "Console". Para hacer la entrada de datos por teclado en Java utilizaremos una clase llamada Scanner que nos facilita el ingreso de datos. Por eso tuvimos que importar la clase Scanner que se encuentra en el paquete java.util en la primera línea de nuestro programa. import java.util.scanner; En la función main debemos crear un objeto de la clase Scanner con la siguiente sintaxis: Scanner teclado=new Scanner(System.in); Luego para cargar valores enteros por teclado debemos implementar la siguiente sintaxis: horastrabajadas=teclado.nextint(); Pero si el dato a cargar se trata de un valor float luego debemos utilizar la siguiente sintaxis: costohora=teclado.nextfloat(); Las operaciones que indicamos la codificamos tal cual: sueldo=horastrabajadas * costohora; Si disponemos una variable que deseemos imprimir utilizamos la siguiente sintaxis: System.out.print(sueldo); Aparecerá el contenido de la variable. Es decir el valor almacenado en la variable sueldo y no el mensaje "sueldo". 36

38 Ejemplos: Estructura de programación secuencial 1. Hallar la superficie de un cuadrado conociendo el valor de un lado. import java.util.scanner; public class SuperficieCuadrado { public static void main(string[] arg) { Scanner teclado=new Scanner(System.in); int lado; int superficie; System.out.print("Ingrese el valor del lado del cuadrado:"); lado=teclado.nextint(); superficie=lado * lado; System.out.print("La superficie del cuadrado es:"); System.out.print(superficie); 2. Realizar la carga de dos números enteros por teclado e imprimir su suma y su producto. import java.util.scanner; public class SumaProductoNumeros { public static void main(string[] arg) { Scanner teclado=new Scanner(System.in); int num1,num2,suma,producto; System.out.print("Ingrese primer valor:"); num1=teclado.nextint(); System.out.print("Ingrese segundo valor"); num2=teclado.nextint(); suma=num1 + num2; producto=num1 * num2; System.out.print("La suma de los dos valores es:"); System.out.println(suma); System.out.print("El producto de los dos valores es:"); System.out.println(producto); Estructura condicional simple - compuesta 3. Realizar un programa que solicite ingresar dos números distintos y muestre por pantalla el mayor de ellos. import java.util.scanner; public class EstructuraCondicionalCompuesta { public static void main(string[] ar) { Scanner teclado=new Scanner(System.in); int num1,num2; System.out.print("Ingrese primer valor:"); num1=teclado.nextint(); System.out.print("Ingrese segundo valor:"); num2=teclado.nextint(); if (num1>num2) { System.out.print(num1); else { System.out.print(num2); 37

39 Estructura condicional anidada 4. Confeccionar un programa que pida por teclado tres notas de un alumno, calcule el promedio e imprima alguno de estos mensajes: Si el promedio es >=7 mostrar "Promocionado". Si el promedio es >=4 y <7 mostrar "Regular". Si el promedio es <4 mostrar "Reprobado". import java.util.scanner; public class EstructuraCondicionalAnidada { public static void main(string[] arg) { Scanner teclado=new Scanner(System.in); int nota1,nota2,nota3; System.out.print("Ingrese primer nota:"); nota1=teclado.nextint(); System.out.print("Ingrese segunda nota:"); nota2=teclado.nextint(); System.out.print("Ingrese tercer nota:"); nota3=teclado.nextint(); int promedio=(nota1 + nota2 + nota3) / 3; if (promedio>=7) { System.out.print("Promocionado"); else { if (promedio>=4) { System.out.print("Regular"); else { System.out.print("Reprobado"); Estructura condicional compuesta con operadores lógicos 5. Confeccionar un programa que lea por teclado tres números distintos y nos muestre el mayor. import java.util.scanner; public class OperadorLogico1 { public static void main(string[] arg) { Scanner teclado=new Scanner(System.in); int num1,num2,num3; System.out.print("Ingrese primer valor:"); num1=teclado.nextint(); System.out.print("Ingrese segundo valor:"); num2=teclado.nextint(); System.out.print("Ingrese tercer valor:"); num3=teclado.nextint(); if (num1>num2 && num1>num3) { System.out.print(num1); else { if (num2>num3) { 38

40 System.out.print(num2); else { System.out.print(num3); 6. Se carga una fecha (día, mes y año) por teclado. Mostrar un mensaje si corresponde al primer trimestre del año (enero, febrero o marzo) Cargar por teclado el valor numérico del día, mes y año. Ejemplo: dia:10 mes:1 año:2010. import java.util.scanner; public class OperadorLogico2 { public static void main(string[] arg) { Scanner teclado=new Scanner(System.in); int dia,mes,año; System.out.print("Ingrese nro de día:"); dia=teclado.nextint(); System.out.print("Ingrese nro de mes:"); mes=teclado.nextint(); System.out.print("Ingrese nro de año:"); año=teclado.nextint(); if (mes==1 mes==2 mes==3) { System.out.print("Corresponde al primer trimestre"); Estructura repetitiva while 7. Escribir un programa que solicite la carga de un valor positivo y nos muestre desde 1 hasta el valor ingresado de uno en uno. Ejemplo: Si ingresamos 30 se debe mostrar en pantalla los números del 1 al 30. import java.util.scanner; public class EstructuraRepetitivaWhile { public static void main(string[] arg) { Scanner teclado=new Scanner(System.in); int n,x; System.out.print("Ingrese el valor final:"); n=teclado.nextint(); x=1; while (x<=n) { System.out.print(x); System.out.print(" - "); x = x + 1; 39

41 Estructura repetitiva do while 8. Escribir un programa que solicite la carga de un número entre 0 y 999, y nos muestre un mensaje de cuántos dígitos tiene el mismo. Finalizar el programa cuando se cargue el valor 0. import java.util.scanner; public class EstructuraRepetitivaDoWhile { public static void main(string[] arg) { Scanner teclado=new Scanner(System.in); int valor; do { System.out.print("Ingrese un valor entre 0 y 999 (0 finaliza):"); valor=teclado.nextint(); if (valor>=100) { System.out.println("Tiene 3 dígitos."); else { if (valor>=10) { System.out.println("Tiene 2 dígitos."); else { System.out.println("Tiene 1 dígito."); while (valor!=0); Estructura repetitiva for 9. Escribir un programa que lea n números enteros y calcule la cantidad de valores mayores o iguales a import java.util.scanner; public class EstructuraRepetitivaFor { public static void main(string[] arg) { Scanner teclado=new Scanner(System.in); int cantidad,n,f,valor; cantidad=0; System.out.print("Cuantos valores ingresará:"); n=teclado.nextint(); for(f=1;f<=n;f++) { System.out.print("Ingrese el valor:"); valor=teclado.nextint(); if (valor>=1000) { cantidad=cantidad+1; System.out.print("La cantidad de valores ingresados mayores o iguales a 1000 son:"); System.out.print(cantidad); 40

42 Cadenas de caracteres 10. Escribir un programa que solicite el ingreso del nombre y edad de dos personas. Mostrar el nombre de la persona con mayor edad. import java.util.scanner; public class CadenaDeCaracteres { public static void main(string[] arg) { Scanner teclado=new Scanner(System.in); String nombre1,nombre2; int edad1,edad2; System.out.print("Ingrese el nombre:"); nombre1=teclado.next(); System.out.print("Ingrese edad:"); edad1=teclado.nextint(); System.out.print("Ingrese el nombre:"); nombre2=teclado.next(); System.out.print("Ingrese edad:"); edad2=teclado.nextint(); System.out.print("La persona de mayor edad es:"); if (edad1>edad2) { System.out.print(nombre1); else { System.out.print(nombre2); 41

43 3.12 Declaración de clases y métodos Declaración de clases La programación orientada a objetos se basa en la programación de clases; a diferencia de la programación estructurada, que está centrada en las funciones. Una clase es una plantilla (molde), que define atributos (variables) y métodos (funciones). Debemos crear una clase antes de poder crear objetos (instancias) de esa clase. Al crear un objeto de una clase, se dice que se crea una instancia de la clase o un objeto propiamente dicho. La estructura de una clase es: class [nombre de la clase] { [atributos o variables de la clase] [métodos o funciones de la clase] [main] Ejemplo1: Crear una clase que permita ingresar el nombre y la edad de una persona. Imprimir los datos cargados e imprimir un mensaje si es mayor de edad (edad>=18) import java.util.scanner; public class Persona { private Scanner teclado; private String nombre; private int edad; public void inicializar() { teclado=new Scanner(System.in); System.out.print("Ingrese nombre:"); nombre=teclado.next(); System.out.print("Ingrese edad:"); edad=teclado.nextint(); public void imprimir() { System.out.println("Nombre:"+nombre); System.out.println("Edad:"+edad); public void esmayoredad() { if (edad>=18) { System.out.print(nombre+" es mayor de edad."); else { System.out.print(nombre+" no es mayor de edad."); 42

44 public static void main(string[] ar) { Persona persona1; persona1=new Persona(); persona1.inicializar(); persona1.imprimir(); persona1.esmayoredad(); El nombre de la clase debe hacer referencia al concepto (en este caso la hemos llamado Persona): public class Persona { Los atributos los definimos dentro de la clase pero fuera de la main: private Scanner teclado; private String nombre; private int edad; Un atributo es normalmente definido con la cláusula private, con esto no permitimos el acceso al atributo desde otras clases. Luego de definir los atributos de la clase debemos declarar los métodos o funciones de la clase. La sintaxis es parecida a la main (sin la cláusula static): public void inicializar() { teclado=new Scanner(System.in); System.out.print("Ingrese nombre:"); nombre=teclado.next(); System.out.print("Ingrese edad:"); edad=teclado.nextint(); En el método inicializar (que será el primero que deberemos llamar desde la main) creamos el objeto de la clase Scanner y cargamos por teclado los atributos nombre y edad. Como podemos ver el método inicializar puede hacer acceso a los tres atributos de la clase Persona. El segundo método tiene por objetivo imprimir el contenido de los atributos nombre y edad (los datos de los atributos se cargaron al ejecutarse previamente el método inicializar: public void imprimir() { System.out.println("Nombre:"+nombre); System.out.println("Edad:"+edad); El tercer método tiene por objetivo mostrar un mensaje si la persona es mayor o no de edad: public void esmayoredad() { if (edad>=18) { System.out.print(nombre+" es mayor de edad."); else { System.out.print(nombre+" no es mayor de edad."); Por último en la main declaramos un objeto de la clase Persona y llamamos a los métodos en un orden adecuado: 43

45 public static void main(string[] ar) { Persona persona1; persona1=new Persona(); persona1.inicializar(); persona1.imprimir(); persona1.esmayoredad(); Persona persona1; //Declaración del objeto persona1=new Persona(); //Creación del objeto persona1.inicializar(); //Llamada de un método Ejemplo2: Desarrollar un programa que cargue los lados de un triángulo e implemente los siguientes métodos: inicializar los atributos, imprimir el valor del lado mayor y otro método que muestre si es equilátero o no. import java.util.scanner; public class Triangulo { private Scanner teclado; private int lado1,lado2,lado3; public void inicializar() { teclado=new Scanner(System.in); System.out.print("Medida lado 1:"); lado1=teclado.nextint(); System.out.print("Medida lado 2:"); lado2=teclado.nextint(); System.out.print("Medida lado 3:"); lado3=teclado.nextint(); public void ladomayor() { System.out.print("Lado mayor:"); if (lado1>lado2 && lado1>lado3) { System.out.println(lado1); else { if (lado2>lado3) { System.out.println(lado2); else { System.out.println(lado3); public void esequilatero() { if (lado1==lado2 && lado1==lado3) { System.out.print("Es un triángulo equilátero"); else { System.out.print("No es un triángulo equilátero"); 44

46 public static void main(string []ar) { Triangulo triangulo1=new Triangulo(); triangulo1.inicializar(); triangulo1.ladomayor(); triangulo1.esequilatero(); Todos los problemas que requieran la entrada de datos por teclado debemos definir un atributo de la clase Scanner: private Scanner teclado; Este problema requiere definir tres atributos de tipo entero donde almacenamos los valores de los lados del triángulo: private int lado1,lado2,lado3; El primer método que deberá llamarse desde la main es el inicializar donde creamos el objeto de la clase Scanner y cargamos los tres atributos por teclado: public void inicializar() { teclado=new Scanner(System.in); System.out.print("Medida lado 1:"); lado1=teclado.nextint(); System.out.print("Medida lado 2:"); lado2=teclado.nextint(); System.out.print("Medida lado 3:"); lado3=teclado.nextint(); El método ladomayor muestra el valor mayor de los tres enteros ingresados: public void ladomayor() { System.out.print("Lado mayor:"); if (lado1>lado2 && lado1>lado3) { System.out.println(lado1); else { if (lado2>lado3) { System.out.println(lado2); else { System.out.println(lado3); El último método de esta clase verifica si los tres enteros ingresados son iguales: public void esequilatero() { if (lado1==lado2 && lado1==lado3) { System.out.print("Es un triángulo equilátero"); else { System.out.print("No es un triángulo equilátero"); 45

47 En la main creamos un objeto de la clase Triangulo y llamamos los métodos respectivos: public static void main(string []ar) { Triangulo triangulo1=new Triangulo(); triangulo1.inicializar(); triangulo1.ladomayor(); triangulo1.esequilatero(); Ejemplo3: Desarrollar una clase que represente un punto en el plano y tenga los siguientes métodos: cargar los valores de x e y, imprimir en que cuadrante se encuentra dicho punto (concepto matemático, primer cuadrante si x e y son positivas, si x<0 e y>0 segundo cuadrante, etc.) import java.util.scanner; public class Punto { private Scanner teclado; int x,y; public void inicializar() { teclado=new Scanner(System.in); System.out.print("Ingrese coordenada x :"); x=teclado.nextint(); System.out.print("Ingrese coordenada y :"); y=teclado.nextint(); void imprimircuadrante() { if (x>0 && y>0) { System.out.print("Se encuentra en el primer cuadrante."); else { if (x<0 && y>0) { System.out.print("Se encuentra en el segundo cuadrante."); else { if (x<0 && y<0) { System.out.print("Se encuentra en el tercer cuadrante."); else { if (x>0 && y<0) { System.out.print("Se encuentra en el cuarto cuadrante."); else { System.out.print("El punto no está en un cuadrante."); 46

48 public static void main(string[] ar) { Punto punto1; punto1=new Punto(); punto1.inicializar(); punto1.imprimircuadrante(); Definimos tres atributos (el objeto de la clase Scanner y los dos enteros donde almacenamos la coordenada x e y del punto: private Scanner teclado; int x,y; El método inicializar crea el objeto de la clase Scanner y pide cargar las coordenadas x e y: public void inicializar() { teclado=new Scanner(System.in); System.out.print("Ingrese coordenada x :"); x=teclado.nextint(); System.out.print("Ingrese coordenada y :"); y=teclado.nextint(); El segundo método mediante un conjunto de if verificamos en que cuadrante se encuentra el punto ingresado: void imprimircuadrante() { if (x>0 && y>0) { System.out.print("Se encuentra en el primer cuadrante."); else { if (x<0 && y>0) { System.out.print("Se encuentra en el segundo cuadrante."); else { if (x<0 && y<0) { System.out.print("Se encuentra en el tercer cuadrante."); else { if (x>0 && y<0) { System.out.print("Se encuentra en el cuarto cuadrante."); else { System.out.print("El punto no está en un cuadrante."); La main no tiene grandes diferencias con los problemas realizados anteriormente, declaramos un objeto de la clase Punto, creamos el objeto mediante el operador new y seguidamente llamamos a los métodos inicializar e imprimircuadrante en ese orden: 47

49 Ejemplo4: public static void main(string[] ar) { Punto punto1; punto1=new Punto(); punto1.inicializar(); punto1.imprimircuadrante(); Desarrollar una clase que represente un Cuadrado y tenga los siguientes métodos: cargar el valor de su lado, imprimir su perímetro y su superficie. import java.util.scanner; public class Cuadrado { private Scanner teclado; int lado; public void inicializar() { teclado=new Scanner(System.in); System.out.print("Ingrese valor del lado :"); lado=teclado.nextint(); public void imprimirperimetro() { int perimetro; perimetro=lado*4; System.out.println("El perímetro es:"+perimetro); public void imprimirsuperficie() { int superficie; superficie=lado*lado; System.out.println("La superficie es:"+superficie); public static void main(string[] ar) { Cuadrado cuadrado1; cuadrado1=new Cuadrado(); cuadrado1.inicializar(); cuadrado1.imprimirperimetro(); cuadrado1.imprimirsuperficie(); En este problema es interesante ver como no definimos dos atributos donde se almacenan la superficie y el perímetro del cuadrado, esto debido a que solo estos datos se los requiere en el método donde se imprimen: public void imprimirperimetro() { int perimetro; perimetro=lado*4; System.out.println("El perímetro es:"+perimetro); 48

50 Esto significa que la variable perimetro es una variable local al método imprimirperimetro. Esta variable es local a dicho método y solo se la puede acceder dentro del método. La diferencia fundamental entre una variable local y un atributo de la clase es que al atributo se lo puede acceder desde cualquier método de la clase y la variable local solo existe mientras se está ejecutando el método Declaración de métodos. Cuando uno plantea una clase en lugar de especificar todo el algoritmo en un único método (lo que hicimos en los primeros pasos de este tutorial) es dividir todas las responsabilidades de las clase en un conjunto de métodos. Un método hemos visto que tiene la siguiente sintaxis: public void [nombre del método]() { [algoritmo] Veremos que hay varios tipos de métodos: a. Métodos con parámetros. Un método puede tener parámetros: public void [nombre del método]([parámetros]) { [algoritmo] Los parámetros los podemos imaginar cómo variables locales al método, pero su valor se inicializa con datos que llegan cuando lo llamamos. Ejemplo1: Confeccionar una clase que permita ingresar valores enteros por teclado y nos muestre la tabla de multiplicar de dicho valor. Finalizar el programa al ingresar el -1. import java.util.scanner; public class TablaMultiplicar { public void cargarvalor() { Scanner teclado=new Scanner(System.in); int valor; do { System.out.print("Ingrese valor:"); valor=teclado.nextint(); if (valor!=-1) { calcular(valor); while (valor!=-1); public void calcular(int v) { for(int f=v;f<=v*10;f=f+v) { System.out.print(f+"-"); 49

51 public static void main(string[] ar) { TablaMultiplicar tabla; tabla=new TablaMultiplicar(); tabla.cargarvalor(); En esta clase no hemos definido ningún atributo, ya que el objeto de la clase Scanner lo requerimos en un solo método, por ello lo definimos como una variable local. El método calcular recibe un parámetro de tipo entero, luego lo utilizamos dentro del método para mostrar la tabla de multiplicar de dicho valor, para esto inicializamos la variable f con el valor que llega en el parámetro. Luego de cada ejecución del for incrementamos el contador f con el valor de v. public void calcular(int v) { for(int f=v;f<=v*10;f=f+v) { System.out.println(f); Un método puede no tener parámetros como hemos visto en problemas anteriores o puede tener uno o más parámetros (en caso de tener más de un parámetro los mismos se separan por coma) El método cargarvalores no tiene parámetros y tiene por objetivo cargar un valor entero por teclado y llamar al método calcular para que muestre la tabla de multiplicar del valor que le pasamos por teclado: public void cargarvalor() { Scanner teclado=new Scanner(System.in); int valor; do { System.out.print("Ingrese valor:"); valor=teclado.nextint(); if (valor!=-1) { calcular(valor); while (valor!=-1); Como vemos al método calcular lo llamamos por su nombre y entre paréntesis le pasamos el dato a enviar (debe ser un valor o variable entera) En este problema en la main solo llamamos al método cargarvalor, ya que el método calcular luego es llamado por el método cargarvalor: public static void main(string[] ar) { TablaMultiplicar tabla; tabla=new TablaMultiplicar(); tabla.cargarvalor(); 50

52 b. Métodos que retornan un dato. Un método puede retornar un dato: public [tipo de dato] [nombre del método]([parámetros]) { [algoritmo] return [tipo de dato] Cuando un método retorna un dato en vez de indicar la palabra clave void previo al nombre del método indicamos el tipo de dato que retorna. Luego dentro del algoritmo en el momento que queremos que finalice el mismo y retorne el dato empleamos la palabra clave return con el valor respectivo. Ejemplo1: Confeccionar una clase que permita ingresar tres valores por teclado. Luego mostrar el mayor y el menor. import java.util.scanner; public class MayorMenor { public void cargarvalores() { Scanner teclado=new Scanner(System.in); System.out.print("Ingrese primer valor:"); int valor1=teclado.nextint(); System.out.print("Ingrese segundo valor:"); int valor2=teclado.nextint(); System.out.print("Ingrese tercer valor:"); int valor3=teclado.nextint(); int mayor,menor; mayor=calcularmayor(valor1,valor2,valor3); menor=calcularmenor(valor1,valor2,valor3); System.out.println("El valor mayor de los tres es:"+mayor); System.out.println("El valor menor de los tres es:"+menor); public int calcularmayor(int v1,int v2,int v3) { int m; if(v1>>v2 && v1>v3) { m=v1; else { if(v2>v3) { m=v2; else { m=v3; return m; 51

53 public int calcularmenor(int v1,int v2,int v3) { int m; if(v1<v2 && v1<v3) { m=v1; else { if(v2<v3) { m=v2; else { m=v3; return m; public static void main(string[] ar) { MayorMenor maymen=new MayorMenor(); maymen.cargarvalores(); Si vemos la sintaxis que calcula el mayor de tres valores enteros es similar al algoritmo visto en conceptos anteriores: public int calcularmayor(int v1,int v2,int v3) { int m; if(v1>v2 && v1>v3) { m=v1; else { if(v2>v3) { m=v2; else { m=v3; return m; Lo primero que podemos observar que el método retorna un entero y recibe tres parámetros: public int calcularmayor(int v1,int v2,int v3) { Dentro del método verificamos cuál de los tres parámetros almacena un valor mayor, a este valor lo almacenamos en una variable local llamada "m", al valor almacenado en esta variable lo retornamos al final con un return. La llamada al método calcularmayor lo hacemos desde dentro del método cargarcalores: mayor=calcularmayor(valor1,valor2,valor3); Debemos asignar a una variable el valor devuelto por el método calcularmayor. Luego el contenido de la variable mayor lo mostramos: System.out.println("El valor mayor de los tres es:"+mayor); La lógica es similar para el cálculo del menor. 52

54 3.13 Estructura de datos tipo vector. Un vector es una estructura de datos que permite almacenar un CONJUNTO de datos del MISMO tipo. Con un único nombre se define un vector y por medio de un subíndice hacemos referencia a cada elemento del mismo (componente). Ejemplo1: Se desea guardar los sueldos de 5 operarios. import java.util.scanner; public class SueldoVector { private Scanner teclado; private int[] sueldos; public void cargar() { teclado=new Scanner(System.in); sueldos=new int[5]; for(int f=0;f<5;f++) { System.out.print("Ingrese valor de la componente:"); sueldos[f]=teclado.nextint(); public void imprimir() { for(int f=0;f<5;f++) { System.out.println(sueldos[f]); public static void main(string[] ar) { SueldoVector pv=new SueldoVector(); pv.cargar(); pv.imprimir(); Para la declaración de un vector le antecedemos al nombre los corchetes abiertos y cerrados: private int[] sueldos; 53

55 Lo definimos como atributo de la clase ya que lo utilizaremos en los dos métodos. En el método de cargar lo primero que hacemos es crear el vector (en java los vectores son objetos por lo que es necesario proceder a su creación mediante el operador new): sueldos=new int[5]; Cuando creamos el vector indicamos entre corchetes la cantidad de elementos que se pueden almacenar posteriormente en el mismo. Para cargar cada componente debemos indicar entre corchetes que elemento del vector estamos accediendo: for(int f=0;f<5;f++) { System.out.print("Ingrese valor de la componente:"); sueldos[f]=teclado.nextint(); La estructura de programación que más se adapta para cargar en forma completa las componentes de un vector es un for, ya que sabemos de antemano la cantidad de valores a cargar. Cuando f vale cero estamos accediendo a la primer componente del vector (en nuestro caso sería): sueldos[0]=teclado.nextint(); Lo más común es utilizar una estructura repetitiva for para recorrer cada componente del vector. Utilizar el for nos reduce la cantidad de código, si no utilizo un for debería en forma secuencial implementar el siguiente código: System.out.print("Ingrese valor de la componente:"); sueldos[0]=teclado.nextint(); System.out.print("Ingrese valor de la componente:"); sueldos[1]=teclado.nextint(); System.out.print("Ingrese valor de la componente:"); sueldos[2]=teclado.nextint(); System.out.print("Ingrese valor de la componente:"); sueldos[3]=teclado.nextint(); System.out.print("Ingrese valor de la componente:"); sueldos[4]=teclado.nextint(); La impresión de las componentes del vector lo hacemos en el otro método: public void imprimir() { for(int f=0;f<5;f++) { System.out.println(sueldos[f]); Siempre que queremos acceder a una componente del vector debemos indicar entre corchetes la componente, dicho valor comienza a numerarse en cero y continua hasta un número menos del tamaño del vector, en nuestro caso creamos el vector con 5 elementos: sueldos=new int[5]; Por último en este programa creamos un objeto en la main y llamamos a lo métodos de cargar e imprimir el vector: 54

56 public static void main(string[] ar) { SueldoVector pv=new SueldoVector(); pv.cargar(); pv.imprimir(); Ejemplo2: Desarrollar un vector de 5 elementos de tipo float que representen las estaturas de 5 personas. Obtener el promedio de las mismas, contar cuántas personas son más altas que el promedio y cuántas más bajas. import java.util.scanner; public class EstaturaVector { private Scanner teclado; private float[] alturas; private float promedio; public void cargar() { teclado=new Scanner(System.in); alturas=new float[5]; for(int f=0;f<5;f++) { System.out.print("Ingrese la altura de la persona:"); alturas[f]=teclado.nextfloat(); public void calcularpromedio() { float suma; suma=0; for(int f=0;f<5;f++) { suma=suma+alturas[f]; promedio=suma/5; System.out.println("Promedio de alturas:"+promedio); public void mayoresmenores() { int may,men; may=0; men=0; for(int f=0;f<5;f++) { if (alturas[f]>promedio) { may++; else { if (alturas[f]<promedio) { men++; System.out.println("Cantidad de personas mayores al promedio:"+may); 55

57 System.out.println("Cantidad de personas menores al promedio:"+men); public static void main(string[] ar) { EstaturaVector pv2=new EstaturaVector(); pv2.cargar(); pv2.calcularpromedio(); pv2.mayoresmenores(); Vector (Tamaño de un vector) Como hemos visto cuando se crea un vector indicamos entre corchetes su tamaño: sueldos=new int[5]; Que pasa ahora si cambiamos el tamaño del vector cuando lo creamos. Podemos pedir al usuario que indique el tamaño del vector en tiempo de ejecución, en estos casos se hace imprescindible el empleo del atributo length. Ejemplo3: Desarrollar un programa que permita ingresar un vector de n elementos, ingresados por teclado, se desea imprimir la suma de todos sus elementos. import java.util.scanner; public class SumaVector { private Scanner teclado; private int[] vec; public void cargar() { teclado=new Scanner(System.in); System.out.print("Cuantos elementos tiene el vector:"); int n; n=teclado.nextint(); vec=new int[n]; for(int f=0;f<vec.length;f++) { System.out.print("Ingrese elemento:"); vec[f]=teclado.nextint(); public void acumularelementos() { int suma=0; for(int f=0;f<vec.length;f++) { suma=suma+vec[f]; System.out.println("La suma de los elementos es:"+suma); 56

58 public static void main(string[] ar) { SumaVector pv=new SumaVector(); pv.cargar(); pv.acumularelementos(); 3.14 Estructura de datos tipo matriz Una matriz es una estructura de datos que permite almacenar un CONJUNTO de datos del MISMO tipo. Con un único nombre se define la matriz y por medio de DOS subíndices hacemos referencia a cada elemento de la misma (componente) Hemos graficado una matriz de 3 filas y 5 columnas. Para hacer referencia a cada elemento debemos indicar primero la fila y luego la columna, por ejemplo en la componente 1,4 se almacena el valor 97. En este ejemplo almacenamos valores enteros. Todos los elementos de la matriz deben ser del mismo tipo (int, float, String etc.) Las filas y columnas comienzan a numerarse a partir de cero, similar a los vectores. Una matriz se la puede representar por un conjunto de vectores. Ejemplo1: Crear una matriz de 3 filas por 5 columnas con elementos de tipo int, cargar sus componentes y luego imprimirlas. import java.util.scanner; public class Matriz1 { private Scanner teclado; private int[][] mat; public void cargar() { teclado=new Scanner(System.in); mat=new int[3][5]; for(int f=0;f<3;f++) { for(int c=0;c<5;c++) { 57

59 System.out.print("Ingrese componente:"); mat[f][c]=teclado.nextint(); public void imprimir() { for(int f=0;f<3;f++) { for(int c=0;c<5;c++) { System.out.print(mat[f][c]+" "); System.out.println(); public static void main(string[] ar) { Matriz1 ma=new Matriz1(); ma.cargar(); ma.imprimir(); Para definir una matriz debemos antecederle los corchetes abiertos y cerrados dos veces: private int[][] mat; De esta forma el compilador de Java puede diferenciar los vectores de las matrices. Para crear la matriz, es decir hacer la reserva de espacio de todas sus componentes debemos utilizar el operador new y mediante dos subíndices indicamos la cantidad de filas y columnas que tendrá la matriz: mat=new int[3][5]; Luego debemos pasar a cargar sus 15 componentes (cada fila almacena 5 componentes y tenemos 3 filas) Lo más cómodo es utilizar un for anidado, el primer for que incrementa el contador f lo utilizamos para recorrer las filas y el contador interno llamado c lo utilizamos para recorrer las columnas. Cada vez que se repite en forma completa el for interno se carga una fila completa, primero se carga la fila cero en forma completa, luego la fila uno y finalmente la fila 2. Siempre que accedemos a una posición de la matriz debemos disponer dos subíndices que hagan referencia a la fila y columna mat[f][c]): for(int f=0;f<3;f++) { for(int c=0;c<5;c++) { System.out.print("Ingrese componente:"); mat[f][c]=teclado.nextint(); Para imprimir la matriz de forma similar utilizamos dos for para acceder a cada elemento de la matriz: 58

60 for(int f=0;f<3;f++) { for(int c=0;c<5;c++) { System.out.print(mat[f][c]+" "); System.out.println(); Cada vez que se ejecuta todas las vueltas del for interno tenemos en pantalla una fila completa de la matriz, por eso pasamos a ejecutar un salto de línea (con esto logramos que en pantalla los datos aparezcan en forma matricial): System.out.println(); Matrices (cantidad de filas y columnas) Como hemos visto para definir y crear la matriz utilizamos la siguiente sintaxis: Creación: int[][] mat; mat=new int[3][4]; Como las matrices son objetos en Java disponemos por un lado del atributo length que almacena la cantidad de filas de la matriz: System.out.println("Cantidad de filas de la matriz:" + mat.length); También podemos preguntarle a cada fila de la matriz la cantidad de elementos que almacena: System.out.println("Cantidad de elementos de la primer fila:" + mat[0].length); Ejemplo2: Crear una matriz de n * m filas (cargar n y m por teclado) Imprimir la matriz completa y la última fila. import java.util.scanner; public class Matriz5 { private Scanner teclado; private int[][] mat; public void cargar() { teclado=new Scanner(System.in); System.out.print("Cuantas fila tiene la matriz:"); int filas=teclado.nextint(); System.out.print("Cuantas columnas tiene la matriz:"); int columnas=teclado.nextint(); mat=new int[filas][columnas]; for(int f=0;f<mat.length;f++) { for(int c=0;c<mat[f].length;c++) { System.out.print("Ingrese componente:"); 59

61 mat[f][c]=teclado.nextint(); public void imprimir() { for(int f=0;f<mat.length;f++) { for(int c=0;c<mat[f].length;c++) { System.out.print(mat[f][c]+" "); System.out.println(); public void imprimirultimafila() { System.out.println("Ultima fila"); for(int c=0;c<mat[mat.length-1].length;c++) { System.out.print(mat[mat.length-1][c]+" "); public static void main(string[] ar) { Matriz5 ma=new Matriz5(); ma.cargar(); ma.imprimir(); ma.imprimirultimafila(); 60

62 3.15 Constructor de la clase En Java podemos definir un método que se ejecute inicialmente y en forma automática. Este método se lo llama constructor. El constructor tiene las siguientes características: Tiene el mismo nombre de la clase. Es el primer método que se ejecuta. Se ejecuta en forma automática. No puede retornar datos. Se ejecuta una única vez. Un constructor tiene por objetivo inicializar atributos. Ejemplo1: Se desea guardar los sueldos de 5 operarios en un vector. Realizar la creación ingreso del vector en el constructor. import java.util.scanner; public class Operarios { private Scanner teclado; private int[] sueldos; public Operarios() { teclado=new Scanner(System.in); sueldos=new int[5]; for(int f=0;f<5;f++) { System.out.print("Ingrese el sueldo del operario:"); sueldos[f]=teclado.nextint(); public void imprimir() { for(int f=0;f<5;f++) { System.out.println(sueldos[f]); public static void main(string[] ar) { Operarios op=new Operarios(); op.imprimir(); 61

63 Como podemos ver es el mismo problema que resolvimos cuando vimos vectores. La diferencia es que hemos sustituido el método cargar con el constructor: public Operarios() { teclado=new Scanner(System.in); sueldos=new int[5]; for(int f=0;f<5;f++) { System.out.print("Ingrese el sueldo del operario:"); sueldos[f]=teclado.nextint(); Como la clase se llama Operarios el constructor tiene el mismo nombre, no disponemos la palabra clave void ya que el constructor no puede retornar datos. La ventaja de plantear un constructor en lugar de definir un método con cualquier nombre es que se llamará en forma automática cuando se crea un objeto de esta clase: public static void main(string[] ar) { Operarios op=new Operarios(); Cuando se crea el objeto op se llama al método constructor. Finalmente llamamos al método imprimir: op.imprimir(); Ejemplo2: Desarrollar una clase llamada Alumno y definir como atributos su nombre y su edad. En el constructor realizar la carga de datos. Definir otros dos métodos para imprimir los datos ingresados y un mensaje si es mayor o no de edad (edad >=18). import java.util.scanner; public class Alumno { private Scanner teclado; private String nombre; private int edad; public Alumno() { teclado=new Scanner(System.in); System.out.print("Ingrese nombre:"); nombre=teclado.next(); System.out.print("Ingrese edad:"); edad=teclado.nextint(); public void imprimir() { System.out.println("Nombre:"+nombre); System.out.println("Edad:"+edad); 62

64 public void esmayoredad() { if (edad>=18) { System.out.print(nombre+" es mayor de edad."); else { System.out.print(nombre+" no es mayor de edad."); public static void main(string[] ar) { Alumno alumno1=new Alumno(); alumno1.imprimir(); alumno1.esmayoredad(); Declaramos la clase Persona, sus tres atributos y definimos el constructor con el mismo nombre de la clase: public class Alumno { private Scanner teclado; private String nombre; private int edad; public Alumno() { teclado=new Scanner(System.in); System.out.print("Ingrese nombre:"); nombre=teclado.next(); System.out.print("Ingrese edad:"); edad=teclado.nextint(); En la main el constructor se llama en forma automática cuando creamos un objeto de la clase Alumno: public static void main(string[] ar) { Alumno alumno1=new Alumno(); Los otros dos métodos deben llamarse por su nombre y en el orden que necesitemos: alumno1.imprimir(); alumno1.esmayoredad(); 63

65 3.16 Colaboración de clases Normalmente un problema resuelto con la metodología de programación orientada a objetos no interviene una sola clase, sino que hay muchas clases que interactúan y se comunican. Plantearemos un problema separando las actividades en dos clases. Ejemplo1: Un banco tiene 3 clientes que pueden hacer depósitos y extracciones. También el banco requiere que al final del día calcule la cantidad de dinero que hay depositada. Lo primero que hacemos es identificar las clases: Clase Cliente y la Clase Banco. Luego debemos definir los atributos y los métodos de cada clase: Cliente Banco atributos o nombre o monto métodos o constructor o depositar o extraer o retornarmonto atributos o 3 Cliente (3 objetos de la clase Cliente) métodos o constructor o operar o depositostotales Creamos un proyecto en Eclipse llamado: Proyecto1 y dentro del proyecto creamos dos clases llamadas: Cliente y Banco. Código Clase Cliente public class Cliente { private String nombre; private int monto; public Cliente(String nom) { nombre=nom; monto=0; 64

66 public void depositar(int m) { monto=monto+m; public void extraer(int m) { monto=monto-m; public int retornarmonto() { return monto; public void imprimir() { System.out.println(nombre+" tiene depositado la suma de "+monto); Código Clase Banco public class Banco { private Cliente cliente1,cliente2,cliente3; public Banco() { cliente1=new Cliente("Juan"); cliente2=new Cliente("Ana"); cliente3=new Cliente("Pedro"); public void operar() { cliente1.depositar (100); cliente2.depositar (150); cliente3.depositar (200); cliente3.extraer (150); public void depositostotales () { int t = cliente1.retornarmonto () + cliente2.retornarmonto () + cliente3.retornarmonto (); System.out.println ("El total de dinero en el banco es:" + t); cliente1.imprimir(); cliente2.imprimir(); cliente3.imprimir(); public static void main(string[] ar) { Banco banco1=new Banco(); banco1.operar(); banco1.depositostotales(); 65

67 Analicemos la implementación del problema. Los atributos de una clase normalmente son privados para que no se tenga acceso directamente desde otra clase, los atributos son modificados por los métodos de la misma clase: private String nombre; private int monto; El constructor recibe como parámetro el nombre del cliente y lo almacena en el atributo respectivo e inicializa el atributo monto en cero: public Cliente(String nom) { nombre=nom; monto=0; Los métodos depositar y extraer actualizan el atributo monto con el dinero que llega como parámetro (para simplificar el problema no hemos validado que cuando se extrae dinero el atributo monto quede con un valor negativo): public void depositar(int m) { monto=monto+m; public void extraer(int m) { monto=monto-m; El método retornarmonto tiene por objetivo comunicar al Banco la cantidad de dinero que tiene el cliente (recordemos que como el atributo monto es privado de la clase, debemos tener un método que lo retorne): public int retornarmonto() { return monto; Por último el método imprimir muestra nombre y el monto de dinero del cliente: public void imprimir() { System.out.println(nombre+" tiene depositado la suma de "+monto); Como podemos observar la clase Cliente no tiene función main. Entonces donde definimos objetos de la clase Cliente? La respuesta a esta pregunta es que en la clase Banco definimos tres objetos de la clase Cliente. Veamos ahora la clase Banco que requiere la colaboración de la clase Cliente. Primero definimos tres atributos de tipo Cliente: public class Banco { private Cliente cliente1,cliente2,cliente3; En el constructor creamos los tres objetos (cada vez que creamos un objeto de la clase Cliente debemos pasar a su constructor el nombre del cliente, recordemos que su monto de depósito se inicializa con cero): 66

68 public Banco() { cliente1=new Cliente("Juan"); cliente2=new Cliente("Ana"); cliente3=new Cliente("Pedro"); El método operar del banco (llamamos a los métodos depositar y extraer de los clientes): public void operar() { cliente1.depositar (100); cliente2.depositar (150); cliente3.depositar (200); cliente3.extraer (150); El método depositostotales obtiene el monto depositado de cada uno de los tres clientes, procede a mostrarlos y llama al método imprimir de cada cliente para poder mostrar el nombre y depósito: public void depositostotales () { int t = cliente1.retornarmonto () + cliente2.retornarmonto () + cliente3.retornarmonto (); System.out.println ("El total de dinero en el banco es:" + t); cliente1.imprimir(); cliente2.imprimir(); cliente3.imprimir(); Por último en la main definimos un objeto de la clase Banco (la clase Banco es la clase principal en nuestro problema): public static void main(string[] ar) { Banco banco1=new Banco(); banco1.operar(); banco1.depositostotales(); Ejemplo 2: Desarrollar un programa que permita jugar a los dados. Las reglas de juego son: se tiran tres dados si los tres salen con el mismo valor mostrar un mensaje que "gano", sino "perdió". Lo primero que hacemos es identificar las clases: Clase Dado y la clase JuegoDeDados. Luego los atributos y los métodos de cada clase: Dado atributos o valor métodos o tirar 67

69 JuegoDeDados o imprimir o retornarvalor atributos o 3 Dado (3 objetos de la clase Dado) métodos o constructor o jugar Creamos un proyecto en Eclipse llamado: Proyecto2 y dentro del proyecto creamos dos clases llamadas: Dado y JuegoDeDados. Código Clase Dado public class Dado { private int valor; public void tirar() { valor=1+(int)(math.random()*6); public void imprimir() { System.out.println("El valor del dado es:"+valor); public int retornarvalor() { return valor; Código Clase JuegodeDados public class JuegoDeDados { private Dado dado1,dado2,dado3; public JuegoDeDados() { dado1=new Dado(); dado2=new Dado(); dado3=new Dado(); public void jugar() { dado1.tirar(); dado1.imprimir(); dado2.tirar(); dado2.imprimir(); dado3.tirar(); dado3.imprimir(); if (dado1.retornarvalor()==dado2.retornarvalor() && dado1.retornarvalor()==dado3.retornarvalor()) { 68

70 System.out.println("Ganó"); else { System.out.println("Perdió"); public static void main(string[] ar){ JuegoDeDados j=new JuegoDeDados(); j.jugar(); La clase dado define el atributo "valor" donde almacenamos un valor aleatorio que representa el número que sale al tirarlo. public class Dado { private int valor; El método tirar almacena el valor aleatorio para generar un valor aleatorio utilizamos el método random de la clase Math, el mismo genera un valor real comprendido entre 0 y 1, este valor generado multiplicado por 6 y antecediendo (int) obtenemos la parte entera de dicho producto: public void tirar() { valor=1+(int)(math.random()*6); Como vemos le sumamos uno ya que el producto del valor aleatorio con seis puede generar números enteros entre 0 y 5. El método imprimir de la clase Dado muestra por pantalla el valor del dado: public void imprimir() { System.out.println("El valor del dado es:"+valor); Por último el método que retorna el valor del dado (se utiliza en la otra clase para ver si los tres dados generaron el mismo valor): public int retornarvalor() { return valor; La clase JuegoDeDatos define tres atributos de la clase Dado (con esto decimos que la clase Dado colabora con la clase JuegoDeDados): public class JuegoDeDados { private Dado dado1,dado2,dado3; En el constructor procedemos a crear los tres objetos de la clase Dado: public JuegoDeDados() { dado1=new Dado(); dado2=new Dado(); dado3=new Dado(); 69

71 En el método jugar llamamos al método tirar de cada dado, pedimos que se imprima el valor generado y finalmente procedemos a verificar si se ganó o no: public void jugar() { dado1.tirar(); dado1.imprimir(); dado2.tirar(); dado2.imprimir(); dado3.tirar(); dado3.imprimir(); if (dado1.retornarvalor()==dado2.retornarvalor() && dado1.retornarvalor()==dado3.retornarvalor()) { System.out.println("Ganó"); else { System.out.println("Perdió"); En la main creamos solo un objeto de la clase principal (en este caso la clase principal es el JuegoDeDados): public static void main(string[] ar){ JuegoDeDados j=new JuegoDeDados(); j.jugar(); 70