Java Introducción Lenguaje

EstucturasEstucturas de Datosde Datos PPááginagina 11
Unidad I
Tema 2: Introducción a Java
Profesor: Jorge Escalona / Tobías Bolívar
Email: escaljorge@gmail.com / tobiasbolivar@gmail.com
Página Web: http://estructuradatos.tripod.com

Unidad I: La TecnologUnidad I: La Tecnologíía Javaa Java
Qué es Java?
De acuerdo a la información proporcionada por Sun
Microsystems (http://java.sun.com), java es:
[un] lenguaje simple, orientado a objetos, distribuido,
interpretado, sólido, seguro, de arquitectura neutral, de
alto desempeño, de multihilos y dinámico.

• Simple: basado en C++, pero sin muchas de las características más tediosas
de éste.
– Java no ofrece soporte a los tipos de datos punteros ni a la herencia múltiple.
– Java no ofrece soporte ni a typedef ni a #define.
– Java tiene un sistema automático para asignación y liberacion de memoria
(recolección de basura).
– Java tiene una clase String como parte de sus tipos básicos.
• Orientado a objetos: provee una clara y eficiente tecnología para soportar
las principales características de un lenguaje orientado a objetos.
– Encapsulación.
– Polimorfismo.
– Herencia.
Qué es Java?

• Distribuido: diseñado específicamente para trabajar en un ambiente de
redes, con una biblioteca muy grande para la programación utilizando el grupo
de protoolos TCP/IP.
• Interpretado: el compilador de Java traduce un archivo fuente a códigos de
byte (bytecodes), el cuál se puede ejecutar en cualquier máquina en la cual se
haya instlado el interpretador y la plataforma de ejecución de Java.
• Sólido: implementa una tipificación rigurosa y elimina el manejo de
apuntadores que puedan dañar fácilmente la memoria. Además, soporta
diferentes niveles de verificación de errores, tanto en tiempo de compilación
como en tiempo de ejecución.
Qué es Java?

• Seguro: diseñado para ejecutarse en ambientes distribuidos, por lo cual
incorpora diferentes niveles de seguridad que restringen el acceso y la
ejecución indebida de archivos.
• Arquitectura neutral: el código de bytes generado es ejecutado por el
interpretador de java, lo cual lo hace independiente de la plataforma.
• Portable: debido su arquitectura neutral, se permite una gran capacidad de
portabilidad, además de se estandarizan todos los tipos de datos básicos que
en algunos sistemas pueden diferir.
Qué es Java?

• De alto desempeño: soporta diversas características que le permiten un
rendimiento tan alto como cualquier compilador nativo, sin sacrificar la
robustez y seguridad.
• multihilos: se puede utilizar para crear aplicaciones que implementen más
de una cosa a la vez,a través de un sistema multihilos (multithreading), ideal
para apoyar los programas que se ejecuten en tiempo real.
• Dinámico: utiliza un método de interfaces que permite que nuevos métodos
y variables de instancias en una biblioteca de objetos, sin afectar los objetos
clientes dependientes.
Qué es Java?

•Permite crear tres tipos distintos de aplicaciones:
–Aplicaciones ordinarias (standalone).
–Applets.
–Más recientemente:
–Servlets.
–JavaBeans
–Páginas JSP
–Enterprise JavaBean
Qué es Java?

•La fundamental es el JDK de Sun (¡¡gratis!!).
•Existen multitud de entornos de desarrollo de otros fabricantes.
•Existen versiones del JDK para diferentes plataformas:
–Linux, Win95+,/NT, Solaris, MacOS, ...
•El JDK se renueva cada poco tiempo.
Herramientas de Desarrollo

Contenido del Java SDK 1.3

•Principales herramientas del SDK
•El compilador: javac.exe
•El depurador: jdb.exe
•El intérprete: java.exe y javaw.exe
•El visualizador de applets: appletviewer.exe
•El generador de documentación: javadoc.exe
•Un desensamblador de clases: javap.exe
•El generador de archivos fuentes y de cabecera (.c y .h)
para clases nativas en C: javah.exe

•A partir del subdirectorio principal
•Deberemos incluir el subdirectorio bin
en el PATH
•Especial importancia a la variable de
entorno CLASSPATH
•No descomprimir el archivo
classes.zip
Contenido del Java SDK 1.3

Compilación y Ejecución de un programa en Java
C:javajavac myProgram.java
C:javajava myProgram
JVM

Unidad I: CaracterUnidad I: Caracteríísticas del Lenguajesticas del Lenguaje
Programa “Hola Mundo”
class Hola {
public static void main(String argumentos[]) {
System.out.println("hola, mundo");
}
}
•El programa se inicia llamando al método main de la clase principal.
•El nombre de la clase principal es el mismo que el del archivo fuente:
–Hola.java
Ejemplo: Bienvenido.java

• public: indica que el método main es público y, por tanto, puede ser
llamado desde otras clases.
• static: indica que la clase no necesita ser instanciada para poder
utilizar el método al que califica.
• void: indica que la función main no devuelve ningún valor.
• El método main debe aceptar siempre, como parámetro, un vector de
Strings, que contendrá los posibles argumentos que se le pasen al
programa en la línea de comandos, aunque como es nuestro caso, no
se utilice.
Programa “Hola Mundo” – El código

• El método println es un método estático de la clase System (no hace
falta declarar un objeto de esa clase para usarlo).
• El atributo out hace referencia a la salida estándar, así el println
escribe por ella (la cadena que le pasamos y un final de línea).
System.out.println(“Hola, mundo”);

Unidad I: ProyectosUnidad I: Proyectos
• Un proyecto puede tener varios archivos.
• Cada archivo puede tener varias clases.
• El compilador genera un archivo .class para cada clase.
• Para ejecutarlo, llamamos al intérprete y le pasamos el
nombre de la clase principal:
java Hola
Compilación de un proyecto
Ejemplo: Error.java

• java.lang: clases esenciales, números, strings, objetos, compilador,
runtime, seguridad y threads (se incluye automáticamente en todo
programa Java)
• java.io: clases que manejan entrada y salida.
• java.net: clases para el soporte de redes (URL, TCP, UDP, IP, FTP,
etc).
• java.awt: clases para manejo de interfaces gráficas, ventanas, etc.
• java.awt.image : clases para el manejo de imágenes.
• java.awt.peer: clases para el manejo de interfaces gráficas
dependientes de la plataforma (motif, windows).
• java.applet: clases para la creación de applets y recursos para
reproducción de audio.
Bibliotecas básicas de Java

Tipo Descripción Tamaño/Formato
Byte Entero de un byte 8-bits complemento 2
Short Entero corto 16-bits complemento 2
Int Entero 32-bits complemento 2
Long Entero largo 64-bits complemento 2
Float Punto flotante, precisión simple 32-bits IEEE 754
Double Punto flotante, precisión doble 64-bits IEEE 754
Char 16-bit carácter Unicode 16-bits carceter Unicode
Boolean Valor booleano True o False
Tipos de Datos Simples

•Los tipos simples anteriores son "envueltos" por clases equivalentes
(java.lang.Integer, java.lang.Double, java.lang.Byte, etc.) , que pueden
tratarlos como si fueran objetos en lugar de datos simples.
•A diferencia de otros lenguajes de programación como el C, en Java los
tipos de datos simples no dependen de la plataforma ni del sistema
operativo. Un entero de tipo int siempre tendrá 4 bytes.
Tipos de Datos Simples
Ejemplo: AB.java
TipoBoolean.java

Tipos de Datos Referencias
•Arreglos
•Clases
•Interfaces
Nota: Las referencias son elementos de datos cuyo valor es una dirección de
memoria. En otros lenguajes son llamados apuntadores. En java no se permite
explícitamente acceder directamente a las posiciones de memoria a las cuales
hacen referencia, sólo se pueden accesar a a través del nombre de variable.
Nota: Las referencias son elementos de datos cuyo valor es una dirección de
memoria. En otros lenguajes son llamados apuntadores. En java no se permite
explícitamente acceder directamente a las posiciones de memoria a las cuales
hacen referencia, sólo se pueden accesar a a través del nombre de variable.

Nombres de Variables
• Deben comenzar con una letra seguida por cualquier carácter
Unicode.
• No hay límites en cuanto a la longitud del nombre de variable.
• No se puede utilizar una palabra clave, ni las literales booleanas
true o false, ni la palabra reservada null.
• Debe ser única dentro del alcance que se está definiendo.
Nota: por convención, los nombres de variables comienzan con una letra minúscula, y los nombres
de clases con letras mayúsculas. Si el nombre de variable consiste de más de una palabra, se
escriben una despué de la otra, y cada palabra después de la primera se inicia con una mayúscula.
Aunque el caracter “underscore” ( _ ) es válido, por convención sólo se utiliza para separar palabras
en nombres de constantes, ya que estas se escriben en mayúsculas.
Ejemplo de tipos simples: valor, cantRegistros, esVisible.
Ejemplo para clases : Animales, AnimalesVertebrados.

Alcance de Variables

// enteros
byte maximoByte = Byte.MAX_VALUE;
short maximoShort = Short.MAX_VALUE;
int maximoInteger = Integer.MAX_VALUE;
long maximoLong = Long.MAX_VALUE;
// números reales
float maximoFloat = Float.MAX_VALUE;
double maximoDouble = Double.MAX_VALUE;
// otros tipos simples
char unCaracter = 'S';
boolean unBoolean = true;
Inicialización de Variables

Variables Finales (Constantes)
final int varConstante = 0;
final int constanteVacia;
. . .
constanteVacia = 0;

Operadores
•Aritméticos: +,-,*,/,%,++,--
•Relacionales: <,>, <=, >=, ==, !=
•Condicionales: &&, ||, !,&,|,^
•Lógicos Binarios: >>,<<,&,|,^
•Asignaciones: =, +=, -=, *=, /=, %=, &=, |=, ^=,>>=, <<=
•Otros: ?:, ( parametros), (tipo),., [ ], new, instanceof
Ejemplo: Operadores.java
Prioridad.java

Estructuras de Control
•Repetitivas: while, do-while, for
•Condicionales: if-else, switch-case
•Bifurcaciones: break, continue, label:, return
•Manejo de Exepciones: try-cath-finally, throw

Estructuras de Control Repetitivas:
while (expresion) {
instrucción(es)
}
do {
instrucción(es)
} while (expresión);
for (inicialización; terminación; incremento) {
instrucción(es)
}

if (expresión) {
instruccion(es)
}
Estructuras de Control Condicionales:
if (expresion) {
// instrucción(es)
}
else {
// instrucción(es)
}
if (expresion) {
// instrucción(es)
}
else if {
// instrucción(es)
}
else if {
// instrucción(es)
}
else {
// instrucción(es)
}
Formato 1:
Formato 2:
Formato 3:

switch (integer expression) {
case integer expression:
instruccion(es)
break;
...
default:
instruccion(es)
break;
}

Inicio bloque {
instrucción(es);
[continue;]
[break;]
[return;]
[return valor];
}
label:etiqueta
Inicio bloque {
instrucción(es);
[continue etiqueta;]
[break etiqueta;]
}
Ejemplo: Bucles.java
DoWhile.java

• Se reserva memoria al hacer new al instanciar un
objeto.
• Existe un "recolector de basura" que libera
automáticamente la memoria no usada por objetos
extinguidos.
• Las variables simples no son objetos, pero los vectores
si.
Gestión de Memoria:

try {
instruccion(es)
}catch (nombre tipoexcepcion) {
instruccion(es)
}finally {
instruccion(es)
}
• try: identifica un bloque de instrucciones dentro del cual una excepción (error)
podría dispararse.
• catch: identifica un bloque de instrucciones que pueden manejar un tipo
específico de excepción. Las instrucciones se ejecutan sólo si se produce un
tipo particular de excepción dentro del bloque try al cual está asociado.
• finally: identifica un bloque de instrucciones que son ejecutadas
independientemente de que un error ocurra o no en el bloque del try.
Estructuras para el Manejo de Excepciones:
Formato:

leerArchivo{
abrir el archivo;
determinar su tamaño;
reservar la memoria necesaria;
leer el archivo en la memoria;
cerrar el archivo;
}
Manejo de Excepciones:
Separación del código regular del código para el manejo de las excepciones

leerArchivo {
try {
abrir el archivo;
determinar su tamaño;
reservar la memoria necesaria;
leer el archivo en la memoria;
cerrar el archivo;
} catch (fileOpenFailed) {
hacerAlgo;
} catch (sizeDeterminationFailed) {
hacerAlgo;
} catch (memoryAllocationFailed) {
hacerAlgo;
} catch (readFailed) {
hacerAlgo;
} catch (fileCloseFailed) {
hacerAlgo;
}
}
Separación del código regular del código para el manejo de las excepciones

metodo1 {
llamar a metodo2;
}
metodo2 {
llamar a metodo3;
}
metodo3 {
llamar a leerArchivo;
}
Propagación de errores hacia arriba en la pila de llamadas

metodo1{
try {
llamar a metodo2;
} catch (exception) {
procesarError;
}
}
metodo2 throws exception {
llamar a metodo3;
}
metodo3 throws exception {
llamar a leerArchivo;
}
Propagación de errores hacia arriba en la pila de llamadas

Agrupación de errores por tipo (jerarquía de errores)

catch (InvalidIndexException e) {
. . .
}
catch (ArrayException e) {
. . .
}
catch (Exception e) {
. . .
}
Intercepta el error por
Índice del arreglo fuera de rango
Intercepta cualquier error
relacionado con el arreglo
Intercepta cualquier error
del programa
Agrupación de errores por tipo (jerarquía de errores)

Estructura de
una clase
Unidad I: Clases y HerenciaUnidad I: Clases y Herencia

Declaración de una clase

Declaración de las variables miembros de una clase

Nivel de acceso de los miembros de una clase
XXpackage
XXXXpublic
XX*Xprotected
Xprivate
otrosPaqueteSubclaseClaseNivel

Declaración de los métodos miembros de una clase

Estructura de un método de una clase
Partes de la declaración del método

• Son métodos especiales que sirven para inicializar una instancia de esa clase
(objeto).
• Tienen el mismo nombre que la clase.
• Sintaxis:
<modificador> <nombre_clase> ([<lista_argumentos>]) {
[<instrucciones>]
}
• Podemos tener varios constructores en la misma clase que difieran en la lista
de parámetros.
• Invocación:
Hola h=new Hola();
Métodos Constructores

Métodos Constructores (Constructor por defecto)
• Hay siempre al menos un constructor en cada clase.
• Si el programador no suministra ningún constructor, el constructor por
defecto es incluido automáticamente:
•El constructor por defecto no tiene argumentos.
•El constructor por defecto no tiene instrucciones.
• Permite al usuario de la clase crear instancias de objetos con el
operador new Xxx () sin que el programador tenga que escribir un
constructor.

Accesando Atributos y Métodos
•Se utiliza la notación “punto”: <objeto>.<miembro>
•Utilizado para accesar tanto los atributos como los métodos del objeto.
•Dentro de los métodos de una clase no se necesita utilizar la notación “punto”
para accesar los miembros de esa misma clase.
•Ejemplos:
d.setWeight(80);
d.weight = 42; //válido si el atributo weight es público

Encapsulación
•El problema: Código cliente tiene acceso directo a datos internos de la clase:
MiFecha
+ dia
+ mes
+ anno
MiFecha d = new MiFecha();
d.dia = 32;
//día inválido
d.mes = 2; d.dia = 30;
//día inválido para ese mes
d.dia = d.dia + 1;
//no se verifica cambio de mes

•La Solución: Código cliente debe usar métodos de acceso para los datos
internos:
MiFecha d = new MiFecha();
d.setDia(32);
//día inválido; retorna false
d.setMes(2);
d.setDia(30);
//día inválido; retorna false
d.setDia(d.getDia() + 1);
//retorna false si ocurre cambio de mes
Encapsulación
MiFecha
- dia
- mes
- anno
+ getDia()
+ getMes()
+ getAnno()
+ setDia(int)
+ setMes(int)
+ setAnno(int)
- validarDia(int)
Valida día
según mes

Encapsulación
Oculta los detalles de la implementación
de una clase.
Fuerza al usuario a usar la interfaz pública
para accesar los datos.
Facilita el mantenimiento del código y la
detección de errores.
MiFecha
- dia
- mes
- anno
+ getDia()
+ getMes()
+ getAnno()
+ setDia(int)
+ setMes(int)
+ setAnno(int)
- validarDia(int)

Pase de parámetros a métodos
• El lenguaje Java sólo permite pasar argumentos por valor.
• Cuando una instancia de un objeto es pasada como argumento a
un método, el valor del argumento es una referencia al objeto.
• El contenido del objeto puede ser cambiado en el método invocado,
pero no la referencia.

El operador de referencia this
• Sirve para referenciar atributos
locales y métodos miembros
dentro de metodos o
constructores locales.
• La palabra reservada this
distingue una variable de un
método o constructor de una
instancia de una variable de la
clase.
• Sirve también para pasar el
objeto actual como un parámetro
a otro método o constructor.
Class MiFecha {
int dia = 1;
int mes = 1;
int anno = 2000;
public MiFecha(int dia,
int mes, int anno){
this.dia = dia;
this.mes = mes;
this.anno = anno;
}
public MiFecha(MiFecha fecha){
this.dia = fecha.getDia();
this.mes = fecha.getMes();
this.anno = fecha.getAnno();
}
...
}

Unidad I: Operaciones BUnidad I: Operaciones Báásicas de Entrada y Salidasicas de Entrada y Salida
Entrada/Salida por Consola
• System.out permite escribir a la “salida estándar”
•Declaración: public static final java.io.PrintStream out
• System.in permite leer desde la “entrada estándar”
•Declaración: public static final java.io.InputStream in
• System.err referencia a la salida de errores
•Declaración: public static final java.io.PrintStream err

Entrada/Salida por Consola
import java.io.*;
public class Consola{
public static void main(String[] args){
//Crea un bufer de lectura para leer cada linea desde el teclado.
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader teclado = new BufferedReader(isr);
//Variable auxiliar para leer desde el teclado
String cadLeida;
System.out.println(“Introduzca la base: “);
cadLeida = teclado.readLine();
int x = Integer.parseInt(cadLeida);
System.out.println(“Introduzca el exponente: “);
cadLeida = teclado.readLine();
int y = Integer.parseInt(cadLeida);
System.out.println(“x^y = “ + Math.pow(x,y));
}
}

Entrada/Salida Interfaz Gráfica (javax.swing.JOptionPane)
import javax.swing.JOptionPane; // importa la clase JOptionPane
Public class InterfazGrafica{
public static void main(String[] args){
String cadena1, cadena2;
int x, y, potencia;
//lee la base y el exponente
cadena1 = JOptionPane.showInputDialog( “Introduzca la base:" );
cadena2 = JOptionPane.showInputDialog( “Introduzca el exponente:" );
//se convierten los valores y se calcula el resultado
x = Integer.parseInt(cadena1);
y = Integer.parseInt(cadena2);
potencia = Math.pow(x,y);
//despliega el resultado
JOptionPane.showMessageDialog(null, “x^y = " + potencia, "Resultado",
JOptionPane.PLAIN_MESSAGE );
}
}

Unidad I: Entornos de DesarrolloUnidad I: Entornos de Desarrollo
•Visual Café
•Visual J++
•Visual Age for Java
•Jbuilder
•Java WorkShop
•JavaStudio
•.... Y cientos más
Entornos de Desarrollo (IDE’s) • La mayoría incluyen su
propio compilador y
máquina virtual Java:
Esto puede causar
problemas con los
cambios de versiones y
librerías.
• Sun controla la
especificación de Java
y lanza nuevas
versiones del JDK
(idéntico para varias
plataformas).

Unidad I: MUnidad I: Máás Informacis Informacióón...n...
•Página Principal de Java:
•http://java.sun.com
•Tutoriales:
–ftp://herodes.redes.upv.es/lar/Java/Jtutotorial/index.html
–http://www.fie.us.es/info/internet/JAVA/
–ftp://herodes.redes.upv.es/lar/Java/ThinkInJava.pdf
–http://java.sun.com
•Aplicaciones:
–http://www.javashareware.com
–http://www.acme.com

Tema 2: AutoevaluaciTema 2: Autoevaluacióónn
1. Menciona las principales características de Java
2. Menciona las ventajas de Java sobre C++ o lenguajes similares
3. Por qué Java puede correr en cualquier plataforma sin modificar o recompilar el código ?
4. Qué es un paquete ?
5. De qué clase se derivan implícitamente una clase en Java ?
6. Para qué se emplea this ?
7. Qué es una interface ?
8. Investiga la jerarquía de clases de Java.
9. Cuál es la estructura general de un programa en Java?
10. Cuáles son los tipos de variables con los que cuenta Java ?
11. Cuáles son los tipos primitivos de Java ?
12. En que difiere el tipo char de Java del de otros lenguajes ?
13. Cuál es el alcance de las variables en Java ?
14. Cuál es la precedencia de operadores en Java?
15. Cuál es la diferencia entre los operadores && y &?
16. Cuáles son los tipos de comentarios que maneja Java?
17. Explica como se hace el manejo de errores en Java
18. Cuál es la diferencia entre break y continue?
19. Diferencia entre break y continue y sus contrapartes etiquetadas?
20. Cuál es la estructura general de un programa en Java?

Tema 2: AutoevaluaciTema 2: Autoevaluacióónn
package Conversion.*;
import java.io;
public class Conversion {
private static void main (String args){
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br= new BufferedReader();
String cadena;
try {
System.out.println("Indique el número de metros y pulse RETURN")
cadena = br.readline();
double d = new Double(cadena);
double metros = d.doubleValue();
double pulgadas = metros * 39,27;
double pies = pulgadas / 12;
pulgadas = pulgadas % 12;
pies = pies - pulgadas / 12;
System.out.println("Conversión de metros en pies y pulgadas");
System.out.println(metros+" metros son "+pies+" pies y
"pulgadas+" pulgadas");
}
catch(Exception e){
System.out.println("Cualquier tipo de error");}
}
}
Problema 1: Verificar el siguiente programa identificando los errores de sintaxis

Java Introducción Lenguaje

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (20)

Similar a Java Introducción Lenguaje

Similar a Java Introducción Lenguaje (20)

Más de Pedro Sánchez

Más de Pedro Sánchez (20)

Último

Último (20)

Java Introducción Lenguaje