Unidad 2 Clases y Objetos

Programación Orientada a Objetos I.T.S.A.

Unidad 2Clases y Objetos

2. Clases y Objetos.

Como ya se había mencionado en temas anteriores una Clase es una parte de un programa compuesta por un conjunto de miembros, estos pueden ser: Atributos, Métodos y Objetos

Cuando hablamos de Atributos, nos referimos a las características principales o instancias a la cuales se recurren para guardar y conservar un dato. El control y manejo de esos datos se llevan a cabo en un Método por medio de un algoritmo, donde un algoritmo es un conjunto de actividades que permiten encontrar la solución un problema o una tarea específica.

1. Declaración de clases:

Para la declaración o implementación de una clase, sabiendo que está compuesta por miembros entre ellos el método, para los método existen dos tipos, uno llamado método primario (main) y el otro llamado secundario, este último se crea con cualquier nombre o cadena de caracteres, que sirvan como identificador para diferenciar el método por su nombre.

Una clase se puede dar de dos maneras, una de ellas donde sólo puede contar o implementar únicamente métodos secundarios y dicha clase se llama clase de aplicación y cuando la clase contiene implementado el método principal se le conoce como clase principal, como se muestra en inciso a), b) de la Figura 1.

Ing. C. Sánchez P. Página 1


1.1. Atributos, Métodos, Encapsulamiento.

Los Atributos se pueden diferenciar dos maneras principalmente, que son: Los atributos de primera instancia (variables Globales) y los instanciados al método (variables Locales), este último se utiliza para el envío y recepción de datos conocidos como instancias o variables de acarreo, para los pasos de parámetros

El paso de parámetro es una técnica en la manipulación de datos de un método a otro o de una clase a otra.

Declaración de atributos:

Para la declaración de los atributos también tiene ciertas diferencias entre las instanciadas a la clase y al método:

Formato:Modoacceso TipodeDato identificador;

Para los modos de acceso existen varios modos, que son: predeterminado (static), público (public), privado (private) y protegido (protected), cada uno con su respectiva característica, las diferencias se aprecian al vincular más de una clase.

El Tipo de Dato, se refiere a los tipos de datos primitivos que son:

Numérico Entero: short, int, long, byteNumérico Fraccional doublé, floatCarácter charCadena String

Existen otros tipos llamados tipos referenciados, no son más que tipos prefabricados del mismo lenguaje de programación, para el caso de java, existen los: Array, interfaz, clase, etc. Sintaxis, para la declaración de variables y constantes de primera instancias:

static int var;final static int varCte=10;

la diferencia existe en que la constante se declara anteponiéndole la palabra reservada ‘final’, con esto se le indica que es una identificador constante, (puesta en código, con la figura 2) .



y para la declaración de variables instanciadas al método, son similares con la diferencia que no tienen el modo de acceso con en la figura 3:

Los Métodos no son más que algoritmos o sub algoritmos de un problema general, estos métodos ayudan a comprender mejor la solución de problema, ya que cada uno de ellos puede realizar una tarea específica y hace que un problema extenso se desglose en sub algoritmos, donde en un método principal (main) se puedan controlar para su interacción, como en la figura 4.

El término de Encapsulamiento, no más que una característica y capacidad del lenguaje para hacer que un identificador soporte más de un dato a la vez.



Para algunos lenguajes manejaron y manipularon los arreglos de datos, esto consistía en que un identificador declarado de cierto tipo de dato pudiera almacenar más de un elementos a la vez y poder controlarlos por medio un índice, que señala la posición de cada elemento en el arreglo.

En los LPOO, permitió que sus clases pudieran declarar variables, estas se llamarían objetos, dichos objetos tiene la capacidad de encapsular todos los recursos de la clase que los crea, como en la figura 5.

Con la variable ‘Obj’, se puede referenciar los métodos y los atributos de primera instancia de la clase, por el modo de acceso que se tenga para ello, hay otros medios que más adelante estudiaremos

2. Instanciación de una clase.

La instanciación de una clase consiste en las declaraciones de sus miembros, como se ha mencionado en los temas anteriores, es primordial especificar estos miembros el modo de acceso que se le hará, para que se pueden referenciar por los objetos.

Sintaxis para invocar un miembro por medio de un objeto:

Formato:

Objeto.Miembro;

Este miembro puede ser una variable o un método y el objeto es una variable declarada por la clase, que más adelante detallaremos.

Sintaxis:

Obj.Var; // para cuando se trata de una variable de primera instancia



Obj.Metodo(); // para cuando se trata de un método

3. Referencia al objeto actual.

Como ya se había dicho en temas anteriores, para referenciar un miembro de la clase, se debe hacer con el objeto declarado y creado por la clase, esta declaración se lleva a cabo por la clase y la creación por su constructor este o no implementado.El constructor consiste en un método que lleva el mismo nombre que la clase, en algunos caso es necesario implementarlo y de no hacerlo existe uno por default, donde la declaración y creación se realiza de la siguiente manera.

Formato en la declaración y creación de un objeto.

NomClase Obj; // declaración del objetoObj = new NomClase(); // creación del objeto.

Estas dos instrucciones se pueden escribir en una sola línea, de la forma:

NomClase Obj = new NomClase();

Después de esta instrucción el objeto ‘Obj’ tiene todos los derechos de manipular los miembros de la clase que lo declara y crea.

Pero no siempre es así, existe una palabra reservada del lenguaje llamada this, ésta funciona o hace el papel de un objeto creado, y se puede utilizar sin ser declarada y creada, con la diferencia que no funciona en los métodos estáticos y se usa de la misma forma que un objeto creado, para instanciar los miembros.

Por ejemplo:

this.Metodo(); //llamando el miembro metodo

o bien

this.Atributo; //siendo Atributo una variable de primera instancia



4. Métodos:

Veamos el siguiente ejemplo para la implementación de métodos, tal como lo indica el ejemplo del Ejercicio 1.

Práctica1, Considera el ejemplo de la Ejercicio 1 y complemente los método de la aritmética de Resta(), Multiplar(), Modulo() y la Divison(), controlados en un menú.

Práctica 2. Una clase que haga lo mismo de la primera práctica, donde se aplique el JOptionPane, para las entradas y salidas de dato

4.1. Declaración, mensajes, paso de Parámetros, retorno de valores.

Paso de parámetro. Es una técnica en la programación que permite y facilita la compartición de datos compatibles de un sitio a otro, para ello existe dos tipos de paso de parámetros:


/* Ejemplo 1* Esta Clase permite probar la utilidad de los métodos; * Elaborado por: */

import java.util.Scanner;class MetodoSuma{ // El metodo Suma opera con dos variables public static void Suma()

{int x=0, y=0, z=0;Scanner Leer = new Scanner(System.in);System.out.print("Digite el vaolr de x"); x= Leer.nextInt(); //lee un valor para xSystem.out.print("Dijite el valor de y"); y= Leer.nextInt(); //lee un valor para yz= x+y; //suma x+ySystem.out.println("La suma de "+x+" + "+y+" = "+z);

}

//prepara aquí los demás método de la aritmética

public static void main(String[] var){ Suma(); // preparar aquí el menú que controle los métodos }

}


Paso de parámetro por valorPaso de parámetro por referencia

En el Paso de parámetro por valor, consiste en que una variable otorga una copia de su valor a otra variable, dicha de otra manera, pasar el valor o contenido de una variable a otra. Por ejemplo:

X=Y, siendo X,Y dos variables del mismo tipo y la asignación como el paso de parámetro más simple que puede haber.

Para el Paso de parámetro por referencia, tiene un enfoque similar al de paso de parámetro por valor, con la diferencia que en este lo hace a nivel objeto, es decir, que un objeto concede una copia de la a otro objeto, lo complejo en estos caso es, que los objeto trabajan con direcciones de memoria, e implica que si se hace mal uso de la dirección, puede provocar errores muy fuerte en la obetencion del os datos. Por ejemplo

NomClase ObjA, ObjB; //declaración de dos objetos

ObjA = new NomClase(); //creación de memoria para el objeto A

ObjB = ObjA; //el ObjA, le pasa una copia al ObjB

En esta última instrucción es donde ve la aplicación del paso de parámetro por referencia. En base a lo descrito en el ejemplo de la Ejemplo 1, veamos un caso para la aplicación en el envío de mensajes como paso de parámetros en el Ejercicio 2


/*Ejercicio 2 1/2* Esta clase nos permite mostrar el uso y la aplicación de los paso de parámetros, ya sea en * envío del mensaje y el retorno de los datos */ import javax.swing.JOptionPane; class PPxValor { // El método Suma recibe un par de operando, sin retorno

public static void Suma(int x, int y){ int z=0; String Cad=""; z = x+y; // realiza el cálculo Cad="La Suma de "+x+" + "+y+" = "+z; JOptionPane.showMessageDialog(null,Cad); //emite la salida

} //El método de Resta, recibe un par de valores y retorna la respuesta public int Resta(int x, int y) { return (x-y); } //calcula y retorna //El método re Division, recibe un par de valores de tipo flotante public static float Division(float x, float y) { return (x/y); } //calcula y retorna un tipo flotante


Observa ahora en el llamado del método de la división, se le envían dos valores de tipo numérico entero y en la implementación del método los reciben dos variables de tipo numérico fraccional, esto indica que se puede realizar esa conversión en el envío de los datos.

Práctica 3, considere el ejercicio 2, para complementarlo con los demás métodos e implementar su menú para su mejor control.

Ahora observemos el ejemplo 3, que nos muestra el uso y la aplicación de un paso de parámetro por referencia.


2/2 public static void main(String[] var){ int a=0, b=0, c=0; double z=0.0; String Cad="";

Cad = JOptionPane.showInputDialog(null,"Digite el valor de a "); a = Integer.parseInt(Cad); Cad = JOptionPane.showInputDialog(null,"Digite el valor de b "); b= Integer.parseInt(Cad); PPxValor Obj = new PPxValor(); Obj.Suma(a,b); // llamando a Suma, enviando dos argumentos c = Obj.Resta(a,b); //invocando a Resta, enviando dos argumentos z= Obj.Division(a,b); //invocando a Division con dos argumentos Cad="La Resta de "+a+" - "+b+" = "+c+"\n"; Cad = Cad+" y la Division de "+a+" / "+b+" = "+z; JOptionPane.showMessageDialog(null,Cad); }

}

/* Ejemplo 3 1/2* En esta clase solo veremos el uso y la aplicación de un paso de parámetros por referencias */import javax.swing.JOptionPane;class PPxRef{

protected int X,Y,Z;

public int Generador(){ int Valor =0; // declaracion de la variable Valor Valor = (int)(Math.random() * 100 ); //generacion de dato aleatorioreturn Valor; // retorno del valor generado}



2/2//implementacion del metod principalpublic static void main(String[] var){ String Cad="";

PPxRef Obj1 = new PPxRef(); //declaracion y creacion de Obj1 // La variable Cad, recoge los datos iniciales de las instancias Cad ="Los valores iniciales de las instancias son \n"; Cad = Cad+"X = "+Obj1.X+", Y = "+Obj1.Y+", Z = "+Obj1.Z+"\n";

JOptionPane.showMessageDialog(null,Cad); // imprime los datos

Obj1.X = Obj1.Generador(); //generando el valor de X Obj1.Y = Obj1.Generador(); //generando el valor de Y // la variable Cad, recoge nuevos datos Cad = Cad+"Ahora se tiene generado el valor de X, Y \n"; Cad = Cad+"Obj1.X = "+Obj1.X+", Obj1.Y = "+Obj1.Y+", Obj1.Z = "+Obj1.Z+"\n";JOptionPane.showMessageDialog(null,Cad); //imprime los datos

PPxRef Obj2; // declaracion de un objeto Obj2 = Obj1; // realizando un paso de parametro por referencia

// ahora la variable Cad, recoge nuevos datos del obj2 Cad = Cad+"Ahora se tiene generado el valor de X, Y \n"; Cad = Cad+"Obj2.X = "+Obj2.X+", Obj2.Y = "+Obj2.Y+", Obj2.Z = "+Obj2.Z+"\n";JOptionPane.showMessageDialog(null,Cad); //imprime los datos

// ahora el Obj2 manipulara las instancias Obj2.Z = Obj2.X + Obj2.Y; // ahora la variable Cad, recoge nuevos datos del obj2, ya manipulados

Cad = Cad+"Ahora el Obj2, actualiza a Z\n"; Cad = Cad+"Obj1.X = "+Obj1.X+", Obj1.Y = "+Obj1.Y+", Obj1.Z = "+Obj1.Z+"\n"; Cad = Cad+"Obj2.X = "+Obj2.X+", Obj2.Y = "+Obj2.Y+", Obj2.Z = "+Obj2.Z+"\n";JOptionPane.showMessageDialog(null,Cad); //imprime los datos

PPxRef Obj3 = new PPxRef(); //declaracion y creacion del Obj3 Obj3.X = Obj3.Generador(); //generan un nuevo valor para X Obj3.Y = Obj3.Generador(); //generando un nuevo valor para y Obj3.Z = Obj3.X * Obj3.Y; //el Obj3, opera sus elementos Cad = Cad+"Ahora se crea un tercer objeto\n con datos propios\n"; Cad = Cad+"Obj1.X = "+Obj1.X+", Obj1.Y = "+Obj1.Y+", Obj1.Z = "+Obj1.Z+"\n"; Cad = Cad+"Obj2.X = "+Obj2.X+", Obj2.Y = "+Obj2.Y+", Obj2.Z = "+Obj2.Z+"\n"; Cad = Cad+"Obj3.X = "+Obj3.X+", Obj3.Y = "+Obj3.Y+", Obj3.Z = "+Obj3.Z+"\n";

JOptionPane.showMessageDialog(null,Cad); //imprime los datos }}


5. Constructores y destructores:

Un constructor, es un método que lleva el mismo nombre que la clase, se considera como el corazón de la clase, ya es el que le da vida a los objetos para encapsular los miembros de una clase.

Las características principales de un constructor son varios:

Permite inicializar las instancias de la claseNo tienen valor de retornoExiste siempre uno por defaultExisten varios tiposAyudan en la creación de los objetos

La finalidad de un constructor, es crear un espacio de memoria donde se puedan trabajar los miembros de una clase, esto significa que por medio de un encapsulamiento que es representado por una variable declarada por la clase y creada por el constructor y que es llamado como objeto, hace posible el trabajo más sencillo para la operación de miembros de su clase. Por ejemplo, en la figura 6, nos muestra la implementación de un constructor:

Destructores, conocido también como recolector de basura, tiene una finalidad de limpiar la memoria ocupada por los constructores en tiempo de ejecución de los miembros de una clase, es decir, cada vez que se crea un objeto se reserva un espacio de memoria y cuando cierra la aplicación este espacio se elimina, en algunos lenguajes es necesario señalar e implementar los destructores.



Para el caso de Java, cuenta con un recolector de basura, esto indica que no es necesario implementar los destructores, que al cerrar la ejecución de la clase automáticamente se elimina el uso de la memoria, pero cuando dichas clases son inter-conectadas, en el caso de las herencias entre clase, es importante señalar la forma de interactuar con sus destructores, que esto le veremos más adelante

5.1. Declaración, uso y aplicaciones.

Veamos el siguiente ejemplo (Ejemplo 4), esta clase nos muestra la implementación de los constructores, como ya había mencionado antes en las características, existen varios tipos.

Un constructor puede estar vacío (conocido como constructor por default) o recibir parámetros para actualizar las instancias, estos parámetros pueden ser entre las variable (Común) o entre los objetos (por Copia), cuando se da entre los objetos se dice que un constructor por copia


/*Ejemplo 4.*Este ejemplo nos muestra la aplicación de los constructores */

import javax.swing.JOptionPane;class Constructores{ public int X,Y,Z; public Constructores(String Cadena) {JOptionPane.showMessageDialog(null, Cadena);}

public Constructores(String Cadena, int a, int b){ X=a; Y=b; Cadena = Cadena +"\nX = "+X+"; Y = "+Y; JOptionPane.showMessageDialog(null, Cadena);} // fin del constructorpublic Constructores(String Cadena, Constructores C){ X=C.X; Y=C.Y; Z = X*Y; Cadena = Cadena +"\nX = "+X+"; Y = "+Y+"; Z = "+Z;

JOptionPane.showMessageDialog(null, Cadena);} //fin del constructor

public int Generador(){ int Valor =0; // declaracion de la variable Valor Valor = (int)(Math.random() * 10 ); //generacion de dato aleatorio

return Valor; // retorno del valor generado}

public static void main(String[] arg){ Constructores Obj1 = new Constructores("Inicia el constructor vacio...");

Constructores Obj2 = new Constructores("se activa el constructor, iniciando valores a X, Y",Obj1.Generador(), Obj1.Generador() );

Constructores Obj3 = new Constructores("se activa el constructor, iniciando valores a X, Y",Obj2); } }


6. Sobrecarga de métodos.

Se entiende por sobrecarga aquella función que realiza más de una tarea específica a la vez, en la programación surgen esos detalles, donde un método puede esta implementado más una vez, y en cada implementación realice una tarea distinta.

Cuando esto sucede en los constructores se dice que hay una sobrecarga de constructores y cuando se da en los métodos de expresa como una sobrecarga de métodos.

Ara que esto se dé, es importante señalar las diferencias, para que a la hora de invocar el método, el manejador no se equivoque de referencia.

Veamos el siguiente ejemplo (Ejemplo 5) para la sobre carga de métodos.

Observemos los métodos Operador, la diferencia es en el número de argumentos en el paso de parámetros y la tarea de cada uno, ahora para probar la aplicación veamos el siguiente ejemplo (Ejemplo 6).


/* Ejemplo 5.*En esta clase nos muestra el uso y aplicacion de la sobre carga */

import javax.swing.JOptionPane;class SobreCarga{ // Este metodo permite generar un vlor aleatoriamente

public int Operador(){int x=0; // decl la var 'x' x = (int)(Math.random() * 10 ); //genera aleatoriamente valor de 'x' return x; // retorna el valor 'x'}

//Este Operador, recibe un param y lo eleva al cuadrado public int Operador(int a) { return a*a; } // retorna el cuadrado de 'a'

//Este tercer operador calcula el módulo de 'a' entre 'b' public int Operador(int a, int b) { return a%b; } //retorna el módulo de la división}



/* Ejemplo 6.*En esta clase se prueba la sobrecarga de la clase SobreCarga */

import javax.swing.JOptionPane;

class PruebaSobreCarga{

public static void main(String[] args){ int a=0,b=0,c=0; // dec de tres var instanc al metodo String Cad=""; SobreCarga SC = new SobreCarga(); //se crea un objeto de la clase SobreCarga a=SC.Operador(); Cad = "El Valor generado de a = "+a+"\n"; c = SC.Operador(a); Cad = Cad +"Y el Cuadrado de "+a+" = "+c+"\n"; b=SC.Operador(); Cad = Cad +" Ahora se generó el valor de b = "+b+"\n"; c = SC.Operador(a,b); Cad = Cad +"y el modulo de "+a+" % "+b+" = "+c; JOptionPane.showMessageDialog(null,Cad); }

}


Ahora analicemos los siguientes ejercicios, que utilizan con estructura un arreglo unidimensional, para cada uno de estos ejemplos hay que hacerlos para cuando se maneja una matriz y un cubo.

Veamos el siguiente ejemplo (Ejemplo 7)


/* Ejemplo 7. 1/2** En este clase se analizará el uso y aplicación de un arreglo unidimensional (vector o lista)** en conjunto con suu operaciones básicas */ import javax.swing.JOptionPane;

class UsoArreglo{ //implementacion de un metodo generador de datos aleatorio public int Generador() { return (int)(Math.random() * 100); } //implement el metodo que almacena datos en un vector public int[] Almacenar(int[] B, int n) { for(int i=0; i<n; i++) { B[i] = Generador(); } //invoc al generador y llena el vector return B; // retorna el arreglo lleno } // fin del metodo //implement el metodo que visualiza los datos del vector public void Visualiza(int[] A, int n) { String Cad = ""; // declarac de la variab Cad, Cad="Los elem del arreglo son: \n"; for(int i=0; i<n; i++) { Cad = Cad +A[i]+", "; } JOptionPane.showMessageDialog(null,Cad); } // fin del metodo //implement el metodo que ordena los elem del arreglo public int[] Ordenar(int[] A, int n) {int i=0, j=0, Aux=0; //declarac de dos índices

for(i=0; i<(n-1); i++) //inicia el ciclo del punto pivote {for (j=i; j<n; j++) // " el ciclo del rastreo { if(A[i] > A[j]) //compara si el elem que apunta 'i'> que al que apunta 'j' { Aux= A[i]; // aux toma el elem que apunta 'i' A[i] = A[j]; //ahora el elem que apunta 'j' se asigna donde apunta 'i' A[j] = Aux; //por ultimo Aux se asigna donde apunta 'j' } } // fin del ciclo del rastreo } //fin del ciclo del punto pivote return A; // retorna todo el arreglo ya ordenado de menor a mayor } // fin del metodo



2/2 //implement el metodo de búsqueda //implement el metodo de Modificacion //implement el metodo de Eliminacion public void MenuVector() { int n=0, Opc=0; // declarac 'n' como tamaño del vector String Cad="",Opcion=""; int[] A; // declarac 'A' como vector //pedir el tamaño del vector Cad = JOptionPane.showInputDialog(null,"Para cuántos Elem ?"); n= Integer.parseInt(Cad); // convert la cadena en valor numerico A= new int[n]; //creando el vector segun el tamaño 'n' Cad = "MENU PRINCIPAL \n" +"1.- Almacenar un vector \n" +"2.- Visualizar los elem del vector \n" +"3.- Ordenar de forma ascendente el vector \n" +"4.- Buscar un elem sobre el vector \n" +"5.- Modificar un elem del vector \n" +"6.- Eliminar un elem del vector \n" +"7.- Finalizar \n" +" Digite una Opcion "; do{ // inicia un ciclo do-while Opcion = JOptionPane.showInputDialog(null,Cad); Opc= Integer.parseInt(Opcion); // convert la cadena en valor numerico switch(Opc) { case 1: A=Almacenar(A,n); break; case 2: Visualiza(A,n); break; case 3: A = Ordenar(A,n); break; case 7: System.exit(0); default:JOptionPane.showMessageDialog(null,"Opcion Invalida,,,");break; } }while(Opc!=7); // fin del ciclo do-while } // fin del metodo Menu //implementando el metodo primario public static void main(String[] vars) { UsoArreglo Obj = new UsoArreglo(); //se crea el objeto Obj.MenuVector(); // se invoca el Menu }}


Practica 4. Ahora considerando el ejemplo 7, complementen los demás métodos que hacen falta para tener las operaciones básicas sobre un arreglo.


Unidad 2 Clases y Objetos

Documents

Transcript of Unidad 2 Clases y Objetos