¡Descarga Apuntes sobre el Lenguaje de Programacion Java Parte1 y más Apuntes en PDF de Informática solo en Docsity!
EL LENGUAJE DE PROGRAMACION
JAVA
AUTOR:
ING. RAUL CORDOVA, M.Sc. FEBRERO − 2000 I. FUNDAMENTOS DE JAVA
1. Enunciados y expresiones - Un enunciado es lo más sencillo que hay en Java; cada uno forma una sola operación Java. - Ejemplos: int i = 1; import java.awt.Font; System.out.println(Esta moto es una + color + + fabricante); m.engineState 0 true; - Algunos enunciados regresan valores. Este tipo de enunciados se denominan expresiones. - Cada enunciado termina en punto y coma. Existen enunciados compuestos o bloques, los cuales pueden colocarse en cualquier lugar donde pondría un solo enunciado.
- Los enunciados de bloque están rodeados por llaves. 2. Variables y tipos de datos
- Variables son lugares en la memoria donde pueden guardarse valores.
- Poseen un nombre, un tipo y un valor.
- Antes de usar una variable, primero se la debe declarar y a partir de ahí es factible asignarle valores.
- Java posee tres clases de variables: de instancia, de clase y locales.
- Las variables de instancia se utilizan para definir atributos o el estado de un objeto en particular. Las variables de clase son similares a las de instancia, con la diferencia de que sus valores se aplican a todas las instancias de clase (y a la misma clase), en lugar de tener diferentes valores para cada objeto.
Las variables locales se declaran y utilizan dentro de las definiciones de método, por ejemplo, para contadores de índica en ciclos, como variables temporales, o para guardar valores que sólo se necesitan dentro de la definición.
También pueden usarse dentro de bloques. Una vez que el método o bloque termina su ejecución, la definición de variable y su valor dejan de existir.
Se recomienda utilizar variables locales para guardar la información necesitada por un solo método y las variables de instancia para guardar la información requerida por varios métodos en el objeto.
Declaración de variables
- Consisten en un tipo y nombre de variable. Ejemplo: int myAge; String myName; boolean isTired; Las definiciones de variables pueden ubicarse en cualquier lugar de la definición del método (es decir, en cualquier lugar donde pueda ubicarse un enunciado normal de Java), aunque por lo común, se declaran al inicio de la definición, antes de utilizarse:
public static void main (String args[]) { int count; String title; boolean isAsleep; ... } Puede encadenar nombres de variables con el mismo tipo: int x,y,z; String firstName, LastName; También puede dar a cada variable un valor inicial cuando la declare: int myAge, mySize, numShoes = 28; String myName = Gina; boolean isTired = true; int a = 4, b = 5, c = 6; Si existen variables múltiples en la misma línea y sólo una está inicializada, el valor inicial se aplica sólo a la última variable en una declaración.
También se pueden agrupar en la misma línea variables individuales e inicializadas si se utilizan comas, como en el último ejemplo.
Se deben dar valores a las variables locales antes de utilizarlas, sino el programa en Java no se compilará ). Por esta razón, siempre es recomendable dar valores iniciales a las variables locales.
Las definiciones de variables de instancia y de clase no tienen esta restricción: su valor inicial depende del tipo de variable: null para instancias de clase, 0 para variables numéricas, `' para caracteres y false para booleanas.
Nombres de variables
short 16 bits −32.768 a +32. int 32 bits −2.147.483.648 a +2.147.483. long 64 bits −9.223.372.036.854.775.808 a +9.223.372.036.854.775. Los números de punto flotante se utilizan para valores con una parte decimal. Estos cumplen con el estándar IEEE754 (un estándar internacional para definir números de punto flotante y su aritmética).
Existen dos tipos de punto flotante: float (32 bits, precisión sencilla) y double (64 bits, doble precisión).
El tipo char se utiliza para caracteres individuales. Puesto que Java emplea el conjunto de caracteres Unicode, el tipo char tiene 16 bits de precisión, sin signo.
El tipo boolean puede tener uno de dos valores: true o false. Advertirá que a diferencia de otros lenguajes similares a C, boolean no es un número, ni tampoco puede tratarse como si lo fuera.
Además de los 8 tipos de datos básicos, las variables en Java también pueden declararse para mantener una instancia de una clase en particular:
String apellido; Font fuenteBásica; OvalShape myOval; Cada una de estas variables sólo puede mantener instancias de una clase dada. Al crear nuevas clases también se pueden declarar variables para mantener instancias de esas clases (y sus subclases).
En Java, para declarar nuevos tipos de datos, primero se debe declarar una clase nueva y después las variables pueden declararse para que sean de ese tipo de clase.
ASIGNACION DE VALORES A VARIABLES
- Se usa el operador de asignación = : tamaño = 14; matriculado = true; Comentarios
- En Java se tienen tres tipos: /* / para varias líneas // para una sola línea /* */ usada en javadoc para generar documentación API del código. Literales Se usan para indicar valores en los programas. Literales de número
- Existen varias literales de enteros: Entera decimal de tipo int. Ej. 4 (puede ser también byte o short) Entera decimal más grande que int es en forma automática long. Un número pequeño a long, se agrega una L o l al final del número: 4L Enteros negativos están precedidos por un signo menos: − Enteros octales: empiezan con cero. Ej. 0777 ó 0004. Enteros hexadecimales: empiezan con 0x ó 0X. Ej. 0xFF, 0XAF45. Pueden contener dígitos normales (0−9) o hexadecimales en mayúsculas o minúsculas (a−f o A−F). Literales de punto flotante tienen dos partes: entera y decimal. Ej. 5.6777777. Las literales de punto flotante resultan en un número de punto flotante de tipo double sin importar la precisión de ese número. Se puede forzar el número al tipo float al agregar la letra f (o F) al número. Ej: 2.56F. Se pueden también usar exponentes en las literales de punto flotante usándose e o E, seguida del exponente, positivo o negativo. Ej. 10e45, .36E−2. Literales booleanas Consisten en las palabras clave true o false, las cuales se pueden usar en cualquier lugar en que se necesite hacer una prueba o como los únicos valores posibles para variables booleanas.
Literales de número
- Se expresan por un solo carácter entre comillas sencillas:
a',#', `3'. - Se guardan como caracteres Unicode de 16 bits.
- En Java también se tienen códigos especiales, no imprimibles o Unicode. TABLA: Códigos de escape de caracteres. Escape Significado \n Línea nueva \t Tabulador \b Retroceso \r Regreso de carro \f Alimentación de forma \ Diagonal inversa ' Comilla sencilla
Cada operador toma dos operandos, uno a cada lado del operador. El operador de resta (−) puede usarse para negar un operando sencillo.
- La división de enteros resulta en un entero y el residuo se ignora. Ej: 31/9 da 3.
- El módulo proporciona el residuo de una división entera. 31%9 da 4.
- Un entero operado con otro entero da un entero.
- Si un operando es long, el resultado será long.
- Si un operando es entero y otro de punto flotante, el resultado será de punto flotante. Programa de ejemplo: class PruebaAritmética { public static void main (String args[ ]) { short x = 6; int y = 4; float a = 12.5f; float b = 7f; System.out.println(x es + x + , y es + y); System.out.println(x − y = + (x − y)); System.out.println(x * y = + (x * y)); System.out.println(x / y = + (x / y)); System.out.println(x % y = + (x % y)); System.out.println(a es + a + , b es + b; System.out.println(a / b = + (a / b)); } } Resultado: x es 6, y es 4 x + y = 10 x − y = 2 x * y = 24 x / y = 1
x % y = 2 a es 12.5, b es 7 a / b = 1. HERENCIA, INTERFACES Y PAQUETES
- Son mecanismos para organizar clases y el comportamiento de la clase. HERENCIA Con la herencia, todas las clases, las que se programan, las de otras bibliotecas que se utilicen y también las clases de la utilería estándar, están arregladas dentro de una jerarquía estricta.
Cada clase tiene una superclase (la clase superior en la jerarquía) y puede tener una o más subclases (las clases debajo de esa clase en la jerarquía).
- Las clases inferiores en la jerarquía heredan de las clases más altas. Las subclases heredan todos los métodos y variables de las superclases, con lo que no se requiere volver a definir o copiar ese código de alguna otra clase.
- En la parte superior de la jerarquía de clase Java está la clase Object.
- Todas las clases heredan de esta superclase. Es la clase más general en la jerarquía, ya que define el comportamiento heredado por todas las clases en la jerarquía de clase Java.
Cada clase hacia abajo en la jerarquía agrega más información y se vuelve más apta para un propósito específico.
Cuando se escriben nuevas clases Java, por lo general se deseará crear una clase que tenga toda la información que otra clase tiene, además de alguna información extra.
Por ejemplo, tal vez se desee una versión de un Button con su propia etiqueta integrada. Para obtener toda la información de esta clase, lo que debe hacer es definir la clase que hereda de la clase Button.
La nueva clase, en forma automática obtendrá el comportamiento definido en Button (y en las superclases de ésta), así que su única preocupación deben ser los elementos que diferencian a su clase de la clase Button original.
Este mecanismo utilizado para definir nuevas clases así como las diferencias entre ellas y sus supeclases, se llama subclasificación.
La subclasificación implica crear una nueva clase que heredará de alguna otra clase en la jerarquía. Al usar la subclasificación, sólo se necesitarán definir las diferencias entre esta clase y su padre; el comportamiento adicional está disponible para la nueva clase mediante la herencia.
Si una clase define un comportamiento nuevo por completo y no es en sí una subclase de otra clase, también puede heredar directamente de Object, y todavía se permite ajustarse con habilida a la jerarquía de clase Java.
De hecho, si se crea una definición de clase que no indica su superclase en la primera línea, Java de manera automática supone que está heredando de Object.
- La clase Motorcycle que se creó anteriormente, heredaba de esta clase. CREACION DE UNA JERARQUÍA DE CLASES Si se va crear un conjunto más grande de clases, tiene sentido que estas clases no sólo hereden de la jerarquía de clases existente, sino que también hagan por sí mismas una jerarquía.
Esto puede implicar una planeación previa al intentar organizar el código Java, aunque las ventajas son significativas una vez que ésta se realiza:
- Cuando se desarrollan clases en una jerarquía, se puede descomponer información común para
- Aquí se creó una clase llamada HelloAgainApplet. La parte que dice extends java.applet.Applet , indica que la clase de applet creada es una subclase de la clase Applet.
Ya que la clase Applet está dentro del paquete java.applet, no se tendrá acceso automático a esa clase y se tendrá que referirse a ella en forma explícita por paquete y nombre de clase.
La otra parte de esta definición de clase es la palabra clave public. Significa que la clase creada está disponible para todo el sistema Java después de que se cargó.
En la mayoría de ocasiones, se necesitará hacer una clase public sólo si se desea que sea visible para todas las demás clases del programa Java, aunque los applets, en particular, deben declararse como públicos.
- Incorporemos una variable de instancia para contener a un objeto Font: Font f = new Font(TimesRoman, Font.BOLD, 36); La variable de instancia f ahora contiene una nueva instancia de la clase Font que forma parte del paquete java.awt. Este objeto fuente en particular es una fuente Times Roman, en negritas y de 36 puntos de altura.
Al crear una variable de instancia para guardar este objeto fuente, lo vuelve disponible para todos los métodos en su clase. Ahora vamos a crear un método que lo utilice.
Cuando escribe applets, hay varios métodos estándares definidos en las superclases del applet que por lo común sobrepondrá en la clase de su applet. Estos incluyen métodos para inicializar el applet, para empezar su ejecución, para manejar operaciones como movimientos o clics del ratón, o para limpiar el espacio cuando el applet detenga su ejecución.
Uno de estos métodos estándares es paint(), el cual de hecho despliega su applet en la pantalla. La definición predeterminada de paint() no efectúa nada: es un método vacío. Al sobreponer este método, le indica al applet qué debe dibujar en la pantalla.
- Veamos una definición de paint(): public void paint(Graphics g) { g.setFont(f); g.setColor(Color.red); g.drawString(Hello again!, 5, 25); } Respecto al método paint(), obsérvese que está declarado como public, al igual que el applet mismo. Este método es así por un motivo diferente: a causa de que el método al que sobrepone está declarado de la misma forma. Si un método de una superclase está definido como público, el método que lo sobrepone también debe ser público o, de lo contrario, tendrá un error cuando compile la clase.
En segundo lugar, el método paint() toma un solo argumento: una instancia de la clase Graphics. Esta clase tiene un comportamiento independiente de la plataforma para presentar fuentes, colores y operaciones de dibujo básicas.
- Dentro del método paint(), se realizaron tres actividades: Se le indicó al objeto gráficos que la fuente de dibujo predeterminada sería la contenida en la variable de instancia f.
Se le indicó al objeto gráficos que el color prederminado es una instancia de la clase Color para el color rojo.
- Por último, se dibujó la cadena Hello Again! en la pantalla, en las posiciones x y de 5 y 25.
- Para un applet tan sencillo, esto es todo lo que necesita hacer. Aquí está la apariencia del applet hasta
ahora: public class Hello AgainApplet extends java.applet.Applet { Font f = new Font(TimesRoman, Font.BOLD,26); public void paint (Graphics g) { g.setFont(f); g.setColor(Color.red); g.drawString(Hello again!, 5, 50); } } Para poder usar Graphics, Font y Color, es necesario importarlas al inicio del archivo de clase, antes de la definción de clase.
import java.awt.Graphics; import java.awt.Font; import java.awt.Color; También se puede importar un paquete completo de clases (public), al utilizar un asterisco (*) en lugar del nombre de la clase específica. Por ejemplo, para importar todas clases en el paquete awt, se puede usar esta línea:
import java.awt.*;
- La clase completa lucirá entonces así: import java.awt.Graphics; import java.awt.Font; import java.awt.Color; public class Hello AgainApplet extends java.applet.Applet { Font f = new Font(TimesRoman, Font.BOLD,26); public void paint (Graphics g) { g.setFont(f); g.setColor(Color.red); g.drawString(Hello again!, 5, 50);
public static void main (String args[ ]) { Date d1,d2, d3; d1 = new Date(); System.out.println(Fecha 1: + d1); d2 = new Date(71,7,1,7,30); System.out.println(Fecha 2: + d2); d3 = new Date(April 3 1993 3:24 PM); System.out.println(Fecha 3: + d3); } } SALIDA: Fecha 1: Tue Feb 13 09:36:56 PST 1996 Fecha 2: Sun Aug 01 07:30:00 PDT 1971 Fecha 3: Sat Apr 03 15:24:00 PST 1993 Aquí se dan tres maneras diferentes de instanciar a la clase Date, utilizando diferentes argumentos para new.
Esto es posible gracias a que se han definido tres métodos diferentes para instanciar a la clase Date, cada uno de los cuales se llama constructor.
- El uso de new hace que, primero, se cree la nueva instancia de la clase dada y se le asigna memoria. Luego, cuando se crea un nuevo objeto, se llama a un método especial definido en la clase dada, llamado constructor.
- Los constructores son métodos especiales para crear e inicializar nuevas instancias de clase. Inicializan el nuevo objeto y sus variables, crean cualquier otro objeto que se necesite y pueden realizar cualquier otra operación para inicializarse a sí mismos.
Cada definición de constructor puede tener un número diferente o tipos de argumentos diferentes; así, cuando se utilice new se puede especificar diferentes argumentos en la lista de argumentos y se llamará al constructor adecuado para esos argumentos.
ADMINISTRACION DE MEMORIA EN JAVA
Es dinámica y automática. Cuando se crea un nuevo objeto, éste, en forma automática destina la cantidad adecuada de memoria para ese objeto en la pila.
El programador no tiene que asignar memoria para algún objeto en forma explícita, pues el lenguaje lo hace por sí mismo.
Cuando se deja de usar el objeto, ya no contará con referencias a ese objeto: la administración de la memoria es automática.
Java, para hacer esto, cuenta con un colector de basura que localiza objetos no usados y libera la memoria que emplearon esos objetos.
- No es necesario hacer una liberación explícita de memoria. ACCESO CONFIGURACIÓN DE VARIABLES DE INSTANCIA Y DE CLASE Las variables de instancia se comportan de la misma forma que las locales, pero para referirse a ellas, se usará una notación punto.
Obtención de valores de variables de instancia Se usa la notación punto, en la cual un nombre de variable de instancia o de clase tendrá dos partes: el objeto, al lado izquierdo del punto y la variable, al lado derecho.
- Ej: myObject.var;
- Esta forma de accesar a las variables es una expresión (regresa un valor). Se puede anidar el acceso a las variables de instancia. Si var mantiene un objeto y éste tiene su propia variable de instancia llamada state, se puede referir a ella de esta manera:
myObject.var.state; Las expresiones de punto se evalúan de izquierda a derecha, así que se debe empezar con la variable var de myObject, la cual se dirige a otro objeto con la variable state. Al final se tendrá el valor de esa variable.
Cambio de valores
- Sólo se inserta un operador de asignación al lado derecho de la expresión: myObject.var.state = true; Ejemplo: este programa prueba y modifica las variables de instancia de un objeto Point, el cual es parte del paquete java.awt y se refiere a un punto de coordenadas con valores x Y y. import java.awt.Point; class TestPoint { public static void main (String args[ ]) { Point elPunto = new Point(10,10); System.out.println(X es + elPunto.x); System.out.println(Y es + elPunto.y); System.out.println(Seteando X a 5.); elPunto.x = 5; System.out.println(Seteando Y a 15.); elPunto.y = 15; System.out.println(X es + elPunto.x);
FamilyMember dad = new FamilyMember(); System.out.println(El apellido de la familia es: + dad.surname); System.out.println(El apellido de la familia es: + FamilyMember.surname); Como al utilizar una instancia se puede cambiar el valor de una variable de clase, es fácil confundirse con las variables de clase y el origen de sus valores.
Por esta razón, es una buena idea usar el nombre de la clase siempre que se refiera a una variable de clase, lo cual hace al código más fácil de leer y es más sencillo de depurar cuando se presentan resultados extraños.
LLAMADA A LOS METODOS
- Llamar a un método en los objetos es similar a referirse a sus variables de instancia.
- Las llamadas a los métodos también utilizan la notación de punto. El objeto cuyo método se llama, está al lado izquierdo del punto, y el nombre del método y sus argumentos están al lado derecho del punto:
myObject.methodOne(arg1, arg2, arg3);
- Todos los métodos deben tener paréntesis enseguida aun si el método no tiene argumentos: myObject.methodNoArgs(); A su vez, si el método que llamó resulta ser un objeto que cuenta con otros métodos, se los puede anidar como con las variables:
myObject.getClass().getName(); También se pueden combinar llamadas a métodos anidados y también referencias a variables de instancia:
myObject.var.methodTwo(arg1, arg2);
- El método System.out.println() es un buen ejemplo de la anidación de variables y métodos.
- La clase System, parte del paquete java.lang, describe el comportamiento específico del sistema. System.out es una variable de clase que contiene una instancia de la clase PrintStream, que apunta a la salida estándar del sistema. Estas instancias cuentan con un método println() que imprime una cadena a ese flujo de salida.
- El siguiente ejemplo muestra algunos métodos definidos en la clase String. Las cadenas incluyen métodos para pruebas y modificación, similares a las bibliotecas de este tipo en otros lenguajes.
Class TestString { public static void main (String args[ ]) { String str = Hoy es la época de vacaciones; System.out.println(La cadena es: + str);
System.out.println(La longitud de esta cadena es: + str.length); System.out.println(El carácter en la posición 5 es: + str.charAt(5)); System.out.println(La subcadena desde el carácter 11 hasta el 17 es: + str.substring(11,17)); System.out.println(La posición del carácter v es: + str.indexOf(`v')); System.out.print (El índice del inicio de la ); System.out.println(subcadena \época\ es: + str.indexOf(época)); System.out.println(La cadena en mayúsculas es: + str.toUpperCase()); } } Métodos de Clase
- Se aplican a la clase y no a sus instancias. Por lo común, son utilizados por los métodos de utilería que pueden no operar en forma directa en una instancia de esa clase, pero se adecuan a la clase de manera conceptual.
Por ejemplo, la clase String contiene un método de clase llamado valueOf(), que puede tomar uno de varios tipos diferentes de argumentos (enteros, booleanos y otros objetos).
Este método regresa entonces a una nueva instancia de String que contiene el valor de la cadena del argumento que se dio.
Este método no opera de modo directo en una instancia existente de String, aunque obtener una cadena de otro objeto o tipo de dato es, en definitiva, una operación de cadena y tiene sentido definirla en la clase String.
Los métodos de clase también pueden ser útiles para conjuntar métodos generales en un lugar (la clase).
Por ejemplo, la clase Math, definida en el paquete java.lang, contiene un conjunto muy grande de operaciones matemáticas, como métodos de clase; no existen instancias de la clase Math, pero aún puede usar sus métodos con argumentos numéricos o booleanos.
- Para llamar a un método de clase, se utiliza la notación punto. Al igual que con las variables de clase, se puede usar una instancia de clase o la clase misma, a la izquierda del punto.
Sin embargo, emplear el nombre de la clase para estas variables hace que su código sea más fácil de leer.
- Las últimas dos líneas en el siguiente ejemplo producen el mismo resultado:
