📘 Clase 7 — Modificadores de acceso (public, protected, private)

TypeScript · 2026-07-12 · Carpeta: 02-Ejercicios/Tipos_clase ⬅️ Volver al índice de clases

🎯 Qué aprendí

• Qué son los modificadores de acceso en una clase.
• Cuándo usar public, protected y private.
• Cómo estos modificadores ayudan al encapsulamiento.
• Qué miembros se pueden usar desde fuera de la clase y cuáles no.
• Cómo documentar mejor la intención de una clase con niveles de acceso.

---

📖 PARTE TEÓRICA

🧱 1. ¿Qué son los modificadores de acceso?

Los modificadores de acceso son palabras clave que indican desde dónde se puede usar una propiedad o un método de una clase.

En TypeScript, los tres principales son:

• public
• protected
• private

Sirven para aplicar uno de los pilares de la POO: el encapsulamiento, es decir, agrupar datos y comportamientos relacionados y controlar qué se expone y qué se protege.

🌍 2. public: accesible desde cualquier parte

Un miembro public puede usarse dentro de la clase y también desde fuera.

class Persona {
  public name: string;

  constructor(name: string) {
    this.name = name;
  }
}

const persona = new Persona("Styp");
console.log(persona.name); // ✅ permitido

💡 public es lo que forma parte de la "cara visible" de la clase.

🛡️ 3. protected: visible dentro de la clase

Un miembro protected no se puede usar desde fuera con una instancia normal. Su idea es que quede disponible dentro de la clase y reservado para casos más avanzados que veremos después.

class Persona {
  protected age: number;

  constructor(age: number) {
    this.age = age;
  }
}

const persona = new Persona(30);
// console.log(persona.age); // ❌ no permitido

📝 Por ahora, quédate con esta idea: protected no es público, pero tampoco es tan cerrado como private. Se usa cuando algo no debe exponerse hacia afuera.

🔒 4. private: solo dentro de la clase

Un miembro private solo existe para la lógica interna de esa clase.

class Persona {
  private isDeveloper: boolean;

  constructor(isDeveloper: boolean) {
    this.isDeveloper = isDeveloper;
  }
}

const persona = new Persona(true);
// console.log(persona.isDeveloper); // ❌ no permitido

💡 Usa private cuando un dato o comportamiento sea estrictamente interno y no quieras que nadie lo toque desde fuera.

⚖️ 5. Diferencia entre public, protected y private

Modificador	¿Se puede usar fuera de la clase?	Uso típico
public	✅ Sí	Datos y métodos que quieres exponer
protected	❌ No	Mecánicas internas que no deben verse afuera
private	❌ No	Datos y lógica totalmente interna

👤 6. La clase real trabajada en este tema

Este fue el ejemplo base verificado:

export class Persona {
  public name: string;
  protected age: number;
  private isDeveloper: boolean;

  constructor(name: string, age: number, isDeveloper: boolean) {
    this.name = name;
    this.age = age;
    this.isDeveloper = isDeveloper;
  }

  public saludar(): string {
    return `Hola, mi nombre es ${this.name}, tengo ${this.age} años`;
  }

  protected obtenerEdad(): number {
    return this.age;
  }

  private esDesarrollador(): boolean {
    return this.isDeveloper;
  }
}

Lo importante:

• name es público y sí puede verse desde fuera.
• age está protegido y no puede consultarse desde una instancia normal.
• isDeveloper es privado y queda encerrado dentro de la clase.
• saludar() sí puede ejecutarse desde fuera porque es public.

🧠 7. ¿Cómo afectan estos modificadores a la visibilidad?

En el archivo de implementación:

import { Persona } from "./clase.js";

let persona = new Persona("Styp", 30, true);
console.log(persona.saludar());

Esto sí funciona porque saludar() es público.

Pero estas líneas fallarían:

// console.log(persona.age);              // ❌ protected
// console.log(persona.obtenerEdad());    // ❌ protected
// console.log(persona.isDeveloper);      // ❌ private
// console.log(persona.esDesarrollador()); // ❌ private

🧪 En el autocompletado del editor, cuando escribes persona., normalmente solo verás los miembros públicos disponibles.

🧷 8. ¿Por qué son importantes?

Los modificadores de acceso ayudan a:

• proteger datos sensibles
• evitar uso incorrecto desde fuera
• dejar claro qué forma parte de la API pública
• mantener código más ordenado y más fácil de evolucionar

Una buena regla mental es:

• empieza con lo más cerrado
• expón solo lo necesario

💡 En la práctica: si algo no necesitas mostrar afuera, no lo hagas público por defecto.

🧭 9. ¿Cuándo usar private y cuándo protected?

Usa private cuando el dato o método sea exclusivo de esa clase y absolutamente nadie más deba tocarlo. Es como un diario personal con candado.

Usa protected cuando quieras reservar una pieza interna y no exponerla al mundo exterior. Por ahora puedes pensarlo como un nivel intermedio: no es visible fuera, pero tampoco es tan cerrado como private.

📝 En esta clase no trabajamos herencia todavía. Aquí el foco es entender la diferencia de visibilidad y el encapsulamiento.

---

💻 PARTE PRÁCTICA

Archivos trabajados:

• 02-Ejercicios/Tipos_clase/clase.ts
• 02-Ejercicios/Tipos_clase/implementacion.ts

cd 02-Ejercicios/Tipos_clase
tsc && node implementacion.js

Código verificado:

• la clase Persona define miembros public, protected y private
• implementacion.ts importa la clase con ./clase.js
• se crea una instancia y se llama al método público saludar()

Salida real:

Hola, mi nombre es Styp, tengo 30 años

Todo verificado y corriendo. ✅

---

🏋️ EJERCICIOS CON SOLUCIÓN

Ejercicio 1 — Propiedad pública

Crea una clase Usuario con una propiedad pública nombre y un método público saludar(). Luego crea una instancia e imprime el nombre y el saludo.

Ver solución

class Usuario {
  public nombre: string;

  constructor(nombre: string) {
    this.nombre = nombre;
  }

  public saludar(): string {
    return `Hola, soy ${this.nombre}`;
  }
}

let usuario = new Usuario("Ana");
console.log(usuario.nombre);
console.log(usuario.saludar());

Terminal esperada:

zsh · usuario.ts

$ tsc usuario.ts
$ node usuario.js
Ana
Hola, soy Ana

Ejercicio 2 — Miembro privado

Crea una clase Cuenta con una propiedad privada saldo y un método público verSaldo(). No intentes imprimir saldo directamente; hazlo a través del método.

Ver solución

class Cuenta {
  private saldo: number;

  constructor(saldo: number) {
    this.saldo = saldo;
  }

  public verSaldo(): string {
    return `Saldo actual: ${this.saldo}`;
  }
}

let cuenta = new Cuenta(500);
console.log(cuenta.verSaldo());

// console.log(cuenta.saldo);
// ❌ Error: Property 'saldo' is private.

Terminal esperada:

zsh · cuenta.ts

$ tsc cuenta.ts
$ node cuenta.js
Saldo actual: 500

Ejercicio 3 — Método protegido

Crea una clase Perfil con una propiedad pública nombre y un método protegido obtenerMensajeInterno(). Agrega un método público mostrarMensaje() que use internamente el método protegido.

Ver solución

class Perfil {
  public nombre: string;

  constructor(nombre: string) {
    this.nombre = nombre;
  }

  protected obtenerMensajeInterno(): string {
    return `Mensaje interno para ${this.nombre}`;
  }

  public mostrarMensaje(): string {
    return this.obtenerMensajeInterno();
  }
}

let perfil = new Perfil("Luis");
console.log(perfil.mostrarMensaje());

// console.log(perfil.obtenerMensajeInterno());
// ❌ Error: Property 'obtenerMensajeInterno' is protected.

Terminal esperada:

zsh · perfil.ts

$ tsc perfil.ts
$ node perfil.js
Mensaje interno para Luis

Ejercicio 4 — Comparar visibilidades

Crea una clase PersonaSegura con:

• public nombre
• protected edad
• private activo

Agrega un método público resumen() que imprima los tres datos.

Ver solución

class PersonaSegura {
  public nombre: string;
  protected edad: number;
  private activo: boolean;

  constructor(nombre: string, edad: number, activo: boolean) {
    this.nombre = nombre;
    this.edad = edad;
    this.activo = activo;
  }

  public resumen(): string {
    return `Nombre: ${this.nombre}, Edad: ${this.edad}, Activo: ${this.activo}`;
  }
}

let persona = new PersonaSegura("Carlos", 28, true);
console.log(persona.resumen());
console.log(persona.nombre);

// console.log(persona.edad);
// console.log(persona.activo);

Terminal esperada:

zsh · personaSegura.ts

$ tsc personaSegura.ts
$ node personaSegura.js
Nombre: Carlos, Edad: 28, Activo: true
Carlos

🧭 ¿Para qué sirven estos modificadores?

Se usan para controlar qué partes de una clase deben verse desde fuera y cuáles deben quedar protegidas.

• public para lo que sí quieres exponer
• protected para mecánicas internas no visibles externamente
• private para datos y lógica completamente internos

💡 En resumen: los modificadores de acceso hacen tus clases más claras, seguras y ordenadas.

---

❓ Preguntas y respuestas (autoevaluación)

1. ¿Qué hace public?

Permite acceder a la propiedad o método desde cualquier parte del código.

2. ¿Qué hace private?

Restringe el acceso solo al interior de la clase donde fue definido.

3. ¿Qué hace protected en esta etapa del curso?

Marca un miembro como no visible desde fuera de la clase; es un nivel intermedio de acceso.

4. ¿Por qué usar modificadores de acceso?

Para controlar visibilidad, proteger datos y hacer más claro el diseño de la clase.

5. ¿Qué significa encapsulamiento?

Agrupar datos y métodos relacionados en una clase y controlar cómo se accede a ellos.

📎 Apuntes relacionados

• Clase 6: clases básicas
• Conceptos
• Comandos

➡️ Siguiente

Herencia y extends para reutilizar comportamiento entre clases.