U2 Java

UNIDAD II
CREACIÓN DE CLASES PROPIAS
JAVA INTRODUCCIÓN
Módulo II
Creación de clases propias
Contenido 2
Introducción ........................................................................................................ 3
Desarrollo ........................................................................................................... 4
Clases ................................................................................................... 4
1.1 Definición de Clases: ......................................................................... 4
1.2 Clases múltiples ................................................................................. 8
Argumentos y parámetros ................................................................... 12
2.1 Argumento: ...................................................................................... 12
2.2 Parámetros: ..................................................................................... 12
Constructores ...................................................................................... 13
Constantes en la clase ........................................................................ 15
Variables locales ................................................................................. 18
Llamadas a métodos ........................................................................... 19
6.1 Método principal............................................................................... 21
La palabra reservada this .................................................................... 24
Llamada a métodos con parámetros ................................................... 26
Cosas para recordar ......................................................................................... 28
Organización de clases en paquetes .................................................. 29
Cometarios javadoc.......................................................................................... 31
Clases fraccionadas: la clase fracción ............................................................. 34
Bibliografía ....................................................................................................... 49
Optativa I – Java Introducción

Prof. Adan Morel
Creación de clases propias 3
Fuente: www.desmotivaciones.es
Introducción
Mientras más conocimientos adquiramos, más preguntas sabremos responder.
Y para comprender grandes cosas debemos comenzar por lo esencial. Por
ejemplo las clases que son un elemento fundamental para la Programación
Orientada a Objetos, y hasta ahora hemos usado solo clases estándares. Sin
embargo, debemos aprender cómo escribir programas usando nuestras propias
clases.

Prof. Adan Morel
Para hacerlo es necesario primeramente adentrarnos en las características y
4
componentes que ellas conllevan detalladamente.
En este material se cuenta con las definiciones y sintaxis de cada elemento a

utilizar, los ejemplos sencillos permiten ejercitar la mente para luego ver algunos
un poco más complejos. De esta manera nos iremos preparando para desarrollar
programas seguros, limpios y comprensibles.
Desarrollo
Clases
1.1 Definición de Clases:
Cuenta con una serie de métodos y propiedades que definen el comportamiento

y la forma que posee un objeto. Define las especificaciones formales que
identificaran unas clases de otras.
No es fácil encontrar lugar para estacionar en la gran ciudad. Suponga que

queremos desarrollar un programa para un estacionamiento en el que podamos
asignarles a los automóviles que ingresan alguna forma de número de número
de identificación junto con la información relevante, tal como el nombre del
propietario, y también que el programa pueda calcular por día su nueva cuenta
con descuento incluido y que se sume a la cuenta actual del mes. Entre los
muchos tipos de objetos necesarios para este programa, diseñaremos una clase
central que modele un Automóvil. No existe tal clase Automóvil entre las clases
comunes, por supuesto, así que tenemos que definir una nosotros mismos. Al
usar esta clase solo podemos asignar y recuperar el nombre del propietario.

Prof. Adan Morel
El siguiente programa de ejemplo crea dos objetos Automóvil, les asigna los
5
nombres de los propietarios y muestra la información:
class RegistroAutomovil {
public static void main (String[] args) {
Automovil auto1, auto2;
String pro1,pro 2;
auto1=new Automovil( ); // Crea y asigna valores a auto1
auto1.establecePropietario(“Carlos Lopez”) ;
auto2=new Automovil( ) ; // Crea y asigna valores a auto2
auto2.establecePropietario (“José Amarilla“) ;
//salida de la información
Pro1=auto1.obtenPropietario( ) ;
Pro2=auto2.obtenPropietario( ) ;
System.out.print int(pro1 + “posee un Automovil.”) ;
System.out.print int(pro2 +”también posee un Automovil.”)

Prof. Adan Morel
6
class Automovil {
//Miembro de datos
Prívate String Propietario ;
//Constructor:inicia el miembro de datos
public Automovil ( ) {
Propietario = “Desconocido” ;}
//Devuelve el nombre del propietario de la bicicleta
Public String obtenPropietario ( ) {
Return Propietario ;}
//Asigna el nombre del propietrario de la bicicleta
public void establecePropietario(String ) {
Propietario =nom;
Para distinguir de las clases estándares, llamamos a Automóvil y a otras clases

que definimos como Clases definidas por el programador.
El diagrama de dependencia entre las dos clases es como sigue:
RegistroAutomov Automóvil

Prof. Adan Morel
Cuando se ejecuta este programa, obtenemos el siguiente resultado en la
7
ventana de resultados estándar:
Carlos López posee un Automóvil.
José Amarilla también posee un Automóvil.
La declaración de la clase comienza con la palabra reservada class seguida por

el nombre. Cualquier identificador valido que no sea una palabra reservada
puede usarse como el nombre de clase.
► Convención de listado de clase:
class <nombre de clase> {
//miembros de datos
//constructor
//métodos
Definimos los tres métodos dentro de la declaración de clase.
Miembros de datos de una clase: son los valores de datos asociados con la
clase o las instancias de la clase.
<lista-modificadores> <tipo de datos> <nombre>;
Constructor: es un método especial que se ejecuta cuando se crea una nueva

instancia de la clase, es decir, cuando se llama a un operador new.

Prof. Adan Morel
Public <nombre de clase> (parámetros) {
8
<Sentencias>
Método: Para que una clase u objeto procese el mensaje que recibe, debe
poseer un método compatible, que es una secuencia de instrucciones que una
clase u objeto sigue para realizar una tarea. Un método definido para una clase
se llama método de clase y un método definido para un objeto es un método de
instancia.
<Modificadores> <tipo de retorno> <nombre del método> (<parámetros>)
{ <Cuerpo del método>}
1.2 Clases múltiples
Escribamos un segundo programa de muestra para obtener mayor práctica en la

definición de clases. En este ejemplo, definiremos una nueva clase llamada
Cuenta. Un objeto Cuenta tiene el nombre del propietario (String) y el Saldo (Int).
Tenemos dos métodos –suma y descuenta- para calcular la cuenta final.

Prof. Adan Morel
Class ProgramaDos {
9
// Este programa de muestra usa ambas clases Automovil y Cuenta
Public static void main (String [] args) {
Automovil auto;
Cuenta cuenta;
String Nombre = “Raul Castro”;
auto = new Automovil ();
auto.establecePropietario (Nombre);
cuenta = new Cuenta ();
cuenta.establecePropietario (Nombre);
cuenta.SaldoInicial (50000);
cuenta.suma (10000);
cuenta.descuenta (1500);
//Presenta alguna información
System.out.println (auto.obtenPropietario ()+ “posee un Automovil

y”);
System.out.println (“tiene Gs.”+ cuenta.obtenSaldoActual ()+”en su

cuenta”);

Prof. Adan Morel
Este programa crea un objeto Automóvil y un objeto Cuenta fija el nombre de sus
10
propietarios como Raúl Castro, inicia el saldo de la cuenta en Gs. 50000, suma
Gs. 10000 a la cuenta, descuenta Gs. 1500 de la cuenta y, por último, imprime
alguna información de los objetos Automóvil y Cuenta. El diagrama del programa
es como sigue:
Automóvil
ProgramaDos
Cuenta
Ya hemos desarrollado y visto la clase RegristroAutomovil, Automóvil y

ProgramaDos. Usamos la clase Automóvil sin modificación, así que solo
debemos considerar la definición de la clase Cuenta. Hay dos miembros de datos
para la clase, uno para almacenar el nombre del propietario y otro para mantener
el saldo de la cuenta. Los métodos establece y obtén para l nombre del
propietario son idénticos a aquellos definidos para la clase Automóvil. Los
métodos suma y descuenta modifican el saldo al sumar y restar. Los métodos
SaldoInicial y obtenSaldoActual se definen en forma similar a los otros métodos
establece y obtén.

Prof. Adan Morel
Esta sería la definición completa de la clase Cuenta:
11
Class Cuenta {
//Miembros de datos
private String Propietario;
private int saldo;
//constructor
public Cuenta ( ) {
Propietario = “Desconocido”;
saldo = 0;
}
//Suma la cuenta del dia
public void suma (int monto) {
saldo= saldo+monto;
}
//Realiza el descuento
public void descuenta (int monto) {
desc= (monto*15)/100;
monto=monto-desc;
saldo= saldo-monto;
}
//Devuelve el saldo actual de esta cuenta
public int obtenSaldoActual ( ) {
return saldo;
}
//Devuelve el nombre del propietario de esta cuenta
public String obtenPropietario () {
return Propietario;
}
//Establece el saldo inicial de esta cuenta
public void SaldoInicial (int cantidad) {
saldo= cantidad;
}
//Asigna el nombre del propietario de esta cuenta
public void establecePropietario (String nom) {
Propietario = nom;
}
}

Prof. Adan Morel
Se deben de compilar todas las clases antes de ejecutar el programa. Sin
12
embargo, no se deben de compilar las tres clases cada vez que queramos
ejecutar el programa. Por ejemplo si la clase Automóvil ya está compilada y no
se le han hecho cambios, entonces no hay necesidad de volver a compilarla.
Argumentos y parámetros
2.1 Argumento:
Es un valor que nosotros pasamos a un método y el valor se asigna a los

parámetros correspondientes.
2.2 Parámetros:
Es un marcador de posición en el método llamado para mantener el valor de un

argumento pasado.
► Los argumentos y parámetros coinciden en el orden de izquierda a

derecha. Siempre que el tipo de datos de un argumento sea compatible
en la asignación con el parámetro correspondiente, la llamada es válida.
Puesto que un parámetro es parecido es parecido a un marcador de
posición que no mantendrá un valor hasta que se pase un argumento, al
parámetro se le llama parámetro formal y al argumento, un parámetro real.
Considere la siguiente clase de ejemplo que incluye un método llamado calcula.

Este método tiene tres parámetros: dos int y un double.

Prof. Adan Morel
class Demo {
13
…
public void calcular (int i, int j, double x) {
// cuerpo del método
// las sentencias reales en el cuerpo son
//irrelevantes
}
…
}
Cuando llamamos al método calcula, debemos pasar tres valores. Los valores
que pasamos deben ser compatibles en la asignación con los parámetros
correspondientes.
Por ejemplo, no está bien pasar un valor double a un parámetro int.
Constructores
► Constructor: es un método especial que se ejecuta cuando se crea una

nueva instancia de la clase, es decir, cuando se llama a un operador
new(nuevo).
Sintaxis:
public <nombre de clase> (parámetros) {
<Sentencias>

Prof. Adan Morel
Este es el constructor para la clase Automóvil:
14
public Automovil() {
Propietario =”Desconocido”;
El siguiente diagrama muestra como los componentes de la sintaxis general

correspondiente a los elementos reales en el constructor de la clase Automóvil:
Nombre de clase
Modificador Parametros
public Automovil ( ){
Propietario = “Unassigned”; } Sentencias
Nota que un constructor no tiene un tipo return (devolución) y, en consecuencia

nunca incluirá una sentencia return.
El propósito del constructor Automóvil es iniciar el miembro de datos en un valor

que refleje el estado al que no se ha asignado todavía el nombre real. Puesto
que un constructor se ejecuta cuando se crea una nueva instancia, es el lugar
más lógico para iniciar los miembros de datos y desarrollar cualquier otra tarea
de inicio.
Es posible definir más de un constructor a una clase. Los constructores múltiples

se llaman Constructores sobrecargados. Casi siempre es buena idea definir
constructores múltiples a una clase.

Prof. Adan Morel
Un Constructor por omisión es un constructor que no acepta argumentos y no
15
tiene sentencias en su cuerpo, esto significa que el compilador de Java en forma
automática incluirá un constructor por omisión.
Los constructores que definimos hasta ahora no aceptan argumentos.
Para tener un ejemplo de constructores con uno o más argumentos, veamos esta
parte de la clase Cuenta en donde definiremos un constructor con dos
parámetros, que acepte el nombre del propietario y active el saldo inicial al
mismo tiempo de la creación del objeto.
public Cuenta (String nom, int iniciaSaldo) {
propietario= nom;
saldo= iniciaSaldo;
Constantes en la clase
Para recordar, usamos una constante cuando queremos “bloquear” el valor

asignado de manera que no pueda ocurrir cambio alguno. Cuando declaramos
una constante en la clase esta constante la comparten todos los métodos que
hay en ella.
Veamos este ejemplo, suponga que inicializamos como constante de la clase la

variable “pi” de modo que automáticamente se hagan los cálculos de Longitud y
Área de la circunferencia de un círculo.

Prof. Adan Morel
public class Datos {
16
private static final double pi= 3.14159265359;
private double radio=5;
public Longitud(){
Longitud=2*pi*radio;
public Area(){
Area= pi*(radio*radio);
public double obtenLog(){
return Longitud;
public double obtenArea(){
return Area;
DEPENDENCIA

Prof. Adan Morel
17
public class Circunferencia {
public static void main(String[] args) {
Datos resulLog, resulArea;
resulLog= new Datos();
resulArea= new Datos();
resulLog.Longitud();
resulArea.Area();
System.out.printl("Los resultados son: " +resulLog.obtenLongitud()+"

"+resulArea.obtenArea());
La constante “pi” de la clase se declara como:
private static final double pi= 3.14159265359;

Prof. Adan Morel
El modificador final designa que el identificador “pi” es una constante y el
18
modificador static designa que es una constante de la clase. La palabra
reservada static se usa para declarar componentes de clase, así como variables
de clase y métodos de clase.
Variables locales
Las variables locales son variables temporales que se declaran dentro de la

declaración de método. Su uso dará por resultado un código mucho más limpio.
El espacio en la memoria para estas variables y para los parámetros se asigna
a partir de la declaración y al principio del método, respectivamente, y se borra
cuando se sale de ese método.
public void descuenta (int public void descuenta (int

monto){ Utilizando monto){
una
cuenta= cuenta-monto; int cuentaNueva;
variable
} local. }
Cuando declare una variable local, asegúrese de que el identificador que use no
entre en conflicto con los miembros de datos de una clase. Veamos el siguiente
ejemplo:

Prof. Adan Morel
Class Datos { 19
private int x;
…
public void calcula () {
int x;
x=5;
}
…
}
La declaración de clase no es un error. Se usa el mismo identificador tanto para

la variable local como para la variable de instancia. Esto cambia el valor de la
variable local, no de la variable de instancia. Es aceptable pero no aconsejable.
Llamadas a métodos
Recordemos, para que una clase u objeto procese el mensaje que recibe, debe
poseer un método compatible, que es una secuencia de instrucciones que una
clase u objeto sigue para realizar una tarea. En su sintaxis tiene una lista de
parámetros que es opcional, después del nombre del método y siempre entre
paréntesis puede aparecer esta lista (también llamados argumentos) separados
por comas. Estos parámetros son los datos de entrada que recibe el método para
operar con ellos. Un método puede recibir cero o más argumentos. Se debe
especificar para cada argumento su tipo. Los paréntesis son obligatorios aunque
estén vacíos.
Existen los métodos de instancia que están definidos para un objeto, y los
métodos de clase que están definidos para una clase.

Prof. Adan Morel
Hasta ahora siempre que llamamos a un método del mismo objeto, usamos la
20
notación punto. Así como podemos llamar a un método de otro objeto, es posible
llamar a un método desde un método del mismo objeto.
Esta es la diferencia entre llamar otro método del mismo objeto y llamar un
método de un objeto diferente.
Clase A Clase B
Public void ejemplo () { Public void calculo () {
Clase B objeto= new Clase B(); ….}
Objeto.calculo(); Public void ejemplo() {
} calculo();
}
La notación punto es La notación punto es

necesaria cuando se llama opcional cuando llama a un
a un método de otro objeto. método del mismo objeto.

Prof. Adan Morel
6.1 Método principal 21
Sabemos que los métodos en Java pueden tener cualquier nombre (excluido el
de palabras clave). Existe un nombre de método que está reservado en Java y
otros lenguajes: el método main. Este método es un método especial en tanto en
cuanto es el que da lugar al inicio del programa. Si comparamos un programa
con un partido de fútbol, el método main sería el responsable de poner el partido
en juego.
Imagen proveída por el docente
Es importante tener claro que el orientada a objetos, se desarrolla

método main no es el elemento mediante la interacción entre
principal en el desarrollo del objetos, que en la figura hemos
programa. El programa, de acuerdo representado como jugadores en el
con el paradigma de programación campo de fútbol. Por tanto el

Prof. Adan Morel
cometido del método main será porque lo estamos utilizando
22
normalmente es iniciar el programa con fines didácticos. En programas
(poner el balón en juego) y profesionales esto no debe ocurrir.
permanecer en un segundo plano
El método main es indudablemente
mientras los objetos interactúan
importante. Por eso y por motivos
entre sí, controlando el desarrollo de
históricos en el desarrollo de la
la situación como si del árbitro se
programación muchas veces se
tratara. El método main normalmente
alude a él (o a la clase donde se
no será muy extenso en cuanto a
sitúa) como clase principal o
líneas de código respecto al resto del
“programa” principal. Pero hay que
código (clases).
tener bien claro que su carácter
Si esto ocurriera, posiblemente sería principal se debe a que es quien
indicador de que este método tiene inicia el desarrollo del programa, no
más protagonismo del que debe, y a que sea quien debe asumir el
en nuestro símil el árbitro no debe protagonismo del mismo.1
ser protagonista del partido. En
En lugar de definir una clase
algunos ejemplos de código que
principal por separado como lo
desarrollemos quizás la clase con el
hicimos para la Clase Automóvil
método main contenga gran parte
anteriormente, es posible convertir
del código total, pero si esto es así
también esta clase como principal.
1 www.aprenderaprogramar.com

Prof. Adan Morel
Class Automovil {
23
prívate String Propietario;
public String obtenPropietario () {
return Propietario;
public void establecePropietario (String nom) {
propietario=nom;
//Metodo principal que muestra un ejemplo de uso de la clase Automovil
public static void main (String [] args) {
Automovil miAuto;
miAuto = new Automovil();
miAuto.estableceProoietario (“Raul Castro ”);
system.out.printl(miAuto.obtenPropietario()+”Posee un Automovil”);

Prof. Adan Morel
Ventajas
24
1- Tenemos una clase menos que manejar si no hay que definir una clase
principal por separado.
“Esta ventaja parece no ser muy sustancial, pero cuando escribimos numerosas
clases el escribir una clase principal por separado a todas aquellas clases de
manera que se conviertan ejecutables, se hace tedioso”.
2- Cuando desarrollamos clases reutilizables (como datos y cuenta) para

otros programadores, con frecuencia se puede incluir un ejemplo sencillo
de cómo usar las clases.
“En lugar de proporcionar una sencilla clase principal por separado, es más
conveniente añadir el método principal a estas clases”.
La palabra reservada this
La palabra reservada this se conoce como apuntador con referencia a si

mismo porque se usa para referirse al objeto receptor de un mensaje desde
dentro del método de este objeto; es decir, this se refiere al objeto actual sobre
el que está actuando un método determinado y se utiliza siempre que se quiera
hace referencia al objeto actual de la clase.
public class calculo {
int x;
public calculo() {
x = 5;

Prof. Adan Morel
public calculo( int vale ) {
25
this.x = vale;
public calculo( int x) {
this.x= x;
public void multiplica( int y ) {
x = x + y;
En este ejemplo x está refiriéndose a x en la clase cálculo, correspondiente al

objeto actual. Cuando se utiliza this en el tercer constructor, se refiere
directamente al objeto en sí, no permite que el ámbito actual defina la resolución
de variables, utilizando x como parámetro formal y luego this para acceder a la
variable de instancia del objeto actual.
Se
refiere al Se refiere
miembro this.x = x; al
de parámetro.
datos.

Prof. Adan Morel
Llamada a métodos con parámetros 26
► Paso de parámetros en llamada por valor
Proporcionaremos una cobertura más detallada de cómo se pasan los

argumentos a un método. Primero revisemos algunos hechos claves. Las
variables locales se usan con propósitos temporales, tales como el
almacenamiento de los resultados intermedios de un cálculo. Mientras que los
miembros de datos de una clase son accesibles desde todos los métodos de
instancia de la clase, las variables y los parámetros locales son accesibles solo
desde el método en donde se declararon y solo están disponibles mientras se
ejecuta el método. El espacio en la memoria para variables y parámetros locales
se asigna, respectivamente, una vez hecha la declaración y al inicio del método,
y se borra al salirse de él.
Cuando se llama a un método, se pasa el valor del argumento al parámetro que

concuerde y se asigna un espacio aparte en la memoria para almacenar este
valor. Esta forma de pasar el valor de los argumentos se llama esquema de
paso por valor o esquema de llamada por valor. Puesto que el espacio aparte
en la memoria se asigna para cada parámetro durante la ejecución del método,
el parámetro es local al método y, por lo tanto, los cambios hechos al parámetro
no afectaran el valor del argumento correspondiente.
Considere el siguiente método miMetodo de la clase Prueba. El método no hace

nada significativo. Lo usamos aquí para ilustrar cómo funciona el esquema de
llamada por valor:
class Prueba {
public void miMetodo (int uno, double dos) {

uno =25;
dos =35.4:

Prof. Adan Morel
}
27
}
¿Cuál será el resultado del siguiente código?
Prueba prueba;
Int x, y;
prueba = new Prueba ();
x =10;
y =20;
prueba.miMetodo (x, y);
System.out.println (x + “ “+y);
El resultado será:
10 20
Porque con el esquema de paso por valor, los valores de los argumentos se
pasan a los parámetros, pero los cambios hechos a los parámetros no se pasan
de regreso a los argumentos.
Los argumentos concuerdan con los parámetros en orden de izquierda a

derecha; esto es, el valor del argumento del extremo izquierdo se pasa al
parámetro del extremo izquierdo, el siguiente valor del argumento del extremo

Prof. Adan Morel
izquierda, se pasa al siguiente valor del parámetro y así sucesivamente. El
28
número del argumento en la llamada del método debe concordar con el número
de parámetro en la definición del método. Por ejemplo, ninguna de las llamadas
a miMetodo desde la clase prueba es válida porque el número del argumentos y
el número de parámetros no concuerdan.
prueba .miMetodo ( 12 ) ;
prueba .miMetodo ( x, y, 24.5) ;
Puesto que estamos asignando el valor de un argumento al parámetro

respectivo, el tipo de datos de un argumento debe ser compatible con el tipo de
datos del parámetro correspondiente. Por ejemplo, podemos pasar un
argumento entero a un parámetro float, pero no al revés. En los siguientes, la
primera llamada es válida pero la segunda no lo es:
prueba .miMetodo ( 12, 25 );
prueba .miMetodo ( 23. 0, 34.5 );
El nombre del parámetro y el del argumento pueden ser el mismo. Sin embargo,
recuerde que los valores de los argumentos aún se pasa a un método a través
del esquema paso por valor; esto es, se hacen las copias locales tanto si el
argumento y el parámetro comparte el mismo nombre como si no.
Cosas para recordar

Recuerde estos puntos clave acerca de argumentos y parámetros:
1. Los argumentos se pasan aún método al usar el esquema de paso por

valor.

Prof. Adan Morel
2. Los argumentos concuerdan con los parámetros de izquierda a derecha.
29
El tipo de datos de un argumento debe ser compatible en la tarea con el
tipo de datos del parámetro respectivo.
3. El número de llamadas del método debe concordar con el número de
parámetros en la definición del método.
4. Parámetros y argumentos no tienen que tener el mismo nombre.
5. Las copias locales, que son distintas de los argumentos, se crean aun
cuando los parámetros y los argumentos compartan el mismo nombre.
6. Los parámetros son entradas a un método y son locales al método. Los
cambios hechos a los parámetros no afectarán el valor de los argumentos
correspondientes.
Organización de clases en paquetes
Por simplicidad hemos colocado todas las clases de un programa definidas por
el programador en la misma carpeta. Este enfoque funciona bien mientras se
aprende programación y no se trata con muchas clases. Pero en un contexto de
la vida real, hay que manejar las clases de manera más efectiva.
El enfoque correcto para reutilizar las clases definidas por el programador es

organizarlas en paquetes, de la misma manera que las clases estándar también
se organizan en paquetes. Ilustramos el proceso al usar la clase Fracción.
Nombremos miutil al paquete que contendrá la clase Fracción. Es una
convención en Java nombrar al paquete con letras minúsculas. Una vez que este
paquete este configurado en forma correcta, podemos usar las clases del
paquete al importarlo, así como hicimos con los paquetes estándares.

Prof. Adan Morel
Import miutil.*;
30
Class MiCliente {
Fraccion f1;
…
}
Con el fin de configurar los paquetes definidos por el programador para su

reutilización general, y no solo para su uso por los programas en la misma
carpeta, hay que llevar a cabo las siguientes tareas:
1. Incluir la sentencia
Package miutil;
Como la primera sentencia del archivo fuente para la clase Fracción.
2. La declaración de la clase debe incluir el modificador de visibilidad public

como
Public class Fraccion {
…
}
3. Crear una carpeta llamada miutil, que es el mismo nombre que el nombre
del paquete. En Java, el paquete debe tener una correspondencia de uno
a uno con la carpeta.
4. Colocar la clase Fracción modificada dentro de la carpeta miutil y

compilarla.

Prof. Adan Morel
5. Modificar la variable de ambiente CLASSPATH para incluir la carpeta que
31
contiene la carpeta miutil.
El quinto paso es el más problemático para aquellos que apenas conocen Java.
Puesto que los pasos exactos para cambiar la variable de ambiente
CLASSPATH son diferentes en cada plataforma (Windows, Unix, Mac) y Java
IDE (Eclipse, Netbeans, jGRASP, BlueJ, etc.), aquí solo describiremos la idea
general para la plataforma Windows. Suponga que tenemos una carpeta llamada
JavaPrograms en la unidad C: y que el paquete (carpeta) miutil está colocado
dentro de esta carpeta JavaPrograms. Entonces, para usar las clases en el
paquete miutil, el ambiente classpath debería hacer referencia a la carpeta
JavaPrograms (no al paquete miutil en si):
set classpath = . ;c:\JavaPrograms
El punto después del símbolo de igual se refiere a la carpeta actual (la carpeta
en donde se ubica el programa del cliente que intentamos ejecutar). Sin esta
referencia a la carpeta actual, el programa del cliente no reconocerá otras clases
en la misma carpeta.
Cometarios javadoc
Existen tres estilos de comentarios en Java. Hemos usado dos de ellos. Le
presentamos el tercer estilo llamado comentarios javadoc en esta sección.
Muchas de las clases definidas por el programa que diseñamos son para el uso
de otros programadores. Es, por lo tanto, muy importante proporcionar la
documentación significativas de los programadores cliente de manera que
puedan encender cómo usar nuestras clases de manera correcta. Al añadir
comentarios javadoc a las clases que diseñemos, podemos proporcionar un
estilo de documentación de clases. Una vez que los comentarios javadoc estén

Prof. Adan Morel
añadidos a la clase, podemos usar un programa especial (viene como parte de
32
Java 2 SDK) para generar archivos HTML para la documentación.
Los comentarios javadoc comienzan con el marcador /** y terminan con el

marcador */. Los asteriscos en las líneas entre el primer y último marcador no
tienen importancia; están ahí para proporcionar una ayuda visual para realzar
los comentarios del programa. Usar los asteriscos de esta manera para los
comentarios javadoc es una regla aceptada.
Dentro de los comentarios javadoc, podemos usar varias etiquetas javadoc, es

decir, marcadores especiales que empiecen con la marca @.
La etiqueta @autor, una etiqueta javadoc, la cual usamos para listar los autores
de la clase.
/**
*Una instancia de esta clase representa una fraccion.
*
*@autor Dr. Caffeine
*
*/
Class Fraccion {
…
}
Aquí presentamos como comentar un miembro de datos en Javadoc:
/**
*La parte del numerador de esta fracción
*/
Prívate int numerador;

Prof. Adan Morel
Cuando la longitud de un comentario es poca y cabe en una sola línea, entonces
33
podemos escribir el comentario Javadoc como:
/**La parte del numerador de esta fracción */

Prívate int numerador;
El comentario Javadoc para un método es similar al del comentario de

encabezado de la clase. Incluirá una serie de etiquetas javadoc además de una
descripción general. Aquí se presenta un ejemplo:
/**
*Devuelve la suma de esta fracción
*y el parametro frac. La suma
*devuelta no esta simplificada.
*
*@param frac la Fraccion para sumarla a esta Fraccion
*
*@return la suma de this y frac
*/
Public Fraccion suma (Fraccion frac) {
…..
}
El propósito del comentario encabezado del método es grabar el propósito del

método, la lista de los parámetros pasados al método y el valor devuelto del
método.

Prof. Adan Morel
Este método recibe un parámetro recibe un parámetro, así que hay una etiqueta
34
@param. Adjuntamos una breve descripción del parámetro además del nombre
del parámetro. La sintaxis es:
@param <nombre del parametro> <descripción>
La parte de <descripción> puede ocupar más de una línea. Como este método
devuelve un valor, nosotros añadimos la etiqueta @return. Su sintaxis:
@return <descripcion>
Clases fraccionadas: la clase fracción

En esta sección presentamos un ejemplo de clases fraccionadas, en donde
utilizamos todo lo que hemos aprendido hasta ahora. Se trata de un programa
de cálculo que puede realizar la resta y suma de dos fracciones. La explicación
necesaria se halla en los comentarios.
//-------------------------------------------------------------------------------------------------
//MIEMBROS DE DATOS
//-------------------------------------------------------------------------------------------------
package miutil;
/**

Prof. Adan Morel
*Una instancia de esta clase representa una fracción.
35
*/
public class Fraccion {
/**El numerador de esta fracción*/
private int numerador;
/**El denominador de esta fracción */
private int denominador;
//-------------------------------------------------------------------------------------------------
//CONSTRUCTORES
//-------------------------------------------------------------------------------------------------
/**
*Crea una fracción 0/1
*/
public Fraccion () {
this(0,1);
/**

Prof. Adan Morel
*Crea una fracción numero/1
36
*@param numero el numerador
*/
public Fraccion (int numero) {
this (numero, 1);
/**
*crea una copia de frac
*@param frac se crea una copia de este parametro
*/
public Fraccion (Fraccion frac) {
this (frac.obtenNumerador(), fra.obtenDenominador);
/**
*Crea una fracción num/denom. Crea una fracción
*negativa como –num y denom. Si se especifican
*valores negativos tanto para num como para denom, la fracción
*se convierte en positiva. Si num es positivo y

Prof. Adan Morel
*denom es negativo, la fracción se convertirá para
37
*tener un num negativo y un denom positivo.
*Cuando num es cero, denom se configura en 1. Cero
*siempre se representa como 0/1
*@param num el numerador
*@param denom el denominador
*/
public Fraccion (int num, int denom) {
if (denom<0){
num=-num;
denom=-denom;
if (num==0){
denom =1;
obtenNumerador(num);
obtenDenominador(denom);

Prof. Adan Morel
//-------------------------------------------------------------------------------------------------------
38
//METODOS DE CLASE
//-------------------------------------------------------------------------------------------------------
/**
*Devuelve el máximo común divisor de
*los parámetros m y n
*@param m el primer numero
*@param n el segundo numero
*@return el máximo común divisor de my n
*/
public static int mcd (int m, int n){
int r= n%m;
MCD
while (r!=o) {
n=m;
m=r;
r=n%m;
return m;

Prof. Adan Morel
*Devuelve el menor de los dos parámetros f1 y f2
39
*@param f1 la primera fracción a comparar
*@param f2 la segunda fracción a comparar
*@return el menor de los dos parámetros
*/
public static Fraccion min (Fraccion f1, Fraccion f2) {
//convierte a decimal y luego compara

MIN
double f1_dec= f1.decimal();
double f2_dec= f2.decimal();
if (f1_dec <= f2_dec) {
return f1;
} else {
return f2;

Prof. Adan Morel
//-------------------------------------------------------------------------------------------------------
40
//METODOS PUBLICOS DE INSTANCIA
//-------------------------------------------------------------------------------------------------------
/**
*Devuelve la suma de esta fracción
*y el parámetro frac. La suma
*@param frac la Fraccion para añadir a esta
* Fracción
*@return la suma de this y frac
*/
public Fraccion suma (Fraccion frac) {
int a, b, c, d; SUMA
Fraccion adicion;
a= this.obtenNumerador();
b= this.obtenDenominador();
c= frac.obtenNumerador();
d= frac.obtenDenominador();

Prof. Adan Morel
adicion= new Fraccion (a*d+b*c, b*d);
41
return adicion;
/**
*Devuelve la suma de esta fraccion
*y el parametro int. La suma
*@param numero el entero para añadir a esta
* fracción
*@return la suma de esta Fraccion y el numero
*/
SUMA
public Fraccion suma (int numero) {
Fraccion frac = new Fraccion (numero, 1);
Fraccion adicion = suma (frac);
return adicion;

Prof. Adan Morel
public boolean equals (Fraccion frac) {
42
Fraccion f1= simplifica(); //simplifica por si mismo EQUALS

Fraccion f2= frac.simplifica(); //simplifica frac
return (f1.obtenNumerador() ==f2.obtenNumerador() &&
F1.obtenDenominador() == f2.obtenDenominador());
/**Devuelve el denominador de esta fracción
* @return el denominador de esta fracción
*/
public int obtenDenominador() { OBTEN

return denominador;
DENOMINADOR
}
/**Devuelve el numerador de esta fracción
* @return el numerador de esta fracción
*/

Prof. Adan Morel
43
public int obtenNumerador() { OBTEN
return numerador; NUMERADOR

}
/**
*Asigna el denominador de esta fracción
* @param denom el denominador de esta fracción
*/
public void asignaDenominador (int denom) {

ASIGNA
if (denom==0) {
DENOMINADOR
// error fatal
System.out.println(“Error fatal”);
System.exit(1);
denominador= denom;

Prof. Adan Morel
/**
44
*Asigna el numerador de esta fracción
* @param num el numerador de esta fracción
*/
public void asignaNumerador (int num) { ASIGNA
numerador=num; NUMERADOR
}
/**
*Devuelve un Nuevo objeto Fraccion que está en
*su forma más simple de este objeto Fraccion. Si
*esta Fraccion es cero, entonces se devuelve una
*copia simple.
*@return un objeto Fraccion en su forma más simple
* de esta fracción
*/

Prof. Adan Morel
public Fraccion simplifica () {
45
SIMPLIFICA
int num=obtenNumerador();
int denom=obtenDenominador();
int divisor =1;
if (num!=0) {
divisor= mcd(Math.abs(num), denom);
return new Fraccion (num/divisor, denom/divisor);
/**
*Devuelve la diferencia de esta fracción
*y el parámetro frac. La diferencia
*@param frac la Fraccion para restarla a esta
* fracción
*@return la diferencia de this y frac
*/

Prof. Adan Morel
public Fraccion resta (Fraccion frac) {
46
int a, b, c, d; RESTA
Fraccion diferencia;
a= this.obtenNumerador();
b= this.obtenDenominador();
c= frac.obtenNumerador();
d= frac.obtenDenominador();
diferencia= new Fraccion (a*d-b*c, b*d);
return diferencia;
/**
*Devuelve la diferencia de esta fraccion
*y el parametro int. La diferencia
*@param numero el entero para restar
*@return la diferencia de esta Fraccion y el numero

Prof. Adan Morel
*/
47
public Fraccion resta (int numero) {
Fraccion frac = new Fraccion (numero, 1);

RESTA
Fraccion diferencia = resta (frac);
return diferencia;
/**
*Devuelve la representacion String de esta Fraccion
*@return la representación String de esta Fraccion
*/
public String aString () {
return obatenNumerador() + “/” + obtenDenominador (); aString

}

Prof. Adan Morel
//-------------------------------------------------------------------------------------------------------
48
//METODOS PRIVATE
//-------------------------------------------------------------------------------------------------------
//**
*Devuelve el equivalente decimal de esta fracción
*@return el equivalente decimal de esta fracción
*/
private double decimal () {
//devuelve el equivalente decimal DECIMAL

return (double) obtenNumerador() / obtenDenominador();

Prof. Adan Morel
Bibliografía 49
► Deitel, H., & Deitel, P. (2004). Como Programar Java. Mexico: Prentice
Hall.
► Holzner, S. (2000). LA BIBLIA DE JAVA 2. MADRID: ANAYA

MULTIMEDIA.
► Wu, C. T. (2001). Programación en Java. Madrid: MCGRAW-HILL.

Prof. Adan Morel

U2 Java

Cargado por

Copyright:

Formatos disponibles

U2 Java

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

U2 Java

Cargado por

Copyright:

Formatos disponibles

UNIDAD II

CREACIÓN DE CLASES PROPIAS

1.1 Definición de Clases: ......................................................................... 4

1.2 Clases múltiples ................................................................................. 8

Argumentos y parámetros ................................................................... 12

2.1 Argumento: ...................................................................................... 12

2.2 Parámetros: ..................................................................................... 12

Constantes en la clase ........................................................................ 15

Variables locales ................................................................................. 18

Llamadas a métodos ........................................................................... 19

6.1 Método principal............................................................................... 21

La palabra reservada this .................................................................... 24

Llamada a métodos con parámetros ................................................... 26

Cosas para recordar ......................................................................................... 28

Organización de clases en paquetes .................................................. 29

Clases fraccionadas: la clase fracción ............................................................. 34

Optativa I – Java Introducción

Optativa I – Java Introducción

En este material se cuenta con las definiciones y sintaxis de cada elemento a

1.1 Definición de Clases:

Cuenta con una serie de métodos y propiedades que definen el comportamiento

No es fácil encontrar lugar para estacionar en la gran ciudad. Suponga que

Optativa I – Java Introducción

public static void main (String[] args) {

Automovil auto1, auto2;

auto1=new Automovil( ); // Crea y asigna valores a auto1

auto2=new Automovil( ) ; // Crea y asigna valores a auto2

auto2.establecePropietario (“José Amarilla“) ;

System.out.print int(pro1 + “posee un Automovil.”) ;

System.out.print int(pro2 +”también posee un Automovil.”)

Optativa I – Java Introducción

Prívate String Propietario ;

//Constructor:inicia el miembro de datos

//Devuelve el nombre del propietario de la bicicleta

Public String obtenPropietario ( ) {

//Asigna el nombre del propietrario de la bicicleta

public void establecePropietario(String ) {

Para distinguir de las clases estándares, llamamos a Automóvil y a otras clases

El diagrama de dependencia entre las dos clases es como sigue:

Optativa I – Java Introducción

Carlos López posee un Automóvil.

José Amarilla también posee un Automóvil.

La declaración de la clase comienza con la palabra reservada class seguida por

► Convención de listado de clase:

class <nombre de clase> {

Definimos los tres métodos dentro de la declaración de clase.

<lista-modificadores> <tipo de datos> <nombre>;

Constructor: es un método especial que se ejecuta cuando se crea una nueva

Optativa I – Java Introducción

<Modificadores> <tipo de retorno> <nombre del método> (<parámetros>)

{ <Cuerpo del método>}

1.2 Clases múltiples

Escribamos un segundo programa de muestra para obtener mayor práctica en la

Optativa I – Java Introducción

Public static void main (String [] args) {

String Nombre = “Raul Castro”;

auto = new Automovil ();

cuenta = new Cuenta ();