Programa:

Técnico Profesional en Programación de Computadores

Trimestre: 3
Docente: José Palacio
Asignatura: Desarrollo de Aplicaciones con Acceso a Datos
Tema: Creación de Clases y Construcción de Objetos en Memoria

CREACIÓN DE CLASES Y
CONSTRUCCIÓN DE OBJETOS EN MEMORIA

INTRODUCCIÓN
El concepto fundamental en la Programación Orientada a Objetos es el objeto, el cual es el elemento constituyente de
todas las aplicaciones, basadas en este paradigma. El objeto es un ente que posee unas características específicas que
lo definen, llamadas propiedades o atributos, por ejemplo un objeto Auto, tendrá un modelo, una marca, un color, un
número de puertas, etc., un objeto Persona, podría tener nombre, apellido, dirección, etc., las propiedades
particulares de cada objetos dependerán de los requerimientos propios de la aplicación que se esté construyendo.

Al crear un objeto se le deben asignar valores a dichas propiedades, las cuales serán diferentes para cada objeto del
mismo tipo, pero ¿cómo sabe el objeto que propiedades debe manejar?, la respuesta se basa en el hecho de que para
poder construir un objeto, debemos basarnos en un modelo (una base), que defina que propiedades son relevantes
para el mismo; a este modelo se le denomina clase. Por lo tanto la programación orientada a objetos se basa en la
definición de elementos conocidos como clases, que se utilizan como base para la construcción de los objetos.

Además hay que tener en cuenta, que con las simples propiedades no basta, ya que para que la programación tenga
sentido, el programa debe realizar una serie de operaciones, estas operaciones se definen para cada objeto durante la
creación de la clase (aunque esto depende del tipo de clase) y son conocidos con el nombre de métodos.

DESCRIPCION DE SINTAXIS
La sintaxis utilizada en la redacción del documento es la siguiente:

1. El lenguaje de programación Java es de tipo Case Sensitive, por lo tanto diferencia mayúsculas de minúsculas.
2. Se utilizará el estilo de escritura CamelCase, para la identificación de los elementos del programa.
a. Para nombres de clases y constructores se utilizará UpperCamelCase, por ejemplo: ClasePrincipal.
b. Para las constantes se utilizará UPPERCASE, por ejemplo: VALORPI.
c. Para el resto de elementos se utilizará lowerCamelCase, por ejemplo: primerNombre.
3. Los textos escritos en negrita, con un color distinto al negro representan palabras reservadas del lenguaje y
deben ser escritos tal cual aparecen en el documento.
4. Los textos escritos en cursiva representan valores que deberán ser reemplazados por el valor indicado en el
documento, por lo general un nombre definido por el programador.

DEFINICIÓN DE UNA CLASE

A nivel de sistema operativo, por lo general una clase no es más que un archivo, con el código de definición de la clase
(propiedades y métodos), en el caso del lenguaje Java, la clase es un archivo de texto, que debe tener el mismo
nombre de la clase (respetando Case Sensitive), y la extensión .java.

La definición de la clase se basa en un diagrama conocido como diagrama de clases (basado en el estándar UML), en el
cual se definen todas las características de los elementos de la clase, excepto la codificación de los métodos.

El siguiente diagrama de clases, define la clase que se creará y utilizará en este documento, y cuya descripción aparece
después de la misma:

JOSÉ PALACIO VELASQUEZ Página 1


Cuenta Nombre de la Clase

- numeroCuenta: int
Propiedades o atributos
- saldo: double

+ Cuenta() Constructores

+ Cuenta(num: int, monto:double)
+ getNumCuenta():int
+ setNumCuenta(num:int):void
Métodos
+ getSaldo():double
+ setSaldo(monto:double):void
+ consignar(monto:double):boolean
+ retirar(monto:double):int

En la parte superior del diagrama aparece el nombre de la clase (Cuenta), el cual siguiendo la norma UpperCamelCase
inicia con letra mayúscula, luego aparecen los nombres de dos propiedades según la nomenclatura lowerCamelCase
iniciando con mayúscula a partir de la segunda palabra que pueda llegar a conformar el nombre (numeroCuenta, y
saldo) aparecen los tipos de datos respectivos de cada propiedad (según los tipos de datos primitivos de Java),
también se observa que los nombres de dichas propiedades van precedidos de un signo de resta (-), esto indica que se
debe utilizar el modificador de acceso private, el cual se utiliza para impedir que las propiedades puedan ser
modificadas directamente desde fuera de la clase (esto es un mecanismo de protección que permite evitar el acceso
directos a la memoria RAM).

Luego de las propiedades aparecen los métodos u operaciones que puede realizar la clase, en este diagrama, aparecen
dos métodos iniciales, que como característica principal, cuentan con el mismo nombre de la clase (Cuenta), a estos
métodos especiales se les denomina constructores, y se utilizan para definir como se realizará la creación del objeto
basado en dicha clase. Para el caso actual se utilizaran dos constructores, uno que no recibe ningún parámetro
(Cuenta()), utilizado para construir un objeto, sin recibir valores desde la clase que lo cree. Y el otro que recibe dos
parámetros (Cuenta(num:int, monto:double)), que permitirá para este caso crear un objeto con las propiedades
numeroCuenta y saldo con valores ya asignados.

Después de los constructores aparecen los métodos convencionales, se observa la existencia de métodos que se
utilizarán para asígnale valores a las propiedades, conocidos como métodos tipo set y métodos que permiten obtener
el valor almacenado en la propiedad, conocidos como métodos get, los cuales para este ejemplo son de tipo public (ya
que van precedidos por el signo de suma (+). Por cada propiedad, deberá existir un método tipo set y otro tipo get.
Aparte también se observa la existencia de otros dos métodos, uno que será utilizado para realizar consignaciones en
la cuenta y otro para hacer retiros, cada método puede o no requerir parámetros e igualmente cada método deberá
definir un tipo de retorno para el mismo.

Los algoritmos para los distintos métodos debieron ser definidos y entregados a los programadores, a través de otros
diagramas UML, que por ahora no vienen al caso.

CODIFICACIÓN DE LA CLASE
Teniendo en cuenta entonces el diagrama de clase, el nombre de la clase debe ser Cuenta (Cuenta.java para el
nombre del archivo) y deberá ser de tipo public.

JOSÉ PALACIO VELASQUEZ Página 2


public class Cuenta {

// Declaración de las propiedades de la clase
private int numeroCuenta;
private double saldo;
// Constructor por defecto para la creación del objeto
public Cuenta() {
}
// Constructor que recibe parámetros para la inicialización de las propiedades
public Cuenta(int num, double monto){
numeroCuenta = num;
saldo=monto;
}
// Método tipo GET para devolver el contenido de la variable numeroCuenta
public int getNumCuenta(){
return numeroCuenta;
}
// Método tipo SET para asignar el contenido de la variable numeroCuenta
public void setNumCuenta(int num){
numeroCuenta = num;
}
// Método tipo GET para devolver el contenido de la variable saldo
public double getSaldo(){
return saldo;
}
// Método tipo SET para asignar el contenido de la variable saldo
public void setSaldo(double monto){
saldo = monto;
}
// Método para realizar consignaciones a la cuenta, de tipo boolean, si devuelve
// true la consignación se realizó satisfactoriamente y se incrementa el saldo
// en caso contrario devuelve false
public boolean consignar(double monto){
boolean resultado = false;
if (monto > 0){
saldo += monto;
resultado = true;
}
return resultado;
}
// Método para realizar retiros a la cuenta, de tipo int, si se devuelve un 300
// el retiro se realizó satisfactoriamente y se realizar el retiro, si se devuelve
// un 301, el valor del monto a retirar es superior al saldo de la cuenta,
// si se devuelve un 302 el valor del monto no es un valor válido
public int retirar(double monto){
int resultado;
if (monto > 0){
if (monto <= saldo){
saldo -= monto;
resultado = 300;
} else {
resultado = 301;
}
} else {
resultado = 302;
}
return resultado;
}
}

CONSTRUCCIÓN DE UN OBJETO
Como se ha definido anteriormente, las clases se utilizan como base para la construcción de los objetos, la cual se
basa en la siguiente sintaxis:

Clase objeto = new Constructor([Parámetros]);

JOSÉ PALACIO VELASQUEZ Página 3


La elección del constructor se determina durante el momento de la creación, basándose en los diferentes
constructores que hayan sido definidos en la clase, muchas clases sólo implementan el llamado constructor por
defecto, que no recibe parámetros.

Para el ejemplo actual, utilizando el método main de Java, para la construcción del objeto c1, basado en la clase
Cuenta, el código podría ser el siguiente:

public class Principal

public static void main(String args[]){

// Creación del objeto c1 utilizando el constructor por defecto
Cuenta c1 = new Cuenta();
// Asignación de los valores a las propiedades del objeto a través
// de los métodos tipo SET
c1.setNumCuenta(1000);
c1.setSaldo(150000);
// Mostrando el contenido de las propiedades del objeto a través
// de los métodos tipo GET
System.out.println(“Su número de cuenta es: “ + c1.getNumCuenta() +
“ y su saldo es: “ + c1.getSaldo());
// Al intentar realizar un consignación se verifica si el método
// devuelve un true, lo que indica que se pudo realizar la
// consignación, esto se valida usando la instrucción if
if (c1.consignar(50000)){
System.out.println(“Consignación realizada satisfactoriamente”);
System.out.println(“Su nuevo saldo es: “ + c1.getSaldo());
} else {
System.out.println(“Valor a consignar incorrecto”);
}
// Al intentar realizar un retiro se verifican los valores de retorno
// del método retirar, para mostrarle un mensaje personalizado al
// usuario, según unos valores predefinidos en el sistema
if (c1.retirar(30000) == 300){
System.out.println(“Retiro realizado satisfactoriamente”);
System.out.println(“Su nuevo saldo es: “ + c1.getSaldo());
} else if (c1.retirar(30000) == 301){
System.out.println(“El valor a retirar es superior al saldo”);
} else {
System.out.println(“Valor a retirar incorrecto”);
}
}
}

JOSÉ PALACIO VELASQUEZ Página 4