R
Tutorial R: Sistema S4: clases formales y validación
Aprende a definir clases formales, validar atributos y crear métodos S4 en R para programación orientada a objetos robusta y estructurada.
Aprende R y certifícateDefinición formal de clases con setClass()
El sistema S4 en R representa un enfoque estructurado para la programación orientada a objetos, ofreciendo mayor formalidad que el sistema S3 que vimos anteriormente. A diferencia de S3, donde las clases son bastante flexibles, S4 proporciona un marco más riguroso para definir clases con estructura predeterminada.
La función setClass() es el punto de partida para crear clases en el sistema S4. Esta función nos permite definir formalmente una clase especificando su nombre, atributos (llamados "slots") y otras características.
Sintaxis básica de setClass()
La estructura básica para definir una clase S4 es:
setClass(
Class, # Nombre de la clase
slots, # Definición de atributos
prototype # Valores predeterminados (opcional)
)
Veamos un ejemplo sencillo para entender mejor cómo funciona:
# Definimos una clase Persona
setClass(
"Persona",
slots = c(
nombre = "character",
edad = "numeric"
)
)
En este ejemplo, hemos creado una clase llamada "Persona" con dos atributos (slots): nombre (de tipo character) y edad (de tipo numeric).
Creación de objetos
Una vez definida la clase, podemos crear instancias (objetos) de esta clase utilizando la función new()
:
# Creamos un objeto de la clase Persona
ana <- new("Persona", nombre = "Ana García", edad = 28)
# Verificamos la clase del objeto
class(ana) # Devuelve "Persona"
Acceso a los slots
Para acceder a los atributos de un objeto S4, utilizamos el operador @
o la función slot()
:
# Accediendo a los slots con @
ana@nombre # "Ana García"
ana@edad # 28
# Alternativamente, usando la función slot()
slot(ana, "nombre") # "Ana García"
El operador @
es similar al operador $
que usamos con listas, pero específico para objetos S4.
Valores predeterminados con prototype
Podemos establecer valores predeterminados para los slots utilizando el argumento prototype
:
setClass(
"Estudiante",
slots = c(
nombre = "character",
edad = "numeric",
curso = "character",
promedio = "numeric"
),
prototype = list(
curso = "No asignado",
promedio = 0
)
)
# Creamos un estudiante sin especificar todos los slots
estudiante1 <- new("Estudiante", nombre = "Carlos", edad = 20)
# Los valores no especificados toman los valores del prototype
estudiante1@curso # "No asignado"
estudiante1@promedio # 0
Clases con herencia
S4 permite definir relaciones de herencia entre clases mediante el parámetro contains
:
# Definimos una clase EstudianteGraduado que hereda de Estudiante
setClass(
"EstudianteGraduado",
slots = c(
especialidad = "character",
asesor = "character"
),
contains = "Estudiante"
)
# Creamos un objeto de la clase EstudianteGraduado
graduado <- new("EstudianteGraduado",
nombre = "Laura",
edad = 24,
curso = "Maestría",
especialidad = "Estadística",
asesor = "Dr. Martínez")
# Podemos acceder tanto a los slots propios como a los heredados
graduado@nombre # "Laura"
graduado@especialidad # "Estadística"
Verificación de clases
Podemos verificar si un objeto pertenece a una clase específica utilizando la función is()
:
# Verificamos si graduado es un EstudianteGraduado
is(graduado, "EstudianteGraduado") # TRUE
# También es un Estudiante debido a la herencia
is(graduado, "Estudiante") # TRUE
Ejemplo práctico: Clase Rectángulo
Veamos un ejemplo más completo con una clase que representa un rectángulo:
# Definimos la clase Rectangulo
setClass(
"Rectangulo",
slots = c(
ancho = "numeric",
alto = "numeric"
),
prototype = list(
ancho = 1,
alto = 1
)
)
# Creamos algunos rectángulos
rect1 <- new("Rectangulo") # Usa los valores predeterminados
rect2 <- new("Rectangulo", ancho = 5, alto = 3)
# Calculamos el área (por ahora sin métodos formales)
calcular_area <- function(rectangulo) {
return(rectangulo@ancho * rectangulo@alto)
}
# Probamos la función
calcular_area(rect1) # 1 (1×1)
calcular_area(rect2) # 15 (5×3)
Ventajas de usar setClass()
El uso de setClass()
para definir clases S4 ofrece varias ventajas:
- Estructura formal: Las clases tienen una estructura predefinida y clara.
- Tipado de atributos: Cada slot tiene un tipo específico, lo que ayuda a prevenir errores.
- Valores predeterminados: Podemos establecer valores iniciales para los atributos.
- Herencia explícita: Las relaciones de herencia se definen formalmente.
Estas características hacen que el código sea más robusto y mantenible, especialmente en proyectos grandes o cuando se trabaja en equipo.
Consideraciones importantes
Al trabajar con clases S4, es importante tener en cuenta:
- Las clases S4 requieren que cargues el paquete methods, aunque normalmente ya está cargado en una sesión de R estándar.
- Los nombres de las clases suelen comenzar con mayúscula por convención.
- A diferencia de S3, en S4 no puedes añadir slots a un objeto después de crearlo.
# Esto generará un error
ana@direccion <- "Calle Principal 123" # Error: no se puede añadir slots
El sistema S4 proporciona un marco más estructurado para la programación orientada a objetos en R, lo que resulta especialmente útil cuando necesitamos garantizar la consistencia de nuestros objetos y sus atributos.
Slots y validación de atributos
Los slots son la columna vertebral de las clases S4, funcionando como contenedores formales para los atributos de un objeto. A diferencia del sistema S3, donde los atributos son flexibles, en S4 cada slot tiene un tipo específico que debe respetarse. Esta característica nos permite implementar un nivel adicional de seguridad mediante la validación de atributos.
Tipos de datos para slots
Cuando definimos una clase con setClass()
, debemos especificar el tipo de cada slot. R ofrece varios tipos básicos que podemos utilizar:
- character: para cadenas de texto
- numeric: para números (enteros o decimales)
- logical: para valores booleanos (TRUE/FALSE)
- integer: específicamente para números enteros
- list: para listas que pueden contener elementos heterogéneos
- matrix: para matrices
- data.frame: para marcos de datos
- Otras clases S4 definidas previamente
Veamos un ejemplo con diferentes tipos de slots:
setClass(
"Producto",
slots = c(
codigo = "character",
precio = "numeric",
disponible = "logical",
etiquetas = "list"
)
)
# Creamos un objeto con diferentes tipos de datos
producto1 <- new("Producto",
codigo = "P001",
precio = 29.99,
disponible = TRUE,
etiquetas = list("electrónica", "oferta"))
Validación básica de tipos
La primera capa de validación ocurre automáticamente cuando creamos un objeto. Si intentamos asignar un valor de tipo incorrecto a un slot, R generará un error:
# Esto generará un error porque precio debe ser numérico
try(
producto_error <- new("Producto",
codigo = "P002",
precio = "treinta euros", # Error: debe ser numeric
disponible = TRUE,
etiquetas = list("hogar"))
)
Validación personalizada con setValidity()
La función setValidity()
nos permite definir reglas de validación personalizadas para nuestras clases. Estas reglas van más allá de la simple comprobación de tipos y pueden incluir cualquier lógica que necesitemos:
# Definimos una clase con validación personalizada
setClass(
"Cuenta",
slots = c(
titular = "character",
saldo = "numeric",
limite_credito = "numeric"
)
)
# Añadimos reglas de validación
setValidity("Cuenta", function(object) {
# Verificamos que el titular no esté vacío
if (nchar(object@titular) == 0) {
return("El nombre del titular no puede estar vacío")
}
# Verificamos que el saldo no sea negativo
if (object@saldo < 0) {
return("El saldo no puede ser negativo")
}
# Verificamos que el límite de crédito sea positivo
if (object@limite_credito <= 0) {
return("El límite de crédito debe ser mayor que cero")
}
# Si todas las validaciones pasan, retornamos TRUE
return(TRUE)
})
La función de validación debe retornar TRUE
si el objeto es válido, o un mensaje de error (string) si no lo es.
Ahora, cuando intentemos crear un objeto que no cumpla con estas reglas, R generará un error:
# Objeto válido
cuenta_valida <- new("Cuenta",
titular = "María López",
saldo = 1000,
limite_credito = 500)
# Esto generará un error por saldo negativo
try(
cuenta_invalida <- new("Cuenta",
titular = "Juan Pérez",
saldo = -200, # Viola la regla de saldo no negativo
limite_credito = 300)
)
Validación de rangos y valores permitidos
Un caso común de validación es asegurarse de que los valores estén dentro de ciertos rangos o pertenezcan a un conjunto de valores permitidos:
setClass(
"Calificacion",
slots = c(
estudiante = "character",
asignatura = "character",
nota = "numeric",
estado = "character"
)
)
# Validación de rangos y valores permitidos
setValidity("Calificacion", function(object) {
# Validamos que la nota esté entre 0 y 10
if (object@nota < 0 || object@nota > 10) {
return("La nota debe estar entre 0 y 10")
}
# Validamos que el estado sea uno de los valores permitidos
estados_validos <- c("aprobado", "suspenso", "pendiente")
if (!object@estado %in% estados_validos) {
return(paste("El estado debe ser uno de:",
paste(estados_validos, collapse=", ")))
}
return(TRUE)
})
# Creamos una calificación válida
calificacion1 <- new("Calificacion",
estudiante = "Elena Gómez",
asignatura = "Estadística",
nota = 8.5,
estado = "aprobado")
# Esto generará un error por estado inválido
try(
calificacion2 <- new("Calificacion",
estudiante = "Carlos Ruiz",
asignatura = "Programación",
nota = 6.7,
estado = "excelente") # No está en la lista de estados válidos
)
Validación de relaciones entre slots
También podemos validar relaciones entre diferentes slots:
setClass(
"Rectangulo",
slots = c(
ancho = "numeric",
alto = "numeric",
area = "numeric"
)
)
# Validamos que el área sea consistente con ancho y alto
setValidity("Rectangulo", function(object) {
area_calculada <- object@ancho * object@alto
# Comprobamos si el área almacenada coincide con la calculada
if (abs(object@area - area_calculada) > 0.0001) { # Permitimos pequeñas diferencias por redondeo
return("El área debe ser igual a ancho * alto")
}
return(TRUE)
})
# Creamos un rectángulo válido
rect_valido <- new("Rectangulo", ancho = 5, alto = 3, area = 15)
# Esto generará un error por área inconsistente
try(
rect_invalido <- new("Rectangulo", ancho = 4, alto = 2, area = 10) # Debería ser 8
)
Validación con initialize()
Otra forma de implementar validación es mediante el método initialize()
, que se ejecuta cuando se crea un nuevo objeto. Esto nos permite calcular automáticamente valores o aplicar transformaciones:
setClass(
"Circulo",
slots = c(
radio = "numeric",
area = "numeric",
perimetro = "numeric"
)
)
# Definimos un método initialize personalizado
setMethod("initialize", "Circulo", function(.Object, radio, ...) {
# Llamamos al inicializador de la clase base
.Object <- callNextMethod(.Object, radio = radio, ...)
# Calculamos automáticamente el área y el perímetro
if (!missing(radio)) {
.Object@area <- pi * radio^2
.Object@perimetro <- 2 * pi * radio
}
# Retornamos el objeto inicializado
return(.Object)
})
# Creamos un círculo especificando solo el radio
circulo <- new("Circulo", radio = 5)
# Los otros valores se calculan automáticamente
circulo@area # Aproximadamente 78.54
circulo@perimetro # Aproximadamente 31.42
Validación en tiempo de ejecución con validObject()
La función validObject()
nos permite verificar explícitamente si un objeto cumple con sus reglas de validación en cualquier momento:
# Creamos un objeto válido
cuenta <- new("Cuenta",
titular = "Ana Martínez",
saldo = 500,
limite_credito = 1000)
# Modificamos directamente un slot
cuenta@saldo <- -100 # Esto hace que el objeto sea inválido
# Verificamos manualmente la validez
try(
validObject(cuenta) # Esto generará un error
)
# Corregimos el problema
cuenta@saldo <- 0
validObject(cuenta) # Ahora es válido
Ventajas de la validación de atributos
La validación de atributos en S4 ofrece varias ventajas importantes:
- Integridad de datos: Garantiza que los objetos siempre contengan datos válidos.
- Detección temprana de errores: Los problemas se identifican en el momento de la creación o modificación.
- Autovalidación: Los objetos pueden verificar su propia consistencia interna.
- Documentación implícita: Las reglas de validación sirven como documentación sobre las restricciones de los datos.
La combinación de slots tipados y validación personalizada hace que el sistema S4 sea especialmente adecuado para modelar dominios complejos donde la integridad de los datos es crucial, como aplicaciones científicas, financieras o de análisis estadístico.
Métodos S4 con setMethod()
Los métodos son una parte fundamental de la programación orientada a objetos, ya que definen el comportamiento de los objetos. En el sistema S4 de R, los métodos se implementan formalmente mediante la función setMethod()
, que nos permite asociar funciones específicas a combinaciones de clases.
A diferencia del sistema S3, donde los métodos se definen de manera más flexible, S4 proporciona un marco estructurado para la definición de métodos, permitiendo un control más preciso sobre qué función se ejecuta para cada tipo de objeto.
Estructura básica de setMethod()
La sintaxis básica para definir un método S4 es:
setMethod(
f, # Nombre del método genérico
signature, # Clases de los argumentos
definition # Función que implementa el método
)
Veamos cada componente:
- f: Es el nombre de la función genérica para la que estamos definiendo un método.
- signature: Especifica las clases de los argumentos para las que se aplicará este método.
- definition: Es la implementación del método, una función que se ejecutará cuando se llame al método genérico con objetos que coincidan con la firma.
Funciones genéricas
Antes de definir métodos específicos, necesitamos una función genérica. Podemos usar una existente o crear una nueva con setGeneric()
:
# Definimos una función genérica para calcular el área
setGeneric("calcularArea", function(objeto) {
standardGeneric("calcularArea")
})
La llamada a standardGeneric()
es crucial, ya que indica a R que debe buscar y ejecutar el método apropiado según la clase del objeto.
Implementando métodos para diferentes clases
Ahora podemos implementar el método calcularArea
para diferentes clases:
# Definimos una clase Rectangulo
setClass(
"Rectangulo",
slots = c(
ancho = "numeric",
alto = "numeric"
)
)
# Implementamos calcularArea para Rectangulo
setMethod(
"calcularArea",
signature("Rectangulo"),
function(objeto) {
return(objeto@ancho * objeto@alto)
}
)
# Definimos una clase Circulo
setClass(
"Circulo",
slots = c(
radio = "numeric"
)
)
# Implementamos calcularArea para Circulo
setMethod(
"calcularArea",
signature("Circulo"),
function(objeto) {
return(pi * objeto@radio^2)
}
)
Ahora podemos crear objetos y llamar al método:
# Creamos objetos
rect <- new("Rectangulo", ancho = 5, alto = 3)
circ <- new("Circulo", radio = 2)
# Llamamos al método genérico
calcularArea(rect) # Devuelve 15
calcularArea(circ) # Devuelve aproximadamente 12.57
El sistema S4 selecciona automáticamente el método adecuado según la clase del objeto.
Métodos con múltiples argumentos
Los métodos S4 pueden tener múltiples argumentos, y la firma puede especificar las clases para cada uno de ellos:
# Definimos una función genérica con dos argumentos
setGeneric("combinar", function(objeto1, objeto2) {
standardGeneric("combinar")
})
# Implementamos un método para combinar dos rectángulos
setMethod(
"combinar",
signature("Rectangulo", "Rectangulo"),
function(objeto1, objeto2) {
# Creamos un nuevo rectángulo con dimensiones combinadas
nuevo_ancho <- objeto1@ancho + objeto2@ancho
nuevo_alto <- max(objeto1@alto, objeto2@alto)
return(new("Rectangulo", ancho = nuevo_ancho, alto = nuevo_alto))
}
)
Podemos usar este método para combinar dos rectángulos:
rect1 <- new("Rectangulo", ancho = 3, alto = 2)
rect2 <- new("Rectangulo", ancho = 4, alto = 5)
# Combinamos los rectángulos
rect_combinado <- combinar(rect1, rect2)
# Verificamos las dimensiones
rect_combinado@ancho # 7
rect_combinado@alto # 5
Métodos para funciones estándar
Podemos definir métodos S4 para funciones estándar de R, como show()
(equivalente a print()
), plot()
, o los operadores aritméticos:
# Definimos un método show para Rectangulo
setMethod(
"show",
"Rectangulo",
function(object) {
cat("Rectángulo de", object@ancho, "x", object@alto, "\n")
cat("Área:", object@ancho * object@alto, "\n")
}
)
# Ahora cuando imprimimos un rectángulo, se usa nuestro método
rect <- new("Rectangulo", ancho = 4, alto = 3)
rect # Muestra: "Rectángulo de 4 x 3, Área: 12"
Métodos con argumentos opcionales
Podemos definir métodos que acepten argumentos opcionales utilizando ...
en la definición:
# Definimos una función genérica con argumentos opcionales
setGeneric("dibujar", function(objeto, ...) {
standardGeneric("dibujar")
})
# Implementamos el método para Circulo
setMethod(
"dibujar",
"Circulo",
function(objeto, color = "blue", relleno = FALSE, ...) {
cat("Dibujando círculo de radio", objeto@radio, "\n")
cat("Color:", color, "\n")
cat("Relleno:", if(relleno) "Sí" else "No", "\n")
# Aquí iría el código real para dibujar
}
)
# Usamos el método con diferentes opciones
circ <- new("Circulo", radio = 5)
dibujar(circ) # Usa valores predeterminados
dibujar(circ, color = "red", relleno = TRUE) # Personaliza opciones
Herencia de métodos
Los métodos S4 respetan la jerarquía de herencia de clases. Si definimos un método para una clase base, las clases derivadas pueden utilizarlo:
# Definimos una clase base Figura
setClass(
"Figura",
slots = c(
color = "character"
)
)
# Hacemos que Rectangulo herede de Figura
setClass(
"Rectangulo",
slots = c(
ancho = "numeric",
alto = "numeric"
),
contains = "Figura"
)
# Definimos un método para la clase base
setMethod(
"show",
"Figura",
function(object) {
cat("Figura de color", object@color, "\n")
}
)
# Creamos un rectángulo
rect <- new("Rectangulo", ancho = 5, alto = 3, color = "verde")
# El método show de Figura se aplica a Rectangulo
rect # Muestra: "Figura de color verde"
Podemos sobrescribir el método para la clase derivada si necesitamos un comportamiento específico:
# Sobrescribimos el método show para Rectangulo
setMethod(
"show",
"Rectangulo",
function(object) {
# Llamamos primero al método de la clase base
callNextMethod()
# Añadimos información específica del rectángulo
cat("Dimensiones:", object@ancho, "x", object@alto, "\n")
}
)
# Ahora el rectángulo muestra información más específica
rect # Muestra: "Figura de color verde" seguido de "Dimensiones: 5 x 3"
Métodos para operadores
Podemos definir métodos para operadores como +
, -
, *
, etc., lo que nos permite implementar operaciones personalizadas entre objetos:
# Definimos un método para el operador + entre dos rectángulos
setMethod(
"+",
signature("Rectangulo", "Rectangulo"),
function(e1, e2) {
# Sumamos las áreas y creamos un nuevo rectángulo cuadrado
area_total <- (e1@ancho * e1@alto) + (e2@ancho * e2@alto)
lado <- sqrt(area_total) # Lado de un cuadrado con la misma área
return(new("Rectangulo", ancho = lado, alto = lado))
}
)
# Probamos la suma de rectángulos
rect1 <- new("Rectangulo", ancho = 3, alto = 4) # Área = 12
rect2 <- new("Rectangulo", ancho = 2, alto = 5) # Área = 10
rect_suma <- rect1 + rect2 # Área = 22
rect_suma@ancho # Aproximadamente 4.69
rect_suma@alto # Aproximadamente 4.69
Verificación de métodos disponibles
Podemos usar la función showMethods()
para inspeccionar qué métodos están disponibles para una función genérica:
# Mostramos todos los métodos definidos para calcularArea
showMethods("calcularArea")
# Mostramos métodos para una clase específica
showMethods(class = "Rectangulo")
Ejemplo práctico: Sistema de gestión de formas
Veamos un ejemplo más completo que integra clases, validación y métodos:
# Definimos una clase base Forma
setClass(
"Forma",
slots = c(
nombre = "character",
color = "character"
),
prototype = list(
color = "negro"
)
)
# Validación para la clase base
setValidity("Forma", function(object) {
if (nchar(object@nombre) == 0) {
return("El nombre no puede estar vacío")
}
return(TRUE)
})
# Definimos subclases
setClass(
"Rectangulo",
slots = c(
ancho = "numeric",
alto = "numeric"
),
contains = "Forma",
prototype = list(
nombre = "rectángulo"
)
)
setClass(
"Circulo",
slots = c(
radio = "numeric"
),
contains = "Forma",
prototype = list(
nombre = "círculo"
)
)
# Definimos funciones genéricas
setGeneric("area", function(forma) standardGeneric("area"))
setGeneric("perimetro", function(forma) standardGeneric("perimetro"))
setGeneric("escalar", function(forma, factor) standardGeneric("escalar"))
# Implementamos métodos para Rectangulo
setMethod("area", "Rectangulo", function(forma) {
return(forma@ancho * forma@alto)
})
setMethod("perimetro", "Rectangulo", function(forma) {
return(2 * (forma@ancho + forma@alto))
})
setMethod("escalar", "Rectangulo", function(forma, factor) {
forma@ancho <- forma@ancho * factor
forma@alto <- forma@alto * factor
return(forma)
})
# Implementamos métodos para Circulo
setMethod("area", "Circulo", function(forma) {
return(pi * forma@radio^2)
})
setMethod("perimetro", "Circulo", function(forma) {
return(2 * pi * forma@radio)
})
setMethod("escalar", "Circulo", function(forma, factor) {
forma@radio <- forma@radio * factor
return(forma)
})
# Método show personalizado para todas las formas
setMethod("show", "Forma", function(object) {
cat(object@nombre, "de color", object@color, "\n")
})
# Probamos el sistema
rect <- new("Rectangulo", nombre = "Rectángulo A", color = "azul", ancho = 5, alto = 3)
circ <- new("Circulo", nombre = "Círculo B", color = "rojo", radio = 4)
# Mostramos las formas
rect # "Rectángulo A de color azul"
circ # "Círculo B de color rojo"
# Calculamos áreas y perímetros
area(rect) # 15
perimetro(rect) # 16
area(circ) # Aproximadamente 50.27
perimetro(circ) # Aproximadamente 25.13
# Escalamos las formas
rect_grande <- escalar(rect, 2)
area(rect_grande) # 60 (4 veces el área original)
Este sistema de gestión de formas demuestra cómo los métodos S4 nos permiten implementar comportamientos específicos para diferentes clases, manteniendo una interfaz común a través de funciones genéricas.
La combinación de clases formales, validación de atributos y métodos específicos hace que el sistema S4 sea una herramienta poderosa para modelar dominios complejos en R, especialmente cuando necesitamos garantizar la integridad de los datos y comportamientos bien definidos.
Otras lecciones de R
Accede a todas las lecciones de R y aprende con ejemplos prácticos de código y ejercicios de programación con IDE web sin instalar nada.
Instalación De R Y Rstudio
Introducción Y Entorno
Introducción A R
Introducción Y Entorno
Operadores
Sintaxis
Estructuras De Datos
Sintaxis
Funciones
Sintaxis
Estructuras De Control Iterativo
Sintaxis
Scopes Y Closures
Sintaxis
Estructuras De Control Condicional
Sintaxis
Funciones Anónimas
Sintaxis
Tipos De Datos Y Variables
Sintaxis
Sistema R6: Clases Referenciales Y Encapsulamiento
Programación Orientada A Objetos
Sistema S4: Clases Formales Y Validación
Programación Orientada A Objetos
Herencia Y Polimorfismo En R
Programación Orientada A Objetos
Sistemas De Oop En R
Programación Orientada A Objetos
Sistema S3: Clases Implícitas Y Métodos Genéricos
Programación Orientada A Objetos
Tidyverse Para Transformación De Datos
Manipulación De Datos
Lubridate Para Fechas Y Tiempo
Manipulación De Datos
Group_by Y Summarize Para Agrupación Y Resumen
Manipulación De Datos
Stringr Para Expresiones Regulares
Manipulación De Datos
Tidyr Para Limpieza De Valores Faltantes
Manipulación De Datos
Joins En R Para Combinación Y Relaciones De Tablas
Manipulación De Datos
Pivot_longer Y Pivot_wider Para Reestructuración
Manipulación De Datos
Mutate Y Transmute Para Transformación
Manipulación De Datos
Dplyr Para Filtrado Y Selección
Manipulación De Datos
Readr Y Read.csv Para Importar Datos
Manipulación De Datos
Gráficos Bivariantes En R
Visualización De Datos
Gráficos Univariantes En R
Visualización De Datos
Facetas En Ggplot2
Visualización De Datos
Personalización Y Temas
Visualización De Datos
Ggplot2 Para Visualización De Datos
Visualización De Datos
Gráficos Multivariantes En R
Visualización De Datos
Correlación En R
Estadística
Regresión Lineal En R
Estadística
Pruebas De Hipótesis En R
Estadística
Anova En R
Estadística
Estadística Descriptiva En R
Estadística
Ejercicios de programación de R
Evalúa tus conocimientos de esta lección Sistema S4: clases formales y validación con nuestros retos de programación de tipo Test, Puzzle, Código y Proyecto con VSCode, guiados por IA.
En esta lección
Objetivos de aprendizaje de esta lección
- Comprender la definición formal de clases S4 usando setClass()
- Aprender a validar atributos y relaciones entre slots con setValidity() y validObject()
- Implementar métodos específicos para clases S4 mediante setMethod()
- Gestionar herencia y valores predeterminados en clases S4
- Aplicar un sistema completo de clases, validación y métodos para modelar dominios complejos en R