Poo 2 Java

Tema 2.
Introducción a Java
Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Universidad de Málaga
Programación Orientada a Objetos

Tema
Universidad
2. Introducción
de Málaga
a Java Programación Orientada a Objetos 1 / 98
Programación Orientada a Objetos
Tema 2. Introducción a Java

Programas y paquetes
Clases y objetos, tipos y variables
Elementos del lenguaje
Control de errores
Cadenas de caracteres
Arrays
Herencia, polimorfismo y vinculación dinámica
Clases abstractas e interfaces
Esta obra se encuentra bajo una licencia Reconocimiento-NoComercial-CompartirIgual 4.0 Internacional (CC BY-NC-SA 4.0) de Creative Commons.

Tema
Universidad
2. Introducción
de Málaga
Desarrollado por Sun (ahora Oracle). Aparece en 1995.

Basado en C++ (y algo en Smalltalk) eliminando:
Definiciones de tipos de valores y macros.
Punteros y aritmética de punteros.
necesidad de liberar memoria.
Fiable y seguro:
Memoria dinámica automática (no punteros explícitos).
comprobación automática de tamaño de variables.
Orientado a objetos con:
Herencia simple y polimorfismo de datos.
Redefinición de métodos y vinculación dinámica.
Concurrencia integrada en el lenguaje.
Interfaz gráfica integrada en el lenguaje.

Tema
Universidad
2. Introducción
de Málaga
Java es un lenguaje que sigue un esquema de traducción mixto:
Los ficheros con código fuente en Java (.java) se compilan a bytecode
(.class).
Los ficheros con código bytecode (.class) son interpretados por la Máquina
Virtual de Java (JVM).
Bibliotecas
(organizadas en paquetes)
.java .class .jar .jar
.class .class
.class .class
.class .class
.java .class
Compilador
Interprete
.java .class JVM
Fuente Bytecode
Java
Tema
Universidad
2. Introducción
de Málaga
Programa Java
Un programa Java está formado por una o varias clases Java diseñadas para
colaborar en la realización de una tarea.
De entre todas las clases que forman el programa, existe una clase pública
distinguida que contiene un método de clase (estático) que es el punto de
entrada inicial para la ejecución del programa:
public static void main(String[] args) { ... }
Las demás clases, unas pueden estar definidas explícitamente para este
programa, y otras pueden pertenecer a una biblioteca de clases.

Tema
Universidad
2. Introducción
de Málaga
Paquetes Java
En Java, las clases se organizan en paquetes (package).
El nombre del paquete especifica la jerarquía de directorios (carpetas) donde
se encuentra cada clase.
Todas las clases de un mismo paquete deben estar localizadas en un mismo
directorio (carpeta), organizadas jerárquicamente según el nombre del paquete
al que pertenecen.
Los paquetes son mecanismos lógicos de organización para agrupar clases
relacionadas.
Si una clase no especifica el paquete al que pertenece, entonces formará parte
del paquete por defecto (anónimo).
Todas las clases que pertenecen a un paquete pueden utilizar directamente,
por sus nombres, a las demás clases que se encuentran dentro del mismo
paquete.
Si una clase quiere utilizar a otra clase que pertenece a otro paquete, entonces
puede hacerlo de dos formas:
Cualificando el nombre de la clase a utilizar con el nombre del paquete al que
pertenece.
Importando la clase a utilizar mediante la construcción import.

Tema
Universidad
2. Introducción
de Málaga
Paquetes Java
Dada la siguiente especificación de clases, donde ambas clases se definen

dentro del mismo paquete:
// File: pac1/Punto.java
package pac1;
public class Punto {
private double x, y;
Punto() { x = 0; y = 0; }
Punto(double a, double b) { x = a; y = b; }
// ...
}
// File: pac1/Segmento.java
package pac1;
public class Segmento {
private Punto origen, extremo; // utilización directa de Punto
public Segmento(double x1, double y1, double x2, double y2) {
origen = new Punto(x1, y1); // utilización directa de Punto
extremo = new Punto(x2, y2); // utilización directa de Punto
}
// ...
}

Tema
Universidad
2. Introducción
de Málaga
Paquetes Java
Sin embargo, si ambas clases se definen en paquetes distintos, es necesario

cualificar o importar el nombre de la clase utilizada:
package pac1;
Punto() { x = 0; y = 0; }
// ...
}
package pac2;
private pac1.Punto origen, extremo; // utilización cualificada de Punto
origen = new pac1.Punto(x1, y1); // utilización cualificada de Punto
extremo = new pac1.Punto(x2, y2); // utilización cualificada de Punto
}
// ...
}

Tema
Universidad
2. Introducción
de Málaga
Paquetes Java
Sin embargo, si ambas clases se definen en paquetes distintos, es necesario

cualificar o importar el nombre de la clase utilizada:
package pac1;
Punto() { x = 0; y = 0; }
// ...
}
package pac2;
import pac1.*; // importación de todas las clases del paquete pac1
import pac1.Punto; // importación explícita de la clase Punto
private Punto origen, extremo; // utilización importada de Punto
origen = new Punto(x1, y1); // utilización importada de Punto
extremo = new Punto(x2, y2); // utilización importada de Punto
}
// ...
}

Tema
Universidad
2. Introducción
de Málaga
Paquetes básicos de Java
java.lang: para funciones del lenguaje.

java.util: para utilidades adicionales.
java.io: para entrada y salida.
java.text: para formato especializado.
java.awt: para diseño gráfico e interfaz de usuario.
java.awt.event: para gestionar eventos.
javax.swing: nuevo diseño de GUI.
java.net: para comunicaciones.
...

Tema
Universidad
2. Introducción
de Málaga
Acceso a las bibliotecas de Java
Todas las clases del paquete java.lang se importan automáticamente a

cualquier programa de Java, por lo que no es necesario ni cualificarlas ni
importarlas explícitamente. Por ejemplo System o Math.
Para todas las demás clases del resto de bibliotecas, sí es necesario cualificar
o importar explícitamente el paquete al que pertenece.
Por ejemplo, el siguiente programa calcula el valor medio de un millón de
números generados aleatoriamente, usando la clase Random del paquete
java.util y la clase System del paquete java.lang.
public class TestAleatorio {
public static void main(String[] args) {
java.util.Random rnd = new java.util.Random(); // cualificación explícita
double sum = 0.0;
for (int i = 0; i < 1000000; ++i) {
sum += rnd.nextDouble();
}
System.out.println("media = " + sum / 1000000.0); // utilización implícita
}
}

Tema
Universidad
2. Introducción
de Málaga
Acceso a paquetes
Los paquetes del sistema cuelgan de varios subdirectorios específicos:

<system>/java y <system>/javax
Cuando una clase importa un determinado paquete o clase, el compilador lo
busca por defecto entre los paquetes del sistema y, además, en el
directorio raiz del proyecto Java al que pertenece la clase.
Para que el compilador busque paquetes en otro sitio, se debe especificar en la
variable CLASSPATH del entorno.
La variable CLASSPATH del entorno contiene una lista con todos directorios de
búsqueda de los paquetes.
El nombre de cada paquete debe coincidir con la ruta que va desde algún
directorio del CLASSPATH (o desde /java o /javax) al subdirectorio
correspondiente donde reside el paquete. Por ejemplo: java.util y
java.awt.event

Tema
Universidad
2. Introducción
de Málaga
Jerarquía de paquetes
Frontera del CLASSPATH
javax
java
util lang
io
Otros Paquetes java.util java.lang

java.io
Paquetes del Sistema

Tema
Universidad
2. Introducción
de Málaga
Fichero Java
Cada clase declarada como pública debe de estar en un fichero .java con su
mismo nombre.
Cada fichero .java puede contener varias clases pero sólo una podrá ser
pública.
En caso de que la clase pertenezca a un determinado paquete, entonces el
fichero residirá en la jerarquía de directorios (carpetas) especificada por la
ruta del nombre del paquete.
Cada fichero .java debe compilarse, generando un fichero .class (en
bytecodes) por cada clase contenida en él.
El programa se ejecuta pasando el fichero .class de la clase distinguida al
intérprete de la Máquina Virtual de Java.

Tema
Universidad
2. Introducción
de Málaga
Clases en Java
Una clase pública debe estar definida en un fichero .java con su mismo
nombre.
La definición de una clase consta de los siguientes elementos:
Especificación del paquete al que pertenece la clase. Si no se especifica,
entonces pertenece al paquete por defecto (anónimo).
Especificación del nombre de la clase, de la relación de herencia e
implementación de interfaces.
Especificación de los atributos, tanto variables de instancia como variables de
clase, especificando su nombre, tipo, y cualificadores necesarios (static,
final), así como de su control de visibilidad (public, protected y private).
Definición de los constructores, diferenciados por los parámetros que reciben,
especificando su control de visibilidad (public, protected y private).
Definición de los métodos, tanto métodos de instancia como métodos de
clase, especificando su nombre, tipo, parámetros, y cualificadores necesarios
(static, final), así como de su control de visibilidad (public, protected y
private).

Tema
Universidad
2. Introducción
de Málaga
Ejemplo: Clase Punto
// Punto.java
// Atributos
// Constructores
public Punto() { x = 0; y = 0; }
public Punto(double a, double b) { x = a; y = b; }
// Métodos
public double abscisa() { return x; }
public double ordenada() { return y; }
public void abscisa(double a) { x = a; }
public void ordenada(double b) { y = b; }
public void desplazar(double a, double b) { x += a; y += b; }
public double distancia(Punto pto) {
return Math.sqrt(Math.pow(this.x - pto.x, 2) + Math.pow(this.y - pto.y, 2));
}
}

Tema
Universidad
2. Introducción
de Málaga
Ejemplo: Clase Particula
// Particula.java
public class Particula extends Punto {
// Atributos
final static double G = 6.67e-11;
private double masa; // ( + los atributos heredados de Punto )
// Constructores
public Particula(double m) {
this(0, 0, m); // Se refiere a Particula(double, double, double)
}
public Particula(double a, double b, double m) {
super(a, b); // Se refiere a Punto(double, double)
masa = m;
}
// Métodos ( + los métodos heredados de Punto )
public void masa(double m) { masa = m; }
public double masa() { return masa; }
public double atraccion(Particula part) {
// Nótese la invocación al método distancia heredado de Punto
return G * this.masa * part.masa / Math.pow(this.distancia(part), 2);
}
}

Tema
Universidad
2. Introducción
de Málaga
Variables de instancia
Cada instancia (objeto) tiene sus propias variables de instancia
independientes.
Se crean cuando se crea dinámicamente el objeto al que pertenecen.
Se destruyen cuando se destruye el objeto al que pertenecen.
Ej. cada punto tiene dos variables de instancia : x, y
pto1 Punto pto2 Punto
• ▸ 1 2 • ▸ 2 1
Las variables de instancia se acceden cualificándolas con el nombre de la

referencia al objeto al que pertenecen (this para el objeto implicado, aunque
se puede suprimir si no hay conflicto de nombres). Por ejemplo: part.masa,
this.masa, masa.
Se pueden declarar final si su valor no cambiará (será constante).
Se inicializan con un valor por defecto (cero o null) si no se especifica ningún
otro valor (no para final).
Desde fuera de la clase, hay que tener en cuenta el control de visibilidad.
private double x, y; // x e y son variables de instancia
// ...
}
Tema
Universidad
2. Introducción
de Málaga
Definición de constructores de objetos
Se define un constructor de una clase especificando el nivel de visibilidad, el

nombre de la clase, seguido por la lista de parámetros, y por el cuerpo que
especifica las sentencias necesarias para construir un objeto adecuadamente.
En la definición de una clase se pueden definir varios constructores: con
distinto número de argumentos o con argumentos de distintos tipos.
Un constructor puede invocar a otro constructor de la misma clase
especificando en la primera línea del cuerpo al objeto this seguido por la
lista de parámetros adecuados.
// Punto.java
private double x, y; public Punto(double a, double b) {
public Punto() { x = a;
this(0, 0); y = b;
} }
}
Si no se define ningún constructor explícitamente, entonces el sistema

proporciona automáticamente un constructor por defecto, sin parámetros,
que asigna valores iniciales por defecto a las variables de instancia del objeto
creado.
Tema
Universidad
2. Introducción
de Málaga
Métodos de instancia
Los métodos de instancia se invocan cualificándolos con el nombre de la

referencia al objeto sobre el que se aplican (this para el objeto implicado,
aunque se puede suprimir si no hay conflicto de nombres). Por ejemplo:
p1.distancia(p2), this.distancia(part), distancia(part).
Pueden acceder directamente tanto a las variables de clase como a las
variables de instancia del propio objeto implicado.
Pueden invocar directamente tanto a los métodos de clase como a los
métodos de instancia sobre el propio objeto implicado.
// ...
}
}

Tema
Universidad
2. Introducción
de Málaga
Parámetros
Los parámetros se declaran en la definición de los métodos.

Hay una instancia independiente por cada invocación al método.
Se crean cuando se ejecuta la invocación a un determinado método.
Se destruyen cuando termina la ejecución del método invocado.
Se inicializan como una copia de los valores especificados en la invocación al
método.
En Java, todos los parámetros son por valor. No existe el paso por referencia.
// ...
public void desplazar(double a, double b) {
x += a; // a y b son parámetros
y += b;
}
}

Tema
Universidad
2. Introducción
de Málaga
Variables Locales
Las variables locales se declaran dentro de la definición de los métodos.

Hay una instancia independiente por cada invocación al método.
Se crean cuando se ejecuta la instrucción de declaración de la variable.
Se destruyen cuando termina la ejecución del ámbito del bloque donde fue
declarada.
Si no se inicializa, la variable contiene un valor inespecificado (basura).
public class Poligono {
// ...
public double perimetro() {
double suma = 0; // suma e i son variables locales
for (int i = 0; i < ptos.length - 1; ++i) {
suma += ptos[i].distancia(ptos[i+1]);
}
return suma;
}
}

Tema
Universidad
2. Introducción
de Málaga
Ejemplo: la clase NumeroRacional
Defina una clase NumeroRacional que modele el concepto matemático de

números racionales.
Como estado interno de los objetos, almacenará tanto el numerador como el
denominador.
Proporcionará los siguientes constructores y métodos públicos:
Ctor. por defecto, crea el numero racional 0/1.
Ctor(x,y), crea el numero racional x/y normalizado.
Consulta del estado interno del objeto (numerador y denominador).
Sumar, Restar, Multiplicar y Dividir, reciben como parámetro un número racional
y devuelven un nuevo número racional resultado de aplicar la operación al
número racional actual con el número racional recibido como parámetro.
Representación textual del objeto (toString()).
Un número racional normalizado:
Atención al caso del denominador cero (0).
Atención al caso del numerador cero (0).
El denominador siempre debe ser positivo.
La fracción siempre se almacena en modo reducido. Es necesario calcular el MCD.

Tema
Universidad
2. Introducción
de Málaga
Variables de clase
Se declaran como static.
Existen, aunque no se hayan creado objetos de la clase.
Se crean cuando se carga la clase a la que pertenece.
Se destruyen cuando se descarga la clase a la que pertenece, usualmente al
finalizar la ejecución del programa.
Sólo hay una única instancia, común y compartida por todos los objetos de
la misma clase.
Se acceden cualificándolas con el nombre de la clase a la que pertenecen. Por
ejemplo: Particula.G.
Dentro de la propia clase, se acceden directamente, sin necesidad de
cualificación (se puede utilizar this si es necesario). Por ejemplo: G, this.G.
Se pueden declarar final si su valor no cambiará (será constante).
Se deben inicializar en la declaración de la variable. Se inicializan con un
valor cero o null si no se especifica ningún otro valor (no para final).
private static final double G = 6.67e-11; // variable de clase constante
// ...
}
Tema
Universidad
2. Introducción
de Málaga
Métodos de clase
Se declaran como static.
Existen, aunque no se hayan creado objetos de la clase.
Se invocan cualificándolos con el nombre de la clase a la que pertenecen. Por
ejemplo: Math.sqrt(x), Math.pow(x, 2).
Dentro de la propia clase, se invocan directamente, sin necesidad de
cualificación (se puede utilizar this si es necesario).
Sólo pueden acceder directamente a las variables de clase.
Sólo pueden invocar directamente a los métodos de clase.
public class NumeroRacional {
private static int mcd(int n, int m) {
n = Math.abs(n); // n = (n < 0) ? -n : n;
m = Math.abs(m); // m = (m < 0) ? -m : m;
if (n < m) {
int x = n; n = m; m = x;
}
while (m != 0) {
int r = n % m;
n = m;
m = r;
}
return n;
}
}
Tema
Universidad
2. Introducción
de Málaga
Ejemplo (I)
sqrt y pow son métodos de clase de la clase Math y se invocan, en la clase

Punto, cualificándolos con el nombre de la clase Math.
// Invocación a métodos estáticos
return Math.sqrt(Math.pow(this.x - pto.x, 2)
+ Math.pow(this.y - pto.y, 2));
}
out es una variable de clase y currentTimeMillis es un método de
clase, ambos de la clase System:
public class Ejemplo {
// Acceso a variable estática
System.out.println("Hola");
// Invocación a método estático
long time = System.currentTimeMillis();
}
}

Tema
Universidad
2. Introducción
de Málaga
Ejemplo (II)
// Libro.java
public class Libro {
private static double IVA = 16.0; // Variable de Clase
private String titulo; // Variable de instancia
private double precio; // Variable de instancia
// Constructor
public Libro(String tit, double p) {
titulo = tit;
precio = p;
}
public double calcPrecio() {
return precio + precio * IVA / 100;
}
@Override
public String toString() {
return "(" + titulo + ", " + calcPrecio() + ")";
}
// Método de Clase
private static void cambiarIVA(double iva) {
IVA = iva;
}
}

Tema
Universidad
2. Introducción
de Málaga
Ejemplo (III)
// Libro.java
public class Libro {
private static int refCnt = 1; // Variable de Clase
private String titulo; // Variable de instancia
private int referencia; // Variable de instancia
// Constructor
public Libro(String tit) {
titulo = tit;
referencia = refCnt;
++refCnt;
}
@Override
return "(" + titulo + ", " + referencia + ")";
}
}

Tema
Universidad
2. Introducción
de Málaga
Control de Acceso y Visibilidad
Existen cuatro niveles de acceso y visibilidad:

private – acceso privado, sólo desde dentro de la propia clase.
Por omisión – acceso desde dentro del propio paquete (package).
protected – acceso protegido, desde dentro del paquete y de las clases
herederas (sub-clases).
public – acceso público, desde cualquier sitio.
Nivel de Acceso
Desde Desde Desde Desde

Propia Propio Una Otra
Clase Paquete Subclase Clase
□ - private SÍ NO NO NO
▵▴ ~ package SÍ SÍ NO NO
⋄ ⬩ # protected SÍ SÍ SÍ NO
◦ • + public SÍ SÍ SÍ SÍ
Las clases e interfaces de nivel externo sólo pueden tener visibilidad pública o paquete.

Tema
Universidad
2. Introducción
de Málaga
Símbolos en Eclipse para Diagramas de Clases UML

Tema
Universidad
2. Introducción
de Málaga
Tipos y variables
Tipos de datos primitivos
Tipo Valores Rango Ejemplos

▸ boolean false y true false y true
▸ char Unicode de 16 bits Unicode 'a', '$', '\t', '\n', '\u0061'
byte entero de 8 bits -128 .. 127 100, -34
short entero de 16 bits -32768 .. 32767 2578, -93
31 31
▸ int entero de 32 bits -2 .. 2 -1 56, 0xaf, 0xAF, 0b1001, 1_000
63 63
long entero de 64 bits -2 .. 2 -1 8456l, 33456L
float real de 32 bits ±3.40282E±38 67.345f, 34.122F, 21.34e2f
▸ double real de 64 bits ±1.79769313E±308 4.66, 23.7e3, 35.213d, 23.2D

Tema
Universidad
2. Introducción
de Málaga
Tipos y variables
Valores de tipos de datos primitivos

Los valores son los datos pertenecientes a estos tipos primitivos.
Los valores se pueden almacenar y manipular mediante variables.
Además, los valores se pueden manipular directamente, usando sus
representaciones literales.
Variables de tipos de datos primitivos

Las variables de tipos de datos primitivos almacenan, en un momento dado, un
determinado valor de entre los valores posibles definidos por el tipo.
cnt letra pi ok int cnt = 1;
char letra = 'a';
1 'a' 3.14 true double pi = 3.14;
boolean ok = true;
La asignación (=) modifica el valor almacenado en una variable.

Los operadores (==, !=, <, <=, >, >=) comparan los valores de las variables
de tipos primitivos.

Tema
Universidad
2. Introducción
de Málaga
Tipos y variables
Clases
Una Clase representa una abstracción de datos, especifica las características de
unos objetos: su estado interno (atributos) y su comportamiento (métodos).
Variables de referencia a objetos

Las variables de una determinada Clase no almacenan un objeto de esa Clase,
sino que almacenan una referencia polimórfica a un objeto que haya sido
creado dinámicamente, o null.
pto1 Punto pto2 pto3 Punto pto4 Punto pto1 = new Punto(1,2);
Punto pto2 = pto1;
• ▸ 1 2 ◂ • • ▸ 3 4 / Punto pto3 = new Punto(3,4);
Punto pto4 = null;
La asignación (=) asigna la referencia (al mismo objeto compartido).

Los operadores (==, !=) comparan las referencias, es decir, si ambas
variables referencian al mismo objeto. Para comparar los contenidos de los
objetos se debe invocar al método equals: pto1.equals(pto3).

Tema
Universidad
2. Introducción
de Málaga
Tipos y variables
Arrays
Se pueden definir arrays de tipos primitivos, de referencias a objetos y multi-dimensionales.
Variables de referencia a arrays

Las variables de tipo array no almacenan el propio array, sino que almacenan
una referencia a un array que haya sido creado dinámicamente, o null.
int[] elms = new int[4];
int[][] mat = new int[2][3];
Punto[] ptos = new Punto[4];
elms ptos
• ▸ 0 0 0 0 • ▸ / / / /
mat
▸ 0 0 0
• ▸ •
• ▸ 0 0 0
La asignación (=) asigna la referencia (al mismo array compartido).

Los operadores (==, !=) comparan las referencias, no los contenidos.
Tema
Universidad
2. Introducción
de Málaga
Tipos y variables
Arrays

int[] elms = new int[] { 1, 2, 3, 4 };
int[][] mat = new int[][] { { 3, 4, 5 }, { 6, 7, 8 } };
Punto[] ptos = new Punto[] { new Punto(1,2), null, null, new Punto(3,4) };
elms ptos
• ▸ 1 2 3 4 • ▸ • / / •
mat
▸ 3 4 5 ▾ ▾
• ▸ • Punto Punto
• ▸ 6 7 8 1 2 3 4

Tema
Universidad
2. Introducción
de Málaga
Tipos y variables
Arrays

int[] elms = { 1, 2, 3, 4 };
int[][] mat = { { 3, 4, 5 }, { 6, 7, 8 } };
Punto[] ptos = { new Punto(1,2), null, null, new Punto(3,4) };
elms ptos
• ▸ 1 2 3 4 • ▸ • / / •
mat
▸ 3 4 5 ▾ ▾
• ▸ • Punto Punto
• ▸ 6 7 8 1 2 3 4

Tema
Universidad
2. Introducción
de Málaga
La vida de los objetos
Los objetos son siempre instancias de alguna clase.

Durante la ejecución de un programa:
Se crean objetos con el operador new.
Los objetos interactúan entre sí enviándose mensajes (invocando a métodos
aplicados sobre otros objetos).
Los objetos no necesarios se eliminan automáticamente, cuando se pierden las
referencias a dichos objetos (recolección de basura automática).
Se puede ayudar a la eliminación de un objeto anulando su referencia. Ej:
pto = null;
Se puede activar la eliminación automática, invocando al recolector de basura
(método de clase gc() de la clase System).
System.gc();

Tema
Universidad
2. Introducción
de Málaga
Creación de objetos
Cada instancia (objeto) se crea dinámicamente invocando, mediante el

operador new, al constructor de la clase, especificando la lista de argumentos
adecuada.
El operador new reserva el espacio de memoria adecuado para almacenar el
estado interno del nuevo objeto a crear.
El constructor asigna unos valores iniciales a sus variables de instancia.
El operador new devuelve una referencia al objeto que crea, que puede ser
asignado a una variable, o puede ser utilizado directamente en una expresión.
// Main.java
public class Main {
Punto pto1 = new Punto(1, 2);
double d = new Punto(3,4).distancia(new Punto(4,5));
}
}
pto1 Punto pto2 Punto
• ▸ 1 2 • ▸ 2 1

Tema
Universidad
2. Introducción
de Málaga
Asignación o Copia
Las sentencias de asignación sobre variables de tipos primitivos permiten
almacenar una copia del valor en la variable.
Una variable que referencia a un objeto se puede asignar a otra variable de su
misma clase. En este caso se asigna la referencia al objeto, y ambas
variables referenciarán al mismo objeto compartido.
// Main.java
public class Main {
Punto pto2 = pto1;
int x = 3, y = 1;
y = x;
}
}
pto1 x
• ▸ Punto 3
pto2 ▸ 1 2 y
• 3
Para duplicar (copiar) un objeto, se debe crear otro objeto de la

misma clase y duplicar (copiar) sus variables de estado.
Tema
Universidad
2. Introducción
de Málaga
Ejemplo Segmento 1 (asignación)
Si desde un determinado objeto se referencia a objetos externos, entonces
esos objetos externos podrían ser accedidos y manipulados desde el exterior,
sin el control de la clase que los referencia.
private Punto origen, extremo;
public Segmento(Punto pto1, Punto pto2) {
origen = pto1; // Asignación (referencia a un objeto externo)
extremo = pto2; // Asignación (referencia a un objeto externo)
}
public double longitud() {
return origen.distancia(extremo);
}
Punto pt1 = new Punto(1, 3);
Segmento sgt = new Segmento(pt1, pt2);
}
}
pt1 Punto Segment sgt
• ▸ 1 3 ◂ • • ◂ •
pt2 Punto
• ▸ 2 5 ◂

Tema
Universidad
2. Introducción
de Málaga
Ejemplo Segmento 2 (copia)
Si desde un determinado objeto se referencia a objetos internos, entonces esos
objetos internos no pueden ser manipulados desde el exterior, y se encuentran
bajo el control de la clase que los referencia.
public Segmento(Punto pto1, Punto pto2) {
origen = new Punto(pto1.abscisa(), pto1.ordenada()); // Copia (ref. obj. interno)
extremo = new Punto(pto2.abscisa(), pto2.ordenada()); // Copia (ref. obj. interno)
}
public double longitud() {
return origen.distancia(extremo);
}
Segmento sgt = new Segmento(pt1, pt2);
}
}
pt1 Punto sgt Segment Punto
• ▸ 1 3 • ▸ • • ▸ 1 3
Punto
pt2 Punto
▸ 2 5
• ▸ 2 5

Tema
Universidad
2. Introducción
de Málaga
Paso de parámetros
El paso de parámetros en Java es Por Valor, esto es, se realiza una copia del
valor del parámetro real en el parámetro formal correspondiente.
El paso de parámetros de tipos primitivos implica una copia independiente
del valor almacenado.
Cualquier modificación en el parámetro formal dentro del método no afecta al
valor almacenado en el parámetro actual.
El paso de parámetros de objetos implica una copia de la referencia, en
cuyo caso el mismo objeto referenciado es compartido entre el método
invocante y el invocado.
Cualquier modificación en el objeto referenciado por el parámetro formal dentro
del método sí afecta al estado del objeto referenciado por el parámetro actual.
De igual modo sucede en el caso de los arrays.

Tema
Universidad
2. Introducción
de Málaga
Conversiones de tipos y clases
Se producen conversiones de tipo de forma implícita (automática) en ciertos

contextos, siempre a tipos más amplios siguiendo la ordenación:
byte ▸ short ▸ int ▸ long ▸ float ▸ double
char
Se producen conversiones de clase de forma implícita (automática) en ciertos
contextos, siempre a clases ascendentes (super-clases) en la línea jerárquica de
la herencia.
Se permiten las conversiones explícitas (casting) en sentido contrario
mediante la construcción (sólo se comprueban durante la ejecución):
( <tipo/clase> ) <expresión>

Tema
Universidad
2. Introducción
de Málaga
Conversiones implícitas: contextos
La conversión implícita se produce en los siguientes contextos:

Asignaciones: el tipo de la expresión se promociona al tipo de la variable de
destino.
Invocaciones a métodos: los tipos de los parámetros reales se promocionan a
los tipos de los parámetros formales.
Evaluación de expresiones aritméticas: los tipos de los operandos se
promocionan al tipo del operando con el tipo más general (como mínimo se
promocionan a int).
Concatenación de cadenas: los valores de los argumentos se convierten en
cadenas automáticamente (invocación automática al método toString()).

Tema
Universidad
2. Introducción
de Málaga
Identificadores
Los identificadores dan nombre a: variables, métodos, clases e interfaces.

Un identificador (nombre) es una secuencia arbitraria de caracteres Unicode:
letras, dígitos, subrayado o símbolos de monedas. No debe comenzar por
dígito ni coincidir con alguna palabra reservada.
int numero;
Por convenio:
Nombres de variables y métodos en minúsculas. Si son compuestos, las
palabras no se separan y comienzan con mayúscula.
long valorMaximo;
Nombres de clases e interfaces comienzan con mayúscula, seguido de
minúsculas. Si son compuestos, las palabras no se separan y comienzan con
mayúscula.
class NumeroRacional { ... }
Nombres de constantes todo en mayúsculas. Si son compuestos, las palabras se
separan con subrayados.
final double CTE_GRAVITACION = 6.673e-11;

Tema
Universidad
2. Introducción
de Málaga
Variables y constantes
Variables
Las variables almacenan valores de tipos primitivos, referencias a objetos y
referencias a arrays.
Las variables deben ser declaradas antes de su utilización:
int contador, maximo;
La declaración también puede especificar el valor de inicialización:

int contador = 0;
Las sentencias de asignación permiten modificar el valor almacenado en una

variable.
contador = contador + 1;
Constantes
Una variable se puede declarar como constante precediendo su declaración
con la etiqueta final:
final int MAXIMO = 100;

Tema
Universidad
2. Introducción
de Málaga
Inicialización de variables
Cuando no se le asigna un valor explícitamente a una variable:

Las variables de clase (no para final) se inicializan automáticamente al cargar
la clase.
Las variables de instancia (no para final) se inicializan automáticamente cada
vez que se crea una instancia.
Las variables locales no se inicializan de forma automática, tienen inicialmente
un valor basura y el compilador produce un error si se utilizan sin haber sido
asignado un valor.
Valores de inicialización automática para cada tipo:
boolean: false // boolean
char: '\u0000' // char
int: 0 // byte, short, int y long
double: +0.0 // float y double
Object: null // referencia a un objeto de cualquier tipo
array[]: null // referencia a un array de cualquier tipo

Tema
Universidad
2. Introducción
de Málaga
Ámbito de una variable
El ámbito de una variable es la zona de código donde se puede usar su

identificador sin calificar.
Un identificador debe ser único dentro de su ámbito.
El ámbito determina cuándo se crea y cuándo se destruye el espacio de
memoria para la variable.
Las variables, según su ámbito, se clasifican en las siguientes categorías:
Variable de clase o de instancia (declarada dentro de una clase).
Variable local (declarada dentro de un método).
Parámetro de método (declarada en la lista de parámetros de un método).
Parámetro de gestor de excepciones (declarada dentro de catch (...)).

Tema
Universidad
2. Introducción
de Málaga
Expresiones
Una expresión es una combinación de los siguientes elementos, combinados

adecuadamente según la sintaxis del lenguaje:
Valores literales.
Variables.
Operadores.
Mensajes (invocaciones a métodos).
Una expresión se evalúa a:
Un valor de tipo primitivo (simple).
Una referencia a un objeto.
Una referencia a un array.
La evaluación de una expresión devuelve el resultado calculado.

Tema
Universidad
2. Introducción
de Málaga
Operadores
Un operador es una función de uno, dos o tres argumentos.
Aritméticos:
unarios: +, -, ++, --
binarios: +, -, *, /, %
Relacionales/comparación (binarios): ==, !=, <, <=, >, >=
Lógicos: (unario) !, (binarios) &&, ||
Manipulación de bits: (unario) ~, (binarios) &, |, ˆ, <<, >>, >>>
Otros operadores: (unario) new, (binario) instanceof, (ternario) ?:
Asignación (binarios, requieren una variable a la izquierda):
=, +=, -=, *=, /=, %=, &=, |=, ˆ=
Con un operador y sus argumentos se construyen expresiones simples.
3 * 5 x + 7.3 'a' <= 45
Las expresiones simples se pueden combinar dando lugar a expresiones

compuestas.
3 + 5 * x / 7.3 y * (x + 7.3) (x > y) ? x : y
El orden de evaluación de las expresiones compuestas depende de la

precedencia y de la asociatividad de los operadores que aparezcan en la
expresión.
Tema
Universidad
2. Introducción
de Málaga
Precedencia y asociatividad de operadores
Precedencia (de mayor a menor) Asociatividad

paréntesis (x) NO
acceso e incr x[i] x.y x++ x-- Izquierda
unarios ++x --x +x -x !x ~x Derecha
creación y cast new T() (T)x Derecha
multiplicativos * /% Izquierda
sumatorios +- Izquierda
desplaz-bits << >> >>> Izquierda
relacionales < <= > >= instanceof Izquierda
igualdad == != Izquierda
y-bits & Izquierda
xor-bits ˆ Izquierda
o-bits | Izquierda
y-lógico && Izquierda
o-lógico || Izquierda
condicional b?x:y Derecha
asignación = += -= *= /= %= &= |= ˆ= <<= >>= >>>= Derecha

Tema
Universidad
2. Introducción
de Málaga
Instrucciones/sentencias
Existen tres clases de instrucciones o sentencias:

Sentencias de declaración de variables.
Sentencias de control de ejecución.
Secuencia.
Selección.
Iteración (repetición).
Control de Excepciones.
Sentencias de expresión:
Asignaciones.
Incrementos y decrementos.
Mensajes (invocaciones a métodos).
Creaciones de objetos.
Un bloque es un grupo de cero o más sentencias, encerradas entre llaves,
dando lugar a una sentencia compuesta.
Un bloque se puede usar en cualquier parte donde se necesite una sentencia
simple.

Tema
Universidad
2. Introducción
de Málaga
Sentencias de iteración (repetición)
while ( <exp_lógica> ) {
// <sentencias>
}
do {
// <sentencias>
} while ( <exp_lógica> );
for ( <exp_ini> ; <exp_lógica> ; <exp_incr> ) {

// <sentencias>
}
for ( <tipo_elemento> <vble> : <array_o_colección> ) {

// <sentencias>
}

Tema
Universidad
2. Introducción
de Málaga
Sentencias de selección
if ( <exp_lógica> ) { switch (<exp>) { // char byte short

/* <sentencias> */ case <valor_1> : // int String
} // <sentencias>
break;
if ( <exp_lógica> ) { case <valor_2> :
/* <sentencias> */ // <sentencias>
} else { break;
/* <sentencias> */ ...
} case <valor_k> :
// <sentencias>
if ( <exp_lógica> ) { break;
/* <sentencias> */ default :
} else if ( <exp_lógica> ) { // <sentencias>
/* <sentencias> */ break;
} else { }
/* <sentencias> */
}

Tema
Universidad
2. Introducción
de Málaga
Criterios de codificación y corrección
El número de iteraciones que realiza un determinado bucle (for, while,

do-while) no puede estar condicionado por la utilización de las sentencias
return, break, continue.
El numero de iteraciones que realiza el bucle for debe quedar claramente
especificado en la cabecera del mismo.
Dentro del cuerpo del bucle for no se puede modificar la variable de control del
bucle.
En las funciones y métodos sólo está permitido una única sentencia return, y
debe ser la última sentencia del cuerpo del mismo.
Estos criterios de codificación serán considerados en la corrección del código
proporcionado por el alumno.

Tema
Universidad
2. Introducción
de Málaga
Control de excepciones (I)
Las excepciones son un mecanismo de ayuda para la comunicación y el

manejo de errores.
Cuando se produce un error en un método:
1 Se crea un objeto de la clase Exception (de java.lang) o derivada, con
información sobre el error.
2 Se lanza el objeto excepción creado anteriormente (el sistema o el programador
mediante la instrucción throw).
3 Se interrumpe el flujo normal de ejecución.
4 El entorno de ejecución intenta encontrar un manejador para dicho objeto
excepción.
1 Dentro del propio método o
2 En un método anterior en la pila de activaciones.

Tema
Universidad
2. Introducción
de Málaga
Control de excepciones (II)
Existen cuatro sentencias relacionadas con el control de excepciones:
try: delimita un bloque de instrucciones donde se puede producir una

excepción.
catch: identifica un bloque de código asociado a un bloque try donde se
maneja un tipo particular de excepción.
finally: identifica un bloque de código que se ejecutará siempre después de
un bloque try, tanto si se producen excepciones como si no.
throw: lanza un objeto excepción que haya sido creado, con información sobre
el error producido.
try {
// <sentencias> // Bloque vigilado // throw
} catch ( <tipo_excepción> <vble> ) {
// <sentencias> // Manejador
} catch ( <tipo_excepción> <vble> ) {
// <sentencias> // Manejador
} finally {
// <sentencias> // Siempre se ejecuta
}

Tema
Universidad
2. Introducción
de Málaga
Las cadenas de caracteres se representan en Java como secuencias de
caracteres Unicode encerradas entre comillas dobles:
"Ejemplo de cadena de caracteres"
La clase String (de java.lang) dispone de constructores y métodos para

crear y manipular cadenas.
Los objetos de esta clase se pueden inicializar:
Forma normal:
String str = new String("¡Hola!");
Forma simplificada:
String str = "¡Hola!";
Los objetos de la clase String en Java son inmutables.

Los métodos para acceder a los caracteres de un objeto String:
length(): devuelve el número de caracteres de la cadena.
charAt(i): devuelve el carácter que se encuentra en la posición i en la cadena
(0 ≤ i < length()).
Si se intenta acceder a una posición no válida el sistema lanza una excepción:
IndexOutOfBoundsException.
Tema
Universidad
2. Introducción
de Málaga
La concatenación (+, +=) produce como resultado un nuevo objeto String
como resultado de unir dos cadenas de caracteres.
En la concatenación de cadenas de caracteres pueden intervenir otros tipos
de datos, que serán convertidos automáticamente a su representación String.
int i = 42;
System.out.println("i es " + i); // muestra: i es 42
En el caso de objetos:
Punto p = new Punto(3, 4);
System.out.println("p es " + p); // muestra: p es Punto@119c0982
Es necesario que la clase defina el método público toString().
class Punto {
// ...
@Override
return "(" + x + ", " + y + ")";
}
}
Punto p = new Punto(3, 4);
System.out.println("p es " + p); // muestra: p es (3, 4)

Tema
Universidad
2. Introducción
de Málaga
Comparación de cadenas
c1.equals(c2): devuelve true si c1 y c2 son iguales y false en otro caso.
c1.equalsIgnoreCase(c2): igual que la anterior, pero sin tener en cuenta
las diferencias por mayúsculas y minúsculas.
c1.compareTo(c2): devuelve un entero menor, igual o mayor que cero
cuando c1 es menor, igual o mayor que c2.
c1.compareToIgnoreCase(c2): igual que la anterior, pero sin tener en
cuenta las diferencias por mayúsculas y minúsculas.
ATENCIÓN c1 == c2 compara las referencias, es decir, si ambas variables
referencian al mismo objeto.

Tema
Universidad
2. Introducción
de Málaga
Otros métodos
c1.indexOf(c2): devuelve la primera posición de c2 (carácter o cadena).
c1.lastIndexOf(c2): devuelve la última posición de c2 (carácter o cadena).
c1.toLowerCase(): devuelve un nuevo objeto String con todo minúsculas.
c1.toUpperCase(): devuelve un nuevo objeto String con todo mayúsculas.
c1.substring(desde, hasta): devuelve un nuevo objeto String con los
caracteres a partir de la posición desde y hasta la posición hasta (sin
incluirla).
Conversiones
String.valueOf(v): devuelve un nuevo objeto String con la representación
del valor especificado en v.
Integer.parseInt(c1): devuelve el resultado de obtener el valor del número
entero representado en c1.
Double.parseDouble(c1): devuelve el resultado de obtener el valor del
número real representado en c1.
Tema
Universidad
2. Introducción
de Málaga
Arrays
Los Arrays representan objetos que contienen una colección (de longitud fija)
de elementos (componentes) de un mismo tipo o clase.
La longitud se puede consultar en la variable de instancia length.
Declaración de dos arrays, uno con elementos de tipo entero y otro de tipo
Punto:
int[] listaEnteros;
Punto[] listaPuntos;
Se pueden crear especificando cuantos elementos tienen (los elementos se
inicializan con los valores por defecto):
int[] listaEnteros = new int[4];
Punto[] listaPuntos = new Punto[t];
listaEnteros listaPuntos
• ▸ 0 0 0 0 • ▸ / / /
Se pueden crear especificando el valor inicial de los componentes:

int[] listaEnteros = new int[] { 0, 1, 2, 3 };
Punto[] listaPuntos = { new Punto(1,2), null, new Punto(3,4) };
• ▸ 0 1 2 3 • ▸ • / •
listaEnteros listaPuntos
▾ ▾
Punto Punto
1 2 3 4

Tema
Universidad
2. Introducción
de Málaga
Arrays
El primer elemento de un array se encuentra en la posición 0:

Si se intenta acceder a una posición no válida del array, el sistema lanza una
excepción: IndexOutOfBoundsException.
for (int i = 0; i < listaEnteros.length; ++i){
listaEnteros[i] = i;
}
for (int i = 0; i < listaPuntos.length; ++i){
listaPuntos[i] = new Punto(i, i);
}
String[] cadenas = { "CAD1", "CAD2", "CAD3" };
for (int i = 0; i < cadenas.length; ++i) {
System.out.println(cadenas[i].toLowerCase());
}
Para acceder a todos los elementos de un array, también se puede utilizar la

sentencia for-each:
for (int e : listaEnteros) {
System.out.println(e);
}

Tema
Universidad
2. Introducción
de Málaga
Operaciones con Arrays: Copia de Elementos
Copia de los elementos de un array: System.arraycopy()

El método de clase arraycopy() de java.lang.System permite copiar los
elementos de un array:
public static void arraycopy(Object arrayOrigen, int primIndOrigen,
Object arrayDestino, int primIndDestino,
int numeroDeElmsCopia);
El array destino debe existir y tener tantos elementos como sea necesario.
Ejemplo de utilización:
char[] arrayOrigen = {
'd','e','s','c','a','f','e','i','n','a','d','o'
};
char[] arrayDestino = new char[7];
System.arraycopy(arrayOrigen, 3, arrayDestino, 0, 7);
// arrayDestino ahora contendrá: { 'c','a','f','e','i','n','a' }
}

Tema
Universidad
2. Introducción
de Málaga
Operaciones con Arrays: Duplicación de Arrays (I)
Duplicación de un array: Arrays.copyOf()

El método de clase copyOf() de java.util.Arrays permite duplicar un
array, creando una nueva instancia.
public static TipoBase[] copyOf(TipoBase[] arrayOriginal,
int nuevaLongitud);
Si la nueva longitud especificada es diferente de la del array original:

Elimina los últimos elementos si es menor.
Añade al final valores por defecto si es mayor.
import java.util.Arrays;
int[] arrayOrigen = { 12, 4, 8, 3, 5, 203, 28 };
int[] arrayDestino1 = Arrays.copyOf(arrayOrigen, 3);
// arrayDestino1 contendrá: { 12, 4, 8 }
int[] arrayDestino2 = Arrays.copyOf(arrayOrigen, 10);
// arrayDestino2 contendrá: { 12, 4, 8, 3, 5, 203, 28, 0, 0, 0 }
}

Tema
Universidad
2. Introducción
de Málaga
Operaciones con Arrays: Duplicación de Arrays (II)
Duplicación de un array: Arrays.copyOfRange()

El método de clase copyOfRange() de java.util.Arrays permite duplicar
un array, creando una nueva instancia, copiando los elementos a partir de la
posición desde y hasta la posición hasta (sin incluirla).
public static TipoBase[] copyOfRange(TipoBase[] arrayOriginal,
int desde, int hasta);
Si la posición hasta es mayor que los elementos del array original, entonces
añade al final valores por defecto.
int[] arrayOrigen = { 12, 4, 8, 3, 5, 203, 28 };
int[] arrayDestino1 = Arrays.copyOfRange(arrayOrigen, 2, 5);
// arrayDestino1 contendrá: { 8, 3, 5 }
int[] arrayDestino2 = Arrays.copyOfRange(arrayOrigen, 5, 9);
// arrayDestino2 contendrá: { 203, 28, 0, 0 }
}

Tema
Universidad
2. Introducción
de Málaga
Operaciones con Arrays: toString
Representación String: Arrays.toString()

El método de clase toString() de java.util.Arrays devuelve un nuevo
objeto String con la representación del contenido de un array.
El método de clase deepToString() de java.util.Arrays devuelve un
nuevo objeto String con la representación del contenido de un array
multi-dimensional.
public static String toString(TipoBase[] array);
public static String deepToString(Object[] array);
int[] array = { 1, 3, 5, 7, 9 };
System.out.println(Arrays.toString(array));
// muestra [1, 3, 5, 7, 9]
}

Tema
Universidad
2. Introducción
de Málaga
Operaciones con Arrays: Comparación y Búsqueda
Comparación y Búsqueda. Arrays.equals() y Arrays.binarySearch()
El método de clase equals() de java.util.Arrays devuelve true si los
contenidos de dos arrays son iguales.
public static boolean equals(TipoBase[] a1, TipoBase[] a2);
El método de clase binarySearch() de java.util.Arrays devuelve el
índice donde se encuentra un determinado valor en un array ordenado
(negativo si no lo encuentra).
public static int binarySearch(TipoBase[] array, TipoBase valor);
int[] array1 = { 1, 3, 5, 7, 9 };
System.out.println(Arrays.binarySearch(array, 5)); // muestra 2
int[] array2 = { 1, 3, 5, 7, 9 };
if (Arrays.equals(array1, array2)) {
System.out.println("Iguales");
}
}

Tema
Universidad
2. Introducción
de Málaga
Arrays Multidimensionales
Los elementos de un array también pueden ser arrays, dando lugar a a los
arrays multi-dimensionales.
int[][] a = new int[2][3];
int[][] b = new int[][] { { 3, 4, 5 }, { 6, 7, 8 } };
int[][] c = { { 3, 4, 5 }, { 6, 7, 8 } };
double[][][] d = new double[3][5][4];
a b
▸ 0 0 0 ▸ 3 4 5
• ▸ • • ▸ •
• ▸ 0 0 0 • ▸ 6 7 8
El uso más común de arrays multidimensionales es el array de dos dimensiones.

También es posible crear un array multidimensional creando cada componente
(dimensión) paso a paso, e incluso con tamaños diferentes.
int[][] x = new int[2][];
for (int i = 0; i < x.length; i++) {
x[i] = new int[i + 2];
for (int j = 0; j < x[i].length; j++) {
x[i][j] = i + j;
}
}

Tema
Universidad
2. Introducción
de Málaga
Ejemplo: la clase Coleccion
Defina una clase Coleccion que modele el concepto de colección de números

enteros.
Como estado interno de los objetos, almacenará tanto el numero de elementos
almacenados, como el array que almacena la secuencia de números del objeto.
Proporcionará los siguientes constructores y métodos públicos:
Ctor. por defecto, crea una colección vacía (sin elementos), con una capacidad
inicial de TAM (10).
Ctor(t), crea una colección vacía (sin elementos), con la capacidad inicial recibida
como parámetro.
Consultar el estado interno del objeto (número de elementos y el elemento
almacenado en una posición determinada).
Consultar si la colección esta vacía y vaciar la colección.
Añadir, eliminar y contiene, reciben como parámetro un número y realizan la
operación solicitada.
Representación textual del objeto (toString()).

Tema
Universidad
2. Introducción
de Málaga
Clases anidadas: clases internas estáticas
Las clases anidadas se definen dentro de la definición de otra clase.

Aunque se pueden distinguir diversos tipos de clases anidadas (internas, locales,
anónimas), solo consideraremos las denominadas clases internas estáticas.
Una clase interna estática se define como un atributo más de la clase,
especificando el calificador static.
Para acceder a ellas desde el exterior, si es visible, se debe cualificar su nombre
con el nombre de la clase externa a la que pertenece.
private static class Punto {
// ...
}
// ...
}

Tema
Universidad
2. Introducción
de Málaga
Datos enumerados: enum (I)
Se pueden definir datos enumerados como clases públicas.
Se deben especificar todos los valores de la enumeración.
// fichero Dia.java
public enum Dia {
Lun, Mar, Mie, Jue, Vie, Sab, Dom
}
Cada valor de la enumeración se puede utilizar cualificándolo con el nombre de
la clase enumerada: Dia.Lun.
Se proporcionan automáticamente los siguientes métodos asociados a la clase
enumerada: valueOf(str), values(), toString(), ordinal(), equals(v),
hashCode(), compareTo(v).
public class Main {
Dia s = Dia.Lun; // primer valor de la enumeración
Dia t = Dia.valueOf("Mie"); // valor asociado al String
int ord = s.ordinal(); // ordinal asociado al valor
for(Dia se : Dia.values()) { // Dia[] con todos los valores
System.out.print(se + " "); // se.toString()
}
// muestra: Lun Mar Mie Jue Vie Sab Dom
}
}
Tema
Universidad
2. Introducción
de Málaga
Datos enumerados: enum (II)
También es posible definir datos enumerados como clases internas

estáticas.
public class Ejemplo {
public static enum Dia { Lun, Mar, Mie, Jue, Vie, Sab, Dom }

Dia s = Dia.Lun; // primer valor de la enumeración
Dia t = Dia.valueOf("Mie"); // valor asociado al String
int ord = s.ordinal(); // ordinal asociado al valor
for(Dia se : Dia.values()) { // Dia[] con todos los valores
System.out.print(se + " "); // se.toString()
}
// muestra: Lun Mar Mie Jue Vie Sab Dom
}
}

Tema
Universidad
2. Introducción
de Málaga
Herencia
Se puede definir una clase (sub-clase) que hereda estado y comportamiento
de otra clase (super-clase), a la que especializa o extiende (añade estado y
comportamiento), en la forma:
class Subclase extends Superclase { /* ... */ }
La sub-clase hereda tanto los atributos como los métodos definidos por la
super-clase (reusabilidad del código).
La sub-clase puede definir nuevos atributos y nuevos métodos (extensibilidad),
así como redefinir métodos de la super-clase.
La herencia de clases se expresa en UML mediante una línea sólida desde la
sub-clase con un triángulo hueco en el extremo de la super-clase.
Superclase Punto Persona
^ ^ ^
Subclase Particula Paciente Médico

Tema
Universidad
2. Introducción
de Málaga
Herencia
Java sólo permite herencia simple, por lo que pueden establecerse jerarquías
de clases (una clase sólo puede heredar de una única clase, pero puede tener
varias clases herederas).
La relación de herencia es transitiva, si C hereda de B y B hereda de A,
entonces C también hereda de A.
Todas las jerarquías de clases confluyen en la clase Object de java.lang
que define los comportamientos básicos que debe presentar cualquier clase.
Object
^
Punto Persona
^ ^
Particula ... Paciente Médico Alumno

Tema
Universidad
2. Introducción
de Málaga
Ejemplo: Clase Punto
// Punto.java
// Atributos
// Constructores
public Punto() {
this(0, 0); // invocación a Punto(double, double)
}
public Punto(double a, double b) {
x = a; y = b;
}
// Métodos
public double abscisa() { return x; }
public double ordenada() { return y; }
public void abscisa(double a) { x = a; }
public void ordenada(double b) { y = b; }
public void desplazar(double a, double b) { x += a; y += b; }
}
}

Tema
Universidad
2. Introducción
de Málaga
Ejemplo: Clase Particula
// Particula.java
// Atributos
final static double G = 6.67e-11;
private double masa; // ( + los atributos heredados de Punto )
// Constructores
this(0, 0, m); // invocación a Particula(double, double, double)
}
public Particula(double a, double b, double m) {
super(a, b); // invocación a Punto(double, double)
masa = m;
}
// Métodos ( + los métodos heredados de Punto )
public void masa(double m) { masa = m; }
public double masa() { return masa; }
public double atraccion(Particula part) {
// Nótese la invocación al método distancia heredado de Punto
return G * this.masa * part.masa / Math.pow(this.distancia(part), 2);
}
}

Tema
Universidad
2. Introducción
de Málaga
Herencia y constructores
Los constructores no se heredan.
Cuando se define un constructor de una subclase se debe proceder de alguna
de las tres formas siguientes:
Invocar a un constructor de la misma clase (con distintos argumentos) mediante
this (debe ser la primera línea):
this(0, 0, m); // invocación a Particula(double, double, double)
}
Invocar a algún constructor de la superclase mediante super (debe ser la
primera línea):
public Particula(double a, double b, double m){
super(a, b); // invocación a Punto(double, double)
masa = m;
}
En otro caso, se invoca automáticamente por defecto al constructor sin
argumentos (constructor por defecto) de la superclase:
public Particula(double m){
// invocación automática a Punto()
masa = m;
}
Tema
Universidad
2. Introducción
de Málaga
Herencia y Polimorfismo
El polimorfismo permite que un objeto de una sub-clase pueda ser
considerado y referenciado como un objeto de la super-clase. Principio de
sustitución. Ej. toda partícula es un punto.
Una variable del tipo de la superclase (tipo estático) puede referenciar a un
objeto de la subclase (tipo dinámico).
Punto pto = new Particula(3, 5, 22);
En contextos polimórficos, sólo es válido invocar a los métodos especificados
por el tipo estático de la variable.
Punto pt1 = new Particula(3, 5, 22);
double d = pt1.distancia(pt2); // Correcto
// double f = pt1.atraccion(pt2); // ERROR. No es posible
Es posible forzar la conversión de tipos de la super-clase a la sub-clase, pero
hay que estar muy seguros, ya que no todos los objetos de la super-clase son
también objetos de la sub-clase.
double d = pt1.distancia(pt2); // Correcto
double f = ((Particula)pt1).atraccion((Particula)pt2); // Posible y peligroso
Tema
Universidad
2. Introducción
de Málaga
Herencia y redefinición del comportamiento
Una subclase puede redefinir algún método heredado (no private ni final).
En la subclase, el método redefinido de la superclase queda oculto por el nuevo
método. Se puede invocar al método oculto de la superclase:
super.<nombre-método>(argumentos)
public class Vehiculo {
private Punto posicion;
public Vehiculo() { posicion = new Punto(); }
public void mover(double tiempo) { posicion.desplazar(tiempo * velocidad(), 0); }
public double velocidad() { return 10; } // Km/h
}
public class Automovil extends Vehiculo {
@Override
}
public class Bicicleta extends Vehiculo {
@Override
public double velocidad() { return 2 * super.velocidad(); } // el doble de velocidad qu
}
public class PruebaVehiculo {
Vehiculo[] a = { new vehiculo(), new Automovil(), new Bicicleta() };
for (Vehiculo v : a) {
v.mover(1); // mover cada vehiculo 1 hora
System.out.println(v.velocidad());
}
}
}
Tema
Universidad
2. Introducción
de Málaga
Herencia y Vinculación Dinámica
La vinculación dinámica resulta el complemento indispensable del
polimorfismo.
En contextos polimórficos, sólo es válido invocar a los métodos especificados
por el tipo estático de la variable.
En contextos polimórficos, la ejecución del método invocado se selecciona
adecuadamente, en tiempo de ejecución, dependiendo del tipo dinámico del
objeto, y no del tipo estático de la variable que lo referencia.
La invocación del método que ha de resolver un mensaje se retrasa al tiempo de
ejecución, y depende del tipo dinámico del objeto.
Vehiculo[] a = { new vehiculo(), new Automovil(), new Bicicleta() };
}
}
}
Los métodos de clase y las variables de clase o de instancia se resuelven por

vinculación estática (en tiempo de compilación).
La resolución de los métodos de instancia se realiza por vinculación
dinámica (en tiempo de ejecución).
Tema
Universidad
2. Introducción
de Málaga
Prohibiendo subclases
Por razones de seguridad o de diseño, se puede prohibir la definición de

subclases para una clase etiquetándola con final.
Recordad que una subclase puede sustituir a su superclase donde ésta sea
necesaria y tener comportamientos muy distintos.
El compilador rechazará cualquier intento de definir una subclase para una
clase etiquetada con final.
También se pueden etiquetar con final:
Métodos, para evitar su redefinición en alguna posible subclase.
Variables, para mantener constantes sus valores o referencias.

Tema
Universidad
2. Introducción
de Málaga
Ejemplo: la clase Conjunto
Defina una clase Conjunto que modele el concepto de conjunto de números

enteros. Esta clase debe heredar de la clase Coleccion, extender y redefinir
su comportamiento.
Proporcionará los siguientes constructores y métodos públicos (además de los
heredados de la superclase):
Ctor. por defecto, crea un conjunto vacío (sin elementos), con una capacidad
inicial de TAM (10).
Ctor(t), crea un conjunto vacío (sin elementos), con la capacidad inicial recibida
como parámetro.
Unión, e intersección, reciben como parámetro un Conjunto y devuelven un
nuevo Conjunto resultado de aplicar la operación al conjunto actual con el
conjunto recibido como parámetro.
Debe redefinir el método de la superclase para añadir, de tal forma que los
objetos de la clase Conjunto no almacenen elementos repetidos.

Tema
Universidad
2. Introducción
de Málaga
Promoviendo subclases: Clases abstractas
A veces, una clase puede modelar una abstracción, aunque no le sea posible
proporcionar una implementación adecuada o suficiente, pero sin embargo, sí es
capaz de proporcionar una definición abstracta del comportamiento esperado.
Las clases descendientes serán las encargadas de proporcionar (implementar)
los comportamientos adecuadamente, según la abstración que modelen.
Estas clases se etiquetan como abstract y pueden tener métodos sin
definición, también etiquetados como abstract.
Se utilizan para formar jerarquías, proporcionando definiciones de
comportamientos abstractos.
No es posible crear instancias de clases abstractas. Se deben definir
subclases que no sean abstractas para poder crear objetos.

Tema
Universidad
2. Introducción
de Málaga
Promoviendo subclases: Clases abstractas
Por ejemplo, la clase Vehiculo modela una abstracción, sin embargo, no
puede proporcionar una implementación adecuada para el método que
determina la velocidad del vehículo. Esta operación deberá ser proporcionada
por las subclases.
public abstract class Vehiculo {
public Vehiculo() { posicion = new Punto(); }
public void mover(double tiempo) { posicion.desplazar(tiempo * velocidad(), 0); }
public abstract double velocidad() ; // Km/h
}
public class Automovil extends Vehiculo {
@Override
}
public class Bicicleta extends Vehiculo {
@Override
}
Vehiculo[] a = { new Automovil(), new Bicicleta() }; // NO instancia Vehiculo
}
}
}
Tema
Universidad
2. Introducción
de Málaga
Interfaces
Una interfaz define un comportamiento que debe ser implementado por
cualquier clase que pretenda ofrecer ese comportamiento.
Una interfaz puede extender (heredar) a múltiples interfaces, heredando el
comportamiento definido por ellas, así como añadir nuevo comportamiento.
Una interfaz sólo puede ser extendida por otra interfaz.
En una interfaz, sólo se pueden definir métodos abstractos, métodos por
defecto, métodos y constantes estáticas y clases e interfaces anidadas.
public interface Interfaz1 {
String CAD1 = "SUN"; // public static final
String CAD2 = "PC"; // public static final
void valorCambiado(String producto, int val); // public abstract
static String simbolo() { return CAD1; } // public static
}
public interface Interfaz2 {
double balance(String producto); // public abstract
default boolean esDeficit(String producto) { // public default
return balance(producto) < 0;
}
}
public interface MiInterfaz extends Interfaz1 , Interfaz2 {
// métodos y constantes heredados (+)
void exportar(); // public abstract
}
Tema
Universidad
2. Introducción
de Málaga
Implementación de Interfaces
Una clase puede implementar a varias interfaces, además de heredar de una

única clase. Deberá implementar el comportamiento definido por la interfaz.
Cuando una clase implementa una interfaz:
Hereda todas las constantes definidas en la interfaz y en sus superinterfaces.
Debe implementar todos los métodos definidos por la interfaz y sus
superinterfaces. Salvo que sea una clase sea abstracta, en cuyo caso los
métodos no implementados son abstract.
Un objeto, de una clase que implementa una interfaz, puede ser utilizado
(polimórficamente) en cualquier sitio donde sea necesario un objeto que
implemente la interfaz especificada.
public class MiClase extends Superclase1
implements Interfaz1, Interfaz2, ... {
// ...
void valorCambiado(String producto, int val) {
// debe implementar los métodos definidos en las interfaces que implementa
}
double balance(String producto) {
// debe implementar los métodos definidos en las interfaces que implementa
}
}

Tema
Universidad
2. Introducción
de Málaga
Diagrama UML de Clases e Interfaces
La composición de clases se expresa en UML mediante una línea sólida con punta
de flecha con la punta abierta entre la clase poseedora y la clase poseída.
La herencia de clases se expresa en UML mediante una línea sólida desde la
sub-clase con un triángulo hueco en el extremo de la super-clase.
La herencia de interfaces se expresa en UML mediante una línea sólida desde la
sub-interfaz con un triángulo hueco en el extremo de la super-interfaz.
La implementación de interfaces se expresa en UML mediante una línea
discontinua desde la clase con un triángulo hueco en el extremo de la interfaz.
SuperClase «interface» «interface»

Interfaz1 Interfaz2
SubClase obj ClasePoseida «interface»

Interfaz3
*
Tema
Universidad
2. Introducción
de Málaga
Ejemplo de Interfaces
public interface IVehiculo {
void mover(double tiempo) ;
double velocidad() ;
default double distanciaRecorrida(double tiempo) { return tiempo * velocidad(); }
}
public class Bicicleta implements IVehiculo {
public Bicicleta() { posicion = new Punto(); }
@Override
public void mover(double tiempo) { posicion.desplazar(distanciaRecorrida(tiempo), 0); }
@Override
}
public class Automovil implements IVehiculo {
private static final double CONSUMO = 7.5; // litros a los 100 Km
private Punto posicion; private double deposito;
public Automovil() { posicion = new Punto(); deposito = 50; }
@Override
public void mover(double tiempo) {
double dist = distanciaRecorrida(tiempo);
if (deposito >= CONSUMO * dist / 100) {
posicion.desplazar(dist, 0);
deposito -= CONSUMO * dist / 100;
}
}
@Override
}
Tema
Universidad
2. Introducción
de Málaga
Uso de interfaces
No es posible crear instancias (objetos) de una interfaz.

Podemos declarar variables y parámetros del tipo definido por una interfaz, que
pueden hacer referencia a cualquier objeto de una clase (y de las herederas de
ella) que implementa la interfaz (Polimorfismo).
IVehiculo[] a = { new Automovil(), new Bicicleta() }; // NO instancia IVehiculo
for (IVehiculo v : a) {
}
}
}

Tema
Universidad
2. Introducción
de Málaga
Interfaces como Abstracción Funcional
Las interfaces proporcionan soluciones elegantes a problemas donde se desea

aplicar a los datos un procesamiento flexible y adaptable a diferentes
contextos (abstracción funcional).
Allí donde sea necesaria la funcionalidad especificada por la interfaz, se podrá
utilizar una clase que implemente dicha interfaz. Diferentes clases podrán
proporcionar diferentes implementaciones de dicha funcionalidad, haciendo
de este mecanismo algo flexible y adaptable a diferentes contextos.
Por ejemplo, supongamos una clase Amigos que contiene una lista con los
amigos de una persona.
Podemos añadir, acceder y mostrar los amigos.
También podemos seleccionar a los amigos según diferentes criterios.
Por cada criterio, habrá que implementar un nuevo método.
Si deseamos añadir un nuevo criterio en el futuro, deberemos modificar la clase
para añadir un nuevo método.
Es más adecuado, flexible y adaptable definir el criterio de selección como una
interfaz que proporcione una abstracción funcional sobre dicho criterio de
selección.

Tema
Universidad
2. Introducción
de Málaga
Ejemplo sin Interfaces (I)
La clase Persona define las características de una persona:

public class Persona {
private String nombre;
private int edad;
private String aficiones;
public Persona(String n, int e, String a) {
nombre = n;
edad = e;
aficiones = a;
}
public String getNombre() {
return nombre;
}
public int getEdad() {
return edad;
}
public String getAficiones() {
return aficiones;
}
@Override
return "("+nombre+"; "+edad+"; "+aficiones+")";
}
}

Tema
Universidad
2. Introducción
de Málaga
Ejemplo sin Interfaces (II)
La clase Amigos permite almacenar los amigos de una persona, así como
seleccionarlos según diferentes criterios (edad, etc.):
public class Amigos {
private Persona[] amg;
private int na;
public Amigos() {
na = 0;
amg = new Persona[16];
}
public Persona[] seleccionarEdad(int a, int b) {
Persona[] r = new Persona[na];
int x = 0;
for (int i = 0; i < na; ++i) {
if (a <= amg[i].getEdad() && amg[i].getEdad() < b) {
r[x] = amg[i];
++x;
}
}
return Arrays.copyOf(r, x);
}
/*
* Otros métodos para otros criterios de selección
*/
public void add(Persona p) { /* ... */ }
public String toString() { /* ... */ }
}
Tema
Universidad
2. Introducción
de Málaga
Ejemplo sin Interfaces (III)
Podemos utilizar la clase Amigos para almacenar y seleccionar los amigos de

una persona según diferentes criterios (edad, etc.):
public class Main {
Amigos a = new Amigos();
a.add(new Persona("pepe", 20, "futbol, tenis"));
a.add(new Persona("maria", 21, "tenis, ping-pong"));
a.add(new Persona("lola", 22, "natacion, futbol"));
a.add(new Persona("juan", 23, "tenis"));
System.out.println(a);
System.out.println(Arrays.toString(a.seleccionarEdad(21, 23)));
}
}

Tema
Universidad
2. Introducción
de Málaga
Ejemplo con Interfaces como Abstracción Funcional (I)
La utilización de interfaces proporciona una solución más flexible y adaptable.
La interfaz Predicado especifica el criterio de de selección:
public interface Predicado {
public boolean test(Persona p);
}
La clase SelectorEdad implementa la selección por edad:
public class SelectorEdad implements Predicado {
private int min, max;
public SelectorEdad(int min, int max) {
this.min = min;
this.max = max;
}
public boolean test(Persona p) {
return (min <= p.getEdad() && p.getEdad() < max);
}
}
La clase SelectorAficion implementa la selección por aficion:
public class SelectorAficion implements Predicado {
private String aficion;
public SelectorAficion(String af) {
this.aficion = af;
}
public boolean test(Persona p) {
return p.getAficiones().contains(aficion);
}
}
Tema
Universidad
2. Introducción
de Málaga
Ejemplo con Interfaces como Abstracción Funcional (II)
La clase Amigos utiliza la clase que implemente la interfaz Predicado como
criterio de selección, a través del método test():
public class Amigos {
private Persona[] amg;
private int na;
public Amigos() {
na = 0;
amg = new Persona[16];
}
public Persona[] seleccionar(Predicado p) { // el predicado especifica el criterio
Persona[] r = new Persona[na];
int x = 0;
for (int i = 0; i < na; ++i) {
if (p.test(amg[i])) { // invoca al método test sobre el objeto predicado
r[x] = amg[i];
++x;
}
}
return Arrays.copyOf(r, x);
}
/*
* Otros métodos para otros criterios de selección
*/
public void add(Persona p) { /* ... */ }
public String toString() { /* ... */ }
}
Tema
Universidad
2. Introducción
de Málaga
Ejemplo con Interfaces como Abstracción Funcional (III)
La clase que invoca al método de selección especifica el criterio para

seleccionar según la clase del objeto que proporcione como argumento:
public class Main {
Amigos a = new Amigos();
a.add(new Persona("pepe", 20, "futbol, tenis"));
a.add(new Persona("maria", 21, "tenis, ping-pong"));
a.add(new Persona("lola", 22, "natacion, futbol"));
a.add(new Persona("juan", 23, "tenis"));
System.out.println(a);
Persona[] s1 = a.seleccionar(new SelectorEdad(21, 23));
System.out.println(Arrays.toString(s1));
Persona[] s2 = a.seleccionar(new SelectorAficion("tenis"));
System.out.println(Arrays.toString(s2));
}
}

Tema
Universidad
2. Introducción
de Málaga
Ejemplo: la interfaz EstructuraDeDatos
Defina una interfaz EstructuraDeDatos que modele la manipulación de

estructuras de datos lineales que almacenan números enteros.
Proporcionará los siguientes métodos públicos:
Añadir un elemento recibido como parámetro a la estructura. Si la estructura
está llena, se doblará su capacidad y se añadirá el nuevo elemento.
Sacar un elemento de la estructura. Si la estructura está vacía, lanzará una
excepción (RuntimeException).
Consultar el número de elementos almacenados en la estructura.
Consultar si la estructura está vacía. Esta operación será un método por defecto
implementado en la propia interfaz.
Diseñe también 2 clases que implementen dicha interfaz:
Clase Pila. Una pila es una estructura de datos lineal en la que los elementos
se meten y sacan por el mismo extremo (la cima de la pila).
Clase Cola. Una cola es una estructura de datos lineal en la que los elementos
se meten por un extremo (final de la cola) y se sacan por el otro extremo
(principio de la cola).
Estas 2 clases, además, también redefinirán el método toString() para
ofrecer una representación textual de la estructura de datos.

Tema
Universidad
2. Introducción
de Málaga

Poo 2 Java

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

Poo 2 Java

Cargado por

Copyright:

Formatos disponibles

Tema 2.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Programación Orientada a Objetos

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Tema 2. Introducción a Java

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Desarrollado por Sun (ahora Oracle). Aparece en 1995.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Dada la siguiente especificación de clases, donde ambas clases se definen

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Sin embargo, si ambas clases se definen en paquetes distintos, es necesario

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Sin embargo, si ambas clases se definen en paquetes distintos, es necesario

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

java.lang: para funciones del lenguaje.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Todas las clases del paquete java.lang se importan automáticamente a

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Los paquetes del sistema cuelgan de varios subdirectorios específicos:

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Frontera del CLASSPATH

Otros Paquetes java.util java.lang

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Las variables de instancia se acceden cualificándolas con el nombre de la

Se define un constructor de una clase especificando el nivel de visibilidad, el

Si no se define ningún constructor explícitamente, entonces el sistema

Los métodos de instancia se invocan cualificándolos con el nombre de la

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Los parámetros se declaran en la definición de los métodos.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Las variables locales se declaran dentro de la definición de los métodos.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Defina una clase NumeroRacional que modele el concepto matemático de

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

sqrt y pow son métodos de clase de la clase Math y se invocan, en la clase

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Existen cuatro niveles de acceso y visibilidad:

Desde Desde Desde Desde

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Tipos de datos primitivos

Tipo Valores Rango Ejemplos

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Valores de tipos de datos primitivos

Variables de tipos de datos primitivos

La asignación (=) modifica el valor almacenado en una variable.

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Variables de referencia a objetos

La asignación (=) asigna la referencia (al mismo objeto compartido).

Dpto. Lenguajes y Ciencias de la Computación. E.T.S.I. Informática.

Variables de referencia a arrays

La asignación (=) asigna la referencia (al mismo array compartido).

Variables de referencia a arrays

La asignación (=) asigna la referencia (al mismo array compartido).

Variables de referencia a arrays