PII 01 Introduccion

Tema 1.
Introducción
• Historia y principios de Java. Java básico

• Clases: objetos, atributos, métodos
• Clase vs. instancia
• Visibilidad
• set/get
• Objetos vs. valores primitivos
• Constructores
• Conversiones implícitas y explícitas
• Contenedores (composición)
Programación II Tema 1 - Introducción

Recordatorio...
• Comunidad
bit.ly/ud-prog2-com
• Instalación
Java SE Development Kit 8 (Oracle)
Eclipse IDE for Java Developers
• Cuaderno/bitácora de aprendizaje
• No es solo código, es lo que aprendes
alrededor de él. ¡Lleva tu historial!
• ¿Quieres compartirlo? “Prog2-Nnnnn Aaaaa”

Eclipse: filosofía
• Es un proyecto abierto (open source, GPL,CPL  EPL)

– Desarrollado en Java
– Para Java... y para muchas más cosas
• IDE (Integrated Development Environment)
– ¡NO ES JAVA! Llama a Java
– Integra edición, compilación, ejecución,
depuración
• Estructura de ficheros
– Workspace
• Proyecto
– src / bin / ...

Eclipse: entendiendo (1)
• Configurando el workspace...
– UTF8: General | Workspace | Text file encoding -> UTF8
– Ctrl+Esp: Java | Editor | Content Assist | Advanced | Java Prop / Java Type Prop / Templates
• Aspecto general
– Paneles
• Package Explorer
• Editor
• Outline
• Console
• También Navigator | Search | Problems | Javadoc...
– Teclas rápidas! Resumen en "Recursos adicionales”
Eclipse: entendiendo (2)
• Configurando el proyecto
– Project | Options ...
• Ciclo de edición | ejecución
– Compilación automática
– Coloreado de código
– Ejecución
– Depuración
• Sugerencias de escritura (Ctrl+Esp)
• Sugerencias de corrección (Ctrl+1)

Evolución de la OO (1/2)
• Datos y Subprogramas
– Principio fundamental: “Divide y vencerás”
• División del problema en partes (subprogramas, funciones,...)
más pequeñas y fáciles de resolver
• Se afronta cada una de las partes por separado
• Finalmente se integran las partes
– Ventajas: Simplificación del problema
– Inconvenientes:
• No favorece la reutilización
• Falta de protección de los datos
• Confusión entre los datos y el código
• Mezcla del qué y el cómo

Evolución de la OO (2/2)
• TAD (Tipos Abstractos de Datos)

– Módulos que contienen datos y las funciones que
los manipulan [TAD = Datos + Funciones]
– Mejor Reutilización y Protección de los Datos
– Encapsulación
• Orientación a Objetos
– Reutilización Extrema  Herencia
– Ocultamiento de la información
– Todo el programa se desarrolla alrededor de los
datos que manipula

Evolución de los Leng. Prog. OO
• Lenguajes Procedurales (no orientados a objetos)

– LISP (años 50), Simula (años 60), Pascal, C, ADA,...
• Lenguajes Orientados a Objetos Puros
– Smalltalk (años 70)
– Únicamente permiten la programación OO
• Lenguajes Orientados a Objetos Híbridos
– C++ y Pascal Orientado a Objetos (años 80)
– Programación Tradicional + Mecanismos de
Programación OO
– Guardan la compatibilidad con C y Pascal
• Los más utilizados: "casi" puros o multiparadigma
– C++, Eiffel, Java, C#, Python, Ruby, JavaScript...

Orígenes de Java (1/2)
• 1991
– Grupo de Sun liderado por James Gosling
– Objetivo  Diseño de lenguaje para aparatos electrónicos
• Pequeño – Eficiente – Portable
– Requisito  Debía ser comprensible por cualquier aparato
– Funcionamiento
• Compilador generaba código intermedio
• Todos los aparatos poseen un sencillo intérprete capaz de
entenderlo.
– Surge un nuevo lenguaje OO: Oak  Green  Java
• 1992
– 1ª aplicación de esta tecnología: control remoto
inteligente (*7)
– Fue un fracaso comercial

Orígenes de Java (2/2)
• 1993 y 1994
– Disolución del proyecto
• Mientras...
– Nacimiento de la web y de los primeros navegadores.
– La web necesitaba un lenguaje portable, pequeño y seguro.
– 1994: Gosling y su equipo realizan HotJava
• Navegador hecho en Java y capaz de ejecutar código Java (Applets)
• Mayor dinamismo a las hasta entonces “aburridas” páginas web
• 1995
– Presentación de Java por Sun
– Éxito total por la aplicación de este lenguaje a la web
– Los principales navegadores incorporan intérpretes de Java
• 1996 - ..
– Se empieza a utilizar cada vez más como lenguaje de propósito general

Versiones
• Sun, luego Oracle

– Regulado por el JCP (Java Community Process)
– JDK 1.0 (1996), JDK 1.1 (1997)
– J2SE 1.2 [Java 2] (1998) J2SE / J2EE / J2ME
– J2SE 1.3 (2000), J2SE 1.4 (2002), J2SE 1.5 (2004)
– Java SE 6 (2006)
– Java SE 7 (2011)
– Java SE 8 (2014)
– Java SE 9 (2017), SE 10, SE 11 (2018)
– Java SE 12 (marzo 2019)
Java es interpretado y compilado (1/2)
javac.exe
Programa fuente Compilación Código intermedio
(cualquier editor (bytecode)
de texto, cualquier .class
sistema)
.java
Intérprete para Win ...

Intérprete para Intérprete para
Unix Linux
java.exe
Compilación e interpretación de un programa Java

Java es interpretado y compilado (2/2)
• Java no se compila a código máquina.

• Se compila a un código intermedio llamado
“ByteCode”.
• El ByteCode lo interpreta la Maquina Virtual Java
(JVM)
• Por tanto, el “ByteCode” se podrá ejecutar en
cualquier máquina que posea el intérprete de Java
(JVM)
– Existen intérpretes de Java para las principales
plataformas: Windows, Unix, Linux, Mac...)
• Java es, por tanto, compilado e interpretado
– Compilador: javac.exe Intérprete: java.exe

Características (1/3)
• Simple
– Fácil de aprender
• Pocas construcciones
• Similar a otros lenguajes (C y C++)
– Se suprimen muchas causas de error:
• Sentencia goto
• Ficheros de cabecera (.H) y sentencias preprocesador (#)
– ¡Punteros!  Java gestiona automáticamente las direcciones de memoria
(&) e indirecciones (*)
• Accesos fuera de rango (strings y arrays)
• Posee un recolector de basura automático (garbage collector)
– No hay que preocuparse de la reserva y liberación de memoria
• Orientado a Objetos
– OO Casi Puro (todo son objetos, excepto tipos primitivos)
• Muchas Librerías  Mayor Reusabilidad  Productividad
• Robusto

• Portable - Multiplataforma
• Un programa Java se puede ejecutar en cualquier
plataforma que posea el intérprete de Java
• "Write Once, Run Anywhere"
• Seguro
– Algunos aspectos internos como:
• No permite punteros y controla los límites de los arrays y strings
• Los intérpretes realizan verificaciones del ByteCode
• Sandbox Model (restricciones al código “sospechoso”)
• Firma Digital (indica el origen del código)
• Multihilo (Multithread)
– Posibilidad de ejecutar varias tareas simultáneamente

• Eficiente (depende de con quién se le compare)
– Optimizaciones de compilación y de la JVM
• Dinámico
– Carga de las clases dinámica (no hay un único ".exe")
• Distribuido
– Soporte nativo para ejecución en red
• Gratuito
– Los intérpretes, las librerías de clases y las especificaciones
del lenguajes son de libre distribución
– Aspecto fundamental para su éxito en Internet y para su
consolidación como un lenguaje multiplataforma

La memoria en Java
Stack(s) Heap
¡GC!
Locales
Datos en Objetos
ejecución
Method Area
Globales (static)
Código

Sintaxis básica de Java (1)
• Tipos
– Java es un lenguaje con un control estricto y fuerte de
tipos
• Cada variable debe declararse con un tipo y no puede cambiar
– Los tipos se clasifican en dos grandes grupos: tipos
primitivos y clases
– Tipos Primitivos
• char (codificado en unicode UTF-8, 16 o 32)
• boolean (literales false o true)
• Numéricos
– Enteros (byte, short, int, long) (8, 16, 32, 64 bits con signo)
– Reales (float, double) (32, 64 bits con signo, infinito, NaN)
– Literales
• Por defecto int (ej: 457 = int) o double (ej: 2.45 = double)
• Sufijos L (long. Ej: -1L), F (float. Ej: 1.0F), D (double. Ej: 10D)
• Prefijo 0x (hexadecimal) - 0 (octal)
• Notación exponencial n1 e n2 (ej: 10e2, 1.35e-3) = n1*10^n2
• Caracteres 'c' o '\unnnn'. Strings "string"
• null es referencia nula para objetos
• Estructura léxica:
• espacio, tab, salto de línea - separadores (no finalizadores)
• punto y coma (;) - finalizador de sentencia
• identificador - letras y dígitos empezando en letra (y tb. _ $)
(se pueden usar ñs y tildes, pero mejor evitarlas -codificación-)
– No pueden ser palabras clave ni literales
• palabra clave:
abstract, assert, boolean, break, byte, case, catch, char, class, const, continue,
default, do, double, else, enum, extends, final, finally, float, for, if, goto,
implements, import, instanceof, int, interface, long, native, new, package,
private, protected, public, return, short, static, strictfp, super, switch,
synchronized, this, throw, throws, transient, try, void, volatile, while
• En el lit. string el LF sí acaba. Caracteres de "escape": \n \t \" \\

– Comentarios
• El “//” comenta hasta el final de la línea
• El “/*” comenta hasta el primer “*/”
(no se permite anidamiento)
• Comentarios de documentación “/**” al principio de una clase,
atributo o método. (JavaDoc, herramienta por defecto).
• Datos (No hay globales: dentro de clases o código)
• Declaración: tipo nombreDato [ = inic ] [, nom2 [= in2] ... ] ;
• "Atributos" en clases, "locales" en código
• Funciones
• Solo se pueden definir dentro de clases ("métodos")
• Paso de parámetros por valor(*), con tipo y posición
(o sea: los cambios “no se devuelven”)
• Retorno único (return) o sin retorno (void)
tipo nombreMétodo( tipo nompar1, tipo nompar2 ... ) {
código
[return ...]
}
• Sobrecarga de métodos con distintos parámetros
• Variables y pars: no código, solo datos (λ en Java 8)
– Bloques
• El código se organiza en bloques
• Entre llaves de inicio { y cierre }
• Alcance de una variable: dentro del bloque en el que
se define.
• { } se pueden poner donde se quieran, pero
normalmente van en construcciones de control
• Donde puede ir una sentencia, puede ir un bloque
• No es obligatorio pero se recomienda usar
tabuladores (o espacios) para legibilidad
• Cada método tiene obligatoriamente un bloque
(“cuerpo”)

– Conversiones entre los tipos enteros, reales y
caracteres. De dos tipos:
•Implícitas (automáticamente por el compilador)
5 + 2.3 [5  5.0]
double x = 5 / 2.0; [5/2.0  5.0/2.0]
real = entero [entero  real]
•Explícitas (programador mediante un casting).

Atención a la pérdida de precisión
(int)5.4
double x = 5 / (double)2

• Todos los demás tipos son clases (referencias).
– Definidas por el usuario o ya existentes en el API de Java
– Las clases en Java se gestionan mediante referencias.
ClaseX referencia = instanciaClaseX;
ClaseX referencia = null;
• Toda variable de un tipo de clase X (o sea, referencia)
mantiene una referencia nula, expresada por el literal
null, o bien apunta a una instancia de la clase X (o alguna
de sus subclases)
• Las instancias hay que crearlas explícitamente. La
declaración no implica instanciación
• La destrucción es automática (cuando ya no se usan):
garbage collector (pero no es instantánea)

• Operadores
– Asignación (=)
Asignación combinada (+= -= *= /= %=)
– Aritméticos (enteros y reales)
+ - * /
– Aritméticos (enteros)
% (módulo o resto) Incr/decremento: ++, -- (prefijo, postfijo)
– Strings: + (único operador sobrecargado)
– Booleanos
< <= > >= == !=
&& || !
– Manipulación de bits (enteros)
And (&), Or (|), Xor (^), Not (~), Desplazamiento (>> << >>>)
También &= |= ^= <<= >>= >>>=
– Otros: ? : (if en expresión) -> (functional Java 8)
• Precedencia
++ -- ! | * / % | + - | > < >= <= | == != | && | || | =
• Estructuras de Control  Como en C y C++
if ( exp ) sent1 [else sent2]
switch (exp) { // exp  byte, short, int, char, String
case exp: sent;
... // ojo al break; (si no se pone sigue ejecutando)
[default: sent;]
}
if ternario: expLógica ? expThen : expElse
Todas las expresiones en cortocircuito!!!!
for (inic ; exp.while ; inc.) sent ;
for (tipo var : array ) sent ; // "foreach"
while ( exp ) sent ;
do sent ; while ( exp ) ; // En bucles break; continue;
• Normas de estilo recomendadas en Java
– Clases empiezan con mayúscula y cada cambio
de concepto con mayúscula.
class MiClase
– Miembros (atributos y métodos) empiezan con
minúsculas y cada cambio de concepto con
mayúscula.
int miAtributo
void miMetodo()
– Constantes todo con mayúsculas y cada cambio
de concepto con guión bajo ‘_’
static final int MI_CONSTANTE

• Normas de estilo recomendadas en Java (2)
– Nombres de método = verbos. Retorno boolean
"ser" o "estar" (ej. estaExento()) (set, get, is...)
– Nombres de variables y métodos significativos
– Orden deseable en clase: atributos estáticos,
atributos de instancia, constructores, métodos.
– Indentar los cuerpos de toda estructura
(métodos, repetitivas y alternativas, try-catch...)
– Comentarios javadoc en clase / met. públicos.
– // FIXME errores si el código no funciona
– // TODO tareas pendientes y mejoras en código
Lista de recomendaciones de código Java originales de Sun:
http://www.oracle.com/technetwork/java/codeconvtoc-136057.html

¿Qué es la abstración?
• Abstracción
– Quedarse con las características esenciales de algo (desde un
cierto punto de vista), ignorando los detalles irrelevantes.

Clases y objetos
• Clases y Objetos
– Un programa orientado a objetos se compone sólo de
objetos
– Un Objeto...
• Tiene datos (atributos) y comportamiento (métodos)
• Es la concreción (un ejemplar, instancia) de una clase
– Una Clase...
• Es una plantilla (modelo) para crear objetos similares.
• Define un conjunto de características comunes (atributos y
métodos) a todos los objetos de esa clase.
• Es la abstracción de un conjunto de objetos.
• Puede utilizarse para crear muchos objetos, pocos o ninguno
– En ese caso es simplemente una agrupación de código y datos únicos
– Por ejemplo, Math

Acceso encapsulado

De clase y de instancia (1)
– Atributos de Instancia
• Cada instancia creada de la clase tiene sus propios
valores y espacio de almacenamiento. Ej: velocidad
Máxima, consumo y matrícula
– Atributos de Clase
• Se crea una variable única para la clase y TODOS los
objetos que se creen a partir de esa clase.
• Todos los objetos acceden a esa variable (se comparte
por todos)
• Lleva el modificador static
• Ejemplo: numCoches

De clase y de instancia (2)
• Métodos de Instancia
– Método asociado a una instancia/objeto en particular
– Cuando se llama, se tiene acceso a los datos contenidos
en la instancia a la que está asociada.
• Llamada: objeto.nombre_metodo(arg1, arg2,...argN)
• Métodos de Clase
– Método asociado a la clase y no a una instancia en
particular. Es un método único para todos los objetos
creados a partir de esa clase.
– Manejan información significativa para toda la clase y
no de una instancia en particular
– Se declaran como static
– No contemplan el polimorfismo (con herencia)
• Llamada: nombre_clase.nombre_metodo(arg1, arg2,..., argN)
La clase es una plantilla!
no static static
class C {
double d; ... d i2 ...
String s;
static int i2; ... s
void op1() {...}
int op2() {...} op1() op3()
static int op3(){...}
} op2()
op1()
5.0
C c1 = new C(); op2()
c1.d = 5.0; c1.s = “a”; “a”
c1
C c2 = new C(); c2
c2.d = 25; c2.s = “bb”; 25
op1()
op2()
“bb”
¿Y qué es un programa?
• Actividades fundamentales de un programa

OO
– Crear los objetos necesarios (constructores)
– Invocar métodos de los objetos (mensajes)
– Borrar los objetos cuando no son necesarios
(automático en Java: garbage collector)

Sintaxis Java decl. de clases (1)
[Modif. de clase] class Nombre_Clase [Clase Padre (0-1)] [Interfaces(0-N)]

{
[Cuerpo de la Clase]
}
[Modif. de clase]: public | abstract | final

[Clase Padre]: extends Tipo_Clase_Padre
[Interfaces]: implements Lista_Interfaces

• Ejemplo de declaración de una clase
public class Circulo
{
double x,y;
double radio;
public double perimetro()
{
return 2*3.1416*radio;
}
public double area()
{
return 3.1416*radio*radio;
}
}

• Modificadores que no afectan al ámbito

MODIFICADOR SIGNIFICADO
final Atributo con valor constante

Método que no puede ser redefinido
Clase que no puede ser heredada
static Método o atributo de clase
abstract Método que está declarado pero no

implementado (método abstracto). Deberá
implementarse en las subclases
Clase que no puede instanciarse

Visibilidad (1)
• Encapsulación y Ocultamiento de la Información

– Manipulación de un objeto como una caja negra, sin
necesidad de conocer nunca su estructura interna.
– Se usan los servicios (métodos) que proporciona el
objeto sin necesidad de conocer como está éste
implementado por dentro
– En las OO, las propiedades (atributos) de los objetos
pueden ser privadas y se accede a ellas a través de los
métodos
• Se recomienda que los atributos sean siempre privados
• Acceso público con get/set [ver luego]

Visibilidad (2)
– Modificadores que afectan al ámbito
Acceso
MODIFICADOR
Clase Paquete Subclases Mundo
public SÍ SÍ SÍ SÍ
protected SÍ SÍ SÍ NO
sin modificador SÍ SÍ NO NO
private SÍ NO NO NO

Objetos y tipos primitivos
• Importantes las diferencias:

– Tipos primitivos:
• Datos: simples (número, carácter, lógico)
• Tamaño: dependiente de tipo (bits codif.)
• Se crean en cuanto se declaran (en stack/global)
• Siempre tienen valor (siempre están “creados”)
– Objetos
• Datos: compuestos (agregación, incluso otros objetos)
• Tamaño: una referencia [aparte: espacio atributos]
• Se crean con new (antes NO están creados) (en heap)
• Se usa el valor especial null cuando no lo están

Objetos y tipos primitivos (2)
• Tipos primitivos
– Sus valores se comparan con == !=
– Sus valores se copian con =
– Se usan con operadores (+, -, * ...)
• Objetos
– Con == no se comparan los valores: referencias
• Para los valores .equals()
– Con = no se duplica el valor, solo la referencia
(copia superficial. Ojo!) [.clone()] (aliasing)
– Se usan con métodos sobre ellos obj.met(...)
• Ambos: variables, atributos, parámetros, retorno...
Métodos get y set (1/3)
• El acceso directo a los atributos pone en

peligro el concepto de encapsulación
• Propuesta:
– Métodos get (público si procede) para consultar
los atributos de una clase
– Métodos set (público si procede) para modificar
los atributos de una clase
– Atributos privados

Get y set (2/3): ¿Por qué
complicarnos?
– 1) Independencia de implementación y cambios
(ej: long getDNI())
– 2) Protección de datos invariantes (sin set, solo get)
– 3) Control de errores
(ej: setFecha( int dia, int mes, int anyo ))
– 4) Campos calculados
(ej: setValorFactura( base, iva ) -> base, iva, total)
– 5) Polimorfismo
(diferente lógica en clase padre e hijo sobre el mismo dato)
– 6) Para pruebas y depuración

es más fácil depurar el paso por un método que por un atributo:
void getDNI() {
if (...) System.out.println( "Cogiendo DNI " + dni );
return dni;
}
Métodos get y set (3/3)
• Ejemplo:
public void setX(double pX)
{
x=pX;
}
public double getX()
{
return x;
}
public void setCentro(double pX, double pY)
{
this.x = pX;
this.y = pY;
}
...

Constructores (1/2)
• Tipo especial de método que permite crear objetos
• Cuando una clase no declara ningún constructor, Java
automáticamente crea un constructor por defecto
(constructor sin parámetros). Cuando no se especifica uno
por defecto pero se declara uno con parámetros, se pierde
el constructor por defecto
• Una clase puede tener uno o varios constructores.
• El nombre del método constructor debe coincidir con el
nombre de la clase y no devuelve ningún tipo de valor (ni
void).
• En principio suelen ser siempre públicos. ¿Por qué?

Constructores (2/2)
• Ejemplo Constructores
public class Circulo
{
double x,y;
double radio;
public Circulo()
{
x = 0;
y = 0;
radio = 0;
}
public Circulo(double cX, double cY, double r)
{
x = cX;
y = cY;
radio = r;
}
…
}

Sintaxis para instancias (1/3)
• Creación de instancias
Circulo miCirculo; //CASO 1º
– CASO 1º: Así no se crea ningún objeto, únicamente estamos declarando una
referencia a un objeto de tipo Circulo (se inicializa a null).
Circulo miCirculo = new Circulo(); //CASO 2º
– CASO 2º: Así estamos creando un objeto de tipo Circulo mediante el

constructor sin parámetros ( new Circulo() ) y se lo estamos asignando a la
referencia miCirculo
Circulo miCirculo = new Circulo(2,4,5);//CASO 3º
– CASO 3º: Así estamos creando un objeto de tipo Circulo mediante la

invocación al constructor con tres parámetros ( new Circulo
(int,int,int) ) y se lo estamos asignando a la referencia miCirculo
– En Java todos los objetos se crean en memoria dinámica (new)

-heap-

• Acceso a los atributos de un objeto
miCirculo.x = 3;
miCirculo.y = 3;
miCirculo.radio = 3;
Siempre bajo el supuesto de que los

modificadores de esos atributos permitan el
acceso

• Acceso a los métodos de un objeto

miCirculo.area();
miCirculo.perímetro();
int a = miCirculo.area(); //CORRECTO
int a = area(miCirculo); //ERROR
Siempre bajo el supuesto de que los modificadores de esos métodos
permitan el acceso a ellos.
–En Java el acceso a los métodos y atributos de un objeto se realiza a
través de la referencia que apunta al objeto.
<referencia>.<nombre_metodo>(<argumentos>)
<referencia>.<nombre_atributo>
(Una vez que definimos set/get, se recomienda hacer los

atributos privados y nunca acceder a ellos directamente desde
ningún otro sitio que no sea su propia clase –ocultación-)

La clase String (1)
• El String (en Java) no es un tipo primitivo, es una
clase. Sin embargo, Java le ofrece un tratamiento
especial.
– El new es automático (no hace falta expresarlo)
– Los literales de la cadena van entre comillas dobles.
String saludo = “Hola”;
– Java permite la concatenación de cadenas mediante +
System.out.println(saludo + “ a todos!!!”);
– Si se concatena un String con otro tipo, este se convierte
automáticamente a String
int valor = 5;
System.out.println(“Valor = ” + valor + ‘.’);
• (método toString()!!)
La clase String (2)
– ¡Son objetos! Se comparan con equals()
miString.equals( "fin" ) // Ok. Tb equalsIgnoreCase()
miString == "fin" // OJO -compara objs, no valores-
– Literales String
• No pueden separarse por líneas o tabuladores
• Códigos especiales con contrabarra: \n, \t, \', \", \\ ...
– No se pueden modificar (inmutables)
• StringBuffer  strings modificables
– append(), delete(), insert(), toString()
– Algunos métodos útiles...
• charAt(), compareTo(), compareToIgnoreCase(),
contains(), endsWith(), indexOf(), lastIndexOf(),
length(), replace(), startsWith(), substring(),
toLowerCase(), toUpperCase(), trim()
La clase String (3)
• Conversiones
– De tipo primitivo a String: concatenando
• i + ""
• Con maquetación: método format
String.format( "%5d", 123 ); // __123
String.format( "%05d", 123 ); // 00123
String.format( "%,8d", 123456 ); // _123.456
String.format( "%7.2f", 123.456 ); // _123,46
String.format( "%,.2f", 1234.567 ); // 1.234,57
– De objeto a String: toString()
– De String a primitivo: lo veremos (wrappers)
– De String a objeto: "a mano" (hay que programarlo)
Arrays (1/5)
• Los arrays en Java se caracterizan por ser objetos
• Por tanto, se necesita una referencia para manipularlos.
• Declaración de un array:
int v[]; //No se indica el tamaño
int[] v;
– ¡Ojo! Aquí lo único que hemos hecho es declarar una referencia a un
array de enteros. ¡El array todavía no está creado!
• El array, como cualquier otro objeto, se crea con new
v = new int[10];
float v2 = new float[50]
• Para acceder a los elementos de una array se usa la notación
clásica de arrays:
v[0] = 5;
int a = v[2];

Arrays (2/5)
• El rango de un array está en 0 y N-1 (siendo N el tamaño)
• Si se accede a una posición fuera de rango, el interprete nos
avisa (se produce una excepción)
• Como los arrays son objetos tienen atributos. El atributo
length permite saber el tamaño de una array
int tamaño = v.length
• Java permite inicializar el array en su declaración
int[] v = {1,2,3};
• Equivale a:
int[] v = new int[3];
v[0] = 1;
v[1] = 2;
v[2] = 3;

Arrays (3/5)
• Ejemplo:
public class Ejemplo
{
public static void main(String[] args)
{
int[] a1 = {1,2,3,4};
for(int i=0; i < a1.length; i++)
System.out.println(a1[i]);
}
}
• Cuando el array no es de tipos primitivos lo que se almacena en cada
posición es una referencia a un objeto
Animal[] animales = new Animal[10];
• Inicialmente, cada una de las referencias del array se inicializa a null.
• Posteriormente habrá que crear los objetos y guardarlos en el array
animales[0] = new Animal();
animales[1] = new Animal();

Ejemplo de arrays
• De tipo primitivo
• De objetos
int v[]; //Sólo referencia!! Racional v[] = new Racional[3];
v = new int[6]; null null null
//o lo que es lo mismo
//Si intentamos operar con Racionales
int v[] = new int[6];
v[0].setNumerador(1);//Null pointer Exc
//Es necesario crear los objetos
0 0 0 0 0 0 v[0] = new Racional(1,1);
//Acceso a los elementos
v[0] = 3; ref null null 1 1
v[5] = 4;//Error
v[3] = 2; v[0].setNumerador(2);
3 0 0 2 0 0
ref null null 2 1
for (int i=0; i < 6; i++)
//Se pueden crear todos los objetos
v[i] = i;
for (int i=0; i<v.length;i++)
0 1 2 3 4 5 v[i] = new Racional(1,1);

Arrays (4/5)
• Ejercicio: Indica qué se visualiza en cada caso por pantalla
class PruebaArrays
{
{
int[] a = new int[10];
String[] b = new String[10];
System.out.println("Longitud: " + a.length);
for (int i=0;i<a.length;i++)
System.out.println(a[i]);
System.out.println("Longitud: " + b.length);
for (int i=0;i<b.length;i++)
System.out.println(b[i]);
b[i]=new String("" + i);
System.out.println(b[i]);
}
}

Arrays Multidimensionales (5/5)
• Arrays Multidimensionales
– Los arrays multidimensionales no son más que arrays donde cada
elemento es a su vez otro array (arrays de arrays)
– El número de dimensiones lo indica el número de corchetes:
int [][] v1; //ref. a array de 2 dim
int [][][] v2; //ref. a array de 3 dim
– A la hora de crear el array se indicará el tamaño de cada dimensión:
v1 = new int[10][20] ; //array de 10 x 20
v2 = new int[6][4][5];
– Para acceder a un elemento de un array multidimensional:
v1[3][4] = 5;
v2[3][2][2] = 6;
– Longitudes con length:
v1.length -> 10 (primera dimensión)
v1[0].length -> 20 (segunda dimensión)
v2[0][0].length -> 5 (etc.)

Ejemplos de Arrays (1/2)
class QueHago
{
{
String[][] arrayOfStringArrays = new String[5][];
for (int i=0;i<arrayOfStringArrays.length;i++)
{
String[] nuevoArray = new String[10];
arrayOfStringArrays[i] = nuevoArray;
for (int j=0;j<nuevoArray.length;j++)
nuevoArray[j] = new String(“(”+i+“,”+j+”)”);
}
for (int i=0;i<arrayOfStringArrays.length;i++)
{
for (int j=0;j<arrayOfStringArrays[i].length;j++)
System.out.print(arrayOfStringArrays[i][j]);
}
}
}

Ejemplos de Arrays (2/2)
class HolaConTiempo
{
static int contInstancias = 0;
static HolaConTiempo[] instancias =new HolaConTiempo[10];
int num;
long tiempoCreacion;
HolaConTiempo()
{
num = ++contInstancias;
tiempoCreacion = System.currentTimeMillis();
}
void saludar()
{
System.out.println(“¡Hola! Soy la instancia “ + num +
“ y he nacido en el milisegundo “ + tiempoCreacion);
}
public static void main(String args[])
{
//Creamos las 10 instancias
for (int i=0;i<10;i++)
instancias[i] = new HolaConTiempo();
//Que saluden las 10 instancias
for (int i=0;i<10;i++)
instancias[i].saludar();
} }

Contenedores
• Una clase puede tener el objetivo de guardar

objetos de otras clases
– ¡un objeto que guarda objetos!
– Eso es un contenedor
• Un array es un contenedor
– Podemos definir nuestros propios contenedores
• Ver ejemplo (Pastillero.java)

Otros aspectos: Comparación
• Dos objetos se comparan por referencias

– if (o1 == o2) ...
• Para comparar por valores:
– equals(Object o)
– if (o1.equals(o2)) ...
• ¿Comparación >,<?
– Método int compareTo(Object o)
• Devuelve -1, 0, +1
• No con todas las clases (ver interfaces)

Otros aspectos: javadoc
• Utilidad incluida en JDK

• Permite integrar la documentación de una
clase con el código de la misma
• Basada en comentarios con sintaxis fija
– Inicio en /** en lugar de /*
• Utilidad: javadoc.exe
– Genera .html integrable con doc. java

Sintaxis comentarios
• Justo antes de la clase o del método

• Primera línea: descripción corta resumen
(summary)
• Comentarios de los parámetros con @param
• Referencias a otras clases métodos @see
• Retornos de párrafo con <p>
• Otras posibilidades, como hiperenlaces (
{@link OtraCosa} )

Javadoc - ejemplo
/**
Clase de ejemplo javadoc. Utiliza la clase {@link String}.<p>
*/
public class Ejemplo {
/**
Devuelve una palabra a partir de un num. dado y de un gestor de ejemplos.
El parámetro pista debe referenciar a una cadena válida. <p>
Este método devuelve, de todas las palabras del gestor indicado,
aquéllos cuyo valor no es nulo, ordenados por su nombre.
Si no hay ninguno, devuelve una lista vacía.
@param numeroíndice válido de string

(si no es válido, se devuelve string vacío)
@param inicio gestor de ejemplos fuente de datos
@return palabra índice del gestor de ejemplos
@see #ponePalabra(String)
@see GestorEjemplos
@version 20090101
@since 0.3
*/
public String devuelvePalabra( int numero, GestorEjemplos inicio ) {
return "";
}

Visión documentación (1)

Visión documentación (2)

Ejercicios Propuestos (1/4)
• Ejercicio 1:
– Solucionar los problemas de la siguiente clase, reescribiéndola para que se compile
correctamente.
class HolaMundo2
{
int cont;
public static void main( String args[] )
{
cont = 0;
HolaMundo2 a = new HolaMundo2();
HolaMundo2 b = new HolaMundo2();
HolaMundo2 c = new HolaMundo2();
a.saludar();
b.saludar();
c.saludar();
}
HolaMundo2()
{
cont++;
}
void saludar()
{
System.out.println(“Hola, soy la instancia " + cont );
}
}
– Modificarla para que cada instancia indique su número secuencial. No se puede cambiar el
método main (excepto la primera sentencia, aunque no es necesario).

• Ejercicio 2:
– Crear una clase Vaca que tenga:
– Atributos: color de pelo (String), edad (entero), nombre (String)
• Métodos:
– debes elegir tres constructores diferentes
– muu: método que hace que la vaca muja y diga su nombre y color de pelo
"Muuu...mi nombre es XXX y mi color de pelo es YYY"
– compararEdad: dadas las edades de dos vacas (la que envía el mensaje y
otra como parámetro) saca el nombre de la vaca más antigua "La vaca XXX
es más vieja que la vaca YYY"
• Programa principal:
– Crear tres instancias de la clase Vaca, llamadas miVaca1, miVaca2 y
miVaca3. Para cada una de ellas utilizar un constructor diferente.
– Hacer que las tres mujan.
– Comparar la edad de miVaca1 y miVaca2.
– Modificar el programa para que cada vez que se cree una instancia de la
clase vaca salga un mensaje indicando el número de vaca creada: "Se ha
creado la vaca 1", etc.

• Ejercicio 3:
– Modificar la clase HolaMundo, llamándola HolaMundoAMedias:
(Hacerlo utilizando los métodos más apropiados de String)
• para que se parta de una variable String que contenga " ¡Esta es la cadena
Hola Mundo... a medias! ".
• posteriormente debe eliminar los espacios del inicio y del final.
• finalmente, quitar el substring que sobra para dejar simplemente "¡Hola
Mundo... a medias!", que debe ser el String visualizado.
– Ayudas para la realización del ejercicio:
– El método de instancia trim() de la clase String elimina espacios en blanco de los
extremos de un String.
– El método de instancia subString (inicio, fin) de la clase String devuelve los
caracteres de inicio a fin del String.
– El método de instancia indexOf(subString) de la clase String indica en qué posición
se encuentra la primera ocurrencia del subString en el String que llama al método.
• Ejercicio 4:
– Describe con tus palabras todos los pasos desde la edición hasta la
ejecución, los problemas que pueden surgir y cómo solucionarlos.
– ¿Qué ficheros y programas son necesarios en cada etapa?
– ¿Cuál es el conjunto mínimo de ficheros y programas necesarios para la
ejecución final de un programa Java?

• Ejercicio 5:
– Escribir un programa que coja todos los parámetros de la línea de comandos, si
los hay, y los muestre por pantalla, uno en cada línea, indicando con un solo
asterisco después de cada uno si está repetido (es decir, si algún otro parámetro
previo es un String igual)
• Ejercicio 6:
– ¿Por qué el siguiente trozo de código produce un error de compilación? ¿Cuál es
la diferencia entre a y c?
class Inicializacion
{
static int a;
{
int c;
int b=17;
if ( b!= 0)
System.out.println(b);
else
{
System.out.println(a);
System.out.println(c);
}
}
}

PII 01 Introduccion

Cargado por

Información del documento

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

PII 01 Introduccion

Cargado por

Copyright:

Formatos disponibles

Tema 1.

• Historia y principios de Java. Java básico

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

• Es un proyecto abierto (open source, GPL,CPL  EPL)

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

• TAD (Tipos Abstractos de Datos)

Programación II Tema 1 - Introducción

• Lenguajes Procedurales (no orientados a objetos)

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

• Sun, luego Oracle

Intérprete para Win ...

Compilación e interpretación de un programa Java

Programación II Tema 1 - Introducción

• Java no se compila a código máquina.

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

• En el lit. string el LF sí acaba. Caracteres de "escape": \n \t \" \\

Programación II Tema 1 - Introducción

•Explícitas (programador mediante un casting).

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

• Actividades fundamentales de un programa

Programación II Tema 1 - Introducción

[Modif. de clase] class Nombre_Clase [Clase Padre (0-1)] [Interfaces(0-N)]

[Modif. de clase]: public | abstract | final

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

• Modificadores que no afectan al ámbito

final Atributo con valor constante

abstract Método que está declarado pero no

Programación II Tema 1 - Introducción

• Encapsulación y Ocultamiento de la Información

Programación II Tema 1 - Introducción

– Modificadores que afectan al ámbito

Programación II Tema 1 - Introducción

• Importantes las diferencias:

Programación II Tema 1 - Introducción

• El acceso directo a los atributos pone en

Programación II Tema 1 - Introducción

– 6) Para pruebas y depuración

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

Programación II Tema 1 - Introducción

Circulo miCirculo = new Circulo(); //CASO 2º

– CASO 2º: Así estamos creando un objeto de tipo Circulo mediante el

Circulo miCirculo = new Circulo(2,4,5);//CASO 3º

– CASO 3º: Así estamos creando un objeto de tipo Circulo mediante la

– En Java todos los objetos se crean en memoria dinámica (new)

Programación II Tema 1 - Introducción

• Acceso a los atributos de un objeto