Información básica Java

Explicar la Tecnología Java

Docente:
Freddy Mendez Ortiz

Que es la Tecnología Java?
• La tecnología Java es:
– Un lenguaje de programación
– Un ambiente de desarrollo
– Un ambiente de aplicación
• Tiene sintaxis similar a C++
• Es usada para desarrollar tanto aplicaciones como
applets

Principales Metas de la
Tecnología Java?
• Provee un lenguaje fácil de usar por:
– Evita muchas fallas presentes en otros
lenguajes.
– Usa el paradigma Orientado a Objetos
– Permite crear código estable y limpio.
• Provee un ambiente interpretado para:
– Mejora la velocidad de desarrollo.
– Portabilidad del código

Tecnología Java?
• Permite ejecutar mas de una actividad
• Cargar clases dinámicamente; esto es, cuando
ellas son realmente necesitadas
• Permite cambiar programas dinámicamente
durante la ejecución por la carga de clases desde
fuentes distantes
• Proveer mejor seguridad

Tecnología Java?
• Las siguientes características satisfacen estas
metas:
– La maquina virtual de Java JVM
– El colector de basura
– El ambiente de ejecución de Java JRE
– Herramientas de interface de JVM

Maquina Virtual de Java
• Una maquina imaginaria que es implementada
para emular esta en software en una maquina real.
El código para la JVM es almacenado en archivos
.class, cada uno de los cuales contiene a lo mas
una clase publica.

• Provee las especificaciones del hardware de la
plataforma
• Lee archivos compilados (Bytecodes) que son
independientes de la plataforma
• Es implementada en software o hardware
• Es implementada en las herramientas de
desarrollo de la Tecnología Java o en un
navegador Web

• La mayoría de los chequeos de tipo son
realizados cuando el código es compilado
• La implementación de la JVM aprobada por Sun
Microsystems debe ser capas de ejecutar cualquier
archivo class compilado
• La JVM se ejecuta en diferentes sistemas
operativos (Solaris, Linux, Mac, Windows)

Colector de Basuras
• Memoria asignada que no esta siendo necesitada
debería ser desasignada
• En otros lenguajes desasignar la memoria es
responsabilidad del programador
• El lenguaje de programación de Java provee un
hilo de nivel del sistema para monitorear memoria
asignada

Colector de Basuras
• El colector de basura tiene las siguientes
características:
– Cheque y libera memoria no necesitada.
– Se realizado automáticamente.
– Puede variar drásticamente entre las diferentes
implementaciones de la JVM

Ambiente de ejecución de Java

Operación del JRE con JIT
(Just-In-Time)

Tareas de la JVM
• La JVM realiza tres tareas principales:
– Cargar el código
– Verificar el código
– Ejecutar el código

Cargador de Clases
• Carga todas las clases necesarias para la
ejecución de un programa
• Mantiene las clases de los archivos locales del
sistema en nombre de espacio (namespaces)
separados
• Previene la suplantación (spoofing)

Verificador de Bytecode
Asegura que:
• El código cumple con las especificaciones de la
JVM.
• El código no viola integridad del sistema.
• El código no causa operaciones de stack overflows
• Los tipos de parámetros para todas las
operaciones de código son correctas.

Ambiente de ejecución de la
Tecnología de Java

Declaración de Clases en la
Tecnología Java
• Sintaxis básica de una clase en Java:
<modifidor>* class <nombre_clase> {
<declaración_atributos>*
< declaración_constructor>*
< declaración_metodos>*
}

Declaración de Clases en la
Tecnología Java
• Ejemplo:
1 public class Vehiculo {
2 private double maxCarga;
3 public void setMaxCarga(double valor) {
4 maxCarga = valor;
5 }
6}

Declaración de Atributos en
la Tecnología Java
• Sintaxis básica de un atributo en Java:
<modificador>* <tipo> <nombre>[=<initial_valor>];
• Ejemplo:
1 public class Valores {
2 private int x;
3 private float y = 10000.0F;
4 private String nombre = "Bates Motel";
5}

Declaración de Métodos en
la Tecnología Java
• Sintaxis básica de un método en Java:
<modificador>* <tipo_retorno> <nombre>
(<argumentos>*) {
<declaraciones>*
}

Declaración de Métodos en
la Tecnología Java
• Ejemplo:
1 public class Perro {
2 private int peso;
3 public int getPeso() {
4 return peso;
5 }
6 public void setPeso(int nuevoPeso) {
7 if (nuevoPeso > 0 ) {
8 peso = nuevoPeso;
9 }
10 }
11 }

Accediendo a miembros de
un Objeto
• La notación punto es:<objeto>.<miembro>
• Esta es usada para acceder a los miembros de un
objeto incluyendo atributos y métodos
• Ejemplo de la notación punto:
– d.setPeso(42);
– d.peso = 42; // Solo si el atributo peso es public

Ocultar Información
• El problema:

• El código del cliente tiene acceso directo a los
datos internos (d referencia un objeto de tipo
MiFecha)
• d.dia = 32; // Día invalido
• d.mes = 2; d.dia = 30; // posible pero erróneo
• d.dia = d.dia + 1; // no chequea si da la vuelta

• El código del cliente debe usar los métodos getters
y setters para acceder a los datos internos
• d.setDia(32); // Día invalido, retorna false

• d.setMes(2); // posible pero erróneo,
• d.setDia(30); // setDia retorna false

• d.setDia(d.getDia() + 1); // día invalido, retorna
false

Encapsulamiento
• Oculta la implementación de detalles de la clase
• Obliga al usuario a usar una interface para acceder
a los datos
• Hace el código mantenible

Declaración de
Constructores en Java
• Sintaxis básica de un constructor en Java:
<modificador>* <nombre_clase> (<argumentos>*) {
<declaraciones>*
}

Declaración de
Constructores en Java
• Ejemplo:
1 public class Dog {
2 private int weight;
3 public Dog() {
4 weight = 42;
5 }
6}

Constructor por defecto
• Siempre debe existir por lo menos un constructor
en cada clase
• Si no se escribe ninguno, el constructor por defecto
se presenta automáticamente:
– No recibe argumentos
– El cuerpo es vació
• El constructor por defecto permite crear instancias
de objetos de la forma new XXX(); sin tener ningún
constructor definido

Esquema archivo fuente
• Sintaxis básica de un archivo fuente en Java:
[<declaración_paquetes>]
<declaración_import>*
<declaración_clase>+

Esquema archivo fuente
• Por ejemplo, el archivo
ReporteCapacidadVehiculo.java es:
1 package shipping.reports;
2
3 import shipping.domain.*;
4 import java.util.List;
5 import java.io.*;
6
7 public class ReporteCapacidadVehiculo {
8 private List vehiculos;
9 public void generarReporte(Writer salida) {...}
10 }

Paquetes de Software
• Los paquetes ayudan a administrar grandes
sistemas de software
• Los paquetes pueden contener clases y sub
paquetes

Declaración de Paquetes
• Sintaxis básica de la declaración de paquetes:
package <top_pkg_nombre>[.<sub_pkg_nombre>]*;
• Ejemplo de la declaración:
package shipping.gui.reportscreens;
• Específicamente la declaración de paquetes va al
inicio del archivo fuente
• Solamente una declaración de paquete por archivo
fuente

Declaración de Paquetes
• Si ningún paquete es declarado, entonces la clase
es colocada dentro de un paquete por default
• El nombre de los paquetes debe ser jerárquico y
separado por puntos.

Declaración de import
• Sintaxis básica de la declaración de import:
import <pkg_nombre>[.<sub_pkg_nombre>]*.<class_nombre>;
o
import <pkg_nombre>[.<sub_pkg_nombre>]*.*;
• Ejemplo de la declaración:
import java.util.List;
import java.io.*;
import shipping.gui.reportscreens.*;

Declaración de import
• La declaración de import hace lo siguiente:
– Precede todas las declaraciones de clases
– Le indica al compilador donde puede encontrar
las clases

Identificadores, palabras
reservadas y tipos de datos

Docente:
Freddy Mendez Ortiz

Comentarios
• Los tres estilos permitidos de comentarios en los
programas de la Tecnología de Java son:
//Comentarios de línea

/*Comentarios de bloque
*una o mas líneas
*/

/**Comentarios de documentación
*se pueden extender una o mas líneas
*/

Puntos y coma, bloques y
espacios en blanco
• Una declaración es una o mas líneas de código
terminadas por un punto y coma ( ; ):
total = a + b + c
+ d + e + f;
• Un bloque es una colección de declaraciones
limitadas por llaves que abren ( { ) y cierran ( } )
{
x = y + 1;
y = x + 1;
}

Identificadores
• Los identificadores tienen las siguientes
características:
– Son nombres dados a variables, clases o
métodos
– Pueden iniciar con una letra Unicode, guion de
piso ( _ ), o signo de moneda ( $ )
– Son sensibles a mayúsculas y minúsculas, y no
tiene longitud máxima

Identificadores
• Ejemplos:
identificadores
nombreUsuario
nombre_usuario
_var_sys_1
$cambio

Palabras reservadas de Java
abstract continue for new switch
assert default goto package synchronized
boolean do if private this
break double implements protected throw
byte else import public throws
case enum instanceof return transient
catch extends int short try
char final interface static void
class finally long strictfp volatile
const float native super while

Palabras literales reservadas: null, true y false

Tipos primitivos
• El lenguaje de programación Java define ocho
tipos de datos primitivos:
– Lógicos : boolean
– Textuales : char
– Enteros : byte, short, int, long
– Flotantes : float, double

Lógico - boolean
• El primitivo boolean tiene las siguientes
características:
– El tipo de dato boolean tiene dos valores
literales, true y false
Por ejemplo la siguiente declaración:
boolean bandera = true;
Declara la variable bandera como tipo boolean
y asigna a esta un valor de true

Textual - char
• El textual primitivo char tiene las siguientes
características:
– Representa un carácter Unicode de 16-bit
– Debe estar entre comillas sencillas (‘ ‘)
– Usa las siguientes notaciones:
• ‘a’ La letra a
• ‘ t ’ El carácter tabulador
• ‘u????’ Un especifico carácter Unicode, ????, es
reemplazado con exactamente cuatro
digitos hexadecimales

Textual - String
• El textual tipo String tiene las siguientes
características:
– No es un tipo de dato primitivo, es un tipo de
clase
– Tiene declaración literal entre comillas dobles
(“”). Ej: “Java es el mejor lenguaje del mundo”
– Puede ser usado como sigue:
• String saludo = “Buenos días !! n";
• String mensajeError = "Registro no encontrado !";

Enteros – byte, short, int y
long
• Los primitivos enteros tienen las siguientes
características:
– Primitivos enteros usan tres formas: Decimal,
Octal y Hexadecimal
2 077 0xBAAC
– Los literales tiene como tipo por defecto int
– Los literales con el sufijo L o l son de tipo long

Enteros – byte, short, int y
long
• Los primitivos enteros tienen los siguientes rangos:

Longitud del Entero Nombre o tipo Rango
8 bits byte -27 hasta 27-1
16 bits short -215 hasta 215-1
32 bits int -231 hasta 231-1
64 bits long -263 hasta 263-1

Punto flotante – float y
double
• Los primitivos punto flotante tienen las siguientes
características:
– Los literales punto flotante incluyen una de dos
punto decimal o un de los siguientes caracteres:
• E or e (agrega un valor exponencial)
• F or f (float)
• D or d (double)

double
– Ejemplos:
• 3.14 Un simple valor punto flotante (double)
• 6.02E23 Un gran valor punto flotante
• 2.718F Un simple valor de tamaño float
• 123.4E+306D Un gran valor double con redundante D

• Los literales tienen como tipo por defecto
double

double
• Los primitivos punto flotante tienen los siguientes
tamaños:

Longitud del Flotante Nombre o tipo
32 bits float
64 bits double

Variables, declaraciones y
asignaciones
public class Asigna {
public static void main (String args [ ]) {
// declara variables enteras
int x, y;
// declara y asigna un punto flotante
float z = 3.414f;
// declara y asigna un double
double w = 3.1415;
// declara y asigna un boolean
boolean bandera = true;

asignaciones
// declara variable carácter
char c;
// declara variable String
String str;
// declara y asigna variable String
String str1 = “chao";
// asigna valor a variable tipo char
c = 'A';
// asigna valor a variable String
str = “Hola, alguien en casa!";

asignaciones
// asigna valores a las variables int
x = 6;
y = 1000;
}
}

Tipos de referencia en Java
• En la Tecnología Java, aparte de los tipos
primitivos, todos los demás son tipos de referencia
• Una variable de referencia contiene un
identificador a un objeto

• Por ejemplo:
public class MiFecha {
private int dia = 1;
private int mes = 1;
private int anio = 2000;
public MiFecha(int d, int m, int a) { ... }
public String toString() { ... }
}

• Por ejemplo:
public class PruebaMiFecha {
public static void main(String [ ] args) {
MiFecha hoy = new MiFecha (22, 7, 1964);
}
}

Construyendo e
Inicializando Objetos
• Llamando a new Xyz() desarrolla las siguientes
acciones:
– La memoria es asignada para el Objeto
– La inicialización explicita de atributos es desarrollada
– Un constructor es ejecutado.
– La referencia del Objeto es retornada por el operador
new

Construyendo e
Inicializando Objetos
• La referencia de un Objeto es asignada a la
variable
• Un ejemplo es:
– MiFecha hoy = new MiFecha (22, 7, 1964);

Asignación y Organización
de memoria
• Una declaración permite almacenar solamente una
referencia
– hoy ????

Asignación y Organización
de memoria
• Usar el operador new asigna espacio para el
Objeto MiFecha
– hoy ????

– dia 0

– mes 0

– anio 0

Inicialización explicita de
atributos
• Inicializa los atributos como sigue:
– hoy ????

– dia 1

– mes 1

– anio 2000

Inicialización explicita de
atributos
• Los valores por defecto son tomados de la
declaración de atributos de la clase :
– private int dia = 1;
– private int mes = 1;
– private int anio = 2000;

Ejecutando el constructor
• Ejecuta el correspondiente constructor:
– hoy ????

– dia 22

– mes 7

– anio 1964

Ejecutando el constructor
• En el caso de la sobrecarga de constructores, el
primer constructor puede llamar a otros

Asignando a la variable
• Ejecuta el correspondiente constructor:
– hoy 0x01abcdef

– dia 22

– mes 7

– anio 1964

Asignación de referencias
• Dos variables referencian al mismo objeto:
– int x = 7;
– int y = x;
– MiFecha s = new MiFecha(22, 7, 1964);
– MiFecha t = s;

– x 7 22 7 1964

– y 7

– s 0x01abcdef
– t 0x01abcdef

Asignación de referencias
• Se reasignan dos variables apuntan a dos objetos:
– t = new MiFecha(22, 12, 1964);

– x 7 22 7 1964
– y 7 22 12 1964
– s 0x01abcdef
– t 0x123456fa

Paso por valor
• En una sencilla maquina virtual, el lenguaje de
programación de Java únicamente pasa
argumentos por valor
• Cuando la instancia de un objeto es pasada como
argumento de un método, el valor del argumento
es una referencia del objeto
• El contenido del objeto puede ser cambiado en el
llamado del método, pero la referencia original del
objeto nunca cambia

Paso por valor
public class PruebaPaso {
// El método cambia el valor actual
public static void cambiaInt(int valor) {
valor = 55;
}
public static void cambiaRefObjeto(MiFecha ref) {
ref = new MiFecha (1, 1, 2000);
}
public static void cambiaAtribObjeto(MiFecha ref){
ref.setDia(4);
}

Paso por valor
public static void main(String args [ ] ) {
MiFecha fecha;
int val;
// Asigna el int
val = 11;
// Trata de cambiar el valor
cambiaInt(val);
// Cual es el valor actual?
System.out.println("Int valor es: " + val);

• El resultado es: Int valor es 11

Paso por valor
// Asigna la fecha
fecha = new MiFecha(22, 7, 1964);
// Trata de cambiar el objeto
cambiaRefObjeto(fecha);
System.out.println("MiFecha: " + fecha);

• El resultado es: MiFecha: 22-7-1964

Paso por valor
// Ahora cambia el atributo día
// a través de la referencia del objeto
cambiaAtribObjeto(fecha);
System.out.println("MiFecha: " + fecha);
}
}

• El resultado es: MiFecha: 4-7-1964

La referencia this
• Unos pocos usos de la palabra reservada this son:
– Resolver ambigüedad entre variables de
instancia y parámetros
– Pasar el actual objeto como parámetro a otro
método o constructor

La referencia this
private int dia = 1;
private int mes = 1;
private int anio = 2000;

public MiFecha(int dia, int mes, int anio) {
this. dia = dia;
this. mes = mes;
this. anio = anio;
}

La referencia this
public MiFecha (MiFecha fecha) {
this. dia = fecha. dia;
this. mes = fecha. mes;
this. anio = fecha. anio;
}

public String toString() {
return "" + dia + "-" + mes + "-" + anio;
}

La referencia this
public MiFecha addDias(int numDias) {
MiFecha nuevaFecha = new MiFecha(this);
nuevaFecha.dia = nuevaFecha.dia + numDias;
// Resto de la implementación de código...
return nuevaFecha;
}
}

La referencia this
public class PruebaMiFecha {
public static void main(String [ ] args) {
MiFecha miFecha = new MiFecha (22, 7, 1964);
MiFecha siguienteSemana = miFecha.addDias(7);
System.out.println(siguienteSemana);
}
}

Expresiones y control de
flujo

Docente:
Freddy Mendez Ortiz

Variables y alcance
• Variables locales son:
– Variables que son definidas dentro de un
método y son llamadas: locales, automáticas,
temporales o de pila
– Variables que son creadas cuando el método se
ejecuta y destruidas cuando el método termine.

Variables y alcance
• La inicialización de variables incluye lo siguiente:
– Las variables locales requieren inicialización
explicita
– Las variables de instancia son inicializadas
automáticamente

Ejemplo alcance variables
public class EjemploAlcance {
private int i=1;
public void primerMetodo() {
int i=4, j=5;
this.i = i + j;
segundoMetodo(7);
}
public void segundoMetodo (int i) {
int j=8;
this.i = i + j;
}
}

public class TestScoping {
public static void main(String[] args) {
EjemploAlcance alcance = new EjemploAlcance();
alcance.primerMetodo();
}
}

Stack de
Heap
Ejecución
Memory

j 8 EjemploAlcance
segundoMetodo
i 7 i 1
this
j 5
primerMetodo
i 4
this
main alcance

Inicialización variables
Variable Valor
byte 0
short 0
int 0
long 0L
float 0.0F
double 0.0D
char 'u0000'
boolean false
Todos los tipos de null
referencia

Principio Inicializar antes de
usar
• El compilador puede verificar que las variables
locales tiene que ser inicializadas antes de usarse
public void hacerComputo() {
int x = (int)(Math.random() * 100);
int y;
int z;
if (x > 50) {
y = 9;
}
z = y + x; // Posible uso antes de inicializar
}

Precedencia operadores
Operadores Asociatividad
++ -- ~ ! ( ) R to L
*/% L to R
+- L to R
<< >> >>> L to R
< > <= >= instanceof L to R
== != L to R
& L to R
^ L to R
| L to R
&& L to R
|| L to R
<boolean_expr> ? <expr1> : <expr2> R to L
= *= /= %= += -= <<= >>= >>>= &= ^= |= R to L

Operadores Lógicos
• Los operadores boolean son:
! – NOT & – AND
| – OR ^ – XOR
• Los operadores boolean short-circuit are:
&& – AND || – OR
• Los operadores se pueden usar como:
MiFecha d = reservacion.getFechaSalida();
if ( (d != null) && (d.dia > 31) {
// Hacer algo con d
}

Operadores Lógicos a
Bitwise
• Los operadores bitwise a enteros son:
~ – Complemento & – AND
^ – XOR | – OR
• Los operadores se pueden usar como:

Operadores Right-Shift >> y
>>>
• Operador Right-Shift:
• Ejemplos son:
– 128 >> 1 retorna 128/21 = 64
– 256 >> 4 retorna 256/24 = 16
– -256 >> 4 retorna -256/24 = -16
• El bit del signo es copiado durante el corrimiento

Operadores Right-Shift >> y
>>>
• Operador unsigned Right-Shift:
• Este operador es usado para patrones de bit
• El bit del signo no es copiado durante el
corrimiento

Operador Left-Shift <<
• Operador Left-Shift trabaja como:
– 128 << 1 retorna 128 * 21 = 256
– 16 << 2 retorna 16 * 22 = 64

Concatenar String con +
• El operador + funciona como sigue:
– Realiza concatenación de String
– Produce un nuevo String
String titulo = “Dr.”;
String nombre = “Luis” + “ ” + “Perez”;
String saludo = titulo + “ ” + nombre;
• Un argumento debe ser un objeto String
• No Strings son convertidos a objetos String de
forma automática

Casting
• Si información podría perderse en una asignación,
el programador debe confirmar la asignación con
un casting
• La asignación entre lont e int requiere un casting
explicito
long granValor = 99L;
int valor = granValor; // Incorrecto, necesita casting
int valor = (int) granValor; // OK
int valor = 99L; // Incorrecto, necesita casting
int valor = (int) 99L; // OK
int valor = 99; // Por defecto int

Promoción y Casting de
expresiones
• Las variables se promueven automáticamente a su
forma mas grande (como int a long)
• La expresión es compatible de asignar si el tipo de
la variable es al menos igual de grande (mismo
numero de bits) como el tipo de la expresión
– long x = 6; // 6 es un tipo int, OK
– int y = 99L; // 99L es un tipo long, ilegal
– double z = 12.414F; // 12.414F es un tipo float, OK
– float z1 = 12.414; // 12.414 es double, illegal

Declaración de if simple
• La sintaxis de la declaración del if es:
if ( <expresión_boolean> )
<declaración_o_bloque>
• Ejemplo:
if ( x < 10 )
System.out.println(“Usted ha terminado?");
• o (recomendado):
if ( x < 10 ) {
System.out.println(“Usted ha terminado?");
}

Declaración de if, else
complejo
• La sintaxis de la declaración del if-else es:
else

Declaración de if, else
complejo
• La sintaxis de la declaración del if-else-if es:
else if ( <expresión_boolean> )

Declaración de switch
• La sintaxis de la declaración de switch es:
switch ( <expresión> ) {
case <constante1>:
<declaración_o_bloque>*
[break;]
case <constante2>:
[break;]
default:
[break;]
}

• Un ejemplo de la declaración switch es:
switch ( carModel ) {
case DELUXE:
addAire();
addRadio();
addLlantas();
addMotor();
break;

case STANDARD:
addRadio();
addLlantas();
addMotor();
break;
default:
addLlantas();
addMotor();
}

• Esta declaración switch es equivalente al ejemplo
anterior:
switch ( carModel ) {
case DELUXE:
addAire();
case STANDARD:
addRadio();
default:
addLlantas();
addMotor();
}

• Sin la declaración break, la ejecución continua a
través de cada subsiguiente cláusula case

Declaración de ciclos
• Ciclo for:
for ( <init_expr>; <test_expr>; <alter_expr> )
• Ejemplo:
for ( int i = 0; i < 10; i++ )
System.out.println(i + " el cuadrado es " + (i*i));
• o (recomendado):
for ( int i = 0; i < 10; i++ ) {
}

• Ciclo while:
while ( <test_expr> )
• Ejemplo:
int i = 0;
while ( i < 10 ) {
i++;
}

• Ciclo do/while:
do
while ( <test_expr> );
• Ejemplo:
int i = 0;
do {
i++;
} while ( i < 10 );

Controles de flujo
especiales
• El comando break [<label>];
• El comando continue [<label>];
• El comando <label>:<declaración>, donde
<declaración> debe ser un ciclo

Declaración break
do {
declaración;
if ( condición ) {
break;
}
declaración;
} while ( <test_expr> );

Declaración continue
do {
declaración;
if ( condición ) {
continue;
}
declaración;
} while ( <test_expr> );

Usando la declaración break
con Labels
outer:
do {
declaración1;
do {
declaración2;
if ( condición ) {
break outer;
}
declaración3;
} while ( test_expr );
declaración4;

Usando la declaración
continue con Labels
outer:
do {
declaración1;
do {
declaración2;
if ( condición ) {
continue outer;
}
declaración3;
declaración4;

Arreglos

Docente:
Freddy Mendez Ortiz

Declaración de Arreglos
• Grupo de datos de un mismo tipo. Colección
Homogénea
• Declaración de arreglos de tipo primitivo y de
clase:
– char s [ ];
– MiPunto p [ ];
• Crea espacio para una referencia
• Un arreglo es un objeto, este se debe crear con
new

Creación de Arreglos
• Se usa la palabra new para crear un Objeto arreglo
• Ejemplo de arreglo de tipo primitivo (char):
public char[] crearArreglo() {
char[] s;
s = new char[26];
for ( int i=0; i<26; i++ ) {
s[i] = (char) (’A’ + i);
}
return s;
}

Creación de Arreglo de char
Heap
Stack de Memory
Ejecución
char [ ]
A
B
C
D
s …
crearArreglo
this
main

Creación de Arreglos de
Referencia
• Ejemplo de arreglo de tipo de referencia de objeto:
public MiPunto[] crearArreglo() {
MiPunto[] p;
p = new MiPunto[10];
for ( int i=0; i<10; i++ ) {
p[i] = new MiPunto(i, i+1);
}
return p;
}

Creación de Arreglo de
Referencia MiPunto
Heap
Stack de Memory
Ejecución
MiPunto [ ] MiPunto
x 0
y 1
MiPunto
x 1
crearArreglo p y 2
…
this
main

Inicialización de Arreglos
• Inicializar un elemento del arreglo
• Crear un arreglo con valores iniciales
String[] nombres;
nombres = new String[3];
nombres[0] = "Georgianna";
nombres[1] = "Jen";
nombres[2] = "Simon";

String[] nombres = { "Georgianna", "Jen", "Simon“ };

Inicialización de Arreglos
MiFecha[] fechas;
fechas = new MiFecha[3];
fechas[0] = new MiFecha(22, 7, 1964);

MiFecha[] fechas = { new MiFecha(22, 7, 1964),
new MiFecha(1, 1, 2000), new MiFecha(22, 12, 1964) };

Arreglos Multidimencionales
• Arreglos de arreglos
int[][] dosDim = new int[4][];
dosDim[0] = new int[5];
int[][] dosDim = new int[][4]; // ilegal

Arreglos Multidimencionales
• Arreglos de arreglos no rectangulares
int[][] dosDim = new int[4][];
• Arreglo de 4 arreglos de 5 enteros
int[][] dosDim = new int[4][5];

Limites de los Arreglos
• Todos los arreglos inician en la posición cero (0)
public void imprimirElementos(int[] lista) {
for (int i = 0; i < lista.length; i++) {
System.out.println(lista[i]);
}
}

Ciclo for mejorado

public void imprimirElementos(int[] lista) {
for (int elemento : lista) {
System.out.println(elemento);
}
}

• Se puede leer para cada elemento en la lista haga

Redimensión de Arreglos
• Un arreglo no se puede redimensionar
• Se puede usar la misma variable de referencia
para apuntar a un nuevo arreglo:
int[] miArreglo = new int[6];
miArreglo = new int[10];

Copiando Arreglos
• El método System.arraycopy() permite copiar el
contenido
1 //arreglo original
2 int[] miArreglo = { 1, 2, 3, 4, 5, 6 };
3
4 //nuevo arreglo mas grande
5 int[] hold = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
6
7 // copia todo el arreglo miArreglo en el arreglo hold,
8 // iniciando desde la posición 0
9 System.arraycopy(miArreglo, 0, hold, 0, miArreglo.length);

Diseño de Clases

Docente:
Freddy Mendez Ortiz

Subclases
• La clase Empleado:
public class Empleado {
public String nombre = "";
public double salario;
public Date fechaNacimiento;
public String getDetalles() {...}
}

Subclases
• La clase Administrador:
public class Administrador {
public String departamento;
}

Diagrama de clase del uso
de Herencia
}

public class Administrador
extends Empleado {
public String departamento;
}

Herencia Simple
• Cuando una clase hereda solo de una clase padre,
se llama Herencia Simple
• Interfaces proveen los beneficios de herencia
simple sin inconvenientes
• Sintaxis de una clase de Java:
<modificador> class <nombre> [extends <superclase>] {
<declaración>*
}

Control de Acceso
Modificador Misma Mismo Subclase Universo
Clase Paquete
private Si

default Si Si

protected Si Si Si

public Si Si Si Si

Sobrescritura de Métodos
• Una clase puede modificar el comportamiento
heredado de una clase Padre
• Una subclase puede crear un método con diferente
funcionalidad que el método de su Padre pero con
mismo:
– Nombre
– Tipo de retorno *
– Lista de argumentos

* El tipo de retorno puede ser una subclase
del tipo retornado J2SE 5.0

Sobrescritura de Métodos
public class Empleado { public class Administrador extends
protected String nombre; Empleado {
protected double salario; protected String departamento;
protected Date fechaNacimiento;
public String getDetalles () {
return “Nombre: “ + nombre +
public String getDetalles() { “n” + “Salario: “ + salario +
return “Nombre: “ + nombre + “Admin de: “ + departamento;
}
“n” + “Salario: “ + salario;
}
}
}

Métodos Sobrescritos no
pueden ser menos accesibles
public class Padre { public class UseAmbos {
public void hacerAlgo () {} public void hacerOtraCosa() {
} Padre p1 = new Padre();
Padre p2 = new Hijo();
p1. hacerAlgo ();
public class Hijo extends Padre { p2. hacerAlgo ();
private void hacerAlgo () {} // ilegal }
} }

Invocación de métodos
sobrescritos
• Un método de una subclase puede invocar un
método de la clase Padre usando la palabra
reservada super
– La palabra super es usada en una clase para referirse a
la superclase
– La palabra super es usada en una clase para referirse a
los miembros de la superclase, tanto atributos como
métodos
– El comportamiento invocado no tiene que ser el de la
superclase, este puede subir jerárquicamente

Invocación de métodos
sobrescritos
public class Empleado { public class Administrador extends
protected String nombre; Empleado {
protected double salario; protected String departamento;
protected Date fechaNacimiento;
public String getDetalles () {
return super.getDetalles() +
public String getDetalles() { “Admin de: “ + departamento;
return “Nombre: “ + nombre + }
}
“n” + “Salario: “ + salario;
}
}

Polimorfismo
• La habilidad de tener varias formas. Ej; La clase
Administrador tiene acceso a los métodos desde la
clase Empleado
• Un objeto tiene una sola forma
• Una variable de referencia puede referenciar a
objetos de diferentes formas

Polimorfismo
• Empleado e = new Administrador();
• e.departamento = “Ventas”;
• ilegal tratar de asignar al atributo de Administrador
• La variable es declarada de tipo Empleado, aun
cuando el objeto Administrador tenga este atributo

Invocación virtual de
métodos
• La invocación virtual de métodos es desarrollada
de la siguiente forma:
Empleado e = new Administrador();
e.getDetalles();
• El tipo en tiempo de compilación y en tiempo de
ejecución tiene las siguientes características:

Invocación virtual de
métodos
– El nombre del método debe ser un miembro del
tipo de variable declarada; en este caso
Empleado tiene un método llamado
getDetalles()
– La implementación del método usado es basado
en el tipo de Objeto en tiempo de ejecución; en
este caso Administrador tiene una
implementación del método getDetalles()

Colecciones Heterogéneas
• Las colecciones de objetos del mismo tipo son
llamadas colecciones homogéneas. Por ejemplo:
MiFecha[] fechas = new MiFecha[2];
• Las colecciones de objetos de diferente tipo son
llamadas colecciones heterogéneas. Por ejemplo:
Empleado [] staff = new Empleado[1024];
staff[0] = new Administrador();
staff[1] = new Empleado();
staff[2] = new Ingeniero();

Argumentos Polimorficos
• Puesto que un Administrador es un Empleado, lo
siguiente es valido:
public class ImpuestoServicio {
public TasaImp buscarTasaImp(Empleado e) {
// calcula la tasa de impuesto del empleado
}
}
// Mientras tanto, en otra parte de la aplicación
ImpuestoServicio impSer = new ImpuestoServicio();
Administrador m = new Administrador();
TasaImp t = impSer.buscarTasaImp(m);

El operador instanceof
public class Empleado extends Object
public class Administrador extends Empleado
public class Ingeniero extends Empleado
----------------------------------------
public void hacerAlgo(Empleado e) {
if ( e instanceof Administrador ) {
// Procesa un Administrador
} else if ( e instanceof Ingeniero ) {
// Procesa un Ingeniero
} else {
// Procesa cualquier otro tipo de Empleado
}
}

Casting de Objetos
public void hacerAlgo(Empleado e) {
if ( e instanceof Administrador ) {
Administrador m = (Administrador) e;
System.out.println(“Este es el Administrador de ”
+ m.getDepartamento());
} // Resto del código
}

Casting de Objetos
• Use el operador instanceof para probar el tipo de
un Objeto.
• Devuelve la funcionalidad de un objeto usando
casting.
• Compruebe un correcto casting usando los
siguientes lineamientos:
• Casting hacia arriba en la jerarquía es realizado
implícitamente.

Casting de Objetos
• Casting hacia abajo debe ser a una subclase y es
chequeado por el compilador.
• El tipo del objeto es chequeado en tiempo de
ejecución cuando un error de ejecución ocurre.

Sobrecarga de Métodos
• Uso de la sobrecarga:
public void println(int i)
public void println(float f)
public void println(String s)
• Lista de argumentos debe ser diferente.
• Tipo de retorno puede ser diferente.

Métodos usando variable de
argumentos
• Los métodos usando variables de argumentos
permite múltiples números de argumentos en el
método. Por ejemplo:
public class Estadisticas {
public float promedio(int... nums) {
int sum = 0;
for ( int x : nums ) {
sum += x;
}
return ((float) sum) / nums.length;
}
}

Métodos usando variable de
argumentos
• El parámetro varargs es tratado como un arreglo.
Por ejemplo:
float gradoPromedio = stats.promedio(4, 3, 4);
float edadPromedio = stats.promedio(24, 32, 27, 18);

Sobrecarga de constructores
• public class EjemploAlcance {
• Como con los métodos, los constructores pueden
ser sobrecargados. Por ejemplo:
public Empleado(String nombre, double salario, Date fn)
public Empleado(String nombre, double salario)
public Empleado(String nombre, Date fn)
• La lista de argumentos debe ser diferente.
• Ud puede usar la referencia this como primera
linea del constructor para llamar a otro constructor.

private static final double BASE_SALARIO = 15000.00;
private String nombre;
private double salario;
private Date fechaNacimiento;

public Empleado(String nombre, double salario, Date fn) {
this. nombre = nombre;
this. salario = salario;
this.fechaNacimiento = fn;
}

public Empleado(String nombre, double salario) {
this(nombre, salario, null);
}
public Empleado(String nombre, Date fn) {
this(nombre, BASE_SALARIO, fn);
}
// mas código de Empleado...
}

Constructores no se heredan
• Una subclase hereda todos los métodos y
variables de la superclase (clase Padre).
• Una subclase no hereda el constructor de la
superclase.
• Dos formas para incluir un constructor son:
• Usar el constructor por default.
• Escribir uno o mas constructores explícitamente.

Invocando el constructor de
la superclase
• Para invocar el constructor del Padre, debe colocar
el llamado a super en la primera línea de el
constructor.
• Ud puede llamar a un constructor especifico del
Padre por los argumentos que se usen al llamar a
super.

la superclase
• Si los llamados this o super no son usados en el
constructor, entonces el compilador agrega un
llamado implícito a super() que llama al constructor
del Padre sin argumentos (el cual podría ser el
constructor por default).
• Si la clase Padre define constructores, pero no
provee uno sin argumentos, entonces el
compilador genera un mensaje de error.

la superclase
public class Administrador extends Empleado {
private String departamento;

public Administrador(String nombre, double salario, String dept) {
super(nombre, salario);
this. departamento = dept;
}

Construyendo e Inicializando
Objetos
• La memoria es asignada y la inicialización por
defecto ocurre.
• La inicialización de variables de instancia usa estos
pasos recursivamente:
1. Vincula los parámetros del constructor.
2. Si existe llamado explicito a this(), este llama
recursivamente, y salta al paso 5.

Construyendo e Inicializando
Objetos
3. Llamado recursivo de al super explicita o
implícitamente, excepto para Object.
4. Ejecuta la inicialización explicita de variables
de instancia.
5. Ejecuta el cuerpo de el actual constructor.

Ejemplo Construcción e
Inicialización
public class Object {
public Object() {}
}

Inicialización
public class Empleado extends Object {
private String nombre;
private double salario = 15000.00;
private Date fechaNacimiento;
public Empleado(String n, Date fn) {
// llamado a super() implícito;
nombre = n;
fechaNacimiento = fn;
}
public Empleado(String n) {
this(n, null);
}
}

Inicialización
public class Administrador extends Empleado {
private String departamento;

public Administrador(String n, String d) {
super(n);
departamento = d;
}
}

Inicialización
0 Inicialización básica
0.1 Asigna memoria para el objeto completo Administrador
0.2 Inicializa todas las variables de instancia con su valor por
defecto (0 or null)
1 Llama al constructor Administrador("Joe Smith", “Ventas")
1.1 Vincula los parámetros del constructor: n="Joe Smith",
d="Ventas"
1.2 No existe llamado explicito a this()
1.3 Llamado al super(n) para Empleado(String)
1.3.1 Vincula los parámetros del constructor: n="Joe Smith"
1.3.2 Llama this(n, null) para Empleado(String, Date)

Inicialización
1.3.2.1 Vincula los parámetros del constructor: n="Joe Smith",
fn=null
1.3.2.2 No existe llamado explicito a this
1.3.2.3 Llamado al super() para Object()
1.3.2.3.1 Vinculación no es necesaria
1.3.2.3.2 No existe llamado explicito a this
1.3.2.3.3 No existe llamado a super (Object es la raiz)
1.3.2.3.4 No existe inicialización explicita de variables para
Object
1.3.2.3.5 No existe cuerpo en el constructor llamado
1.3.2.4 inicialización explicita de variables de Empleado:
salario=15000.00;

Inicialización
1.3.2.5 Ejecuta el cuerpo: nombre="Joe Smith";
fechaNacimiento=null;
1.3.3 - 1.3.4 Pasos saltados
1.3.5 Ejecuta el cuerpo: No existe cuerpo en Empleado(String)
1.4 No existe inicialización explicita de variables para
Administrador
1.5 Ejecuta el cuerpo: departamento=“Ventas"

La clase Object
• La clase Object es la raíz de todas las clases en
Java
• Una declaración que no tenga la cláusula extends,
implica que hereda de Object.
public class Empleado
• Es equivalente a:
public class Empleado extends Object
• Dos métodos importantes son:
• equals()
• toString()

El método equals
• El operador == determina if dos referencias son
iguales (esto es, referenciar al mismo objeto).
• El método equals determina si los objetos son
iguales pero no necesariamente idénticos.
• La implementación de Object de el método equals
usa el operador ==.

El método equals
• Usuarios de clases pueden sobrescribir el método
equals para implementar una prueba especifica
para igualdad.
• Nota: Ud debería sobrescribir el método
hashCodemethod si sobrescribe el método equals.

Un ejemplo de equals
private int dia;
private int mes;
private int anio;

public MiFecha(int dia, int mes, int anio) {
this.dia = dia;
this.mes = mes;
this.anio = anio;
}

public boolean equals(Object o) {
boolean resultado = false;
if ( (o != null) && (o instanceof MiFecha) ) {
MiFecha d = (MiFecha) o;
if ( (dia == d.dia) && (mes == d.mes) && (anio == d.anio) ) {
resultado = true;
}
}
return resultado;
}

public int hashCode() {
return (dia ^ mes ^ anio);
}
}

class TestEquals {
public static void main(String[] args) {
MiFecha fecha1 = new MiFecha(14, 3, 1976);
MiFecha fecha2 = new MiFecha(14, 3, 1976);

if ( fecha1 == fecha2 ) {
System.out.println("fecha1 idéntica a fecha2");
} else {
System.out.println("fecha1 no es idéntica a fecha2");
}

if ( fecha1.equals(fecha2) ) {
System.out.println("fecha1 es igual a fecha2");
} else {
System.out.println("fecha1 no es igual a fecha2");
}

System.out.println(“fijar fecha2 = fecha1;");
fecha2 = fecha1;

if ( fecha1 == fecha2 ) {
System.out.println("fecha1 es idéntica a fecha2");
} else {
System.out.println("fecha1 no es idéntica a fecha2");
}
}
}

• Este ejemplo genera la siguiente salida:
fecha1 no es idéntica a fecha2
fecha1 es igual a fecha2
fijar fecha2 = fecha1;
fecha1 es idéntica a fecha2

El método toString
• El método toString() tiene las siguientes
características:
– Este método convierte un objeto en un String
– Este método se usa durante la concatenación de String
– Sobrescribir este método para proveer información sobre
un objeto definido por el usuario en formato legible.
– Usado por las clases wrappers (toString static método)
para convertir tipos primitivos a String.

Clases Wrapper
• Mirando elementos de tipo primitivo como un
objeto
Tipo de dato primitivo Clase wrapper
boolean Boolean
byte Byte
char Character
short Short
int Integer
long Long
float Float
double Double

Clases Wrapper
• Un ejemplo para la clase wrapper es:
int pInt = 420;
Integer wInt = new Integer(pInt); // Esto es llamado boxing
int p2 = wInt.intValue(); // Esto es llamado unboxing
• Otros métodos son:
int x = Integer.valueOf(str).intValue();
int x = Integer.parseInt(str);

Autoboxing de tipos
primitivos
• Autoboxing tiene la siguiente descripción:
• Conversión de tipos primitivos a los objetos
equivalentes
• Las clases wrapes no son siempre necesarias
• Ejemplo:
int pInt = 420;
Integer wInt = new Integer(pInt); // Esto es autoboxing
int p2 = wInt.intValue(); // Esto es autoboxing

Autoboxing de tipos
primitivos
• Wrapped primitivos también son usables en
expresiones aritméticas.

Información básica Java

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Información básica Java

Similar a Información básica Java (20)

Información básica Java