10.

Creando nuestras propias clases

10.1 Objetivos
Hemos estudiado como usar las clases existentes de la biblioteca de clases de Java,
ahora estudiaremos como escribir nuestras propias clases.

Notación que se usará en este texto:

* -Significa que puede aparecer 0 o mas veces en la línea donde
aparezca.

<descripción> - Indica que debes sustituir un valor en esta parte.

[] - Indica que esta parte es opcional.

10.2 Definiendo nuestras propias clases

Piensa en un nombre apropiado para el nombre de la clase, y lista toda la información o
propiedades que tu clase contendrá. También lista los métodos que usarás para tu clase.

Para definir una clase, escribimos,

<modificador> class <nombre> {

<declaraciónDeAtributos>*
<declaraciónDelConstructor>*
<declaracionDeMetodos>*
}

Donde <modificador> es un modificador de acceso, el cual puede ser combinado con

otros tipos de modificadores. Recuerde que para una clase de alto nivel, los únicos
modificadores válidos son public y packaged.

Ejemplo para crear la clase de registro de un estudiante:

public class RegistroEstudiante

{
//Adicionaremos mas código aquí
}

Donde ,
public, significa que nuestra clase es accesible desde las otras clases, dentro o fuera del
paquete.
Class, es la palabra clave usada para crear una clase en Java.
RegistroEstudiante, es el identificador único que describe nuestra clase

Notas:
1. Pon un nombre apropiado a tu clase.
2. Empieza los nombres de las clases con una letra MAYÚSCULA.
3. El archivo de tu clase debe tener el MISMO NOMBRE que el que tiene tu clase.
10.3 Declarando Atributos
Para declarar un cierto atributo para nuestra clase, escribimos:
<modificador> <tipo> <nombre> [<=valor_por_defecto>];

Lo siguiente son algunos ejemplos de información que deseamos adicionar a nuestro

registro de estudiante.

Nombre -String
direccion -String
edad -int
nota de matemáticas -double
nota de inglés -double
nota de ciencia -double
promedio -double

10.3.1 Variables Instancia

Adicionemos estas variables a nuestro código:

public class RegistroEstudiante

{
private String nombre;
private String direccion;
private int edad;
private double notaMatematicas;
private double notaIngles;
private double notaCiencias;
private double promedio;
//Adicionaremos más código aquí
}

Donde,
private, significa que las variables sólo son accesibles dentro de la clase. Otros objetos
no pueden acceder a estas variables directamente.

Notas:
1. Declara todas tus variables instancias en la parte de arriba de la declaración de la
clase.
2. Declare una variable por cada línea.
3. Las variables instancia, como cualquier otra variable debe comenzar con una
letra MINÚSCULA.
4. Use un tipo de dato apropiado para cada variable que declares.
5. Declare variables instancia como private para que solo los métodos de la clase
puedan acceder a ellos directamente.
10.3.2 Variables clase o Variables estáticas
Además de las variables instancia, nosotros podemos también declarar variables clase o
variables que pertenecen a la clase como un todo. El valor de estas variables es el
mismo para todos los objetos de la misma clase. Supongamos que queremos conocer el
número total de estudiantes en el registro que tenemos, entonces podemos declarar una
variable estática que contendrá este valor. Llamemos a esta variable
contadorEstudiantes.

Para declarar una variable estática,

public class RegistroEstudiante
{
//aquí están las variables instancia que ya declaramos
private static int contadorEstudiantes;
//Adicionaremos más código aquí
}

Usamos la palabra clave static para indicar que una variable es una variable estática.

Hasta ahora nuestro código luce así:

public class RegistroEstudiante

{
private String nombre;
private String direccion;
private int edad;
private double notaMatematicas;
private double notaIngles;
private double notaCiencias;
private double promedio;

private static int contadorEstudiantes;

//Adicionaremos más código aquí

}

10.4 Declarando Métodos

Veamos la sintaxis para declarar métodos:

<modificador> <tipoDeDatoRetorno> <nombre>(<parametros>*) {

<cuerpo del método>*
}

Donde,
<modificador> puede ser cualquier modificador: public, private, protected, default
<tipoDeDatoRetorno> puede ser cualquier tipo de dato (incluido void)
<nombre> puede ser cualquier identificador válido
<parametros>::= <tipo de dato del parámetro> <nombre del parámetro> [,]
10.4.1 Métodos de acceso
Para poder implementar encapsulación, esto es, no queremos que cualquier objeto
acceda a nuestros datos todo el tiempo, declaramos los campos o atributos de nuestras
clases como privadas (private) Sin embargo hay momentos en que deseamos que otros
objetos accedan a nuestros datos privados. Para hacer esto, creamos los métodos de
acceso.

Los métodos de acceso son usados para leer valores de las variables de la clase (de
instancia y estáticas). Un método de acceso usualmente comienza así:
get<NombreDeLaVariableInstancia>. Y retorna un valor.

Para nuestro ejemplo, queremos métodos de acceso que puedan leer el nombre, la
dirección, las notas de inglés, matemáticas y ciencias del estudiante.

Veamos una implementación de un método de acceso:

public class RegistroEstudiante

{
private String nombre;
::
public String getNombre(){
return nombre;
}
}

Donde,
public, significa que el método puede ser llamado por objetos fuera de la clase.
String, es el tipo de dato que retorna el método.
getNombre, es el nombre del método,
(), significa que nuestro método no tiene parámetros
return nombre, significa que retornará el valor de la variable instancia nombre al
método que la llama. El tipo de dato de la variable debe coincidir con el tipo de dato en
la declaración del método.

10.4.2 Métodos mutadores

Ahora, ¿y si queremos que otros objetos alteren nuestros datos? Lo que hacemos es
proveer métodos que puedan escribir o cambiar valores de nuestras variables
(instancia/estáticas). Nosotros llamamos a estos métodos, métodos mutadores.
Usualmente se escriben así: set<NombreDeLaVariable>.

Veamos una implementación de un método mutador,

public class RegistroEstudiante

{
private String nombre;
::
public void setNombre( String temp ){
nombre = temp;
}
 }
Donde,
public, significa que el método puede ser llamado por otros objetos fuera de la clase
void, significa que el método no retornará ningún valor,
setNombre, el nombre del método,
(String temp), parámetro que será usado en nuestro método
nombre=temp;, asigna el valor de temp a nombre y entonces cambia el dato dentro de la
variable instancia nombre.

Los métodos mutadores no retornan valores. Estos métodos sí contienen argumentos

que pueden ser usados en nuestro método.

10.4.3 Declaraciones de retorno múltiple (ver pdf JEDI)

Dependiendo de algunos condicionales retornan una u otra respuesta.

10.4.4 Métodos estáticos

Para la variable estática contadorEstudiantes, podemos crear un método estático para
acceder a este valor:

public class RegistroEstudiante

{
private static int contadorEstudiantes;
public static int getContadorEstudiantes(){
return contadorEstudiantes;
}
}

Donde,
static, significa que el método es estático y debe ser llamado así:
<NombreDeLaClase>.<nombreDelMétodo>. Por ejemplo, en este caso, podemos llamar
al método así: RegistroEstudiante.getContadorEstudiantes()

Por ahora el valor para contadorEstudiantes siempre va a ser 0, luego cuando veamos
constructores veremos como cambiar dicho valor.

Notas:
1. Los métodos deben comenzar con una letra minúscula.
2. Los nombres de los métodos deben ser verbos.
3. Siempre provee documentación antes de declarar un método.

Ver ejemplo en la página 157 del manual JEDI.

10.5 La referencia this
La referencia this es usada para acceder a las variables instancia ensombrecidas por los
parámetros. Para entender esto veamos un ejemplo. Supongamos que tenemos la
siguiente declaración para cambiar la edad.

public void setEdad( int edad ){

edad = edad; //INCORRECTO!!!
}

El nombre del parámetro en la declaración es edad, el cual es el mismo nombre de la

variable instancia edad. En este caso estamos asignando el valor del parámetro edad a si
mismo! Esto no es lo que queremos que pase en nuestro código. Para corregir este error,
usamos la referencia this. Para usarla, hacemos esto:
This.<nombreDeLaVariableInstancia>
Entonces, podríamos reescribir nuestro código así:

public void setEdad( int edad ){

this.edad = edad;
}
Este método entonces asignará el valor del parámetro edad a la variable instancia edad.

Nota: Solo podemos usar la referencia this para variables instancia y NO para variables
estáticas o clase.

10.6 Métodos sobrecargados

En nuestras clases, nosotros queremos a veces crear métodos que tengan el mismo
nombre pero que funcionen diferente dependiendo de los parámetros que les pasemos.
Esta capacidad es posible en Java, y esto es llamado Método sobrecargado.

Ejemplo. Página160 Jedi.

Siempre recuerda que los métodos sobrecargados tienen las siguientes propiedades:
tienen el mismo nombre, diferentes parámetros, pueden retornar tipos diferentes o el
mismo.

10.7 Declarando constructores

Los constructores son importantes en la instanciación de un objeto. Es un método donde
todas las inicializaciones tienen lugar.

Las siguientes son propiedades de un constructor:

1. Los constructores tienen el mismo nombre de la clase.
2. Un constructor es como un método ordinario, sin embargo puede tener
información de alcance o accesibilidad (como public…), el nombre del
constructor y parámetros si tiene.
3. Los constructores no retornan ningún valor.
4. Tú no puedes llamar a un constructor directamente, solo puede ser llamado
usando el operador new durante la instanciación de la clase.
Para declarar un constructor, escribimos,

<modificador> <nombreDeLaClase> (<parametros>*) {

<declaraciones>*
}

10.7.1 Constructor por defecto

Cada clase tiene un constructor por defecto. El constructor por defecto es el constructor
sin ningún parámetro. Si la clase no especifica algún constructor, entonces un
constructor por defecto es creado.

10.7.2 Constructores sobrecargados

Como se ha mencionado, los constructores pueden estar sobrecargados, por ejemplo,
aquí tenemos cuatro constructores sobrecargados,

public StudentRecord(){
//some initialization code here
}
public StudentRecord(String temp){
this.name = temp;
}

public StudentRecord(String name, String address){

this.name = name;
this.address = address;
}

public StudentRecord(double mGrade, double eGrade,

double sGrade){
mathGrade = mGrade;
englishGrade = eGrade;
scienceGrade = sGrade;
}

10.7.3 Usando Constructores

Para usar estos constructores, tenemos el siguiente código,

public static void main( String[] args )

{
//create three objects for Student record
StudentRecord annaRecord=new StudentRecord("Anna");

StudentRecord beahRecord=new StudentRecord("Beah",

"Philippines");

StudentRecord crisRecord=new StudentRecord(80,90,100);

//some code here
}
Ahora, recordemos a la variable estática contadorEstudiantes (studenCount) que
declaramos antes. El propósito de contadorEstudiantes es contar el número de objetos
que han sido instanciados con la clase RegistroEstudiante(StudentRecord). Entonces, lo
que podemos hacer aquí es, cada vez que un objeto de la clase RegistroEstudiante es
instanciado, nosotros incrementamos el valor de contadorEstudiantes. Una buena
ubicación para modificar e incrementar el valor de contadorEstudiantes es en los
constructores, porque siempre se llaman cada vez que un objeto es instanciado. Por
ejemplo,

public StudentRecord(){
//some initialization code here
studentCount++; //add a student
}

public StudentRecord(String temp){

this.name = temp;
studentCount++; //add a student
}

public StudentRecord(String name, String address){

this.name = name;
this.address = address;
studentCount++; //add a student
}

public StudentRecord(double mGrade, double eGrade,

double sGrade){
mathGrade = mGrade;
englishGrade = eGrade;
scienceGrade = sGrade;
studentCount++; //add a student
}

10.7.4 El llamado al constructor this()

Tu puedes llamar a un constructor desde otro constructor. Use this() para esto. Ver
ejemplo pag. 164 Jedi.

10.8 Paquetes
Los paquetes en Java significan una agrupación de clases e interfaces juntas en una
unidad. Esta característica provee un mecanismo conveniente para manejar un grupo
grande de clases e interfaces evitando potenciales conflictos de nombrado.

10.8.1 Importando paquetes

Para poder usar las clases por fuera del paquete en el que estás trabajando, necesitas
importar el paquete para esas clases. Por defecto, todos tus programas de Java importan
el paquete java.lang.*, es por esto que tu puedes usar las clases como String e Integers
dentro de tus programas sin tener que importar ningún paquete.
La sintaxis para importar paquetes es la siguiente,

Import<nombreDelPaquete>;

Por ejemplo, si quieres usar la clase Color que se encuentra dentro del paquete awt,
tienes que escribir lo siguiente:
import java.awt.Color;
import. Java.awt.*;

La primera declaración importa la clase específica Color, mientras que la otra importa
todas las clases del paquete java.awt.

10.8.2 Creando tus propios paquetes (Ver pág. 165 Jedi)

10.8.3 Configurando el CLASSPATH (Ver pág. 166 Jedi)

10.9 Modificadores de acceso

Cuando creamos nuestras clases y definimos las propiedades y métodos en nuestra
clase, podemos implementar alguna clase de restricción para acceder a esos datos. Por
ejemplo, si tú quieres que cierto atributo pueda cambiar solo por los métodos que están
dentro de la clase, tú puedes esconderlo de otros objetos que usen tu clase. En Java,
tenemos lo que llamamos modificadores de acceso para implementar esto.

Hay cuatro tipos diferentes de modificadores de acceso en Java: public, private,

protected y default. Los primeros tres modificadores se escriben explícitamente en el
código para indicar el tipo de acceso, pero para el cuarto: default, ninguna palabra clave
es usada.

10.9.1 Acceso por defecto (default) (también llamado accesibilidad de paquete)

Este especifica que solo las clases que están dentro del mismo paquete pueden acceder a
las variables y métodos de la clase. Se aplica si ningún modificador de acceso es escrito.

Por ejemplo:

public class StudentRecord

{
//default access to instance variable
int name;

//default access to method

String getName(){
return name;
}
}

En este ejemplo, la variable name y el método getName() pueden ser accedidos por
otros objetos, siempre en cuando pertenezcan al mismo paquete que la clase
StudenRecord.
10.9.2 Acceso público (public)
Este especifica que los miembros de una clase son accesibles por cualquiera, aunque
estén dentro o fuera de la clase o del paquete. Cualquier objeto que interactúe con la
clase puede tener acceso a los miembros públicos de la clase. Por ejemplo:

public class StudentRecord

{
//public access to instance variable
public int name;

//public access to method

public String getName(){
return name;
}
}

En este ejemplo, la variable instancia name y el método getName() pueden ser

accedidos por otros objetos.

10.9.3 Acceso protegido (protected)

Este especifica que los miembros de la clase son accesibles solo por métodos que
pertenezcan a la misma clase y a las subclases de la clase. Por ejemplo:

public class StudentRecord

{
//protected access to instance variable
protected int name;

//protected access to method

protected String getName(){
return name;
}
}

10.9.4 Acceso privado (private)

Este acceso especifica que los miembros de la clase solo son accesibles por la clase en
la que fueron definidos. Por ejemplo,

public class StudentRecord

{
//private access to instance variable
private int name;

//private access to method

private String getName(){
return name;
}
}

Nota:
Las variables instancia de una clase deben normalmente ser declaradas privadas, y la
clase solo proveerá métodos de acceso y mutadores para esas variables.