Clases y Objetos

CLASES Y PROGRAMACION ORIENTADO A
OBJETOS
Cuando se escribe un programa en un lenguaje orientado a

objetos, definimos una plantilla o clase que describe las
características y el comportamiento de un conjunto de objetos
similares. La clase automóvil describe las características
comunes de todos los automóviles: sus atributos y su
comportamiento (fig. 4.1). Los atributos o propiedades se
refieren a la marca o fabricante, el color, las dimensiones,
si tienen dos, tres, cuatro o más puertas, la potencia, si
utiliza como combustible la gasolina o gasoil, etc. El
comportamiento se refiere a la posibilidad de desplazarse por
una carretera, frenar, acelerar, cambiar de marcha, girar,
etc.
Luego, tenemos automóviles concretos, por ejemplo el
automóvil propio de una determinada marca, color, potencia,
etc, el automóvil del vecino de otra marca, de otro color,
etc, el automóvil de un amigo, etc.
Una clase es por tanto una plantilla implementada en software
que describe un conjunto de objetos con atributos y
comportamiento similares.
Una instancia u objeto de una clase es una representación
concreta y específica de una clase y que reside en la memoria
del ordenador.
PROGRAMACION CON JAVA 2 1

Figura Error! No text of specified style in document..1 Clases y objetos
1.1. ATRIBUTOS
Los atributos son las características individuales que
diferencian un objeto de otro y determinan su
apariencia, estado u otras cualidades. Los atributos se
guardan en variables denominadas de instancia, y cada
objeto particular puede tener valores distintos para
estas variables.
Las variables de instancia también denominados miembros

dato, son declaradas en la clase pero sus valores son
fijados y cambiados en el objeto.
Además de las variables de instancia hay variables de

clase, las cuales se aplican a la clase y a todas sus
instancias. Por ejemplo, el número de ruedas de un
automóvil es el mismo cuatro, para todos los
automóviles.
1.2. COMPORTAMIENTO
El comportamiento de los objetos de una clase se
implementa mediante funciones miembro o métodos. Un

método es un conjunto de instrucciones que realizan una
determinada tarea y son similares a las funciones de
los lenguajes estructurados.
Del mismo modo que hay variables de instancia y de

clase, también hay métodos de instancia y de clase. En
el primer caso, un objeto llama a un método para
realizar una determinada tarea, en el segundo, el método
se llama desde la propia clase.
1.3. UNA CLASE EN JAVA

Para crear una clase se utiliza la palabra reservada
class y a continuación el nombre de la clase. La
definición de la clase se pone entre las llaves de
apertura y cierre. El nombre de la clase empieza con
una letra mayúscula.
class NombreClase{
//miembros dato o datos miembro
//funciones miembro
1.3.1. LOS MIEMBROS DATO

Los valores de los atributos se guardan en los
miembros dato o variables de instancia. Los
nombres de dichas variables comienzan por letra
minúscula.
Vamos a crear una clase denominada Rectangulo,

que describa las características comunes a
estas figuras planas que son las siguientes:
 El origen del rectángulo: el origen o

posición de la esquina superior izquierda
del rectángulo en el plano determinado por
dos números enteros x e y.
 Las dimensiones del rectángulo: ancho y

alto, otros dos números enteros.

class Rectangulo
{
int x;
int y;
int ancho;
int alto;
//faltan las funciones miembro
}
1.3.2. LAS FUNCIONES MIEMBRO

En el lenguaje Java las funciones miembro o
métodos se definen y se llaman.
El nombre de las funciones miembro o métodos

comienza por letra minúscula y deben sugerir
acciones (mover, calcular, etc.). La
definición de una función tiene el siguiente
formato:
[modificador] tipo nombreFuncion(tipo parm1,

tipo parm2, tipo parm3, . . .)
{ declaraciones de variables locales;
//...sentencias
[return[(]expresión[)]];
Entre las llaves de apertura y cierre se coloca

la definición de la función, tipo indica el
tipo de dato que puede ser predefinido int,

double, etc, o definido por el usuario, una
clase cualquiera.
Un modificador es una palabra clave que

modifica el nivel de protección predeterminado
del método o función miembro (este tema se
analizará más adelante).
Para llamar a una función miembro o método se

escribe
retorno=objeto.nombreFuncion (arg1, arg2, arg3);
Cuando se llama a la función, los argumentos

arg1, arg2, arg3 se copian en los parámetros
parm1, parm2, parm3 y se ejecutan las
sentencias dentro de la función. La función
finaliza cuando se llega al final de su bloque
de definición o cuando encuentra una sentencia
return.
Cuando se llama a la función, el valor devuelto

mediante la sentencia return se asigna a la
variable retorno.
Cuando una función no devuelve nada se dice que

es de tipo void. Para llamar a la función, se
escribe
objeto.nombreFuncion (arg1, arg2, arg3);
Una función suele finalizar cuando llega al

final del bloque de su definición
void funcion(....)
{
//sentencias...
}
Una función puede finalizar antes del llegar

al final de su definición

void funcion(....)
{
//sentencias...
if(condicion) return;
//sentencias..
}
Una función puede devolver un valor (un tipo

de dato primitivo o un objeto).
double funcion(....)
{
double suma=0.0;
//sentencias...
return suma;
}
Cualquier variable declarada dentro de la

función tiene una vida temporal, existiendo en
memoria, mientras la función esté activa. Se
trata de variables locales a la función. Por
ejemplo:
void nombreFuncion(int parm){

//...
int i=5;
//...
}
La variable parm, existe desde el comienzo

hasta el final de la función. La variable local
i, existe desde el punto de su declaración
hasta el final del bloque de la función.
Se ha de tener en cuenta que las funciones

miembro tienen acceso a los miembros dato, por
tanto, es importante en el diseño de una clase
decidir qué variables son miembros dato, qué
variables son locales a las funciones miembro,
y qué valores les pasamos a dichas funciones.
Hemos definido los atributos o miembros dato

de la clase Rectangulo, ahora le vamos añadir
un comportamiento: los objetos de la clase
Rectangulo o rectángulos sabrán calcular su

área, tendrán capacidad para trasladarse a otro
punto del plano, sabrán si contienen en su
interior un punto determinado del plano.
La función que calcula el área realizará la

siguiente tarea, calculará el producto del
ancho por el alto del rectángulo y devolverá
el resultado. La función devuelve un entero es
por tanto, de tipo int. No es necesario pasarle
datos ya que tiene acceso a los miembros dato
ancho y alto que guardan la anchura y la altura
de un rectángulo concreto.
class Rectangulo{
int x;
int y;
int ancho;
int alto;
int calcularArea(){
return (ancho*alto);
}
}
A la función que desplaza el rectángulo

horizontalmente en dx, y verticalmente en dy,
le pasamos dichos desplazamientos, y a partir
de estos datos actualizará los valores que
guardan sus miembros dato x e y. La función no
devuelve nada es de tipo void.
class Rectangulo{
int x;
int y;
int ancho;
int alto;
void desplazar(int dx, int dy){
x+=dx;
y+=dy;
}
}
La función que determina si un punto está o no

en el interior del rectángulo, devolverá true
si el punto se encuentra en el interior del
rectángulo y devolverá false si no se
encuentra, es decir, será una función del tipo

boolean. La función necesitará conocer las
coordenadas de dicho punto. Para que un punto
de coordenadas x1 e y1 esté dentro de un
rectángulo cuyo origen es x e y, y cuyas
dimensiones son ancho y alto, se deberá cumplir
a la vez cuatro condiciones
x1>x y a la vez x1<x+ancho
También se debe cumplir
y1>y y a la vez y1<y+alto
Como se tienen que cumplir las cuatro

condiciones a la vez, se unen mediante el
operador lógico AND simbolizado por &&.
class Rectangulo
{
int x;
int y;
int ancho;
int alto;
boolean estaDentro(int x1, int y1)

{
if((x1>x)&&(x1<x+ancho)&&(y1>y)&&(y1<y+ ancho))
{
return true;
}
return false;
}
}
En el lenguaje Java, si la primera condición

es falsa no se evalúan las restantes
expresiones ya que el resultado es false. Ahora
bien, si la primera es verdadera true, se pasa
a evaluar la segunda, si ésta el falsa el
resultado es false, y así sucesivamente.

1.3.3. LOS CONSTRUCTORES
Un objeto de una clase se crea llamando a una
función especial denominada constructor de la
clase. El constructor se llama de forma
automática cuando se crea un objeto, para
situarlo en memoria e inicializar los miembros
dato declarados en la clase. El constructor
tiene el mismo nombre que la clase. Lo
específico del constructor es que no tiene tipo
de retorno.
class Rectangulo{
int x;
int y;
int ancho;
int alto;
Rectangulo(int x1, int y1, int w, int h){
x=x1;
y=y1;
ancho=w;
alto=h;
}
}
El constructor recibe cuatro números que

guardan los parámetros x1, y1, w y h, y con
ellos inicializa los miembros dato x, y, ancho
y alto.
Una clase puede tener más de un constructor.

Por ejemplo, el siguiente constructor crea un
rectángulo cuyo origen está en el punto (0, 0).
class Rectangulo{
int x;
int y;
int ancho;
int alto;
Rectangulo(int w, int h){
x=0;
y=0;
ancho=w;
alto=h;
}
}

Este constructor crea un rectángulo de
dimensiones nulas situado en el punto (0, 0),
class Rectangulo{
int x;
int y;
int ancho;
int alto;
Rectangulo(){
x=0;
y=0;
ancho=0;
alto=0;
}
}
Con estas porciones de código definimos la

clase, y la guardamos en un archivo que tenga
el mismo nombre que la clase Rectangulo y con
extensión .java.
public class Rectangulo
{
int x;
int y;
int ancho;
int alto;
public Rectangulo()
{
x=0;
y=0;
ancho=0;
alto=0;
}
public Rectangulo(int x1, int y1, int w, int h)

{
x=x1;
y=y1;
ancho=w;
alto=h;
}
public Rectangulo(int w, int h)

{
x=0;
y=0;
ancho=w;
alto=h;
}

int calcularArea()
{
}
void desplazar(int dx, int dy)

{
x+=dx;
y+=dy;
}

{
if((x1>x)&&(x1<x+ancho)&&(y1>y)&&(y1<y+ancho))
{
return true;
}
return false;
}
1.4. LOS OBJETOS

Para crear un objeto de una clase se usa la palabra
reservada new.
Por ejemplo,
Rectangulo rect1=new Rectangulo(10, 20, 40, 80);
new reserva espacio en memoria para los miembros dato y

devuelve una referencia que se guarda en la variable
rect1 del tipo Rectangulo que denominamos ahora objeto.
Dicha sentencia, crea un objeto denominado rect1 de la
clase Rectangulo llamando al segundo constructor en el
listado. El rectángulo estará situado en el punto de
coordenadas x=10, y=20; tendrá una anchura de ancho=40
y una altura de alto=80.
Rectangulo rect2=new Rectangulo(40, 80);
Crea un objeto denominado rect2 de la clase Rectangulo

llamando al tercer constructor, dicho rectángulo estará
situado en el punto de coordenadas x=0, y=0; y tendrá
una anchura de ancho=40 y una altura de alto=80.
Rectangulo rect3=new Rectangulo();

Crea un objeto denominado rect3 de la clase Rectangulo
llamando al primer constructor, dicho rectángulo estará
situado en el punto de coordenadas x=0, y=0; y tendrá
una anchura de ancho=0 y una altura de alto=0.
1.4.1. ACCESO A LOS MIEMBROS

Desde un objeto se puede acceder a los miembros
mediante la siguiente sintaxis
objeto.miembro;
Por ejemplo, podemos acceder al miembro dato

ancho, para cambiar la anchura de un objeto
rectángulo.
rect1.ancho=100;
El rectángulo rect1 que tenía inicialmente una

anchura de 40, mediante esta sentencia se la
cambiamos a 100.
Desde un objeto llamamos a las funciones

miembro para realizar una determinada tarea.
Por ejemplo, desde el rectángulo rect1 llamamos
a la función calcularArea para calcular el área
de dicho rectángulo.
rect1.calcularArea();
La función miembro area devuelve un entero, que

guardaremos en una variable entera medidaArea,
para luego usar este dato.
int medidaArea=rect1.calcularArea();
System.out.println("El área del rectángulo es

"+medidaArea);
Para desplazar el rectángulo rect2, 10 unidades

hacia la derecha y 20 hacia abajo, escribiremos
rect2.desplazar(10, 20);
Podemos verificar mediante el siguiente código

si el punto (20, 30) está en el interior del
rectángulo rect1.

if(rect1.estaDentro(20,30))
{
System.out.println("El punto está dentro del
rectángulo");
}else
{
System.out.println("El punto está fuera del
rectángulo");
}
rect1.dentro() devuelve true si el punto (20,

30) que se le pasa a dicha función miembro está
en el interior del rectángulo rect1,
ejecutándose la primera sentencia, en caso
contrario se ejecuta la segunda.
Como veremos más adelante no siempre es posible

acceder a los miembros, si establecemos
controles de acceso a los mismos.
public class RectanguloApp1
{
public static void main(String[] args)
{
System.out.println("El área del rectángulo es
"+medidaArea);
{
System.out.println("El punto está dentro del
rectángulo");
}
else
{
System.out.println("El punto está fuera del
rectángulo");
}
}//fin main
}

1.5. LA VIDA DE UN OBJETO
En el lenguaje C++, los objetos que se crean con new se
han de eliminar con delete, new reserva espacio en
memoria para el objeto y delete libera dicha memoria.
En el lenguaje Java no es necesario liberar la memoria
reservada, el recolector de basura (garbage collector)
se encarga de hacerlo por nosotros, liberando al
programador de una de las tareas que más quebraderos de
cabeza le producen, olvidarse de liberar la memoria
reservada.
Veamos un ejemplo
public class UnaClase

{
{
Image granImagen=creaImagen();
mostrar(graImagen);
while(condicion)
{
calcular();
}
}
}
El objeto granImagen, continua en memoria hasta que se

alcanza el final de la función main, aunque solamente
es necesario hasta el bucle while. En C o en C++
eliminariamos dicho objeto liberando la memoria que
ocupa mediante delete. El equivalente en Java es el de
asignar al objeto granImagen el valor null.
public class UnaClase

{
{
Image granImagen=creaImagen();
mostrar(graImagen);
granImagen=null;
while(condicion)
{
calcular();
}
}
}

A partir de la sentencia marcada en letra negrita el
recolector de basura se encargará de liberar la memoria
ocupada por dicha imagen. Así pues, se asignará el valor
null a las referencias a objetos temporales que ocupen
mucha memoria tan pronto como no sean necesarios.
Creamos dos objetos de la clase rectángulo, del mismo

modo que en el apartado anterior
Si escribimos
rect3=rect1;
En rect3 se guarda la referencia al objeto rect1. La

referencia al objeto rect3 se pierde. El recolector se
encarga de liberar el espacio en memoria ocupado por el
objeto rect3.
La destrucción de un objeto es una tarea (thread) de

baja prioridad que lleva a cabo la Máquina Virtual Java
(JVM). Por tanto, nunca podemos saber cuando se va a
destruir un objeto.
Puede haber situaciones en las que es necesario realizar

ciertas operaciones que no puede realizar el recolector
de basura (garbage collector) cuando se destruye un
objeto. Por ejemplo, se han abierto varios archivos
durante la vida de un objeto, y se desea que los archivos
estén cerrados cuando dicho objeto desaparece. Se puede
definir en la clase un método denominado finalize que
realice esta tarea. Este método es llamado por el
recolector de basura inmediatamente antes de que el
objeto sea destruido.
Ejemplo (1): Manejo de la clase rectángulo.

//archivo Rectangulo.java
public class Rectangulo
{
int x;
int y;
int ancho;
int alto;

public Rectangulo()
{
x=0;
y=0;
ancho=0;
alto=0;
}
public Rectangulo(int x1, int y1, int w, int h)
{
x=x1;
y=y1;
ancho=w;
alto=h;
}
public Rectangulo(int w, int h)

{
x=0;
y=0;
ancho=w;
alto=h;
}
int calcularArea()
{
}
void desplazar(int dx, int dy)

{
x+=dx;
y+=dy;
}

{
if((x1>x)&&(x1<x+ancho)&&(y1>y)&&(y1<y+ancho))
{
return true;
}
return false;
}
__________________________________
//archivo: RectanguloApp1.java
public class RectanguloApp1

{
{

System.out.println("El area del rectangulo 1 es
"+medidaArea);
System.out.println("Las nuevas coordenadas del rectangulo

2 es: ");
System.out.println("x= "+ rect2.x+" y="+rect2.y);
{
System.out.println("El punto (20,30) esta dentro del
rectangulo 1");
}
else
{
System.out.println("El punto (20,30) esta fuera del
rectangulo 1");
}
}//fin main
}
1.6. IDENTIFICADORES
Cómo se escriben los nombres de las variables, de las
clases, de las funciones, etc., es un asunto muy
importante de cara a la comprensión y el mantenimiento
de código. En la introducción a los fundamentos del
lenguaje Java hemos tratado ya de los identificadores.
El código debe de ser tanto más fácil de leer y de

entender como sea posible. Alguien que lea el código,
incluso después de cierto tiempo, debe ser capaz de
entender lo que hace a primera vista, aunque los
detalles internos, es decir, cómo lo hace, precise un
estudio detallado.
Vemos primero un ejemplo que muestra un código poco

legible y por tanto, muy difícil de mantener

public class Cuen
{
private int ba;
public void dep(int i)
{
ba+=i;
}
public void ret(int i)
{
ba-=i;
}
public int get()
{
return ba;
}
}
Las abreviaciones empleadas solamente tienen

significado para el programador en el momento de
escribir el código, ya que puede olvidarse de su
significado con el tiempo. Otros programadores del grupo
tienen que descifrar el significado del nombre de cada
variable o de cada función. El tiempo extra que se gasta
en escribir con claridad el nombre de los diversos
elementos que entran en el programa, se ahorra más
adelante durante su desarrollo, depuración, y mejora,
es decir, durante todo el ciclo de vida del programa.
public class CuentaBancaria

{
private int balance;
public void depositar(int cantidad)
{
balance+=cantidad;
}
public void retirar(int cantidad)
{
balance-=cantidad;
}
public int obtenerBalance()
{
return balance;
}
}

1.7. MODIFICADORES DE ACCESO A LOS MIEMBROS
DE UNA CLASE
Una faceta importante de los lenguajes de Programación
Orientada a Objetos se denomina encapsulación. El acceso
a los miembros de una clase está controlado. Para usar
una clase, solamente necesitamos saber que funciones
miembro se pueden llamar y a qué datos podemos acceder,
no necesitamos saber como está hecha la clase, como son
sus detalles internos. Una vez que la clase está
depurada y probada, la clase es como una caja negra.
Los objetos de dicha clase guardan unos datos, y están
caracterizados por una determinada conducta. Este
ocultamiento de la información niega a las entidades
exteriores el acceso a los miembros privados (private)
de un objeto. De este modo, las entidades exteriores
acceden a los datos de una manera controlada a través
de algunas funciones miembro. Para acceder a un miembro
público (public), sea dato o función basta escribir:
objeto_de_la_clase.miembro_público_no_estático
clase.miembro_público_estático
La segunda representación se ampliará cuando veamos

miembros dato estático y métodos estático.
1.7.1. MIEMBROS PÚBLICOS

Los miembros públicos son aquellos que tienen
delante la palabra public, y se puede acceder
a ellos sin ninguna restricción.
1.7.2. MIEMBROS PRIVADOS

Los miembros privados son aquellos que tienen
delante la palabra private, y se puede acceder
a ellos solamente dentro del ámbito de la
clase.
1.7.3. POR DEFECTO (A NIVEL DE PAQUETE)

Cuando no se pone ningún modificador de acceso
delante de los miembros, se dice que son
accesibles dentro del mismo paquete (package).

Esto es lo que hemos utilizado en algunos de
los ejemplos estudiados antes.
package es la primera sentencia que se pone en

un archivo .java. El nombre del paquete es el
mismo que el nombre del subdirectorio que
contiene los archivos .java. Cada archivo .java
contiene habitualmente una clase. Si tiene más
de una solamente una de ellas es pública. El
nombre de dicha clase coincide con el nombre
del archivo. El uso de paquetes se estudiará
más adelante.
Como se habrá dado cuenta hay una correspondencia entre

archivos y clases, entre paquetes y subdirectorios. El
Entorno Integrado de Desarrollo (IDE) en el que creamos
los programas facilita esta tarea sin que el usuario se
aperciba de ello.
Ejemplo (2): Uso de los modificadores de acceso package
//archivo: Linea.java
import java.io.*;
class Linea
{
//coordenada 1er punto, modificador de acceso:package
int x1,y1;
//coordenada 2do punto, modificador de acceso:package
int x2,y2;
void leer() //modificador de acceso:package

{
try
{
// Definir un flujo de caracteres de entrada: flujoE
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader flujoE = new BufferedReader(isr);
String sdato; // variable para almacenar una línea de texto
//lectura
System.out.println("Introduzca 1er punto: ");
System.out.print("x1: ");
sdato = flujoE.readLine(); // leer una línea de texto
x1=Integer.parseInt(sdato);//convierte cadena
System.out.print("y1: ");
y1=Integer.parseInt(sdato);//convierte cadena

System.out.println("Introduzca 2do punto: ");
}
catch (IOException ignorada)
{}
}
void escribir() //modificador de acceso:package

{
System.out.println("Puntos de la recta : ");
System.out.println("x1="+x1+" y1="+y1);
}
// Archivo LineaAppl.java
import java.io.*;
class LineaAppl
{
public static void main (String[] args)
{
//Creación de un objeto recta: r1
Linea r1=new Linea();
// uso del objeto r1
//como el modificador de acceso es package

//y la clase Linea esta en el mismo directorio
//entonces main() puede utilizar los métodos
//leer() y escribir()
r1.leer();
r1.escribir();
}
}

Ejemplo (3): Uso del modificador de acceso privado
(private). El siguiente programa es similar al anterior
salvo que los métodos de la clase Linea son private.
//archivo: Linea1.java
import java.io.*;
class Linea1
{
//coordenada 1er punto, modificador de acceso:package
int x1,y1;
//coordenada 2do punto, modificador de acceso:package
int x2,y2;
private void leer() //modificador de acceso:privado

{
try
{
//lectura


}
{}
}
private void escribir() //modificador de acceso:privado

{
}
// Archivo Linea1Appl.java
import java.io.*;
class Linea1Appl
{
{
Linea1 r1=new Linea1();
//como el modificador de acceso de los metodos

//de la clase Linea es privado
//entonces main() no puede utilizar los métodos
r1.leer();
r1.escribir();
}
}
NOTA: Este programa no ejecuta porque el compilador

protesta mostrando el siguiente mensaje:
\Linea1Appl.java:18: leer() has private access in Linea1

r1.leer();
^
\Linea1Appl.java:19: escribir() has private access in Linea1
r1.escribir();
^
2 errors

Ejemplo (4): Uso del modificador private y public.
Notese como la función main(), puede acceder a los
métodos públicos de la clase Linea2.
import java.io.*;
class Linea2
{
//coordenada 1er punto, modificador de acceso:privado
private int x1,y1;
//coordenada 2do punto, modificador de acceso:privado
private int x2,y2;
//los datos miembro solo seran accedidos por su métodos
//por ser privados
public void leer() //modificador de acceso:público

{
try
{
//lectura

}
{}
}
public void escribir() //modificador de acceso:público

{
}

import java.io.*;
class Linea2Appl
{
{
//como el modificador de acceso de los métodos

//de la clase Linea es public
//entonces main() puede utilizar los métodos
r1.leer();
r1.escribir();
}
}
Ejemplo (5) Uso del modificador public. Notese como la

función main(), puede acceder a los datos y métodos
públicos.
import java.io.*;
class Linea3
{
//coordenada 1er punto, modificador de acceso:público
public int x1,y1;

//coordenada 2do punto, modificador de acceso:público
public int x2,y2;
//los datos miembro solo seran accedidos por su métodos
//por ser privados
public void leer() //modificador de acceso:público

{
try
{
//lectura

}
{}
}
public void escribir() //modificador de acceso:público

{
}
}
import java.io.*;
class Linea3Appl
{
{
//como el modificador de acceso de los datos

//entonces main() puede accesar a los datos
//sin necesidad de utilizar sus métodos
System.out.println("Valores inciales de la recta:");
r1.x1=10;r1.y1=11;
r1.x2=100;r1.y2=101;
System.out.println("x1="+r1.x1+" y1="+r1.y1);
System.out.println("x2="+r1.x2+" y2="+r1.y2);
//como el modificador de acceso de los métodos
//entonces main() puede accesar a
//leer() y escribir(), para modificar sus datos
//miembro
System.out.println("Valores para modificar la recta:");
r1.leer();
r1.escribir();
}
}
1.8. EJEMPLOS DEL USO DE CLASES

Ejemplo (6): Realice un programa que maneje la clase
tiempo. Esta clase debe tener las siguientes
características:
 La clase tiene los datos miembro hora, min , seg;

los cuales guardan las horas, minutos y segundos
respectivamente.
 Los métodos (funciones miembro) a implementar son:

void leer_tiempo() : que asigna valores a hora, min ,
seg. (2 PTOS)
void escribir_tiempo() : Permite visualizar el valor de

hora, min , seg (2 PTOS)
tiempo tiempo_transcurrido(tiempo nuevotiempo) :

retorna un objeto de la clase tiempo, que contiene el
tiempo transcurrido con respecto al parámetro recibido
(4 PTOS).
 La clase que contiene al método principal main(),

debe manipular estos métodos. (2 PTOS)
//archivo tiempo.java
import java.io.*;
class tiempo
{ //hora minutos y segundos
private int hora,min,seg;
public void leer_tiempo() throws IOException

{ // Definir un flujo de caracteres de entrada: flujoE
System.out.print("hora (0-23): ");

hora=Integer.parseInt(sdato);//convierte cadena
System.out.print("minutos (0-59): ");

min=Integer.parseInt(sdato);//convierte cadena
System.out.print("segundos (0-59): ");

seg=Integer.parseInt(sdato);//convierte cadena
}
public void escribir_tiempo()

{ System.out.println(hora+":"+min+":"+seg);
}
public tiempo tiempo_transcurrido(tiempo nt)

//se recibe el tiempo nuevo
{ int tseg=0;//guarda los segundos del tiempo anterior
int ntseg=0;//guarda los segundos del tiempo nuevo
int transeg;//guarda los segundos del tiempo transcurrido

tiempo dif=new tiempo();
//convertir los tiempos a seg
//con el tiempo anterior

tseg=tseg+hora*3600;tseg=tseg+min*60;tseg=tseg+seg;
//con el tiempo nuevo nt

ntseg=ntseg+nt.hora*3600;ntseg=ntseg+nt.min*60;
ntseg=ntseg+nt.seg;
//hallar los segundos transcurridos

transeg=ntseg-tseg;
//convertir a horas, minutos y segundos

dif.hora=transeg/3600; transeg=transeg%3600;
dif.min=transeg/60;transeg=transeg%60;
dif.seg=transeg;
return dif;
}
}
//archivo: exa2p120032App.java
import java.io.*;
class exa2p120032App
{
throws IOException
{ tiempo t1=new tiempo();tiempo t2=new tiempo();
tiempo trans=new tiempo();
System.out.println("Ingrese tiempo :");
t1.leer_tiempo(); t1.escribir_tiempo();
System.out.println("Ingrese nuevo tiempo :");

t2.leer_tiempo(); t2.escribir_tiempo();
System.out.println("Tiempo transcurrido :");

trans=t1.tiempo_transcurrido(t2);
trans.escribir_tiempo();
}
}

Ejemplo (7): Uso de la clase complejo.
// Archivo: Complejo.java
import java.lang.Math;
class Complejo
{ private float real;
private float imaginario;
Complejo()
{ real=0;
imaginario=0;
}
public void asignar(float r, float i)

{ real=r;
imaginario=i;
}
public void escribir()

{
System.out.println("El complejo es: "+real+" +
"+imaginario+" i");
}
public float absoluto(Complejo c)

{ float va;
va=c.real*c.real+c.imaginario*c.imaginario;
va=(float) Math.sqrt(va);
return va;
}
}
_________________________________________
// Archivo ComplejoAppl.java
import java.io.*;

class ComplejoAppl
{
throws IOException
{
float re,im; //real, imaginario

float valabs;//valor absoluto
//Creación de un objeto complejo: c1

Complejo c1=new Complejo();
//lectura de datos
System.out.print("Introduzca parte real: ");
re=Float.parseFloat(sdato);//convierte cadena a float
System.out.print("Introduzca parte imaginaria: ");
im=Float.parseFloat(sdato);//convierte cadena a float
// uso del objeto c1

c1.asignar(re,im);
c1.escribir();
valabs=c1.absoluto(c1);
System.out.println("El valor absoluto es : "+valabs);
}
}
Ejemplo (8): Clase quebrado
//archivo: quebrado.java
import java.io.*;
class quebrado

{
private int n;//numerador
private int d;//denominador
public void leer()

{
try
{
//lectura
System.out.print("Introduzca numerador: ");
n=Integer.parseInt(sdato);//convierte cadena
System.out.print("Introduzca denominador: ");
d=Integer.parseInt(sdato);//convierte cadena
}
{}
}

{
System.out.print("El quebrado es: ");
if (d!=1)
System.out.println(n+"/"+d);
else
System.out.println(n);
}
public quebrado sumar(quebrado r)

{ quebrado s=new quebrado();
s.n=n*r.d+d*r.n;
s.d=d*r.d;
return(s);
}
public quebrado simplificar(quebrado r)

{ int i;
i=2;
while(i<=r.n && i<=r.d)
{
while(r.n%i==0 && r.d%i==0)
{ r.n=r.n/i;
r.d=r.d/i;
}
i++;
}
return(r);
}
}

//archivo: quebradoAppl.java
public class quebradoAppl

{
{
quebrado q1=new quebrado();
quebrado q2=new quebrado();
quebrado q=new quebrado();
q1.leer();
q1.escribir();
q2.leer();
q2.escribir();
System.out.println("La suma es: ");

q=q1.sumar(q2);
q=q.simplificar(q);
q.escribir();
}//fin main
}
Ejemplo (9): Clase cuenta (Versión 1). Muestra el uso

de las funciones miembro con parámetros, por lo que se
debe pasar valores a estas funciones.
// Archivo: Cuenta.java
import java.lang.Math;
class Cuenta
{ private float saldo;
public void asignar(float s)

{ saldo=s;
}

{ System.out.println("El saldo es: "+saldo);
}
public void deposito(float d)

{ saldo=saldo+d;
}
public void retiro(float r)

{ // no se verifica si el saldo es mayor que el retiro
saldo=saldo-r;
}
}
// Archivo CuentaAppl.java
import java.io.*;
class CuentaAppl
{
throws IOException
{
float sal,dep,ret; //saldo inicial, depósito y retiro
//Creación de un objeto Cuenta: c

Cuenta c=new Cuenta();
//lectura de datos
System.out.print("Introduzca saldo inicial: ");
sal=Float.parseFloat(sdato);//convierte cadena a float
c.asignar(sal);
c.escribir();
System.out.print("Introduzca deposito: ");

dep=Float.parseFloat(sdato);//convierte cadena a float
c.deposito(dep);
c.escribir();
System.out.print("Introduzca retiro: ");

ret=Float.parseFloat(sdato);//convierte cadena a float
c.retiro(ret);
c.escribir();
}
}

de las funciones miembro sin parámetros, por lo que se
debe leer los valores desde la misma función. Observe
el uso de throws IOException en las funciones.
// Archivo: Cuenta1.java
import java.io.*;
class Cuenta1
public void asignar() throws IOException

{

//lectura de datos
saldo=Float.parseFloat(sdato);//convierte cadena a float
}

{
System.out.println("El saldo es: "+saldo);
}
public void deposito() throws IOException

{

float dep;

saldo=saldo+dep;
}
public void retiro() throws IOException

{
float ret;

// no se verifica si el saldo es mayor que el retiro

saldo=saldo-ret;
}
}
// Archivo Cuenta1Appl.java
import java.io.*;
class Cuenta1Appl
{
throws IOException
{
//Creación de un objeto Cuenta1
Cuenta1 c=new Cuenta1();
c.asignar();
c.escribir();
c.deposito();
c.escribir();
c.retiro();
c.escribir();
}
}

de las funciones miembro sin parámetros, por lo que se
debe leer los valores desde la misma función. Observe
el uso de try. . .catch en lugar de throws IOException
en las funciones.
// Archivo: Cuenta2.java
import java.io.*;
class Cuenta2
public void asignar()

{ try
{
String sdato; // variable para almacenar una línea de

//texto
//lectura de datos
saldo=Float.parseFloat(sdato);//convierte cadena a float
}
{}
}

{
System.out.println("El saldo es: "+saldo);
}
public void deposito()

{ try
{

//texto
float dep;

saldo=saldo+dep;
}
{}
}
public void retiro()

{ try
{
//texto
float ret;

// no se verifica si el saldo es mayor que el retiro

saldo=saldo-ret;
}
{}
}
}
// Archivo Cuenta2Appl.java
import java.io.*;
class Cuenta2Appl
{
{
//Creación de un objeto Cuenta2: c
Cuenta2 c=new Cuenta2();
c.asignar();
c.escribir();
c.deposito();
c.escribir();
c.retiro();
c.escribir();
}

}
Ejemplo (12): Clase Conjunto (Versión 1). Muestra el

uso de la funcion miembro union con un parámetro.
Observe el uso de try. . .catch en lugar de throws
IOException en la función leer().
//archivo: Conjunto.java
import java.io.*;
import java.lang.String.*;
class Conjunto
{
private char [] e;//elemento del conjunto
public void leer()

{//la lectura no verifica que existan elementos repetidos
try
{

//lectura
System.out.print("Elementos del conjunto como cadena: ");
//crear un arreglo de caracteres

e=sdato.toCharArray();
}
{}
}

{
System.out.print("Los elementos del Conjunto
son : {");
for(int i=0;i<e.length;i++)
if (i!=e.length)

System.out.print(e[i]+",");
else
System.out.print(e[i]);
System.out.println("}");
}
public Conjunto union(Conjunto c1)

{
int i,j; //contadores
//tam guarda el tamaño de los dos conjuntos
int tam=e.length+c1.e.length;
//conjunto union
Conjunto u=new Conjunto();
//el conjunto union supone que no va a existir
//elementos que puedan repetirse en ambos conjuntos
//inicializa elementos del conjunto union
u.e=new char [tam];
//añade elementos del primer conjunto

for(i=0;i<e.length;i++)
u.e[i]=e[i];
//añade elementos del segundo conjunto

j=i;
for(i=0;i<c1.e.length;i++)
{u.e[j]=c1.e[i];
j++;
}
return u;
}
//archivo: ConjuntoAppl.java
public class ConjuntoAppl

{
{
Conjunto c=new Conjunto();
Conjunto c1=new Conjunto();
Conjunto c2=new Conjunto();
c1.leer();
c1.escribir();
c2.leer();
c2.escribir();
System.out.println("Conjunto union");

c=c1.union(c2);
c.escribir();
}//fin main
}
Ejemplo (13): Clase Conjunto (Versión 2). Muestra el

uso de la funcion miembro union con dos parámetros.
Observe el uso de try. . .catch en lugar de throws
IOException en la función leer().
//archivo: Conjunto1.java
import java.io.*;
import java.lang.String.*;
class Conjunto1
{
private char [] e;//elemento del conjunto
public void leer()

{//la lectura no verifica que existan elementos repetidos
try
{
//lectura
System.out.print("Elementos del conjunto como cadena: ");
//crear un arreglo de caracteres

e=sdato.toCharArray();
}
{}
}

{
System.out.print("Los elementos del Conjunto son : {");

for(int i=0;i<e.length;i++)
if (i!=e.length)
System.out.print(e[i]+",");
else
System.out.print(e[i]);
System.out.println("}");
}
public Conjunto1 union(Conjunto1 c1, Conjunto1 c2)

{
int i,j; //contadores
//tam guarda el tamaño de los dos conjuntos
int tam=c1.e.length+c2.e.length;
//conjunto union
Conjunto1 u=new Conjunto1();
//el conjunto union supone que no va a existir
//elementos que puedan repetirse en ambos conjuntos
//inicializa elementos del conjunto union
u.e=new char [tam];
//añade elementos del primer conjunto

u.e[i]=c1.e[i];
//añade elementos del segundo conjunto

j=i;
{u.e[j]=c2.e[i];
j++;
}
return u;
}
//archivo: Conjunto1Appl.java
public class Conjunto1Appl

{
{
Conjunto1 c=new Conjunto1();
Conjunto1 c1=new Conjunto1();
Conjunto1 c2=new Conjunto1();
c1.leer();
c1.escribir();
c2.leer();
c2.escribir();

System.out.println("Conjunto union");
c=c.union(c1,c2);
c.escribir();
}//fin main
}

Ejemplo (14): Realice un programa que maneje la clase
enterazo. Esta clase permite almacenar los dígitos de
un número en base diez, en cada posición de un arreglo:
 La clase tiene los siguientes datos miembros: valor[

]: arreglo que almacena los dígitos del número.
 Los métodos (funciones miembro) a implementar son:
void asignar(): Define el valor almacenar del dato

miembro. (No usar charToArray()) (2 PTOS)
void mostrar(): Muestra el contenido del dato

miembro. (2 PTOS)
enterazo multiplicar(enterazo numero2): Recibe un

objeto de la clase enterazo y lo multiplica con el
enterazo de la clase actual. Esta función devuelve
un objeto enterazo que contiene la multiplicación
de esos dos números. (4 PTOS)
 La clase que contiene al método principal main(),

debe manipular estos métodos. (2 PTOS)
//archivo enterazo.java
import java.io.*;
class enterazo
{ //arreglo que almacena los dígitos de un número
//consideremos tres cifras
private int[] valor;
public void asignar() throws IOException

{ // Definir un flujo de caracteres de entrada: flujoE
valor= new int[3];
System.out.println("Ingrese cifra por cifra del numero: ");
for (int i=0;i<valor.length;i++)

{
valor[i]=Integer.parseInt(sdato);//convierte cadena
}

}
public void mostrar()

{
for (int i=0;i<valor.length;i++)
System.out.print(valor[i]);
System.out.println("");
}
public enterazo multiplicar(enterazo ent2)

{ int tam=valor.length+ent2.valor.length;
int[]n1=new int[tam];
enterazo mult=new enterazo();

mult.valor= new int[tam];
int in;//contador para 1er, 2do y 3er termino de la suma

int j;//cifra derecha del 1er enterazo
int i;//cifra derecha del 1er enterazo
int aux,acarreo=0;
// Recorre las cifras del segundo número y

// lo almacena en 1er término suma n1[]
in=tam-1;//derecha del 1er término de la suma

j=ent2.valor.length-1;// cifra derecha 2do enterazo
for(i=valor.length-1;i>=0;i--)
{ aux=valor[i]*ent2.valor[j]+acarreo;
n1[in]=aux%10;
acarreo=aux/10;
in--;
}
n1[in]=acarreo;
acarreo=0;
// lo almacena en 2do término suma n2[]
in=tam-2;//derecha del 2do término de la suma
j=ent2.valor.length-2;// cifra 2do enterazo
n2[in]=aux%10;
acarreo=aux/10;
in--;
}
n2[in]=acarreo;
acarreo=0;
// lo almacena en 3er término suma n3[]
in=tam-3;//derecha del 3er término de la suma
j=ent2.valor.length-3;// cifra derecha 2do enterazo

n3[in]=aux%10;
acarreo=aux/10;
in--;
}
n3[in]=acarreo;
acarreo=0;
//suma de los tres términos
for(i=n1.length-1;i>=0;i--)
{ aux=n1[i]+n2[i]+n3[i]+acarreo;
mult.valor[i]=aux%10;
acarreo=aux/10;
}
return mult;
}
}
//archivo: exa2p220032App.java
import java.io.*;
class exa2p220032App
{
throws IOException
{ enterazo e1=new enterazo();enterazo e2=new enterazo();
enterazo em=new enterazo();
e1.asignar();
System.out.println("primer numero: ");e1.mostrar();
e2.asignar();
System.out.println("segundo numero: ");e2.mostrar();
em=e1.multiplicar(e2);
System.out.println("multiplicacion: ");em.mostrar();
}
}

1.9. SOBRECARGA DE UN MÉTODO
Es posible y a menudo deseable crear más de un método
con el mismo nombre, pero con listas de parámetros
distintas. A esto se le llama sobrecarga de método. Se
sobrecarga un método siempre que se crea un método en
una clase que ya tiene un método con el mismo nombre.
Aquí presentamos una versión de la clase quebrado
(ejemplo mostrado antes) que utiliza sobrecarga de
método para sumar 2 y 3 quebrados. A diferencia del
ejemplo con la clase quebrado anterior este no utiliza
un solo parámetro en la suma sino 2 y tres parámetros.
Sugerimos analizar las diferencias.
Ejemplo(15): Sobrecarga del método sumar(...), de la

clase quebrado1.
//archivo: quebrado1.java
import java.io.*;
class quebrado1
{
private int n;//numerador
private int d;//denominador
public void leer()

{
try
{
//lectura
System.out.print("Introduzca numerador: ");
System.out.print("Introduzca denominador: ");
d=Integer.parseInt(sdato);//convierte cadena
}
{}
}

{
System.out.print("El quebrado es: ");
if (d!=1)
System.out.println(n+"/"+d);

else
System.out.println(n);
}
public quebrado1 sumar(quebrado1 r1, quebrado1 r2)

{ quebrado1 r=new quebrado1();
r.n=r1.n*r2.d+r1.d*r2.n;
r.d=r1.d*r2.d;
return(r);
}
public quebrado1 sumar(quebrado1 r1,quebrado1 r2,quebrado1 r3)

{ quebrado1 r=new quebrado1();
r.n=r1.n*r2.d*r3.d+r2.n*r1.d*r3.d+r3.n*r1.d*r2.d;
r.d=r1.d*r2.d*r3.d;
return(r);
}
public quebrado1 simplificar(quebrado1 r)

{ int i;
i=2;
while(i<=r.n && i<=r.d)
{
while(r.n%i==0 && r.d%i==0)
{ r.n=r.n/i;
r.d=r.d/i;
}
i++;
}
return(r);
}

//archivo: quebrado1Appl.java
public class quebrado1Appl

{
{
quebrado1 q1=new quebrado1();
quebrado1 q=new quebrado1();
q1.leer();
q1.escribir();
q2.leer();
q2.escribir();
q3.leer();
q3.escribir();
System.out.println("La suma de los dos primeros es: ");

q=q.sumar(q1,q2);
q=q.simplificar(q);
q.escribir();
System.out.println("La suma de los tres primeros es: ");

q=q.sumar(q1,q2,q3);
q=q.simplificar(q);
q.escribir();
}//fin main
}

1.10. ARREGLO DE OBJETOS
Supongamos que se tiene la clase persona definida de la
siguiente forma:
class Persona
{
private String nombre;
private float sueldo;
public void leer()

{ . . .
}

{ . . .
}
public float obtener_sueldo()

{ . . .
}
}
y se desea utilizar no solamente un objeto persona sino

un conjunto de objetos persona; para lograr este
objetivo, debemos definir un arreglo de objetos de la
siguiente forma:
//declara y crea el arreglo de objetos
Persona[] p=new Persona[5];
La instrucción anterior permite crear un arreglo de

objetos tal como se muestra en la figura:
Persona[0] Persona[1] Persona[2] Persona[3] Persona[4]
Debemos aclarar que cada posición del arreglo tiene los

atributos miembro nombre, sueldo y todos comparten los
métodos de la clase.
El acceso a los miembros del objeto se realiza de la

siguiente manera:

p[i]=new Persona();
p[i].leer();
p[i].escribir();
Ejemplo(16): Uso de la clase persona con arreglos.
//Archivo: Personaa.java
import java.io.*;
class Personaa
{
private String nombre;
private float sueldo;
public void leer()

{
try
{
//lectura
System.out.print("nombre: ");
nombre= flujoE.readLine(); // leer una línea de texto
System.out.print("sueldo: ");
sueldo=Float.parseFloat(sdato);//convierte cadena
}
{}
}

{
System.out.println("Nombre : "+nombre);
System.out.println("Sueldo : "+sueldo);
}
public float obtener_sueldo()

{
return sueldo;
}

//archivo: PersonaaApp.java
import java.io.*;
class PersonaApp
{
throws IOException
{

int n;
//lectura de tamaño del arreglo

System.out.print("# de personas: ");
//declara y crea el arreglo de objetos

Persona[] p=new Persona[n];
//otras variables
int i;//contador
float prom;//promedio de los sueldos
float sueldos=0;//acumulador de los sueldos
//inicializaciòn de objetos
for (i=0;i<p.length;i++)
p[i]=new Persona();
//lectura de datos
System.out.println("Ingrese datos de las personas: ");
p[i].leer();
//Impresión de datos
System.out.println("Datos de las personas: ");
{
System.out.println("Persona No. "+i);
p[i].escribir();
sueldos+=p[i].obtener_sueldo();
}
//Imprime el promedio de los sueldos

prom=sueldos/p.length;
System.out.println("El promedio es: "+prom);
}
}

1.11. VARIABLES DE CLASE (VARIABLE ESTÁTICA)
En nuestra definición de la clase Circulo hemos
declarado 3 variables de instancias (x, y, r). Variable
de instancia significa que cada clase (cada círculo)
tiene su propia copia de esas 3 variables. Pero hay
veces que necesitamos una variable de la cual haya una
sola copia, algo así como una variable global.
El problema es que Java no soporta variables globales

(A modo de comentario, esto no se considera un problema
sino una ventaja). Cada variable en Java debe declararse
dentro de una clase. Así que Java utiliza la palabra
clave static para indicar que una variable particular
es una variable de clase en lugar de una variable de
instancia. Las variables de clase existen
independientemente del número de instancias creadas de
la clase, existen y pueden usarse inclusive si la clase
nunca se inicializó.
Este tipo de variable, declarada con la palabra clave

static se llama a menudo variable estática. Pero es
preferible, y de ahora en adelante lo vamos a hacer así,
llamarlas variables de clase, porque de esta manera es
fácilmente distinguible de su opuesta, variables de
instancia.

Ejemplo: Ejemplo de uso variable estática
public class Circulo2
{
static int numCirculos = 0;
//variable de clase: contador de círculos creados
public double x, y, r;
//variable de instancia: centro y radio del circulo
// Constructores
public Circulo2 (double x, double y, double r)
{
this.x = x;
this.y = y;
this.r = r;
numCirculos++;
}
public Circulo2 (double r)

{
this (0.0, 0.0, r);
}
public Circulo2 (Circulo2 c)

{
this (c.x, c.y, c.r);
}
public Circulo2 ()
{
this (0.0, 0.0, 1.0);
}
//Métodos
public double circunferencia()
{
return 2*3.14159*r;
}
public double area()

{
return 3.14159*r*r;
}
}
1.11.1. ACCEDIENDO A LAS VARIABLES DE CLASE

Ahora que sabemos el número de objetos Circulo
creados, ¿cómo podemos acceder a esa
información? Porque las variables de clase
están asociadas con la clase antes que con una
instancia, accedemos a ellas a través de la
clase. Por lo tanto, debemos escribir:

System.out.println ("Número de círculos creados: " +
Circulo2.numCirculos);
Podemos notar que en uno de los constructores

usamos la variable escribiendo numCirculos, en
lugar de Circulo.numCirculos. Podemos hacer
esto dentro de la definición de la misma clase.
Ejemplo(17): Programa completo de la clase Circulo2
//Archivo Circulo2.java

{
static int numCirculos = 0;
//variable de clase: contador de círculos creados
// Constructores
public Circulo2 (double x, double y, double r)
{
this.x = x;
this.y = y;
this.r = r;
numCirculos++;
}
public Circulo2 (double r)

{
this (0.0, 0.0, r);
}
public Circulo2 (Circulo2 c)

{
this (c.x, c.y, c.r);
}
public Circulo2 ()
{
this (0.0, 0.0, 1.0);
}
//Métodos
public double circunferencia()
{
return 2*3.14159*r;
}
public double area()

{
return 3.14159*r*r;
}
}

// Archivo Circulo2App.java
import java.io.*;
class Circulo2App
{
throws IOException
{
Circulo2 c1=new Circulo2();
System.out.print("Circunferencia del circulo 1: ");
System.out.println(c1.circunferencia());
System.out.print("Area del circulo 1: ");
System.out.println(c1.area());
Circulo2 c2=new Circulo2(2,5,100);

Circulo2 c3=new Circulo2(10);

System.out.print("El numero de circulos creados es: ");

System.out.println( Circulo2.numCirculos);
}
}
1.12. Y LAS VARIABLES GLOBALES ???

Java no soporta variables globales, aunque
Circulo.numCirculos se comporta como si lo fuera. La
diferencia con el lenguaje C es que aquí no hay
posibilidad de conflictos de nombres. Si usamos otra
clase con una variable de clase llamada numCirculos, no

hay colisión porque ambas deben ser referenciadas por
sus nombres de clases.
1.13. CONSTANTES: OTRO EJEMPLO DE VARIABLES DE

CLASE
Intentemos un ejemplo un poco más complicado. Cuando
calculamos el área y la circunferencia usamos el valor
de . Dado que usamos ese valor con frecuencia, no
queremos tipear 3.14159 cada vez que lo usamos, por lo
que podemos ponerlo en una variable.
public class Circulo
{
public static final double PI = 3.14159265358979323846;
// etc...
}
Además del uso de static, el cual ya lo hemos visto, en

el ejemplo usamos la palabra clave final, la cual
significa que la variable no puede cambiar su valor.
Esto previene de hacer una estupidez, como la siguiente:
Circulo.PI = 4;
El compilador Java es hábil respecto de las variables

declaradas static y final, ya que sabe que tienen
valores constantes. Por lo que cuando escribimos código
como el siguiente:
double circunferencia = 2 * Circulo.PI * radio;
el compilador precalcula el valor 2 * Circulo.PI, en

lugar de dejarlo para el intérprete.
1.14. EJEMPLOS DE VARIABLES DE CLASE

Ejemplo(18): Realice un programa que calcule el total
de la compra de 3 libros. Debe tener en cuenta lo
siguiente:
 Utilizar la clase libro que tiene los datos miembro

titulo, autor y precio. Además la clase libro
tiene los métodos: void leer_datos ( ), y void
escribir_total_compra ( ). El método void
leer_datos ( ) permite leer los datos miembros de

los libros y la vez calcula el total de la compra.
El método void escribir_total_compra ( ) permite
escribir el total de la compra para los tres
libros. (5 PTOS)
 Debe utilizar variables de clase (variables

estáticas), las que usted considere conveniente,
para almacenar la cantidad de libros comprados,
así como para calcular el total de la compra.(5
PTOS).
//archivo: Libro.java
import java.io.*;
class Libro
{
//variables de clase
static int cantidad;
static float total=0;
//datos miembro
private String titulo;
private float precio;
//funciones miembro
public void leer_datos()
{
try
{
InputStreamReader isr = new
InputStreamReader(System.in);

texto

//lectura
System.out.print("Introduzca titulo: ");
titulo = flujoE.readLine(); // leer una línea de texto
System.out.print("Introduzca precio: ");
precio=Float.parseFloat(sdato);//convierte cadena
System.out.print("Cantidad de libros a comprar: ");

cantidad=Integer.parseInt(sdato);//convierte cadena
}
{}
total=total+precio*cantidad;
}//fin leer
public void escribir_total_compra()

{
System.out.println("El total de la compra es: "+total);
}//fin escribir_total_compra
// Archivo LibroAppl.java
class LibroAppl
{
{
//Creación de los objetos libro: li1,li2,li3
Libro li1=new Libro();
System.out.println("Ingrese datos del primer libro");
li1.leer_datos();
System.out.println("Ingrese datos del segundo libro");
li2.leer_datos();
System.out.println("Ingrese datos del tercer libro");
li3.leer_datos();
//escribe el total
//puede utilizar cualquiera de los objetos
li1.escribir_total_compra();
}
}

1.15. MÉTODOS DE CLASE (MÉTODOS ESTÁTICOS)
El uso de Math.sqrt(4), permite encontrar la raiz
cuadrada de 4; lo que está pasando aquí es que Math es
el nombre de una clase, sqrt() es el nombre de un método
de clase (método estático) definido en Math, a
diferencia con los métodos de instancia, tales como
area() y circunferencia() en la clase Circulo, que son
los que hemos visto ahora.
Características:
 Los métodos de clase se declaran con la palabra

clave static.
 A los métodos de clase los podemos ver también como

métodos estáticos.
 Los métodos de clase se invocan a través de la

clase en lugar de una instancia (objeto).
 Los métodos de clase son lo más parecido a métodos

globales. Como a ellos se hacen referencia a través
de la clase, no hay peligro de conflicto de
nombres.
1.15.1. SIN THIS

Los métodos de clases difieren de los métodos
de instancias en un punto importante: no pasan
la referencia implícita this. De esta manera,
los métodos sin this no están asociados con
ninguna instancia de la clase y no pueden hacer
referencia a ninguna variable de instancia o
invocar métodos de instancia.
1.15.2. UN MÉTODO DE CLASE PARA Circulo

El siguiente ejemplo, muestra dos definiciones
de un método para nuestra clase Circulo. Una
es un método de instancia y la otra es un método
de clase.
Ejemplo: Un método de clase y un método de

instancia

{
//....
//MÉTODO DE INSTANCIA. DEVUELVE EL MAYOR DE LOS DOS CÍRCULOS
public Circulo3 elMayor (Circulo3 c)
{
if (c.r > r)
return c;
else
return this;
}
//MÉTODO DE CLASE. DEVUELVE EL MAYOR DE LOS DOS CÍRCULOS

public static Circulo3 elMayor (Circulo3 a, Circulo3 b)
{
if (a.r > b.r)
return a;
else
return b;
}
//....
}
Podemos invocar el método de instancia de la

siguiente manera:
Circulo3 a = new Circulo3 (2.0);
Circulo3 b = new Circulo3 (3.0);
Circulo3 c = a.elMayor(b);
y el método de clase así:

Circulo3 a = new Circulo3 (2.0);
Circulo3 b = new Circulo3 (3.0);
Circulo3 d = Circulo3.elMayor(a,b);
Ejemplo(19): Programa completo de la clase Circulo3
//archivo: Circulo3.java

{
private double x, y, r;
// Constructores
Circulo3 (double x, double y, double r)
{ this.x = x; this.y = y; this.r = r;

}
Circulo3 (double r)
{
this (0.0, 0.0, r);
}

{
System.out.println("x= "+x+" y= "+y+" r= "+r);
}
//Métodos:
//MÉTODO DE INSTANCIA. DEVUELVE EL MAYOR DE LOS DOS CÍRCULOS

public Circulo3 elMayor (Circulo3 c)
{
if (c.r > r)
return c;
else
return this;
}
//MÉTODO DE CLASE. DEVUELVE EL MAYOR DE LOS DOS CÍRCULOS

public static Circulo3 elMayor (Circulo3 a, Circulo3 b)
{
if (a.r > b.r)
return a;
else
return b;
}
// Archivo Circulo3App.java
import java.io.*;
class Circulo3App
{
throws IOException
{
Circulo3 a=new Circulo3(50);

System.out.println("primer circulo:");
a.escribir();
Circulo3 b=new Circulo3(100);
System.out.println("segundo circulo:");
b.escribir();
System.out.println("Utilizando el metodo de instancia se

tiene:");
Circulo3 c = a.elMayor(b);

System.out.println("Circulo mayor:");
c.escribir();
System.out.println("Utilizando el metodo de clase se

tiene:");
Circulo3 d = Circulo3.elMayor(a,b);
System.out.println("Circulo mayor:");
c.escribir();
}
}
Ejemplo(20): Programa que utiliza métodos estaticos

para calcular la matriz inversa.
Solución:
La inversa de una matriz dada es otra matriz tal que

multiplicada a la derecha o a la izquierda por la matriz
dada, da la matriz unidad. Veamos como se obtiene la
matriz inversa de una matriz 4 x 4, y luego
generalizaremos para una matriz cuadrada de dimensión
n.
El producto de las dos matrices da lugar a los

siguientes sistemas de cuatro ecuaciones con cuatro
incógnitas. Los términos independientes bij son todos
ceros excepto los de la diagonal principal
b00=b11=b22=b33=1.

Primera columna:
Segunda columna:
Tercera columna
Cuarta columna
Para el cálculo de la matriz inversa, deberemos

transformar la matriz a, los términos independientes b
(cada una de las columnas de la matriz unidad), y
calcular las n2 incógnitas x.
La matriz de los términos independientes b es la matriz

unidad, cuyos elementos son todos cero, excepto los de
la diagonal principal que son unos.
for(int i=0; i<n; i++){

b[i][i]=1.0;
}
El código de la transformación de los elementos de la matriz es el mismo que nos sirvió para calcular el
determinante de una matriz cuadrada. Le añadimos el código de la transformación de los términos
independientes ( a la derecha en las fórmulas que siguen) para cada uno de los cuatro sistemas de ecuaciones
s=0, 1, 2, 3
k=0
k=1
k=2
for(int k=0; k<n-1; k++){

for(int i=k+1; i<n; i++){
//términos independientes
for(int s=0; s<n; s++){
b[i][s]-=a[i][k]*b[k][s]/a[k][k];
}
//elementos de la matriz
for(int j=k+1; j<n; j++){
a[i][j]-=a[i][k]*a[k][j]/a[k][k];
}
}
}
Una vez realizadas las transformaciones, se calcula las

n2 incógnitas x en orden inverso y las guardamos en la
matriz c . Primero, la última incógnita y luego todas
las n-1 restantes. De nuevo, el índice s representa la
columna de la matriz b de los términos independientes,
y de la matriz c de las incógnitas.

for(int s=0; s<n; s++){
c[n-1][s]=b[n-1][s]/a[n-1][n-1];
for(int i=n-2; i>=0; i--){
c[i][s]=b[i][s]/a[i][i];
for(int k=n-1; k>i; k--){
c[i][s]-=a[i][k]*c[k][s]/a[i][i];
}
}
}
Si queremos mantener la matriz original d, hacemos una

copia a de dicha matriz en el cuerpo de la función
inversa y realizamos las operaciones con la matriz copia
dejando la original sin modificar.
double [][] a=d;
El código completo de esta función estática inversa que

halla la matriz inversa de una matriz cuadrada es el
siguiente.
Archivo Matriz.java
class Matriz
{
public static double [][] inversa(double d[][])

{
int n=d.length; //dimensión de la matriz
double [][] a=d; //La matriz a es una copia de d
double [][] b=new double [n][n]; //matriz de los
términos independientes
double [][] c=new double [n][n]; //matriz de las
incógnitas
//matriz unidad
for(int i=0; i<n; i++)
{
b[i][i]=1.0;
}
//transformación de la matriz y de los términos independientes
for(int k=0; k<n-1; k++)
{

for(int i=k+1; i<n; i++)
{
//términos independientes
for(int s=0; s<n; s++)
{
b[i][s]-=a[i][k]*b[k][s]/a[k][k];
}
//elementos de la matriz
for(int j=k+1; j<n; j++)
{
a[i][j]-=a[i][k]*a[k][j]/a[k][k];
}
}
}
//cálculo de las incógnitas, elementos de la matriz inversa
for(int s=0; s<n; s++)
{
c[n-1][s]=b[n-1][s]/a[n-1][n-1];
for(int i=n-2; i>=0; i--)
{
c[i][s]=b[i][s]/a[i][i];
for(int k=n-1; k>i; k--)
{
c[i][s]-=a[i][k]*c[k][s]/a[i][i];
}
}
}
return c;
}
public static void mostrar(double m[][])

{
System.out.println("\n\n");
for (int i=0; i < m.length; i++)

{
for (int j=0; j <m[i].length; j++)
{
System.out.print(m[i][j]+"\t");
}
System.out.println("");
}
System.out.println("\n\n");
Archivo MatrizAppl.java
class MatrizAppl
{

{
double [][] m={{2,1,-3},

{-1,3,2},
{3,1,-3}
};
double [][] m1= new double [3][3];
System.out.println("Matriz original");
Matriz.mostrar(m);
System.out.println("Matriz inversa");
m1=Matriz.inversa(m);
Matriz.mostrar(m1);
1.16. DESTRUCCIÓN DE LOS OBJETOS

Ahora que ya hemos visto como crear y usar objetos, la
pregunta obvia es: ¿cómo destruirlos?. La respuesta es:
no hay que destruirlos. En Java no existe un método
destructor como en C++, acá Java se encarga de la
destrucción de los objetos por nosotros, y nos permite
concentrarnos en otras cosas más importantes, como el
algoritmo en el que estemos trabajando.

1.16.1. EL RECOLECTOR DE BASURA (GARBAGE
COLLECTOR)
La técnica que usa Java para deshacerse de los
objetos una vez que ellos no se necesitan más
es llamada garbage collection. El intérprete
Java conoce qué objetos tiene almacenado.
También puede resolver cuáles variables
refieren a cuáles objetos y cuáles objetos
refieren a otros objetos. De esta manera, puede
resolver cuando un objeto almacenado ya no es
referenciado por ningún objeto ni por ninguna
variable. Cuando encuentra un objeto en esta
situación, el garbage collector sabe que puede
destruirlo, y lo hace. El garbage collector
también puede detectar y destruir ciclos de
objetos que refieren a cada uno, pero que no
son referenciados por ningún otro objeto.
El garbage collector corre en un hilo (thread)

de baja prioridad, y hace la mayoría de su
trabajo cuando no se está ejecutando nada.
Generalmente corre cuando el procesador se
encuentra inactivo, por ejemplo esperando una
entrada por teclado del usuario o un evento con
el mouse. Pero hay un momento en que puede
llegar a correr con alta prioridad, y haciendo
caer un poco al sistema en grandes
aplicaciones, y es cuando el intérprete se
empieza a quedar sin memoria. Cabe aclarar que
esto no ocurre seguido, ya que como el garbage
collector se está ejecutando en un thread de
baja prioridad ya viene recuperando memoria.
Todo este esquema si bien puede parecer algo

pesado y poco económico, podemos asegurar que
no lo es. Un buen garbage collector puede ser
sorprendentemente eficiente.

Clases y Objetos

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Clases y Objetos

Загружено:

Авторское право:

Доступные форматы

CLASES Y PROGRAMACION ORIENTADO A

Cuando se escribe un programa en un lenguaje orientado a

PROGRAMACION CON JAVA 2 1

Las variables de instancia también denominados miembros

Además de las variables de instancia hay variables de

PROGRAMACION CON JAVA 2 2

Del mismo modo que hay variables de instancia y de

1.3. UNA CLASE EN JAVA

//miembros dato o datos miembro

1.3.1. LOS MIEMBROS DATO

Vamos a crear una clase denominada Rectangulo,

 El origen del rectángulo: el origen o

 Las dimensiones del rectángulo: ancho y

PROGRAMACION CON JAVA 2 3

1.3.2. LAS FUNCIONES MIEMBRO

El nombre de las funciones miembro o métodos

[modificador] tipo nombreFuncion(tipo parm1,

{ declaraciones de variables locales;

Entre las llaves de apertura y cierre se coloca

PROGRAMACION CON JAVA 2 4

Un modificador es una palabra clave que

Para llamar a una función miembro o método se

retorno=objeto.nombreFuncion (arg1, arg2, arg3);

Cuando se llama a la función, los argumentos

Cuando se llama a la función, el valor devuelto

Cuando una función no devuelve nada se dice que

objeto.nombreFuncion (arg1, arg2, arg3);

Una función suele finalizar cuando llega al

Una función puede finalizar antes del llegar

PROGRAMACION CON JAVA 2 5

Una función puede devolver un valor (un tipo

Cualquier variable declarada dentro de la

void nombreFuncion(int parm){

La variable parm, existe desde el comienzo

Se ha de tener en cuenta que las funciones

Hemos definido los atributos o miembros dato

PROGRAMACION CON JAVA 2 6

La función que calcula el área realizará la

A la función que desplaza el rectángulo

La función que determina si un punto está o no

PROGRAMACION CON JAVA 2 7

x1>x y a la vez x1<x+ancho

También se debe cumplir

y1>y y a la vez y1<y+alto

Como se tienen que cumplir las cuatro

boolean estaDentro(int x1, int y1)

En el lenguaje Java, si la primera condición

PROGRAMACION CON JAVA 2 8

El constructor recibe cuatro números que

Una clase puede tener más de un constructor.

PROGRAMACION CON JAVA 2 9

Con estas porciones de código definimos la

public Rectangulo(int x1, int y1, int w, int h)

public Rectangulo(int w, int h)

PROGRAMACION CON JAVA 2 10

void desplazar(int dx, int dy)

boolean estaDentro(int x1, int y1)

1.4. LOS OBJETOS

Rectangulo rect1=new Rectangulo(10, 20, 40, 80);

new reserva espacio en memoria para los miembros dato y

Rectangulo rect2=new Rectangulo(40, 80);

Crea un objeto denominado rect2 de la clase Rectangulo

Rectangulo rect3=new Rectangulo();

PROGRAMACION CON JAVA 2 11