1. Encapsulamiento: conceptos básicos

Al término de esta publicación, ustedes podrán crear clases agrupadas en paquetes, crear objetos, emplear los modificadores de acceso: public y prívate, así como el modificador static y la referencia this en Java. Finalmente, aplicarán el concepto de encapsulamiento.

TEMARIO

· Creación de clases y paquetes

· Creación de objetos

· Modificadores

· Ejercicios + Link

ACTIVIDADES PROPUESTAS

· Ustedes crean clases agrupadas en paquetes.

· Ustedes crean objetos de diversas clases.

· Ustedes emplean y diferencian los modificadores de acceso: public y private.

· Los alumnos realizan diversas operaciones con los objetos creados.

1. CONCEPTOS BÁSICOS DE LA PROGRAMACIÓN ORIENTADA A OBJETOS

1.1 PAQUETE

Un paquete es un conjunto de clases agrupadas que guardan una relación entre sí. Los paquetes se declaran utilizando la palabra package seguida del nombre del paquete. Esta instrucción debe colocarse al inicio del archivo y debe ser la primera sentencia que debe ejecutarse. 

Ejemplo:

package semana1;
public class Alumno{
...
}

Al crearse un paquete se crea una carpeta con el mismo nombre del paquete. En nuestro ejemplo se creará la carpeta semana1. Si colocamos la misma instrucción package al inicio de otras clases, lograremos agrupar varias clases en el mismo paquete.

Uso de la sentencia import

La sentencia import se utiliza para incluir una lista de paquetes en donde se buscará una determinada clase. Su aplicación se aprecia cuando se hace referencia a una clase desde otra que se encuentra fuera del paquete. 

La sintaxis es:

import nombre_paquete.nombre_clase;

Ejemplo:

import semana1.Alumno;

De esta forma, se tiene acceso a todos los miembros (variables y métodos) de la clase Alumno que se encuentra en el paquete semana1 desde una clase que se encuentra fuera de dicho paquete. En la sentencia import se puede emplear el caracter Asterisco “ * “ con lo cual se estaría indicando que se importe todas las clases del paquete. 

Ejemplo:

import semana1.*;

1.2 CLASE 

Una clase es una plantilla que especifica los atributos y el comportamiento de un determinado tipo de objeto. Los atributos se especifican mediante variables (variables miembro) y el comportamiento mediante métodos (métodos miembro). En la Programación Orientada a Objetos (POO) una clase define un nuevo tipo de dato. Una vez definido, este nuevo tipo se puede utilizar para crear objetos.

1.2.1 Declaración y definición de una clase

En su forma más simple una clase se declara y define de la siguiente manera:

package nomnre_paquete;
public class NombreClase {
   // Declaración de variables miembro
   public tipo1 variable1;
   public tipo2 variable2;
   .
   .
   .

   // Definición del constructor
   public NombreClase (parámetros) {
   }

   // Definición de métodos miembro
   public tipo1 metodo1(parámetros) {
   }
   public tipo2 metodo2(parámetros) {
   }
   .
   .
   .
}

1.2.2 Constructor 

Un constructor es un método especial que se utiliza para inicializar un objeto inmediatamente después de su creación. El constructor de una clase se caracteriza por tener el mismo nombre de su clase y no tener tipo de retorno. Si una clase no define un constructor, Java crea un constructor por defecto que no tiene parámetros y que no realiza ninguna inicialización especial.

1.3 OBJETO

• Un objeto es una instancia (o ejemplar) de una clase.
• La JVM carga a la memoria el código de bytes de una clase en el primer momento en que la clase sea mencionada durante la ejecución del programa. En adelante, la clase cargada, será utilizada como una fábrica de objetos.
• Cada vez que se crea un objeto se crea una copia de cada una de las variables miembro declaradas por su clase. Estas variables, propias de cada objeto, se denominan: variables de instancia.
• En cambio, los métodos, son compartidos por todos los objetos de la misma clase desde el código de la clase previamente cargada.

1.3.1 Creación de objetos

Se siguen los siguientes pasos:

- Se declara una variable referencia que almacenará la dirección de memoria del objeto a crear.

nombreClase nombreReferencia;

- Se crea el objeto y se asigna su dirección de memoria a la variable referencia. Para esto se usa el operador new. El operador new crea el objeto dinámicamente (en tiempo de ejecución) y devuelve la dirección de memoria del objeto creado.

nombreReferencia = new nombreClase( lista de argumentos );

El nombre de la clase seguido por los paréntesis invoca al constructor de la clase. 

- Los dos pasos anteriores pueden efectuarse en un solo paso de la siguiente manera:

nombreClase nombreReferencia = new nombreClase( lista de argumentos );

2. ACCESO A LOS MIEMBROS DE UNA CLASE 

Para acceder a un miembro de una clase se escribe el nombre de la variable referencia, un punto y el nombre del miembro (variable miembro o método miembro) al que se desea acceder.

Ejemplo 1:

Declare la clase Alumno dentro del paquete semana1 que permita registrar un nombre y dos notas. Además, debe crear un método promedio que retorne la nota promedio.

package semana1;
public class Alumno {
   // Variables miembro
   public String nombre;
   public int nota1, nota2;

   // Operaciones
   public double promedio() {
      return (nota1 + nota2) / 2.0;
   }
}

En la clase principal (clase donde se ha creado la GUI) cree un objeto de la clase Alumno, y luego de ingresar sus datos visualice la data ingresada, además del promedio obtenido.

void procesar() {
   semana1.Alumno a = new semana1.Alumno();
   a.nombre = "Juan";
   a.nota1 = 13;
   a.nota2 = 15;
   listado(a);
}

void listado(semana1.Alumno x) {
   imprimir("nombre: " + x.nombre);
   imprimir("nota 1: " + x.nota1);
   imprimir("nota 2: " + x.nota2);
   imprimir("promedio: " + x.promedio());
}

Resultado: 

nombre: Juan 

nota 1: 13 

nota 2: 15 

promedio: 14.0

Importante: 

Como la clase Alumno se encuentra dentro del paquete semana1 y la clase principal esta fuera de dicho paquete se le debe anteponer al nombre de la clase el nombre del paquete tal como se aprecia en el ejemplo 1: semana1.Alumno. Se habrá dado cuenta que realizar esta acción se vuelve tedioso. Por lo tanto, lo más simple sería importar el paquete semana1 para que el compilador de Java ubique a la clase Alumno y de esta forma evitar la referencia al paquete cada vez que se hace referencia a la clase. En este ejemplo, se debe incluir en las sentencias de importación la siguiente linea:

import semana1.Alumno;

Ahora sí, el código de la clase principal quedaría de esta forma:

void procesar() {
   Alumno a = new Alumno();
   a.nombre = "Juan";
   a.nota1 = 13;
   a.nota2 = 15;
   listado(a);
}

void listado(Alumno x) {
   imprimir("nombre: " + x.nombre);
   imprimir("nota 1: " + x.nota1);
   imprimir("nota 2: " + x.nota2);
   imprimir("promedio: " + x.promedio());
}

Resultado:

nombre: Juan
nota 1: 13
nota 2: 15
promedio: 14.0

En los siguientes ejemplos, se asume que se ha importado el paquete correspondiente.

Ejemplo 2: 

Añada un constructor a la clase Alumno para inicializar sus variables miembro al momento de crear el objeto.

package semana1;
public class Alumno {
   // Variables miembro
   public String nombre;
   public int nota1, nota2;

   // Constructor
   public Alumno(String nom, int n1, int n2) {
      nombre = nom;
      nota1 = n1;
      nota2 = n2;
   }

   // Operaciones
   public double promedio() {
      return (nota1 + nota2) / 2.0;
   }
}

A la pulsación de un botón cree el objeto y, a la vez, inicialice sus variables miembro.

void procesar() {
   Alumno a = new Alumno("Juan",13,15);
   listado(a);
}

void listado(Alumno x){
   imprimir("Objeto: "+x);
   imprimir("nombre: "+x.nombre);
   imprimir("nota 1: "+x.nota1);
   imprimir("nota 2: "+x.nota2);
   imprimir("promedio: "+x.promedio());
}

Resultado:

Objeto: semana1.Alumno@92e78c
nombre: Juan
nota 1: 13
nota 2: 15
promedio: 14.0

3. CONTROL DE ACCESO Y ENCAPSULAMIENTO 

Una clase puede controlar qué partes de un programa pueden acceder a los miembros de su clase: variables miembro y métodos miembro. Una clase bien diseñada impide el acceso directo a sus variables miembro proporcionando a cambio un conjunto de métodos de acceso que sirvan como intermediarios entre las variables miembro y el mundo exterior. Esto permite controlar el uso correcto de las variables miembro, pues los métodos de acceso pueden actuar como filtros que prueben los datos que se pretenden ingresar a las variables miembro. Por otra parte, algunos métodos de la clase pueden ser necesarios sólo desde el interior de la clase por lo que deben quedar restringidos sólo para uso interno. Para controlar el acceso a los miembros de una clase, se usan especificadores o modificadores de acceso que se anteponen a las declaraciones de los miembros a controlar. Los especificadores de acceso son public, private y protected. Se ve la aplicación del especificador de acceso protected cuando se trabaja con herencia, por lo que lo veremos más adelante. 

En la tabla que sigue, se muestra el uso de los especificadores de acceso.

La primera columna indica si la propia clase tiene acceso al miembro definido por el especificador de acceso. La segunda columna indica si las subclases de la clase (sin importar dentro de qué paquete se encuentren estas) tienen acceso a los miembros. La tercera columna indica si las clases del mismo paquete que la clase (sin importar su parentesco) tienen acceso a los miembros. La cuarta columna indica si todas las clases tienen acceso a los miembros. 

Encapsulamiento es la capacidad de ocultar los detalles internos del comportamiento de una clase y exponer o dar a conocer sólo los detalles que sean necesarios para el resto de clases. Este ocultamiento nos permite restringir y controlar el uso de la clase. Restringir, porque habrán ciertos atributos y métodos privados o protegidos y controlar, porque habrán ciertos mecanismos para modificar el estado de nuestra clase como, por ejemplo, los métodos de acceso. 

Ejemplo 3: 

Haga que las variables miembro de la clase Alumno sean de uso privado y declare sus respectivos métodos de acceso: get/set.

package semana2;
public class Alumno {
   // Variables miembro
   private String nombre;
   private int nota1, nota2;

   // Constructor
   public Alumno(String nom, int n1, int n2) {
      nombre = nom;
      nota1 = n1;
      nota2 = n2;
   }

   // Métodos de acceso: get
   public String getNombre() {
      return nombre;
   } 
   public int getNota1() {
      return nota1;
   }
   public int getNota2() {
      return nota2;
   }

   // Métodos de acceso: set
   public void setNombre(String nom) {
      nombre = nom;
   }
   public void setNota1(int n) {
      nota1 = n;
   }
   public void setNota2(int n) {
      nota2 = n;
   }

   // Operaciones
   public double promedio() {
      return (nota1 + nota2) / 2.0; 
   }
}

A la pulsación de un botón, cree el objeto y, a la vez, inicialice sus variables miembro. Luego, modifique sus notas.

void procesar() {
   Alumno a = new Alumno("Juan",13,15);
   listado(a);
   a.setNota1(19);
   a.setNota2(18);
   listado(a);
}

void listado(Alumno x) {
   imprimir("nombre: " + x.getNombre());
   imprimir("nota 1: " + x.getNota1());
   imprimir("nota 2: " + x.getNota2());
   imprimir("promedio: " + x.promedio());
}

Resultados:

nombre: Juan
nota 1: 13
nota 2: 15
promedio: 14.0

nombre: Juan
nota 1: 19
nota 2: 18
promedio: 18.5

4. ASIGNACIÓN ENTRE VARIABLES REFERENCIA 

Cuando se asigna la variable referencia ra a la variable referencia rb, se asigna la dirección de memoria contenida en ra. Luego de ello, tanto ra como rb referencian (controlan) al mismo objeto. 

Ejemplo 4:

Cilindro ra = new Cilindro(2,5);
Cilindro rb;

rb = ra;

Note que a partir de este momento tanto ra como rb se refieren al mismo objeto.

rb.setRadio(8);

Cambia por 8 el valor del radio del objeto a través de la referencia rb.

imprimir(“Radio : “ + ra.getRadio());

Extrae el valor del radio del objeto a través de la referencia ra imprime 8. 

Ejemplo 5: 

A la pulsación de un botón, cree el objeto a de la clase Alumno inicializando sus variables miembro. Luego, a través de la referencia b, modifique las notas.

void procesar() {
   Alumno a = new Alumno("Juan",13,15);
   listado(a);
   Alumno b = a;
   b.setNota1(19);
   b.setNota2(18);
   listado(a);
}

Resultados

nombre: Juan
nota 1: 13
nota 2: 15
promedio: 14.0

nombre: Juan
nota 1: 19
nota 2: 18
promedio: 18.5

Descargar ejercicios:

Descargar archivo

Preguntas:

¿Qué es un paquete?

¿Qué es un import?

¿Qué es una clase?
¿Qué es un constructor?

¿Qué es un objeto? 
¿Cómo crear un objeto? 
¿Cómo acceder a los miembros de una clase?

¿Qué es control de acceso y encapsulamiento? 
¿Qué es un modificador de acceso? 
¿Qué son los métodos de acceso?

¿En qué consiste la asignación entre variables referencia?