Programación III (Java) - 01 Introduccion

Características esenciales O.O.
(1)
• Abstracción
– Quedarse con las características esenciales de algo (desde un
cierto punto de vista), ignorando los detalles irrelevantes.

Programación III Tema 1 - Introducción

(2)
• 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


(3)


(4)
– 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


(5)
• 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,...,
Programación III argN) Tema 1 - Introducción

(6)
• Actividades fundamentales de un programa
OO
– Crear los objetos necesarios (constructores)
– Invocación de métodos de objetos (mensajes)
– Borrar los objetos cuando no son necesarios
(automático en Java: garbage collector)


(7)
• 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]


Métodos get y set (1/3)

• El acceso a los atributos tal y como se ha
explicado anteriormente viola el concepto
de encapsulación.
• Solución:
– Métodos get para consultar los atributos de una
clase.
– Métodos set para modificar los atributos de una
clase.


• ¿Por qué complicarnos?
– 1) Independencia de implementación y cambios
• (ej: long getDNI())
– 2) Control de errores
• (ej: setFecha( int dia, int mes, int anyo ))
– 3) Campos calculados
• (ej: setValorFactura ( base, iva ) -> base, iva, total)
– 4) Polimorfismo
• (diferente lógica en clase padre e hijo sobre el mismo dato)

– 5) 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;
}

• 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;
}
...


Sintaxis básica de Java (1)
• Normas de estilo seguidas 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


• 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).
• Tipos
– Java es un lenguaje con un control estricto de tipos
• Cada variable debe declararse con un tipo
– Los tipos se clasifican en dos grandes grupos:
• Tipos Primitivos
• Clases
– Tipos Primitivos
• char
• boolean
• Numéricos
– Enteros (byte, short, int, long) (8, 16, 32, 64 bits con signo)
– Reales (float, double) (32, 64 bits con signo, infinito, NaN)


– 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).
Máxima: No perder 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 la palabra clave null, o bien
apunta a una instancia de la clase X (o alguna de sus subclases).
– Las instancias hay que crearlas EXPLICITAMENTE (o algún método
las creará por nosotros). La declaración no implica instanciación.


• Operadores
– Aritméticos (enteros y reales)
• + - * /
– Aritméticos (enteros)
• % (módulo o resto)
– Booleanos
• < <= > >= == !=
• && || !
– Manipulación de bits (enteros)
• And (&), Or (|), Xor (^), Not (~), Desplazamiento (>> << >>>)
– Incremento y decremento (forma prefija y postfija)
• ++ --
– Asignación (=)



• Estructuras de Control  Iguales que en C y
C++
• if ( exp ) sent1 [else sent2]
• for (inic; exp.while; inc.) sent ;
• switch (exp) {
– case exp: sent;
– ... }
• while ( exp ) sent ;
• do sent while ( exp ) ;


Sintaxis Java decl. de clases
(1/4)

[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


(2/4)
• 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;
}
}


(3/4)
• 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


(4/4)
– Modificadores que afectan al ámbito
MODIFICADOR SIGNIFICADO

public Mét/Atr accesible desde cualquier clase

private Mét/Atr sólo accesible en métodos de la misma
clase

<Sin Mét/Atr accesible por la propia clase y por las
Modificador> clases del mismo paquete

protected Mét/Atr accesible por la propia clase, por las
subclases y por las clases del mismo paquete


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)



• 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 a ellos.


• 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>


Herencia (1/2)
• Características de la Herencia
• Diferencia los TADs de la POO
• En Java, SOLO HAY HERENCIA SIMPLE (cada hijo sólo tiene
1 padre, aunque un padre puede tener N hijos)
• Funciona de modo estrictamente jerárquico
• Los métodos y atributos se heredan hacia abajo en la jerarquía
• En Java, TODAS LAS CLASES DERIVAN DE LA CLASE Object
(todas son subclases de ella) aunque no se indique
explícitamente.
• Las clases superiores describen un comportamiento más general,
las inferiores son más específicas (ej: Animal y Perro)
• Ventaja Principal: Reutilización de Código + simplificación
conceptual y programática.


Herencia (2/2)
– Sintaxis Java para la Herencia
• La cláusula extends indica que una clase hereda de
otra.
public class Perro extends Animal
{
…
}
• La clase de la que se hereda (Animal) debe ser
accesible:
– Estar en el mismo paquete que la clase Coche. (Tema 3)
– Estar declarada en otro paquete como public. (sgte
apartado)
– No estar declarada como final. (sgte apartado)


¿De dónde se hereda?
• La relación de herencia es transitiva
– Si A es subclase de B y B es subclase de C, entonces A es subclase de C
• Si no hay cláusula extends, entonces la superclase directa es java.lang.Object
• Ejemplo:
class Animal
{
}
class Perro extends Animal
{
}
class PastorAleman extends Perro
{
}
• Animal es subclase de java.lang.Object
• Perro es subclase de Animal y por tanto también de java.lang.Object
• Perro es superclase de PastorAleman
• ...


Modificadores de Clase Her.
(1/2)
• abstract
– Sirve para proporcionar un comportamiento común a varias clases.
– Indica que es una clase abstracta (una clase incompleta). La clase puede (no es obligatorio)
tener algunos métodos declarados pero no implementados (métodos abstractos).
– Las clases con este modificador NO SE PUEDEN INSTANCIAR
– Ejemplo:
abstract class Punto //clase abstracta
{
int x;
int y;
void mover(int x, int y)
{ this.x += x; this.y += y;
}
abstract void dibujar(); //método abstracto
}
abstract class PuntoColoreable extends Punto
{
int color;
}
class PuntoSimple extends Punto
{
void dibujar()
{ System.out.println(“(”+ x + ”,” + y + ”)”);
}
}


Modificadores de Clase Her.
(2/2)
• final
– Indica que la definición de la clase está completa.
• No se puede heredar de esa clase (no puede tener subclases).
• Si una clase es declarada abstract y final  Error de compilación
• public
– La clase es accesible a clases de otros paquetes. (Tema 3)
– Sólo una clase public por fichero fuente (las otras clases si las hubiera
son "privadas")


Polimorfismo
• ¿Qué es?
– Poder ejecutar código distinto de métodos iguales según el objeto que se haya
instanciado.
– En concreto...
• La variable que contiene un objeto y el objeto contenido no son del mismo tipo
• El método que se lanza se decide en ejecución, no en compilación
• Condiciones mínimas en otros lenguajes
– Herencia / misma signatura en métodos / método virtual
• Condiciones mínimas en Java.
– Herencia y misma signatura. Todos los métodos en Java son potencialmente
virtuales (polimórficos)
• Utilidad.
– Independencia y abstracción.
• Utilidad en Java.
– Java no existiría sin el polimorfismo. Independiente de plataforma.
• El uso de instanceof.
– Permite conocer el tipo real del objeto que se ha instanciado.

Animal a = new PastorAleman();
System.out.println(a instanceof PastorAleman);


Referencias this y super
– this
• Es la referencia al propio objeto sobre el que se está trabajando.
• No hace falta usarla para acceder a los atributos y métodos
propios pero siempre está presente en métodos de instancia.
• A veces es necesaria cuando se quiere pasar la referencia al
propio objeto como parámetro de otro método.
• Ej:
– panel.dibujaObjeto( this )
– super
• Permite referenciar a la clase padre.
• Se emplea cuando se ha redefinido un método y se quiere
acceder al método del padre (si no se usara esta palabra
reservada se llamaría al método de la propia clase y no habría
forma de invocar el del padre). [super.método(...)]
• Permite también llamar al constructor de la clase padre desde
el constructor de la clase hija. [super(...)]. En este caso, la
llamada debe ser la primera del constructor del hijo.


Ejemplo this y super:
class Rectangulo
{
void saludar()
{
System.out.println("Hola, soy Rectangulo, y saludo");
}
}
class Cuadrado extends Rectangulo
{
void saludar() //Método redefinido
{
System.out.println("Hola, soy un cuadrado");
}
void saludos()
{
saludar(); //Hola, soy un cuadrado
this.saludar(); //Hola, soy un cuadrado
super.saludar(); //Hola, soy Rectangulo, y saludo
}
public static void main (String[] args)
{
Cuadrado c1 = new Cuadrado();
c1.saludos();
}
}


Cadenas de constructores

• Los constructores se llaman en cadena
– Se reserva espacio para el descendiente
– Se ejecuta el código de todos los constructores
• Cada constructor inicializa sus atributos
• Primero los padres (de Object hacia abajo)
• Por eso lo primero que tiene que hacer cada
constructor es llamar al constructor de la clase padre
– super( ... )
– super() por defecto (lo hace Java si no lo hace el
programador)


La clase String
• El String (en Java) no es un tipo primitivo, es una
clase. Sin embargo, Java le ofrece un tratamiento
especial.
– 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 una cadena con otro tipo, este último se
convierte automáticamente a cadena
int valor = 5;
System.out.println(“Valor = ” + valor + ‘.’);
• (método toString())


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 ref null null 2 1
for (int 0i=0; 2i < 6; i++)
0

v[i] = i; //Se pueden crear todos los objetos
for (int i=0; i<v.length;i++)
0 4
v[i] = new Racional(1,1);
1 2 3 5


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;


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();
} }


Composición (1/4)
• Las clases pueden incluir atributos que a su vez son objetos, o métodos que devuelven
objetos.
• Los objetos se pueden encadenar para hacer llamadas.
• Ejemplo:
class Persona {
Persona padre; //Atributo de tipo clase
String nombre;
public Persona(Persona pPadre, String pNombre)
{
padre = pPadre; nombre = pNombre;
}
public String saluda()
{
return nombre;
}
public Persona getPadre()
{
return padre;
}
public static void main (String args[])
{
Persona filiberto = new Persona(null,"Filiberto");
Persona pablo = new Persona( filiberto, "Pablo" );
Persona nuria = new Persona( filiberto, "Nuria" );
Persona alberto = new Persona( nuria, "Alberto" );
//El nieto es Alberto
System.out.println("El nieto es: " + alberto.saluda());
//La madre es Nuria
System.out.println("La madre: " + alberto.getPadre().saluda());
//El abuelo es Filiberto
System.out.println("El abuelo es: " + alberto.getPadre().getPadre().saluda());
} }


Composición (2/4)
class Punto
{
private int x,y;
public int getX() { return x; }
public int getY() { return y; }
}
public class Cuadrado
{
Punto[] vertices;
Cuadrado(Punto p1, Punto p2, Punto p3, Punto p4)
{ vertices = new Punto[4];
vertices[0] = p1;
vertices[1] = p2;
vertices[2] = p3;
vertices[3] = p4;
}
Punto getOrigen()
{
return vertices[0];
}
{
Punto p1 = new Punto(0,0);
Cuadrado c = new Cuadrado(p1,p2,p3,p4);
System.out.println(c.getOrigen().getX());
System.out.println(c.getOrigen().getY());
}
}


Composición 3/4
• ¡Atención al error de referencia nula ! (muy
habitual en composición)
class Fecha { class Persona {
private int dia, mes, anyo; private String nombre;
private Fecha fechaNcto;
Fecha (int d, int m, int a){ //COMPOSICIÓN
dia = d;
mes = m; void imprimir(){
anyo = a; s.o.p.(nombre + “ “);
} s.o.p.(fechaNcto.dia +”/”); //ACCESO
} s.o.p.(fechaNcto.mes +”/”);
s.o.p.(fechaNcto.anyo +”/”);
}
}
class X {
...main(...){
Persona p = new Persona();
p.imprimir(); //ERROR. ¿POR QUÉ?

}

Composición 4/4
• Cuando se crea un objeto compuesto, se • Solución 2. Crear la fecha a la vez que la
deben crear también TODOS los persona (en el constructor)
objetos que lo componen
class Persona {
private String nombre;
• Solución 1. Crear la fecha después de la private Fecha fechaNcto;
persona
Persona(){
class X { fechaNcto = new Fecha(0,0,0);
...main(...){ }
Persona p = new Persona(); ...
p.setFecha(new Fecha(1,1,2000); }
p.imprimir(); //CORRECTO class X {
...main(...){
} Persona p = new Persona();
p.imprimir(); //CORRECTO
}
}
}


Otros aspectos:
Wrappers (envoltorios)
• ¿Cómo tratar un primitivo como un objeto?
– Wrappers (envoltorios)
• Clase para cada tipo: Integer, Double, Char...
• Constructores muy sencillos
Integer i = new Integer(5)
• Métodos conversores
int j = i.intValue()
• Conversiones desde string
double r = Double.parseDouble( “185” );
• Métodos estáticos genéricos de tipo
Double.isNaN(5.75)
– Las últimas ver. de Java hacen conv. automática
Integer i = 5; System.out.println( i + 3 );

Otros aspectos:
Comparación
• Dos objetos se comparan por referencias
– if (o1 == o2) ...
• Para comparar por valores:
– equals(Object o)
– Definido en Object (todos lo tienen)
– 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?


Ejercicios Propuestos (4/4)
• 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);
}
}
}


Programación III (Java) - 01 Introduccion

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Programación III (Java) - 01 Introduccion

Ähnlich wie Programación III (Java) - 01 Introduccion (20)

Mehr von Andoni Eguíluz Morán

Mehr von Andoni Eguíluz Morán (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Programación III (Java) - 01 Introduccion

Hinweis der Redaktion