Java PDF

Introducción y Fundamentos del
lenguaje de programación
Java
Agenda
Qué es Java ?
Características generales del lenguaje
Variables
Tipos de Datos
Estructuras de control
Orientado a Objeto:
Clase, objeto, atributos, métodos, constructores
y mas….
Java
Tecnología desarrollada por Sun Microsystems

para aplicaciones software independiente de la
plataforma, que engloba:
Lenguaje de programación Java
API Java, proporciona a los programadores un
entorno de desarrollo completo, así como una
infraestructura.
JVM, la máquina virtual que ejecuta bytecode de
Java.
Java
Lenguaje de programación orientado a objetos

desarrollado por Sun Microsystems a principios
de los 90
Las aplicaciones son compiladas en un bytecode,
aunque también es posible la compilación en
código de máquina nativo
En tiempo de ejecución, el bytecode es
normalmente interpretado
Java
La promesa inicial era Write Once, Run Anywhere
La idea era proporcionar un lenguaje

independiente de la plataforma y un entorno de
ejecución ligero y gratuito
Tecnología Java
La tecnología Java incluye el lenguaje de

programación y la plataforma
Java es al mismo tiempo compilado e interpretado

Tecnología Java
Genera byteCode
Implementación
de la Máquina
Virtual Java
Tecnología Java
Compile-time Environment Compile-time Environment
Class
Loader Java
Class
Bytecode Libraries
Java Verifier
Source
(.java)
Just in
Java Java
Time
Bytecodes Interpreter Java
Compiler
move locally Virtual
or through machine
Java network
Compiler
Runtime System
Java Operating System

Bytecode
(.class )
Hardware
Programa Simple
public class ProgramaSimple {

public static void main(String[] args) {
System.out.println("Este es” +
”un programa simple");
System.exit(0);
}
}
Características del lenguaje
Características del Lenguaje
Sensible a las Mayúsculas / Minúsculas

Distingue entre mayúsculas y minúsculas.
Los identificadores Papa, papa y PAPA son
diferentes. No pueden comenzar con dígitos
Los identificadores deben ser descriptivos
Todas las palabras reservadas del lenguaje van en
minúsculas
Estilo
Los programadores deben seguir ciertas convenciones en
cuanto a estilo
Los nombres de las clases deben empezar con mayúscula,
las siguientes palabras también inician en mayúscula
public class DanceFloor
Los nombres de los métodos, campos y variables

empiezan con minúscula y el resto de las palabras
comienzan con mayúscula
private int stepsCount = 0;
public void nextStep()
Generalmente, los nombres de los métodos suenan como

verbos
setBackground, getText, moveForward, stop
Los nombres de los campos o atributos como nombres
foot, picture, button, controlPanel
Las constantes se especifican completamente en
mayúsculas
PI, PIXELS_PER_INCH
Es OK usar nombres cortos estandares para variables
temporales
i, k, x, y, str
Sintáxis vs Estilo
Sintáxis es parte del lenguaje. El compilador

chequea este aspecto
Estilo es una convención ampliamente adoptada
por los desarrolladores de software
El propósito del estilo es mejorar la comprensión
de los programas
El compilador detecta errores de sintáxis y genera

mensajes de error
Texto incluído en comentarios y las cadenas de
caracteres son excluídas del chequeo sintáctico
Antes de compilar, lea cuidadosamente su
código para detectar errores sintácticos y
lógicos
Errores comunes de sintáxis
Ortografía Public static int abs (int x)

{ Punto y coma
(p → P, if → If)
If (x < 0); extraño
{
x = -x
}
Falta } return x; Falta punto y
coma
public static int sqrt (int x)
...
Comentarios
Un bloque de comentario puede ser
colocado entre las marcas /* y */
/* Exercise 5-2 for Java Methods
Author: Miss Brace
Date: 3/5/2010
Rev. 1.0 */
Un comentario de una sola línea va desde

// hasta el final de la línea
weight *= 2.2046; // Convert to kilograms
Características del Lenguaje
Comentarios
/** comentario */
Los caracteres entre /** y */son ignorados y se
incluyen en la generación automática de la
documentación.
Usado por javadoc para la generación

automática de documentación en formato
HTML a partir del código fuente
Debe preceder una clase, un método o un
campo
Se pueden usar tags especiales de javadoc
@param – describe el parámetro de un método
@return - describe el valor de retorno de un
método
/** indica un comentario javadoc
/**
* Returns total sales from all vendors;
* sets <code>totalSales</code> Se pueden usar tags
* to 0. HTML
*
* @return total amount of sales from all vendors
*/
Estilo
Ejemplo javadoc
/**
* Inserta un título en la clase descripción.
* Al ser el título obligatorio, si es nulo o vacío se lanzará
* una excepción.
*
* @param titulo El nuevo título de la descripción.
* @throws IllegalArgumentException Si titulo es null, está vacío o contiene solo
espacios.
*/
public void setTitulo (String titulo) throws IllegalArgumentException
{
if (titulo == null || titulo.trim().equals(""))
{
throw new Exception ("El título no puede ser nulo o vacío");
}
else
{
this.titulo = titulo;
}
}
La disposición de los elementos dentro del código es libre

Instrucciones o sentencias: línea simple de código
terminada en ;
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;
Estilo
Coloque cada sentencia en una línea e indente

el código entre llaves
Use conscientemente los comentarios. Comente
constructores, métodos, campos o atributos,
pasos importantes pero no comente cada
sentencia en su programa
Estilo
public void nextStep() public void nextStep()

{ if (stepsCount % 2 {
== 0) leftFoot. if (stepsCount % 2 == 0)
moveForward (2 * leftFoot.moveForward (2 * stepLength);
stepLength); else
else rightFoot. rightFoot.moveForward (2 * stepLength);
moveForward(2 *
stepLength); stepsCount++;
stepsCount++; } }
Compila bien Más fácil de leer

Palabras Reservadas
Palabras con un significado especial para el compilador
Ejemplos:
Nombres de tipos básicos: boolean, char, double, int, …
Indicadores de control: do, if, else, for, while, …
Class, interface, extends, implements
package, import
this, super
Modificadores de acceso: public, private, protected
Constantes: true, false, null
public void fill (char ch)

{
int rows = grid.length, cols = grid[0].length;
Agregar líneas en
for (int r = 0; r < rows; r++) blanco para facilitar
{ lectura
for (int c = 0; c < cols; c++)
{
grid[r][c] = ch;
}
}
Agregar espacios alrededor de los
} operadores y después de los puntos
y comas
public void makeNextStep ( ) Cuerpo del
{ método
if (currentState == State.READY)
{
amy.firstStep();
amy.firstStep();
ben.firstStep();
currentState = State.MOVING; Grupo de
stepsCount = 0; sentencias
}
else if (currentState == State.MOVING)
{
if (amy.distanceTraveled() <= danceFloor.getWidth() * 3 / 4)
{ Grupo de
amy.nextStep(); Grupo de
ben.nextStep();
sentencias
sentencias
stepsCount++;
}
else
{
amy.stop(); Grupo de
ben.stop(); sentencias
currentState = State.STOPPED;
}
}
danceFloor.update(this);
}
Variables
Variables
Una variable corresponde a una dirección de

memoria que almacena un valor.
q = 100 - q;
significa
1. Leer el valor actual de q
2. Restar 100 de dicho valor
3. Mover el resultado a q
Variables
Las variables pueden ser de distintos tipos : int,

char, double, boolean, etc.
Las variables pueden contener objetos entonces
el tipo de la variable es la clase del objeto
El programador le da nombre a las variables
Generalmente los nombres de las variables
empiezan con una letra en minúscula (por
convención)
Variables
Una variable debe ser declarada antes de su uso
int count;
double x, y; Nombre(s)
Tipo JButton go;
Walker amy;
String firstName;
Variables
El operador de asignación permite cambiar el
valor de una variable
count = 5;
x = 0;
go = new JButton("Go");
firstName = args[0];
Una variable puede ser inicializada en su

declaración
int count = 5;
JButton go = new JButton("Go");
String firstName = args[0];
Variables
Alcance
Cada variable tiene un alcance –
el área en el código donde es
“visible”
{
Si usa una variable fuera de su int k = ...;
alcance, el compilador ...
reportará un error de sintáxis }
Variables pueden tener el mismo for (int k = ...)

nombre cuando sus alcances {
no se solapan ...
}
Variables
Las variables locales se declaran dentro de un

constructor o en un método
Las variables locales pierden su valor y son
destruidas cuando finaliza el constructor o
método
El alcance de una variable local es desde su
declaración hasta donde cierra el paréntesis del
bloque en el cual fue declarado
Variables
public class SomeClass

{
...
public SomeType SomeMethod (...)
{
Variable local declarada Alcance
{
Variable local declarada
}
}
...
}
Variables
Usen variables locales cuando sea apropiado;

nunca use atributos cuando debería usar una
variable
Nómbrelas de manera que puedan ser fácilmente
distinguibles de los atributos
Use el mismo nombre para variables locales
usadas de la misma forma en distintos métodos
(por ejemplo, x, y para coordenadas, cont,
count para un contador, i, k para índices, etc.).
Variables
Errores comunes
public void someMethod (...)

{
int x = 0;
...
int x = 5;
...
Error de sintáxis.
Variable declarada dos
veces dentro del mismo
alcance
Variables
Errores comunes
private double radius;

...
public Circle (...) // constructor
{
double radius = 5;
...
radius ha sido declarada como
atributo y como variable local; el
valor del atributo radius se queda
en 0.0
Tipos de datos primitivos
Tipos de datos primitivos
• int • byte
• double • short
• char • long
• boolean • float
Tipos de datos
String no es un tipo primitivo de datos

String trabaja igual que cualquier objeto
excepto por
String entre comillas dobles representa
constantes literales
+ y += concatena strings
"Catch " + 22 "Catch 22"

Tipos de datos
Constantes literales
new line
tab
'A', '+', '\n', '\t' char
-99, 2010, 0 int
0.75, -12.3, 8., .5 double
“coin.gif", "1776", "y", "\n" String

Tipos de datos
Constantes simbólicas son inicializadas
como final
private final int stepLength = 48;

private static final int BUFFER_SIZE = 1024;
public static final int PIXELS_PER_INCH = 6;
Tipos de datos
Por qué Constantes Simbólicas?

Fácil de cambiar su valor en un
programa en caso de ser necesario
Fácil de cambiar a una variable
Facilita la lectura del código
Operadores Aritméticos
Operadores
Operadores: +, -, /, * , %
La precedencia de los operadores y paréntesis es
la misma que en algebra
m % n es el resto cuando m es dividido por n (por
ejemplo, 17 % 5 is 2; 2 % 8 is 2)
% tiene el mismo rango que / y *
Operadores binarios con el mismo rango se
evaluan de izquierda a derecha
Operadores
El tipo del resultado viene determinado por el tipo

de los operandos y no por sus valores. Esta regla
aplica también para los resultados intermedios
en una expresión
Si uno de los operandos es entero y el otro es
double, entonces el resultado es double. Si
ambos operandos son enteros, el resultado será
entero
Operadores
Si a y b son enteros entonces a / b es

truncado a un entero
17 / 5 3
3/4 0
… aún si asignamos el resultado a un
double el resultado será truncado a un
entero
double ratio = 2 / 3;
Operadores
Para obtener el resultado correcto, deben usar

constantes dobles o el operador cast
double ratio = 2.0 / 3;
double ratio = 2 / 3.0;
int m = ..., n = ...;
double factor = (double)m / (double)n;
double factor = (double)m / n;
double r2 = n / 2.0;
Operadores
Devuelve
un double
int ptsOnDie = (int)(Math.random() * 6) + 1;
int miles = (int)(km * 1.61 + 0.5);
Convierte Km a Millas,
redondeado al entero
más cercano
Estructuras de Control
if else
if ( <condition> ) if ( <condition> )
{ {
< statements > < statements >
} }
else
{
< other statements > la cláusula else
} es opcional
Expresiones booleanas
Variables booleanas pueden

tener sólo dos posibles
valores: true o false.
Se definen igual que el resto
de las variables o atributos
boolean
true
false
private boolean hasMiddleName;
boolean isRolling = false;
Palabras
reservadas
Expresiones booleanas
En if (<condition> ) <condition> es una

expresión booleana
El resultado de una expresión booleana es true o
false
Las expresiones booleanas están compuestas de
variables booleanas y operadores lógicos y
relacionales
Operadores relacionales
Operadores relacionales <, >, <=, >=, ==, !=

Hay que tener cuidado cuando se usan
con objetos, pues en esos casos estamos
comparando referencias (direcciones)
en lugar de sus valores
String cmd = console.readLine();
if ( cmd == "Help" ) ... incorrecto
Usar los métodos equals o

equalsIgnoreCase para comparar
Strings:
String cmd = console.readLine();
if ( cmd.equals ("Help") ) ...
o
if ( "Help".equals (cmd) ) ...

Mayor
! -(unary) ++ -- (cast)
* / %
+ -
< <= > >= == !=
&&
||
Menor Más fácil de leer
if ( ( ( year % 4 ) == 0 ) && ( month == 2 ) ) ...

if ( year % 4 == 0 && month == 2 ) ...
If else anidados
if ("forward".equals(cmd))
{
if (slide >= numSlides)
beep.play();
else
slide++;
}
else
{
if (slide <= 1)
beep.play();
else
slide--;
}
If else if
if (drinkSize.equals(”Large")) if (drinkSize.equals(”Large"))
{ price += 1.39;
price += 1.39; else if (drinkSize.equals("Medium"))
} price += 1.19;
else if (drinkSize.equals("Medium")) else // if "Small" drink size
{ price += 0.99;
price += 1.19;
}
else // if "Small" drink size
{
price += 0.99;
}
Errores comunes
Punto y coma adicional Faltan { }
if (...) ; if (...)
{ sentencia1;
sentencia2;
sentencias;
...
... if (...)
} Es más seguro if (...)
usar { } en if- sentencia1;
else
else
sentencia2;
switch
switch (expression) switch (num)

{ {
case value1: case 1:
... case 2:
break; System.out.println ("Buckle your shoe");
break;
case value2: case 3:
... ...
break;
... }
...
default:
...
break;
}
Tipos de datos enumerados
Usados cuando el atributo de un objeto o

estado puede tomar solo un pequeño
conjunto de valores
private enum Speed { LOW, MEDIUM, HIGH };
private enum InkColor { BLACK, RED };
private enum DayOfWeek { sunday, monday,

tuesday, wednesday, thursday, friday, saturday };
Tipos de datos enumerados
Use == o != para comparar valores enum
private enum Speed { LOW, MEDIUM, HIGH };
...
Speed currentSpeed = Speed.LOW;
...
if (currentSpeed == Speed.LOW) ...
Puede ser usado en una estructura switch
switch (currentSpeed)
{
case LOW:
...
break;
case MEDIUM:
...
while
condicion es cualquier
expresión lógica
while ( condicion )
{
statement1;
statement2; cuerpo del lazo
...
statementN;
}
Si el cuerpo tiene solo while ( condicion )

una sentencia, entonces statement1;
las { } son opcionales
while
// Returns the smallest n

// such that 2^n >= x
public static int intLog2 (int x)
{ Inicialización
int n = 0, p = 1;
while ( p < x ) Test
{
p *= 2; Cambio
n++;
}
return n;
}
for
for es una forma abreviada que combina

en una sentencia la inicialización, la
condición y el cambio
for ( initialization; condition; change )
{
statement1;
statement2;
...
statementN;
}
do while
do Se ejecuta al menos
{ una vez
statement1;
statement2;
...
statementN;
Si la condición es
} while ( condition );
falsa, no se ejecuta
la próxima iteración
Siempre use { } para
facilitar la lectura del
código
break y continue
El break en una sentencia de iteración instruye al

programa para que termine inmediatamente la
iteración y continúe en la primera sentencia
después del lazo
return en un lazo indica al programa para que
inmediatamente termine la ejecución del
método y retorne al punto donde fue invocado
Un break o return debe estar dentro de una
cláusula if o else
break y continue
int r, c;
for (r = 0; r < m.length; r++)

{ breaks colocados
for (c = 0; c < m[0].length; c++) dentro de un lazo
{ interno continuan
if (m [ r ][ c ] == 'X' ) con el lazo externo
break;
}
}
...
Paradigma
Orientado a Objetos
Paradigma Orientado a
Objetos
Paradigma estructurado o procedural: Los programas se
dividen en procedimientos independientes con acceso
total a los datos comunes.
Algortimos + Estructuras de Datos = Programas

Paradigma orientado a objetos: Los datos se consideran la
parte más importante del programa. Los objetos
modelan las características de los problemas del mundo
real, su comportamiento ante estas caracteristicas y su
forma de interactuar con otros elementos
objetos + mensajes = Programas

Ejemplo: Tomarse un café en una
panadería
Procedural Orientado a Objetos

El cliente entra en la El cliente entra en la
panadería panadería
El cliente pasa detrás de la El cliente pide un café al
barra “cafetero”
El cliente prepara la El “cafetero” prepara el
cafetera café.
El cliente se sirve el café El “cafetero” sirve el café
El cliente se bebe el café. al cliente.
El cliente se bebe el café.
Paradigma Orientado a
Objetos
Clases: Patrones que indican como construir objetos
Objetos: Instancias de las clases en tiempo de ejecución.
Miembros de la clase:
Atributos: Características o propiedades de los objetos
(o clases). Pueden ser variables de tipo simple o
referencias a otros objetos
Métodos: Comportamientos de los objetos. Son
funciones que operan sobre los atributos de los
objetos.
Clase
Sintáxis
Class <NombreClase> {
// Declaracion de atributos
<tipo> <var>;
// Declaración de métodos
<tipo> <nombreMetodo> ( <argumentos> )
{ … }
}
El nombre del archivo debe coincidir con el de la clase

definida en él.
Se recomienda definir una clase por cada archivo Java.
Estructura general
Attribute
Creación de un objeto
Se usa la palabra reservada new
<refObjeto> = new <NombreClase>();
Ejemplo:
Circulo miCirculo;
miCirculo = new Circulo();
Atributos
Atributos o Miembros
Los miembros o atributos se declaran fuera de los

constructores y métodos
Generalmente su declaración se agrupa en el
tope de la clase o después de los métodos
El alcance de un atributo es toda la clase
Alcance de los atributos

{
Alcance Atributos
Constructores y
métodos
}
O
{
Constructores y
Alcance métodos
Atributos
}
Atributos
La definición de los miembros o atributos de una

clase se puede ampliar añadiendo
modificadores al principio.:
[modificador]<tipo> <identificador>;
[modificador]<tipo> <nombre>(<args>)
{...}
Los modificadores permiten acceder a los datos o
métodos de manera restringida
Atributos
public. El miembro de la clase es accesible

desde cualquier parte del código.
private. El miembro de la clase sólo es accesible
desde código perteneciente a la propia clase.
protected(o friendly). Sólo las subclases de la
clase y nadie más pueden acceder a las
variables y métodos.
Ejemplo
public class Circulo {

// Atributos
double radio;
String color;
// Metodos
void asigRadio( ){ … }
double area( ){…}
}
Atributos de una clase
De instancia. Cada instancia tiene un valor particular. Representan

el estado particular de cada objeto.
De clase. Todas las instancias comparten el mismo valor para estos
atributos (como atributo global). Si se cambia en una instancia, se
refleja en todas. Representan el estado compartido
Se declaran utilizando el modificador static.
class Ficha {
public long id;
public static long idactual = 0;
public Ficha() {
id = idactual++;
}
}
Acceso a los miembros
El operador “.” aplicado a referencias permite el acceso a atributos y

métodos.
public class EjemplosManipulacionObjetos {

Ficha f1 = new Ficha();
System.out.println(f1.id);
f1.id = 34;
Persona juan = new Persona("Juan","5555555");
Persona maria = new Persona("María","5555555");
Persona pedro = new Persona("Pedro","5555555",
juan,maria);
System.out.println(pedro.nombre());
System.out.println(pedro.padre().nombre());
System.out.println(pedro.madre().nombre());
}
}
Métodos
Constructores y métodos públicos de una clase

constituyen la interface de la clase que puede
ser usada por sus clientes
Todos los campos son generalmente declarados
de tipo privado, es decir están ocultos
Métodos “Ayudantes” que son necesarios sólo
para la clase se declaran de forma privada
accessor modifier
Generalmente, el programador provee de

métodos “accessors” que permiten acceder
campos privados y métodos “modifiers” que
permiten modificar el valor de los campos
privados
Generalmente, el nombre de los métodos
“accessor” comienzan con get y los “modifiers”
con set
encapsulación
public class MyClass

{
// Private fields:
private <sometype> myField;
...
// Constructors:
public MyClass (...) { ... } Public interface:
... public constructors
// Public methods: and methods
public <sometype> myMethod (...) { ... }
...
// Private methods:
private <sometype> myMethod (...) { ... }
...
}
Constructores
Un constructor es un procedimiento para crear

objetos de una clase
El constructor generalmente inicializa los campos
del objeto
Los constructores no tienen valor de retorno
Todos los constructores en una clase tienen el
mismo nombre ( el de la clase)
Los contructores pueden recibir parámetros
Constructores
Si una clase tiene más de un constructor,

entonces deben tener distintos números o tipo
de argumentos
Generalmente se proveen constructores sin
argumentos
Si el programador no provee un constructor, Java
provee uno por defecto que reserva memoria
para el objeto e inicializa los campos con los
valores por defecto
Constructores
public class Fraction public Fraction (int n, int d)

{ {
private int num, denom; num = n;
denom = d;
public Fraction ( ) reduce ();
{ }
num = 0;
denom = 1; “No-args” public Fraction (Fraction other)
} constructor {
num = other.num;
public Fraction (int n) denom = other.denom;
{ }
num = n; ... Copy
denom = 1;
} Continua ® }
constructor
Constructores
Constructores de una clase pueden

llamarse entre si usando la palabra
reservada this
public class Fraction ...
{ public Fraction (int p, int q)
... {
num = p;
public Fraction (int n) denom = q;
{ reduce ();
this (n, 1); }
} ...
...
Referencias a objetos
Fraction f1 = new Fraction(3,7); Fraction f1 = new Fraction(3,7);

Fraction f2 = f1; Fraction f2 = new Fraction(3,7);
Objeto objeto
f1 Fraction
f1 Fraction
num = 3 num = 3
f2 denom = 7 denom = 7
objeto
f2 Fraction
Referencia al
mismo objeto
num = 3
denom = 7
Métodos
public [or private] returnType

methodName (type1 name1, ..., typeN nameN)
{
...
} cuerpo
encabezado
Para definir un método
• Decida entre public y private (usualmente public)
• Dele un nombre
• Especifique el tipo de argumentos y deles un
nombre
• Especifique el valor del retorno del método
• Escriba el código del método
Paso de argumentos
Cualquier expresión que tenga el tipo apropiado

puede ser pasada como argumento
double u = 3, v = -4;
...
Polynomial p = new Polynomial (1.0, -(u + v), u * v);
double y = p.getValue (2 * v - u);
public class Polynomial

{
public Polynomial (double a, double b, double c) { ... }
public double getValue (double x) { ... }
...
Paso de argumentos
Un tipo “menor” puede ser promovido a un
tipo “mayor” ( int a long, float a double)
int es promovido a double cuando sea
necesario
...
Polynomial p = new Polynomial (1, -5, 6);
double y = p.getValue (3);
Igual que (3.0) Igual que

(1.0, -5.0, 6.0)
Paso de argumentos
Los tipos primitivos son siempre pasados por
valor, es decir el valor es copiado en el
parámetro public class Polynomial
{
double x = 3.0; ... copia
double y = p.getValue ( x ); public double getValue (double u)
{
double v;
u actua como una
...
variable local en
}
getValue
}
x: 3.0 copia u: 3.0

Paso de argumentos
public class Test

{
public double square (double x)
{
x *= x; x es una copia del parámetro
return x; pasado. La copia cambia pero…
}
public static void main(String[ ] args)

{
Test calc = new Test (); ... el valor original de
double x = 3.0; x no cambia
double y = calc.square (x); Salida: 3 9
System.out.println (x + " " + y);
}
}
Paso de argumentos
Los objetos siempre se pasan por referencia: la

referencia es copiada mas no el objeto
Fraction f1 = new Fraction (1, 2); public class Fraction

Fraction f2 = new Fraction (5, 17); {
... copia referencia
Fraction f3 = f1.add (f2);
public Fraction add
(Fraction f)
Un objeto {
Refiere a
Fraction: ...
}
num = 5 } Refiere al
denom = 17 mismo objeto
Paso de argumentos
Dentro de un método, this hace referencia

al objeto por el cual el método fue
invocado
this puede ser pasado a otros constructores
y métodos como parámetro
public class ChessGame
{
...
Player player1 = new Player (this);
...
Una referencia a
este (this) objeto
ChessGame
sentencia return
Un método, a menos que sea void, retorna un

valor del tipo especificado por el método
Paso de argumentos
La sentencia return es usada para terminar el
método y devolver un valor
return expresión;
El tipo del valor o

expresión retornada debe
ser del mismo que lo
declarado en el método
sentencia return
Un método puede tener varias sentencias return
public someType myMethod (...)

{
...
if (...)
return <expression1>;
else if (...)
...
}
sentencia return
Un método booleano puede retornar true,
false, o el resultado de una expresión
booleana
public boolean myMethod (...)

{
...
if (...)
return true;
...
return n % 2 == 0;
}
sentencia return
Un método void puede usar una sentencia

de return para finalizar antes el método
public void myMethod (...)

{
...
if (...)
return;
...
} No hay necesidad
de especificar
return al final del
método
sentencia return
Si la clase devuelve una clase, entonces el
método retornará una referencia a un objeto o
null
Generalmente el objeto será creado dentro del
método usando new
public Fraction inverse ()
{
if (num == 0)
return null;
return new Fraction (denom, num);
}
El objeto retornado puede también venir de un
parámetro o de otra llamada a otro método
Sobrecarga de métodos
Métodos de la misma clase que tienen el
mismo nombre y diferente número y/o
tipo de argumentos se conocen como
métodos sobrecargados
Use sobrecarga de métodos cuando
deben llevar a cabo tareas similares
public void move (int x, int y) { ... }

public void move (double x, double y) { ... }
public void move (Point p) { ... }
public Fraction add (int n) { ... }

public Fraction add (Fraction other) { ... }
El compilador los trata como métodos diferentes

El compilador sabe cuál método será invocado
basado en el número de argumentos y el tipo
de los mismos
public class Circle
{
Circle circle = new Circle(5); public void move (int x, int y)
circle.move (50, 100); { ... }
Point center = new Point(50, 100);
circle.move (center);
public void move (Point p)
{ ... }
...
El tipo devuelto por el método no es suficiente

para distinguir métodos sobrecargados
public class Circle

{
public void move (int x, int y)
{ ... } Error de sintáxis
public Point move (int x, int y)

{ ... }
...
Campos static
Un campo static (class field o class

variable) es un campo compartido por
todos los objetos de la clase
Un campo non-static ( instance field o
instance variable) pertenece al objeto en
particular
Campos static
Un campo static puede mantener una
constante compartida por todos los
objetos de la clase
public class RollingDie Palabras
{ reservadas:
private static final double slowDown = 0.97;
static
private static final double speedFactor = 0.04;
... final
Un campo static puede ser usado para

recoger estadísticas o totales de los
objetos de la clase
Campos static
El campo Static es almacenado dentro del código
de la clase, de manera separada de las
variables de instancia que describen a un
objeto en si
Campos public static son usualmente constantes
globales y son referenciadas con el operador .
ClassName.constName
double area = Math.PI * r * r;

setBackground(Color.BLUE);
c.add(btn, BorderLayout.NORTH);
System.out.println(area);
Campos static
Generalmente no se inicializan los campos static en los

constructores. Se hace en la declaración o en métodos
public static
Si una clase tiene solamente campos static, entonces no

hay necesidad de crear objetos de dicha clase. Todos
serían idénticos
Math y System son ejemplos de lo anterior. No poseen

constructores públicos y no pueden ser instanciados
static métodos
Métodos static pueden acceder y manipular campos
estáticos de una clase
No pueden acceder campos no estáticos o llamar
métodos no estáticos de la clase
Los métodos static son llamados usando la “notación
punto”
ClassName.statMethod(...)
double x = Math.random();
double y = Math.sqrt (x);
System.exit();
static métodos
public class MyClass

{
public static final int statConst;
private static int statVar;
private int instVar;

...
public static int statMethod(...) Método static
{
statVar = statConst;
statMethod(...); OK
instVar = ...; Error!

instMethod(...);
}
Métodos no static
Un método no static puede ser invocado
por un objeto usando la notación punto
objName.instMethod(...);
vendor.addMoney(25);
die1.roll();
Estos métodos pueden acceder todos los

campos y métodos de la clase (static o
no)
Herencia
Herencia
Superclase
(clase base)
Subclass extends
Superclass
Subclase
(clase derivada)
La herencia representa una relación de

“es un” entre objetos
Un objeto de la subclase es un objeto de
la superclase
Jerarquía entre clases
Usando herencia, el programador puede
definir jerarquía entre las clases
Biped
Walker Hopper Dancer
ToedInWalker CharlieChaplin
Herencia
La herencia de clases se lleva a cabo mediante

extends
Establece una relación de especialización --
generalización entre clases.
La subclase puede introducir nuevos métodos y
redefinir métodos de la superclase.
Ayuda a reducir Biped

Constructor
duplicación de código Accessors
factorizando lo común turnLeft
turnRight
entre varias clases en la turnAround
superclase draw
Walker Hopper
Constructor Constructor
firstStep firstStep
nextStep nextStep
stop stop
distanceTraveled distanceTraveled
Reduce la duplicación de código y
permite escribir métodos mas generales
public void moveAcross Sirve tanto para

(Walker creature, int distance) Walker o Hopper
{ por polimorfismo
creature.firstStep();
while (creature.distanceTraveled() < distance)
creature.nextStep();
creature.stop(); public void moveAcross
} (Biped creature, int distance)
{
public void moveAcross creature.firstStep();
(Hopper creature, int distance) while (creature.distanceTraveled() < distance)
{ creature.nextStep();
creature.firstStep(); creature.stop();
while (creature.distanceTraveled() < distance) }
creature.stop();
}
Ejemplo de herencia
public class Articulo { // clase padre
public float precio=0;
...
public void setPrecio(float elPrecio) {
precio = elPrecio;
}
...
public float getPrecio() {
return precio;
}
}
//los métodos y atributos de Articulo son heredados a Pelicula
public class Pelicula extends Articulo {// clase hijo
public void setDescripcion(String descrip) {

descripcion = descrip;
}
...
public String getDescripcion() {
return descripcion;
}
}
Ejemplo de herencia
public class Persona { // Hereda de Object
private String nombre;
public Persona(String nombre) {
this.nombre = nombre;
}
public String nombre() {return nombre;}
}
public class Empleado extends Persona {
private double salario;
public Empleado(String nombre,double salario) {
super(nombre); // invoca al constructor de la superclase
this.salario = salario;
}
public double salario() {return salario;}
}
Herencia “es un”
Para saber si la relación de herencia es correcta, se plantea la

pregunta
"¿la subclase es-una superclase?". La respuesta debe ser "sí”
¿el Jefe es-un Empleado? Sí
¿la Secretaria es-un Empleado? Sí
class Bici class Bici
{ {
int numRuedas; int numRuedas;
int numAsientos; int numAsientos;
int velocidadMax; int velocidadMax;
} }
class Avion class Avion extends Bici
{ {
int numRuedas; int numAlas;
int numAsientos; }
int velocidadMax;
int numAlas; ¿Avion es-una Bici? NO
}
Relación de contenido
Una clase puede contener referencias a objetos de otras

clases
Se diferencia de la herencia en que es necesario
instanciarlos por separado
Responde afirmativamente a la pregunta:
¿<Contenedor> tiene-un <Contenido>?
class Motor class Chasis class Coche
{ { {
... ... Motor m;
} } Chasis ch;
}
¿un Coche tiene-un Motor? Sí

¿un Coche tiene-un Chasis? Sí
Métodos virtuales
Una subclase puede modificar los métodos que

ha heredado de las superclase, manteniendo
los mismos nombres, tipos de retorno y listas de
argumentos.
class Empleado {
int calcularVacaciones() {...}
}
class Jefe extends Empleado {
int numSupervisados,
int calcularVacaciones() {...}
}
Ejemplo
class Persona {
// Atributos
private String nombre;
private String telefono;
private Persona padre;
private Persona madre;
// Constructores
public Persona(String nombre, String telefono) {
this(nombre,telefono,null,null);
}
public Persona(String nombre, String telefono, Persona
padre, Persona madre) {
this.nombre = nombre;
this.telefono = telefono;
this.padre = padre;
this.madre = madre;
....
.........
// Metodos, acceden a atributos privados
public String nombre() {return nombre;}
public String telefono() {return telefono;}
public Persona padre() {return padre;}
public Persona madre() {return madre;}
public boolean hayPadre() {return padre != null;}
public boolean hayMadre() {return madre != null;}
}
polimorfismo
Asegura que el método correcto será llamado

para un objeto de un tipo específico, aún
cuando el objeto es una referencia a un objeto
de un tipo genérico, es decir de una superclase
Una vez definido una superclase común, el

polimorfismo ya existe, no hay que hacer nada
adicional
polimorfismo
El parámetro actual pasado a este método puede ser

Walker, Hopper, etc. ⎯ cualquier subclase de Biped.
public void moveAcross (Biped creature, int distance)

{
creature.firstStep();
while (creature.distanceTraveled () < distance)
creature.stop();
}
El método correcto será llamado automáticamente para

cada tipo específico de creature: métodos Walker para
Walker, métodos Hopper para Hopper, etc.
Un método con el mismo nombre, tipo de retorno
y lista de parámetros puede ser aplicado a
objetos de diferentes clases.
Uso, trabajar con la clase más general:
Parámetros polimórficos
Colecciones heterogéneas
Empleado e1 = new Empleado();

Empleado e2 = new Jefe();
Empleado e1 = new Secretaria();
e2.numSupervisados = 15; // ERROR

((Jefe)e2).numSupervisados = 15;
Parámetros polimórficos
class Mascota {...}
class Raton extends Mascota {...}
class Gato extends Mascota {...}
class Veterinario
{
void vacunar ( Mascota m )
{...}
}
...
Veterinario doctor = new Veterinario();
Gato tom = new Gato();
Raton jerry = new Raton();
doctor.vacunar(tom);
doctor.vacunar(jerry);
...
clases abstractas
Algunos métodos en una clase pueden ser

declarados como abstract y sólo
especificar la firma del método
Una clase con uno o más métodos
abstractos debe ser declarada abstract
public abstract class Biped
{
...
public abstract void firstStep();
Métodos
public abstract void nextStep();
abstractos
public abstract void stop();
...
public void draw(Graphics g) { ... }
}
clases abstractas
Clases abstractas sirven como superclases

comunes para clases más específicas
Un método abstracto provee una oportunidad al
compilador para realizar chequeo adicional de
errores
Las clases y métodos abstractos son necesarios
para que el polimorfismo funcione
Las clases abstractas están más cerca de la raíz de
la jerarquía pues describen objetos abstractos
clases abstractas
Java no nos permite instanciar, es decir crear

objetos, de una clase abstracta
Aún cuando la clase abstracta pueda tener
constructores, estos pueden ser llamados desde
constructores de las subclases
Una clase sin métodos abstractos se conoce
concrete
Ejemplo
Jerarquía de figuras geométricas:
class Punto
{
int x;
int y;
int color;
}
abstract class Figura

{
Punto ptoOrigen;
abstract void dibujar();
}
class Rectangulo extends Figura
{
Punto ptoFinal;
void dibujar() {...}
}
class Circulo extends Figura
{
int radio;
void dibujar() {...}
}
Class Object
En Java, cada clase por defecto extiende de

Object(java.lang)
Object es una clase concreta
Methods
public class Object redefined
{ (overridden)
public String toString {...} as necessary
public boolean equals (Object other) {... }
public int hashCode() { ... }
// a few other methods

...
}
Object
Todas las clases implícitamente heredan de la clase

Object: raíz de la jerarquía.
Object define un conjunto de métodos redefinibles:
public boolean equals(Object o): Permite definir el
criterio de igualdad de contenido de una
determinada clase
El operador == únicamente chequea la igualdad de
referencias.
En Object, equals se define directamente como la
identidad de referencias.
Object
public class Ficha {

private long id;
private static long idactual = 0;
public Ficha() {
id = idactual++;
}
public long id() {return id;}
public boolean equals(Object o) {
return (o instanceof Ficha) &&
((Ficha)o).id() == id;
}
public String toString() {
return "Ficha(id="+id+")";
}
}
Object
String s1 = new String("Hola")

String s2 = new String("Hola");
if (s1 == s2) // false
...
if (s1.equals(s2)) // true
...
s1.equals(s2) equivale a s2.equals(s1)
Llamando a los constructores de
una superclase
Biped
public class Walker extends Biped Walker

{
// Constructor
public Walker(int x, int y, Image leftPic, Image rightPic)
{
Llama al constructor
super(x, y, leftPic, rightPic); de Biped
...
} El número y tipo de argumentos debe coincidir
} con alguna de los constructores de la superclase
Si está presente,
debe ser la primera
sentencia
una superclase
Siempre se llama a uno de los constructores de

la superclase, pero no es necesario hacerlo
de forma explícita
Si no hay una llamada explícita a super,
entonces se invoca al constructor por defecto
de la superclase sin argumentos
una superclase
El constructor de una superclase llama al

constructor de su superclase hasta el
constructor de Objetc
Object
super( )
Biped
super(...)
Walker
LLamando métodos de la
superclase
Walker
public class CharlieChaplin

extends Walker CharlieChaplin
{
...
public void nextStep ()
{
turnFeetIn();
super.nextStep(); Llama al método
turnFeetOut(); nextStep de Walker
}
... super.someMethod se refiere a someMethod
} en la clase más cercana en la jerarquía de
clases donde someMethod fue definido.
Interface
DanceFloor Aerobics
Interface
DanceGroup Waltz
ControlPanel Dance Rumba
Band Cha-Cha-Cha
Dancer Salsa
Interface
Una interface es un conjunto de declaraciones de métodos

Declaración:
interface <NombreInterfaz>
{
<tipo> <nombreMétodo1> ( <args> );
<tipo> <nombreMétodo2> ( <args> );
...
}
Una clase que implemente el código de la interfaz debe

implementar todos sus métodos
class <NombreClase> implements <NombreInterfaz>
{
<tipo> <nombreMétodo1> ( <args> ) { <código> }
<tipo> <nombreMétodo2> ( <args> ) { <código> }
...
}
Interface
Un interface en Java es similar a una clase

abstracta que no tiene atributos ni
constructores, y todos sus métodos son
abstractos
public interface Dance

{
DanceStep getStep (int i);
int getTempo ();
int getBeat (int i);
}
Interface
Hay que indicar explícitamente que una clase
implementa una interface
Una clase concreta que implementa una
interface debe suplir todos los métodos de
dicha interface
public class Waltz implements Dance
{
...
// Methods:
public DanceStep getStep (int i) { ... }
public int getTempo () { return 750; }
public int getBeat (int i) { ... }
...
}
Interace
Las interfaces sirven para:

➔ Declararmétodos que serán implementados por
una o más clases
➔ Definirla interface de programación de un
objeto, sin mostrar el cuerpo actual de la clase
Cada interface debe escribirse en un archivo
*.java con el mismo nombre de la interface
Interface - abstract
interface Interfaz
{
<tipo> <método1>();
<tipo> <método2>();
...
<tipo> <métodoN>();
}
equivale a
abstract class Interfaz

{
abstract <tipo> <método1>();
abstract <tipo> <método2>();
...
abstract <tipo> <métodoN>();
}
Interface
public interface Edible public class Pancake
{ implements Edible
String getFoodGroup(); {
int getCaloriesPerServing(); ...
} }
public class Breakfast

Polimorfismo: el
{ método correcto
private int myTotalCalories = 0; es llamado para
... cada tipo
public void eat (Edible obj, int servings) específico de
{ Edible, es decir
myTotalCalories += Pancake, etc.
obj.getCaloriesPerServing () * servings;
}
...
}
Array
array
Un array o arreglo es un bloque de localidades
consecutivas de memoria que almacenan
valores del mismo tipo de dato
Cada localidad individual se le conoce como
elemento del arreglo
Cuando hablamos de un elemento, hacemos
referencia al valor almacenado en dicho
elemento
1.39 1.69 1.74 0.0 Un arreglo de

doubles
array
En lugar de tratar cada elemento como
una variable por separado, todo el
arreglo obtiene un nombre
Un elemento específico del arreglo es
referenciado usando el nombre del
arreglo y el índice del mismo
1.39 1.69 1.74 0.0

c[0] c[1] c[2] c[3] c es el nombre del
arreglo
array
En Java, un índice se escribe entre [ ]

El índice puede tomar cualquier valor entero entre 0
y la longitud – 1 del arreglo
Se puede usar como índice una variable entera o
cualquier expresión que de como resultado un
valor entero
a [3]
a [k]
a [k - 2]
a [ (int) (6 * Math.random()) ]
array
En Java, los arreglos se declaran de forma

estática, es decir, su tamaño no puede cambiar
a tiempo de ejecución
El interpretador de Java chequea los valores de
los índices y lanza una excepctón
ArrayIndexOutOfBoundsException si el índice es
negativo o mayor que la longitud – 1 del arreglo
array
El poder de los arreglos radica en el hecho
de que los valores de los índices pueden
ser calculado a tiempo de ejecución
Sin arrays: Con arrays:
int sum = 0; int n = 1000;

sum += score0; int sum = 0, k;
1000 sum += score1;
veces! … for (k = 0; k < n; k++)
sum += score999; sum += scores[k];
array
Los arreglos nos permiten un acceso directo a
cualquier elemento del mismo sin necesidad de
recorrer toda la estructura de datos
Sin arrays: Con arrays:
if (k == 0) display (scores[k]);
1000 display (score0);
veces! else if (k == 1)
display (score1);
else
… // etc.
array
En Java, un arreglo es un objeto. Si el tipo de sus
elementos es anyType, entonces el tipo del
objeto arreglo es anyType[ ].
Declaración de arreglos anyType [ ] arrName;
Dado que es un objeto, la declaración crea

solamente una referncia inicialmente en null. Un
arreglo debe ser creado antes de su uso
arrName = new anyType [length] ;

[ ] en lugar de ( )
array
Cuando el arreglo es creado, se le asigna espacio
de memoria para almacenar sus elementos. Si
no se especifica los valores de los elementos,
éstos obtienen el valor por defecto
Longitud 10, todos

scores = new int [10] ;
los valores en 0
words = new String [10000]; longitud 10000, todos

los valores en null
array
Un arreglo puede ser inicializado en la

declaración
int [ ] scores = new int [10] ;

private double [ ] gasPrices = { 3.05, 3.17, 3.59 };
String [ ] words = new String [10000];
String [ ] cities = {"Atlanta", "Boston", "Cincinnati" };
array
O puede ser inicializado más adelante
durante la ejecución
No inicializado
String [ ] words;
...
words = new String [ console.readInt() ];
No inicializado
private double[ ] gasPrices;
…
gasPrices = new double[ ] { 3.05, 3.17, 3.59 };
array
La longitud del arreglo es indicado en el momento

de la creación
La longitud puede indicarse explícitamente en la
declaración o através de la lista de inicialización
La longitud de un arreglo arrName es obtenido en
el código usando arrName.length.
length es un atributo público (no un método) del
objeto array
array
Como cualquier objeto, un arreglo es
pasado a un método como una
referencia
Los elementos del arreglo original no son
copiados y pueden ser modificados
desde el método
// Swaps a [ i ] and a [ j ]
public void swap (int [ ] a, int i, int j)
{
int temp = a [ i ];
a [ i ] = a [ j ];
a [ j ] = temp;
}
array
public double[ ] solveQuadratic (double a, double b, double c)

{
double d = b * b - 4 * a * c;
if (d < 0) return null;
d = Math.sqrt(d); O simplemente
double[ ] roots = new double[2]; return new double[ ]

roots[0] = (-b - d) / (2*a); { (-b - d) / (2*a),
roots[1] = (-b + d) / (2*a); (-b + d) / (2*a) };
return roots;
}
array
Arreglos de dos dimensiones son usados
para representar matrices
Un elemento en una matriz es direccionado
usando un par de índices (fila, columna)
board [ r ] [ c ] = 'x';
array
// 2-D array of char with 5 rows, 7 cols:
char[ ] [ ] letterGrid = new char [5][7];
// 2-D array of Color with 1024 rows, 768 cols:

Color[ ] [ ] image = new Color [1024][768];
// 2-D array of double with 2 rows and 3 cols:

double [ ] [ ] sample =
{ { 0.0, 0.1, 0.2 },
{ 1.0, 1.1, 1.2 } };
Si m es una matriz, entonces m[k] es un arreglo de una dimensión,

la k-ésima fila.
m.length es el número de filas
m[k].length es la longitud de la k-ésima fila
array
Java permite matrices en donde las filas pueden

tener longitudes diferentes
En una matriz rectangular, m[0].length puede ser
usado para representar el número de columnas.
Matriz irregular Matriz rectangular
m.length m.length
m[3].length m[0].length
array
Un arreglo de 2-dimensiones puede ser

recorrido usando lazos anidados
for (int r = 0; r < m.length; r++)

{
for (int c = 0; c < m[0].length; c++)
{
... // process m[ r ][ c ]
}
}
array
Transpuesta de una matriz
int n = m.length;
for (int r = 1; r < n; r++)

{
El número total de
for (int c = 0; c < r; c++) iteraciones a lo largo
{ del lazo interno es :
double temp = m [ r ][ c ];
m [ r ][ c ] = m [ c ][ r ]; 1 + 2 + 3 + ... + n-1 =
m [ c ][ r ] = temp; n (n - 1) / 2
}
}
Colecciones heterogéneas
Hasta ahora un array sólo podía contener elementos

del mismo tipo (colección homogénea)
Utilizando polimorfismo se pueden tener elementos de
distinto tipo en un array (colección heterogénea)
Se crean utilizando arrays definidos con el tipo
superclase
Mascota[] listaMascotas = new Mascota[5];
listaMascotas[0] = new Mascota();
listaMascotas[1] = new Gato();
listaMascotas[2] = new Raton();
listaMascotas[3] = new Raton();
listaMascotas[4] = new Gato();
class Empleado
{
...
Se consigue tratar a todos los
int salario; elementos por igual, aunque
int calcularVacaciones(){...}
alguno tenga un tratamiento
}
class Jefe extends Empleado
especial
{
int numTrabajadores;
int calcularVacaciones(){...}
}
...
Empleado[] lista = new Empleado[100];
lista[0] = new Empleado();
...
lista[56] = new Jefe();
...
for (int i = 0; i < lista.length; i++)
{
System.out.println(lista[i].calcularVacaciones());
}
Clase String
La clase String
Un objeto de la clase String representa una

cadena de caracteres
La clase String pertenece al paquete java.lang
package que está dentro de Java
Como cualquier clase, String tiene constructores y
métodos
Al contrario de otras clases, String tiene dos
operadores , + y += (usados para concatenar)
Literal Strings (cont’d)
Un texto string puede incluir caracteres de

“escape”
➔ \\ se refiere a \
➔ \n se refiere al caracter de nueva línea
String s1 = "Biology”;
String s2 = "C:\\jdk1.4\\docs";
String s3 = "Hello\n";
Inmutabilidad
Una vez creado, un string no puede ser cambiado:

ninguno de los métodos permite hacer cambios
A estos objetos se les conoce como inmutables
Los objetos inmutables son convenientes porque
varias referencias pueden apuntar al mismo
objeto de forma segura: no existe peligro de
cambiar el objeto a través de una referencia sin
que el resto se de cuenta del cambio
Inmutabilidad
Ventaja: mas eficiente, no necesita hacer copia
String s1 = "Sun"; String s1 = "Sun";

String s2 = s1; String s2 = new String(s1);
s1 s1 "Sun"
"Sun"
s2 s2 "Sun"
OK Menos eficiente:
ocupa más memoria
Inmutabilidad
Desventaja: menos eficiente— para pequeños

cambios necesitas crear un nuevo string y botar
el viejo
String s = "sun";
char ch = Character.toUpperCase(s.charAt (0));
s = ch + s.substring (1);
s "sun"
"Sun"
Strings vacíos
Un string vacío corresponde a una cadena que

no tiene caracteres. Su longitud es 0
String s1 = ""; Strings vacíos

String s2 = new String();
No debe confundirse con string no inicializado
private String errorMsg; errorMsg

es null
Métodos — length, charAt
int length (); • Devuelve el número de

caracteres en el string
• Devuelve el k-ésimo char
char charAt (k);
Las posiciones en un string son

numeradas desde 0
Retorna:
”Flower".length(); 6
”Wind".charAt (2); ’n'
Método — substring
String s2 = s.substring (i, k);

strawberry
devuelve la subcadena de
caracteres en las posiciones i hasta i k
k-1
strawberry
String s2 = s.substring (i);
i
devuelve la subcadena desde el i-
ésimo caracter Retorna:
”strawberry".substring (2,5); "raw"
"unhappy".substring (2); "happy"
"emptiness".substring (9); "" (empty string)
Método — Concat
String result = s1 + s2;

concatena s1 y s2
String result = s1.concat (s2);

igual que s1 + s2
result += s3;
concatena s3 a result
result += num;
convierte num a String y lo concatena a
result
Método — Find (indexOf)
0 8 11 15
String date ="July 5, 2012 1:28:19 PM";
retorna
date.indexOf ('J'); 0
date.indexOf ('2'); 8
date.indexOf ("2012"); 8
date.indexOf ('2', 9); 11 (empieza a buscar a partir
de la posición 9)
date.indexOf ("2020"); -1 no encontrado

date.lastIndexOf ('2'); 15
Métodos — Comparaciones
boolean b = s1.equals(s2);
retorna true si el string s1 es igual a s2
boolean b = s1.equalsIgnoreCase(s2);
retorna true si el string s1 matches s2, case-blind
int diff = s1.compareTo(s2);

retorna la diferencia s1 - s2
int diff = s1.compareToIgnoreCase(s2);

retorna la diferencia s1 - s2, case-blind
public class Palindrome {
public static boolean isPalindrome(String stringToTest) {
String workingCopy = removeJunk(stringToTest);
String reversedCopy = reverse(workingCopy);
return reversedCopy.equalsIgnoreCase(workingCopy);
}
protected static String removeJunk(String string)

{
int i, len = string.length();
StringBuffer dest = new StringBuffer(len);
char c;
for (i = (len - 1); i >= 0; i--) {

c = string.charAt(i);
if (Character.isLetterOrDigit(c)) {
dest.append(c);
}
}
return dest.toString();
}
protected static String reverse(String string) {
StringBuffer sb = new StringBuffer(string);
return sb.reverse().toString();
}

String string = "Madam, I'm Adam.";
System.out.println();
System.out.println(
• "Testing whether the following " + "string is a palindrome:");
System.out.println(" " + string);
if (isPalindrome(string)) {
System.out.println(“It IS a palindrome!");
} else {
System.out.println("It is NOT a palindrome!");
}
}
}
De diagramas de clase (UML)
a Java
Transformación de clases para
una implementación OO
Todo atributo y operación en el diagrama de

clases se debe declarar formando parte de su
clase correspondiente.
class LíneaVenta {
Línea Venta int cantidad;
subtotal( ) {...}
cantidad:entero
LíneaVenta() {...}
subtotal( ) }
Transformación de asociaciones
para una implementación OO
Una asociación bidireccional es implementada,

normalmente, como un atributo de referencia dentro
de cada objeto asociado.
Si la asociación es unidireccional sólo se necesita

añadir un atributo de referencia a una de las clases.
Una asociación también se puede implementar

como una clase.
Los atributos de referencia de la clase “uno” son

simplemente referencias a un objeto.
Los atributos de referencia de la clase “muchos”

necesitan un contenedor de objetos.
Una asociación cualificada se puede implementar

en forma de objeto diccionario.
1..* trabajapara 1
Persona Compañía
empleado empresario
class Persona { class Compañía {

Compañía empresario; Persona[] empleado;
Persona( ) { … } Compañía( ) { … }
} }
1..* Edita 1
Libros Editorial
class Libro { class Editorial {

Libro( ) { … } Libro[] mislibros;
} Editorial( ) { … }
}
Transformación de clase
asociación para una
implementación OO
0..* Esta autorizado en 0..*
Usuario Estación de
trabajo
Autorización
class Usuario { class estaciónt {
autorización[] miautori; autorización[] miautori;
Usuario( ){ … } estaciónt( ){ … }
} }
class autorización {
usuario miusuario;
estaciónt miestación;
autorización( ){ … }
}
Transformación de atributos de
enlace para una implementación OO
Asociación uno-a-uno: Los atributos de enlace se

pueden almacenar como atributos de cualquiera de
los objetos.
Asociación uno-a-muchos: Los atributos de enlace se

pueden almacenar como atributos del objeto
“muchos”.
Asociación muchos-a-muchos: Se implementa la

asociación como una clase.
Transformación de agregación
•Se implementa igual que la asociación.
computadora
1..* 1
monitor teclado
class Monitor {
Monitor( ) { … }
} class Teclado {
Teclado( ) {…}
}
class Computadora {
Monitor[] mismonitores;
Teclado miteclado;
Computadora( ) {
}
}
Transformación de herencia simple
Lámpara
Fluorescente Incandescente
class Lámpara {
Lámpara( ) { … }
}
class Fluorescente extends Lámpara {

Fluorescente( ) {…}
}
class Incandescente extends Lámpara {

Incandescente( ) { … }
}
Paquetes
Paquetes
Un paquete es una agrupación de clases (librería)

El programador puede crear sus propios paquetes con la sentencia
package al principio del archivo fuente
package <nombre.paquete>;
Ejemplo: package empresa.finanzas;

La composición de nombres (separados por puntos) está relacionada
con la jerarquía de directorios:
CLASSPATH\empresa\finanzas\
Los nombres de los paquetes se suelen escribir en minúsculas
Ejemplo de Paquetes
Archivo fuente Empleado.java:
package empresa.finanzas;
public class Empleado
{
...
}
La clase Empleado realmente se llama empresa.finanzas.Empleado

Si no se indica la sentencia package, la clase Empleado pertenecerá a
un paquete por defecto sin nombre
Sentencia import
La sentencia import indica al compilador dónde están ubicadas las

clases que estamos utilizando
Para importar sólo una clase de un paquete:
import <nombre.paquete>.<NombreClase>;
Para importar todas las clases de un paquete:
import <nombre.paquete>.*;
El compilador añade a todos los archivos la línea
import java.lang.*;
El paquete que contiene las clases fundamentales para programar
en Java (System, String, Object...)
Ejemplo de import
import empresa.finanzas.*;
public class Jefe extends Empleado
{
String departamento;
Empleado[] subordinados;
}
Si no se pone el import, deberíamos referirnos a

Empleado como empresa.finanzas.Empleado
La clase Jefe pertenece al paquete anónimo por
defecto
String pertenece al paquete java.lang
Modificadores de acceso:
atributos y métodos
Especificador Clase Subclase Paquete Mundo
private Si No No No
protected Si Si* Si No
public Si Si Si Si
package Si No Si No
La clase Vector
La Clase Vector
La clase Vector (paquete java.util) representa una colección

heterogénea de objetos (referencias a objetos de tipo Object o a
cualquiera de sus subclases)
El vector al crearse reserva cierta cantidad de memoria, aunque sus
elementos sólo utilicen una parte
El tamaño del vector se incrementa por bloques cuando se añade y se
agota el espacio reservado. El tamaño de incremento se indica en
el atributo capacityIncrement
El vector se mantiene compacto en todo momento

Cada elemento es accesible a través de un índice, pero no con los
corchetes, [ ]
La Clase Vector
Atributos:
int capacityIncrement: incremento en la capacidad del vector. Si vale
cero, duplica el tamaño actual del vector.
int elementCount: número de elementos válidos del vector
Object[] elementData: array de objetos donde se guardan los
elementos
Constructores:
Vector(): Crea un vector vacío (capacidad 10, incremento 0)
Vector(int initialCapacity): Crea un vector vacío con la capacidad
dada (incremento 0)
Vector(int initialCapacity, int initialIncrement): Crea un
vector vacío con la capacidad y el incremento dados
La Clase Vector
Métodos:
int capacity() devuelve la capacidad que tiene el vector
int size() devuelve el número de elementos en el vector
boolean contains(Object elem) devuelve true si el vector contiene el objeto

especificado
int indexOf(Object elem) devuelve la posición de la primera vez que
aparece el objeto que se le pasa
Object get(int index) devuelve el elemento situado en la posición

indicada (*)
void set(Object elem,int index) reemplaza el objeto que corresponde al índice
por el objeto que se le pasa (*)
Los métodos con (*) pueden lanzar la excepción ArrayIndexOutOfBoundsException

La Clase Vector
Métodos:
void removeElementAt(int borra el objeto situado en la posición indicada

index) (*)
void addElement(Object elem) añade un objeto al final
void insertElementAt(Object inserta el objeto que se le pasa en la posición

elem, indicada, desplazando el resto de elementos
en el vector (*)
int index)

Java PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Java PDF

Cargado por

Copyright:

Formatos disponibles

Introducción y Fundamentos del

Tecnología desarrollada por Sun Microsystems

Lenguaje de programación orientado a objetos

La promesa inicial era Write Once, Run Anywhere

La idea era proporcionar un lenguaje

La tecnología Java incluye el lenguaje de

Java es al mismo tiempo compilado e interpretado

Java Operating System

public class ProgramaSimple {

Sensible a las Mayúsculas / Minúsculas

Los nombres de los métodos, campos y variables

Generalmente, los nombres de los métodos suenan como

Sintáxis es parte del lenguaje. El compilador

El compilador detecta errores de sintáxis y genera

Errores comunes de sintáxis

Ortografía Public static int abs (int x)

Un comentario de una sola línea va desde

Usado por javadoc para la generación

/** indica un comentario javadoc

La disposición de los elementos dentro del código es libre

Coloque cada sentencia en una línea e indente

public void nextStep() public void nextStep()

Compila bien Más fácil de leer

public void fill (char ch)

Una variable corresponde a una dirección de

Las variables pueden ser de distintos tipos : int,

Una variable debe ser declarada antes de su uso

Una variable puede ser inicializada en su

Variables pueden tener el mismo for (int k = ...)

Las variables locales se declaran dentro de un

public class SomeClass

Usen variables locales cuando sea apropiado;

public void someMethod (...)

private double radius;

String no es un tipo primitivo de datos

"Catch " + 22 "Catch 22"

'A', '+', '\n', '\t' char

-99, 2010, 0 int

0.75, -12.3, 8., .5 double

“coin.gif", "1776", "y", "\n" String

private final int stepLength = 48;

Por qué Constantes Simbólicas?

El tipo del resultado viene determinado por el tipo

Si a y b son enteros entonces a / b es

Para obtener el resultado correcto, deben usar

int ptsOnDie = (int)(Math.random() * 6) + 1;

int miles = (int)(km * 1.61 + 0.5);

Variables booleanas pueden

En if (<condition> ) <condition> es una

Operadores relacionales <, >, <=, >=, ==, !=

Usar los métodos equals o

if ( "Help".equals (cmd) ) ...

if ( ( ( year % 4 ) == 0 ) && ( month == 2 ) ) ...

Punto y coma adicional Faltan { }

switch (expression) switch (num)

Usados cuando el atributo de un objeto o

private enum Speed { LOW, MEDIUM, HIGH };

private enum InkColor { BLACK, RED };

private enum DayOfWeek { sunday, monday,

Si el cuerpo tiene solo while ( condicion )

// Returns the smallest n

for es una forma abreviada que combina

El break en una sentencia de iteración instruye al