2.
4 Construcción de clases y objetos en Java
2.4.1. Definición de una clase
2.4.1.1 Miembros de una clase:
Formato para construir una clase:
class Nombre_clase
{
m-a tipo de dato nombre_identificador_1;
:
m-a tipo de dato nombre_identificador _n;
m-a tipo de dato nombre_del_método ( lista de
parámetros )
{ /* Declaración de identificadores locales al método */
tipo de dato nombre_ Identificador_1;
:
tipo de dato nombre_ Identificador_n;
/* Bloque de Instrucciones */
_________
_________
return identificador;
}
}
Estos datos son
globales a la clase
Estos datos son locales
al método
Los parámetros formales:
- son valores que se suministran al método en forma de variables, objetos y/o
constantes,
- deben ser declarados con su tipo de dato correspondiente y
separados por coma.,
- son locales al método, lo cual significa que serán
reconocidos sólo en el método donde están declarados.
Paso de parámetros por valor: Todos los tipos de datos primitivos (int, long, float,
double, boolean), se pasan en los métodos por valor. En otras palabras, sus valores se
copian en nuevas posiciones, que se pasan al método; como consecuencia de esto, si un
argumento se cambia dentro de un método no se cambiará en el programa llamador
original.
Paso de parámetros por referencia: Los objetos, los arreglos y cadenas pasan por
referencia. El paso de un objeto significa que la referencia del objeto se pasa a un
parámetro formal. Cualquier cambio al objeto local que suceda dentro del cuerpo del
método afectará al objeto original que se pasa como argumento.
2.4.3 Modificadores de acceso.
Con el fin de mantener la característica de ocultar en POO, se debe considerar cómo se
accede a los miembros de la clase. Normalmente, es una buena práctica restringir el acceso
a los datos y métodos de una clase que se utiliza para definir el objeto. Esta práctica de
limitación del acceso a cierta información interna se llama ocultamiento .
A continuación, se presenta un cuadro de los modificadores de acceso en Java, donde
se pueden especificar y cómo funcionan:
Modificadores Clase Métodos Datos Funcionamiento
Por defecto Un dato o método es visible en esta clase.
si si si Un método o dato es visible en el objeto
La clase es visible en este paquete.
public si si si Un dato o método es visible en esta clase.
Un método o dato es visible en el objeto
Una clase es visible a todos los programas
de cualquier paquete.
private no si si Un método o dato es visible en esta clase
y no visible en la subclase.
Un método o dato no es visible en el
objeto
protected no si si Un método o dato es visible en esta clase
y en las subclases.
Un método o dato es visible en el objeto
Cuando especificamos modificadores de acceso (public o por defecto) a una clase su
funcionamiento es de la siguiente manera:
public por defecto
/*La clase es accesible dentro de /*La clase es accesible dentro del paquete
cualquier paquete, todos los donde esta la clase */
paquetes la pueden usar */
public class BufferedReader
class Ejemplo
extends Reader {
{
...
} }
Cuando creamos un objeto, lo hacemos instanciándolo a una clase.
A continuación se presentan unos ejemplos de los modificadores de acceso en Java y
como funcionan en el objeto:
El símbolo significa que no es visible para el objeto o en otras palabras que el
objeto no lo puede usar.
Ejemplos:
-Acceso privado Objeto : cajachica
class Rectangulo
{ private int longitud;
private int ancho ;
private calcular( )
{ longitud ancho
2.0 3.0
}
calcular()
}
. . .
cajachica.longitud = 3; /* ERROR */
cajachica.calcular( ); /* ERROR */
-Acceso por defecto, público o protegido:
class Rectangulo Objeto : cajachica
{ int longitud;
protected int ancho ;
public void calcular( )
{
longitud ancho
2.0 3.0
}
} . . . calcular()
cajachica.longitud = 3;
cajachica.calcular( );
Ejemplo de modificadores de acceso
2.4.4 Declaración y Creación de un Objeto.
Un objeto es una variable por referencia, este tiene la capacidad de guardar una dirección
de memoria.
Una vez definida la clase se pueden crear muchas instancias de una clase.
Todos los objetos deben ser declarados antes de ser utilizados.
Formatos de declaración de objetos en Java.
Formato # 1:
Nombre_clase nombre_objeto_1 ; //declara el objeto y contiene basura
nombre_objeto_1 = new Nombre_clase (lista de párametros ) ; //crea el objeto
Es el constructor
Ejemplo:
//declara el objeto
Rectangulo cajachica; o
Rectangulo cajagrande; Rectangulo cajachica, cajagrande;
cajachica cajagrande
basura basura No apunta a
nada
//crea el objeto
cajachica = new Rectangulo( ) ;
cajagrande = new Rectangulo( ) ;
Formato # 2:
Nombre_clase nombre_objeto_1 = new Nombre_clase( ) ;//declara y crea el
objeto
Es el constructor
Ejemplo :
Rectangulo cajachica = new Rectangulo ( ) ;
Clase Objeto : cajachica
Rectangulo Se Se instncia
2.4.5 Acceso alongitud
datos y métodos longitud ancho
ancho
Después que se ha creado un objeto, se puede acceder a sus elementos con el formato
siguiente: calcular( ) calcular()
El operador para acceder a los miembros de un objeto es el punto (w)
nombre_objeto.nombre_del_método ([lista parámetros actuales] )
Donde lista de parámetros actuales pueden ser identificadores y/o constantes, que serán
enviados al método llamado. Los argumentos deben corresponder en tipo, orden y cantidad
con la lista de parámetros del método.
Definición
Definicióndedeununmétodo
método(formal_1,formal_2,
(formal_1,formal_2,......formal-n)
formal-n)
Invocación
Invocacióndel
delmétodo
método(actual_1,
(actual_1,actual_2,
actual_2,......actual_n)
actual_n)
Correspondencia de parámetros actuales y formales
2.3.1.2.3. Métodos Especiales (constructor y destructor)
Constructor: es un método que sirve para construir un nuevo objeto y asignar valores
iniciales a sus miembros datos. Al no existir un constructor, el compilador genera uno
automáticamente o por defecto.
Los constructores se caracterizan por:
-tener el mismo nombre de la clase que inicializa
-no devuelven valores
- puede admitir parámetros como cualquier método
- puede existir más de un constructor e incluso no existir
- no deberán desarrollarse para otra tarea que no sea de inicializar un objeto
Ejemplo:
clase Rectangulo
{ float longitud ;
float ancho ;
Rectangulo(float lon, float a)
{ longitud = lon ;
ancho = a ;
}
: }
Activación del constructor:
Rectangulo Cajachica = new Rectangulo (2.0, 3.0) ;
Rectángulo Cajagrande = new Rectangulo (10.0, 20.0) ;
Destructor: es un método que libera o limpia el almacenamiento asignado a los objetos
cuando se crean. Toda clase tiene el método constructor por defecto
Definición o dominio del problema (enunciado):
Leer dos lados de un triángulo, calcular la hipotenusa H = cat12 + cat22
y presentar el resultado
Análisis Orientado a Objetos y Diseño Orientado a Objetos
De la definición del problema debemos ahora poder identificar cuáles serían las
entidades (objetos), entradas, procesos y salidas que serán requeridas por el
Análisis y Diseño Orientado a Objetos. Esto se puede obtener a través de las
siguientes preguntas:
1. Cuál es el objeto a estudiar? Para obtener la clase.
2. Que datos de entrada me proporciona el problema? Son los atributos.
Estos pueden ser variables o constantes.
3. Cuál es la información de salida? Es información a imprimir o desplegar.
4. Qué procesos debo realizar para obtener la salida? Son los métodos
Volviendo al Ejemplo, podemos determinar los siguientes datos:
OBJETO: Hipotenusa
DATOS ENTRADA: cat1, cat2
PROCESO: cat12 +cat22
SALIDA : h
Diseño Orientado a Objetos
Representación del diseño de clases utilizando un Diagrama
UML
Hipotenusa
- flotante cat1
- flotante cat2
+ asignar_val ( )
+ flotante calcular_hip( )
Ejemplo codificado en el lenguaje Java:
/ * Programa en Java */
import java.io.*;
class Hipotenusa {
private float cat1,cat2;
/*el constructor no se definió, por lo que existe es el
constructor por defecto*/
public void asignar_val(float a, float b)
{
cat1=a;
cat2=b;
}
public double calcular_hip()
{double h;
h=Math.sqrt(Math.pow(cat1,2) + Math.pow(cat2,2));
return (h);
}
}
//Programa Principal
class Hipotenusap
{ public static void main (String [] arg) throws IOException {
float a,b;
double res;
/* se crea el objeto */
Hipotenusa obj_hip = new Hipotenusa();
//Activación de mensajes o llamados de métodos a ejecutar
obj_hip.asignar_val(2,3);
res=obj_hip.calcular_hip();
System.out.println("Hipotenusa es = "+res);
} }
