PROG.

ORIENTADA A OBJETOS

Periodo:
Enero – Junio /2024

Investigación : tema 2

Maestro: Adriana Leticia Medellín

Alumnos:

Francisco Eloy Ramírez Mesquitic 23260226

Brando Peralta Gallardo 23261102
Juan Pablo Vela Ramos 23260262
Luis Fernando Medellín Estrada 23260208
Mario Zahid Smer Morenos 22260074

Carrera: Ing. Sistemas Computacionales

 2.1 DECLARACIÓN DE CLASES: ATRIBUTOS, MÉTODOS,
ENCAPSULAMIENTO

La declaración de una clase define la estructura de la misma. Dicho de otra forma,

la declaración de una clase informa de los elementos que la conforman.
Posteriormente a ser declarada, una clase debe ser implementada
convenientemente, es decir, se debe escribir el código correspondiente a los
procedimientos y funciones que determinan el funcionamiento de esa clase.
Las clases se declaran en la sección TIPO del script pues las clases son, al fin y al
cabo, tipos de datos.
La programación orientada a objetos se basa en la programación de clases; a
diferencia de la programación estructurada, que está centrada en las funciones.
Una clase es un molde del que luego se pueden crear múltiples objetos, con
similares características.
Una clase es una plantilla (molde), que define atributos (variables) y métodos
(funciones)
La clase define los atributos y métodos comunes a los objetos de ese tipo, pero
luego, cada objeto tendrá sus propios valores y compartirán las mismas funciones.
Debemos crear una clase antes de poder crear objetos (instancias) de esa clase. Al
crear un objeto de una clase, se dice que se crea una instancia de la clase o un
objeto propiamente dicho.

Tipos de atributos.

Objetivos:

a) Profundizar en el concepto de atributo de una clase e indicar los tipos de atributos

en Java
b) Interpretar el código fuente de una aplicación Java donde aparecen distintos
tipos de atributos
c) Construir una aplicación Java sencilla, convenientemente especificada, que
emplee clases con diferentes tipos de atributos.

Los atributos, también llamados datos o variables miembro son porciones de

información que un objeto posee o conoce de sí mismo. Una clase puede tener
cualquier número de atributos o no Tener ninguno. Se declaran con un identificador
y el tipo de dato correspondiente.

Modificador Visibilidad
public Pública (+)
protectec Protegida / en la herencia(#)
private Privada(-)
package De paquete (~)
Métodos

Java como todo lenguaje de programación orientado a objetos utiliza los llamados
métodos. A continuación veremos cómo se crea un método y como se utilizan.
Se podría decir que existen 2 grandes tipos de métodos, el primer tipo de método
son métodos que realizan procesos, puedes realizar cualquier operación con ellos,
sin embargo el propósito es manipular variables existentes. El segundo tipo de
métodos son los que realizan un proceso o cálculo, y calculan una variable
específica, un ejemplo podría ser un método para obtener el valor de una
multiplicación.
Los métodos en java pueden tener parámetros, es decir, que un método puede
utilizar variables predefinidas para ser utilizadas en sus procesos.

Encapsulamiento

Como se puede observar de los diagramas, las variables del objeto se localizan en
el centro o núcleo del objeto. Los métodos rodean y esconden el núcleo del objeto
de otros objetos en el programa. Al empaquetamiento de las variables de un objeto
con la protección de sus métodos se le llama encapsulamiento. Típicamente, el
encapsulamiento es utilizado para esconder detalles de la puesta en práctica no
importantes de otros objetos. Entonces, los detalles de la puesta en práctica pueden
cambiar en cualquier tiempo sin afectar otras partes del programa.

El encapsulamiento de variables y métodos en un componente de software

ordenado es, todavía, una simple idea poderosa que provee dos principales
beneficios a los desarrolladores de software.

Modularidad

esto es, el código fuente de un objeto puede ser escrito, así como darle
mantenimiento, independientemente del código fuente de otros objetos. Así mismo,
un objeto puede ser transferido alrededor del sistema sin alterar su estado y
conducta.
Ocultamiento de la información, es decir, un objeto tiene una "interfaz publica" que
otros objetos pueden utilizar para comunicarse con él. Pero el objeto puede
mantener información y métodos privados que pueden ser cambiados en cualquier
tiempo sin afectar a los otros objetos que dependan de ello.
Los objetos proveen el beneficio de la modularidad y el ocultamiento de la
información. Las clases proveen el beneficio de la reutilización. Los programadores
de software utilizan la misma clase, y por lo tanto el mismo código, una y otra vez
para crear muchos objetos.
En las implantaciones orientadas a objetos se percibe un objeto como un paquete
de datos y procedimientos que se pueden llevar a cabo con estos datos. Esto
encapsula los datos y los procedimientos. La realidad es diferente: los atributos se
relacionan al objeto o instancia y los métodos a la clase. ¿Por qué se hace así? Los
atributos son variables comunes en cada objeto de una clase y cada uno de ellos
puede tener un valor asociado, para cada variable, diferente al que tienen para esa
misma variable los demás objetos. Los métodos, por su parte, pertenecen a la clase
y no se almacenan en cada objeto, puesto que sería un desperdicio almacenar el
mismo procedimiento varias veces y ello va contra el principio de reutilización de
código.

2.2 INSTANCIACIÓN DE UNA CLASE

Podemos interpretar que una clase es el plano que describe como es un objeto de
la clase, por tanto podemos entender que a partir de la clase podemos fabricar
objetos. A ese objeto construido se le denomina instancia, y al proceso de construir
un objeto se le llama instanciación.
Cuando se construye un objeto es necesario dar un valor inicial a sus atributos, es
por ello que existe un método especial en cada clase, llamado constructor, que es
ejecutado de forma automática cada vez que es instanciada una variable.
Generalmente el constructor se llama igual que la clase y no devuelve ningún valor.
Análogamente, destructor es un método perteneciente a una clase que es ejecutado
de forma automática cuando un objeto es destruido. Java no soporta los
destructores. Es posible que exista más de un constructor en una clase,
diferenciados sólo en los parámetros que recibe, pero en la instanciación sólo será
utilizado uno de los constructores.

Ejemplo:

clase base

package ejemplo_de_libro;

import java.util.Scanner;
public class Main {

public static void main(String[] args) {

Scanner entrada = new Scanner(System.in);
LibroCalificaciones miLibroCalificaciones = new LibroCalificaciones();
System.out.println("Escribe algo: ");
String nombreDelCurso = entrada.nextLine();
System.out.println();
miLibroCalificaciones.mostrarMensaje(nombreDelCurso);
 }
}

clase derivada
package ejemplo_de_libro;

public class LibroCalificaciones {

public void mostrarMensaje(String nombredelsaludo)
{
System.out.printf("Bienvenido al libro de calificaciones para :\n%s\n",
nombredelsaludo);
}
}

2.3 REFERENCIA AL OBJETO ACTUAL

La utilización de THIS en lugar de hacer referencia explícitamente al objeto actual

por su nombre (por ejemplo, thisform.command1.caption) hace que el código de
programa pueda alternarse entre objetos, porque evita el nombre del objeto y
encapsula automáticamente la clase primaria del objeto.

THIS permite hacer referencia a una propiedad o un objeto de una definición de

clase. Los métodos de un bloque de definición de clase pueden utilizar THIS para
especificar una propiedad o un objeto que existirá cuando se cree la clase.

Puesto que múltiples instancias de objetos comparten el mismo código de método,

THIS siempre hace referencia a la instancia en la que está ejecutándose el código.
Si hay múltiples instancias de un objeto, y se llama a uno de los métodos del objeto,
THIS hace referencia al objeto correcto.

Cada objeto puede acceder a una referencia a si mismo mediante la palabra this.
Cuando se hace una llamada a un método no static para un objeto especifico, el
cuerpo del método utiliza en forma implícita la palabra this para hacer referencia a
las variables de instancia y los demás métodos del objeto.

Ahora demostraremos el uso implícito y explicito de la referencia this para permitir

al método main de la clase PruebaThis que muestre en pantalla los datos prívate de
un objeto de la clase TiempoSimple. Hicimos esto para demostrar que, al compilador
un archivo .java que contiene mas de una clase, el compilador produce un archivo
de clase separado por la extensión .class para cada clase compilada.
 // Ejemplo This.java

//Uso implicito y explicito de this para hacer referencia a los miembros de un objeto

public class PruebaThis

{
public static void main (String args[])
{
TiempoSimple tiempo=new TiempoSimple(15, 30, 19 );
System.out.println(tiempo.crearString());
}//fin de main
}//fin de la clase PruebaThis
//la clase TiempoSimple demuestra la referencia "this"
public class TiempoSimple
{
private int hora; //0-23
private int minuto; //0-59
private int segundo;//0-59
//si el constructor utiliza nombres de parametros identicos a
//los nombres de las variables de instancia, se reuiere la
//referencia "this" para diferenciar unos nombres de otros
public TiempoSimple (int hora,int minuto, int segundo)
{
this.hora=hora;//establece la hora del objeto "this"
this.minuto=minuto;//establece el minuto del objeto "this"
this.segundo=segundo;//establece el segundo del objeto "this"
}//fin del constructor de TiempoSimple
//usa la referencia "this" explicita e implicita para llamar StringUniversal
public String crearString()
{
return String.format("%24s:%s\n%24s:%s",
"this.aStringUniversal()",this.aStringUniversal(),
"aStringUniversal()",aStringUniversal());
}//fin del metodo crearString
//convierte a String en formato de hora universal (HH:MM:SS)
public String aStringUniversal()
{
//"this"no se requiere aqui para acceder a las variables de instancia,
//ya que el metodo no tiene variable locales con los mismos
//nombres que las variables de instancia
return String.format("%02d:%02d:%02d",
this.hora, this.minuto, this.segundo);
}//fin del metodo sStringUniversal
}//fin de la clase TiempoSimple
 2.4 MÉTODOS : DECLARACIÓN , MENSAJES , PASO DE
PARÁMETROS, RETORNO DE VALORES

Los métodos o funciones miembro se definen dentro de la clase a la que pertenecen

y constituyen la interfaz o forma de acceder a la estructura interna de los objetos es
decir a los datos privados.

Los métodos definen cual son las operaciones que se pueden realizar con los
atributos de los objetos de la clase. La ejecución de un programa orientado a objetos
consiste, en recibir, interpretar y responder unos objetos a los mensajes que envían
otros objetos. En P.O.O. un mensaje está asociado siempre con un método, de
manera que cuando un objeto recibe un mensaje la respuesta a ese mensaje es
ejecutar el método asociado

Modo de acceso:
Específica el tipo de acceso permitido indicando que usuarios de la clase podrán
acceder a ese método, los métodos son la única forma de acceso a los atributos
privados. Por defecto los métodos tienen protección paquete, es decir son
accesibles desde cualquier clase que pertenezca al mismo paquete. Todas las
clases de un mismo fichero .java pertenecen a un mismo paquete.
• Public: Accesible desde cualquier otra clase.
• Package: Accesible sólo desde el mismo paquete.
• Protected: Se comporta como un método público para los métodos
del mismo paquete o de las subclases y para el resto como un método
privado.
• Prívate: Sólo accesible a través de métodos de la propia clase.

Retorno de valores:
Un método puede devolver un valor a quien lo llama o no devolver nada. El valor
devuelto por un método puede ser de un tipo primitivo de datos o una referencia,
pero nunca puede devolver más de un valor. El valor de retorno nunca puede ser
un objeto de una superclase, sí de la misma clase o de una subclase. Si el método
no devuelve nada el tipo devuelto por el método es el tipo void.

Paso de parámetros a una función o método.

Los parámetros de una función son variables locales que se inicializan en el

momento de la llamada al método. Fuera de la función no se conocen y no pueden
ser accedidas. Se crean al entrar en la función y se destruyen al salir de ella.
El paso de parámetros o argumentos a las funciones se puede hacer de dos formas.
Paso por valor , paso por referencia.
2.5 CONSTRUCTORES Y DESTRUCTORES: DECLARACIÓN, USO
Y SUS APLICACIONES

Para crear un objeto se necesita reservar suficiente espacio en memoria e inicializar

los valores de los campos que representan el estado del objeto. Este trabajo es
realizado por un tipo especial de método denominado constructor.

Constructor
Un método constructor de una clase es un método especial que: tiene el mismo
nombre que la clase y no tiene tipo de retorno. La sintaxis para la declaración de
un método constructor es:

[atributos] [modificadores] <identificador> ( [parámetros] ) [inicializador]

{
// Cuerpo del constructor.
}
Donde: atributos (opcional) es información declarativa adicional, modificadores
(opcional) se restringen a extern y a los modificadores de acceso, identificador es el
nombre del método constructor (igual al nombre de la clase), parámetros (opcional)
es la lista de parámetros pasados al constructor, inicializador (opcional). Con el
inicializador, el constructor invoca previamente a otro constructor.
El inicializador puede ser uno de los siguientes: base([listaDeParámetros])
this([listaDeParámetros])
Cuerpo del constructor es el bloque de programa que contiene las instrucciones
para inicializar la instancia de clase (objeto).
Destructor
La sintaxis para declarar un destructor es:
[Atributos] ~ <Identificador> ( )
{
// Cuerpo del destructor.
}
Una clase solamente puede tener un destructor. Los destructores no pueden
heredarse o sobrecargarse, los destructores no pueden invocarse, sino que son
invocados automáticamente, un destructor no acepta modificadores ni parámetros,
por ejemplo, la siguiente es una declaración de un destructor para la clase Figura:
~ Figura()
{
// Instrucciones para limpiar.
}

La destrucción por defecto: Recogida de basura

El intérprete de Java posee un sistema de recogida de basura, que por lo general

permite que no nos preocupemos de liberar la memoria asignada explícitamente.
El recolector de basura será el encargado de liberar una zona de memoria dinámica
que había sido reservada mediante el operador new, cuando el objeto ya no va a
ser utilizado más durante el programa (por ejemplo, sale del ámbito de utilización, o
no es referenciado nuevamente).
El sistema de recogida de basura se ejecuta periódicamente, buscando objetos que
ya no estén referenciados.

La destrucción personalizada: finalice

A veces una clase mantiene un recurso que no es de Java como un descriptor de

archivo o un tipo de letra del sistema de ventanas. En este caso sería acertado el
utilizar la finalización explícita, para asegurar que dicho recurso se libera. Esto se
hace mediante la destrucción personalizada, un sistema similar a los destructores
de C++.
Para especificar una destrucción personalizada se añade un método a la clase con
el nombre finalice.

2.6 SOBRECARGA DE MÉTODOS

Un método sobrecargado se utiliza para reutilizar el nombre de un método pero con
diferentes argumentos (opcionalmente un tipo diferente de retorno). Las reglas para
sobrecargar un método son las siguientes:

• Los métodos sobrecargados deben de cambiar la lista de

argumentos.
• Pueden cambiar el tipo de retorno.
• Pueden cambiar el modificador de acceso.
• Pueden declarar nuevas o más amplias excepciones.
• Un método puede ser sobrecargado en la misma clase o en una
subclase.

Veamos un método que se desea sobrecargar:

public void cambiarTamano(int tamano, String nombre, float patron){ }

Los siguientes métodos son sobrecargas legales del método cambiarTamano():

public void cambiarTamano(int tamano, String nombre){}

public int cambiarTamano(int tamano, float patron){}
public void cambiarTamano(float patron, String nombre) throws IOException{}

Cómo invocar un método sobrecargado:

Lo que define qué método es el que se va a llamar son los argumentos que se
envían al mismo durante la llamada. Si se invoca a un método con un String como
argumento, se ejecutará el método que tome un String como argumento, si se
manda a llamar al mismo método pero con un float como argumento, se ejecutará
el método que tome un float como argumento y así sucesivamente. Si se invoca a
un método con un argumento que no es definido en ninguna de las versiones
sobrecargadas entonces el compilador arrojará un mensaje de error.
Reglas de la sobrecarga y sobreescritura de métodos:
Ahora que hemos visto ambas formas de reescribir métodos, revisemos las reglas
y diferencias entre ambos tipos de reescritura:
1. Argumentos: En un método sobrecargado los argumentos deben de
cambiar mientras que en un método sobreescrito NO deben cambiar.
2. El tipo de retorno: En un método sobrecargado el tipo de retorno puede
cambiar, en un método sobreescrito NO puede cambiar, excepto por
subtipos del tipo declarado originalmente.
3. Excepciones: En un método sobrecargado las excepciones pueden
cambiar, en un método sobreescrito pueden reducirse o eliminarse pero NO
deben de arrojarse excepciones nuevas o más amplias.
4. Acceso: En un método sobrecargado puede cambiar, en un método
sobreescrito el acceso NO debe de hacerse más restrictivo (puede ser
menos restrictivo).
5. Al invocar: En un método sobrecargado los argumentos son los que
determinan qué método es el que se invocará, en un método sobreescrito el
tipo de objeto determina qué método es elegido.

Ejemplo :

clase base

package sobrekarga;

public class Main {

public static void main(String[] args) {

// TODO code application logic here
articulo objarticulo=new articulo();
objarticulo.fijarprecio("70");
objarticulo.mostrarprecio();

edad objedad= new edad();

objedad.poneredad();
objedad.mostraredad();
 }
}

Clase articulo

package sobrekarga;

public class articulo {

private double precio;

public void fijarprecio(){

precio=5.50;

}
public void fijarprecio(String precio){

System.out.println("No es un valor");
}
public void fijaprecio (double precio){
this.precio=precio;
}
public void mostrarprecio(){
System.out.printf("precio es %.2f",precio);
System.out.println();
}
}

Clase edad

package sobrekarga;

public class edad {

private int edad;

public void poneredad(){

edad= 22;
}
public void poneredad(String edad){
System.out.println("no es una edad");
}
public void poneredad(int edad){
this.edad= edad;
}
public void mostraredad(){
System.out.printf("la edad es : %d ",edad);
System.out.println();
}
 }

2.7 SOBRECARGA DE OPERADORES: CONCEPTO Y UTILIDAD,

OPERADORES UNARIOS Y BINARIOS

La sobrecarga de operadores es la capacidad para transformar los operadores de

un lenguaje como por ejemplo el +, -, etc, cuando se dice transformar se refiere a
que los operandos que entran en juego no tienen que ser los que admite el lenguaje
por defecto. Mediante esta técnica podemos sumar dos objetos creados por
nosotros o un objeto y un entero, en vez de limitarnos a sumar números enteros o
reales, por ejemplo.
La sobrecarga de operadores ya era posible en c++ y en otros lenguajes, pero
sorprendentemente java no lo incorpora, así que podemos decir que esta
característica es una ventaja de c# respecto a java, aunque mucha gente, esta
posibilidad, no lo considera una ventaja porque complica el código.

A la hora de hablar de operadores vamos a distinguir entre dos tipos, los unarios y
los binarios. Los unarios son aquellos que solo requieren un operando, por ejemplo
a++, en este caso el operando es 'a' y el operador '++'. Los operadores binarios son
aquellos que necesitan dos operadores, por ejemplo a+c , ahora el operador es '+'
y los operandos 'a' y 'c'. Es importante esta distinción ya que la programación se
hará de forma diferente.

Los operadores que podemos sobrecargar son los unarios, +, -, !, ~, ++, --; y los
binarios +, -, *, /, %, &, |, ^, <<, >>. Es importante decir que los operadores de
comparación, ==, !=, <, >, <=, >=, se pueden sobrecargar pero con la condición que
siempre se sobrecargue el complementario, es decir, si sobrecargamos el ==
debemos sobrecargar el !=

Operadores Unarios

En esta sección se verá cómo sobrecargar los operadores unarios, es decir aquellos
que toman un solo operando, como por ejemplo a++. El prototipo de los métodos
que van a sobrecargar operadores unarios será:
public static Operando operator++(Operando a)
Como antes sustituyendo el ++ por cualquier operador unario. El ejemplo dentro de
nuestra clase de números complejos sería:

public static ComplexNum operator++(ComplexNum a)

{

float auximg = a.Img;

float auxreal = a.Real;

return new ComplexNum(++auxreal, ++auximg);

}
Operadores binarios

Para empezar vamos a sobrecargar el operador suma('+') para que al sumar dos
objetos de la clase ComplexNum, es decir dos números complejos obtengamos un
número complejo que será la suma de ambas partes. Cabe destacar que los
prototipos para sobrecargar operadores serán:
public static Operando operator+(Operando a, Operando b)
Este es el prototipo para el operador +, el resto de operadores binarios van a seguir
el mismo patrón. Por tanto el código del método de sobrecarga será el siguiente:

public static ComplexNum operator+(ComplexNum a, ComplexNum b)

{
return new ComplexNum(a.Real + b.Real, a.Img + b.Img);
}

Este método sobrecarga el operador suma para que podamos sumar dos números
complejos. Un dato a tener en cuenta es que los métodos que sobrecargan
operadores deben ser static. Como se ve en el código los operandos son 'a' y 'b',
que se reciben como parámetro y el resultado de la operación es otro número
complejo que es el que retorna el método. Por tanto se limita a crear un nuevo
número complejo con ambas partes operadas. De la misma forma podemos crear
la sobrecarga del operador resta('-') para que lleve a cabo la misma función:

public static ComplexNum operator-(ComplexNum a, ComplexNum b)

{
return new ComplexNum(a.Real - b.Real, a.Img - b.Img);
}

Como vemos el método es idéntico solo que sustituyendo los + por -. En este caso
el trabajo que hacemos dentro del método es trivial pero podría ser tan complejo
como se quisiera.