2.

1 Declaración de clases: atributos, métodos,

encapsulamiento.
La declaración de una clase define la estructura de la misma. Dicho de otra forma, la
declaración de una clase informa de los elementos que la conforman. Posteriormente
a ser declarada, una clase debe ser implementada convenientemente, es decir, se
debe escribir el código correspondiente a los procedimientos y funciones que
determinan el funcionamiento de esa clase.
Las clases se declaran en la sección TIPO del script pues las clases son, al fin y al
cabo, tipos de datos.
La programación orientada a objetos se basa en la programación de clases; a
diferencia de la programación estructurada, que está centrada en las funciones.
Una clase es un molde del que luego se pueden crear múltiples objetos, con similares
características.
Una clase es una plantilla (molde), que define atributos (variables) y métodos
(funciones)
La clase define los atributos y métodos comunes a los objetos de ese tipo, pero luego,
cada objeto tendrá sus propios valores y compartirán las mismas funciones.
Debemos crear una clase antes de poder crear objetos (instancias) de esa clase. Al
crear un objeto de una clase, se dice que se crea una instancia de la clase o un objeto
propiamente dicho.

Tipos de atributos.
Objetivos:
a) Profundizar en el concepto de atributo de una clase e indicar los tipos de atributos
en Java
b) Interpretar el código fuente de una aplicación Java donde aparecen distintos tipos
de atributos
c) Construir una aplicación Java sencilla, convenientemente especificada, que
emplee clases con diferentes tipos de atributos.
Los atributos, también llamados datos o variables miembro son porciones de
información que un objeto posee o conoce de sí mismo. Una clase puede tener
cualquier número de atributos o no Tener ninguno. Se declaran con un identificador y
el tipo de dato correspondiente.
• Modificador Visibilidad
• public Pública (+)
• protectec Protegida / en la herencia(#)
 • private Privada(-)
• package De paquete (~)
Métodos.
Java como todo lenguaje de programación orientado a objetos utiliza los llamados
métodos. A continuación veremos cómo se crea un método y como se utilizan.
Se podría decir que existen 2 grandes tipos de métodos, el primer tipo de método son
métodos que realizan procesos, puedes realizar cualquier operación con ellos, sin
embargo el propósito es manipular variables existentes. El segundo tipo de métodos
son los que realizan un proceso o cálculo, y calculan una variable específica, un
ejemplo podría ser un método para obtener el valor de una multiplicación.
Los métodos en java pueden tener parámetros, es decir, que un método puede utilizar
variables predefinidas para ser utilizadas en sus procesos.
Encapsulamiento.
Como se puede observar de los diagramas, las variables del objeto se localizan en el
centro o núcleo del objeto. Los métodos rodean y esconden el núcleo del objeto de
otros objetos en el programa. Al empaquetamiento de las variables de un objeto con la
protección de sus métodos se le llama encapsulamiento. Típicamente, el
encapsulamiento es utilizado para esconder detalles de la puesta en práctica no
importantes de otros objetos. Entonces, los detalles de la puesta en práctica pueden
cambiar en cualquier tiempo sin afectar otras partes del programa.
El encapsulamiento de variables y métodos en un componente de software ordenado
es, todavía, una simple idea poderosa que provee dos principales beneficios a los
desarrolladores de software.

2.2 Instanciación de una clase.

Podemos interpretar que una clase es el plano que describe como es un objeto de la
clase, por tanto podemos entender que a partir de la clase podemos fabricar objetos. A
ese objeto construido se le denomina instancia, y al proceso de construir un objeto se le
llama instanciación.
Cuando se construye un objeto es necesario dar un valor inicial a sus atributos, es por ello
que existe un método especial en cada clase, llamado constructor, que es ejecutado de
forma automática cada vez que es instanciada una variable. Generalmente el constructor
se llama igual que la clase y no devuelve ningún valor. Análogamente, destructor es un
método perteneciente a una clase que es ejecutado de forma automática cuando un
objeto es destruido. Java no soporta los destructores. Es posible que exista más de un
constructor en una clase, diferenciados sólo en los parámetros que recibe, pero en la
instanciación sólo será utilizado uno de los constructores.
Ejemplo:
clase base
package ejemplo_de_libro
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
LibroCalificaciones miLibroCalificaciones = new LibroCalificaciones();
System.out.println("Escribe algo: ");
String nombreDelCurso = entrada.nextLine();
System.out.println();
miLibroCalificaciones.mostrarMensaje(nombreDelCurso);
}
}
Clase derivada
package ejemplo_de_libro;
public class LibroCalificaciones {
public void mostrarMensaje(String nombredelsaludo)
{
System.out.printf("Bienvenido al libro de calificaciones para :\n%s\n", nombredelsaludo);
}
}

2.3 Referencia al objeto actual.

La utilización de THIS en lugar de hacer referencia explícitamente al objeto actual por su
nombre (por ejemplo, thisform.command1.caption) hace que el código de programa pueda
alternarse entre objetos, porque evita el nombre del objeto y encapsula automáticamente
la clase primaria del objeto.
THIS permite hacer referencia a una propiedad o un objeto de una definición de clase. Los
métodos de un bloque de definición de clase pueden utilizar THIS para especificar una
propiedad o un objeto que existirá cuando se cree la clase.
Puesto que múltiples instancias de objetos comparten el mismo código de método, THIS
siempre hace referencia a la instancia en la que está ejecutándose el código. Si hay
múltiples instancias de un objeto, y se llama a uno de los métodos del objeto, THIS hace
referencia al objeto correcto.
Cada objeto puede acceder a una referencia a si mismo mediante la palabra this. Cuando
se hace una llamada a un método no static para un objeto especifico, el cuerpo del
método utiliza en forma implícita la palabra this para hacer referencia a las variables de
instancia y los demás métodos del objeto.
Ahora demostraremos el uso implícito y explicito de la referencia this para permitir al
método main de la clase PruebaThis que muestre en pantalla los datos prívate de un
objeto de la clase TiempoSimple. Hicimos esto para demostrar que, al compilador un
archivo .java que contiene más de una clase, el compilador produce un archivo de clase
separado por la extensión .class para cada clase compilada.
// Ejemplo This.java
//Uso implicito y explicito de this para hacer referencia a los miembros de un objeto
public class PruebaThis
{
public static void main (String args[])
{
TiempoSimple tiempo=new TiempoSimple(15, 30, 19 );
System.out.println(tiempo.crearString());
}//fin de main
}//fin de la clase PruebaThis
//la clase TiempoSimple demuestra la referencia "this"
public class TiempoSimple
{
private int hora; //0-23
private int minuto; //0-59
private int segundo;//0-59
//si el constructor utiliza nombres de parametros idénticos a
//los nombres de las variables de instancia, se reuiere la
//referencia "this" para diferenciar unos nombres de otros
public TiempoSimple (int hora,int minuto, int segundo)
{
this.hora=hora;//establece la hora del objeto "this"
this.minuto=minuto;//establece el minuto del objeto "this"
this.segundo=segundo;//establece el segundo del objeto "this"
}//fin del constructor de TiempoSimple
//usa la referencia "this" explicita e implicita para llamar StringUniversal
public String crearString()
{
return String.format("%24s:%s\n%24s:%s",
"this.aStringUniversal()",this.aStringUniversal(),
"aStringUniversal()", aStringUniversal());
}//fin del metodo crearString
//convierte a String en formato de hora universal (HH:MM:SS)
public String aStringUniversal()
{
//"this"no se requiere aquí para acceder a las variables de instancia,
//ya que el metodo no tiene variable locales con los mismos
//nombres que las variables de instancia
return String.format("%02d:%02d:%02d",
this.hora, this.minuto, this.segundo);
}//fin del metodo sStringUniversal
}//fin de la clase TiempoSimple

2.4 Métodos: declaración, mensajes, paso de parámetros, retorno

de valores
Los métodos son subrutinas que definen la interfaz de una clase, sus capacidades y
comportamiento. Un método ha de tener por nombre cualquier identificador legal distinto
de los ya utilizados por los nombres de la clase en que está definido. Los métodos se
declaran al mismo nivel que las variables de instancia dentro de una definición de clase.
En la declaración de los métodos se define el tipo de valor que devuelven y a una lista
formal de parámetros de entrada, de sintaxis tipo identificador separadas por comas. La
forma general de una declaración de método es:
tipo_devuelto nombre_de_método( lista-formal-de-parámetros ) {
cuerpo_del_método;
}
Por ejemplo el siguiente método devuelve la suma de dos enteros:
int metodoSuma( int paramX, int paramY ) {
return ( paramX + paramY );
}
En el caso de que no se desee devolver ningún valor se deberá indicar como tipo la
palabra reservada void. Así mismo, si no se desean parámetros, la declaración del
método debería incluir un par de paréntesis vacíos (sin void):
void metodoVacio( ) { };
Los métodos son llamados indicando una instancia individual de la clase, que tendrá su
propio conjunto único de variables de instancia, por lo que los métodos se pueden referir
directamente a ellas.
El método inicia() para establecer valores a las dos variables de instancia sería el
siguiente:
void inicia( int paramX, int paramY ) {
x = paramX;
y = paramY;
}
MENSAJES Y MÉTODOS
El modelado de objetos no sólo tiene en consideración los objetos de un sistema, sino
también sus interrelaciones.
Los objetos interactúan enviándose mensajes unos a otros. Tras la recepción de un
mensaje el objeto actuará. La acción puede ser el envío de otros mensajes, el cambio de
su estado, o la ejecución de cualquier otra tarea que se requiera que haga el objeto. Un
método se implementa en una clase, y determina cómo tiene que actuar el objeto cuando
recibe un mensaje.
Cuando un objeto A necesita que el objeto B ejecute alguno de sus métodos, el objeto A
le manda un mensaje al objeto B.

Al recibir el mensaje del objeto A, el objeto B ejecutará el método adecuado para el

mensaje recibido.
 PARÁMETROS.
Los métodos son un bloque de código que contiene una serie de instrucciones. En java,
cada instrucción se ejecuta en el contexto de un método.
Los métodos se declaran en una clase o estructura especificando el nivel de acceso, el
valor devuelto, el nombre del método y los parámetros de método. Los parámetros de
método se incluyen entre paréntesis y separados por comas. Los paréntesis vacíos
indican que el método no requiere ningún parámetro. Esta clase contiene tres métodos:
Public class Motorcycle
{
public void StartEngine()
public void AddGas(int gallons)
public int Drive(int miles, int speed) { return 0; }
}
Llamar a un método en un objeto es similar a tener acceso a un campo. Después del
nombre de objeto, agregue un punto, el nombre del método y paréntesis. Los argumentos
se enumeran entre paréntesis y separados por comas. Por tanto, se puede llamar a los
métodos de la clase Motorcycle del modo siguiente:
Motorcycle moto = new Motorcycle();
moto.StartEngine();
moto.AddGas(15);
moto.Drive(5, 20);
Los parámetros que un método recibe también se proporcionan entre paréntesis, pero se
debe especificar el tipo y nombre de cada parámetro. El nombre no tiene por qué ser igual
que el argumento. Por ejemplo:
public static void PassesInteger()
{
int fortyFour = 44;
TakesInteger(fortyFour);
}
static void TakesInteger(int i)
{
i = 33;
}
Aquí un método denominado PassesInteger pasa un argumento a un método denominado
TakesInteger. En PassesInteger el argumento se denomina fortyFour, pero en
TakeInteger es un parámetro denominado i. Este parámetro sólo existe dentro del método
TakesInteger. Otras variables también pueden denominarse i y pueden ser de cualquier
tipo, siempre y cuando no sean parámetros o variables declaradas en ese método.

RETORNO DE VALORES
Los métodos pueden devolver un valor al llamador. Si el tipo de valor de retorno (el que
aparece antes del nombre de método) no es void, el método puede devolver el valor
mediante la palabra clave return. Una instrucción con la palabra clave return, seguida de
un valor que coincida con el tipo de valor devuelto, devolverá ese valor al llamador del
método.
La palabra clave return también detiene la ejecución del método. Si el tipo de valor
devuelto es void, una instrucción return sin ningún valor sigue siendo útil para detener la
ejecución del método. Sin la palabra clave return, el método detendrá la ejecución cuando
llegue al fin del bloque de código. Es necesario que los métodos con un tipo de valor
devuelto no nulo utilicen la palabra clave return para devolver un valor. Por ejemplo, estos
dos métodos utilizan la palabra clave return para devolver enteros:
Public class SimpleMath
{
public int AddTwoNumbers(int number1, int number2)
{
return number1 + number2;
}
public int SquareANumber(int number)
{
return number * number;
}
}
Para emplear un valor devuelto por un método, el método de llamada puede utilizar la
propia llamada del método en cualquier parte donde un valor del mismo tipo sea
suficiente.
 2.5 Constructores y destructores declaración, uso y aplicaciones
Constructores y destructores
Los constructores y destructores son dos tipos de métodos especiales que se ejecutan,
respectivamente, al crear un nuevo objeto y cuando el recolector de basura detecta que
ya no lo estamos utilizando y es posible eliminarlo de la memoria. Hasta ahora no hemos
hecho uso nunca ni de los constructores ni de los destructores puesto que los ejemplos
que hemos venido utilizando eran bastante simples, pero a partir de ahora vamos a
empezar a utilizarlos bastante a menudo. Sobre todo en el caso de los constructores, ya
que los destructores no se suelen usar más que en contadas ocasiones.
Para crear un objeto se necesita reservar suficiente espacio en memoria e inicializar los
valores de los campos que representan el estado del objeto.
Este trabajo es realizado por un tipo especial de método denominado constructor.
Constructor
Un método constructor de una clase es un método especial que:
•Tiene el mismo nombre que la clase y
•No tiene tipo de retorno.
•Inicializa el estado de un objeto.
La sintaxis para la declaración de un método constructor es:
[atributos] [modificadores] <identificador> ( [parámetros] ) [inicializador]
{
// Cuerpo del constructor.
}
Dónde:
Atributos (opcional) es información declarativa adicional.
Modificadores (opcional) se restringen a extern y a los modificadores de acceso.
Identificador es el nombre del método constructor (igual al nombre de la clase).
Parámetros (opcional) es la lista de parámetros pasados al constructor.
Inicializador (opcional). Con el inicializador, el constructor invoca previamente a otro
constructor.
El inicializador puede ser uno de los siguientes:
· base([listaDeParámetros])
· this([listaDeParámetros])
Cuerpo del constructor es el bloque de programa que contiene las instrucciones para
inicializar la instancia de clase (objeto).
Ejemplo:
class Producto
{
private int clave;
private double precio;
public Producto( int c, double p)
{
clave = c;
precio = p;
}
public double daPrecio( )
{
return precio;
}
}
Destructor
En contraposición al constructor, el destructor elimina el vínculo y libera el espacio de
memoria de un objeto, para que pueda ser ocupado nuevamente.

La sintaxis para declarar un destructor es:

[atributos] ~ <identificador> ( )
{
// Cuerpo del destructor.
}
•Una clase solamente puede tener un destructor.
•Los destructores no pueden heredarse o sobrecargarse.
•Los destructores no pueden invocarse, sino que son invocados automáticamente.
•Un destructor no acepta modificadores ni parámetros. Por ejemplo, la siguiente es una
declaración de un destructor para la clase Figura:
~ Figura()
{
// Instrucciones para limpiar.
}
El destructor llama implícitamente al método Object.Finalize( ) en la clase base object. Por
lo tanto, el código destructor precedente es traducido automáticamente a:
protected override void Finalize( )
{
try
{
// Instrucciones para limpiar.
}
finally
{
base.Finalize( ) ;
}
}
Ejemplo:
// Destructores.cs : Maneja tres destructores de clases encadenadas.
using System;
using C = System.Console;
class Primera
{
~ Primera( )
{
C.WriteLine("Se invocó al destructor de Primera...");
}
}
class Segunda : Primera
{
~ Segunda( )
{
C.WriteLine("Se invocó al destructor de Segunda...");
}
}
class Tercera : Segunda
{
~ Tercera( )
{
C.WriteLine("Se invocó al destructor de Tercera...");
}
}
public class Principal
{
public static void Main( )
{
Tercera t = new Tercera ( );
}
}
Aplicaciones de constructores y destructores
En esta sección se presenta una serie de ejemplos donde se implementarán:
1.- clases que sólo poseen el constructor predeterminado
2.- clases con un constructor definido por el programador y
3.- clases con un constructor definido por el programador y el predefinido (que deberá ser
reescrito por el programador).
El constructor predeterminado es incluído automáticamente.
Cuando el programador define un constructor, el predeterminado se anula. En caso de
requerir el constructor predeterminado junto con un constructor definido por el
programador, deberá volverse a escribir el constructor predefinido, de acuerdo al siguiente
formato:
public <nombreClase>( )
{
}
Ejemplo
// Uso del constructor predeterminado.(No se define otro constructor)
using System;
using C = System.Console;
class Persona
{
private string nombre;
private int edad;
public void asignaNombre( string n)
{
nombre = n;
}
public void asignaEdad( int e)
{
edad = e;
}
public string daNombre( )
{
return nombre;
}
public int daEdad( )
{
return edad ;
}
}
public class Principal
{
public static void Main( )
{
Persona p = new Persona( ) ; // Se invoca al constructor
//predeterminado.
p.asignaNombre("Luis");
p.asignaEdad(25);
C.WriteLine("Nombre: {0} , Edad: {1}", p.daNombre(),
p.daEdad());
}
}

2.6 Sobrecarga de métodos

La sobrecarga de Métodos se apoya de métodos y constructores, los destructores no se
pueden sobrecargar ya que sólo debe haber uno por clase.
La sobrecarga de métodos hace que un mismo nombre pueda representar distintos
métodos con distinto tipo y número de parámetros, manejados dentro de la misma clase.
En el ámbito de la POO, la sobrecarga de métodos se refiere a la posibilidad de tener dos
o más métodos con el mismo nombre pero distinta funcionalidad. Es decir, dos o más
métodos con el mismo nombre realizan acciones diferentes y el compilador usará una u
otra dependiendo de los parámetros usados. Esto también se aplica a los constructores
(de hecho, es la aplicación más habitual de la sobrecarga).
Se pueden diferenciar varios métodos sobrecargados a través de sus parámetros, ya sea
por la cantidad, el tipo o el orden de los mismos.
Gracias a la sobrecarga de métodos, una clase puede tener distinto comportamiento
dependiendo de cuál método sobrecargado se use, a esta característica se le conoce
como Polimorfismo por sobrecarga. La palabra Polimorfismo viene de la capacidad que
tiene una clase de cambiar su comportamiento. En el caso del polimorfismo por
sobrecarga, el cambio del comportamiento de una clase se define sobrecargando los
métodos necesarios para lograr el polimorfismo.

2.7 Sobrecarga de operadores: Concepto y

utilidad, operadores unarios y binarios
La sobrecarga de operadores es la capacidad para transformar los operadores de un
lenguaje como por ejemplo el +, -, etc, cuando se dice transformar se refiere a que los
operandos que entran en juego no tienen que ser los que admite el lenguaje por defecto.
Mediante esta técnica podemos sumar dos objetos creados por nosotros o un objeto y un
entero, en vez de limitarnos a sumar números enteros o reales, por ejemplo.
La sobrecarga de operadores ya era posible en c++ y en otros lenguajes, pero
sorprendentemente java no lo incorpora, así que podemos decir que esta característica es
una ventaja de c# respecto a java, aunque mucha gente, esta posibilidad, no lo considera
una ventaja porque complica el código.
A la hora de hablar de operadores vamos a distinguir entre dos tipos, los unarios y los
binarios. Los unarios son aquellos que solo requieren un operando, por ejemplo a++, en
este caso el operando es 'a' y el operador '++'. Los operadores binarios son aquellos que
necesitan dos operadores, por ejemplo a+c , ahora el operador es '+' y los operandos 'a' y
'c'. Es importante esta distinción ya que la programación se hará de forma diferente.
Los operadores que podemos sobrecargar son los unarios, +, -, !, ~, ++, --; y los binarios
+, -, *, /, %, &, |, ^, <<, >>. Es importante decir que los operadores de comparación, ==, !=,
<, >, <=, >=, se pueden sobrecargar pero con la condición que siempre se sobrecargue el
complementario, es decir, si sobrecargamos el == debemos sobrecargar el !=
Operadores Unarios
En esta sección se verá cómo sobrecargar los operadores unarios, es decir aquellos que
toman un solo operando, como por ejemplo a++. El prototipo de los métodos que van a
sobrecargar operadores unarios será:
public static Operando operator++(Operando a)
Como antes sustituyendo el ++ por cualquier operador unario. El ejemplo dentro de
nuestra clase de números complejos sería:
public static ComplexNum operator++(ComplexNum a)
{
float auximg = a.Img;
float auxreal = a.Real;
return new ComplexNum(++auxreal, ++auximg);
}
Operadores binarios

Para empezar vamos a sobrecargar el operador suma('+') para que al sumar dos objetos
de la clase ComplexNum, es decir dos números complejos obtengamos un número
complejo que será la suma de ambas partes. Cabe destacar que los prototipos para
sobrecargar operadores serán:
public static Operando operator+(Operando a, Operando b)
Este es el prototipo para el operador +, el resto de operadores binarios van a seguir el
mismo patrón. Por tanto el código del método de sobrecarga será el siguiente:
public static ComplexNum operator+(ComplexNum a, ComplexNum b)
{
 return new ComplexNum(a.Real + b.Real, a.Img + b.Img);
}
Este método sobrecarga el operador suma para que podamos sumar dos números
complejos. Un dato a tener en cuenta es que los métodos que sobrecargan operadores
deben ser static. Como se ve en el código los operandos son 'a' y 'b', que se reciben como
parámetro y el resultado de la operación es otro número complejo que es el que retorna el
método. Por tanto se limita a crear un nuevo número complejo con ambas partes
operadas. De la misma forma podemos crear la sobrecarga del operador resta('-') para
que lleve a cabo la misma función:
public static ComplexNum operator-(ComplexNum a, ComplexNum b)
{
return new ComplexNum(a.Real - b.Real, a.Img - b.Img);
}