INSTITUTO TECNOLÓGICO

SUPERIOR DE ALVARADO

INGIENERIA EN SISTEMAS COMPUTACIONALES

Materia
PROGRAMACION ORIENTADA A OBJETO
Unidad: 2
NUMERO DE CONTROL:
190Z0390
Semestre-Grupo:
SEGUNDO SEMESTRE – (A)
PRODUCTO ACADEMICO
REPORTE DE LA PRACTICA 2
Presenta
Carlos Eredy Hernández Rodríguez
Docente
ING. JUAN OMAR GAMBOA CRUZ
Fecha:
28 DE FEBRERO DEL 2020

TLALIXCOYAN, VER. FEB-JUN 2020

1
Contenido
...........................................................................................................................................................1
OBJETIVOS GENERALES............................................................................................................3
OBJETIVOS ESPECÍFICOS..........................................................................................................4
MARCO TEORICO..........................................................................................................................5
QUE ES UN CONSTRUCTOR......................................................................................................5
QUE ES UNA SOBRECARGA......................................................................................................7
SOBRECARGA DE MÉTODOS....................................................................................................7
EJEMPLO.....................................................................................................................................8
Sobrecarga de operadores............................................................................................................9
Practica y códigos.........................................................................................................................10
CONCLUSIÓN...............................................................................................................................15

2
OBJETIVOS GENERALES
El objetivo general de esta práctica es que nosotros podamos identificar a los
constructores y a como ver a donde esta incluida la carga de métodos estas
prácticas nos sirvió para poder desarrollar las practicas y poder hacer los
constructores en la programación .y como ya lo mencione antes el objetivo es
claros y precisos que sepamos como identificar a los constructores y que para
llamar a un constructor se le puede poner la sentencia new como por ejemplo new
Lampara (),lo que hace es crear otro objeto distinto, que de inmediato se descarta,
ya que no se guarda en ninguna parte y como podremos identificar a los
constructores pues Los constructores pueden ser , public y private protected son
los características en la cual puedes identificar a un constructor Como podremos
observar el utilizar el this() para pasar de un constructor a otro los parámetros
necesarios. Lo único podemos hacer y que tienes que saberse es que this (), si se
utiliza, siempre ha de ser en la primera línea dentro del constructor. Y El
constructor puede contener más de un código, pero this () ha de estar siempre en
primer lugar y la única manera de poder a ser aun constructor. también hay más
formas de identificar a los constructores Un constructor, tiene el mismo nombre
de la clase a la cual pertenece. Y se puede saber lo que es una sobrecarga es
cuando en una clase, se definen un mismo método, con diferente número de
parámetros, o bien con el mismo número de parámetros pero diferenciándose en
la definición, en la cual, al menos un parámetro sea de diferente tipo, cuando esto
sucede, se dice que el método está sobrecargado.

3
OBJETIVOS ESPECÍFICOS
El objetivo principal de este tema o de esta práctica es que debemos saber en qué
lenguaje de programación podemos hacer en las practicas las cuales pueden
saber lo que es un constructor es un método especial dentro de una clase, que se
llama automáticamente cada vez que se crea un objeto de esa clase. Por qué en
java también no se puede utilizar los destructores por que java ya tienen la
papelera de basura ya ahí se puede eliminar a los constructores. Introducir los
conceptos básicos de programación. Conocer las formas fundamentales de las
programaciones de la computación. Desarrollar la capacidad para analizar, diseñar
e implementar soluciones para que no se nos complique el desarrollar la
programación para constructores en sistemas computacionales hay una alta y
media complejidad. Para el desarrollo de la programación

4
MARCO TEORICO

QUE ES UN CONSTRUCTOR

En programación orientada a objetos (POO), un constructor es una subrutina cuya

misión es inicializar un objeto de una clase. En el constructor se asignan los
valores iniciales del nuevo objeto.
Se utiliza para crear tablas de clases virtuales y poder así desarrollar
el polimorfismo, una de las herramientas de la programación orientada a objetos.
Al utilizar un constructor, el compilador determina cuál de los objetos va a
responder al mensaje (virtual) que hemos creado. Tiene un tipo de acceso, un
nombre y un paréntesis.
En Java es un método especial dentro de una clase, que se llama
automáticamente cada vez que se crea un objeto de esa clase.
Posee el mismo nombre de la clase a la cual pertenece y no puede devolver
ningún valor (ni siquiera se puede especificar la palabra reservada void). Por
ejemplo, si añadiéramos a la clase SSuma un constructor, tendríamos que llamarlo
también SSuma. Cuando en una clase no se escribe propiamente un constructor,
Java asume uno por defecto.

Constructor por defecto

Un constructor por defecto es un constructor sin parámetros que no hace nada.
Sin embargo, será invocado cada vez que se construya un objeto sin especificar
ningún argumento, en cuyo caso el objeto será iniciado con los valores
predeterminados por el sistema (los atributos numéricos a cero, los alfanuméricos
a nuloPeq, y las referencias a objetos a null).
Ejemplo
Un constructor por defecto para la clase SSuma quedaría así:
public SSuma () {}
Como se observa el constructor no posee ningún parámetro, ya que como no ha
sido definido propiamente por el programador, Java lo hace por default.

5
Si se define un constructor con parámetros (definido explícitamente) el constructor
por default se reemplaza por este.
A continuación, se creará un constructor explícito para una clase simple, utilizando
una clase Persona con una serie de atributos.
Primero se declara la clase con sus atributos
class Persona
{
//ATRIBUTOS
private String nombre;
private int edad;
private String empleo;
private double salario;

//CONSTRUCTORES
public Persona() {} //CONSTRUCTOR SIN PARÁMETROS
public Persona(String nombre, int edad, String empleo, double salario)
{
asignarNombre(nombre);
asignarEdad(edad);
asignarEmpleo(empleo);
asignarSalario(salario);
}
//...
}

6
QUE ES UNA SOBRECARGA
Sobrecarga es la capacidad de un lenguaje de programación, que permite
nombrar con el mismo identificador diferentes variables u operaciones.
En programación orientada a objetos la sobrecarga se refiere a la posibilidad de
tener dos o más funciones con el mismo nombre, pero funcionalidad diferente. Es
decir, dos o más funciones con el mismo nombre realizan acciones diferentes. El
compilador usará una u otra dependiendo de los parámetros usados. A esto se
llama también sobrecarga de funciones.
También existe la sobrecarga de operadores que al igual que con la sobrecarga de
funciones se le da más de una implementación a un operador.
El mismo método dentro de una clase permite hacer cosas distintas en función de
los parámetros.
Java no permite al programador implementar sus propios operadores
sobrecargados, pero sí utilizar los predefinidos como el +. C++, por el contrario, si
permite hacerlo.

SOBRECARGA DE MÉTODOS
Algunos métodos en una clase pueden tener el mismo nombre. Estos métodos
deben contar con diferentes argumentos. El compilador decide qué método
invocar comparando los argumentos. Se generará un error si los métodos tienen
definidos los mismos parámetros.
La firma de un método es la combinación del nombre y los tipos de los parámetros
o argumentos.
La sobrecarga de métodos es la creación de varios métodos con el mismo
nombre, pero con diferente lista de tipos de parámetros. Java utiliza el número y
tipo de parámetros para seleccionar cuál definición de método ejecutar.
Java diferencia los métodos sobrecargados con base en el número y tipo de
parámetros o argumentos que tiene el método y no por el tipo que devuelve.
También existe la sobrecarga de constructores: Cuando en una clase existen
constructores múltiples, se dice que hay sobrecarga de constructores.

7
EJEMPLO
/* ProgUsuario4.java */
class ProgUsuario4
{
void imprimeUsuario(Usuario4 usr)
{
// usr.nombre equivale en este caso a usr.getNombre()
System.out.println("\nNombre: " + usr.nombre );
System.out.println("Edad: " + usr.getEdad() );
System.out.println("Direccion: " + usr.getDireccion() +"\n");
}
public static void main(String args[])
{
ProgUsuario4 prog = new ProgUsuario4( );
/* Se declaran dos objetos de la clase Usuario4 */
Usuario4 usr1,usr2;
/* Se utiliza el constructor por omisión */
usr1 = new Usuario4( );
prog.imprimeUsuario(usr1);
/* Se utiliza el segundo constructor de Usuario4 */
usr2 = new Usuario4("Eduardo",24,"Mi direccion");
prog.imprimeUsuario(usr2);
/* Se utiliza el tercer constructor de Usuario4 */
usr1 = new Usuario4(usr2);
usr1.setEdad(50);
usr2.setEdad(30.45f);
prog.imprimeUsuario(usr1);
prog.imprimeUsuario(usr2);
}

8
La sobrecarga de Métodos se apoya de métodos y constructores, los destructores
no se pueden sobrecargar ya que sólo debe haber uno por clase.
La sobrecarga de métodos hace que un mismo nombre pueda representar
distintos métodos con distinto tipo y número de parámetros, manejados dentro de
la misma clase. En el ámbito de la POO, la sobrecarga de métodos se refiere a la
posibilidad de tener dos o más métodos con el mismo nombre, pero distinta
funcionalidad. Es decir, dos o más métodos con el mismo nombre realizan
acciones diferentes y el compilador usará una u otra dependiendo de los
parámetros usados. Esto también se aplica a los constructores (de hecho, es la
aplicación más habitual de la sobrecarga).
Se pueden diferenciar varios métodos sobrecargados a través de sus parámetros,
ya sea por la cantidad, el tipo o el orden de los mismos.
Gracias a la sobrecarga de métodos, una clase puede tener distinto
comportamiento dependiendo de cual método sobrecargado se use, a esta
característica se le conoce como Polimorfismo por sobrecarga. La palabra
Polimorfismo viene de la capacidad que tiene una clase de cambiar su
comportamiento. En el caso del polimorfismo por sobrecarga, el cambio del
comportamiento de una clase se define sobrecargando los métodos necesarios
para lograr el polimorfismo.

Sobrecarga de operadores
Sobrecarga de operadores. Los operadores son un tipo de tokens que indican al
compilador la realización de determinadas operaciones sobre variables u otros. La
sobrecarga de operadores permite redefinir ciertos operadores, como '+' y '-', para
usarlos con las clases que hemos definido. Se llama sobrecarga de operadores
cuando reutilizando el mismo operador con un número de usos diferentes, y el
compilador decide como usar ese operador dependiendo sobre qué opera.
La sobrecarga de operadores solo se puede utilizar con clases, no se pueden
redefinir los operadores para los tipos simples predefinidos.
Los operadores lógicos && y || pueden ser sobrecargados para las clases
definidas por el programador, pero no funcionaran como operadores de short
circuit. Todos los miembros de la construcción lógica serán evaluados sin ningún
problema en lo que se refiere a la salida. Naturalmente los operadores lógicos
predefinidos continuaran siendo operadores de short circuit como era de esperar,
pero no los sobrecargado

9
 Practica y códigos
La practica de los constructores consiste en saber el identificar a donde van los
constructores con que valor va asignado en fin e igual van a ver que esta la
sobrecarga de métodos esto nos sirve para experiencia en si podemos a serlo con
el tiempo y ver como vamos a declarar las variables en si o como va estar la
sobrecarga de operadores
Persona1
public class EJEMPLO1 {
1:aquí podemos identificar en el private que es una característica del constructor
private String nombre;
private int edad;
public void asignaNombre( String n)
{
nombre = n;
}
public void asignaEdad( int e)
{
edad = e;
}
public String daNombre()
{
return nombre;
}
public int daEdad( )
{
return edad ;
2.Aquí asignamos
} el método main para que determinemos un valor
public static void main (String [] args)
3.Se llama
{ al constructor con la sentencia new

10
4.Se manda a llamar o a invocar al constructor con el new es el nombre new
ejemplo
EJEMPLO1 p = new EJEMPLO1() ;.
Los parámetros son el asigna nombre y edad es el que mas se puede repetir
p.asignaNombre("Luis");
p.asignaEdad(25);
//C.WriteLine("Nombre: {0} , Edad: {1}", p.daNombre () p.daEdad());
}
Persona2
5.El nombre de mi nueva clase es ejemplo2
public class EJEMPLO2

6.un constructor con dos parámetros se puede identificar pero de igual forma no
puede ser predeterminado
using System;

using C = System.Console;

7. los parámetros están constituidos

class Persona

private string nombre;

private int edad;

public Persona( string n, int e)

nombre = n;

edad = e;

public string daNombre( )

return nombre;

public int daEdad( )

11
return edad ;

public class Principal

8.Aquí declaramos el método main a veces por no declararlo el programa no corría

public static void Main( )

Persona p = new Persona( "Luis", 25) ;

C.WriteLine("Nombre: {0} , Edad: {1}", p.daNombre(),

p.daEdad());

Persona 2public class EJEMPLO3

9.Hay un constructor con dos parámetros y en si un constructor predeterminado .

using System;

using C = System.Console;

class Persona

10.Hay métodos sobrecargados y lista de parámetros

private string nombre;

private int edad;

public Persona(string n, int e)

nombre = n;

edad = e;

public Persona() // Constructor predeterminado, vuelto a escribir.

public string daNombre()

12
11.Aquí escribimos el método para decir que va a devolver algún valor o por si no
va a devolver nada
,.....return nombre;

public int daEdad()

.....return edad;

public void asignaNombre(string n)

.....nombre = n;

public void asignaEdad(int e)

...edad = e;

Persona3
}
public class Principal
{
public static void Main()
{
Persona pa = new Persona("Luis", 25);
12.aquí se manda a llamar al constructor como la sentencia new persona
Persona pb = new Persona(); // Se invoca al constructor
................................................// predeterminado
13.Aquí hay una lista de parámetros la cual sea repetido mucho mas el
asignanombre y asignaEdad
pb.asignaNombre("Pepe");
pb.asignaEdad(19);

13
C.WriteLine("Nombre: {0} , Edad: {1}", pa.daNombre(),
pa.daEdad());
C.WriteLine("Nombre: {0} , Edad: {1}", pb.daNombre(),
pb.daEdad());
C.Read();
}
}
14.a lo último corrió el programa, pero no decía nada

14
CONCLUSIÓN
En conclusión, de este reporte de practica de los constructores y la sobrecarga de
métodos y sobrecarga de operadores aprendí a como identificar a un constructor y
es un método especial dentro de una clase, que se llama automáticamente cada
vez que se crea un objeto de esa clase en si se puede decir que cada ves que
crean un objeto este método es tomado en cuenta Un constructor por defecto es
un constructor sin parámetros que no hace nada. Sin embargo, será invocado
cada vez que se construya un objeto sin especificar ningún argumento Sobrecarga
es la capacidad de un lenguaje de programación, que permite nombrar con el
mismo identificador diferentes variables u operaciones

15
Bibliografía
gomez gonzalez, e. (2008). progrmacion orientada objetos. los angeles: adventud .

rodriguez , j. (2007). clases y objeto . CIUDAD DE MEXICO: educacion S.A.

USCANGA, E. (2011). DECLRACION DE CLASE. LOS ANGELES: GRAN PLAZA.

16