INSTITUTO TECNOLÓGICO SUPERIOR DE SAN ANDRÉS TUXTLA

MATERIA:
PROGRAMACIÓN ORIENTADA A OBJETOS

CARRERA:
ING. EN SISTEMAS COMPUTACIONALES

DOCENTE:
M. T. I. MONTSERRAT MASDEFIOL SUÁREZ

SEMESTRE: SEGUNDO SEMESTRE GRUPO: 204-A

ACTIVIDAD:

INVESTIGACIÓN ACERCA DE LA UNIDAD 2 “Clases y Objetos”

CICLO ESCOLAR: ENERO-JUNIO 2020

SAN ANDRÉS TUXTLA, VER. A FEBRERO 2020

Página de
Contenido
Equipo 1:....................................................................................................................5

Introducción............................................................................................................5

2.1 Declaración de clases: atributos, métodos, encapsulamiento........................6

¿Qué son las clases?.............................................................................................6

Elementos..............................................................................................................7

Definición de una clase..........................................................................................8

Visibilidad de atributos y métodos.......................................................................10

Encapsulamiento..................................................................................................11

Métodos................................................................................................................13

Paquetes..............................................................................................................14

Clases públicas....................................................................................................14

Conclusión............................................................................................................15

Bibliografía...........................................................................................................16

Equipo 2:..................................................................................................................17

INTRODUCCIÓN.................................................................................................17

CREACIÓN DE UNA CLASE...........................................................................18

- Declaración de una clase..............................................................................18

- Variables de instancia...................................................................................19

Variables de clase............................................................................................19

2.2 Instanciación de una clase.............................................................................20

- Instanciación de objetos en java...................................................................20

Declaración.......................................................................................................21

Instanciación.....................................................................................................21

Inicialización.....................................................................................................22

Página de
 Construcción en UML.......................................................................................23

2.3 Referencia al objeto actual............................................................................23

- Acceso a datos y métodos.............................................................................24

- Referencia al objeto actual con la palabra reservada: this............................28

CONCLUSIÓN.....................................................................................................30

BIBLIOGRAFIA....................................................................................................31

Equipo 3:..................................................................................................................32

INTRODUCCIÓN.................................................................................................32

2.4 Métodos: declaración, mensajes, paso de parámetros, retorno de valores..33

¿QUE ES UN METODO?.................................................................................33

DECLARACION DE UN METODO..................................................................34

LLAMADA A UN MÉTODO..............................................................................35

PASO DE PARÁMETROS A UNA FUNCIÓN O MÉTODO.............................36

MÉTODOS DE CLASE O MÉTODOS STATIC...............................................37

CONCLUSIÓN.....................................................................................................38

REFERENCIAS................................................................................................39

Equipo 4:..................................................................................................................40

INTRODUCCIÓN.................................................................................................40

2.5 Constructores y destructores declaración, uso y aplicaciones......................41

Constructor.......................................................................................................41

Constructor por defecto....................................................................................41

Constructores Sobrecargados..........................................................................43

Destructor.........................................................................................................47

Recolector de basura.......................................................................................48

2.6 Sobrecarga de métodos.................................................................................49

Página de
 Representación en UML......................................................................................51

CONCLUSIÓN.....................................................................................................53

BIBLIOGRAFÍA....................................................................................................54

Equipo 5:..................................................................................................................55

INTRODUCCIÓN.................................................................................................55

¿QUÉ ES UN METODO?.................................................................................56

DEVOLUCIÓN DE VALORES DE UN MÉTODO............................................57

LLAMADO A UN MÉTODO..............................................................................58

2.6 Sobrecarga de métodos.................................................................................60

2.7 Sobrecarga de operadores: Concepto y utilidad, operadores unarios y binarios. 62

Operadores Unarios.........................................................................................63

Operadores binarios.........................................................................................64

CONCLUSIÓN.....................................................................................................66

BIBLIOGRAFIA....................................................................................................67

Página de
 Equipo 1:
Introducción

Las clases son una parte muy importante de los lenguajes de programación
orientado a objetos (POO), estas estructuras nos sirven para crear plantillas de
elementos del mundo real, que utilizaremos posteriormente al crear ejemplares
a partir de esta plantilla. Por ejemplo, el elemento del mundo real "Persona"
podría ser una clase para una aplicación que gestione clientes.

Java es un lenguaje orientado a objetos, así que exceptuando los tipos de datos
básicos para el manejo de números enteros, caracteres, etcétera, todo en java
es un objeto. De esta manera en java existen dos grandes tipos de datos: tipos
de datos primitivos (int, char, float), y tipos de datos referencia.

Java posee instrucciones y sintaxis específicas para la programación orientada

a objetos. Además en java existe el concepto de jerarquía de herencia, es decir,
que todas las clases deben de heredar de otra clase para formar todas ellas un
árbol invertido. La clase raíz de este árbol es la clase java.lang.Object y todas
las clases heredan de ella directa o indirectamente. Adicionalmente las clases
son colocadas en carpetas para facilitar su ordenación y el trabajo con ellas,
dichas carpetas (paquetes es el término más exacto) formarán parte del nombre
de la propia clase, por ejemplo, java.lang.Object significa que existe una
carpeta llamada lang, dentro de la cual existe otra carpeta llamada lang, dentro
de la cual existe una clase llamada Object.

Página de
 2.1 Declaración de clases: atributos, métodos, encapsulamiento
¿Qué son las clases?
En términos prácticos, una clase es un tipo definido por el usuario. Las clases
son los bloques de construcción fundamentales de los programas orientados a
objetos. Booch denomina a una clase como “un conjunto de objetos que
comparten una estructura y comportamiento comunes”.

Una clase contiene la especificación de los datos que describen un objeto junto
con la descripción de las acciones que un objeto conoce cómo ha de ejecutar.
Estas acciones se conocen como servicios o métodos. Una clase incluye
también todos los datos necesarios para describir los objetos creados a partir
de una clase. Estos datos se conocen como atributos, variables o variables
instancia. El término atributo se utiliza en análisis y diseño orientado a objeto y
el término variable instancia se suele utilizar en programas orientados a objetos.

Página de
 Elementos
Atributos: Estructura de los objetos: sus componentes y la información o datos
contenidos en ellos (características).

Métodos: El comportamiento de los objetos. Normalmente se utiliza el término

operaciones, aunque a veces se utilizan otros sinónimos como “servicios”.

Los atributos y métodos pueden ser públicos (+), protegidos (#), y privados (-).

Página de
 Definición de una clase
Antes de que un programa pueda crear objetos de cualquier clase, la clase
debe ser definida. La definición de una clase significa que se debe dar a la
misma un nombre, darle nombre a los elementos que almacenan sus datos y
describir los métodos que realizarán las acciones consideradas en los objetos.

Las definiciones o especificaciones no son código de programa ejecutable. Se

utilizan para asignar almacenamiento a los valores de los atributos usados por
el programa y reconocer los métodos que utilizará el programa. Normalmente
se sitúan en archivos formando los denominados packages, utilizando un
archivo para varias clases que están relacionadas.

Formato

Class NombreClase

Lista_de_miembros

NombreClase: Nombre definido por el usuario que identifica a la clase (puede

incluir letras, números y subrayados como cualquier identificador válido)

Lista_de_miembros: Métodos y datos miembros de la clase.

La definición de una clase no reserva espacio en memoria. El almacenamiento

se asigna cuando se crea un objeto de una clase (instancia de una clase). Las
palabras reservadas public y private se llaman especificadores de acceso.

Página de
Página de
 Visibilidad de atributos y métodos
En una clase podemos definir nuestros atributos y métodos como públicos,
protegidos o privados (public, protected o private) en función de la visibilidad
que queremos que tengan en el resto del código.

Public: podemos acceder a las propiedades y métodos desde cualquier lugar,

desde la clase actual, clases que heredan de la clase actual y desde otras
clases.

Protected: se puede acceder al atributo o método desde la clase que lo define y

desde cualquier otra que herede de esta clase.

Private: los atributos o métodos solo son accesibles desde la clase que los
define.

Tipo de Miembro de Miembro de Miembro de Miembro de

miembro la misma una clase clase del clase de otro
clase derivada paquete paquete
Private X
En blanco X X
Protected X X X
Public x X X x

Cada “X” indica que el acceso está permitido al tipo del miembro de la clase
listado en la columna de la izquierda.

Página de
 Encapsulamiento
Un principio fundamental en programación orientada a objetos es la ocultación
de la información, que significa que a determinados datos del interior de una
clase no se puede acceder por métodos externos a la clase. El mecanismo
principal para ocultar datos es ponerlos en una clase y hacerlos privados. A los
datos o métodos privados sólo se puede acceder desde dentro de la clase. Por
el contrario, los datos o métodos públicos son accesibles desde el exterior de la
clase.

No accesible desde exterior Privado

de la clase (acceso denegado) DATOS O
MÉTODOS

Público
DATOS O
Accesible desde exterior
MÉTODOS
de la clase

Se utilizan tres diferentes especificadores de acceso para controlar el acceso a

los miembros de la clase, son public, private y protected. Cada miembro de la
clase está procedido del especificador de acceso que le corresponde. Se utiliza

Página de
el formato general siguiente en definiciones de la clase, situando primero las
variables instancia, seguidas por los métodos (este orden, sin embargo, no es
obligatorio).

Formato
Class NombreClase
{
Private declaración miembro privado; //miembros privados
Protected declaración miembro protegido; //miembros protegidos
Public declaración miembro público; //miembros públicos
}

El especificador public define miembros públicos, que son aquellos a los que se
puede acceder por cualquier método desde fuera de la clase. A los miembros
que siguen el especificador private sólo se puede acceder por métodos
miembro de la misma clase. A los miembros que siguen al especificador
protected se puede acceder por métodos miembro de la misma clase o de
clases derivadas de la misma, así como por métodos de otras clases que se
encuentran en el mismo paquete. Los especificadores public, protected y
private pueden aparecer e cualquier orden. En el caso de no especificar acceso
a un miembro de una clase, a éste se puede acceder desde los métodos de la
clase y desde cualquier método de las clases del paquete.

Página de
 Métodos
Los métodos miembro que pueden aparecer en la definición de una clase se
clasifican en función del tipo de operación que representan.
Constructores son métodos miembro a los que se les llama cuando un operador
crea un objeto.
Selectores, que devuelven los valores de los miembros dato.
Modificadores o mutadores, que permiten a un programa cliente cambiar los
contenidos de los miembros dato.
Iteradores, que procesan colecciones de objetos, tales como arrays y listas.
Cálculo representa un algoritmo, realiza una operación en la que normalmente
intervienen las variables instancia.

Métodos en línea: Los métodos de las clases siempre se definen dentro del
cuero de la definición de la clase. Se denominan definición en línea.

Página de
 Paquetes

Las definiciones de clases se almacenan normalmente en sus propios archivos

de código fuente, con la extensión .java y de nombre el mismo nombre de la
clase. El compilador de Java, javac, transforma el código fuente en bytecode y
lo almacena en el archivo del mismo nombre y extensión .class.

Clases públicas
Hasta ahora la definición de una clase ha consistido en: class NombreClase
{…}. No se ha puesto un especificador de visibilidad como prefijo de la
cabecera. Cuando se define una clase de esa manera se establece una
restricción importante y es que sólo podrá ser utilizada por las clases definidas
en el mismo paquete.
La definición de una clase puede incluir el modificador public como prefijo en la
cabecera de la clase. Así:
Public class Examen
{
//miembros de la clase
}
La clase examen se puede utilizar en las clases de su propio paquete y en las
clases de cualquier otro paquete.
Habitualmente las clases se definen como public para así poder utilizarlas en
cualquier programa, a no ser que se quiera restringir su uso a las clases del
paquete.

Página de
 Conclusión
En esta unidad de la materia programación orientada a objetos, hemos
aprendido lo más básico y fundamental acerca de la programación orientada a
objetos, hemos descubierto una sintaxis Java que le permite crear clases útiles
y se ha familiarizado con sus elementos básicos para la creación de la misma
que nos ayuda a entender mejor que es una clase y para que nos sirve dentro
de la programación. Saber cómo crear y ejecutar clases en Java que pueden
hacer una buena cantidad de objetos distintos pero con características
comunes entre si, que incluyen hacer cosas diferentes en base a entradas
diferentes. También saber cómo hacer para ocultar la información de las clases
por medio del encapsulamiento.

Página de
 Bibliografía
Luis Joyanes Aguilar e Ignacio Zahonero Martínez. Programación en Java 2. Mc
Graw Hill.

Página de
 Equipo 2:
INTRODUCCIÓN
Dentro de la programación orientada a objetos, se puede destacar como característica más
importante la forma en que se desarrolla un problema específico al crear clases que puedan
implementar objetos, que proporcionen una solución óptima, eficiente y dinámica. Por lo
tanto, los datos y el código que actúa sobre esos datos se agrupan en una clase, para
proporcionar un mejor control ante la información.

Como se mencionó anteriormente se pueden crear objetos de las clases, al instanciar los
objetos, además de permitir la manipulación de variables de cada objeto, se puede manipular
sus datos con los métodos ya establecidos en su clase, efectuando un ahorro de tiempo al
manipular los datos.

Sin embargo, es importante diferenciar los atributos de las clases y de los objetos, debido a
que la forma de acceder a los datos para poder manipularlos difiere entre los elementos, por
lo que también afecta en diferentes escalas, al resto de operaciones del algoritmo.

Cabe destacar que el poder acceder a los elementos de las clases o de los objetos, depende
de la forma en que se hayan declarado, y desde que clase se esté llamando; lo anterior
descrito se debe a los métodos de acceso, que indica la relación entre los atributos de una
clase o un objeto, con el resto del programa.

En el presente documento se brida información acerca de la creación de una clase, su

instanciación, referencias a los elementos tanto de clases como objetos, y la construcción de
lo anterior mencionado en UML.

Página de
Al momento de comenzar a adentrarse en el paradigma de programación orientado a
objetos, se deben de conocer ciertos conceptos, los cuales serán los encargados de definir
ciertas acciones.

Por lo que, antes de comenzar a crear objetos, se debe de conocer el cómo crear una clase,
así como los tipos de atributos (Variables) que este puede manejar:

CREACIÓN DE UNA CLASE

En términos practicos, una clase es un tipo definido por el usuario; la cual es fundamental
para los programas orientados a objetos. Esta se puede denominar un conjunto de objetos
que comparten una estructura, comportamiento y semántica en común.

Una clase puede contener la especificación de ciertas acciones, las cuales se conocen
también como servicios o métodos. Además, también incluyo los datos necesarios para
describir a los futuros objetos creados a partir de la clase, los cuales se conocen atributos o
variables de instancia, además de las variables de clase (retomándose las dos últimas más
adelante).

- Declaración de una clase

Para poder crear una clase, estaba debe definirse, lo que implica que se le debe dar un
nombre a la clase y a los elementos que almacenan sus datos.

Su sintaxis es la siguiente: Para poder crearla, se hace uso de la palabra reservada class,
seguido del nombre de la clase, para después contener todo lo que esta tendrá entre dos
llaves {…}¸ quedando de la siguiente manera:

class NombreClase { class COrdenador {

// Lista_De_Elementos Ejemplo // Lista_De_Elementos

} }

Página de
 - Variables de instancia
Como se puede entender, un objeto es una instancia de una clase, el cual estará relacionado
con atributos previamente declarados dentro de esta, permitiendo así que cada objeto pueda
tener los mismos atributos pero con diferente información, es decir, aunque estos los
compartan, los datos que estos contendrán serán únicos para cada objeto.

Continuando con el ejemplo antes mostrado, estas variables se pueden declarar como
cualquier otra, es decir, con un tipo y un identificador:

class COrdenador {

String Marca;

String Modelo;

int Precio;

Variables de clase
Las variables de clase son aquellas cuyos valores son compartidos entre los objetos de esa
clase, esto significa que será el mismo para todos los objetos.

Dicha variable se declara como estática con la palabra clave static (esta palabra específica
la forma en que el valor es almacenado, como dato estático, en contraposición a otras
variables, las cuales se almacenan de forma dinámica).

Una característica de las variables de clases es que si estas sufren algún cambio en su valor,
dicho cambio se aplicara para todos los objetos, siendo diferente que las variables de
instancia, ya que si en estas se realiza un cambio, dicho cambio solo afecta a la variable y a
la relación que tiene con un objeto.

Sintaxis de declaración:

[Acceso] static Tipo_Variable Nombre_Variable;

Página de
Es posible también asignársele un valor de forma directa, sin embargo, su comportamiento
es el que dicta su tipo de variable y no si este tiene o no asignado un valor desde el inicio,
siendo parecidas a una variable de instancia (con la diferencia en su declaración y
comportamiento).

La sintaxis de una variable de clase a la cual se le asigna un valor, es la siguiente:

[Acceso] static Tipo_Variable Nombre_Variable = Valor;

Con esto antes dicho, quedan cimentadas las bases para poder comenzar a realizar objetos
a partir de dichas clases, ya que estos pertenecerán a una clase, además de que contaran
con atributos, los cuales identificaran a los futuros objetos. Lo único faltante es saber cómo
crear un objeto, tema que se toca a continuación.

2.2 Instanciación de una clase

El fundamento anterior sirvió para marcar el punto de inicio para poder comenzar a crear
objetos. Esto es debido a que al crear una clase esta puede verse inmediatamente como un
molde a partir del cual se comenzaran a crear objetos. Dichas clases contienen los atributos
(o características) que tendrán dichos objetos.

A un objeto construido se le puede denominar instancia, y al proceso de construcción se le

denomina instanciación.

- Instanciación de objetos en java

Para crear objetos en Java, se deben de tener en cuenta tres pasos:

1) Declaración: Proporcionar un nombre al objeto

2) Instanciación: Asignar memoria al objeto
3) Inicialización: Opcionalmente se pueden proporcionar valores iniciales

A continuación se explicara cada uno de los pasos y el cómo estos conducen a la creación
de un objeto.

Página de
 Declaración
Por declaración del objeto se puede entender también como el darle un identificador a dicho
objeto, pero a la vez también se hace una referencia a la clase. Esto se puede explicar en la
siguiente sintaxis:

NombreClase NombreObjeto;

La sintaxis se puede entender como el nombre de la clase a la que pertenecerá el objeto,

seguido inmediatamente del nombre o identificador del objeto. Usando el ejemplo anterior:

COrdenador OComputadora;

Con esto quedaría declarado el objeto, haciendo referencia a la clase a la que este
pertenece.

Instanciación
Instanciación se entiende crear el objeto, para lo cual se utiliza el operador new. Este
operador crea el objeto y devuelve una referencia al objeto creado. Esta referencia es
asignada a una variable del tipo de la clase (referencia explicada durante la Declaración del
objeto). Un objeto estará vivo siempre que este referenciado por una variable de la clase a la
que pertenezca.

Su sintaxis es la siguiente:

NombreObjeto = new NombreClase ();

Esta parte es muy importante, ya que los paréntesis deben de ir siempre al momento de
crear un objeto, ya que este puede contener argumentos, sin embargo, el tema de los
argumentos no será tocado a fondo en el desarrollo de estos temas.

Continuando con el desarrollo del ejemplo anterior, el crear un objeto de la Clase

COrdenador quedaría de la siguiente manera:

OComputadora = new COrdenador ();

Con esto, tanto la referencia como el objeto quedarían creados. Sin embargo, estos tienen
dos formas de declararse: Por partes (que es primero crear la referencia y luego el objeto) o
todo junto.

Página de
El crearlo todo junto se refiere a que al momento de crear la referencia, también se crearía el
objeto, lo cual tendría la siguiente sintaxis:

NombreClase NombreObjeto = new NombreClase ();

Y en base al ejemplo de la clase COrdenador, quedaría de la siguiente manera:

COrdenador OComputadora = new COrdenador ();

Inicialización
La inicialización de un objeto se da en sus variables, ya sean de instancia o de clase.

Al momento de declararlas, a estas se les puede asignar un dato en específico, como se

muestra a continuación:

Variable de instancia  String Marca = “HP”;

Variable de clase  public static String Marca=”HP”;

Sin embargo, también es posible declararlas sin darles un valor en específico, como se
muestra a continuación:

Variable de instancia  String Marca;

Variable de clase  public static String Marca;

Esto es mayormente util ya que permite el asignarles, ya sea al momento de ejecutar el

programa o que sea el usuario el que les proporcione dicho valor. Esto se tocará más a fondo
en el tema 2.3 Referencia al objeto actual, en el apartado de Acceso a datos y métodos.

Construcción en UML
Su construcción en UML de esta clase es muy sencilla, debido a que al ser solo un objeto
creado, contar con 3 atributos y no tener métodos, hace que solo sean dos diagramas, los
cuales son los siguientes:

- Diagrama de clase:

Página de
 El nombre de la clase, seguido por sus atributos y los tipos a los que este pertenece

- Diagrama de objetos:

Aquí se muestra el nombre del objeto, la clase a la que está asociada, así como los datos
que cada uno contiene.

2.3 Referencia al objeto actual

Al decir hacer referencia al objeto actual, se puede entender cómo definir todas aquellas
relaciones entre el objeto, sus atributos y sus métodos, estando dentro de estos últimos la
palabra reservada this, tema que se tocará más adelante.

El hacer dichas relaciones permite acceder a los datos u acciones que estos llevan a cabo,
permitiendo consultarlos, modificarlos o utilizarlos (en el caso de los métodos). A
continuación se verá y explicará el cómo acceder a los datos y métodos de un objeto,
además de la palabra reservada this.

- Acceso a datos y métodos

Una vez se creó el objeto, es posible acceder a sus datos y métodos, esto a partir del
operador punto (.). Este operador se utiliza para seleccionar un miembro individual de un

Página de
objeto de la clase, ya sea métodos, variables de instancia o de clase, esto con el propósito
de especificar que son miembros de un objeto.

Su sintaxis es la siguiente:

NombreObjeto. Dato/Variable;  Referencia a una variable de un objeto

NombreObjeto. Método ();  Referencia a un método de un objeto

Un ejemplo utilizando la clase y el objeto anteriormente declarado, sería el siguiente:

OComputadora. Marca

Sin embargo, esto es solo la forma de indicar que atributo está siendo asignado a un objeto,
pero no se le ha dado ningún valor. El valor puede obtenerse o dársele ya sea al momento
de crear las variables o durante la ejecución del programa, es decir, asignándole un valor.

Por asignarle un valor se refiere a darle un valor establecido al momento de declarar los
atributos o al momento de hacer la referencia a esta, claro está, si esta al haber sido
declarada, no tiene aún un valor o se quiere modificar (como se explicó durante el tema de
Inicialización).

Para los ejemplos se utilizara la variable Marca. Como ya se explicó, al declararla se le

puede asignar un valor, resultando en:

String Marca = “HP”;

Mientras que al momento de crear la referencia, se puede hacer de la siguiente manera:

OComputadora. Marca = “HP”;

Esto sirve para asignar un valor a la variable Marca pero del objeto OComputadora, siendo
exclusivamente de este, por lo cual, el dato que se le asignó, solamente describirá a la
variable Marca del objeto OComputadora, siendo esta así una variable de instancia.

Ahora, en el caso de hacer esto con una variable de clase, es exactamente igual que
asignarle un valor a cualquier variable, con la diferencia de que ese cambio afectara a la
relación que tenga con todos los objetos de la clase. Su sintaxis es la siguiente:

De igual manera, se tomará como ejemplo la variable Marca:

Página de
Marca =”HP”;

Esto sirve para asignarle un valor a la variable de clase, esto con el fin de inicializarla o de
modificarla.

Todos estos procesos pueden igual realizarse con el uso de Scanner y BufferedReader, ya
que estas variables se comportan exactamente igual que una variable común y corriente.

Aunque no tienen una sintaxis definida, este proceso se puede realizar de la siguiente
manera:

 Scanner
- Variable de Instancia

OComputadora. Marca = sc.nextLine (); Se debe de respetar la sintaxis de Scanner para

los tipos que este podrá recibir.

- Variable de clase

Marca = sc.nextLine (); De igual forma, se debe de respetar la sintaxis de Scanner con
respecto a los tipos.

 BufferedReader
- Variable de Instancia

OComputadora. Marca = br.readLine (); BufferedReader ya trabaja por predeterminación

con cadenas de caracteres, por lo cual lo hace perfecto para trabajar con la variable Marca.

- Variable de Clase

Marca = br.readLine (); El mismo caso, trabaja con cadenas de caracteres, por lo cual hace
más fácil su inserción.

Con esto finalmente explicado, se puede exponer el codigo terminado ya con todos estos
elementos aplicados, quedando finalmente asi:

Página de
// Generated by StarUML(tm) Java Add-In

// @ Project :Exposicion Untitled

// @ File Name:Exposicion COrdenador.java

// @ Date : 26/02/2020

// @ Author: Equipo 2

public class COrdenador {

public static String Marca="HP"; //Variable de Clase

public String Modelo; //Variable de Instancia

public int Precio; //Variable de Instancia

public static void main (String args[]){

COrdenador OComputadora = new COrdenador(); //Objeto 1

COrdenador OComputadora2 = new COrdenador(); //Objeto 2

//Referencias OComputadora

OComputadora.Modelo="ABC-123";

OComputadora.Precio=3500;

//Referencias OComputadora2

OComputadora2.Modelo="DEF-456";

OComputadora2.Precio=4500;

System.out.println("\nOComputadora");

System.out.println("Marca: " + OComputadora.Marca);

System.out.println("Modelo: " + OComputadora.Modelo);

System.out.println("Precio: " + OComputadora.Precio);

Página de
 System.out.println("\nOComputadora2");

System.out.println("Marca: " + OComputadora2.Marca);

System.out.println("Modelo: " + OComputadora2.Modelo);

System.out.println("Precio: " + OComputadora2.Precio); }}

Siendo este su resultado:

- Referencia al objeto actual con la palabra reservada: this

Cada objeto puede acceder a una referencia a si mismo mediante la palabra clave this
(también conocida como referencia this). Esta se utiliza cuando se hace una llamada a un
método no static para un objeto específico. El cuerpo del método utiliza una forma implícita la
palabra clave this para hacer referencia a las variables de instancia y a los demás métodos
del objeto.

Un ejemplo del uso de this se puede ver en el siguiente codigo:

class Test{

String a;
String b;

Test(String a, String b){

Página de
 this.a = a;
this.b = b;

void display() {

//Visualización del valor de las variables a y b

System.out.println("a = " + a + " b = " + b);

public static void main(String[] args) {

Test object = new Test ("E", "D");

object.display();

}}

Siendo sus resultados los siguientes:

Página de
 CONCLUSIÓN

El proceso de creación de clases es de suma importancia, debido a que son los bocetos de
la solución, por lo tanto, depende a la abstracción empleada se reflejan diversos resultados.

Dentro de la creación cabe destacar que la descripción que se le proporcione a cada atributo,
método o constructor, afecta el funcionamiento de su implementación a lo largo del código,
esto en consecuencia a diversos factores, como los parámetros, formas de acceso,
operaciones, etcétera.

Es importante discernir el uso del this al emplear una referencia al objeto actual, y no
confundirla al hacer referencias a atributos de clases, debido al alcance que tienen en el flujo
del programa.

Por último, cabe hacer mención que si se crean clases específicas y legibles, es más sencillo
implementar otros elementos de la programación orientada a objetos, como el polimorfismo o
herencia, ya que se tiene un código concreto que evita redundancias o datos innecesarios,
por lo que hace eficiente el desarrollo e implementación de la solución por medio de este
paradigma de programación.

Página de
 BIBLIOGRAFIA

P.J.Deitel y H.M.Deitel. (2008). Java Como Programa, Séptima edición. Ed Pearson Prentice
Hall.

L.J.Aguilar e I.Z.Martínez. (2011). Programación en Java: Algoritmo y programación

orientada a objetos. Ed Mc Graw Hill.

F.J. Ceballos. (s.f.). Java 2: Curso de Programación. Ed. Ra-Ma.

L. Lemay. (s.f). Aprendiendo Java 2 en 21 días. Ed. Prentice Hall

A.Froufe. (Julio, 2000). Java 2: Manual de Usuario y Tutorial 5ta Edición. Ed. Ra-Ma.

S.Holzner. (2000). La Biblia de Java 2.Ed. Anaya Multimedia.

Página de
 Equipo 3:
INTRODUCCIÓN

En la programación orientada a objetos se puede dar de una manera que se d a una forma
muy peculiar con lo cual se requiere de métodos en java para la solución de diversos
problemas que se puedan plantear durante la programación.

El tema de los métodos es muy extenso porque Java les concede mucha potencia y

flexibilidad. Ahora, pero veremos algunas nociones básicas para poder introducir métodos.
De tal manera los métodos se pueden poner por parámetros que se pueden dividir por valor y
regencia con lo que tiene condiciones para declarar o mencionar los métodos para la
elaboración de programas en java.

Página de
 2.4 Métodos: declaración, mensajes, paso de parámetros, retorno de
valores
¿QUE ES UN METODO?

Los métodos son funciones que determinan el comportamiento de los objetos. Un objeto se
comporta de una u otra forma dependiendo de los métodos de la clase a la que pertenece.
Todos los objetos de una misma clase tienen los mismos métodos y el mismo
comportamiento.

Existen tres tipos de métodos:

 Métodos modificadores: Sirven para modificar el valor de los atributos del objeto
 Métodos de consulta: Los métodos de consulta sirven para extraer información de
los objetos.

 Métodos operaciones: Definen el comportamiento de un objeto.

En la mayoría de los casos, otras partes de tu programa interactuarán con una clase a través
de sus métodos.

Un método contiene una o más declaraciones. En un código Java bien escrito, cada método
realiza solo una tarea. Cada método tiene un nombre, y es este el que se usa para llamar al
método. En general, puede dar el nombre que desee a un método cualquiera. Sin embargo,
recuerde que main() está reservado para el método que comienza ejecución de su programa.
Además, no use las palabras clave de Java para nombres de métodos.[1]

Página de
 DECLARACION DE UN METODO

Un método se declara con la siguiente sintaxis:

<Tipo de dato><NombreMetodo>(<Argumentos>)

// instrucciones

{ [return valor;]

…….}

Declaración o cabecera:

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.

private: Sólo accesible a través de métodos de la propia clase.

El uso del método Java, si es estático lo cual significa que el método seria accesible desde
fuera de la clase sin necesidad de instanciar la clase.

static, el acceso al método es estático. [1]

El tipo de dato es dependiente de lo que se desea como resultado del método como puede
ser por ejemplo void si nuestro método no tiene salida alguna, o un tipo de dato especifico
como puede ser double o int si es una salida de tipo numérico.

Página de
 LLAMADA A UN MÉTODO
Para que un método se ejecute hay que llamarlo. La llamada o invocación a un método
provoca la ejecución de las instrucciones que lo componen, una vez se han ejecutado el
control de la ejecución vuelve a quien hizo la llamada.

La llamada al método consta de:

-  Nombre del método.

- Posible lista de argumentos, llamados también parámetros actuales, entre paréntesis y

separados por comas.

Si un método no está definido como static la llamada o invocación al método hay que

hacerla a través de un objeto que pertenezca a la clase que define el método y se dice que
se envía un mensaje al objeto.

nombreObjeto.nombreMétodo([lista de argumentos])
El método se aplica al objeto de la clase a través del operador punto (.)

En este caso el objeto es siempre el argumento implícito del objeto. Los métodos pueden
tener además argumentos explícitos que son los que van entre paréntesis a continuación del
nombre del método.

Cuando se accede al método de un objeto se interpreta que el objeto ha recibido un mensaje

y el objeto responde al mensaje ejecutando el método. Los mensajes que puede recibir un
objeto se corresponden con el nombre de los métodos de su clase.

Si el método devuelve un valor, la llamada a la función debe de formar parte de una

expresión que recoja el valor retornado por la función.

Página de
 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 

Paso por valor

Los parámetros de la función reciben una copia del valor de los argumentos de la llamada.

Las modificaciones que se hagan sobre los parámetros formales no afectan al valor de los
parámetros actuales.

Es el único modo de pasar las variables de los tipos básicos o primitivos.

Paso por referencia

Los parámetros formales reciben una copia de la referencia a un objeto. Los parámetros
formales serán por tanto de tipo referenciado.

Es la forma de pasar los objetos a las funciones y la única forma de poder modificar dentro
de un método una variable de tipo primitivo es incluyéndola como variable miembro de una
clase y pasar como argumento una referencia a un objeto de dicha clase.

El método actúa directamente sobre el objeto, si modifica sus datos una vez termine la
ejecución del método los objetos quedan modificados.  

Con este paso de parámetros se permite, de una forma implícita, que una función devuelva
más de un valor a la función que la llama. [2]

MÉTODOS DE CLASE O MÉTODOS STATIC

Página de
Son métodos que no tienen como finalidad actuar sobre los atributos privados de los objetos.
Se trata de un bloque de sentencias que se agrupan bajo un mismo nombre por tener alguna
relación lógica que las encamina a realizar una tarea específica.  

Se aplican en general donde se necesiten, al no actuar sobre objetos, no pueden acceder a

un miembro no static, los objetos no son el argumento implícito en la llamada, (no actúan
sobre objetos concretos a través del operador punto (.), pero pueden recibir objetos de su
clase como argumentos explícitos). Un miembro static si puede ser accedido a través de
métodos no static

 Los métodos static no pueden acceder a variables ni llamar a métodos no static.

 Los métodos y variables static si pueden ser accedidos o llamados desde miembros
no static.

Los métodos estáticos se crean anteponiendo al nombre del método la palabra static. Si
se define un método como estático es posible llamarlo sin crear un objeto. Como ocurre
con los campos, para invocar un método estático hay dos posibilidades:

• Invocarlo directamente a través del nombre de la clase a la que pertenece.

• Invocarlo a través de un objeto de la clase previamente creado.

Pero en la llamada se suele utilizar el nombre de la clase en lugar del nombre de un

objeto de la clase. [3]

CONCLUSIÓN

Los métodos son necesarios para la declaración dentro de las clases y los objetos dado a
que el comportamiento de los métodos se puede decir que se debe a las clases y a los

Página de
objetos, los métodos, aunque también se considera los valores de las clases y sus tipos de
datos como las públicas, privadas, protegidas e incluso por la paquetería que cuenta en el
caso de java.

Se considera la programación en java importante en las estructuras del código orientado a

objetos con los métodos

REFERENCIAS

Página de
[1] J. MARTINEZ, «FUNDAMENTOS DE PROGRAMACION,» de FUNDAMENTOS DE PROGRAMACION, 2010, p.
206.

[2] B. Eckel, «Piensa en Java Segunda Edicion,» de Piensa en java, Prentice Hall, 2008, p. 625.

[3] Deitel, «Como Programar en java,» de Como Programar en java, 2012, p. 1432.

Página de
 Equipo 4:
INTRODUCCIÓN
Dentro de la programación orientada a objetos, se crean muchos objetos, pero
dependiendo las necesidades del problema, puede existir la posibilidad de que se necesite
inicializar los datos al momento de crearlo, esto se puede visualizar de una forma más fácil al
crear una cuenta bancaria, se proporciona un nombre y se obtiene un cuenta con un saldo
inicial de $0, así para todas las cuentas; lo anterior descrito se soluciona con el uso de los
Constructores.

Otra particularidad es la necesidad de diferenciar funciones que hacen la misma

acción, pero con diferente información o sujeto, se puede visualizar en la vida real con una
acción como abrir, depende a que le hagas referencia va a determinar las acciones a
realizar, debido a que puedes abrir un libro o abrir una puerta, también abrir una caja,
etcétera; analizado desde otro punto de vista se observa al analizar la acción sumar, debido
a que depende los datos a ocupar varia el proceso, lo anterior es porque puedes sumar dos
números enteros, dos números con decimales, más de dos números enteros, dos enteros y
dos decimales, etcétera. A lo anterior descrito se le conoce como sobrecarga.

En el presente documento, se tratarán temas sobre constructores, destructores y

sobrecarga tanto de métodos como constructores, con el objetivo de conocer estos
conceptos para su posterior aplicación.

Página de
 2.5 Constructores y destructores declaración, uso y aplicaciones

Constructor
Un constructor inicializa un objeto inmediatamente después de su creación. Tiene el
mismo nombre que la clase en la que reside y, sintácticamente, es similar a un método. Una
vez definido, se llama automáticamente al constructor después de crear el objeto y antes de
que termine el operador new. Los constructores resultan un poco diferentes, a los métodos
convencionales, porque no devuelven ningún tipo, ni siquiera void. Esto se debe a que el tipo
implícito que devuelve un constructor de clase es el propio tipo de la clase. La tarea del
constructor es inicializar el estado interno de un objeto de forma que el código que crea a la
instancia pueda contar con un objeto completamente inicializado que pueda ser utilizado
inmediatamente. [1]

Reglas

1. El constructor tiene el mismo nombre que la clase.

2. Puede tener cero o más parámetros.

3. No devuelve ningún valor.

Constructor por defecto

Un constructor que no tiene parámetros se llama constructor por defecto; el cual
normalmente inicializa los miembros dato de la clase con valores predeterminados.

Java crea automáticamente un constructor por defecto cuando no existen otros

constructores; tal constructor inicializa las variables de tipo numérico, como int o float a cero,
las variables de tipo boolean a true y las referencias a null.

Tenga cuidado con la escritura de una clase con un solo constructor con argumentos;
si se omite un constructor sin argumento, no será posible utilizar el constructor por defecto.
[2]

Ejemplo:
Página de
//La clase caja usa un constructor para inicializar sus dimensiones
class Caja{
double ancho;
double alto;
double largo;
//Este es el constructor para Caja
Caja(){
ancho=10;
alto=10;
largo=10;
}

Caja(double x, double y, double z){

ancho=x;
alto=y;
largo=z;
}

//Calcula y devuelve el volumen

double volumen(){
return ancho*alto*largo;
}
}

class E1_Caja{
public static void main(String...args){
//Declara, reserva memoria e inicializa objetos de tipo Caja
Caja miCaja2 = new Caja(5,10,10);
Caja miCaja1 = new Caja();

double vol;

Página de
 //Obtención del volumen de la primera caja
vol = miCaja1.volumen();
System.out.println("El volumen de la caja 1 es " + vol);

//Obtención del volumen de la segunda caja

vol = miCaja2.volumen();
System.out.println("El volumen de la caja 2 es " + vol);

}
}

Constructores Sobrecargados
Los constructores se pueden sobrecargar, lo que permite construir objetos con
diferentes tipos de valores iniciales de datos. Si una clase no tiene constructores, se utiliza
un constructor por defecto que no inicializará los datos del objeto. Si no se utilizan
constructores, todos los objetos serán el mismo.

//Constructores sobrecargados [3]

class Tiempo2{
private int hora;
private int minuto;
private int segundo;

//Constructor sin argumentos

public Tiempo2(){
this(0,0,0); //invoca al constructor de Tiempo2 con 3 argumentos
}

Página de
//Costructor solo con hora
public Tiempo2(int h){
this(h,0,0);
}

//Constructor con hora y minuto

public Tiempo2(int h, int m){
this(h,m,0);
}

//Constructor con los tres parametros

public Tiempo2(int h, int m, int s){
establecerTiempo(h,m,s);
}

//Constructor donde se suministra otro objeto Tiempo2

public Tiempo2(Tiempo2 tiempo){
this(tiempo.obtenerHora(), tiempo.obtenerMinuto(), tiempo.obtenerSegundo());
}

//Metodos establecer
public void establecerTiempo(int h, int m, int s){
establecerHora(h);
establecerMinuto(m);
establecerSegundo(s);
}

public void establecerHora(int h){

hora = ( (h >=0 && h< 24) ? h : 0);
}

Página de
 public void establecerMinuto(int m){
minuto = ( (m >=0 && m< 60) ? m : 0);
}

public void establecerSegundo(int s){

segundo = ( (s >=0 && s< 60) ? s : 0);
}

//Metodos obtener
public int obtenerHora(){
return hora;
}

public int obtenerMinuto(){

return minuto;
}

public int obtenerSegundo(){

return segundo;
}

//corvertir en formato de hora universal (HH:MM:SS)

public String aStringUniversal(){
return String.format("%02d:%02d:%02d", obtenerHora(), obtenerMinuto(),
obtenerSegundo());
}

//convertir en formato de hora estándar (H:MM:SS AM o PM)

public String toString(){

Página de
 return String.format( "%d:%02d:%02d %s", ( (obtenerHora() == 0 ||
obtenerHora()== 12) ? 12 : obtenerHora() % 12 ), obtenerMinuto(), obtenerSegundo(),
(obtenerHora()<12 ? "AM" : "PM") );
}
}

class E3_SobrecargaTiempo{
public static void main(String...args){
Tiempo2 t1 = new Tiempo2();
Tiempo2 t2 = new Tiempo2(2);
Tiempo2 t3 = new Tiempo2(21,34);
Tiempo2 t4 = new Tiempo2(12,25,42);
Tiempo2 t5 = new Tiempo2(27,74,99);
Tiempo2 t6 = new Tiempo2(t4);

System.out.println("Se construyo con:");

System.out.println("t1: todos los argumentos predeterminados");
System.out.printf(" %s\n", t1.aStringUniversal());
System.out.printf(" %s\n", t1.toString());

System.out.println("t2: se especifico hora");

System.out.printf(" %s\n", t2.aStringUniversal());
System.out.printf(" %s\n", t2.toString());

System.out.println("t3: se especifico hora y minuto");

System.out.printf(" %s\n", t3.aStringUniversal());
System.out.printf(" %s\n", t3.toString());

System.out.println("t4: se especifico hora, minuto y segundo");

System.out.printf(" %s\n", t4.aStringUniversal());
System.out.printf(" %s\n", t4.toString());

Página de
 System.out.println("t5: se especificaron todos los valores invalidos");
System.out.printf(" %s\n", t5.aStringUniversal());
System.out.printf(" %s\n", t5.toString());

System.out.println("t6: se especifico el objeto t4");

System.out.printf(" %s\n", t6.aStringUniversal());
System.out.printf(" %s\n", t6.toString());
}
}

Destructor
Un destructor es un método especial de una clase que se ejecuta antes de que un
objeto de esa clase sea eliminado físicamente de la memoria. Un destructor se distingue
fácilmente porque tiene el nombre predeterminado finalize. Cuando en una clase no
especificamos un destructor, el compilador proporciona uno a través de la clase Object cuya
sintaxis es la siguiente: [4]

protected void finalize(){ }

Para definir un destructor en una clase tiene que reescribir el método anterior. Sólo es
posible definir un único destructor por clase. En el cuerpo de este se puede escribir cualquier
operación que quiera realizar relacionada con el objeto a destruir.

Un destructor es invocado automáticamente justo antes de que el objeto sea

recolectado como basura por el recolector de basura de Java. Esto ocurre cuando no quedan
referencias al objeto.

Recolector de basura
El recolector de basura se ejecuta en un subproceso paralelamente a su aplicación
limpiando la basura (objetos desreferenciados) en forma silenciosa y en segundo plano y
nunca se detiene por más de una pequeña cantidad de tiempo.
Página de
 Si se desea forzar una completa recolección de basura (marcar y barrer), puede
hacerlo llamando al método gc (garbace collector) de la clase System.

Runtime runtime = Runtime.getRuntime();

runtime.gc();
runtime.runFinalization();

Ejemplo:
class TiempoSimple{
private int hora;
private int minuto;
private int segundo;

public TiempoSimple(int hora, int minuto, int segundo){

this.hora = hora;
this.minuto = minuto;
this.segundo = segundo;
}

public TiempoSimple(){}

public String crearString(){

return String.format("%24s: %s \n %24s:
%s","this.aStringUniversal()",this.aStringUniversal(),"aStringUniversal()",aStringUniversal());
}

//convierte a String en formato de hora universal (HH:MM:SS)

public String aStringUniversal(){
return String.format("%02d:%02d:%02d", this.hora, minuto, this.segundo);
}

protected void finalize() throws Throwable{

Página de
 System.out.println("Objeto eliminado");
}
}

public class E2_Tiempo{

public static void main(String...args){
TiempoSimple tiempo = new TiempoSimple(15,30,19);
System.out.println(tiempo.crearString());

TiempoSimple tiempo2 = new TiempoSimple(23,15,33);

System.out.println(tiempo2.crearString());

Runtime runtime = Runtime.getRuntime();

tiempo=new TiempoSimple();

runtime.gc();
}
}

2.6 Sobrecarga de métodos

En Java es posible definir dos o más métodos que compartan el mismo nombre,
dentro de la misma clase siempre y cuando la declaración de sus parámetros sea diferente.
Cuando se produce esta situación se dice que los métodos están sobrecargados, y que el
proceso es llamado sobrecarga de métodos. La sobrecarga de métodos es una de las formas
en que Java implementa el polimorfismo.

class OverloadDemo{
void test(){
System.out.println("Sin parametros");
}

Página de
 //sobrecarga con un parametro int
void test(int a){
System.out.println("a: " + a);
}
//sobrecarga con dos parametros int
void test(int a, int b){
System.out.println("a y b: " + a + " " + b);
}
}
class E4_Sobrecarga{
public static void main(String...args){
OverloadDemo ob = new OverloadDemo();
double result;
//llamada a todas las versiones del método test()
ob.test();
ob.test(10);
ob.test(10,20);
/*
result = ob.test(123.25);
System.out.println("Resultado de ob.test(123.25): " + result);
*/
}
}

Página de
 Representación en UML
Una forma de representar a los constructores es colocarlo como métodos, con la
deferencia que no tendrán algún tipo de dato de retorno ni siquiera void; colocando sus
respectivos parámetros para que funcione correctamente. En la herramienta StarUML, la
clase Tiempo2 (descrita en el tema de sobrecarga de constructores) presenta la siguiente
forma:

Al exportar el código se obtiene:

//
// Generated by StarUML(tm) Java Add-In
//
// @ File Name : Tiempo2.java
// @ Date : 24/02/2020
// @ Author : Natalia Dominguez Fiscal & Jesús Enrique Figueroa Robles
//

public class Tiempo2 {

private Integer horas = 0;
private Integer minutos = 0;
private Integer segundos = 0;
public void Tiempo2() {

Página de
 public void Tiempo2(Integer h) {

public void Tiempo2(Integer h, Integer m) {

public void Tiempo2(Integer h, Integer m, Integer s) {

public void Tiempo2(Tiempo2 tiempo) {

public String establecerTiempo(Integer h, Integer m, Integer s) {

}
}

En StarUML al exportar el código en los constructores establece que el dato de retorno

es void, por lo tanto, se retira debido a que un constructor no lleva dato de retorno.

Página de
 CONCLUSIÓN

En conclusión, los constructores son una forma sencilla y eficiente de inicializar los
objetos, debido a que prevén casos de implementación de las clases y asignan los valores
que necesita cada objeto; esto va de la mano con la sobrecarga de métodos, por su estrecha
relación con la sobrecarga de constructores, ya que ambos tienen la capacidad de reunir
diversos parámetros a sus operaciones, y activar aquella que se necesite.

Página de
 BIBLIOGRAFÍA

[1] H. Schildt, Java: manual de referencia. 7a ed. México: Mc Graw Hill, 2009

[2] L. Joyanes, I. Zahonero. Programación en Java 6. Algoritmos y programación

orientada a objetos. 1a edición. México: Mc Graw Hill.

[3] P. J. Deitel, Como programar en Java. 7a ed. México: Pearson Educación, 2008

[4] F. Ceballos, Java 2: Curso de programación. 4a ed. Madrid: Alfaomega, 2011

Página de
 Equipo 5:
INTRODUCCIÓN
En este reporte se abarcarán los temas de sobrecarga de métodos y
sobrecarga de operadores, antes de dichos temas se debe de tener bien
comentado los conceptos y sintaxis de un método en Java.
Un método es un mini programa dentro de un programa. Los métodos
contienen varias sentencias bajo un solo nombre, que un programa puede
utilizar una o más veces para ejecutar dichas sentencias. Los métodos ahorran
espacio, reduciendo repeticiones y haciendo más fácil la programación,
proporcionando un medio de dividir un proyecto grande en módulos pequeños
más manejables.
Las clases, los objetos y los métodos son una de las piedras angulares de la
programación en Java, y un buen uso de todas las propiedades básicas ya
expuestas, así como las propiedades avanzadas de los métodos, le
proporcionarán una potencia, a veces impensable, a sus programaciones. La
sobrecarga, la redefinición de métodos y la recursividad son propiedades cuyo
conocimiento es esencial para un diseño eficiente de programas en numerosas
aplicaciones.
La sobrecarga de operadores no existe en Java pero se explica sobre los
operadores unarios y binarios.

Página de
 ¿QUÉ ES UN METODO?
Las clases constan de dos elementos principales: variables de instancia y
métodos. Un método es un bloque de código que tiene un nombre, tipo de
acceso, tipo de retorno y una lista de argumentos o parámetros. Puede tener
también palabras clave asociadas tales como static, abstract y final.
Con la excepción de las sentencias de declaración de objetos, variables y los
bloques de inicialización estática, todo en el código ejecutable en Java se sitúa
dentro de un método. Una definición de un método consta de dos partes:
cabecera y cuerpo.
SINTAXIS
Tipo nombre (lista de parámetros)
{
//cuerpo del método
}
Tipo: Especifica el tipo de datos devuelto por el método (cualquier tipo válido
incluyendo tipos clase que se pueden crear).
Nombre: El nombre que identifica al método. El convenio suele ser utilizar una
letra minúscula para la primera letra del nombre.
Si el método no devuelve un valor, su tipo de retorno debe ser void. El nombre
del método puede ser cualquier distinto de aquellos ya utilizados por otros
elementos dentro del ámbito actual (no puede ser igual a una palabra reservada
Java).
La lista de parámetros es una secuencia de parejas de identificadores y tipos de
datos separados por comas. Los parámetros son, fundamentalmente, variables
que reciben el valor de los argumentos pasados al método cuando este es
llamado. Si el método no tiene parámetros, entonces la lista de parámetros será
vacía.
Los métodos que devuelven a la rutina llamadora un tipo de datos distintos de
void deben utilizar una sentencia return con la siguiente sintaxis:
return valor
Página de
 valor Es una expresión con el valor que devuelve.
Ejemplo
void saludoBienvenida()
{
System.out.println (“¡Hola!”);
System.out.print (“Método llamado saludoBienvenida“) ;
System.out.println (“ que contiene tres sentencias“) ;
}
Un método se debe declarar siempre dentro de una clase.
class Saludo
{
//otras partes de la clase
void saludoBienvenida()
{
System.out.println(“¡Hola!”) ;
System.out.print (“Método llamado saludoBienvenida“) ;
System.out.println (“ que contiene tres sentencias“) ;
}
}
El método ha sido insertado en una clase llamada Saludo. Recordar que la
clase se puede utilizar para crear un objeto Saludo y los objetos tendrán un
método saludoBienvenida(), declarado en la clase.
DEVOLUCIÓN DE VALORES DE UN MÉTODO
La sentencia return se utiliza para salir del método actual y devolver el valor
especificado por el tipo de retorno del método. Si el tipo de retorno del método
es void, la palabra reservada return se utiliza sola.
SINTAXIS
Página de
return ;
return objeto ;

EJEMPLO
Int flex ()
{
Int clorExtremo ;
//realiza cálculos y almacena resultados en clorExtremo
return clorExtremo;
}
Un método se puede utilizar como si tuviera el valor devuelto en la expresión de
retorn
Int x= unObjeto .flex() *44;
En este caso se evalúa el valor devuelto por el método flex(),se multiplica por
44 y se asigna el resultado a la variable x.

LLAMADO A UN MÉTODO
Los métodos, para poder der ejecutados, han de ser llamados o invocados.
Cualquier expresión puede contener una llamada a un método que redirigirá el
control del programa al método nombrado. Normalmente la llamada a un
método se realizará desde un método de otra clase, desde el método principal
main (), aunque naturalmente también podrá ser desde un método de la misma
clase.
El método llamado recibe el control del programa, se ejecuta desde el principio
y cuando termina (se alcanza la sentencia return, o la llave de cierre (}) si se
omite return) el control del programa vuelve y retorna al método llamador.

Página de
La llamada a un método desde otro de la misma clase y para el mismo objeto
se realiza escribiendo el nombre y entre paréntesis la lista de argumentos
actuales. Por ejemplo, sea la clase Semana
class Semana
{
public void listado ( int horas )
{
Int día;
dia= dia semana ():
//…
}
Int diaSemana () {…}
}
Semana nueva=new Semana();
nueva.listado (23);
La ejecución del método listado () supone la llamada al método diaSemana ()
de la misma clase y para el mismo objeto.
La llamada a un método desde un objeto se realizará con el nombre del
objeto,el selector punto (.) y el nombre del método con sus argumentos
actuales.
objeto .nombreMetodo (lista de argumentos actuales) ;
Los métodos static de una clase no son métodos de los objetos de la clase
,sino que son métodos de la clase. Por esa razón la llamada a un método static
se hace con el nombre de la clase, el selector punto (.) y el nombre del método
con sus argumentos actuales.
nombre.Clase.nombreMetodo (lista de argumentos actuales);
No se debe definir un método dentro de otro. Antes de que aparezca el código
de un método debe aparecer la llave de cierre del método anterior.

Página de
 2.6 Sobrecarga de métodos
En Java es posible definir dos o más métodos dentro de la misma clase que
compartan el mismo nombre y que las declaraciones de sus parámetros sean
diferentes. En este caso se dice que los métodos están sobrecargados y el
fenómeno se conoce como sobrecarga de método. La sobrecarga es uno de los
procedimientos mediante el cual Java implementa el polimorfismo.
En las llamadas a los métodos sobrecargados, el compilador determina cuál es
el método invocado basándose en el numero o tipo de argumentos pasados.
Por consiguiente, los métodos sobrecargados deben diferir en el número o tipo
de sus parámetros. Cuando Java encuentra una llamada a un método
sobrecargado, ejecuta la versión del método cuyos parámetros (número y tipo)
coinciden con los argumentos utilizados en la llamada.
REGLA:
Una llamada a un método sobrecargado no debe ser ambigua, de modo que el
compilador pueda decidir inequívocamente cuál es el método llamado.
EJEMPLO:
Se define con cuatro métodos sobrecargados, prueba(),diferenciándose uno de
otro por el número/tipo de los parámetros. En el método main () se llama a cada
uno de los métodos.
El método prueba() se ha sobrecargado cuatro veces. La primera versión no
tiene parámetros; la segunda tiene un parámetro entero; la tercera dos
parámetros enteros y la cuarta tres parámetros de tipo double.
class Sobrecarga
{
public void prueba()
{
System.out.println (“Método sin argumentos “);
}
//sobrecarga de prueba () con un parámetro tipo int
Página de
 public void prueba (int x)
{
System.out.print (“Método con 1 argumento.”);
System.out.println(“x=” + x);
}
//sobrecargado prueba() con dos parámetros tipo int
public void prueba (int x, int y)
{
System.out.print(“ Método con dos argumentos.”);
System.out.println(“x=”+ x +”;y=” + y);
}
//sobrecarga de prueba() con tres parámetros
public void prueba (double x,double y,double z )
{
System.out.print(“Método com 3 argumentos.”);
System.out.println (“×=” +× +”;y=” +y +”;z=” +z);
}
}
//clase con el método main()
class Demosobrecarga
{
public static void main (String [] ar)
{
Sobrecarga objeto=New Sobrecarga ();
//llamada a los métodos sobrecargados
objeto.prueba ();
Página de
 objeto.prueba (29);
objeto.prueba (21,19);
objeto.prueba (-2.5,10.0,5.1);
}
}
Una vez compilado (javac sobrecarga.java) la ejecución (java sobrecarga) da
lugar a esta salida:
Método sin argumentos
Método con 1 argumento. X=29
Método con 2 argumentos. X=21; y=19
Método con 3 argumentos. X=-2.5; y=10.0; z=5.1

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

Página de
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)
Página de
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);
}

Página de
Página de
 CONCLUSIÓN
Los métodos y las clases son la base de construcción de programas en Java.
Se utilizan métodos para subdividir problemas grandes en tareas más
pequeñas.
Este reporte nos dejó aprendizaje los cuales son:
 El concepto, declaración y usos de un método.
 Los métodos que devuelven un resultado lo hacen a través de la
sentencia return.
 Java permite sobrecarga de métodos, que permiten utilizar múltiples
métodos con el mismo nombre y en la misma clase, pero diferente lista de
argumentos.

Página de
 BIBLIOGRAFIA

1.- Programación en C, C++, Java y UML. Luis Joyanes Aguilar. McGRAW

HILL/INTERAMERICANA EDITORES, S.A. DE C.V.

2.- Java Manual de referencia. Herbert Schildt. McGRAW-HILL

INTERAMERICANA EDITORES, S.A. DE C.V.

3.- Programación en java 2. Luis Joyanes Aguilar. Editorial MC GRAW-HILL

Página de