TEMA 4.- PROGRAMACIÓN ORIENTADA A OBJETOS. CLASES.

Objetivos

 Comprender el concepto de recursividad y saber aplicarlo en la resolución de

problemas.
 Agrupar los programas y clases generadas en paquetes para crear una estructura más
lógica y útil.
 Trabajar en profundidad con el concepto de clase.
 Diseñar e implementar la estructura y miembros de una clase.
 Estudiar y comprender el concepto de constructor y finalizador.
 Aplicar el concepto de herencia en la resolución de problemas.
 Comprender el concepto de interface y su aplicación en Java.

Contenidos

4.1.- Creación de Paquetes.

Un paquete es un conjunto de clases relacionadas entre sí que puede a su vez contener

subpaquetes manteniendo la biblioteca de clases de forma jerárquica.

Cuando nos referimos a una clase de un paquete, salvo que se haya importado, hay que
referirse a la misma especificando el paquete y subpaquete.

Clase Objeto.java
package Objetos;
public class Libro {
int isbn;
String titulo;
String autor;
String editorial;
double precio;
}

Clase Tema4.java
package tema4;
import Objetos.Libro;
public class Tema4 {
public static void main(String[] args) {
Libro milibro = new Libro();
}

PROGRAMACIÓN - CICLO FORMATIVO DAM/DAW - TEMA 4. PROGRAMACIÓN ORIENTADA A OBJETOS. 1

CLASES
También podríamos acceder a la clase sin importarla, utilizando:

Clase Tema4.java
package tema4;
public class Tema4 {
public static void main(String[] args)
{ Objetos.Libro milibro = new
Objetos.Libro();
}
}
Los paquetes permiten reducir los conflictos con los nombres puesto que dos clases que se
llaman igual, si pertenecen a paquetes distintos, no deberían de dar problemas.

Los paquetes permiten proteger ciertas clases no públicas al acceso desde fuera del mismo.

Podemos crear subpaquetes desde netbeans pulsando botón derecho sobre el paquete y
seleccionando Nuevo / Java Package. Por último damos nombre al paquete.

Desde la clase principal Biblioteca podemos importar las clases con las sentencias:

import objetos.ejemplares.*;
import objetos.empleados.*;

4.2.- Concepto de clase.

En POO las clases permiten al programador abstraer el problema ocultando la
implementación.
Cuando definamos una clase debemos tener en cuenta que:
 Para acceder a las variables internas de una clase nunca lo haremos directamente si no
que lo hacemos a través de los métodos getter y setter.
 Cambios en una clase no deben repercutir en otras clases ya que se busca un nivel alto
de cohesión o independencia.
En Java hay varios niveles de acceso a los miembros de una clase:
 public (acceso público).
 protected (acceso protegido).
 private (acceso privado).

Cuando especificamos el nivel de acceso a un atributo o método de una clase, lo que estamos
especificando es el nivel de accesibilidad que va a tener ese atributo o método que puede ir
desde el acceso más restrictivo (private) al menos restrictivo (public).

Acceso público (public) indica que puede ser accedido desde cualquier otra clase o subclase
que necesite utilizarlo.

Acceso privado (private) indica que puede ser accedido solamente desde los métodos internos
de su propia clase.

Acceso protegido (protected) indica que puede ser accedido desde cualquier subclases o
clases del mismo paquete a la que pertenece la clase.

(*) Se podría acceder al atributo o método desde la subclase pero no desde la superclase.

Una clase definida como pública puede ser utilizada desde cualquier paquete y otros paquetes
mientras que una clase no definida solamente podrá ser utilizada por las clases de su propio
paquete.

Resumiendo private solo accesible desde la propia clase, protected accesible desde el mismo
paquete y public accesible desde otros paquetes.
Ejemplo:
Si en el paquete personal tenemos en la clase empleado un método llamado calculaLetraDni
que queremos solamente sea accesible desde la clase empleado será un método private.
Si en el paquete personal tenemos en una clase empleado un método llamado
calculaTotalSueldos y queremos también utilizarlo en otra clase llamada nominasEmpleados
que pertenece también al paquete personal, será un método protected.
Por último si en la clase empleado del paquete personal tenemos un método llamado
muestraListado y queremos utilizarlo en la clase externos del paquete recursosHumanos, el
método será public.

empleado.java
package personal;
public class empleado {
private static void calculaLetraDni(){
}
protected static void calculaTotalSueldos(){
}
public static void muestraListado(){
}
private static void componerDni(){
calculaLetraDni();
}
}

nominasEmpleados.java
package personal;
import static personal.empleado.*;
public class nominasEmpleados {
private static void calculaPagosPersonal(){
calculaTotalSueldos();
}
}
externos.java
package recursosHumanos;
import static personal.empleado.*;
public class externos {
private void datosPlantilla(){
muestraListado();
}
}

Referencia al objeto this.

This proporciona una referencia al objeto que llamó al método y con el que se está trabajando.
Puede obviarse pero en ocasiones es necesario para resolver ambigüedades.

public class libro

{ String isbn;
String titulo;
String autor;
String editorial;
double precio;

public libro(String isbn, String titulo, String autor,

String editorial, double precio){
this.isbn = isbn;
this.titulo = titulo;
this.autor = autor;
this.editorial = editorial;
this.precio = precio;
}
}

Método toString.
El método toString se hereda de Object, por lo que sobrescribiremos este método para
adaptarlo y mostrar la información completa de un objeto, es decir, el valor de sus atributos.

package empleadoapp;
public class EmpleadoApp {
public static void main(String[] args) {
//Creamos tres empleados
Empleado empleado1=new Empleado("Fernando", "Ureña", 23, 600);
Empleado empleado2=new Empleado("Antonio", "Lopez", 28, 900);
Empleado empleado3=new Empleado("Alvaro", "Perez", 19, 800);
 //Mostramos la informacion del objeto
System.out.println(empleado1.toString());
System.out.println(empleado2.toString());
System.out.println(empleado3.toString());
}
}

class Empleado
{ String nombre;
String apellido;
int edad;
double salario;

public Empleado(String nombre, String apellido, int edad,

double salario){
this.nombre=nombre;
this.apellido=apellido;
this.edad=edad;
this.salario=salario;
}

@Override
public String toString(){
String mensaje = "El empleado se llama "+nombre+" "
+apellido+" con "+edad+" años y un salario de "
+salario+" €";
return mensaje;
}
}

Al ejecutar obtenemos el siguiente resultado:

run:
El empleado se llama Fernando Ureña con 23 años y un salario de 600.0
€
El empleado se llama Antonio Lopez con 28 años y un salario de 900.0 €
El empleado se llama Alvaro Perez con 19 años y un salario de 800.0 €
BUILD SUCCESSFUL (total time: 0 seconds)

Además, al mostrar el objeto sin llamar al método toString() se ejecutará por defecto este
método:
System.out.println(empleado1);
System.out.println(empleado2);
System.out.println(empleado3);
4.3.- Estructura y Miembros de una Clase
En Java no existen variables globales, por lo tanto, si queremos utilizar una variable única y que
puedan utilizar todos los objetos de una clase deberemos de declararla como estática (static).

A diferencia de los atributos de instancia, los atributos de clase tienen la cláusula static y todos
los objetos de la misma clase compartirán dichos atributos.

Los métodos y atributos de instancia son aquellos que no son static.

Los métodos de instancia (no static) pueden acceder a los atributos de instancia y también a
los atributos de clase.

Un método de clase o static no tienen referencia this y no puede acceder a atributos de

instancia (no static).

Ejemplo:

package concesionario;
public class Concesionario {
public static void main(String[] args)
{ coche coche1 = new coche("4927DFB");
coche coche2 = new coche("9003HGD");
coche coche3 = new coche("1204JHF");
System.out.println(coche1.getMatricula());
System.out.println(coche2.getMatricula());
System.out.println(coche3.getMatricula());
System.out.println(coche.mostrarNumCoches());
}
}

class coche{
String matricula;
static int numCoches = 0;

public coche(String matricula){

this.matricula = matricula;
numCoches++;
}

public String getMatricula(){

return this.matricula;
}

public static int mostrarNumCoches(){

return numCoches;
}
}
Al ejecutar obtenemos:

run:
4927DFB
9003HGD
1204JHF
3
BUILD SUCCESSFUL (total time: 0 seconds)

De este modo, respecto a los métodos de Clase e Instancia tenemos que:

Clase Math.
Librería java.lang.Math dispone de métodos que permiten realizar operaciones matemáticas y
pueden ser llamadas anteponiendo el nombre de la clase Math ya que se tratan de métodos
estáticos de clase.
Ejemplo:
package opermatematicas;
import java.text.DecimalFormat;
public class OperMatematicas {
public static void main(String[] args) {
double prestamo = -410.489;
double sueldo = 1452.389;
double retencion = 328.956;
int valor1 = 10;
int valor2 = 25;
int azar;
int numero = 2;
int exponente = 3;

System.out.println("Valor abosulto de -410.489: "

+Math.abs(prestamo));
System.out.println("Máximo 10 y 25: "
+Math.max(valor1, valor2));
System.out.println("Mínimo 10 y 25: "
+Math.min(valor1, valor2));
System.out.println("Potencia 2 elevado a 3: "
+Math.pow(numero, exponente));
System.out.println("Aleatorio entre 20 y 30: "
+((Math.random()*10)+20));
System.out.println("Redondeo al entero del sueldo: "
+Math.round(sueldo));
System.out.println("Redondeo al entero de la retención: "
+Math.round(retencion));
DecimalFormat formateador = new DecimalFormat("####.##");
System.out.println ("Redondeo Sueldo al segundo decimal: "
+formateador.format(sueldo));
System.out.println ("Redondeo Retención al segundo decimal: "
+formateador.format(retencion));
}
}

Resultado de la ejecución:
Valor abosulto de -410.489: 410.489
Máximo 10 y 25: 25
Mínimo 10 y 25: 10
Potencia 2 elevado a 3: 8.0
Aleatorio entre 20 y 30: 26.728286796166923
Redondeo al entero del sueldo: 1452
Redondeo al entero de la retención: 329
Redondeo Sueldo al segundo decimal: 1452,39
Redondeo Retención al segundo decimal: 328,96
4.4.- Trabajo con Métodos.
Paso de Parámetros por Valor y por Referencia.
Cuando queremos pasar un parámetro a un método lo podemos hacer de dos formas: por
valor y por referencia.
En el paso de parámetros por Valor los parámetros se copian en las variables del método y las
variables pasadas como parámetro no se modifican.
En el paso de parámetros por Referencia las variables pasadas como parámetros se modifican
puesto que el método trabaja con las direcciones de memoria de los parámetros.

En Java el paso de parámetros siempre es por valor, excepto cuando pasamos un array como
parámetro de un método que es pasado como referencia y cualquier cambio en el array dentro
del método queda reflejado fuera del mismo.

Ejemplo: Paso de parámetro por Valor. El parámetro se copia en la variable del método y las
modificaciones no afectan.
package pasoparametros;
public class PasoParametros {
public static void main(String[] args) {
int a = 10;
int b = 5;
suma(a, b);
System.out.println("A: "+a);
System.out.println("B: "+b);
}
}

public static void suma(int a, int b){

int suma;
a=a*a;
b=b*b;
suma=a+b;
System.out.println("La suma es "+suma);
}
}

Resultado:

run:
La suma es 125
A: 10
B: 5
BUILD SUCCESSFUL (total time: 0 seconds)

PROGRAMACIÓN - CICLO FORMATIVO DAW - TEMA 4. PROGRAMACIÓN ORIENTADA A OBJETOS. CLASES 10

Ejemplo: Paso de parámetro por Referencia. Cualquier cambio en el parámetro se refleja fuera
del método pues estamos trabajando con la dirección de memoria al parámetro.

package pasoparametros;
public class PasoParametros {
public static void main(String[] args) {
int contador;
String[] nombres = {"Mario", "Luis", "Pedro", "Ana"};
cambiaNombre(nombres);
for (contador=0; contador<=nombres.length; contador++)
{ System.out.println("El nombre es
"+nombres[contador]);
}
}

public static void cambiaNombre(String[] nombres){

nombres[1]="Antonio";
}
}
Resultado:
run:
El nombre es Mario
El nombre es Antonio
El nombre es Pedro El
nombre es Ana
BUILD SUCCESSFUL (total time: 0 seconds)

Métodos Recursivos.
Un método es recursivo cuando se llama a sí mismo.
Se utiliza la recursividad cuando la resolución del problema es más sencilla y cuando no es
infinita.

En cada llamada al método recursivo no vamos acercando más a la solución. En lugar de

utilizar un método recursivo podríamos utilizar uno equivalente iterativo o repetitivo.

Por ejemplo para calcular la potencia de x elevado a y crearemos el método potencia al que le
pasaremos el número y el exponente: potencia(x,y). Para resolver el caso recursivo debemos
encontrar:
 Una fórmula que nos vaya acercando a la solución.
 Un caso base que hace que nuestra recursividad no sea infinita.

En nuestro ejemplo sabemos que xy = x * xy-1 y que debe para cuando x0 = 1 (caso base). EL
método quedaría como se muestra a continuación:
package recursivo1;
public class Recursivo1 {
public static void main(String[] args) {
double x = 2;
double y = 3;
System.out.println("EL resultado es: "+potencia(x,y));
}

public static double potencia(double x, double y){

if (y==1){
return x;
} else {
return x * potencia(x, y-1);
}
}
}

Resultado:
run:
EL resultado es: 8.0
BUILD SUCCESSFUL (total time: 0 seconds)

El siguiente esquema muestra las llamadas recursivas al método

potencia y el retorno de resultados:
4.5.- Los Constructores.
Cuando creamos un objeto, Java reserva espacio en la memoria para dicho objeto. Podemos
crear un objeto con el constructor por defecto o podemos programar nuestro constructor para
satisfacer las necesidades de la clase. El constructor se llama de forma automática siempre que
se crea un objeto de la clase.

Por tanto tenemos dos tipos de constructores:

 Constructor por defecto. Cuando no se especifica en el código y se ejecuta siempre de
manera automática.
 Constructor definido. Puede ser más de uno. Tiene el mismo nombre que la clase.
Nunca devuelve valor y se declaran como public.

Si existe más de un constructor se dice que está sobrecargado.

Se definen múltiples constructores de una clase cuando puede ser inicializado de varias formas.
Al sobrecargar el constructor, se varía el número y tipo de parámetros que recibe. Cuando
creamos un objeto con new, Java elige el constructor dependiendo de los parámetros
utilizados.

Ejemplo:
public class libro
{ String isbn;
String titulo;
String autor;
String editorial;
double precio;

public libro(String isbn, String titulo){

this.isbn = isbn;
this.titulo = titulo;
}

public libro(String isbn, String titulo, String autor, String

editorial, double precio){
this.isbn = isbn;
this.titulo = titulo;
 this.autor = autor;
this.editorial = editorial;
this.precio = precio;
}
}

Asignación de objetos.
Cuando trabajamos con objetos trabajamos con referencias a la zona de memoria donde se
encuentra el objeto.

Ejemplo:

Desde el método main ejecutamos el siguiente código:

El resultado por pantalla será

Alto: 8
Ancho: 6
Cuando hacemos r2=r1 se está copiando la referencia al objeto y no el contenido de un objeto
en otro.

Para copiar el contenido de un objeto a otro utilizaremos el constructor de copia, que permite
asignar los valores de otro objeto de la misma clase. El constructor de copia tendrá un
parámetro que será un objeto de la misma clase.

Un constructor de copia para la clase anterior sería:

Desde el método main ejecutamos el siguiente código:

El resultado por pantalla será

Alto: 7
Ancho: 5

Inicializadores static
Los inicializadores static son un bloque de código que solamente se ejecuta la primera vez que
se utiliza la clase. Son métodos sin nombre, no devuelven ningún valor y son ideales para
inicializar objetos. Se puede crear más de un inicializador static y se ejecutarán según el orden
en el que se han definido.
Se utiliza la palabra static y entre { } la inicialización que queremos realizar.

Ejemplo:

public class empleados {

int codigo;
String nombre;
String apellidos;
int catLab;
int horasMes;

static double importeCatLab1;

static double importeCatLab2;
static double importeCatLab3;
static double importeCatLab4;

static {
importeCatLab1 = 25;
importeCatLab2 = 20;
importeCatLab3 = 15;
importeCatLab4 = 10;
}

public double sueldoMes(){

double sueldo = 0;
switch (this.catLab){
case 1: sueldo = importeCatLab1 * this.horasMes;
break;
case 2: sueldo = importeCatLab2 * this.horasMes;
break;
case 3: sueldo = importeCatLab3 * this.horasMes;
break;
case 4: sueldo = importeCatLab4 * this.horasMes;
}
return sueldo;
}
}

4.6.- Los Destructores.

En java no existen los destructores. El propio sistema es el encargado de eliminar
definitivamente los objetos cuando dejan de utilizarse. El sistema de liberación de memoria en
Java se conoce como garbage collector (recolector de basura).

4.7.- Encapsulación y Visibilidad. Interfaces.

Los objetos se comunican por medio de los métodos que componen su interfaz. Un interfaz es
un grupo de métodos con sus cuerpos vacios.
Ejemplo:

package interfacefigura;
public interface interFigura {
double PI = 3.1416f; // Por defecto public static final.
double area(); // Por defecto public
}

La clase implementa la interface utilizando la sentencia implements y el nombre de la

interface. La clase debe implementar los métodos declarados en la interface.

Ejemplo:
package interfacefigura;
public class InterfaceFigura {
public static void main(String[] args)
{ Cuadrado miCuadrado = new Cuadrado
(3.5); Circulo miCirculo = new Circulo
(2.75);
Rectangulo miRectangulo = new Rectangulo (2.25, 3);
System.out.println ("Área del Cuadrado: " + miCuadrado.area());
System.out.println ("Área del Círculo: " + miCirculo.area());
System.out.println ("Área del Rectángulo: "+ miRectangulo.area());
}
}

class Cuadrado implements interFigura { // Implementa la interface Figura

double lado;
public Cuadrado (double lado) {
this.lado = lado;
}
public double area() {
return lado*lado;
}
}
class Circulo implements interFigura{ // Implementa la interface Figura
double radio;
public Circulo (double radio) {
this.radio = radio;
}
public double area() {
return (PI*Math.pow(radio,2));
}
}

class Rectangulo implements interFigura{ // Implementa la interface Figura

double lado;
double altura;
public Rectangulo (double lado, double altura) {
this.lado = lado;
this.altura = altura;
}
public double area()
{ return
lado*altura;
}
}
4.8 Herencia.
La herencia es la base de la reutilización de código. Cuando una clase deriva de una clase padre
esta hereda todos sus atributos y métodos. Normalmente la subclase hereda atributos y
métodos de la superclase y los amplía.

VEHICULO

COCHE MOTO CAMIÓN

La clase coche, moto y camión heredan de la clase vehículo sus atributos y métodos.

Para indicar que una clase hereda de otra se utiliza la sentencia extends detrás del nombre de
la clase.

Ejemplo:

public class vehiculo {

: : : :
}
public class coche extends vehiculo {
: : : :
}

public class moto extends vehiculo {

: : : :
}

public class camion extends vehiculo {

: : : :
}

Todas las clases heredan de una clase padre. Si no heredan de clase concreta heredan de la
clase Object.

Ejemplo:

package EjercicioFiguras;
class ejercicioFiguras {
public static void main(String[] args) {
// Figura Cuadrado
cuadrado miCuadrado = new cuadrado(5);
miCuadrado.setColor("Verde");
System.out.println("Color Cuadrado: "+miCuadrado.getColor());
System.out.println("Área Cuadrado: "+miCuadrado.getArea());
System.out.println("****************************************");

// Figura Círculo
circulo miCirculo = new circulo(2.5);
miCirculo.setColor("Azul");
System.out.println("Color Círculo: "+miCirculo.getColor());
System.out.println("Área Círculo: "+miCirculo.getArea());
}
}
class figura
{ String
color;
public void setColor(String s){
color=s;
}
public String getColor(){
return color;
}
}

class circulo extends figura{

double radio;
circulo(double radio){
this.radio = radio;
}
public double getArea(){
return Math.PI*this.radio* this.radio;
}
}

class cuadrado extends figura{

double lado;
cuadrado(double lado){
this.lado = lado;
}
public double getArea()
{ return
this.lado*this.lado;
}
}
Hemos creado una instancia c de la clase cuadrado que hereda los atributos y métodos de la
clase figura.

Al utilizar extends indicamos:

 La clase cuadrado es una subclase de la clase figura.
 La clase cuadrado puede utilizar los métodos de la clase figura.
 Los métodos de la subclase no pueden ser utilizados en la superclase.
 Las clases heredan el comportamiento de la clase padres pero no lo heredan de otras
subclases (hermanos).

PROGRAMACIÓN - CICLO FORMATIVO DAW - TEMA 4. PROGRAMACIÓN ORIENTADA A OBJETOS. CLASES 20