Java clases objetos

TemariodecursoJavaSE©IñakiMartín
7.- Clases y objetos
TEMARIO DE CURSO
PROGRAMACIÓN JAVA SE
CAPÍTULO 7
CLASES Y OBJETOS
© Iñaki Martín
Este obra está bajo una licencia de Creative Commons Reconocimiento-NoComercial-SinObraDerivada 4.0 Internacional.

๏ Antes de los lenguajes Orientados a Objetos (O.O.), solo se podía trabajar con los tipos de datos existentes
(hasta entonces, básicamente, los ya vistos como tipos primitivos: int, boolean, char, double, etc)
๏ En los 90 algunas personas pensaron que necesitaban trabajar con mas información que lo que
representaban números y letras, que necesitaban trabajar con cosas más cotidianas. Ellos quería que se
pudiera operar con coches, con personas, con tiendas, con tarjetas.., si los números se guardan en una
variable en la memoria, de tipo int, o double.... ¿por que no se podía guardar en la memoria un coche o
una pelota?
๏ Ese es el objetivo de la POO (Programación Orientada a Objetos), es una programación que tiene que permitir
trabajar con objetos cotidianos.
๏ Así pues, debe permitir
1. crear (inventar) tipos de datos nuevos,
2. que cualquiera pueda construir los que desee
3. que más tarde, pueda crear "variables" de dichos tipos,
4. trabajar con ellas, y a estas "variables" darles un poder y facultades mucho mayor que a otros tipos
de datos.
P.O.O.
P.O.O.
2

๏ Vamos a crear nuestro propio tipo de dato, como un int, o double, o char... solo que va a ser un tipo “Coche”.
Esto es, vamos a crear un tipo de dato llamado Coche, con lo que luego podremos crear variables de tipo
Coche.
๏ Para construir estos nuevos tipos, necesitamos una "fábrica" o "molde" donde construir las "variables". A
dicha "fábrica" ("molde", "plantilla") se le llama Clase.
๏ Podremos por lo tanto construir una fábrica de Tarjetas, una fábrica de Coches (una Clase Tarjeta, una Clase
Coche) donde realmente luego crearemos variables de tipo Tarjeta o de tipo Coche, variables que serán en
tarjetas "reales", coches "reales".
๏ Estas "variables" construidas con nuestras Clases ("fábricas") se les llama Objetos.
๏ Los objetos son construcciones reales que salen del molde, elementos específicos de una clase. Así pues, con
una misma Clase (fábrica) se construirán muchos Objetos (Tarjetas) diferentes: la tarjeta numero
4345454656577654, la tarjeta numero 8867466535243545, .. tarjetas que se guardan en la memoria como si
fueran un int o un String.
๏ Y por supuesto, para cada objeto, igual que los int o String, se le deberá dar un nombre
๏ Por lo tanto, para poder crear OBJETOS habré de construir antes la fábrica, la CLASE
Fábrica de tipos propios
Clases y objetos
3

๏ ¿Qué hace falta para crear una Clase, para crear mi fábrica o molde?
๏ Lo que define la naturaleza de la Clase son sus características, los datos que me interesan que se tengan a
mano cuando vaya a construir Objetos, las características que identifican claramente a cada “Coche”.
๏ Si en mi fabrica quiero construir Coches, hay cosas típicas de cada coche que puedo usar: marca, modelo,
color, matricula, cilindrada, numero de puertas… todo ello sin pensar en los extras que pueda llevar un coche
๏ Asi que puedo decir que en mi Fabrica (Clase) de Coches contaré por ahora con estos datos:
✤ marca
✤ modelo
✤ color
✤ cilindrada
✤ matricula
Y asi podre “fabricar” un coche. como por ejemplo:
“marca Opel, modelo Astra, color rojo, cilindrada 1600 y matricula 4367PLS”.
Si a este coche que he fabricado en el párrafo anterior le llamo “coche1”, entonces es que ya tengo un
OBJETO llamado “coche1” de mi CLASE Coche.
๏ Puedo luego crear otro OBJETO, otro Coche, que llame coche2, que tenga otras características, y luego más
coches (coche3, cochenuevo, cocheespecial,…), tantos como quiera.
๏ Cada uno de ellos es un OBJETO, una representación REAL de lo que mi clase Coche produce.
Concepto de Clase y Objeto
Clases
4

๏ Otro ejemplo: La fábrica de tarjetas
๏ Vamos a definir ahora la clase Tarjeta, esto es , vamos a crear el molde, la fábrica de construir Tarjetas.
๏ Esta fábrica (y todas las clases que se creen desde ahora) va a tener dos partes diferentes:
➡ La información de la naturaleza de mis futuras tarjetas (los datos que la identificarán). A esta
información la llamaremos Atributos
➡ Cuando construyo objetos, no me basta con que les diga cómo son. En POO además les voy a a decir
cómo quiero que actúen, les voy a decir qué cosas pueden hacer y cómo se van a hacer. Y eso son los
Métodos, son acciones que programaré para que haga con mi Objetos
๏ Veámoslo con el ejemplo de nuestra Clase Tarjeta
Concepto de Atributos y Métodos
Clase Tarjeta
NumeroTarjeta
Titular
FechaCaducidad
Saldo
LimiteDiario
AtributosMétodos
ActivarTarjeta
CambiarLimite
ReintegroCajero
PagoCompra
PedirSaldo
Atributos: cosas que identifican y que son características
de una tarjeta, y claro, relevantes para mi proyecto
Métodos: acciones que se pueden hacer con una tarjeta y que,
y claro, son relevantes para mi proyecto
5

De nuestra fábrica de tarjetas, nuestra clase, podremos
por lo tanto "construir" tantas tarjetas como queramos,
con información diferente en cada una de ellas
Ejemplos de objetos
Clase Tarjeta
NumeroTarjeta
Titular
FechaCaducidad
Saldo
LimiteDiario
AtributosMétodos
ActivarTarjeta
CambiarLimite
ReintegroCajero
PagoCompra
PedirSaldo
Objeto Tarjeta "tarjeta1"
NumeroTarjeta
4398932439037654
Titular Jose Perez
FechaCaducidad 10/19
Saldo 1200
LimiteDiario 500
AtributosMétodos
ActivarTarjeta
CambiarLimite
ReintegroCajero
PagoCompra
PedirSaldo
NumeroTarjeta 865215488554565
Titular Pedro Lopez
Saldo 2300
LimiteDiario 500
AtributosMétodos
ActivarTarjeta
CambiarLimite
ReintegroCajero
PagoCompra
PedirSaldo
NumeroTarjeta 6542321456325874
Titular Luis Sanchez
Saldo 160
LimiteDiario 200
AtributosMétodos ActivarTarjeta
CambiarLimite
ReintegroCajero
PagoCompra
PedirSaldo
6

๏ Es importante entender que en Java, todo son clases.
๏ Los proyectos que se han realizado hasta ahora, todos eran clases (empezaban por class xxxx) :
๏ Aquí vemos que el nombre de la clase es HolaMundo, y que dentro de la clase hay una línea que vimos
someramente antes, sin explicar mucho, que dice:
๏ Esto de main es un método de la clase HolaMundo, clase que en este ejemplo, no tiene atributos (pues no
son obligatorios).
๏ Recordemos que se dijo que todo proyecto java tiene que tener una clase se que tenga un método que se
llama main.
๏ Y este método será por donde se empieza a ejecutar el proyecto, esto es, desde aquí se van a empezar a
evaluar una a una sus instrucciones y a realizar lo que ellas indiquen.
Método main
El método main
public static void main(String[] args) {
class HolaMundo {
System.out.println(" Hola Mundo !!!");
}
}
7

๏ Ésta clase donde está el main, aunque es una clase como otra cualquiera, no se suele usar como clase de
tipo "fabrica", es decir, no se construyen objetos generalmente de ella misma.
๏ Es una clase que tendrá el método main y que desde ahí se iniciará nuestro programa.
๏ Y será ahi por tanto donde ademas de crear variables de tipo int, o double, aproveche a crear variables de
tipo Coche, o Persona, y donde use esas variables, junto con las que proporciona Java.
๏ Así pues, por ahora, y hasta ver más temas en profundidad, es importante distinguir entre
✤ las clases que son fábricas de nuestros objetos. Se crean y se dejan a un lado, simplemente
como fábricas para crear objetos en nuestros programas principales
✤ la clase donde esté el main, que llamaremos clase programa, donde construiré y usaré mis
clases fábrica
Clases tipo fábrica Clase tipo Programa
Clases fábrica y programa
Clases tipo fábrica y clases programa
Clase Coche
Matricula
Titular
AtributosMétodos
Matricular
Pagarimpuesto
Clase InicioProy
String a,b;
Atributos
Métodos
método main {
Creo una Coche
Creo una Persona
}
Clase Persona
Nombre
DNI
AtributosMétodos
ConsultarEdad
8

๏ Vamos a explicar este proceso con un ejemplo: vamos a crear una Clase (una fábrica de un nuevo tipo de dato)
el tipo de dato Coche
๏ Se debe escribir en un fichero con extensión .java
๏ Se construye con la palabra class y el nombre de la clase: class nombreclase
๏ Tras el nombre, el contenido de la clase se encierra entre llaves (igual que como se hace en un if o for)
[modificadores] class nombredelaclase {
// el contenido de la clase viene aquí
…
}
๏ Lo que se ha indicado como "modificadores" es contenido opcional, y en este caso, los modificadores de una
clase son palabras como public, private o protected, que se verán mas adelante. Por el momento ponemos
public.
๏ Voy a llamar a la clase que estamos construyendo MiClaseCoche, para que sea fácil de identificar.
๏ En una clase suele haber ,como ya se dijo, Atributos y Métodos, así que en la clase estarán los dos:
class MiClaseCoche{
// aquí vamos a poner los atributos
…
…
// aquí vamos a poner los metodos
…
…
}
Crear una clase
Creado clases
9
public class MiClaseCoche {
// aqui atributos
// aqui métodos
}

๏ Los atributos indican CÓMO quiero que sea mi Coche, QUÉ le identifica
๏ Para incluir los atributos, se indican como una declaración de variables normal, es decir, se debe indicar
tipo de dato y nombre del atributo:
๏ Estos serán los datos que usará mi programa para trabajar con coches,
๏ Todos los coches que se construyan con mi clase tendrán esta información
๏ Solo crearemos atributos que necesitemos. Aunque haya otros que parezcan evidentes, si no los vamos a usar, es inutil añadirlos
๏ A la vez que se crea cada atributo , se le puede dar también un valor inicial:
Atributos (I)
Atributos
String marca ;
String color ;
String matricula ;
int cilindrada ;
…
10
String coche_1.color = "Rojo";
String marca ;
String color ;
String matricula ;
int cilindrada ;
}
๏ Este será pues el código para crear mi primera Fábrica de Coches (Clase)

fichero MiClaseCoche.java
๏ Una vez creada mi Clase tipo Fábrica, se crea ahora una clase tipo Programa, nuestro verdadero
programa principal, que tendrá su método main, y donde voy a construir mis objetos de tipo coche
๏ Aunque nada impide que en un mismo fichero se guarden varias clases, es costumbre por legibilidad que
cada clase esté en un fichero diferente.
๏ Haremos pues que la clase MiClaseCoche se cree en una nueva clase llamada específicamente así, y la
clase del programa principal, en otra clase que llamaremos (por ejemplo) Inicial.
fichero Inicio.java
11
Por convenio, los nombre de las clases comienzan en Mayúsculas.
De hecho, en Java se distingue claramente una Clase por que es casi lo único que se escribe
comenzando en mayúsculas (a excepción de las constantes, que son todo en mayúscula, y los
enumerados e interfaces, que como se verá mas adelante, son casi subtipos de clases)
String marca ;
String color ;
String matricula ;
int cilindrada ;
}
public class Inicio {
public static void main(String args[]) {
// Aqui crearemos el coche
}
}
Recordar, las clases deben llamarse igual que el fichero .java donde se escriben
Atributos (II)

Con tipos PRIMITIVOS
• Dentro de mi clase Inicio, de su método main, vamos a crear objetos (coches, variables de tipo MiClaseCoche )
• La sintaxis para crear un objeto es : nombreclase nombreobjeto;
nombreobjeto = new nombreclase();
• Para construir objetos (Coches reales), hay que recordar que lo que intentamos con esto es crear un nuevo tipo
de datos, similar a int, double, etc... Pues hagámoslo igual, comparemos con como era crear una variable int, y
veamos que es parecido, solo que hay un paso intermedio nuevo: instanciar
paso 1: DECLARAR:
decir a la memoria:
“construye la variable var y es de
tipo int, pero aun no le hemos dado
contenido”
paso 2: ASIGNAR:
decir a la memoria:
“la variable que existe y se llama var
tiene ahora el valor 23”:
Creando objetos (I)
Creando objetos
Con CLASES
12
paso 1: DECLARAR:
decir a la memoria:
“construye la variable (objeto) coche1 y
es de tipo MiClaseCoche, pero aun no
le hemos dado contenido”.
paso 2: INSTANCIAR:
decir a la memoria: “para el objeto
que se llama coche1 construye un
nuevo (new) objeto de tipo MiClaseCoche”
Sería como ir a la fábrica y decirle “constrúyeme un coche, pero aun no te he dado las
características, su contenido, créamelo vacío"
paso 3: ASIGNAR:
decir a la memoria:
"guarda valores para mi objeto", que
en realidad, es dar valor a los atributos del objeto (se exlica esto luego)
MiClaseCoche coche1 ;
coche1.marca("Kia");
int var;
coche1 = new MiClaseCoche();
var = 23;

๏ A nuestro coche, una vez construido, hay que darle valor, como a cualquier otra variable
๏ Darle valor a un objeto es darle valor a sus atributos, uno a uno, de este modo:
๏ Vemos que se usa un punto (.) para indicar que el “coche_1” tiene un atributo llamado “marca”. Así,
quiere decir “esto es el atributo marca del objeto coche_1”
๏ Los atributos se comportan como variables en todos los aspectos, así que puedo consultar su valor
simplemente con un System.out , o asignarlo a otra variable... o lo que se quiera:
Creando objetos (II)
coche_1.marca
// Escribo el valor de un atributo por consola con un Syso
System.out.println("EL coche que he creado tiene color "+coche_1.color);
// Guardo en una variable String el valor del atributo matricula (por que el atributo es de tipo String)
String mat = coche_1.matricula; // asigno el valos
System.out.println("EL coche creado tiene matricula "+mat);
// Cambio el valor de un atributo, sumandole 200 al propio valor que tuviera antes (como un sumador)
coche_1.cilindrada = coche_1.cilindrada + 200 ;
System.out.println("EL coche tiene como nueva cilindrada "+coche_1.cilindrada);
// Guardo en una variable int el valor de un atributo, sumandole 500 a lo que tuviera
int nuevoPrecio = coche_1.precio + 500 ;
coche_1.marca = "Seat";
coche_1.cilindrada = 1800;
coche_1.color = "Rojo";
coche_1.matricula = "5123RSG";
13
Asignar valor a un objeto

String marca ;
String color ;
String matricula ;
int cilindrada ;
void dimeSiEsMetalizado ()
{
if (color.equals("Negro"))
{
System.out.println("El coche tiene pintura metalizada");
} else
{
System.out.println("El coche NO tiene pintura metalizada");
}
}
}
๏ Los métodos de una clase son métodos normales como los ya vistos en capítulos anteriores
๏ En nuestro ejemplo del coche, crearemos un método que informa de si el coche es de pintura metalizada
(consideraremos que solo la pintura negra es metalizada, y los demás colores no son metalizados :-)
Creando métodos
Creando métodos de una clase
๏ Analizando el método:
‣ Dentro del método, lo que vamos a analizar es el atributo color, y si tiene valor "Negro" emitimos un
mensaje, u otro mensaje en caso contrario.
‣ Recordar que estamos en la Clase (fábrica), estamos diciendo cómo se van a comportar los objetos
(coches reales) cuando los construyamos. La variable "color" es visible dentro del método, por que se
ha declarado anteirormente, a nivel de toda la clase, con lo que la variable se puede usar en el método
14

๏ Construimos un coche con la clase MiClaseCoche como ya vimos anteriormente (cocheDemo1)
๏ Para llamar a los métodos de una clase se usa el punto (.) , al igual que se hace con los atributos
Para llamar al método dimeSiEsMetalizado():
donde realmente estamos diciendo:
“Un cochedemo1. Como es del tipo MiClaseCoche, ir a la definición de la clase MiClaseCoche y buscar si
tiene un método llamado dimeSiEsMetalizado(). Si lo tiene, hacer lo que haya en ese método"
Llamando a métodos
Llamando a métodos creados
cocheDemo1.dimeSiEsMetalizado();
MiClaseCoche cocheDemo1 = new MiClaseCoche();
cocheDemo1.marca = "Opel";
cocheDemo1.cilindrada = 1900;
cocheDemo1.color = "Blanco";
cocheDemo1.matricula = "2333YSG";
15
Atención: al ejecutar este método, dimeSiEsMetalizado(), llamándolo con el objeto cochedemo1, la
primera línea del método compara el atributo color..... pero no un color cualquiera, sino con el
atributo color que tenga... cochedemo1. En este caso, como el atributo color de colorCoche1 es
"Blanco", lo que se muestra por pantalla es "El coche NO tiene pintura metalizada”

Ahora, tras crear un objeto del Coche, podemos llamar al
nuevo método, pasándole la informacion que necesita:
Lo que se hace es que el programa principal dice:
๏ ¿Como llamar a un método de una clase con parámetros? Igual que como cualquier otro método.
Creamos primero un método con parámetros en nuestra clase:
Invocar (llamar) a método con parámetros
cocheDemo3.marca = "Fiat";
cocheDemo3.cilindrada = 800;
cocheDemo3.color = "Blanco";
cocheDemo3.matricularCoche( "1118BEF");
System.out.println("Nueva matricula "+cocheDemo3.matricula);
16
String marca ;
String color ;
String matricula ;
int cilindrada ;
void dimeSiEsMetalizado ()
{
if (color.equals("Negro"))
{
System.out.println("El coche tiene pintura metalizada");
} else
{
System.out.println("El coche NO tiene pintura metalizada");
}
}
void matricularCoche(String matriculaAPoner) {
matricula = matriculaAPoner;
}
}
}
cocheDemo3.matricularCoche( "1118BEF");
“Una llamada a cochedemo1…. Vale, eso es del tipo MiClaseCoche, me voy a la definición de la clase
MiClaseCoche (a la fabrica, a la Clase) y busco si tiene un método llamado
matricularCoche( Y TIENE UN PARAMETRO TIPO STRING AQUI )
Si lo tiene, le pido hacer lo que haya en ese método, y ADEMÁS, le envío esta información: “1118BEF”
๏ Ahora, antes de ejecutar ninguna linea del método, el dato que se recibe ("1118BEF") se coloca en la
variable matriculaAPoner, y esa variable se usa para dar valor al atributo matricula
No olvidar que se trata del atributo matricula del objeto
que llama al método, cocheDemo3, no de ningun otro
๏ Ejemplo completo de llamada al método;
Se crea un coche nuevo, y la matricula se crea
con el método .matricularCoche :
Llamando a métodos con parámetros

๏ Un constructor es un método especial que se ejecuta cuando se efectúa la construcción de un objeto
(más exactamente, cuando se hace la invocación a la instrucción new)  
El constructor
Constructores
17
MiClaseCoche cocheDemo1 = new MiClaseCoche(); Llamada al constructor
๏ Al crear asi un objeto de una clase, usando ese constructor, ¿que contienen los atributos del objeto?
No tienen contenido.
๏ Cuando el compilador ejecuta esa línea, construye un coche, y para ello, llama al método MiClaseCoche() .
Este método es un constructor de la clase MIClaseCoche, un método que se ejecuta cuando se construye el
objeto.
๏ ¿Y si se llama a ese método, donde está este método?
Este caso, MiClaseCoche() es un constructor sin parámetros (no hay parámetros entre los paréntesis). Es un
constructor que Java crea automáticamente para poder usarlo sin necesidad de crearlo, por eso es llamado
“constructor por defecto”
๏ En resumen, al hacer
 
se dice realmente  
“Crea un objeto de tipo MiClaseCoche llamado car2, y usa el constructor MiClaseCoche() para ello”

7.- Clases y objetos Crear un constructor propio 18
๏ Al usar el constructor por defecto, como hemos visto, el objeto creado se crea con atributos que no tiene valor
๏ Sin embargo, normalmente, los constructores se usan para dar un valor inicial a los atributos del objeto.
¿Como se hace eso?
1. Escribiendo nosotros en la clase un constructor
2. Haciendo que el constructor (como un método normal) reciba parámetros, y que estos sean los
valores que queremos dar a los atributos
3. Asignando los parámetros a nuestros atributos
String marca ;
String color ;
String matricula ;
int cilindrada ;
public MiClaseCoche(String ma, String co, String mt, int ci){
marca = ma;
color = co;
matricula = mt;
cilindrada = ci;
}
void dimeSiEsMetalizado (){
if (color.equals("Negro")){
System.out.println("El coche es metalizado");
} else{
System.out.println("El coche NO es metalizado");
}
}
}
}
1 2
3
MiClaseCoche unCoche = new MiClaseCoche(“Kia", “Blanco", “1234KKK", 15000);
Ejemplo de como construir un objeto con el constructor creado:

๏ Un constructor es un método que tiene estas características:
‣ el nombre del método es el mismo de la clase
‣ no devuelve ningún valor (ni siquiera void)
‣ Al igual que con los métodos normales, puede haber sobrecarga de constructores, esto es, puede haber
varios constructores en la misma clase, siempre que no tengan la misma firma de parámetros. Con varios
constructores se faculta que se pueda construir un objeto de diferentes maneras, según cuál se use.
Constructor: características (I) 19
Para que haya sobrecarga, se recuerda que los constructores habrán de diferenciarse en los parámetros, que no serán iguales
en el número, en el tipo o en la posición.
Ejemplo de clase con varios
constructores, y como llamar a los
mismos
TarjetaCredito tj1 = new TarjetaCredito(“Pedro Perez", 1000, true);
TarjetaCredito tj2 = new TarjetaCredito(“Luis Pi”, true);
public class TarjetaCredito{
String titular;
double saldo;
boolean activa;
public TarjetaCredito(String tit, double sal, boolean act)
{
titular = tit;
saldo = sal;
activa = act;
}
public TarjetaCredito(String tit, boolean act)
{
titular = tit;
saldo = 0;
activa = act;
}
}
En el primer caso, se construye el objeto dando
valor a los tres atributos,
En el segundo, no se da valor al saldo, que se
inicializa siempre a 0.

๏ Es absolutamente necesario que todas las clases tengan constructor (incluidas las clases abstractas que
veremos mas adelante)
๏ Si no lo escribimos explícitamente, el compilador crea uno por defecto (que está vacío).
๏ Aquí vemos como se crearía el constructor, y como se usa en otra clase para crear un objeto
public TarjetaCredito()
{
}
20
Cuidado : Java nos crea un constructor vacío por defecto, sólo si no se escribe uno
propio. Si se ha creado uno específico, el de por defecto NO se crea, y no se puede usar
(salvo que se escriba por el usuario uno vacío expresamente).
 
El constructor normalmente se puede crear diretacmente en los IDE de desarrolo. En Eclipse, con btn-dcho (dentro de la clase) - > source-> crear constructor
Se añade una linea super(); que olvidamos por ahora.
public class Inicio {
public static void main(String args[]) {
TarjetaCredito tj2 = new TarjetaCredito();
.......
public class TarjetaCredito{
String titular;
double saldo;
boolean activa;
public TarjetaCredito(String tit, double sal, boolean act)
{
titular = tit;
saldo = sal;
activa = act;
}
public TarjetaCredito()
{
}
}
Clase con un
constructor propio y
además, el
constructor por
defecto
En este caso los atributos no se inicializan al construir el objeto, al menos no desde la llamada al constructor por
medio de sus parámetros.
Constructor: características (II)

7.- Clases y objetos 21Concepto de Clase, Atributo, Método y Objeto
Clase Tarjeta
String titular
double saldo
boolean activa
AtributosMétodos
void activarTarjeta()
void cambiarLimite(int x)
int reintegroCajero()
void pago(double w)
ATRIBUTOS: cosas que identifican y que son características
de una tarjeta
MÉTODOS: acciones que se pueden hacer con una tarjeta
IMPLEMENTACIÓN (definición)
DE LA CLASE
INSTANCIACIÓN DE LA CLASE
TarjetaCredito tj1 = new TarjetaCredito("Luis Pi", 3000, true);
TarjetaCredito tj2 = new TarjetaCredito("Juan Ruiz", false);
OBJETOS : Instancias (variables) de una clase
class TarjetaCredito{
String titular;
double saldo;
boolean activa;
TarjetaCredito(String tit, double sal, boolean act){
titular = tit;
saldo =sal;
activa= act;
}
TarjetaCredito(String tit, boolean act){
titular = tit;
saldo =0;
activa= act;
}
}

๏ Los atributos, al crearse, pueden definirse con un modificador de visibilidad (donde pueden usarse, donde
existen)
Public y private
Public y private
class Persona {
String nombre;
int edad;
public Persona(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
}
22
Persona objp = new Persona("Pepe", 23);
objp.edad = 24; // cambio la edad del objeto objp
๏ Sin embargo, puedo aplicar un modificador llamado private a la hora de
crear un parámetro, con lo que se quiere decir que el atributo solo es visible
desde dentro de la clase, desde fuera de esta no se puede usar el atributo
class Persona {
private String nombre;
private int edad;
....
๏ Con este cambio, la instruccion del ejemplo anterior de cambiar la edad da error, pues no se puede usar la
variable edad fuera de la clase
objp.edad = 24; // ERROR, el atributo edad es private, y no accesible desde fuera de la clase Persona
๏ En los ejemplos anteriores no se ha usado
ningún modificador en los atributos (delante
del tipo de dato no se ha incluido ninguna
palabra). No poner nada es casi lo mismo
que poner public (la pequeña diferencia se
evaluará mas adelante)
๏ De este modo, cuando se creaba un objeto en una clase proyecto, se podia acceder a los atributos de objeto:
๏ Una opcion es usar el modificar public delante del tipo del dato o del método (se ha usado en los métodos en
algunos casos previos). public quiere decir "es visible en cualquier sitio"

๏ El objetivo de hacer un atributo private es que solo la clase pueda controlar el tratamiento del atributo. Ahora, no
se permite que desde fuera de la clase alguien asigne, por ejemplo, un valor -40 a la edad, o un valor 340
๏ Este concepto de proteger los valores de una clase se denomina encapsulación, y es uno de los principios
básicos de la programación orientada a objetos
๏ Pero entonces, ¿cómo hacer para consultar o cambiar el valor del atributo?
Para poder leerlos y escribirlos, se deben crean en la clase unos métodos para estas acciones. Por ejemplo:
// consultar la edad del objeto objp
int laEdad = objp.consultarEdad();
// cambiar la edad del objeto objp
objp.cambiarEdad(24);
Getters y Setters (I)
class Persona {
private int edad;
this.edad = edad;
}
public String consultarNombre() {
return nombre;
}
public void cambiarNombre(String nom) {
nombre = nom;
}
public int consultarEdad() {
return edad;
}
public void cambiarEdad(int ed) {
edad = ed;
}
}
23
๏ El método consultarEdad()
tiene un return de la edad,
asi que asi puede
consultarlo
๏ El método cambiarEdad(24)
recibe el valor 24 en el
parámetro ed, y se lo asigna
al atributo edad, con lo que
lo actualiza
Getters y setters

๏ Al crear estos métodos, cada cual puede llamarlos como desee. Por ejemplo, al método de consultar la edad,
podríamos haberlo llamado consultarEdad(), dimeLaEdad(), darEdad()...
๏ Como son métodos que tendrán casi todas las clases java, se ha "propuesto" un estándar de nombres para ellos,
consistente en:
‣ El método de consulta se crea con get y el nombre del atributo, que empieza ahora en mayúsculas.
‣ El método de modificación se crea con set y el nombre del atributo, que empieza ahora en mayúsculas.
๏ Por ejemplo, con el atributo edad, se usaría :
‣ getEdad() para obtener el valor de edad, y
‣ setEdad() para dar valor al atributo edad.
Y este mismo criterio se aplicaría al resto de atributos:
Getters y Setters (II) 24
class Persona {
private int edad;
this.edad = edad;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nom) {
nombre = nom;
}
public int getEdad() {
return edad;
}
public void setEdad(int ed) {
edad = ed;
}
}

๏ Este principio de anteponer get y set se usa para crear para atributos de tipo boolean. En este caso,
habitualmente el método de acceso no se crea antecediendo get, sino is:
Getters y Setters (III)
boolean mayorDeEdad;
public boolean isMayoeDeEdad(){
return mayorDeEdad;
}
public void setMayorDeEdad(boolean med){
mayorDeEdad = med;
}
25
๏ Estos métodos getters y setters si que suelen ser public para poder accederse desde fuera.
๏ Con el uso de Getters y Setters, es la clase la que se encarga de dar valor al atributo, y si se desea puede
controlar (validar) que el valor que se asigne sea realmente correcto, e igualmente, puedo permitir que se
lea el valor de un atributo, pero puede ser de un modo controlado.  
public void setEdad(int ed)
{
if(ed>0 && ed<125){
edad = ed;
}
}
๏ Se puede también conseguir que no se permita acceso alguno a los atributos de una clase, simplemente aplicando private a los atributos, y no escribiendo
método alguno para su consulta o actualización. En estos casos, son otros métodos propios de la clase los gestionan estos atributos, pero desde fuera de la
clase, no se tiene constancia ni siquiera de la existencia de los atributos.
• Los metodos get y set se denominan comunmente getters y setters
• Se pueden crear automáticamente en los IDEs de desarrollo como Eclipse o Netbeans.
Si se realiza automáticamente, añaden la palabra this a los atributos dentro del método
Esta palabra no es necesaria, y se verá más adelante cual es su significado

๏ El ámbito o alcance de una variable es la zona del programa donde la variable es accesible, donde existe.
๏ Una variable existe dentro del bloque de llaves en el que se ha declarado
๏ En Java las variables se pueden clasificar según su ámbito en:
• Un c
Variables: nombre y ámbito (I)
Variables: ámbito y tipo
26
public class Persona
{
private int edad;
static int edadMaxima;
public static void main(String[] args)
{
int varlocal = 10;
if( varlocal> 5){
int varBloque= 10;
varlocal = varBloque;
}
}
}
Variable de instancia (atributo)
Variable de clase
Variable local
Variable de bloque
Ámbito del atributo edad
Ámbito de la variable local varlocal
Ámbito de la variable de bloque varBloque
✦ Variables de instancia, o atributos
✦ Variables de clase
(static, se detallan mas adelante)
✦ Variables locales
✦ Variables de bloque

A) Variables miembro (o de instancia, o atributos de una clase)
๏ Son las declaradas dentro de una clase y fuera de cualquier método.
๏ Aunque normalmente se declaran al principio de la clase, se pueden declarar en cualquier lugar siempre que sea fuera
de un método.
๏ Son accesibles en cualquier método de la clase.
๏ Salvo que se las inicialice con un valor específico, se crean con un valor por defecto :
• 0 para las numéricas
• ‘0' para las de tipo char
• false a las boolean
• null para String y resto de referencias a objetos.
B) Variables de clase (static) Ver mas adelante en este mismo capítulo
C) Variables locales
๏ Son las declaradas dentro de un método.
๏ Su ámbito comienza donde se declara la variable, NO desde el inicio del método, por lo que están disponibles desde su
declaración hasta el final del método donde se declaran.
๏ No son visibles desde otros métodos.
๏ Distintos métodos de la clase pueden contener variables con el mismo nombre. Se trata de variables distintas.
๏ Si se declara una variable local con el mismo nombre que una variable miembro de la clase, la variable local oculta
a la miembro. La variable miembro queda inaccesible en el ámbito de la variable local del mismo nombre.
๏ No tienen un valor inicial por defecto.
๏ Los parámetros de un método son variables locales al método.
D) Variables de bloque
๏ Son las declaradas dentro de un bloque de instrucciones delimitado por llaves { }.
๏ Están disponibles desde su declaración hasta el final del bloque donde se declaran.
๏ Distintos bloques pueden contener variables con el mismo nombre. Se trata de variables distintas.
๏ Si un bloque de instrucciones contiene dentro otro bloque de instrucciones, en el bloque interior no se puede
declarar una variable con el mismo nombre que otra del bloque exterior.
๏ No tienen un valor inicial por defecto.
Variables: nombre y ámbito (II) 27

7.- Clases y objetos 28
๏ La palabra static se usa para identificar que un miembro de la clase pertenece únicamente a la clase, y no a los
diferentes objetos (instancias) que de dicha clase se creen en el futuro. Se puede aplicar a atributos y métodos
๏ Aplicando static a un atributo, se crea una atributo de clase (a los atributos "no estaticos" se les llama tambien
atributos de instancia)
๏ En ese caso la variable es única para todos los objetos de la clase (ocupa un único lugar en memoria).
๏ Veamoslo con un ejemplo. Tenemos una clase persona con un atributo nombre y otro edadJubilacion (para simplificar
haremos los atributos no private y sin getters ni setters):
Modificador static (I)
static
static en un atributo
class Persona {
String nombre;
int edadJubilacion;
}
๏ Al crear objetos de esta clase, y dar valores a sus atributos, se almacena en memoria cada objeto con sus propios
valores:
Persona obj1 = new Persona();
obj1.nombre = "Pepe";
obj1.edadJubilacion = 65;
obj2.nombre = "Luis";
OBJETO obj1
nombre Pepe
edadJubilacion 65
OBJETO obj1
nombre Luis
edadJubilacion 68

๏ Si definimos el atributo edadJubilacion como static, pasa a ser un atributo de la clase, no diferente para cada objeto,
sino igual para todos ellos (por eso se le llama de clase, por que es de la clase, no de cada objeto)
Modificador static (II)
OBJETO obj1
nombre Pepe
OBJETO obj1
nombre Luis
class Persona {
String nombre;
static int edadJubilacion;
}
CLASE PERSONA
edadJubilacion 68
obj1.nombre = "Pepe";
obj2.nombre = "Luis";
๏ El atributo edadJubilacion puede ser modificado por cualquier objeto, pero con cada cambio, este afecta a todos
los objetos creados (y por crear) de la clase Persona
๏ Más aún, como el atributo realmente no pertenece a ningún objeto, sino a la clase, se puede acceder a el
directamente con el nombre de la clase :
Persona.edadJubilacion = 68;
๏ Un atributo de clase (estático) hemos de declararlo en cabecera de clase, nunca dentro de un método .
๏ Como un atributo static es accesible a nivel de clase, sin necesidad de crear ningun objeto, deberia inicializarse al
crear un objeto (dando un valor por defecto al crear el atributo), no al cargar la clase (en un constructor).
Un ejemplo de uso habitual de un atributo static es contar las instancias que hay de la propia clase (incluyendo un atributo static que haga de contador, en el
constructor de la clase)
๏ Además a static se le puede añadir el modificador final (static final) creando una constante de clase
๏ Asi se crea un atributo común para todos los objetos de esa clase, y fijo (no se puede modificar su valor una vez
asignado). En ests caso, el atributo debe ser obligatoriamente inicializado en el momento de declararse.

Movil m1 = new Movil();
m1.marca = "Montxi";
m1.modelo= "Txupi";
m2.modelo= "Mierdi";
m3.modelo= "Kasi";
m1.maxveloci = 4000;
m1.modelo= "Txupi";
m2.modelo= "Mierdi";
m3.modelo= "Kasi";
30Modificador static (III)
Class Movil
String marca
String modelo
int maxveloci
AtributosMétodos
void pagarbono()
int consultasaldo()
Variable tipo Referencia
m1 Movil 1000001
m2 Movil 1000111
m3 Movil 1010101
STACK HEAP
1000001 marca
modelo
Montxi
Chupi
maxveloci 4000
1000111 marca
modelo
Montxi
Mierdi
maxveloci 2000
101010101 marca
modelo
Montxi
Kasi
maxveloci 3000
Class Movil
String marca
String modelo
static int maxveloci
AtributosMétodos
void pagarbono()
int consultasaldo()
m1 Movil 1000001
m2 Movil 1000111
m3 Movil 1010101
STACK HEAP
1000001 marca
modelo
Montxi
Chupi
1000111 marca
modelo
Montxi
Mierdi
101010101 marca
modelo
Montxi
Kasi
maxveloci 3000Movil class
๏ Sin atributo static
๏ Con atributo static

๏ Aplicando static a un método, crea un método de clase. Tiene estas características:
‣ Al igual que con un atributo static, puedo llamar a un metodo static directamente con el nombre de la clase
Ya se ha visto el uso de métodos estáticos antes: Integer.parseInt(), Math.abs() (de clases Math e Integer:)
‣ Como se pueden usar sin crear un objeto, esto es, puede que no exista ni siquiera ni un objeto:
- dentro de un método static no se pueden usar atributos que no sean static
- todo método invocado desde dentro de un método static ha de ser static a su vez
- no puede usarse this ni super dentro de un método estático.
Modificador static (IV)
static como método
class ClaseConEstaticos {
// atributo de instancia
int indiceInicial = 1;
// atributo statico
static int numInstancias = 0;
// atributo statico y final
static final double CERO_ABSOLUTO = -273.15;
// metodo statico
static public int intAleatorio (int min, int max) {
return (int) (Math.random () * (max - min + 1) + min);
}
// constructor.
public ClaseConEstaticos() {
numInstancias ++;
System.out.println (“Num. actual de instancias: "+ numeroInstancias);
}
}
public class EjEstaticos {
public static void main (String[] args) {
// segun el ejemplo, cada vez que creo un objeto de la clase estoy aumentando
// el valor del atributo estatico
ClaseConEstaticos ce1 = new ClaseConEstaticos ();
ClaseConEstaticos ce2 = new ClaseConEstaticos ();
// para invocar el metodo estatico de la clase ClaseConEstaticos puedo hacerlo
// sin crear un obeto de la clase:
int s = ClaseConEstaticos.intAleatorio (10, 50);
// para invocar los atributos estaticosde la clase ClaseConEstaticos
// puedo hacerlo sin crear un obeto de la clase:
double x = ClaseConEstaticos.CERO_ABSOLUTO;
int n = ClaseConEstaticos.numInstancias;
}
}
obj1.validarEdadJubilacion(); // si el método es static, se puede llamar con un objeto cualquiera
Persona.validarEdadJubilacion(); // si el método es static, se puede llamar con la clase directamente
Ejemplo de clase con
atributos y metodos
estáticos y de instancia
(de objeto)
Uso de la clase
ClaseConEstaticos
Un método static no puede ser sobrescrito.
Pero eso no impide que pueda ser redefinido en una clase
heredada: En tal caso no es sobrescritura (ni siquiera sobrecarga),
es una nueva definición del método (como si fueran clases diferentes
sin ninguna relación)
Sobrescribir staticsTemas avanzados

1. Paso de parámetros por valor
‣ Al llamar al metodo con una variable, el método recibe
el valor de la variable, no la variable
‣ El argumento con que se llama al método y el
parámetro del método que recibe el valor son dos
variables distintas aunque tengan el mismo nombre.
‣ Cualquier modificación que se realice sobre la variable
parámetro dentro del método no afectará al valor de la
variable llamante.
‣ En definitiva, el método no puede modificar el valor de
la variable original.
2. Paso de parámetros por referencia
‣ Al llamar al método con una variable, el método recibe
la direccion de memoria de dicha variable (la referencia)
‣ El argumento con que se llama al método y el
parámetro del método son la misma variable,
‣ Cualquier modificación que se realice sobre la variable
parámetro dentro del método si modificará el valor de la
variable llamante.
‣ En definitiva, el método modificará el valor de la variable
original si se cambia esta dentro del método.
Paso de parámetros en programación
Paso de parámetros en programación
32
๏ En cualquier lenguaje de programación hay dos formas de pasar parámetros a un método:
ProgramaPrincipal()
{
int fuera=1;
incrementar(vfuera);
print(vfuera);
}
method incrementar(int vdentro){
vdentro++;
}
La variable vdentro del método incrementar recibe el VALOR de la
variable vfuera, esto es, recibe un 1, es como si hiciera vdentro =1
La variable vfuera no cambia de valor en el método, asi que la
instrucción print escribe 1
EJEMPLO DE PASO POR VALOR (EN UN LENGUAJE CUALQUIERA)
ProgramaPrincipal()
{
int fuera=1;
incrementar(vfuera);
print(vfuera);
}
method incrementar(int vdentro){
vdentro++;
}
La variable vdentro del método incrementar recibe LA PROPIA
VARIABLE VFUERA , es como si, dentro del método, la variable
vdentro fuera la variable vfuera con una careta. Todo lo que le pase
a vdentro le pasa a vfuera.
Como la variable vfuera se cambia dentro del método, la instrucción
print escribe 2
EJEMPLO DE PASO POR REFERENCIA (EN UN LENGUAJE CUALQUIERA)

๏ En Java todos los parámetros se pasan por valor, pero el efecto en objetos es de referencia.
๏ En principio, los parámetros siempre se pasan por valor.
Cuando se realiza la llamada a un método, los parámetros de los métodos reservan un espacio en memoria y reciben los valores de los argumentos pasados en las llamadas al
método. Los parámetros de los métodos tienen por lo tanto su propia zona de memoria, con lo que realmente reciben la información por valor.
๏ Cuando el argumento es de tipo primitivo (int, double, char, boolean...), el paso por valor significa lo normal
de un paso por valor, el método recibe el valor de la variable, no la variable. El método no puede modificar el
argumento llamante.
๏ Cuando el argumento es un objeto el paso por valor significa que el método recibe un valor, sí, pero ese
valor es la referencia del objeto (al dirección de memoria donde se encuentra el objeto). La referencia, dentro
del método, no puede modificarse, pero si se modifican los contenidos de los objetos durante la ejecución
del método, se modifican tanto argumento como parámetro, pues ambos apuntan al mismo sitio
๏ Resumiendo, aunque todo sea paso por valor, a los efectos reales, se pasan por referencia:
‣ objetos de clases propias y de la api de java
‣ los arrays (recordar que un array para java es un objeto !)
Paso de parámetros en Java (I)
Paso de parámetros en JAVA
33

๏ Ejemplo de estado de variables pasadas por parámetro, cuando son tipos primitivos
๏ Ejemplo de estado de variables pasadas por parámetro, cuando son tipos objeto.
Paso de parámetros en Java (II)
public class MiCoche
{
String matricula;
{
MiCoche c1 = new MiCoche();
c1.matricula = "2412JCS";
int n = 1;
System.out.println("Valor de matricula en el main antes de llamar al metodo: n" + c1.matricula);
darDeBaja(uncoche);
System.out.println("Valor de matricula en el main tras de llamar al metodo: n" + c1.matricula);
}
public static void darDeBaja(MiCoche pcoche)
{
pcoche.matricula = "BAJA";
System.out.println("Valor de matricula dentro del metodo: n" + pcoche.matricula);
}
}
{
int n=1;
System.out.println("Valor de n en main antes de llamar al metodo: "+ n );
incrementar(n);
System.out.println("Valor de n en main después de llamar al metodo: "+ n );
}
public static void incrementar(int n){
n++;
System.out.println("Valor de n en el metodo tras incrementar: "+ n );
}
34

7.- Clases y objetos Paso de parámetros en Java (III)
{
int[] aux = new int[1];
aux[0] = 1;
int n = aux[0];
System.out.println("Valor de n antes de llamar al metodo: " + n);
incrementar(aux);
n = aux[0];
System.out.println("Valor de n tras llamar al metodo: " + n);
}
public static void incrementar(int[] x)
{
x[0] ++;
System.out.println("Valor de n dentro del metodo tras incrementar: " + x[0]);
}
35
๏ Como se ha visto ya, al pasar un array a un método se pasa la dirección de memoria donde se encuentra, y
por lo tanto el método puede modificarlo.
๏ Si es necesario que un método modifique un tipo primitivo que recibe como parámetro, podemos hacer que el
método devuelva el valor modificado, y recogerlo en la misma variable que se pasa como argumento al
metodo: public static void main(String[] args)
{
int n=1;
n = incrementar(n);
}
public static int incrementar(int n){
n++;
return n ;
}

๏ Lo atributos de una clase pueden ser cualquier variable válida en Java
๏ Esfo incluye los objetos de otras clases (tanto de la api de Java como de construccion propia, puesto que las
clases son “tipos de datos” creados por el usuario).
Esto es llamado tambien relación de asociacion: una clase es un atributo de otra.
๏ Por ejemplo, en una clase Libro, puedo almacenar su autor, y que este a su vez, sea una clase propia
๏ Esto se escribe en Java indicando simpl.emente que en la clase Libro hay un atributo que es de tipo Autor:
Objetos como atributos (Asociación entre clases)
Objetos como atributos (Asociaciones entre clases)
36
class Libro {
String titulo;
int numpaginas;
Autor aut;
public Libro(String tit, int nump, Autor a) {
titulo = tit;
numpaginas = nump;
aut = a;
}
}
class Autor {
String nombreAu;
int dni;
public Autor(String nau,int d) {
nombreAu = nau;
dni = d;
}
}
๏ Ejemplo de como crear un objeto de Libro, y consultar sus atributos:
Autor aut1 = new Autor("S.King", 1323123);
Libro lib1 = new Libro("It", 1532, aut1);
String eltitulo = lib1.titulo;
String elautor = lib1.suAutor.nombreAutor; // consulto el nombre del autor... de lib1
lib1.suAutor.dni = 8844774; // cambio el dni del autor .. del lib1

7.- Clases y objetos Arrays de objetos
๏ Las clases son tipos de datos a todos los efectos, y por supuesto, sus objetos son un valor perfectamente
almacenable en un array. Así se define un array de 5 coches :
๏ Con esto se crea un array, pero no su contenido. Si se quiere inicializar, hay que meter en cada elemento del array
un valor.
๏ ¿Y que contiene el array? Pues Coches, con lo que hay que meter un Coche en cada elemento del array… así que
antes de meter nada habrá que crear los Coches que se van a meter…
๏ Se pueden hacer ambas instrucciones a la vez, sin dar nombre al coche que construimos.
๏ ¿Para que voy a darle un nombre al coche, si luego me voy a referir a el como listadecoches [0] ?
Atencion a que cada posicion del array es un coche, si el coche tiene un atributo color, lo puedo modificar asi:
๏ E incluso se puede declarar e inicializar a la vez, como si el contenido fuera un tipo primitivo:
Arrays de objetos
Coche co1 = new Coche() ;
Coche listadecoches [] = { co1, co2, co3 ) } ;
// Ahora sin ni siquiera dar nombre a los coches que añado al array
Coche listadecoches [] = {new Coche(), new Coche(), new Coche(“Azul”) } ;
37
Coche [] listadecoches = new Coche [5] ;
listadecoches [0] = co ;Coche co = new Coche() ;
listadecoches[0].color = "rojo"
listadecoches[0] = new Coche() ;

๏ El método main , como todos los métodos, puede recibir parámetros, y de hecho, esta preparado para
recibirlos
๏ El parámetro que recibe el método main() es un array de Strings.
๏ Serían los argumentos que normalmente se añaden a una llamada normal de ejecución de java, si lo
hiciéramos desde una linea de comando, no desde un IDE como Eclipse o Netbeans:
main y sus argumentos
C:> java miprograma.class param1 param2 23 param4
main( String [ ] args)
38
‣ Solo debe haber uno en cada clase (puede haber más si están sobrecargados, pero no es conveniente por legibilidad). Precisamente el
método es static para evitar ambigüedades y para que se pueda ejecutar sin crear un objeto de nuestro propio programa. Si hacemos
otro metodo main, liamos bastante la claridad del código.
‣ El array de String que recibe por parámetro se llama args... como se pude llamar alcornoques, no es fijo.
‣ Si se desea invocar a un método desde main... y no se quiere que dicho método sea static, se puede crear un objeto de la propia clase
que contiene el main, y con el, llamar al método en cuestión:
Consideraciones sobre el método main()Temas avanzados
public class MiClaseEjemplo {
public int incrementar(int origen,int cantidad){
return sumador+cantidad;
}
public static void main(String args[]) throws IOException {
AAZonaDePruebas a = new AAZonaDePruebas(); // crear un objeto de la propia clase
a.incrementar(4,7); // llamar al método con el objeto creado
new AAZonaDePruebas().incrementar(4,7); // lo mismo en una sola linea

7.- Clases y objetos Uso de main en Eclipse 39
๏ En IDE como Eclipse este paso de parámetros se simula
con la siguiente configuración:
1. Estando en el editor de código, con la clase que tiene el
main() a ejecutar, abrir en el menú superior
Run > Run Configurations (o directamente sobre el
editor, botón derecho, Run As > Run Configurations)
2. En el panel de la izquierda, elegir las configuraciones de
Java Application
3. Si no aparece ninguna asociada a mi clase, pulsar el botón
crear configuración
4. Rellenar los valores de la configuración con la que se va a
ejecutar nuestro programa:
➡ Nombre que le damos a esta configuración
➡ Proyecto que deseamos ejecutar al llamar a esta
configuracion
➡ Clase donde (dentro del proyecto) se encuentra el
método main() que inicia el proyecto.
Véase que se debe incluir el paquete junto con el nombre
de la clase
5. Pinchar en la carpeta de argumentos
6. Escribir en la caja los valores de los argumentos
separados por espacios en blanco
7. Pulsar el botón <Apply> antes de salir de este menú
Paso de parámetros a main( ) en Eclipse

๏ Imaginemos que se ejecuta el programa Actores que hemos configurado en las imágenes anteriores.
๏ Se le enviará al método main, como parámetros de entrada, los valores : JUAN Carlos 234 PePe
๏ Estos valores se asignan (automáticamente por la JVM) a los diferentes elementos del array de Strings
args. Por lo tanto, dentro del método main puedo acceder a cada valor como lo que es, un elemento del array:
๏ Advertir que al tratarse de un array de Strings, si queremos usar alguno de los elementos como un numero,
deberemos usar un Integer.parseInt() o similar
๏ En el ejemplo anterior, antes de coger los valores de parámetro en variable, se comprueba que se hayan
enviado realmente 4 parámetros, ni mas ni menos (usa el atributo length que tienen todos los arrays...)
๏ Ni que decir tiene el que nombre del array de Strings es args, pero es así por convenio, se puede llamar como
nos de la gana.
main y sus argumentos
public class Actores
{
{
if (args.length != 4)
{
System.out.println("Numero de parámetros erróneo");
System.exit(1);
}
String actor1 = args[0];
int polizas = Integer.parseInt(args[2]);
}
}
40
Uso de parámetros de main

• Shallow Copy : Ser produce cuando al copiar un objeto en otro, estamos copiando la referencia del objeto, no el
contenido del mismo. Una simple asignación de un objeto en otro produce una copia superficial :
Las dos variables, m1 y m2, apuntan al mismo objeto Cualquier cambio posterior que se haga en m1, cambia también m2
y viceversa
• Deep Copy: Al copiar de un objeto a otro, se copia el contenido del objeto, no su referencia, de modo que ambos tienen
el mismo contenido (luego son iguales a casi todos los efectos), pero no están en la misma referencia, con lo que cualquier
cambio posterior que se haga en m1, NO cambia m2 y viceversa. No están tampoco compartiendo contenidos, ni la
dirección original de referencia de cada variable.
La manera más útil de hacer una copia profunda es definir un constructor copia, como se explica más adelante.
Copia Shallow y copia deep (copia superficial o profunda)Temas avanzados
Shallow y Deep copy (I) 41
STACK HEAPMovil m1 = new Movil();
m1.marca = “Contxi";
m1.modelo= "Txupi";
Movil m2 = m1;
m1 Movil 1000101
m2 Movil 1000101
1000101 marca
modelo
Contxi
Txupi
m1.marca = “Contxi";
m1.modelo= "Txupi";
// usando un constructor copia
Movil m2 = new Movil(m1);
STACK HEAP
m1 Movil 1000101
m2 Movil 1111100
1000101 marca
modelo
Contxi
Txupi
1111100 marca
modelo
Contxi
Txupi

• Cuando se desea hacer una copia de un objeto, no se debe hacer una asignación directa entre objetos, pues ya se sabe que
con ello se asocian las referencias, no se hace realmente una copia (sólo una Shallow copy, una copia superficial).
• Así, como ambos objetos apuntan al mismo sitio, modificar uno modifica también el otro:
• Para hacer una copia realmente copia, de un objeto, se debe hacer un objeto nuevo, e irle reasignando uno a uno sus
atributos. Para hacerlos más fácil, se puede usar un constructor para ello, el habitualmente llamado "constructor copia" :
• Pero cuidado… esto no funciona cuando uno de los atributos de la clase es un objeto de otra clase?
Veamos como solucionarlo a continuación
Constructor copia (I)Temas avanzados
Libro l1 = new Libro("Cela", "La colmena");
Libro l2 = l1;
System.out.println(l2.getTitulo()); // escribe La colmena, claro
l2.setTitulo("Ben-Hur");
System.out.println(l1.getTitulo()); // escribe.... Ben-Hur,
class Libro {
String autor;
String titulo;
// Este constructor no recibe datos para los atributos, sino un objeto de la misma
// clase Libro, cuyos atributos los asigna a los atributos de la clase
public Libro(Libro original) {
this.autor = original.autor;
this.titulo = original.titulo;
}
}
public class PruebasConCconstructortes {
Libro l1 = new Libro("Cela", "La colmena");
Libro l2 = new Libro(l1);
System.out.println(l2.getTitulo()); // escribe La colmena, claro
l2.setTitulo("Ben-Hur");
System.out.println(l1.getTitulo()); // escribe.... nuevamente La colmena !!!
Shallow y Deep copy (II) Constructor copia (I)

• Si alguno de los atributos de una clase es un objeto de otra clase, cuando se haga reasignación de dicho atributo dentro del constructor
copia, no se puede hacer simplemente con una asignación, pues en tal caso ,estamos haciendo una Shallow de ese atributo en
particular:
¿Por qué ha cambiado el modelo de collar a los dos objetos?
Por que en el constructor copia, al tratar el objeto Collar, se asigna
directamente, y como es un objeto, esta haciendo una Shallow copy.
El truco está en que, en la reasignación de atributos, se han de usar
también constructores copia en los atributos que sean objetos.
Retocando el constructor copia de Perro y escribiendo un
constructor copia para Collar, se soluciona todo:
Constructor copia (II)Temas avanzados
Collar uncollar = new Collar("simple");
Perro uno = new Perro("Blas", uncollar);
Perro dos = new Perro(uno); // copia con constructor copia
// cambio valores del perro dos
dos.nombre = “Epi”;
dos.micollar.modelo=“moderno";
// pinto valores de ambos perros
System.out.println(uno.nombre+ "-"+ uno.micollar.modelo);
System.out.println(dos.nombre+ "-"+ dos.micollar.modelo);
class Perro {
String nombre;
Collar micollar;
// constructor normal
public Perro(String n, String r, Collar c){
this.nombre = n;
this.micollar = c;
}
// constructor copia
public Perro(Perro otro) {
this.nombre = otro.nombre;
this.micollar = otro.micollar;
}
}
class Collar{
String modelo;
public Collar(String modelo) {
this.modelo = modelo;
}
}
consola
Blas-moderno
Epi-moderno
class Perro {
String nombre;
Collar micollar;
public Perro(String n, String r, Collar c){
this.nombre = n;
this.micollar = c;
}
public Perro(Perro otro) {
this.nombre = otro.nombre;
this.micollar = new Collar(otro.micollar);
}
}
class Collar{
String modelo;
}
public Collar(Collar otro) {
this.modelo = otro.modelo;
}
}
Shallow y Deep copy (III) Constructor copia (II)

Método clone() (I)Temas avanzados
Ejemplo de clone() PROFUNDO (DEEP)
Ejemplo de clone() SUPERFICIAL (SHALLOW)
44
class Perro implements Cloneable {
String nombre;
Collar micollar;
public Perro(String nombre, Collar micollar) {
this.micollar = micollar;
}
@Override
protected Object clone() throws CloneNotSupportedException{
return super.clone();
}
}
String nombre;
Collar collar;
public Perro(String nombre, Collar collar) {
this.collar = collar;
}
@Override
Perro clonado = (Perro) super.clone();
clonado.collar = (Collar) collar.clone();
return clonado;
}
}
class Collar{
String modelo;
}
}
Perro uno = new Perro(“Blas",uncollar);
// asi hago un clon de un objeto
Perro dos = (Perro) uno.clone();
dos.nombre = "Epi";
System.out.println(uno.nombre+ "-"+
uno.micollar.modelo);
System.out.println(dos.nombre+ "-"+
dos.micollar.modelo);
class Collar implements Cloneable{
String modelo;
}
@Override
}
}
• Uno de los métodos que se heredan de Object es clone() y sirve, al igual que un constructor
copia, para realizar una copia de un objeto,
• Clone() se usa invocando a la instancia de su padre con super, y haciendo un clone() a su vez
en él. Exige varias cosas para usarse
- La clase que lo sobrescriba debe implementar Cloneable.
- Debe devolver Object, con lo que cuidado con los castings necesarios
- Debe procesar la excepción CloneNotSupportedException
// ejemplo de un método clone() sencillo
@Override
public Object clone(){
try {
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
• Al igual que con el constructor copia, hay que tener cuidado con los atributos que a su vez sean objetos, pues si no se trata individualmente, s
puede acabar en una copia superficial, no profunda. Se incluyen aquí los dos casos:
Shallow y Deep copy (IV) Método clone (I)

Método clone() (II)Temas avanzados
Ejemplo de clone() PROFUNDO (DEEP)
Ejemplo de clone() PERSONAL Y SUPERFICIAL (SHALLOW)
45
String nombre;
Collar micollar;
}
protected Perro clone(){
Perro clonado = new Perro(this.nombre, this.collar);
return clonado;
}
}
class Collar{
String modelo;
}
}
Perro uno = new Perro(“Blas",uncollar);
// asi hago un clon de un objeto
Perro dos = uno.clone();
dos.nombre = "Epi";
System.out.println(uno.nombre+ "-"+
uno.micollar.modelo);
System.out.println(dos.nombre+ "-"+
dos.micollar.modelo);
class Collar implements Cloneable{
String modelo;
}
protected Collar clone() {
return new Collar(this.modelo);
}
}
• Si el método clone() expuesto anteriormente, el que se ha sobrescrito desde Object, es un poco farragoso, aquí os dejamos
una versión de clone() personalizada, que evita los tres obstáculos del clone() tradicional;
- Ya no ha de sobrescribir ni implementar nada.
- Puede devolver un mismo objeto que el que copia, con lo que no hay que usar ningún casting
- No es necesario procesar una excepción específica
• Al igual que con el constructor copia, hay que tener cuidado con los atributos que a su vez sean objetos, pues si no se trata
individualmente, se puede acabar en una copia superficial, no profunda. Se incluyen aquí los dos casos:
String nombre;
Collar micollar;
}
protected Perro clone(){
Perro clonado = new Perro(this.nombre, this.collar);
clonado.collar = this.collar.clone();
return clonado;
}
}
Shallow y Deep copy (V) Método clone (II)

Constructores (avanzado)Temas avanzados
Constructores avanzados
a) No se pueden incluir variables de instancia en la llamada a super().
b) Sí se pueden incluir variables static
c) Recordar que antes del Super() se puede llamar a this(), lo que retarda el fin de ejecución
del super(), con lo que lo dicho anteriormentpara super() vale igualmente ahora para this()
46
‣ La primera instrucción de cualquier constructor, siempre, ha de ser una llamada super() a algun constructor de su supertipo, o
una llamada a this, pero NO a los dos a la vez.
‣ Si en un constructor no se hace explícitamente una llamada a algún super(), se incluye implícitamente una llamada a super()
(sin argumentos)
‣ Si se hace una llamada a this(), NO se crea implícitamente la llamada por defecto a super(), asi que debe ser el otro
constructor llamado con this quien debe hacer la llamada a super() (explicita o implícita)
‣ Los constructores pueden usar cualquier nivel de acceso, incluso private.
‣ No se puede hacer referencia a metodos o variables de instancia hasta que la llamada al superconstructor (super()) haya
terminiado de ejecutarse. Por eso:
 
‣ Solo se puede llamar a un constructor desde dentro de otro constructor. No se puede hacer una llamada directa a un
constructor desde otro método cualquiera
‣ Se puede tener un método con el mismo nombre que el constructor, aunque parezca algo estupido. En este caso el método si
debe especificar una valor de retorno (o void). Es por esto que los constructores no llevan ni siquiera void como valor de
retorno, para distinguirlos de cualquier otro método
‣ Un constructor no es un método, como acabamos de decir, por lo tanto, no pueden ser heredados, ni por supuesto
sobrescritos

Java pasa los parametros por valor (avanzado)Temas avanzados
Paso por valor y referencia . Avanzado
public class TestRotar {
// Stack
// direccion variable valor (direccion Heap)
// 32 miPA 44444411
// 55 miPB 88886666
// 81 paramA 44444411
// 93 paramB 88886666
// En java todos los parametros se pasan por VALOR. si se trata de tipos primitivos se pasa el valor del tipo
// Si se pasa de tipos Objeto, lo que se pasa es la REFERENCIA del mismo, esto es, la DIRECCION de memoria
// Por lo tanto, el parametro del metodo recibe la direccion y toma esa direccion,con lo que el parametro del metodo "apunta" a la direccion del argumento llamante.
// Esto implica que si MODIFICO el objeto DENTRO del estoy modificando TAMBIEN el objeto llamante
// Es por ello que el efecto que hace es como si el parametro se pasara por referecencia.
// Pero CUIDADO que el parametro se esta pasando por VALOR aunque sea un objeto, ºesto es, modificar el conteniro del objeto dentro del metodo lo modifica tambien
// fuera, pero la DIRECCION DEL OBJETO LLAMANTE NO SE CAMBIA DENTRO DEL METODO AUNQUE SE REASIGNE. Veamoslo con un ejemplo.
Punto miPA = new Punto(200, 300);
// **** ESTADO DE STACK
Punto miPB = new Punto(111, 444);
// 32 miPA 44444411
// 55 miPB 88886666
int miNumero = 23;
System.out.println(miPA.getX()); // muestra 200
System.out.println(miPA.getY()); // muestra 300
movemosParametros(miNumero, miPA, miPB);
}
public static void movemosParametros(int paramNum, Punto paramA, Punto paramB) {
// ---------------------- CUANDO EL PARAMETRO ES UN TIPO PRIMITIVO
// paramNum recibe el VALOR de miNumero, esto es, vale ahora 23;
paramNum = 4567; // cambia el valor de paramNum (ahora vale 4567), pero NO de miNumero (que seguira valiendo 23)
// ---------------------- CUANDO EL PARAMETRO ES UN TIPO OBJETO
// paramPuntoA recibe por valor la direccion de memoria (referencia) de miPA
// paramPuntoB recibe por valor la direccion de memoria (referencia) de miPB
// direccion variable referencia (direccion Heap)
// 32 miPA 44444411
// 55 miPB 88886666
// 11 paramA 44444411
// 93 paramB 88886666
paramA.setX(1000); // Estoy cambiando el atributo x de puntoX, y por lo tanto, TAMBIEN el atributo x de puntoA
// No cambia la referencia de ningun elemento, solo el atributo de paramA y miPA
paramB = paramA; // Puede parecer que al reasignar paramA en paramB, tambien se ha asignado miPA a miPB, pero NO ES ASI
// AQUI SE CAMBIA LA REFERENCIA A LA QUE APUNTA paramB, NO LA DE miPB
// Por lo tanto, paramB y miPB YA NO APUNTAN AL MISMO SITIO.
// direccion variable referencia (direccion Heap)
// 32 miPA 44444411
// 55 miPB 88886666
// 11 paramA 44444411
// 93 paramB 44444411
}
}
47

• Se puede declarar un array de modo anónimo, de forma que no se se asigne a ninguna varible
• Puede parecer absurdo pero puede usarse en el paso de argumentos a un método que sean arrays sin necesidad de
crearlos explícitamente
• Antes de ver su uso, comentar que la declaración + inicialización conjunta de arrys que hemos visto puede tener dos
sintaxis:
• Visto esto, este código explica como enviar un array anónimo a un método
Arrays anónimos: paso a métodos por parámetroTemas avanzados
Parámetros Variables (VarArgs)
public static String concatenar(String [ ] cadenas) {
String res = "";
for (int i=0; i< cadenas.length ; i++) {
res = res + cadenas [ i ];
}
return res;
}
public static void main (String [ ] args) {
String [ ] resolucion = concatenar ( new String [ ] { “Juan“, “Perez“, “Lopez“ } ;
}
int tabla1 [ ] = {31, 62, 73, 43} ;
int tabla1 [ ] = new int [ ] {31, 62, 73, 43} ;
48

7.- Clases y objetos Shadowing 49
• Es posible sin pega alguna declarar una variable local con el mismo nombre que una variable de instancia (atributo)
• En tal caso, se trata de variables totalmente diferentes.
• A esta actividad se le llama shadowing, ocultamiento, ...
• No parece una práctica muy atractiva para legibilidad y control de código, pero por ejemplo, se hace muchas veces... en los
parámetros de un constructor (recordar que los parámetros de un método no son más que variables locales al método)
• Si embargo, una clase hija de otra puede declarar un atributo propio con el mismo nombre que el atributo de la clase madre.
Es como "sobrescribir" el atributo. El uso es el mismo que al sobrescribir un método.
- La variable de la clase hija se elige para usarse si se invoca con un objeto de la clase hija, sus hermanas, invocarán al
atributo de la "madre"
- Si se desea acceder al atributo de la clase madre, se puede usar super.atributodelamadre
 
ShadowingTemas avanzados
Shadowing en herencia

Clase Class (I). ReflectionTemas avanzados
• Cualquier objeto de Java (herederos todos de Object) pertenece a una determinada clase.
Por ello, la clase Object tiene el método getClass(), o el literal .class, que devuelve un objeto de la clase Class, que contiene información
de la clase en cuestión, como:
- el nombre
- el package donde se encuentra
- los métodos que contiene
- los atributos que contiene
- los constructores que contiene
- las anotaciones que contiene
y tiene además algunos métodos como isAbstract() o isPrimitive() para ayudar a evaluar como es la clase
• El uso de estos métodos se conoce como “reflection” y a esos métodos , "reflective operations"
• Si se tiene por ejemplo la clase Agente
• Se puede crear un objeto de la clase Class que describa como es la clase Vestido, de cualquiera de estos modos:
• Algunos usos del objeto de Class obtenido:
En la página siguiente se detallan más métodos y usos para la clase Class
50
Class queEsUnAgente = Class.forName("pruebas.Agente"); // usando el nombre de la clase (Agente)
Agente unAgente = new Agente();
Class queEsUnAgente2 = unAgente.getClass(); // usando un objeto de la clase Vestido
public class Agente {
}
queEsUnAgente.getName(); // informa que el nombre de la clase es “Vestido”
queEsUnAgente.getDeclaredField("nombre"); // devuelve un objeto de la clase Field que describe el atributo “nombre”
consola
pruebas.Agente
class java.lang.String
Clase Class (I) Reflection

7.- Clases y objetos Clase Class (II) 51
Clase Class (II). Métodos y ejemplosTemas avanzados
CLASE DEVUELVE METODOS DESCRIPCION
Class String getName()
Devuelve el nombre de la clase, tal y como se uso en su creación. No incluye paquetes ni otras
referencias. NO identifica de modo unico a cada clase
Class String getCanonicalName()
Devuelve el nombre de la clase, tal y como se define en un import, con la ubicación en paquete. Identifica
de modo unico a cada clase
Class Class [] getClasses()
Devuelve una coleccion de objetos Class, con aquellas clases e intgerfaces que son miembros de la
familia de la clase (sus hererderas...)
Class Field [] gertDeclaredFields() Devuelve un array de objetos Field, con la identificación de tipo y nombre de cada atributo de la clase
Class Method [] gertDeclaredMethods() Devuelve un array de objetos Field, con la identificación de tipo y nombre de cada metodo de la clase
Class Constructor [] getConstructors()
Devuelve una coleccion de objetos Constructor, con la identificación de tipo y nombre de cada constructor
de la clase
Class boolean isInterface() Indica si el objeto es una referencia de un Interface
Class boolean isArray() Indica si el objeto es una referencia de un array
Class boolean isPrimitive() Indica si el objeto es una referencia de un tipo primitivo
Class ref = Libro.class;
System.out.println(ref .getName());
System.out.println(ref .getSimpleName());
System.out.println(ref .getCanonicalName());
Class [] cl =Reader.class.getClasses();
Field [] xx= ref.getDeclaredFields();
for(Field c : xx)
System.out.println(c.toString());
Method[] xxx= ref.getDeclaredMethods();
for(Method c : xxx)
Constructor[] xxxx= ref.getConstructors();
for(Constructor c : xxxx)
System.out.println(ref.isArray());
System.out.println(ref.isInterface());
System.out.println(ref.isInstance("Libro"));
Class c = int.class;
System.out.println(c.isPrimitive());
• Ya se ha visto que la clase Class permite obtener información de la clases que se usan en un proyecto.
• Sus objetos tienen muchos métodos con información de la clase a la que hacen referencia, entre otros :
consola
paquete_pruebas_class.Libro
Libro
paquete_pruebas_class.Libro
java.lang.String paquete_pruebas_class.Libro.autor
java.lang.String paquete_pruebas_class.Libro.titulo
public void paquete_pruebas_class.Libro.setAutor(java.lang.String)
public java.lang.String paquete_pruebas_class.Libro.getAutor()
public java.lang.String paquete_pruebas_class.Libro.getTitulo()
public void paquete_pruebas_class.Libro.setTitulo(java.lang.String)
public paquete_pruebas_class.Libro(java.lang.String,java.lang.String)
false
false
false
true

Dentro de un fichero que contiene código fuente (un .java) normalmente solo se incluye el código de una clase, pero puede
haber varias clases, siempre que se cumplan ciertas reglas:
• Un fichero fuente puede contener más de una clase (hablamos ahora de clases independientes, en el mismo fichero .java,
no de clases anónimas ni de clases internas)
• Sólo puede haber una clase pública en cada fichero fuente, y tantas clases no públicas como se desee.
• Si hay una clase pública, el nombre del fichero fuente ( el .java) debe coincidir con el nombre de dicha clase
• Si la clase pertenece a un paquete, la instruccion package debe ser la primera linea del fichero Fuente
• Si hay instrucciones import, estas deben ir inmediatamente despues de la instruccion package (si existe, sino en las primeras
lineas del fichero Fuente) y antes de cualquier declaracion de una clase.
• Si no hay instrucciones package o import, la declaracion de la clase debe ser la primera linea del código
• Si hay alguna instruccion package o import, estas afectan a todas las clases del fichero fuente
• Si un fichero no tiene una clase pública, el nombre del fichero puede ser cualquiera sin necesidad que coincide con ninguna
de las clases que contiene.
• Todo lo dicho para clases, vale igualmente para Interfaces, que a todos los efectos en un fichero fuente se comportan como si
fueran una clase.
• En todas las reglas anteriores no se aplica la
presencia de comentarios, que pueden estar
colocados en cualquier parte del fichero sin
afectar a las lineas de código.
Reglas para escribir varias clases java en ficheros *.javaTemas avanzados
52Reglas para escribir en ficheros .java
public class Ejemplo{
Circulo c = new Circulo();
}
}
class Circulo {
public double radio;
}

• La cohesión es es la medida que indica si una clase tiene una función bien definida dentro del sistema. El objetivo es enfocar
de la forma más precisa posible el propósito de la clase. Cuanto más enfoquemos el propósito de la clase, mayor será su
cohesión.
• Una prueba fácil de cohesión consiste en examinar una clase y decidir si todo su contenido está directamente relacionado con
el nombre de la clase y descrito por el mismo.
• Una alta cohesión hace más fácil:
- Entender qué hace una clase o método
- Usar nombres descriptivos
- Reutilizar clases o métodos
• El acoplamiento entre clases es una medida de la interconexión o dependencia entre esas clases.
• El acoplamiento fuerte significa que las clases relacionadas necesitan saber detalles internos unas de otras, los cambios se
propagan por el sistema y el sistema es posiblemente más difícil de entender.
• Por ello deberemos siempre intentar que nuestras clases tengan un acoplamiento bajo. Cuantas menos cosas conozca la
clase A sobre la clase B, menor será su acoplamiento.
• Lo ideal es conseguir que la clase A sólo conozca de la clase B lo necesario para que pueda hacer uso de los métodos de la
clase B, pero no conozca nada acerca de cómo estos métodos o sus atributos están implementados.
• Los atributos de una clase deberán ser privados y la única forma de acceder a ellos debe ser a través de los métodos getter y
setter.
• Un bajo acoplamiento permite:
- Entender una clase sin leer otras
- Cambiar una clase sin afectar a otras
- Mejora la mantenibilidad del código
Cohesión y acoplamientoTemas avanzados
53Cohesión y acoplamiento

Java clases objetos

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Java clases objetos

Similar a Java clases objetos (20)

Más de Jyoc X

Más de Jyoc X (17)

Último

Último (15)

Java clases objetos