MÓDULO

Área: TECNOLOGÍA

2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA)
Módulo: Conceptos básicos
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA)

Conceptos básicos
Índice

Tabla de contenido

Mapa de Contenido ................................................................................................................................................3

Introducción ...........................................................................................................................................................4
1.Abstracción..........................................................................................................................................................5
2.Programación orientada a objetos (POO) ...........................................................................................................6
2.1 Clases................................................................................................................................................................6
2.2 Creación de clases ............................................................................................................................................7
2.3 Creación de objetos ..........................................................................................................................................9
2.4 Herencia .........................................................................................................................................................10
2.4.1 Conceptos básicos de herencia ...................................................................................................................10
2.4.2 Uso de ‘extends´..........................................................................................................................................11
2.4.3 Sobrecarga de métodos ..............................................................................................................................11
3. Cierre ................................................................................................................................................................12
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA)

Conceptos básicos
Mapa de Contenido
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 4

Conceptos básicos
Tras explorar los fundamentos de la Programación Orientada a Objetos
RESULTADO DE (POO) en Java, los lectores entenderán la relevancia de clases y objetos en
este paradigma. Aprenderán a implementar la herencia para optimizar la
APRENDIZAJE DEL reutilización del código, y reconocerán cómo la abstracción facilita la gestión
MODULO de la complejidad en el diseño de software.

Introducción

La Programación Orientada a Objetos (POO) es un paradigma de desarrollo de software que se basa en el

concepto de objetos, los cuales encapsulan datos y comportamientos relacionados. Este enfoque ofrece
una manera poderosa y flexible de abordar el diseño y la construcción de sistemas de software, permitiendo
a los desarrolladores modelar elementos del mundo real o conceptos de manera intuitiva y reutilizable.

Java, siendo uno de los lenguajes de programación más populares y ampliamente utilizados en el mundo,
implementa de manera robusta los principios de la POO, proporcionando a los programadores un conjunto
rico de herramientas para crear software modular, escalable y fácil de mantener. A través de sus
características como clases, objetos, herencia, polimorfismo, encapsulamiento y abstracción, Java permite
a los desarrolladores construir aplicaciones complejas de manera eficiente.

En este documento, exploraremos los fundamentos de la POO en el contexto de Java, comenzando con la
definición y la importancia de clases y objetos, seguido por una exploración profunda de los conceptos de
encapsulamiento, herencia, polimorfismo y abstracción. Cada uno de estos principios juega un papel crucial
en la creación de software robusto, y entenderlos es esencial para cualquier desarrollador que busque
dominar laprogramación orientada a objetos en Java.

Nuestro objetivo es proporcionar una guía comprensiva que no solo cubra la teoría detrás de cada concepto,
sino que también demuestre su aplicación práctica a través de ejemplos y explicaciones detalladas. Al final
de este documento, los lectores tendrán una sólida comprensión de los principios de la POO y estarán
equipados con el conocimiento necesario para aplicar estos conceptos en sus propios proyectos de
desarrollo de software en java.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 5

1. Abstracción
En la programación orientada a objetos (POO), una clase se crea a menudo por abstracción.

La abstracción en Programación Orientada a Objetos (POO) es un principio clave que nos permite modelar
entidades complejas del mundo real, como un auto, de manera simplificada en código. Al abstraer un auto,
seleccionamos características y comportamientos esenciales para representar en nuestra clase Auto.
Consideramos atributos como marca, modelo, año, que son datos esenciales que todo auto posee. Además,
incluimos métodos como arrancar() y detener(), que son acciones fundamentales que un auto puede realizar.

Este proceso de abstracción nos permite crear un modelo de Auto enfocado en lo que realmente importa para
el propósito de nuestra aplicación, ignorando detalles que no son relevantes. Por ejemplo, no necesitamos
saber cómo funciona internamente el motor para hacer que nuestro auto "arranque" en el programa. Solo
necesitamos un método arrancar() que simule esta acción.

Imagina que estás creando un videojuego y necesitas modelar diferentes tipos de autos. La abstracción te
permite definir una clase base Auto con propiedades y métodos comunes, y luego extender esta clase para
crear tipos específicos de autos, como AutoDeportivo o AutoFamiliar, cada uno con sus propias características
únicas, pero aun compartiendo la estructura básica y comportamientos de Auto.

La abstracción, en esencia, es simplificar la complejidad del mundo real al enfocarse en lo relevante,

permitiéndote construir sistemas más complejos a partir de bloques de construcción simples y entendibles.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 6

2. Programación orientada a objetos (POO)

La Programación Orientada a Objetos es un paradigma de programación basado en el concepto de "objetos",
que pueden contener datos en forma de campos, a menudo conocidos como atributos, y código, en forma de
procedimientos, a menudo conocidos como métodos. La idea clave de la POO es usar objetos para modelar
elementos del mundo real o de sistemas complejos, organizando el software en componentes reutilizables y
modulares.

Los objetos son entendidos por nosotros a través de dos aspectos fundamentales: sus atributos y sus acciones.
Tomemos el ejemplo de un automóvil: identificamos este objeto por atributos como su color, marca, modelo
y año de fabricación. A su vez, reconocemos sus acciones o comportamientos, tales como moverse, acelerar,
frenar y girar. Para ilustrar estos conceptos de manera más clara, analiza el esquema siguiente.

2.1 Clases
Una clase en Java es un "plano" o "prototipo" a partir del cual se crean objetos y se define el estado y el
comportamiento que los objetos del mismo tipo compartirán. Un estado se refiere a los datos (atributos) y el
comportamiento a las operaciones (métodos) que los objetos pueden realizar. La estructura básica de una clase
es la siguiente:
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 7

Componentes de una Clase

• Atributos: Variables que almacenan el estado de los objetos.

• Métodos: Funciones o procedimientos que expresan el comportamiento de los objetos.
• Constructor: Un método especial que se utiliza para inicializar objetos.

2.2 Creación de clases

Vamos a crear una clase simple llamada Auto, que representará algunos aspectos básicos de un coche.

La clase Auto está diseñada para modelar información básica sobre un automóvil. Se definen tres atributos
principales para este propósito: marca, modelo, y año. Estos atributos almacenarán los datos específicos de
cada objeto Auto que creemos.

Atributos

Los atributos son variables que se declaran dentro de una clase. Representan las propiedades o estados que
pueden tener los objetos de esa clase. En el caso de nuestra clase Auto, tenemos:

• String marca: Este atributo almacena la marca del automóvil, como "Toyota" o "Ford".
• String modelo: Guarda el modelo específico del automóvil, como "Corolla" o "Mustang".
• int año: Almacena el año de fabricación del automóvil, como 2020.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 8

Constructor

El constructor es un método especial que tiene el mismo nombre que la clase y se utiliza para inicializar objetos.
No tiene tipo de retorno y se llama automáticamente cuando se crea un nuevo objeto. En nuestra clase Auto,
el constructor toma tres parámetros (marca, modelo, y año) y los asigna a los atributos del objeto:

La palabra clave this se utiliza aquí para referirse a los atributos del objeto actual. Ayuda a diferenciar entre los
parámetros del método y los atributos de la clase cuando tienen el mismo nombre.

Métodos

Un método en programación es una sección de código que se define dentro de una clase y se utiliza para realizar
una operación específica. Los métodos pueden recibir datos de entrada (parámetros), realizar acciones con esos
datos y, opcionalmente, devolver un resultado. Cada método tiene un nombre único dentro de su clase y se invoca
para ejecutar la tarea definida cuando es necesario. Los métodos permiten modularizar y reutilizar el código,
facilitando la organización y el mantenimiento de las aplicaciones.

Imagina que tienes una caja de crayones y cada crayón puede dibujar algo especial. Un método es como uno de
esos crayones. Cuando quieres dibujar algo, eliges el crayón correcto (método) y lo usas para crear tu dibujo
(realizar una tarea). Si deseas dibujar un sol, utilizas el crayón amarillo (método para dibujar un sol). Los métodos
nos ayudan a hacer cosas específicas en nuestros programas, como sumar números o mostrar mensajes, y podemos
usarlos cuantas veces queramos.

Método mostrarInfo()

Los métodos definen el comportamiento de los objetos de una clase. En nuestra clase Auto, hemos definido
un método llamado mostrarInfo() que no retorna ningún valor (void) y se utiliza para imprimir la información
del auto en la consola:
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 9

2.3 Creación de objetos

Para crear un objeto en Java, primero debes tener una clase definida. Luego, puedes crear un objeto (o instancia) de
esa clase usando el operador new, seguido del nombre de la clase y paréntesis. Por ejemplo, si tienes una clase Auto,
puedes crear un objeto miAuto de esta manera:

Para crear un objeto de la clase Auto, utilizamos el siguiente código:

En este ejemplo, miAuto es un objeto de la clase Auto. Utilizamos el constructor de Auto para asignar valores
a los atributos de miAuto y luego llamamos al método mostrarInfo() para imprimir los detalles del coche.

Para usar la clase Auto, creamos un objeto de esta clase en el método main de otra clase, por ejemplo, una
clase Main. Aquí es donde instanciamos un objeto Auto, proporcionando valores específicos para la marca, el
modelo y el año mediante el constructor:

Luego, podemos llamar al método mostrarInfo() en el objeto miAuto para imprimir sus detalles:
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 10

2.4 Herencia
La herencia es un mecanismo de la POO que permite que una clase (llamada subclase o clase derivada) herede
atributos y métodos de otra clase (llamada superclase o clase base). La herencia promueve la reutilización de
código y establece una relación is-a (es-una) entre la subclase y la superclase.

Imagina que la clase "Vehículo" es como un padre o una madre que tiene características generales de vehículos,
como ruedas y capacidad para moverse. Ahora, si tienes una clase "Auto", esta sería como un hijo de
"Vehículo". El "Auto" hereda todas las características de "Vehículo" (como tener ruedas y moverse), pero
además tiene sus propias características especiales, como aire acondicionado o un sistema de sonido. Esto
significa que "Auto" es un tipo específico de "Vehículo" con algunas extras. La herencia nos permite reutilizar
código (porque no tenemos que escribir de nuevo lo que ya está en "Vehículo" para "Auto") y organizar
mejor nuestras clases, haciendo nuestro código más limpio y fácil de entender.

2.4.1 Conceptos básicos de herencia

• Clases base (superclase): Es la clase de la cual otras clases pueden heredar. Define los atributos y
métodos comunes que serán compartidos por sus subclases. También conocida como clase padre o
superclase.

• Clase Derivada (Subclase): Es la clase que hereda de una superclase. Puede utilizar campos y métodos
de la superclase como si fueran propios, y además, tiene la capacidad de añadir nuevos campos y
métodos o modificar algunos de los heredados. También se le conoce como clase hija o subclase.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 11

2.4.2 Uso de ‘extends´

La palabra clave extends se utiliza para establecer una relación de herencia entre dos clases. Cuando una clase
B extiende a la clase A, B se convierte en la subclase de A, y A es la superclase de B.

2.4.3 Sobrecarga de métodos

La sobrecarga de métodos, también conocida como Method Overloading, es una técnica de programación que
permite a una clase tener varios métodos con el mismo nombre, pero con firmas diferentes, es decir, con listas
de parámetros que varían en tipo, número, o ambos. Esta capacidad facilita la implementación de métodos
que pueden realizar operaciones variadas, adaptándose al contexto de su llamada mediante el uso de
diferentes argumentos. Fundamental para diseñar interfaces de clase flexibles y reutilizables, la sobrecarga de
métodos promueve una mayor claridad en la codificación al permitir que variaciones de una misma operación
se nombren de manera consistente. Aunque es un concepto distinto de la herencia, su comprensión y
aplicación son cruciales en el contexto de clases y objetos para la creación de software robusto y mantenible.

En este ejemplo, mostrarTipo es un método sobrecargado que puede operar tanto con argumentos de tipo
String como int.

La sobrecarga de métodos permite a las subclases definir versiones específicas de un método heredado,
siempre que estos métodos sobrecargados tengan listas de parámetros diferentes. Esto puede ser útil para
extender o modificar el comportamiento de los métodos heredados en la subclase.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (JAVA) Pág. 12

3. Cierre
Para concluir nuestra discusión sobre los conceptos fundamentales de la Programación Orientada a Objetos
(POO) en Java, hemos explorado los pilares que constituyen la base de este paradigma de programación. Cada
uno de estos conceptos juega un papel crucial en el desarrollo de software, permitiendo a los desarrolladores
construir sistemas robustos, reutilizables, y mantenibles. A continuación, se presenta un resumen de los puntos
clave discutidos:

• Clases y Objetos: Las clases actúan como plantillas a partir de las cuales se crean los objetos, y los
objetos son instancias de esas clases. Las clases definen el estado y el comportamiento que sus objetos
compartirán.

• Encapsulamiento: Este principio se refiere a la agrupación de los datos (atributos) y los códigos
(métodos) en una unidad (clase) y restringir el acceso a los detalles internos de la implementación,
promoviendo así la seguridad de los datos y la modularidad.

• Herencia: Permite que una clase herede atributos y métodos de otra clase, facilitando la reutilización
de código y la creación de una jerarquía de clases dentro de una aplicación.

Estos conceptos son una parte del núcleo de la POO y son fundamentales para entender cómo diseñar y
estructurar aplicaciones en Java y en otros lenguajes de programación orientados a objetos. La habilidad para
aplicar correctamente estos principios influirá en la calidad, escalabilidad, y mantenibilidad del software
desarrollado, permitiendo a los equipos abordar desafíos de programación complejos de manera efectiva y
eficiente.