1 conceptos básicos de java. 2 características de la programación en java sensible a...

1

Conceptos Básicos de JavaConceptos Básicos de Java

2


Características de la Programación en JavaCaracterí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.

3


Características de la Programación en Java (2)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

4


PaquetesPaquetesPaquetes: 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 agrupadasen 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:

5


Paquetes (2)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.*;

6


Características de la Programación en Java (3)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

7


Características de la Programación en Java (4)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ódigox1 = y * delta ;

x2 = (y+1) * delta ;

8


Características de la Programación en Java (5)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

anioDeNacimiento2_otra_variable

NombreDeVariableMuyLargoNoImporta

BotonPulsacion

Ejemplos NO válidos Razón

3valores (número como primer carácter)

Dia&mes &

Dos más (espacio)

Dos-valores –

9


Características de la Programación en Java (6)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 ;

10


Características de la Programación en Java (7)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

}

11

Características de la Programación en Java (8)Características de la Programación en Java (8)Tipos de Datos

Los tipos primitivos son ocho agrupados en cuatrológico: boolean

texto: charentero: byte, short, int, long

real: float, double

Tipos Primitivos

Tipo Lógico Tipos Numéricos

Integrales Punto Flotante

Caracteres Números Enteros

boolean char byte short int long float double

Los tipos referencia son punteros a objetos


12


Características de la Programación en Java (9)Características de la Programación en Java (9)Tipos de Datos Tipos Primitivos

13


Características de la Programación en Java (10)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

14


Características de la Programación en Java (11)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 ;

15


Características de la Programación en Java (12)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), >, <, >=, <=

16


Características de la Programación en Java (13)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: >>, <<, >>>, &, |, ^, ~

17

xor 0 1

0 0 1

1 1 0

6^3=5 110 con 11 110 11101 =5

-3 -2 -1 0 1 2 3

El cero pertenece a los naturales

~2 = -3

~-2 = 1

~ es el complemento

^ es el XOR

18

<< corrimiento a la izquierda

>> corrimiento a la derecha

27 26 25 24 23 22 21 20

8 4 2 1128 64 32 16

1 1 0 1 =13

13>>1=61 1 0

1 1 0 1 0 13<<1=26

1 byte = 8 bits

19


Control de FlujoControl 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

20


Control de Flujo (2)Control de Flujo (2)if

if (<exprBooleana>)<sentencia> ;

-------------------------------------------------------

if (<exprBooleana>) {

<grupoSentencias>; }

-------------------------------------------------------

if (<exprBooleana>) {<grupoSentencias>; }else{


-------------------------------------------------------

if (<exprBooleana>) {<grupoSentencias>; }else if (<exprBooleana>){

<grupoSentencias>; }else{


if (cont == 0) System.out.println(“cont = cero”);

-------------------------------------------------------------------------------

if (cont == 0) { System.out.println(“cont = cero”); System.out.println(“otra sentencia”);}

-------------------------------------------------------------------------------

if (cont == 0) { System.out.println(“cont = cero”);}else{ 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");}

21


Control de Flujo (3)Control de Flujo (3)switch

switch ( <variable> ) {

case literal1: [<grupoSentencias1>;] [break;]

case literal2: [<grupoSentencias2>;] [break;] ...

case literalN: [<grupoSentenciasN>;] [break;]

[default:<grupoSentencias>;]}

int día = 4;switch (día) { case 1: System.out.println("Lunes"); break;

case 2: System.out.println("Martes"); break;

case 3: System.out.println("Miércoles"); break;

case 4: System.out.println("Jueves"); break;

case 5: System.out.println("Viernes"); break;

case 6: System.out.println("Sábado"); break;

case 7: System.out.println("Domingo"); break;

default: System.out.println(“Error"); }

22


Control de Flujo (4)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 );

}

23


Control de Flujo (5)Control de Flujo (5)while

while (<exprBooleana>){

<grupoSentencias>;

}

int cont = 0;

while (cont++ < 10) {

System.out.println(“contador:“ + i );

}

do while

do{

<grupoSentencias>;

}while (<exprBooleana>);

int cont = 0;

do{

System.out.println(“contador:“ + i );

} while (cont++ < 10);

24


Control de Flujo (6)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.

resultadoIteración: 1Iteración: 2

int i;for (i=1; i<=4; i++) { if (i==3) break; System.out.println("Iteración: "+i);}

ContinueLa 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.

resultadoIteración: 1Iteración: 2Iteración: 4

int i;for (i=1; i<=4; i++) { if (i==3) continue; System.out.println("Iteración: "+i);}

25

Ejemplo de uso ArrayDeclaració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

26

Ejemplo de uso ArrayCrear 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)};

27

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]) ;} }

28

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.

29

Redimensionando un Array

Qué hacemos entonces?Usamos ARRAYCOPY

NO SE PUEDE HACER

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);

30


ClasesClases

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); }}





VariableConstructor

Método

Método principal de la aplicación

Creación de un objeto

31


Clases (2)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

????

2003 anio

08 mes

10 dia

32



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 redefinir aquellos métodos que han sido declarados abstract.

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.

33



Modificadores de Ámbito

34




35




36




37




38


Clases (9)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)

39



Á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 ; // variable miembro void metodo ( int y ){ // argumento int z ; // variable local x = y + z ; }}

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.

40


MétodosMétodosLos 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().

41


Métodos (2)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.

42

Conceptos Básicos de JavaConceptos Básicos de JavaConceptos Básicos de JavaConceptos Básicos de Java

Métodos (3)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.





43


Referencia Referencia thisthisthis: 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;



44


Referencia Referencia this this (2)(2) Cuando se hace referencia al objeto actual en un método que devuelve un objeto del tipo de referencia.



} public Fecha getObjetoFecha() { return this; } public static void main(String[] args) {

Fecha MiFecha = new Fecha(10, 08, 2003);Fecha MiFecha2 = MiFecha.getObjetoFecha();

}}

45


Referencia Referencia this this (3)(3) Cuando se invoca a otros constructores de la clase.



} public Fecha() {

this(01,01,1900); } public static void main(String[] args) {

Fecha MiFecha = new Fecha(10, 08, 2003);Fecha MiFecha2 = new Fecha();

}}

46


HerenciaHerenciaHerencia: 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);

}}

47

Herencia Simplepublic class Employee {public String name = "";public double salary;public Date birthDate;public String getDetails() {...}}

public class Manager extends Employee {public String department;}

48


Herencia (2)Herencia (2)

49

Visibilidad o Acceso

50

Overriding de métodos en herenciapublic 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;}}

51

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();}}

52


Referencia Referencia supersupersuper: 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 {






}}

53


Referencia Referencia super super (2)(2) Cuando se hace referencia a un método de la clase padre.

class Padre {String variable;void metodo() {





}}

54


Referencia Referencia super super (3)(3) Cuando se hace referencia a un constructor de la clase padre.

class Padre {String variable;public Padre(String nombrevar) {

variable = nombrevar;}


String variable;public Hija() {

super(“Padre”);variable = “Hija”;

}}

55


SuperSuper

public String getDetails() { return super.getDetails() + “\nDepartment: " + department;}

public class Manager extends Employee {protected String department;public String getDetails() { return “Name: “ + name + “\n” + “Salary: “ + salary + "\n" + “Manager of: “ + department;}}

56


PolimorfismoPolimorfismoPolimorfismo: 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).

57

Objetos PolimórficosEmployee [] 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) { …}}

58

Operador instanceofpublic class Employee extends Objectpublic class Manager extends Employeepublic class Engineer extends Employee----------------------------------------public void doSomething(Employee e) {if ( e instanceof Manager ) {…..} else if ( e instanceof Engineer ) {…..} else {……}}

59

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());}…..}

60


Clases AbstractasClases 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

61


Clases Abstractas (2)Clases Abstractas (2)Ejemplo:

62

public class Count {private int serialNumber;public static int counter = 0;public Count() {

counter++;serialNumber = counter;

}}


staticstaticEjemplo para atributos:

public class OtherClass {public void incrementNumber() { Count.counter++;}}

llamando desde otra clase

63

public class Count2 {private int serialNumber;private static int counter = 0;public static int getTotalCount() {return counter;}public Count2() {counter++;serialNumber = counter;}}


Static Static Ejemplo para métodos:

public class TestCounter {public static void main(String[] args) {System.out.println("Number of counter is "+ Count2.getTotalCount());Count2 counter = new Count2();System.out.println("Number of counter is "+ Count2.getTotalCount());}}

llamando desde otra clase

64

public class Count3 {private int serialNumber;private static int counter = 0;public static int getSerialNumber() {return serialNumber; // COMPILER ERROR!

}}

Los métodos static no pueden ser accedidos como variables de instancia !!!!


Static Static Ejemplo para métodos:

65

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);}}


Inicializadores Static Inicializadores Static Ejemplo :

66

InterfacesInterfacesInterfaces: 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.


67


Interfaces Interfaces Declaracion:

68


Interfaces Interfaces Representación en UML:

public interface Flyer {public void takeOff();public void land();public void fly();}

public class Airplane implements Flyer {public void takeOff() {…}public void land() {….}public void fly() {….}}

69

Conceptos Básicos de JavaConceptos Básicos de JavaInterfaces Interfaces Representación en UML:

70

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.

71

Ejemplo

72

Ejemplo mejorado

73

Try-catch, con múltiples catch

74

Usando finally

Siempre se ejecuta

75

Categorias de Exception

76

THROWS

Try - catch

Intentando atrapar …. ?

77

THROWS

78

Ejemplo de Throws

79

Clase personal hija de Exception

80

Captura de nuestra Exception

81

SobreGiroException

deficit : double

SobreGiroException()getDeficit()

<<Exception>>

Cuenta

saldo : double

Cuenta(saldoInicial : double)getSaldo() : doubledepositar(cantidad : double)retirar(cantidad : double)

CuentaCorriente

cantidadSobreGiro : double

CuentaCorriente(saldoInicial : double, sobreGiro : double)CuentaCorriente(saldoInicial : double)retirar(cantidad : double)

Ejercicio

82

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

83

Ejemplo

84

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

85

Ejemplo para leer del teclado

86

Otro Ejemplo para leer del teclado

87

Files

File myFile;

myFile = new File("myfile.txt");

myFile = new File("MyDocs", "myfile.txt");

Import java.io

88

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)

89

Ejemplo de Lectura de un File

90

Ejemplo de Escritura de un File

91

Collections

• Un Collection es un objeto que representa un grupo de objetos conocidos como elementos

92

Colección desordenada SIN elementos duplicados

Colección ordenada CON elementos duplicados

93

Ejemplo para SETimport 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);}}

[one, second, 5.0, 3rd, 4] Imprime:

94

Ejemplo para LIST

import java.util.*public class ListExample {public static void main(String[] args) {List list = new ArrayList();list.add("one");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);}}

[one, second, 3rd, 4, 5.0, second, 4]

Imprime:

95

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.

96

Collections : Generics

• Elimina la necesidad de hacer castingAntes 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();

98

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 elementsIterator elements = list.iterator();while ( elements.hasNext() ) {System.out.println(elements.next());}

99

Jerarquía de Iterator en el API

100

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();}}

101

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));}}

1 conceptos básicos de java. 2 características de la programación en java sensible a...

Documents