Download Conceptos Básicos de Java

Conceptos Básicos de Java
1
Conceptos Básicos de Java
Características de la Programación en Java
 Sensible a mayúsculas/minúsculas.
 Palabras reservadas.
 Comentarios.
 Lenguaje de formato libre.
 Identificadores.
 Variables y constantes.
 Convenciones de nomenclatura.
 Tipos de datos.
 Operadores.
2
Conceptos Básicos de Java
Características de la Programación en Java (2)
Sensible a mayúsculas/minúsculas
 Se distingue entre mayúsculas y minúsculas.
 Los identificadores Cat, cat y CAT son diferentes.
 Todas las palabras reservadas del lenguaje van en minúsculas.
Palabras reservadas
3
Conceptos Básicos de Java
Paquetes
Paquetes: es un conjunto de clases e interfaces relacionadas que proveen acceso protegido y
administración de nombres.
 Las clases e interfaces que son parte de la Plataforma Java están agrupadas
en paquetes de acuerdo a su función:
java.applet : para manejo de Applets.
java.io: para manejo de entrada/salida.
java.awt: para manejo de la GUI.
 El programador agrupa sus clases e interfaces en paquetes, anteponiendo la claúsula
package NombreDel Paquete a las declaraciones de todas las clases e interfaces agrupadas.
 La plataforma JAVA importa automáticamente los siguientes paquetes: el default package, el
paquete java.lang y el paquete actual.
 El alcance de la sentencia package es todo el archivo fuente.
Ejemplo:
4
Conceptos Básicos de Java
Paquetes (2)
Sentencia import: indica al compilador dónde están ubicadas las clases que estamos
importando.
Ejemplos:
 Para importar sólo una clase de un paquete:
import <nombre.paquete>.<NombreClase>;
import java.lang.String;
 Para importar todas las clases de un paquete:
import
<nombre.paquete>.*;
import java.lang.*;
5
Conceptos Básicos de Java
Características de la Programación en Java (3)
Comentarios.
Existen tres formas de introducir comentarios:
 Comentario en una línea
// Comentario de una línea
 Comentario en una o más líneas
/* Comentario de más de
una línea */
 Comentario de documentación. Se usa con javadoc
/** Método XYZ:
Realiza la labor X sobre los datos Y
devolviendo Z */
javadoc Fichero.java
> Fichero.html
6
Conceptos Básicos de Java
Características de la Programación en Java (4)
Lenguaje de formato libre.
 La disposición de los elementos dentro del código es libre.
 Sentencias: línea simple de código terminada en “;”
total = a + b + c + d ;
 Bloque de código: conjunto de sentencias agrupadas entre llaves
{
x = x + 1;
y = y + 1;
}
 Java permite espacios en blanco entre elementos del código
x1 = y * delta ;
x2 = (y+1) * delta ;
7
Conceptos Básicos de Java
Características de la Programación en Java (5)
Identificadores





Son nombres de clases, variables o métodos.
No tienen longitud máxima.
El primer carácter del identificador debe ser: A-Z, a-z, _, $.
El resto: A-Z, a-z, _, $, 0-9.
No se permite utilizar palabras reservadas como identificador.
Ejemplos válidos
Ejemplos NO válidos Razón
anioDeNacimiento2
_otra_variable
3valores
(número como primer
carácter)
Dia&mes
&
Dos más
(espacio)
Dos-valores
–
NombreDeVariableMuyLargoNoImporta
BotonPulsacion
8
Conceptos Básicos de Java
Características de la Programación en Java (6)
Variables y constantes
 Variables: zona de memoria cuyos valores van a cambiar durante la ejecución
<tipo> <identificador> ;
ó
<tipo> <identificador> , <identificador> ... ;
ejemplo:
int x, y, z ;
 Constantes: zona de memoria cuyos valores no cambian
final <tipo> <identificador> = <valor> ;
ejemplo: final double PI = 3.14159265 ;
 Asignación de Variables: se utiliza el operador asignación “=“
<variable> = <expresión> ;
La parte izquierda siempre debe ser una variable.
La parte derecha puede ser un literal, una variable, una expresión, una función o una combinación de todos.
Se puede asignar un valor a una variable en el momento de declararla.
ejemplo: int i = 0 ;
9
Conceptos Básicos de Java
Características de la Programación en Java (7)
Convenciones de nomenclatura
 Los identificadores que proporciona Java siguen una convención según el elemento:
Clases: primera letra en mayúscula de cada palabra
ejemplo: Empleado, LibroDeCuentas, String
Variables: primera letra en minúscula y la primera letra de cada palabra en mayúscula
ejemplo: contador, numeroTotalAccesos, string
Constantes: todo en mayúsculas, separando cada palabra por el carácter “_”
ejemplo: PI, ANCHO_IMAGEN
Métodos: siguen el mismo formato que las variables seguidas de paréntesis “(“ “)”
ejemplo: sumar(), obtenerResultado()
Estructuras de control: utilizar llaves englobando a todas las sentencias de una estructura de
control, aunque sólo haya una sentencia
ejemplo: if ( <condición> ) {
// hacer algo
}else{
// hacer otra cosa
}
10
Conceptos Básicos de Java
Características de la Programación en Java (8)
Tipos de Datos
 Los tipos primitivos son ocho agrupados en cuatro
lógico: boolean
texto: char
entero: byte, short, int, long
real: float, double
Tipos Primitivos
Tipo Lógico
Tipos Numéricos
Integrales
boolean
Caracteres
Números Enteros
char
byte short int long
Punto Flotante
float double
 Los tipos referencia son punteros a objetos
11
Conceptos Básicos de Java
Características de la Programación en Java (9)
Tipos de Datos
 Tipos Primitivos
12
Conceptos Básicos de Java
Características de la Programación en Java (10)
Tipos de Datos
 Tipos Referencia
 Un tipo referencia guarda un puntero a la dirección donde se ubica el objeto
 Sólo puede almacenar direcciones de objetos de su propio tipo
 Todas las clases son de tipo referencia
 El valor que toma por defecto una variable de tipo referencia es null
13
Conceptos Básicos de Java
Características de la Programación en Java (11)
Tipos de Datos
Conversión de tipos
 La conversión de tipos (casting) se debe realizar entre tipos de la misma naturaleza:
numéricos o referencia
 Al convertir un tipo a un tamaño más pequeño se puede perder la información de los
bits de mayor peso
 La sintaxis es: (<tipo>) <expresión>
ejemplo: byte num8bits = (byte) 27 ;
int num32bits = 27 ;
num8bits = (byte) num32bits ;
14
Conceptos Básicos de Java
Características de la Programación en Java (12)
Operadores
 Operadores unarios: +,  Operadores aritméticos: +, -, *, /, % (resto de la división)
 Operadores de asignación: =, +=, -=, *=, /=, %=
<var> += <expr> => <var> = <var> + <expr>
 Operadores incrementales: ++, -siguiendo a la variable: <var>++, <var>-ejemplo: i=6;
j=i++; => j=i; i=i+1;
// resultado i=7 , j=6
precediendo a la variable: ++<var>, --<var>
ejemplo: i=6;
j=++i; => i=i+1; j=i;
// resultado i=7 , j=7
 Operadores relacionales: == (igual), != (distinto), >, <, >=, <=
15
Conceptos Básicos de Java
Características de la Programación en Java (13)
Operadores
 Operadores lógicos: && (AND), || (OR), ! (NOT), & (AND), | (OR)
&& y || realizan evaluación perezosa:
op1 && op2 => si op1 es false, no se evalúa op2
op1 || op2 => si op1 es true, no se evalúa op2
& y | siempre evalúan los dos operadores
 Operador instanceof: <objeto> instanceof <clase> determina si un objeto
pertenece a una clase
 Operador condicional: ? :
<exprBooleana> ? <valor1> : <valor2>
Permite bifurcaciones condicionales sencillas
 Operadores a nivel de bits: >>, <<, >>>, &, |, ^, ~
16
^ es el XOR
xor 0
0
1
0
1
6^3=5
1
1
0
~ es el complemento
-3 -2
110 con 11
110
11
101 =5
El cero pertenece a los naturales
-1
0
1
2
3
~2 = -3
~-2 = 1
17
<< corrimiento a la izquierda
>> corrimiento a la derecha
1
27
128
26
1
0
1
0
13<<1=26
1
1
0
13>>1=6
1
1
0
1
=13
25
24
23
22
21
20
32
16
8
4
2
1
64
1 byte = 8 bits
18
Conceptos Básicos de Java
Control de Flujo
 Las sentencias de control del flujo de ejecución permiten tomar decisiones y realizar un
proceso repetidas veces
 Hay dos tipos principales de sentencias de control de flujo:
Condicionales: if, switch
Bucles: for, while, do while
 Otras sentencias que permiten interrumpir el flujo normal de ejecución son break y
continue
19
Conceptos Básicos de Java
Control de Flujo (2)
if
if (<exprBooleana>)
if (cont == 0)
System.out.println(“cont = cero”);
<sentencia> ;
-------------------------------------------------------
if (<exprBooleana>) {
-------------------------------------------------------------------------------
if (cont == 0) {
System.out.println(“cont = cero”);
System.out.println(“otra sentencia”);
<grupoSentencias>;
}
}
-------------------------------------------------------
if (<exprBooleana>) {
-------------------------------------------------------------------------------
if (cont == 0) {
<grupoSentencias>;
}else{
System.out.println(“cont = cero”);
}else{
<grupoSentencias>;
}
-------------------------------------------------------
if (<exprBooleana>) {
<grupoSentencias>;
}else if (<exprBooleana>){
<grupoSentencias>;
}else{
<grupoSentencias>;
}
System.out.println(“cont != cero”);
}
-------------------------------------------------------------------------------
if (nota<4) {
System.out.println("Insuficiente");
}else if (nota<6) {
System.out.println("Suficiente");
}else{
System.out.println(“Muy Bien");
}
20
Conceptos Básicos de Java
Control de Flujo (3)
switch
switch ( <variable> ) {
case literal1:
[<grupoSentencias1>;]
[break;]
int día = 4;
switch (día) {
case 1: System.out.println("Lunes");
break;
case 2: System.out.println("Martes");
break;
case literal2:
[<grupoSentencias2>;]
[break;]
...
case 3: System.out.println("Miércoles");
break;
case 4: System.out.println("Jueves");
break;
case 5: System.out.println("Viernes");
break;
case literalN:
[<grupoSentenciasN>;]
[break;]
case 6: System.out.println("Sábado");
break;
case 7: System.out.println("Domingo");
break;
[default:<grupoSentencias>;]
}
default: System.out.println(“Error");
}
21
Conceptos Básicos de Java
Control de Flujo (4)
for
for ( <inicialización>; <exprBooleana>; <actualización> ) {
<grupoSentencias>;
}
<inicialización> asignación del valor inicial de las variables que intervienen en la expresión
<exprBooleana> condición booleana
<actualización> nuevo valor de las variables en <inicialización>
for ( int i = 0; i < 10; i++ ) {
System.out.println(“valor del contador: “ + i );
}
22
Conceptos Básicos de Java
Control de Flujo (5)
while
while (<exprBooleana>){
<grupoSentencias>;
int cont = 0;
while (cont++ < 10) {
}
System.out.println(“contador:“ + i );
}
do while
do{
int cont = 0;
<grupoSentencias>;
}while (<exprBooleana>);
do{
System.out.println(“contador:“ + i );
} while (cont++ < 10);
23
Conceptos Básicos de Java
Control de Flujo (6)
Break
La instrucción break sirve para abandonar una estructura de control, tanto de las alternativas (if-else y
switch) como de las repetitivas o bucles (for, do-while y while). En el momento que se ejecuta la instrucción
break, el control del programa sale de la estructura en la que se encuentra.
int i;
for (i=1; i<=4; i++) {
if (i==3) break;
System.out.println("Iteración: "+i);
}
resultado
Iteración: 1
Iteración: 2
Continue
La instrucción continue sirve para transferir el control del programa desde la instrucción continue
directamente a la cabecera del bucle (for, do-while o while) donde se encuentra.
int i;
for (i=1; i<=4; i++) {
if (i==3) continue;
System.out.println("Iteración: "+i);
}
resultado
Iteración: 1
Iteración: 2
Iteración: 4
24
Ejemplo de uso Array
Declaración
char s[];
Point p[];
char[] s;
Point[] p;
Un array es un objeto.
Se crea con new
public char[] createArray() {
char[] s;
s = new char[26];
for ( int i=0; i<26; i++ ) {
s[i] = (char) (’A’ + i);
}
return s;
}
public void printElements(int[] list) {
for (int i = 0; i < list.length; i++) {
System.out.println(list[i]);
}}
Longitud del array
25
Ejemplo de uso Array
Crear un Array con valores iniciales
1)
String[] names;
names = new String[3];
names[0] = "Georgianna";
names[1] = "Jen";
names[2] = "Simon";
2)
String[] names = {
"Georgianna",
"Jen",
"Simon"
};
1)
MyDate[] dates;
dates = new MyDate[3];
dates[0] = new MyDate(22, 7, 1964);
dates[1] = new MyDate(1, 1, 2000);
dates[2] = new MyDate(22, 12, 1964);
2)
MyDate[] dates = {
new MyDate(22, 7, 1964),
new MyDate(1, 1, 2000),
new MyDate(22, 12, 1964)
};
26
Ejemplo de uso Array
Multidimensional (matrices)
int[][] twoDim = new int[4][];
twoDim[0] = new int[5];
twoDim[1] = new int[5];
int[][] twoDim = new int[][4]; // illegal
int[][] twoDim = new int[4][5];
String [][] ciudades={{"BsAs","Sao Pablo","Madrid"},
{"Argentina","Brasil","España"}};
for ( int i=0; i<ciudades.length; i++ ) {
for (int j=0; j<ciudades[i].length; j++ ) {
System.out.println(ciudades[i][j]) ;
} }
27
Recorriendo Array
public void printElements(int[] list) {
for ( int element : list ) {
System.out.println(element);
}
}
Este FOR, puede ser leido como:
Para cada elemento en list hacer.
28
Redimensionando un Array
NO SE PUEDE HACER
Qué hacemos entonces?
Usamos ARRAYCOPY
int[] myArray = { 1, 2, 3, 4, 5, 6 };
// nuevo array más grande
int[] hold = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
// copia todo lo de myArray al array hold
System.arraycopy(myArray, 0, hold, 0, myArray.length);
29
Conceptos Básicos de Java
Clases
public class Fecha {
private int dia;
Variable
private int mes;
Constructor
private int anio;
public Fecha(int vdia, int vmes, int vanio) {
dia = vdia;
mes = vmes;
anio = vanio;
Método
}
public void mostrarFecha() {
System.out.println (dia+”/”+mes+”/”+anio);
}
public static void main(String[] args) {
Fecha MiFecha = new Fecha(10, 08, 2003);
}
Método principal de la aplicación
}
Creación de un objeto
30
Conceptos Básicos de Java
Clases (2)
Creación de Objetos
 Se utiliza la palabra reservada new
<NombreClase> <refObjeto>;
<refObjeto> = new <NombreClase>() ;
ó <NombreClase> <refObjeto> = new <NombreClase>() ;
ejemplo: Fecha MiFecha ;
MiFecha
????
MiFecha = new Fecha (10, 08, 2003) ;
MiFecha
0xFFFF0000
dia
10
mes
08
anio
2003
31
Conceptos Básicos de Java
Clases (3)
Modificadores de clase: son palabras reservadas que se anteponen a la declaración de clase.
Sintaxis: modificador class NombreClase
Los modificadores posibles son los siguientes:
 public. Toda clase public debe ser declarada en un fichero
fuente con el nombre de esa clase pública: NombreClase.java. De
esta afirmación se deduce que en un fichero fuente puede haber más
de una clase, pero sólo una con el modificador public.
 abstract. Las clases abstractas no pueden ser instanciadas.
Sirven únicamente para declarar subclases que deben
aquellos métodos que han sido declarados abstract.
redefinir
 final.
Una clase declarada final impide que pueda ser
superclase de otras clases. Dicho de otra forma, ninguna clase
puede heredar de una clase final.
32
Conceptos Básicos de Java
Clases (4)
Modificadores de Ámbito
33
Conceptos Básicos de Java
Clases (5)
Modificadores de Ámbito
34
Conceptos Básicos de Java
Clases (6)
Modificadores de Ámbito
35
Conceptos Básicos de Java
Clases (7)
Modificadores de Ámbito
36
Conceptos Básicos de Java
Clases (8)
Modificadores de Ámbito
37
Conceptos Básicos de Java
Clases (9)
Atributos: sirven para almacenar valores de los objetos que se instancian a partir de una clase.
Sintaxis:
[modifÁmbito][static][final][transient][volatile]
tipo
nombreAtributo
Tipos de Atributos:
 de Objeto: son variables u objetos que almacenan valores distintos para instancias
distintas de la clase (para objetos distintos).
 de Clase: son variables u objetos que almacenan el mismo valor para todos los objetos
instanciados a partir de esa clase.
Declaración de Atributos:
 static.
Mediante la palabra reservada static se declaran
atributos de clase.
 final. Sirve para declarar constantes, no se permite la
modificación de su valor.
 otros modificadores: transient, volatile.
 modific. de ámbito: public, protected, private, (default)
38
Conceptos Básicos de Java
Clases (10)
Ámbito de una variable. En Java se dispone de tres tipos de variables:
 Variables miembro pertenecientes a una clase
 Argumentos de un método de la clase
 Variables locales de un método de la clase
ejemplo:
class Ejemplo {
int x ;
void metodo ( int y ){
int z ;
x = y + z ;
}
}
// variable miembro
// argumento
// variable local
 Las variables miembro son visibles desde cualquier parte de la clase
 Los argumentos y variables locales sólo son visibles dentro del método al que
pertenecen. Dejan de existir al finalizar el método.
39
Conceptos Básicos de Java
Métodos
Los Métodos son bloques de código (subprogramas) definidos dentro de una clase.
Sintaxis: <tipoRetorno> <nombreMétodo> ( <listaArgumentos> )
donde <tipoRetorno> tipo devuelto por el método.
<nombreMétodo> identificador válido en Java.
<listaArgumentos> sucesión de pares tipo-valor separados por coma
ejemplo:
String darFormato (String dia, String mes, String anio) {
String s ;
s = dia + “/” + mes + “/” + anio ;
return s ;
}
 Un método tiene acceso a todos los atributos de su clase.
 Pueden ser llamados o invocados desde cualquier sitio.
 Un método puede invocar a otros métodos.
 En Java no se puede definir un método dentro de otro.
 La ejecución de todos los programas se inician con el método main().
40
Conceptos Básicos de Java
Métodos (2)
Modificadores de métodos:
Sintaxis:
[ModificadorDeÁmbito] [static][abstract][final][native][synchronized]
TipoDevuelto NombreMétodo ([ListaParámetros])
Los modificadores posibles son los siguientes:
 static. Los métodos static son métodos de clase (no de objeto)
y por tanto, no necesita instanciarse la clase (crear un objeto de
esa clase) para poder llamar a ese método.
 abstract. Se declaran en las clases abstract. Cuando se
declara un método abstract, no se implementa el cuerpo del método,
sólo su signatura.
 final. Los métodos de una clase que se declaran de tipo final
no pueden ser redefinidos por las subclases.
 native. Los métodos native, son métodos que se encuentran
escritos en otro lenguaje de programación distinto a Java (ej: C).
 synchronized. Son métodos especiales para cuando varios
threads (subprocesos) pueden acceder concurrentemente a los mismos
datos y se desea que una sección crítica se proteja (bloquee) para
que los threads accedan en exclusión mutua a la misma.
41
Conceptos Básicos de Java
Métodos (3)
Constructor: es un método especial de las clases que sirve para inicializar los objetos que se
instancian como miembros de una clase.
public class Fecha {
private int dia;
private int mes;
private int anio;
public Fecha(int vdia, int vmes, int vanio) {
dia = vdia;
mes = vmes;
anio = vanio;
}
public void mostrarFecha() {
System.out.println (dia+”/”+mes+”/”+anio);
}
public static void main(String[] args) {
Fecha MiFecha = new Fecha(10, 08, 2003);
}
}
42
Conceptos Básicos de Java
Referencia this
this: es una palabra clave que hace referencia al objeto o instancia actual.
Usos:
 Cuando se hace referencia a una variable miembro cuyo identificador coincide con el identificador
de un parámetro.
public class Fecha {
private int dia;
private int mes;
private int anio;
public Fecha(int dia, int mes, int anio) {
this.dia = dia;
this.mes = mes;
this.anio = anio;
}
public void mostrarFecha() {
System.out.println (dia+”/”+mes+”/”+anio);
}
public static void main(String[] args) {
Fecha MiFecha = new Fecha(10, 08, 2003);
}
43
}
Conceptos Básicos de Java
Referencia this (2)
 Cuando se hace referencia al objeto actual en un método que devuelve un objeto del tipo de
referencia.
public class Fecha {
private int dia;
private int mes;
private int anio;
public Fecha(int dia, int mes, int anio) {
this.dia = dia;
this.mes = mes;
this.anio = anio;
}
public Fecha getObjetoFecha() {
return this;
}
public static void main(String[] args) {
Fecha MiFecha = new Fecha(10, 08, 2003);
Fecha MiFecha2 = MiFecha.getObjetoFecha();
}
}
44
Conceptos Básicos de Java
Referencia this (3)
 Cuando se invoca a otros constructores de la clase.
public class Fecha {
private int dia;
private int mes;
private int anio;
public Fecha(int dia, int mes, int anio) {
this.dia = dia;
this.mes = mes;
this.anio = anio;
}
public Fecha() {
this(01,01,1900);
}
public static void main(String[] args) {
Fecha MiFecha = new Fecha(10, 08, 2003);
Fecha MiFecha2 = new Fecha();
}
}
45
Conceptos Básicos de Java
Herencia
Herencia: es el mecanismo por el que se crean nuevos objetos definidos en términos de
objetoa ya existentes.
Sintaxis:
class NombreClaseHija extends NombreClasePadre
class Padre {
String variable;
void metodo() {
variable = “Padre”;
}
}
class Hija extends Padre {
String variable;
void metodo() {
variable = “Hija”;
super.metodo();
System.out.println(variable);
System.out.println(super.variable);
}
}
46
Herencia Simple
public class Employee {
public String name = "";
public double salary;
public Date birthDate;
public String getDetails() {...}
}
public class Manager extends
Employee {
public String department;
}
47
Conceptos Básicos de Java
Herencia (2)
48
Visibilidad o Acceso
49
Overriding de métodos en herencia
public class Employee {
protected String name;
protected double salary;
protected Date birthDate;
public String getDetails() {
return “Name: “ + name + “\n” + “Salary: “ + salary;
}
}
public class Manager extends Employee {
protected String department;
public String getDetails() {
return “Name: “ + name + “\n” + “Salary: “ + salary + "\n" + “Manager of: “ + department;
}
}
50
Los métodos overridden NO
PUEDEN ser menos accesibles
public class Parent {
public void doSomething() {}
}
public class Child extends Parent {
private void doSomething() {} // illegal
}
public class UseBoth {
public void doOtherThing() {
Parent p1 = new Parent();
Parent p2 = new Child();
p1.doSomething();
p2.doSomething();
}
}
51
Conceptos Básicos de Java
Referencia super
super: es una palabra clave que se utiliza para referenciar atributos o métodos de la superclase
que han sido sobrescritos por la clase hija.
Usos:
 Cuando se hace referencia a un atributo de la clase padre.
class Padre {
String variable;
void metodo() {
variable = “Padre”;
}
}
class Hija extends Padre {
String variable;
void metodo() {
variable = “Hija”;
super.metodo();
System.out.println(variable);
System.out.println(super.variable);
}
}
52
Conceptos Básicos de Java
Referencia super (2)
 Cuando se hace referencia a un método de la clase padre.
class Padre {
String variable;
void metodo() {
variable = “Padre”;
}
}
class Hija extends Padre {
String variable;
void metodo() {
variable = “Hija”;
super.metodo();
System.out.println(variable);
System.out.println(super.variable);
}
}
53
Conceptos Básicos de Java
Referencia super (3)
 Cuando se hace referencia a un constructor de la clase padre.
class Padre {
String variable;
public Padre(String nombrevar) {
variable = nombrevar;
}
}
class Hija extends Padre {
String variable;
public Hija() {
super(“Padre”);
variable = “Hija”;
}
}
54
Conceptos Básicos de Java
Super
public class Manager extends Employee {
protected String department;
public String getDetails() {
return “Name: “ + name + “\n” + “Salary: “ + salary + "\n" + “Manager of: “ + department;
}
}
public String getDetails() {
return super.getDetails() + “\nDepartment: " + department;
}
55
Conceptos Básicos de Java
Polimorfismo
Polimorfismo: indica “muchas formas”. Una clase sólo tiene una forma, pero una variable que
hace referencia a la superclase de una jerarquía puede tener muchas formas (una por cada
subclase).
56
Objetos Polimórficos
Employee [] staff = new Employee[1024];
staff[0] = new Manager();
staff[1] = new Employee();
staff[2] = new Engineer();
public class TaxService {
public void chargeTax(){
TaxService taxSvc = new TaxService();
Manager m = new Manager();
TaxRate t = taxSvc.findTaxRate(m);
}
public TaxRate findTaxRate(Employee e) { …}
}
57
Operador instanceof
public class Employee extends Object
public class Manager extends Employee
public class Engineer extends Employee
---------------------------------------public void doSomething(Employee e) {
if ( e instanceof Manager ) {
…..
} else if ( e instanceof Engineer ) {
…..
} else {
……
}
}
58
Casting de objetos
public void doSomething(Employee e) {
if ( e instanceof Manager ) {
Manager m = (Manager) e;
System.out.println(“This is the manager of ” + m.getDepartment());
}
…..
}
59
Conceptos Básicos de Java
Clases Abstractas
Clases Abstractas: una clase abstracta representa un concepto abstracto.
 Una clase abstracta sólo puede ser heredada, pero nunca puede ser instanciada.
 Se declara anteponiendo el modificador abstract a la palabra clave class.
 Una clase abstracta puede contener métodos abstractos y métodos con implementación.
 Un método es abstracto si se declara con el modificador abstract (dentro de una clase
abstracta), pero no se implementa.
 Las subclases de una clase abstracta deben implementar los métodos abstractos que tenga
definidos.
Sintaxis:
abstract class NombreClase
60
Conceptos Básicos de Java
Clases Abstractas (2)
Ejemplo:
61
Conceptos Básicos de Java
static
Ejemplo para atributos:
public class Count {
private int serialNumber;
public static int counter = 0;
public Count() {
counter++;
serialNumber = counter;
}
}
public class OtherClass {
public void incrementNumber() {
Count.counter++;
}
}
62
llamando desde otra clase
Conceptos Básicos de Java
Static
Ejemplo para métodos:
public class TestCounter {
public class Count2 {
public static void main(String[] args) {
private int serialNumber;
System.out.println("Number of counter is "
private static int counter = 0;
+ Count2.getTotalCount());
public static int getTotalCount() { Count2 counter = new Count2();
return counter;
System.out.println("Number of counter is "
}
+ Count2.getTotalCount());
public Count2() {
}
counter++;
}
serialNumber = counter;
}
63
}
llamando desde otra clase
Conceptos Básicos de Java
Static
Ejemplo para métodos:
Los métodos static no pueden ser accedidos como
variables de instancia !!!!
public class Count3 {
private int serialNumber;
private static int counter = 0;
public static int getSerialNumber() {
return serialNumber; // COMPILER ERROR!
}
}
64
Conceptos Básicos de Java
Inicializadores Static Ejemplo :
public class Count4 {
public static int counter;
static {
counter = Integer.getInteger("myApp.Count4.counter").intValue();
}
}
public class TestStaticInit {
public static void main(String[] args) {
System.out.println("counter = "+ Count4.counter);
}
}
65
Conceptos Básicos de Java
Interfaces
Interfaces: una interfaz es una colección de definiciones de métodos sin implementación y
declaraciones de constantes, agrupadas bajo un nombre.
 Define un protocolo de comportamiento que debe ser implementado por cualquier clase que
pretenda utilizar ciertos servicios, con independencia de las relaciones jerárquicas.
 Las interfaces sirven para:
 Declarar métodos que serán implementados por una o más clases. Define un conjunto de métodos
pero no los implementa.
 Definir la interfaz de programación de un objeto, sin mostrar el cuerpo actual de la clase.
 Una interfaz permite a objetos no relacionados interactuar.
 Una clase que implementa una interfaz debe implementar cada uno de los métodos que ésta
define.
 Una interfaz puede extender múltiples interfaces. Por lo tanto, se tiene herencia múltiple de
interfaces. Una interfaz sólo puede ser extendida por otra interfaz.
 Una clase puede implementar varias interfaces.
66
Conceptos Básicos de Java
Interfaces
Declaracion:
67
Conceptos Básicos de Java
Interfaces
Representación en UML:
public class Airplane implements Flyer {
public void takeOff() {…}
public void land() {….}
public void fly() {….}
}
public interface Flyer {
public void takeOff();
public void land();
public void fly();
}
68
Conceptos Básicos de Java
Interfaces
Representación en UML:
69
Control de Flujo de las instrucciones
de
• Selección :
– if, if-else y switch.
• Iteración :
– while, do-while y for.
• Transferencia :
– break, continue, return, try-catch-finally y
assert.
70
Ejemplo
71
Ejemplo mejorado
72
Try-catch, con múltiples catch
73
Usando finally
Siempre se ejecuta
74
Categorias de Exception
75
THROWS
Try - catch
Intentando atrapar ….
?
76
THROWS
77
Ejemplo de Throws
78
Clase personal hija de Exception
79
Captura de nuestra Exception
80
Ejercicio
81
System Properties
• Lo usamos para dialogar con las variables del
entorno del sistema operativo
• System.getProperties, devuelve un objeto
Properties
• System.getProperty, devuelve un String con el
valor de determinada propiedad
• El objeto Properties tiene un método
propertiesNames() que se recorre con un
Enumeration
82
Ejemplo
83
Consola I/O
• System.out : salida estándar al monitor
– Genera un objeto de tipo PrintStream
• System.in : entrada estándar del teclado
– Genera un objeto de tipo InputStream
• System.err : escribe un error estándar
84
Ejemplo para leer del teclado
85
Otro Ejemplo para leer del teclado
86
Files
Import java.io
File myFile;
myFile = new File("myfile.txt");
myFile = new File("MyDocs", "myfile.txt");
87
Leer y Escribir Files
• Para Leer:
– FileReader (lee caracteres)
– BufferedReader (tiene declarado el método
readLine)
• Para Escribir:
– FileWriter (escribe caracteres)
– PrintWriter (tiene declarado los métodos print y
println)
88
Ejemplo de Lectura de un File
89
Ejemplo de Escritura de un File
90
Collections
• Un Collection es un objeto que representa
un grupo de objetos conocidos como
elementos
91
Colección ordenada
CON elementos duplicados
Colección desordenada
SIN elementos duplicados
92
Ejemplo para SET
import java.util.*;
public class SetExample {
public static void main(String[] args) {
Set set = new HashSet();
set.add("one");
set.add("second");
set.add("3rd");
set.add(new Integer(4));
set.add(new Float(5.0F));
set.add("second"); // duplicate, not added
set.add(new Integer(4)); // duplicate, not added
System.out.println(set);
}
}
Imprime:
[one, second, 5.0, 3rd, 4]
93
Ejemplo para LIST
import java.util.*
public class ListExample {
public static void main(String[] args) {
List list = new ArrayList();
Imprime:
list.add("one");
[one, second, 3rd, 4, 5.0, second, 4]
list.add("second");
list.add("3rd");
list.add(new Integer(4));
list.add(new Float(5.0F));
list.add("second"); // duplicate, is added
list.add(new Integer(4)); // duplicate, is added
System.out.println(list);
}
94
}
Collections desde la versión 1.1
• La clase Vector implementa la interface List.
• La clase Stack es una subclase de Vector y soporta
los métodos push, pop, y peek.
• La clase Hashtable implementa la interface Map.
• La interface Enumeration es una variación de la
interface Iterator.
Un enumeration es devuelto en los métodos de
Vector, Stack, y Hashtable.
95
Collections : Generics
• Elimina la necesidad de hacer casting
Antes de Generics
ArrayList list = new ArrayList();
list.add(0, new Integer(42));
int total = ((Integer)list.get(0)).intValue();
Después de Generics
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(0, new Integer(42));
int total = list.get(0).intValue();
96
97
Iterators
• Iteration es el proceso de recuperar cada elemento en una collecion.
• Un Iterator de un Set está desordenado.
• Un ListIterator de un List puede ser escaneado hacia adelante (usando el
método next ) o hacia atrás (usando el método previous).
Ejemplo:
List list = new ArrayList();
add some elements
Iterator elements = list.iterator();
while ( elements.hasNext() ) {
System.out.println(elements.next());
}
98
Jerarquía de Iterator en el API
99
FOR: para recorrer Collections
• Usando FOR con iterators:
public void deleteAll(Collection<NameList> c){
for ( Iterator<NameList> i = c.iterator() ;
i.hasNext() ; ){
NameList nl = i.next();
nl.deleteItem();
• Usando FOR con Collecion:
}
public void deleteAll(Collection<NameList> c){
}
for ( NameList nl : c ){
nl.deleteItem();
}
}
100
FOR: para recorrer Collections
• Usando FOR con arrays:
public int sum(int[] array){
int result = 0;
for ( int element : array ) {
result += element;
}
return result;
}
• Usando FOR anidados:
List<Subject> subjects=...;
List<Teacher> teachers=...;
List<Course> courseList = new
ArrayList<Course>();
for ( Subject subj : subjects ) {
for ( Teacher tchr : teachers ) {
courseList.add(new Course(subj, tchr));
}
}
101