Está en la página 1de 12

UNIVERSIDAD TECNOLÓGICA DE LA REGIÓN NORTE DE GUERRERO

UNIDAD ACADÉMICA EN LA REGIÓN DE LA MONTAÑA

Asignatura:
Programación de aplicaciones

Responsable de la asignatura:
ING. Abel Jerónimo Vargas

Alumno:
Luis Ángel Torreblanca Tejeda

Nombre del trabajo:


Conceptos de investigación de POO (Tarea 1)

Carrera:
Tecnólogas de la Información y Comunicación

Turno:
Vespertino

Grado y grupo
9° “A”

Matricula:
57171900257

Generación:
2018 – 2020

Chilapa de Álvarez, Gro., a 12 de mayo del 2019


Índice

Contenido
Clase .................................................................................................................................................. 1
Objeto ................................................................................................................................................ 2
Método............................................................................................................................................... 4
Atributos ........................................................................................................................................... 5
Instancia de objeto......................................................................................................................... 5
Herencia ............................................................................................................................................ 6
Modificadores de acceso ............................................................................................................. 8
Agregación ....................................................................................................................................... 9
Composición ....................................................................................................................................... 9
Asociación ..................................................................................................................................... 10
Clase
Podemos considerar una clase como una colección de objetos que poseen
características y operaciones comunes. Una clase contiene toda la información
necesaria para crear nuevos objetos.
Ahí es donde se escribe
Estructura de una clase en java el nombre de la clase

Ilustración 1 Ejemplo de clase

Las clase en java de crean escribiendo las palabras public class y


nombre_de_clase, y donde también se colocan dos llaves una de apertura y una de
cierre, y adentro de ellas se escribe el código que contendrá la clase.

Ejemplo 1: Un vehículo se podría considerar como el nombre de una clase, ya que


de dicha clase se pueden derivar difieren tipos de vehículos con los mismos
atributos (el termino de atributo se explicara más adelante), como por ejemplo un
auto con otro auto que poseen las mismos atributos y acciones que en este caso
los dos tiene ruedas, puertas, ventanas y color, y acciones como arrancar, correr
etc. Clase con el nombre de
Vehiculo

Ilustración 2: Ejemplo de imagen con algunos atributos

Y lo mismo sucederá para otras clases que se puedan crear.

Ejemplo 2: una persona también se puede denominar como nombre de unas clases
ya que de dicha clase se pueden derivar personas con los mismos atributos como
lo son nombre, apellidos, edad etc.

1
Clase con el nombre de
Persona

Clase con el nombre de


Ave

Ejemplo 3: el nombre de ave también


se puede denominar como nombre de
clase ya que compórtate atributos con
otras aves, como el color, tamaño, y
acciones como volar, y se crearía
Ilustración 3 Ejemplo de clase Ave
igual como la del ejemplo anterior
adecuándola a lo que se necesite.

Ejemplo 4: instrumento también se puede considerar como el nombre de clase ya


que de ella se pueden compartir atributos con otros instrumentos como lo son tipo,
tamaño, o acciones como lo son tocar etc,

Ejemplo 5: mamíferos también se puede


definir como nombre de clase ya que
comparten atributos con otros mamíferos,
como lo son tipo de alimentación, número de
pies, forma de respiración,

Objeto
Es una forma de agrupar un conjunto de datos (estado) y de funcionalidad
(comportamiento) en un mismo bloque de código que luego puede ser referenciado
desde otras partes de un programa.
Ejemplo 1: Cuando creamos una clase, de ella podemos crear objetos con los
atributos de las clases que en este caso sería la clase vehículo, y de ella podemos
crear un objeto con los atributos de la clase, como lo son al crear un vehículo auto,

2
o un vehículo avión, y que pueden ser reconocidos como vehículos ya sean
terrestres, marinos, o aéreos pero que pueden identificarse.

Ilustración 5 Creación de un
objeto auto derivado de la clase
vehículo
Ilustración 4 Clase vehículo
Aquí se crea un vehículo de tipo auto, para crear un objeto se utiliza la palabra
reservada new, y con ella se crea el objeto auto, existen otras forma de poder
crear objetos, pero solo mostraremos la anterior ya mostrada.

Ejemplo 2: otro ejemplo de objetos es el siguiente que de la clase persona se creara


un objeto con el nombre de alumno y le asignaremos datos desde otra clase

Aquí se crea un constructos de la clase persona, el


constructor sirve para poder asignarles un valor
inicial a los objetos, o para que se les puede
escribir los valores que uno desee, siempre y
cuando se creen un constructor

Ilustración 6 Aquí se crea una clase persona, y algunos de sus


atributos, en donde también se le agrega un constructor
Aquí se crea un objeto alumno, y se le asignan
valores de los cuales se inicializaron en el
constructor de Persona, lo que permite que al
objeto alumno se le puedan asignar valores

Lustración 7: Ejemplo de creación de un objeto

Aquí se muestran dos ejemplos de la creación de


2 objetos un objeto empleado y uno de
miperdona, los cuales no se les asigno valores, la
asignación de valores dependerá de la situación de
cada uno.

3
Método
Es la acción de objeto, un método en Java es un conjunto de instrucciones definidas
dentro de una clase, que realizan una determinada tarea y a las que podemos
invocar mediante un nombre
Ejemplo 1: si implementaros una clase vehículo, y de esa clase se derivara un objeto
auto, el objeto auto se le implementarían métodos para que este pueda funcionar.
Si al auto se le indicara que encienda, el auto tendría que implementar un método
llamado encender para poder encender, con este método el auto en encendería, y
también pasaría lo mismo si al auto se le indicara que avanzase, los métodos
funcionarían como instrucciones para indicarle al auto que hacer, y con ello permitir
su funcionalidad.

Ejemplo 2:
En la programación orientada a objetos los métodos son muy indispensables, otro
ejemplo de cómo se utilizan los métodos son los siguientes, cuando se desarrolla
un sistema (software) usualmente se necesitan registrar movimientos como lo son
agregar usuarios, productos u otras cosas, si en un sistema en donde se registran
usuarios es necesario implementar un método que permita registrar los usuarios, lo
cual se implementaría aun método llamado insertar, y con ese método se registraría
los usuarios en el sistema-
Ejemplo 3:
En los sistemas informáticos se suelen implementar una gran variedad de métodos,
como por ejemplo si en una empresa se es necesario aumentarle el sueldo a un
empleado se necesitaría implementar una método llamo subir sueldo(los nombres
de los métodos se pueden adecuar a la consideración de cada programador para
su fácil entendimiento de su funcionalidad), en los métodos se pueden realizar
diferentes tipos de acciones desde registrar usuarios hasta realizar operaciones
matemáticas, con en este ejemplo de aumentarle el sueldo a un emplead, se
implementaría un método que permitiera aumentarle el sueldo a el empleado.
Ejemplo 4:
Los métodos en la programación nos permiten realizar acciones que uno necesita,
adecuándolos a las necesidades de cada sistema, un sistema bancario en donde

4
se registran transacciones bancarias, depósitos etc., para que en dicho sistema
funciones se requeriría de implementaciones de métodos que permitieran dichas
acciones,

Atributos
Los atributos son las características individuales que diferencian un objeto de otro y
determinan su apariencia (color, estilo, marca, etc.), su estado y otras cualidades.
Ejemplo 1: Un clase persona tiene como atributos nombre, apellidos, dirección,
fecha de nacimiento etc,
Ejemplo 2: la clase vehículo tiene como
atributos color, tamaño, ventanas, llantas etc,

Atributos de las clases

Ejemplo 3: la clase animal tiene como atributos color, tamaño, peso, pies, dedos etc
Ejemplo 4: la clase instrumento puede tener de atributos como tipo de instrumento,
precio, número de cuerdas, tamaño, color etc.
Ejemplo 5: la clase ave puede tener de atributos, nombre, tamaño, si vuela, color,
plumaje, habitad.

Instancia de objeto
Se llama instancia a todo objeto que derive de algún otro.
Al momento de crear una clase, en ella se almacenan los propiedades que poseerá,
para posteriormente puedan utilizarse en los objetos, los objetos son instancias que
derivan de las clases.
Ejemplo
Cuando creamos una clase vehículo de ella se pueden
derivar objetos que básicamente son instancias, pero
agregándoles más operaciones, y de los objetos instancias
por las cuales se podrán hacer uso de las propiedades de
la clase, en la imagen se muestra como se crean instancia de la clase vehicula y se
les asignan valores.

5
Herencia
La herencia permite la sobrescritura de métodos definidos en la clase padre en las
clases que hereden de ella, pudiendo así comportarse de forma diferente.
Ejemplo
Aquí creamos una clase persona en donde
también se crean sus tributos, pero
también le añadimos algunos métodos, get
y set, los cuales sirven para que desde otra
case se puedan utilizar asignándoles
valores, la clase persona la
consideraremos como clase padre ya que
de ella otras clases podrán heredar su
propiedades, aplicando la herencia.
A continuación se creara una clase con el
nombre de Empleado y en ella se creara
un atributo
llamado
sueldo.

Aquí creamos la clase llamada Empleado delante de


ella agregamos una palabra reservado de java que es
la palabra extends, la cual indica que la clase Empleado está heredando las
propiedades de persona, y en la clase
persona solo se declara un atributo
llamado sueldo, con su get y su set.
Aquí creamos una clase Ejecutador la
posee el método main, y que nos permitirá
ejecutar los datos que escribamos en ella.
Lo primero que hacemos es crear un
instancia de la clase empleado,
asignándole un nombre miempleado.
miempleado le implementaremos los
métodos set y get, para poder mostrar los datos en consola, miempleado.setNombre
sirve para que se le puede asignar un nombre a miempleado, lo mismo se realizara
con los demás agregándoles el apellido, edad, dirección, y aquí es donde
demostramos la herencia de persona herédales sus propiedades a empleado, ya
que en la clase persona fue donde creamos los atributos nombre, apellidos, edad,

6
dirección, lo cual nos comprueba que la herencia se dio de una manera exitosa, ya
que en la clase Empleado solo creamos un atributo llamo sueldo con sus métodos,
y para finalizar solo obtenemos los datos ya asignados con set a miempleado,
mandándolos a traer con el método get,
System.out.println servirá para mostrar
los datos en pantalla
En esta imagen podemos comprobar
que la herencia se llevó acabo
correctamente, ya que al momento de
ejecutar la clase, no nos marca ningún
error, y nos muestra los datos en

pantalla exitosamente, en donde nos


muestra el empleado creado con sus
demás propiedades.

Aquí se muestra otro ejemplo de herencia


donde profesor está heredando las
propiedades de empleado, y donde a
profesor solo se le crean dos atributos con
sus métodos get y set.

Aquí nuevamente se muestra como la


herencia se lleva cabo exitosamente, ya
que la instancia miprofe permite que se
le puedan heredar las propiedades de
persona y empleado sin ningún
problema, lo cual permite que miprofe
pueda usar perfectamente las
propiedades de las dos clases y asi
mostrar los datos en pantalla sin ningún
problema

7
Modificadores de acceso
Los modificadores de acceso son los que nos permitirán asignarles el acceso a las
propiedades de cada clase, y indicarles desde que clase se pueden acceder.
Cuando creamos un atributo y le asignamos el
modificador acceso public, esta atributo permitirá que en
las demás clases pueda utilizarse, ya sea que se
encuentre en el mismo paquete o en diferente paquete.
Aquí mostramos la clase persona1 con 4 atributos, curp,
nombre, edad, y dirección asignándole un modificador de
acceso a cada uno, el modificador de acceso public que
se le ha asignado a curp, permitirá que cualquier clase
puede hacer uso de ella, ya que se ha declarado de forma
pública, lo cual también permitirá que se le pueda cambiar
de valor a el
atributo curp
Aquí se muestra como la instancia persona
hace uso de esta variable, desde otra clase
pero que se encuentra en el mismo paquete.
En esta otra imagen se muestra como el
atributo nombre que se le ha asignado el
modificador de acceso protected, el cual también permite que se pueda utilizar
desde otras clases que se encuentren en el mismo paquete, pero impidiendo que
se pueda hacer uso de ella desde otra clase que se encuentre en otro paquete.
El modificador de acceso private hace que los atributos solo se puedan utilizar
desde la clase en la que se crean impidiendo el acceso desde otras clases que se
encuentren en el mismo paquete, y de las clases que
se encuentren desde otro paquete.

Como podemos ver la instancia mipersona no puede


hacer uso del atributo edad, ya que a el atributo edad
se le ha asignado el
modificador de acceso private el cual impide que se
pueda utilizar desde otra clase.

En esta imagen se muestra el último modificador de


acceso llamado modificador de paquete, ya que a
diferencia de los 3 anterior a este atributo solo se ha declaro con un simple dato de
tipo String, y que también se puede manipular desde cualquier clase que se
encuentre en el mismo paquete, como se muestra en la imagen.

8
En esta imagen se muestra como el modificador de
acceso public permite que el atributo se pueda utilizar
desde otra clase que se encuentra en otro paquete,
en línea 1 podemos ver el nombre del paquete, y
como desde otra clase se puede utilizar el atributo
curp, y las 3 atributos anteriores que son nombre, edad, dirección no pueden
utilizarse desde otra clase que se encuentre entro paquete.

Agregación
La agregación es una relación que define que un objeto es parte de otro objeto
cuando definimos que un objeto tiene como atributo otro objeto decimos que es
una agregación
Ejemplo
Tenemos una clase Centrocomercial.
• Tenemos una clase clientes.
• Un centro comercial agrupa a varios clientes.
La agregación se representa en UML mediante un diamante de color blanco
colocado en el extremo en el que está la clase que representa el todo.
cliente
Centrocomercial
1..* 0..*

Lo mismo sucedería con una empresa, ya que una empresa agrupa a varios
clientes, y se representaría de la misma manera que el ejemplo anterior,

Composición
Composición es una forma fuerte de composición donde la vida de la clase
contenida debe coincidir con la vida de la clase contenedor. Los componentes
constituyen una parte del objeto compuesto. De esta forma, los componentes no
pueden ser compartidos por varios objetos compuestos. La supresión del objeto
compuesto conlleva la supresión de los componentes.
Tenemos una clase Escuela.
• Un objeto escuela está a su vez compuesto por uno o varios objetos del tipo
empleado.
• El tiempo de vida de los objetos Empleado depende del tiempo de vida de la
escuela, ya que si no existe una escuela no pueden existir sus empleados.

9
Escuela Empleados
1 1..*

El símbolo de composición es un diamante de color negro colocado en el extremo


en el que está la clase que representa el todo (Compuesto).

Asociación
La asociación se podría definir como el momento en que dos objetos se unen para
trabajar juntos y así, alcanzar una meta.
Ejemplos
Un jugador profesional juega para un equipo de, y ese equipo tiene varios jugares,
que le pueden ayudar a alcanzar sus metas, que son el campeonato, otro ejemplo
puede ser un estudiante y que utiliza una compradora para poder realizar su tareas,
o un conductor que utiliza un coche para llegar a un destino,

10