Ut2 Java
Ut2 Java
JAVA
Página |1
TABLA DE CONTENIDO
¿Qué es Java? .................................................................................................. 3
Ventajas de Java. ..................................................................................................................................... 5
Desventajas de Java ................................................................................................................................. 5
Clases ............................................................................................................ 16
Conceptos básicos......................................................................................................... 16
Creación de una clase ................................................................................................... 16
Creación de un objeto ................................................................................................... 17
La referencia de variables y métodos con this ....................................................................................... 17
Página |2
¿QUÉ ES JAVA?
Hacia 1990, James Gosling, quien trabaja para Sun Microsystems, fue el
encargado de crear programas para controlar aparatos electrónicos domésticos.
Originalmente Gosling y su equipo empezaron el diseño de su software usando C++,
debido a su orientación a objetos. Sin embargo, se dieron cuenta que C++ no satisfacía
los proyectos que se tenían en mente; encontraron dificultades con aspectos
complicados de C++ como la herencia múltiple de clases, errores de programación
(bugs) relacionados con huecos de memoria. De esta manera Gosling decidió que tenía
que empezar por escribir un lenguaje simplificado que le evitara todos los problemas
que se encontró con C++.
Oak se uso por primera vez en un proyecto llamado Proyecto Green, donde el
equipo de desarrollo intentó diseñar un sistema de control para usar dentro del hogar.
Este sistema de control permitiría al usuario manipular distintos dispositivos, como
televisiones, video caseteras, luces caseras y teléfonos, todo desde una computadora
de mano llamada *7 (Star Seven). El sistema *7 incluía una pantalla sensible para que
el dueño seleccionara y controlara estos dispositivos.
La pantalla del *7 tenía diversas figuras, entre las que se encontraba Duke (la
actual mascota de Java). Duke ha sido incluido en muchos ejemplos de applets en la
página de Sun Microsystems. El siguiente paso para Oak fue el proyecto Video En
Demanda (VOD), en el que el lenguaje era usado como la base para el software que
controlaría un sistema de televisión interactivo. Aunque ni *7 ni el proyecto VOD
concluyeron en productos actuales, le dieron a Oak una oportunidad de crecer y
madurar. Con el tiempo
Sun Microsystems descubrió que el nombre Oak ya había sido usado y le cambió
el nombre por Java, y vio nacer un lenguaje poderoso y sencillo.
Página |3
surgió la idea de escribir un navegador de Web que demostraría el poder del
lenguaje, este navegador es el HotJava.
Es orientado a objetos, porque como C++, Java usa clases para organizar el
código en módulos. En tiempo de ejecución, un programa crea objetos a partir de las
clases. Las clases en Java pueden heredar de otras clases, pero la múltiple herencia,
donde una clase hereda métodos y datos de varias clases, no está permitida.
Página |4
Es robusto porque el intérprete de Java revisa todos los accesos al sistema
dentro de un programa, por esto, los programas desarrollados en Java no pueden tirar
el sistema. Esto es, cuando un error serio es encontrado, los programas en Java crean
una excepción. Esta excepción puede ser capturada y manejada por el programa sin el
riesgo de bloquear el sistema.
Es ampliable porque los programas en Java soportan métodos nativos, que son
funciones escritas en otros lenguajes, generalmente C++. Este soporte a métodos
nativos permite a los programadores escribir funciones que pueden ser ejecutadas
más rápido que las funciones equivalentes escritas en Java. Los métodos nativos son
ligados a los programas en forma dinámica, es decir, son asociados con los programas
en tiempo de ejecución.
VENTAJAS DE JAVA.
Es seguro.
Se aprende con facilidad. Soportado por Microsoft.
Es orientado a objetos.
No bloquea el sistema.
Aplicaciones para comunicación en red.
No tiene aritmética de apuntadores.
Es independiente de la plataforma.
DESVENTAJAS DE JAVA
Página |5
INTRODUCCIÓN A JAVA
Java tiene las siguientes características:
Página |6
Comentarios
Los comentarios en Java se pueden escribir en tres formas:
// comentario de una línea
/* comentario de una o más líneas */
/** comentario para documentación */
Identificadores
En Java, un identificador empieza con una letra, el carácter de subraya o el signo
$. Los demás caracteres pueden contener dígitos. Todos los identificadores son
sensibles a mayúsculas / minúsculas.
Los últimos tres ejemplos son muy poco usados en la generalidad de los
programas. Los identificadores pueden contener palabras reservadas, pero no pueden
ser palabras reservadas; por ejemplo, es valido integer, pero no int.
Palabras reservadas
abstract do implements private throw
boolean double import protected throws
break else instanceof public transient
byte extends int return true
case false interface short try
catch final long static void
char finally native super volatile
class float new switch while
continue for null synchronized
default if package this
Página |7
Tipos de datos
Java define ocho tipos de datos primitivos y uno especial. Se pueden agrupar en:
lógicos, textuales, integrales y de punto flotante.
El tipo de dato boolean sólo tiene dos valores: false y true. En C/C++ se permite
que valores numéricos sean interpretados como valores lógicos, pero no es el caso de
Java; sólo se permiten valores lógicos.
Los tipos de datos textuales son: char y String. Los caracteres se representan por
el tipo de dato char, usando un número de 16 bits sin signo con un rango de cero a
216−1 . Los caracteres se encierran entre apóstrofes.
'a' Letra a
'\t' Un tabulador
Los tipos integrales son: byte, short, int y long. Todos son números con signo. Los
números se pueden representar en forma decimal, octal o hexadecimal.
2 Valor decimal es dos
077 El cero que inicia indica un valor octal
0xBC27 0x indica un valor hexadecimal
Para especificar un valor long se debe poner L al final del número. Se puede usar
l o L, pero en minúscula se puede confundir con el número 1 en algunos casos.
2L Valor decimal dos, como un valor largo
077L El cero que inicia indica un valor octal
0xBC27L 0x indica un valor hexadecimal
Los tipos de dato para número de punto flotante son: float y double. Un valor en
punto flotante puede incluir el punto decimal, una parte exponente (letra E), o es
seguido por la letra F (float) o la letra D (double).
3.14 Valor de punto flotante
6.02E23 Valor de punto flotante muy grande
2.718F Valor sencillo de tipo float
123.4E+306D Valor de punto flotante muy grande de tipo double
Página |8
Tamaño Tipo
32 bits float
64 bits double
En Java, todos los valores de punto flotante son double, a menos que se indique
explícitamente que sean float.
Modificadores
Dentro de las palabras reservadas, Java utiliza las siguientes para modificar el
acceso a una variable, clase o función y se colocan al inicio de la declaración: public,
protected, default, private.
El modificador protected da acceso a objetos que son parte del mismo paquete,
y las subclases. (Más adelante se explica el concepto de paquete)
El modificador default da acceso a objetos que son parte del mismo paquete. Sin
embargo, en los programas no se especifica el modificador porque no hay una palabra
para ello.
int numero; // acceso default
Convenciones en la programación
Clases.- Los nombres de las clases deberían ser sustantivos, utilizando
mayúsculas para la primera letra y minúsculas para las restantes, y se pueden mezclar
varios sustantivos.
class CuentaBancaria
Métodos.- Los nombres de los métodos deberían ser verbos, todo el verbo en
minúscula. Se pueden agregar sustantivos con la primera letra en mayúscula. Evitar el
uso de subrayas.
Página |9
void revisarCuenta()
Las variables deben tener significado e indicar su uso. Las variables de una letra
deberían evitarse, excepto las que suelen usarse en ciclos (x, y, i, j, m, n) para
controlarlo.
bloque
}
Ejemplo:
// primer programa en Java
public class HelloWorld {
public static void main(String argv[]) {
System.out.println("Hello world!");
}
}
P á g i n a | 10
CAPÍTULO 2 - EL LENGUAJE
Inicialización de variables
Java no permite que una variable tenga un valor indefinido. Cuando un objeto es
creado, sus variables son inicializadas con los siguientes valores:
byte 0
short 0
int 0
long 0L
float 0.0F
double 0.0D
char '\u0000' (NULO)
boolean false
todas las referencias null
Si algún objeto hace referencia a algo con valor de null, creará una excepción (un
error que es manejable).
Para evitar que las variables tengan valores indeseables, se debe asignárseles
algún valor útil. El compilador estudia el código para determinar que cada variable ha
sido inicializada antes de su primer uso. Si el compilador no puede determinar esto,
entonces ocurre un error en tiempo de compilación.
public void calcula() {
int x = (int)(Math.random() * 100);
int y;
int z;
if(x > 50) {
y = 9;
}
z = y + x;
// el posible uso antes de la inicialización de y creara un error
de compilación
}
Expresiones lógicas
Los operadores relacionales y lógicos regresan un valor boolean.
int i = 1;
if(i) // error en tiempo de compilación
if(i != 0) // correcto
Operadores y su Precedencia
Los operadores en Java son muy similares en estilo y función a aquellos en C y
C++. La siguiente tabla en lista los operadores por orden de precedencia:
Separador . [] () ; ,
D a I ++ -- + - ~ !
P á g i n a | 11
I a D * / %
I a D + -
I a D << >>
I a D < > <= >= instanceof
I a D == !=
I a D &
I a D ^
I a D |
I a D &&
I a D ||
D a I ?:
D a I = *= /= %= += -= <<= >>= &= ^= |=
Los operadores && (and) y || (or) realizan una evaluación corta en expresiones
lógicas.
Cast
Aunque short y char ocupan 16 bits, se debe hacer un cast explícito, debido al
rango que tienen asignado.
Flujo de programa
SENTENCIA IF/ELSE
Permite elegir una de dos opciones. La sintaxis básica de la sentencia if/else es:
if(condición) {
//instrucción_o_bloque
}
else {
//instrucción_o_bloque
}
Ejemplo:
int aleatorio = (int)(Math.random() * 100);
P á g i n a | 12
if(aleatorio < 50) {
System.out.println("menor a 50");
}
else {
SENTENCIA SWITCH
case valor1:
instrucciones;
break;
case valor2:
instrucciones;
break;
case valor3:
instrucciones;
break;
default:
instrucciones;
break;
}
El valor de expresion_a_evaluar debe ser compatible con el tipo int, como short,
byte y char. No se permite evaluar long o valores de punto flotante.
Ejemplo:
switch(colorNum) {
case 0:
setBackground(Color.red);
break;
case 1:
setBackground(Color.green);
break;
case 2:
setBackground(Color.blue);
break;
default:
setBackground(Color.black);
break;
}
LA SENTENCIA FOR
P á g i n a | 13
instrucciones;
}
Ejemplo:
int x;
for(x = 0;x < 10;x++) {
System.out.println("dentro de for");
}
System.out.println("fin de for");
LA SENTENCIA WHILE.
instrucciones;
}
Ejemplo:
int i = 0;
while(i<15) {
System.out.println("dentro de while");
i+=2;
}
LA SENTENCIA DO/WHILE.
Permite realizar una serie de instrucciones hasta que deje de cumplirse una
condición. La sintaxis básica de la sentencia es:
do {
instrucciones;
}while(condición);
P á g i n a | 14
Ejemplo:
int i = 0;
do {
System.out.println("dentro de while");
i++;
}while(i<10);
PAQUETES
...
}
La declaración de paquete, si la hay, debe estar al inicio del código fuente, puede
estar precedida únicamente de comentarios. Solo se permite una declaración package
por archivo fuente. Los nombres de los paquetes son jerárquicos, separados por
puntos. Por lo general, los elementos de los paquetes son escritos enteramente en
minúsculas. Una vez compilado el archivo, puede ser usado por otro mediante la
sentencia import, que indica donde se encuentran los paquetes. Import debe preceder
a todas las declaraciones de clases.
import empresa.sistemas.*;
public class JefeArea extends Empleado {
String departamento;
Empleado subordinados[];
...
}
P á g i n a | 15
CLASES
Conceptos básicos
Una clase es la definición de las tareas que se van a realizar. Incluye las variables
necesarias y los métodos, tanto públicos como privados.
Una subclase es una clase que se deriva de otra, que hereda de otra sus variables
y métodos.
P á g i n a | 16
// calcular el día siguiente
}
}
Creación de un objeto
Para que se puedan realizar las tareas que define la clase Fecha, se tiene que
hacer una instancia de la clase:
Fecha fecha;
fecha = new Fecha();
// tal vez el constructor ya definió la fecha actual
fecha.manana();
// dentro del código de tomorrow se calcula el día siguiente
En Java la palabra reservada this se usa para accesar variables y métodos del
mismo objeto (ya creado) para
En este ejemplo resulta redundante el uso de this, pero puede entenderse que
this.day es la variable de la clase. En el siguiente ejemplo se fija un número de día
pasando un parámetro al método fijaDia():
public class Fecha {
private int dia,mes,anio;
public void fijaDia(int dia) {
this.dia = dia;
}
}
P á g i n a | 17
Este ejemplo es completamente válido y legal, ya que el primer elemento de la
asignación se refiere a la variable de la clase, y el segundo elemento de la asignación se
refiere al parámetro del método fijaDia.
Sobrecarga de métodos
En ciertas circunstancias, uno desea escribir varios métodos en la misma clase
que hagan básicamente lo mismo pero con diferentes parámetros. Considérese el
ejemplo en el que se quiere imprimir la representación textual de un parámetro, por
ejemplo el método print().
Este método podría recibir como parámetros un int, long, double, String, etc. Es
posible que cada tipo de dato requiera de alguna conversión para poder imprimir su
valor como cadena de caracteres. En lenguajes estructurados, la solución sería crear
funciones printint(), printfloat(), printString(), pero sería una tarea tediosa.
Constructores
Un método constructor, como ya se dijo, es el que se encarga de dar ciertos
valores iniciales a las variables de la clase.
public Clase() {
public Clase(int x) {
// inicialización del objeto con un parámetro
}
}
Clase c,d;
c = new Clase();
P á g i n a | 18
d = new Clase(1);
Subclases
En Java todas las clases son subclases de Object. Se crean subclases para realizar
tareas específicas a partir de una clase padre que contiene información básica
(variables y métodos). Por ejemplo, se puede crear la clase
Por lo tanto, se puede ver que la clase Gerente tiene las mismas y más
características y acciones que la clase Empleado, por lo que es posible crear una
subclase Gerente que herede de Empleado.
public class Empleado {
P á g i n a | 19
public class Gerente extends Empleado {
private String departamento;
private Empleado subordinados[];
...
}
Se usa la palabra reservada extends para indicar la herencia de una clase a otra,
en este ejemplo la clase Gerente "extiende" a la clase Empleado en variables y
métodos extra. Ahora la clase Gerente tiene las mismas características que Empleado y
además otras que son propias para esa clase. La clase Gerente heredó de la clase
Empleado sus variables y métodos.
Polimorfismo
Siguiendo con el ejemplo de las clases Empleado y Gerente, se puede tener un
método calculaSalario() en la clase Empleado, por lo que también se hereda a Gerente.
Esto lleva a la idea de que los objetos son polimórficos. Un objeto en particular puede
tener la forma de Gerente, pero también tiene la forma de Empleado.
Para ver un efecto del polimorfismo con estas clases, se puede crear un arreglo
que contenga tanto empleados como gerentes:
Empleado staff[] = new Empleado[100];
staff[0] = new Gerente();
staff[1] = new Empleado();
P á g i n a | 20
public class Empleado
// le puedo hablar de tu
}
}
Esto permite que el programa compile y corra sin errores. Se tiene que hacer la
instancia porque la variable departamento no pertenece a la clase Empleado:
System.out.println(e.departamento); // error!
Redefinición de métodos
Además de heredar los métodos de una clase padre, se puede modificar la acción
de cualquier método, con el fin de mejorar o ampliar esa acción.
La regla que se debe seguir para redefinir un método es que el tipo de dato de
retorno y el número y tipo de datos de los parámetros tiene que ser idéntico al
definido en la clase padre. Sigamos con una variación del
P á g i n a | 21
}
Por ultimo, una comparación entre Java y C++ con respecto a lo visto en este
Capítulo. En C++ se puede redefinir un método marcándolo como virtual en el código
fuente. En lenguajes puros orientados a objetos esto no es normal. C++ hace esto para
incrementar la velocidad de ejecución.
P á g i n a | 22