POO
Objeto
Clase
Herencia
Polimorfismo
Abstracción
Encapsulamiento
Análisis
Diseño
Implementación
Clase Carro
Objeto
Rayo Mcqueen
Tesla
Audi
Un objeto puede tener infinitos atributos, pero no todos son relevantes para un problema dado
Clase Carro
Objeto
Tesla
Audi
color: string;
modelo: int;
precio_euros: float;
tieneGPS: boolean;
color = blanco;
modelo = 2022;
precio_euros = 100000;
tieneGPS = true;
color = rojo;
modelo = 2024;
precio_euros = 90000;
tieneGPS = false;
Diferentes objetos de una misma clase pueden reaccionar de distintas maneras a la ejecución de un método
Clase Carro
Tipos de relaciones:
public class Carro {
// Atributos
public String color;
public int modelo;
public float precio_euros;
public boolean tieneGPS;
// Constructor
public Carro(String color, int modelo, float precio_euros, boolean tieneGPS) {
this.color = color;
this.modelo = modelo;
this.precio_euros = precio_euros;
this.tieneGPS = tieneGPS;
}
// Métodos
public void encender() {
// Implementación del método encender
}
public void actualizarPrecio(double nuevoPrecio) {
// Implementación del método actualizarPrecio
}
public void activarAlarma() {
// Implementación del método activarAlarma
}
public double obtenerKilometraje() {
// Implementación del método obtenerKilometraje
}
public void recargarCombustible(double litros) {
// Implementación del método recargarCombustible
}
public void acelerar() {
// Implementación del método acelerar
}
}
Niveles de acceso o visibilidad
public class MyClass {
// Atributos con diferentes niveles de acceso
public int x;
protected int y;
private int z;
// Constructor
public MyClass(int x, int y, int z) {
this.x = x;
this.y = y;
this.z = z;
}
// Método público
public void publicMethod() {
// Do something
}
// Método protegido
protected void protectedMethod() {
// Do something
}
// Método privado
private void privateMethod() {
// Do something
}
}
// Getter
public type getAttribute() {
if (validationCondition) {
return this.attribute;
}
return null;
}
// Setter
public void setAttribute(type newValue) {
if (validationCondition) {
this.attribute = newValue;
}
}
Determina cuántos objetos de cada tipo intervienen en una relación
Indicador | Significado |
---|---|
0..1 | Cero o uno |
1 | Solo uno |
0..* | Cero o más |
1..* | Uno o más |
n | Solo n (n > 1) |
0..n | Cero a n (n > 1) |
1..n | Uno a n (n > 1) |
Asociación bidireccional
Asociación unidireccional
Asociación reflexiva
Agregación básica
Agregación de composición
Sobrecarga de métodos
Sobreescritura de métodos
Referencias múltiples
// Clase padre
class Animal {
protected String nombre;
protected int edad;
public Animal(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
public void hacerSonido() {
System.out.println("El animal hace un sonido");
}
}
// Clase derivada (hija)
class Perro extends Animal {
private String raza;
public Perro(String nombre, int edad, String raza) {
super(nombre, edad); // Llama atributos del padre
this.raza = raza;
}
@Override
public void hacerSonido() {
System.out.println("¡Guau!");
}
}
Representación de la herencia en UML: Donde Clase1 es la clase padre y Clase2 es la clase hija o clase derivada.
La clase hija en UML no debe ser escrita con los atributos o métodos que toma del padre. Solo se escriben nuevos atributos, nuevos métodos o métodos que fueron sobreescritos o modificados.
Es uno de los grandes aportes de la programación orientada a objetos.
Polimorfismo Interno - Sobrecarga de métodos
public class Calculadora {
public int sumar(int a, int b) {
return a + b;
}
public int sumar(int a, int b, int c) {
return a + b + c;
}
public double sumar(double a, double b) {
return a + b;
}
public String sumar(String a, String b) {
return a + b;
}
}
Polimorfismo Externo - Sobreescritura de métodos
// Clase padre
class Instrumento {
public void tocar() {
System.out.println("Tocando un instrumento");
}
}
// Clase hija
class Guitarra extends Instrumento {
@Override
public void tocar() {
System.out.println("Tocando la guitarra con las cuerdas");
}
}
Instrumento obj1 = new Instrumento();
obj1.tocar();
>> Tocando un instrumento
Guitarra obj2 = new Guitarra();
obj2.tocar();
>> Tocando la guitarra con las cuerdas
Polimorfismo Externo - Múltiple referencia
Un objeto puede ser referenciado de múltiples maneras:
// Clase padre
class Instrumento {
public void tocar() {
System.out.println("Tocando un instrumento");
}
}
// Clase hija
class Guitarra extends Instrumento {
@Override
public void tocar() {
System.out.println("Tocando la guitarra con las cuerdas");
}
}
Object obj = new Guitarra();
Instrumento obj = new Guitarra();
Guitarra obj = new Guitarra();
public abstract class FiguraGeometrica {
protected String color;
//Constructor
public Figura(String color) {
this.color = color;
}
//Métodos abtractos
public abstract double area();
public abstract double perimetro();
//Método no abstracto
public String getColor() {
return color;
}
}
Lo abstracto esta en cursiva(Italic)
public class Rectangulo extends FiguraGeometrica {
private double base;
private double altura;
public Rectangulo(String color, double base, double altura) {
super(color);
this.base = base;
this.altura = altura;
}
@Override
public double area() {
return base * altura;
}
@Override
public double perimetro() {
return 2 * (base + altura);
}
}
// Definición de la interfaz
public interface Sonido {
public void hacerSonido();
public void ajustarVolumen(int nivel);
}
// Clase que implementa la interfaz
public class Guitarra implements Sonido {
private String marca;
private int volumen;
public Guitarra(String marca) {
this.marca = marca;
this.volumen = 5; // volumen por defecto
}
@Override
public void hacerSonido() {
System.out.println("La guitarra " + marca + " hace notas musicales");
}
@Override
public void ajustarVolumen(int nivel) {
this.volumen = nivel;
System.out.println("Volumen ajustado a: " + nivel);
}
}
Ejemplo
public class Despertador implements Sonido {
private String hora;
private int volumen;
public Despertador(String hora) {
this.hora = hora;
this.volumen = 10;
}
@Override
public void hacerSonido() {
System.out.println("El despertador hace RING RING a las " + hora);
}
@Override
public void ajustarVolumen(int nivel) {
this.volumen = nivel;
System.out.println("Alarma ajustada a volumen: " + nivel);
}
}
Ejemplo
Estático(static)
public class MyClass {
public static int x = 5;
public static int add(int value) {
return value + x;
}
}
System.out.println(MyClass.x);
>> 5
System.out.println(MyClass.add(18));
>> 25
Final
private final String name;
public static final double PI = 3.1415;
public final class Student extends Person{...}
public enum DiaSemana {
LUNES,
MARTES,
MIERCOLES,
JUEVES,
VIERNES,
SABADO,
DOMINGO
}
public enum TipoVehiculo {
COCHE(4),
MOTO(2),
CAMION(6);
private final int numRuedas;
// Constructor privado
private TipoVehiculo(int numRuedas) {
this.numRuedas = numRuedas;
}
public int getNumRuedas() {
return numRuedas;
}
}
Otro ejemplo
Ventajas
Casos comunes de uso
Es el proceso de evaluar y verificar que un producto o aplicación de software lleve a cabo su propósito correctamente.
Beneficios de las pruebas:
Principios:
Tipos de pruebas:
Pruebas unitarias
Pruebas de integración
Pruebas funcionales
Pruebas de extremo a extremo
Pruebas de aceptación
Pruebas de rendimiento
Pruebas de humo
junit.
Es una librería externa que debe ser descargada y añadida al proyecto.public class MyClass {
private int number;
public MyClass(int number) {
this.number = number;
}
public int add(int value) {
return this.number + value;
}
}
import static org.junit.Assert.assertEquals;
import org.junit.Test;
public class MyClassTest {
@Test
public void testAdd() throws Throwable {
// Given
MyClass obj = new MyClass(5);
// When
int value = 12;
int result = obj.add(value);
// Then
assertEquals(17, result);
}
}