Atributos

Los atributos son la información que guarda en un momento determinado cada objeto que se instancia de una clase. Cada objeto tiene un espacio de memoria para cada atributo que se presenta en la clase. Esta información, en cada momento, se conoce como estado del objeto.

Para determinar cuáles serían los atributos de una clase y de los objetos derivados de la misma, tenemos al menos cuatro fuentes que pueden generarse:

  • Entradas y salidas
  • Variables intermedias que puedan considerarse importantes mantener para no calcularlas en cada momento dada su interdependencia en la solución del problema.
  • Constantes, como el valor de $π$ o el número máximo de intentos que puede introducirse una contraseña o el número máximo de inscripciones que puede tener un alumno o colores o nombres de los días de la semana.

La relación que permite incorporar atributos a una clase se conoce como “agregación” e indica que una clase u objeto se integra por atributos que pueden ser datos primitivos y también pueden ser objetos de una clase.

En Java se sugiere que los identificadores de atributos se escriban capitalizados , pero iniciando con letra minúscula. Normalmente se describen como sustantivos; por ejemplo, un Grupo (clase) de alumnos tiene como atributos la clave del grupo, clave de la asignatura, clave del profesor, alumnos (colección de objetos de tipo Alumno), etc.

Diagrama sintáctico para identificadores de atributos o variables:

Atributos

Los atributos son declaraciones de variables. En Java hay tres espacios para declarar variables, las que se encuentran en el ámbito de la clase corresponden al estado de cada objeto o el valor de los atributos que guarda cada objeto.

Los atributos utilizan el mecanismo de declaración de variables de Java. Antes de utilizar un identificador debe declararse escribiendo previamente el tipo de dato a utilizar ya sea un tipo de dato primitivo (entero: byte, short, int o long; de punto flotante: double o double; carácter: char; booleano: boolean) o bien una clase (como String) o arreglo (tipo[]).

La declaración de una variable sigue el siguiente diagrama sintáctico:

Atributos

Nota: Aunque en la declaración de atributos se permite declarar varios atributos de un solo tipo separados por coma, se recomienda que cada atributo vaya en un renglón. Es decir, en la declaración de atributos no se recomienda utilizar la línea que regresa y simplemente declarar un atributo por renglón indicando en cada caso el tipo de dato.

El uso de variables, argumentos o atributos deben incluir tres partes declaración, instanciación y asignación de un valor (inicial). Las variables creadas a partir de tipos de datos primitivos números (byte, short, int, long, float y double), booleanos (boolean) y carácter (char) se inicializan en cero: a los números se les asigna cero (0 o 0.0f en el caso de float), a los booleanos false y a los caracteres el valor del caracter nulo ('u0000') tan solo con declararlos. Para los tipos de datos derivados de una clase, no se les asigna ningún espacio en la memoria hasta que se instancian y guardan un valor conocido como nulo (null) hasta que se ocupa el operador new con un constructor (instanciación, que se verá más adelante). Ejemplos:

Atributos

En estos ejemplos, lo sombreado en color verde es la declaración de la variable. Lo sombreado en color rosa es el valor inicial cuando se trata de tipos de datos primitivos; y una instanciación (crear un objeto en la memoria) y asignar un valor inicial cuando se trata de clases (con String, por ser muy utilizado en el lenguaje, no es necesario utilizar el operador new con un método constructor).

De acuerdo con segundo principio de la programación orientada a objetos, TODOS los atributos deben tener la palabra reservada private al inicio, esto se verá más adelante en la sección de encapsulamiento.

El diagrama sintáctico para la declaración de atributos será:

Atributos

Segundo principio de la POO: Encapsulamiento

Bajo el segundo principio de la Programación Orientada a Objetos todos los atributos no deben ser accesibles desde el exterior de la clase u objeto para recuperar su valor o modificarlo, es decir deben tener el modificador private. Por eso, debe agregarse el modificador private a TODOS atributos. Esta propiedad se conoce como encapsulamiento.

Por cuestiones de rendimiento, cuando no se especifica, Java los considera public. Sin embargo, esto NO se recomienda, siempre debes agregar el modificador private.

Entradas y salidas

En un programa de cómputo, al menos la información que se conoce como datos de entrada y salidas o resultados deberían ser como atributos.

Se tendrá acceso a la información almacenada en las variables o atributos de las entradas y las salidas utilizando los métodos getters (obtener) y setters (asignar) información a partir del segundo principio de la programación orientada a objetos conocido como encapsulamiento (que veremos más adelante).

Esta primera aproximación para encontrar los atributos pudiera ser describir la Clase en términos de intentar resolver un problema de Física o Matemáticas, cuando enlistas los datos de entrada y las variables que se desea calcular.

Ejercicio de selección

En los espacios en blanco, selecciona el nombre de los identificadores faltantes a partir del diagrama de clases presentado.

Ejercicio 1

Atributos

public class Triangulo {

// atributos: -----------------------

private double base;    // entrada

private double ;    // entrada

private double area;    // salida

// métodos: -----------------------

}

Ejercicio 2

Atributos

public class Circulo {

// atributos: -----------------------

private double ;    // entrada

private double area;    // salida

// métodos: -----------------------

}

Ejercicio 3

Atributos

public class PoligonoRegular {

// atributos: -----------------------

private int ;    // entrada

private float longitudDelLado;    // entrada

private float area;    // salida

// métodos: -----------------------

}

Ejercicio 4

Atributos

public class Persona {

// atributos: -----------------------

private double estatura;    // entrada

private double ;    // entrada

private double imc;    // salida

private String ;    // salida

// métodos: -----------------------

}

Atributos intermedios

En algunas ocasiones, es necesario guardar cierta información intermedia como parte del proceso, la cual no estaba planteada de inicio como entrada o salida de información. Por ejemplo, cuando se calcula el área de un polígono a partir de conocer el tamaño de un lado y el número de lados, podrían tenerse las siguientes variables:

Atributos

Dónde:

$N$ es el número de lados (dato de entrada).

$L$ es el tamaño de cada lado (dato de entrada).

$\theta$ es la mitad del ángulo interno que se forma desde el centro del polígono hacia cada uno de los lados.

$a$ es la apotema (altura de cada uno de los triángulos).

$P$ es el perímetro del polígono.

$A$ es el área del polígono (dato de salida).

$N$ y $L$ son datos de entrada y $A$ es el resultado que se desea obtener. Sin embargo, en medio de los cálculos es necesario conocer el ángulo $\theta$, la apotema a y el perímetro $P$.

Aunque no son datos que se plantearán inicialmente theta, apotema y perímetro podrían ser tres atributos que pudieran incluirse en como parte de la clase PoligonoRegular para poder realizar de una forma más sencilla los cálculos y no está demás incluirlas como parte del modelo.

Escribir

Escribe en el espacio indicado si existe una o variables atributos de entrada, intermedios y de salida.

Si se desea calcular la desviación estándar de una lista de números, ¿podría sugerirse un atributo intermedio que pudiera incluirse? Observa las siguientes fórmulas tomando en cuenta que $x$ es la lista de números, $x_i$ es el $i^{ésimo}$ término, $\bar x$ es la media, $s^2$ es la varianza y $s$ la desviación estándar:

Promedio $\bar x \sum_{i=1}^{n} x_i$
Varianza $s^2 \sum_{i=1}^{n} (\bar{x} - x_i)$
Desviación estándar: $s^2=\sqrt{s}$

Atributos de entrada:

lista de alumnos ($x$)

Atributos intermedios:

$n$, promedio ($\bar x$) y varianza ($s^2$)

Atributos de salida:

desviación estándar ($s$)
El número de datos, el promedio y la varianza no estaban contemplados en la definición del problema, pero al analizarlo puede determinarse que su implementación como atributos pudiera ser útil.
Es necesario que escribas las respuestas para recibir retroalimentación.

Constantes

Las constantes nos permiten generar identificadores para guardar valores que deben mantenerse unificados a lo largo de una aplicación por ejemplo el valor de $π$, en Java no pueden utilizarse letras distintas al alfabeto inglés. Además, el valor de $π$ siempre es el mismo y convendría tener un identificador que almacenará el valor. El valor de la constante PI = 3.141592653

Java sugiere el uso únicamente de mayúsculas y ocasionalmente dígitos. En este caso de las constantes, no es posible utilizar la técnica de capitalización y suele utilizarse el guion bajo para separar palabras.

Diagrama sintáctico para identificadores de atributos constantes:

Atributos

Identificadores recomendados para constantes pueden ser: PI, LUNES, NEGRO, MAX_VALUE, etc.

El caso de las constantes suele “romper” la regla de que los atributos sean privados, normalmente las constantes son públicas y se declaran siguiendo el siguiente diagrama sintáctico:

Atributos

Algunos ejemplos de declaraciones son:

public final PI = 3.141592653;

public byte lunes = 1;

public Color NEGRO = new Color( 0.0, 0.0, 0.0);