Download Introducción y Fundamentos del lenguaje de programación

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
Bytecode
Verifier
Java
Source
(.java)
Java
Compiler
Java
Bytecodes
move locally
or through
network
Java
Interpreter
Just in
Time
Compiler
Runtime System
Java
Bytecode
(.class )
Operating System
Hardware
Java
Class
Libraries
Java
Virtual
machine
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
Características del lenguaje
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()
Características del lenguaje
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
Características del lenguaje
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
Características del lenguaje
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
Características del lenguaje
Errores comunes de sintáxis
Ortografía
(p → P, if → If)
Falta
}
Public static int abs (int x)
{
If (x < 0);
{
x = -x
}
return x;
public static int sqrt (int x)
...
Punto y coma
extraño
Falta punto y
coma
Características del lenguaje
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.
Características del lenguaje
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
Características del lenguaje
/** indica un comentario javadoc
/**
*
*
*
*
*
*/
Returns total sales from all vendors;
sets <code>totalSales</code>
to 0.
@return total amount of sales from all vendors
Estilo
Se pueden usar tags
HTML
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;
}
}
Características del lenguaje
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;
Características del lenguaje
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
Características del lenguaje
Estilo
public void nextStep()
{ if (stepsCount % 2
== 0) leftFoot.
moveForward (2 *
stepLength);
else rightFoot.
moveForward(2 *
stepLength);
stepsCount++; }
Compila bien
public void nextStep()
{
if (stepsCount % 2 == 0)
leftFoot.moveForward (2 * stepLength);
else
rightFoot.moveForward (2 * stepLength);
stepsCount++;
}
Más fácil de leer
Características del lenguaje
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
Características del lenguaje
public void fill (char ch)
{
int rows = grid.length, cols = grid[0].length;
for (int r = 0; r < rows; r++)
{
for (int c = 0; c < cols; c++)
{
grid[r][c] = ch;
}
}
}
Agregar líneas en
blanco para facilitar
lectura
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;
stepsCount = 0;
Grupo de
sentencias
}
else if (currentState == State.MOVING)
{
if (amy.distanceTraveled() <= danceFloor.getWidth() * 3 / 4)
{
Grupo de
amy.nextStep();
ben.nextStep();
sentencias
stepsCount++;
}
else
{
amy.stop();
ben.stop();
currentState = State.STOPPED;
}
}
danceFloor.update(this);
}
Grupo de
sentencias
Grupo de
sentencias
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
Tipo
count;
double
x, y;
JButton
go;
Walker
amy;
String firstName;
Nombre(s)
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
alcance, el compilador
reportará un error de sintáxis
Variables pueden tener el mismo
nombre cuando sus alcances
no se solapan
{
int k = ...;
...
}
for (int k = ...)
{
...
}
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
{
}
}
...
}
Variable local declarada
Alcance
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
double
char
boolean
•
•
•
•
byte
short
long
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> )
{
< statements >
}
else
{
< other statements >
}
if ( <condition> )
{
< 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
Operadores relacionales
Usar los métodos equals o
equalsIgnoreCase para comparar
Strings:
o
String cmd = console.readLine();
if ( cmd.equals ("Help") ) ...
if ( "Help".equals (cmd) ) ...
Operadores relacionales
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"))
{
price += 1.39;
}
else if (drinkSize.equals("Medium"))
{
price += 1.19;
}
else // if "Small" drink size
{
price += 0.99;
}
if (drinkSize.equals(”Large"))
price += 1.39;
else if (drinkSize.equals("Medium"))
price += 1.19;
else // if "Small" drink size
price += 0.99;
Errores comunes
Punto y coma adicional
if (...) ;
{
sentencias;
...
}
Es más seguro
usar { } en ifelse
Faltan { }
if (...)
sentencia1;
sentencia2;
...
if (...)
if (...)
sentencia1;
else
sentencia2;
switch
switch (expression)
{
case value1:
...
break;
}
case value2:
...
break;
...
...
default:
...
break;
switch (num)
{
case 1:
case 2:
System.out.println ("Buckle your shoe");
break;
case 3:
...
}
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
while ( condicion )
{
statement1;
statement2;
...
statementN;
}
Si el cuerpo tiene solo
una sentencia, entonces
las { } son opcionales
condicion es cualquier
expresión lógica
cuerpo del lazo
while ( condicion )
statement1;
while
// Returns the smallest n
// such that 2^n >= x
public static int intLog2 (int x)
{
int n = 0, p = 1;
while ( p < x )
{
p *= 2;
n++;
}
return n;
}
Inicialización
Test
Cambio
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
{
statement1;
statement2;
...
statementN;
} while ( condition );
Siempre use { } para
facilitar la lectura del
código
Se ejecuta al menos
una vez
Si la condición es
falsa, no se ejecuta
la próxima iteración
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++)
{
for (c = 0; c < m[0].length; c++)
{
if (m [ r ][ c ] == 'X' )
break;
}
}
...
breaks colocados
dentro de un lazo
interno continuan
con el lazo externo
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
El cliente entra en la
panadería
El cliente pasa detrás de la
barra
El cliente prepara la
cafetera
El cliente se sirve el café
El cliente se bebe el café.
Orientado a Objetos
El cliente entra en la
panadería
El cliente pide un café al
“cafetero”
El “cafetero” prepara el
café.
El “cafetero” sirve 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
public class SomeClass
{
Atributos
}
Constructores y
métodos
O
Alcance
public class SomeClass
{
Constructores y
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 {
public static void main(String[] args) {
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 methods:
public <sometype> myMethod (...) { ... }
...
// Private methods:
private <sometype> myMethod (...) { ... }
...
}
Public interface:
public constructors
and methods
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
{
private int num, denom;
public Fraction (int n, int d)
{
num = n;
denom = d;
reduce ();
}
public Fraction ( )
{
num = 0;
“No-args”
denom = 1;
constructor
}
public Fraction (int n)
{
num = n;
denom = 1;
Continua ®
}
public Fraction (Fraction other)
{
num = other.num;
denom = other.denom;
}
...
Copy
}
constructor
Constructores
Constructores de una clase pueden
llamarse entre si usando la palabra
reservada this
public class Fraction
{
...
public Fraction (int n)
{
this (n, 1);
}
...
...
public Fraction (int p, int q)
{
num = p;
denom = q;
reduce ();
}
...
Referencias a objetos
Fraction f1 = new Fraction(3,7);
Fraction f2 = f1;
f1
Objeto
Fraction
f2
num = 3
denom = 7
Fraction f1 = new Fraction(3,7);
Fraction f2 = new Fraction(3,7);
f1
num = 3
denom = 7
f2
Referencia al
mismo objeto
objeto
Fraction
objeto
Fraction
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;
double y = p.getValue ( x );
}
x:
3.0
copia
...
public double getValue (double u)
{
double v;
u actua como una
...
variable local en
}
getValue
copia
u:
3.0
Paso de argumentos
public class Test
{
public double square (double x)
{
x es una copia del parámetro
x *= x;
pasado. La copia cambia pero…
return x;
}
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);
Fraction f2 = new Fraction (5, 17);
public class Fraction
{
... copia referencia
Fraction f3 = f1.add (f2);
Refiere a
Un objeto
Fraction:
num = 5
denom = 17
public Fraction add
(Fraction f)
{
...
}
Refiere al
}
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 (...)
return <expression2>;
...
return <expression3>;
}
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) { ... }
Sobrecarga de métodos
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
Circle circle = new Circle(5);
circle.move (50, 100);
Point center = new Point(50, 100);
circle.move (center);
public class Circle
{
public void move (int x, int y)
{ ... }
public void move (Point p)
{ ... }
...
Sobrecarga de métodos
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)
{ ... }
public Point move (int x, int y)
{ ... }
...
Error de sintáxis
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
{
private static final double slowDown = 0.97;
private static final double speedFactor = 0.04;
...
Palabras
reservadas:
static
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(...)
{
statVar = statConst;
OK
statMethod(...);
instVar = ...;
instMethod(...);
}
Error!
Método static
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
ToedInWalker
Hopper
CharlieChaplin
Dancer
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.
Jerarquía entre clases
Ayuda a reducir
duplicación de código
factorizando lo común
entre varias clases en la
superclase
Walker
Constructor
firstStep
nextStep
stop
distanceTraveled
Biped
Constructor
Accessors
turnLeft
turnRight
turnAround
draw
Hopper
Constructor
firstStep
nextStep
stop
distanceTraveled
Jerarquía entre clases
Reduce la duplicación de código y
permite escribir métodos mas generales
public void moveAcross
(Walker
creature, int distance)
{
Sirve tanto para
Walker o Hopper
por polimorfismo
creature.firstStep();
while (creature.distanceTraveled() < distance)
creature.nextStep();
public void moveAcross
creature.stop();
}
(Biped creature, int distance)
{
public void moveAcross
creature.firstStep();
while (creature.distanceTraveled() < distance)
(Hopper creature, int distance)
creature.nextStep();
{
creature.stop();
creature.firstStep();
while (creature.distanceTraveled() < distance) }
creature.nextStep();
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
{
int numRuedas;
int numAsientos;
int velocidadMax;
}
class Avion
{
int
int
int
int
}
numRuedas;
numAsientos;
velocidadMax;
numAlas;
class Bici
{
int numRuedas;
int numAsientos;
int velocidadMax;
}
class Avion extends Bici
{
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
{
}
¿un Coche tiene-un Motor? Sí
¿un Coche tiene-un Chasis? Sí
class Coche
{
Motor m;
Chasis ch;
}
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.nextStep();
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();
public abstract void nextStep();
public abstract void stop();
...
public void draw(Graphics g) { ... }
}
Métodos
abstractos
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
public class Object
{
public String toString {...}
public boolean equals (Object other) {... }
public int hashCode() { ... }
// a few other methods
...
}
Methods
redefined
(overridden)
as necessary
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
Walker
public class Walker extends Biped
{
// 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
Llamando a los constructores de
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
Llamando a los constructores de
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
CharlieChaplin
extends Walker
{
...
public void nextStep ()
{
turnFeetIn();
Llama al método
super.nextStep();
nextStep de Walker
turnFeetOut();
}
...
super.someMethod se refiere a someMethod
}
en la clase más cercana en la jerarquía de
clases donde someMethod fue definido.
Interface
DanceFloor
DanceGroup
ControlPanel
Aerobics
Interface
Dance
Waltz
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:
➔ Declarar
métodos que serán implementados por
una o más clases
➔ Definir
la 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
{
String getFoodGroup();
int getCaloriesPerServing();
}
public class Pancake
implements Edible
{
...
}
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
{
Pancake, etc.
myTotalCalories +=
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:
1000
veces!
int sum = 0;
sum += score0;
sum += score1;
…
sum += score999;
Con arrays:
int n = 1000;
int sum = 0, k;
for (k = 0; k < n; k++)
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
1000
veces!
Sin arrays:
Con arrays:
if (k == 0)
display (score0);
else if (k == 1)
display (score1);
else
… // etc.
display (scores[k]);
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
scores = new int [10] ;
words = new String [10000];
Longitud 10, todos
los valores en 0
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
String [ ] words;
No inicializado
...
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);
double[ ] roots = new double[2];
roots[0] = (-b - d) / (2*a);
roots[1] = (-b + d) / (2*a);
return roots;
}
O simplemente
return new double[ ]
{ (-b - d) / (2*a),
(-b + d) / (2*a) };
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[3].length
m.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++)
{
for (int c = 0; c < r; c++)
{
double temp = m [ r ][ c ];
m [ r ][ c ] = m [ c ][ r ];
m [ c ][ r ] = temp;
}
}
El número total de
iteraciones a lo largo
del lazo interno es :
1 + 2 + 3 + ... + n-1 =
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
...
elementos por igual, aunque
int salario;
int calcularVacaciones(){...}
alguno tenga un tratamiento
}
especial
class Jefe extends Empleado
{
int numTrabajadores;
int calcularVacaciones(){...}
}
...
Empleado[] lista = new Empleado[100];
lista[0] = new Empleado();
lista[1] = new Empleado();
...
lista[56] = new Jefe();
...
lista[99] = new Empleado();
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 s2 = s1;
s1
String s1 = "Sun";
String s2 = new String(s1);
s1
"Sun"
s2
"Sun"
"Sun"
s2
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 = "";
String s2 = new String();
Strings vacíos
No debe confundirse con string no inicializado
private String errorMsg;
errorMsg
es null
Métodos — length, charAt
int length ();
char charAt (k);
• Devuelve el número de
caracteres en el string
• Devuelve el k-ésimo char
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);
devuelve la subcadena de
caracteres en las posiciones i hasta
k-1
strawberry
i
k
strawberry
String s2 = s.substring (i);
i
devuelve la subcadena desde el iésimo caracter
Retorna:
”strawberry".substring (2,5);
"unhappy".substring (2);
"emptiness".substring (9);
"raw"
"happy"
"" (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
date.indexOf ("2020");
-1
date.lastIndexOf ('2');
15
(empieza a buscar a partir
de la posición 9)
no encontrado
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();
}
public static void main(String[] args) {
String string = "Madam, I'm Adam.";
System.out.println();
System.out.println(
"Testing whether the following " + "string is a palindrome:");
System.out.println("
" + string);
System.out.println();
•
if (isPalindrome(string)) {
System.out.println(“It IS a palindrome!");
} else {
System.out.println("It is NOT a palindrome!");
}
System.out.println();
}
}
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
subtotal( )
{
LíneaVenta() {...}
}
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.
Transformación de asociaciones
para una implementación OO
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.
Transformación de asociaciones
para una implementación OO
1..*
trabajapara
1
Persona
Compañía
empresario
empleado
class Persona {
}
class Compañía {
Compañía empresario;
Persona[] empleado;
Persona( ) { … }
Compañía( ) { … }
}
Transformación de asociaciones
para una implementación OO
1..*
Edita
1
Libros
Editorial
class Libro {
class Editorial {
Libro[] mislibros;
Libro( ) { … }
Editorial( ) { … }
}
}
Transformación de clase
asociación para una
implementación OO
0..*
Esta autorizado en
Usuario
0..*
Estación de
trabajo
Autorización
class Usuario {
autorización[] miautori;
Usuario( ){ … }
}
class autorización {
usuario miusuario;
estaciónt miestación;
autorización( ){ … }
}
class estaciónt {
autorización[] miautori;
estaciónt( ){ … }
}
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
para una implementación OO
•Se implementa igual que la asociación.
computadora
1
1..*
monitor
teclado
class Monitor {
Monitor( ) { … }
}
class Computadora {
Monitor[] mismonitores;
Teclado miteclado;
Computadora( ) {
}
}
class Teclado {
Teclado( ) {…}
}
Transformación de herencia simple
para una implementación OO
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
index)
borra el objeto situado en la posición indicada
(*)
void addElement(Object elem)
añade un objeto al final
void insertElementAt(Object
elem,
inserta el objeto que se le pasa en la posición
indicada, desplazando el resto de elementos
en el vector (*)
int index)