Estructura de Datos

Conceptos Básicos de Java

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

4
 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

5
 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:
[Link] : para manejo de Applets.
[Link]: para manejo de entrada/salida.
[Link]: 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 [Link] y el paquete actual.
 El alcance de la sentencia package es todo el archivo fuente.
Ejemplo:

6
 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 <[Link]>.<NombreClase>;

import [Link];

 Para importar todas las clases de un paquete:

import <[Link]>.*;

import [Link].*;

7
 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 [Link] > [Link]

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

9
 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 3valores (número como primer carácter)
_otra_variable Dia&mes &
NombreDeVariableMuyLargoNoImporta Dos más (espacio)
BotonPulsacion Dos-valores –

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

11
 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 Punto Flotante Caracteres Números Enteros

boolean char byte short int long float double

 Los tipos referencia son punteros a objetos

12
 Conceptos Básicos de Java

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

Tipos de Datos
 Tipos Primitivos

13
 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), >, <, >=, <=

14
 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: >>, <<, >>>, &, |, ^, ~

15
 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

16
 Conceptos Básicos de Java

Control de Flujo (2)

if
if (<exprBooleana>) if (cont == 0)
<sentencia> ; [Link](“cont = cero”);
------------------------------------------------------- -------------------------------------------------------------------------------

if (<exprBooleana>) { if (cont == 0) {
[Link](“cont = cero”);
<grupoSentencias>; [Link](“otra sentencia”);
} }
------------------------------------------------------- -------------------------------------------------------------------------------

if (<exprBooleana>) { if (cont == 0) {
<grupoSentencias>; [Link](“cont = cero”);
}else{ }else{
<grupoSentencias>; [Link](“cont != cero”);
} }
------------------------------------------------------- -------------------------------------------------------------------------------
if (<exprBooleana>) { if (nota<4) {
<grupoSentencias>; [Link]("Insuficiente");
}else if (<exprBooleana>){ }else if (nota<6) {
<grupoSentencias>; [Link]("Suficiente");
}else{ }else{
<grupoSentencias>; [Link](“Muy Bien");
} }

17
 Conceptos Básicos de Java

Control de Flujo (3)

switch

switch ( <variable> ) { int día = 4;

switch (día) {
case literal1: case 1: [Link]("Lunes");
break;
[<grupoSentencias1>;]
case 2: [Link]("Martes");
[break;]
break;
case literal2: case 3: [Link]("Miércoles");
[<grupoSentencias2>;] break;
[break;] case 4: [Link]("Jueves");
break;
...
case 5: [Link]("Viernes");
case literalN: break;
[<grupoSentenciasN>;] case 6: [Link]("Sábado");
break;
[break;]
case 7: [Link]("Domingo");
[default:<grupoSentencias>;] break;
} default: [Link](“Error");
}

18
 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++ ) {

[Link](“valor del contador: “ + i );
}

19
 Conceptos Básicos de Java

Control de Flujo (5)

while

while (<exprBooleana>){ int cont = 0;

<grupoSentencias>; while (cont++ < 10) {
} [Link](“contador:“ + i );
}

do while

do{ int cont = 0;

<grupoSentencias>; do{
}while (<exprBooleana>); [Link](“contador:“ + i );
} while (cont++ < 10);

20
 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; resultado
for (i=1; i<=4; i++) {
Iteración: 1
if (i==3) break;
Iteración: 2
[Link]("Iteración: "+i);
}

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; resultado
for (i=1; i<=4; i++) {
Iteración: 1
if (i==3) continue;
Iteración: 2
[Link]("Iteración: "+i);
Iteración: 4
}
21
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.

22
Ejemplo

23
Consola I/O
• [Link] : salida estándar al monitor
• Genera un objeto de tipo PrintStream
• [Link] : entrada estándar del teclado
• Genera un objeto de tipo InputStream
• [Link] : escribe un error estándar

24
Ejemplo para leer del teclado

25
Otro Ejemplo para leer del teclado

26
ESTRUCTURA DE DATOS
 Ejemplo de uso Array
Declaración public char[] createArray() {
char s[]; char[] s;
Point p[]; s = new char[26];
char[] s; for ( int i=0; i<26; i++ ) {
Point[] p; s[i] = (char) (’A’ + i);
Un array es un objeto. }
Se crea con new return s;
}

public void printElements(int[] list) {

for (int i = 0; i < [Link]; i++) {
[Link](list[i]); Longitud del array
}} 28
 Ejemplo de uso Array
Crear un Array con valores iniciales 1)
1) MyDate[] dates;
String[] names; dates = new MyDate[3];
names = new String[3]; dates[0] = new MyDate(22, 7, 1964);
names[0] = "Georgianna"; dates[1] = new MyDate(1, 1, 2000);
names[1] = "Jen"; dates[2] = new MyDate(22, 12, 1964);
names[2] = "Simon"; 2)
2)
MyDate[] dates = {
String[] names = {
new MyDate(22, 7, 1964),
"Georgianna",
new MyDate(1, 1, 2000),
"Jen",
new MyDate(22, 12, 1964)
"Simon"
};
}; 29
 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<[Link]; i++ ) {
for (int j=0; j<ciudades[i].length; j++ ) {
[Link](ciudades[i][j]) ;
} } 30
Recorriendo Array

public void printElements(int[] list) {

for ( int element : list ) {
[Link](element);
}
}

Este FOR, puede ser leido como:

Para cada elemento en list hacer.

31
 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

[Link](myArray, 0, hold, 0, [Link]);

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

33
 Colección ordenada
CON elementos duplicados

Colección desordenada
SIN elementos duplicados
34
 Ejemplo para SET
import [Link].*;
public class SetExample {
public static void main(String[] args) {
Set set = new HashSet();
[Link]("one"); Imprime:
[Link]("second"); [one, second, 5.0, 3rd, 4]
[Link]("3rd");
[Link](new Integer(4));
[Link](new Float(5.0F));
[Link]("second"); // duplicate, not added
[Link](new Integer(4)); // duplicate, not added
[Link](set);
}
}
35
 Ejemplo para LIST
import [Link].*
public class ListExample {
public static void main(String[] args) {
List list = new ArrayList();
[Link]("one");
Imprime:
[Link]("second"); [one, second, 3rd, 4, 5.0, second, 4]
[Link]("3rd");
[Link](new Integer(4));
[Link](new Float(5.0F));
[Link]("second"); // duplicate, is added
[Link](new Integer(4)); // duplicate, is added
[Link](list);
}
} 36
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.

37
Collections : Generics

• Elimina la necesidad de hacer casting

Antes de Generics
ArrayList list = new ArrayList();
[Link](0, new Integer(42));
int total = ((Integer)[Link](0)).intValue();
Después de Generics
ArrayList<Integer> list = new ArrayList<Integer>();
[Link](0, new Integer(42));
int total = [Link](0).intValue();

38
39
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 = [Link]();
while ( [Link]() ) {
[Link]([Link]());
}

40
PROGRAMACIÓN ORIENTADA A OBJETOS
 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() {
[Link] (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
42
 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: [Link]. 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.

43
 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().

44
 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() {
[Link] (dia+”/”+mes+”/”+anio);
}
public static void main(String[] args) {
Fecha MiFecha = new Fecha(10, 08, 2003);
}
}

45
 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) {
[Link] = dia;
[Link] = mes;
[Link] = anio;
}
public void mostrarFecha() {
[Link] (dia+”/”+mes+”/”+anio);
}
public static void main(String[] args) {
Fecha MiFecha = new Fecha(10, 08, 2003);
}
}

46
 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) {
[Link] = dia;
[Link] = mes;
[Link] = anio;
}
public Fecha getObjetoFecha() {
return this;
}
public static void main(String[] args) {
Fecha MiFecha = new Fecha(10, 08, 2003);
Fecha MiFecha2 = [Link]();
}
}

47
 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) {
[Link] = dia;
[Link] = mes;
[Link] = anio;
}
public Fecha() {
this(01,01,1900);
}
public static void main(String[] args) {
Fecha MiFecha = new Fecha(10, 08, 2003);
Fecha MiFecha2 = new Fecha();
}
}

48
 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”;
[Link]();
[Link](variable);
[Link]([Link]);
}
}
49
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;
}
50
 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”;
[Link]();
[Link](variable);
[Link]([Link]);
}
}
51
 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”;
[Link]();
[Link](variable);
[Link]([Link]);
}
}

52
 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”;
}
}

53
 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 [Link]() + “\nDepartment: " + department;
}

54
 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).

55
 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 = [Link](m);
}
public TaxRate findTaxRate(Employee e) { …}
} 56
 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.

57
 Conceptos Básicos de Java

Interfaces
Declaracion:

58
 Conceptos Básicos de Java

Interfaces
Representación en UML:

public interface Flyer {

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

59
 Conceptos Básicos de Java
Interfaces
Representación en UML:

60
Gracias

Las imágenes son de sus

autores, para fines netamente
académicos