Acceso público

Clase 4 de 25 • Curso de TypeScript: Programación Orientada a Objetos y Asincronismo

Clase anteriorSiguiente clase

Migdualy Alejandra Gonzalez Martinez

student•

Si no le defines el acceso a ninguna variable por default sera pública.

Carlos Rodríguez

student•

Método o propiedad

Axel Enrique Galeed Gutierrez

student•

¿Qué quiere decir acceso público?

Esto quiere decir que podemos acceder a las propiedades y métodos del objeto desde el exterior.

Public

Por defecto, todas las propiedades y métodos son públicos pero si queremos aclarar en nuestro código el alcance de los mismos podemos utilizar la palabra reservada public.

class nameClass {
		public parameter1: dataType;
		constructor (parameters) { statements }

		public method (parameters): dataType { statements }
}

Desventajas del alcance público

La desventaja que tenemos al tener una propiedad o método con alcance público es que estás pueden ser modificables desde fuera de la clase.

Ejemplo

type PartOfTheCalendar = 'day' | 'month'| 'year';

export class MyDate {
    year: number;
    month: number;
    day: number;

    constructor (year: number, month: number, day: number) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    add (amount: number, type: PartOfTheCalendar) {
        if (type === 'day') this.day += amount;
        if (type === 'month') this.month += amount;
        if (type === 'year') this. year += amount;
    }
}

const myDate = new MyDate(2000, 11, 10);
myDate.day = 12;
MyDate.prototype.add = function () {
    console.log('Change');
};

console.log(myDate.day);
myDate.add(13, 'day');

Paolo Joaquin Pinto Perez

student•

Que ironia que ahora se parece más a java. jeje El encapsulamiento es lo mejor :D

Brahyan Antonio Martinez Madera

student•

Js fue mi amor a primera vista, ts fue mi amor maduro XD

Arnold Stuwar Pedraza Marin

student•

y asi inicia el encapsulamiento.

Diego Raciel Ortega Hernandez

student•

Nunca supe que era el acceso publico o privado :0 ahora lo se :'3

Jesús Patricio Pereira Matus

student•

la verdad que bueno venir de aprender java a aprender TS para ver angular porque te facilita entender la POO ya que java esta hecho sobre este paradigma de la programacion, en resumen les digo la POO esta hecho de 4 pilares, abstraccion, encapsulamiento, polimorfismo y herencia, la abstraccion viene de traer los objetos reales o conceptuales a la programacion o al mundo logico, el encapsulamiento trata de encapsular los datos con los accesos que se hablan en esta clase y obtenerlos via get y set que es obtener o cambiar que se hablan despues, polimorfismo trata de que algo lo puede hacer diferente ejemplo una clase animal puede hacer un sonido pero cada tipo de animal lo hara diferente, herencia es que las clases pueden heredar atributos y propiedades de otras clases ejemplo una persona puede ser trabajador

Jesús Patricio Pereira Matus

student•

agrego al ultimo ejemplo una persona puede ser trabajador pero seguira teniendo propiedades y metodos de un trabajador eso es herencia, claramente agregandole a la clase trabajador metodos como trabajar, salario, puesto entre otra cosas pero heredan de la persona

Dario Mendoza

student•

El alcance público en programación, especialmente en TypeScript y POO, tiene desventajas como:

Acceso no controlado: Cualquier parte del código puede modificar una propiedad, lo que puede generar errores difíciles de rastrear.
Dificultad en el mantenimiento: Aumenta la complejidad y puede dificultar la comprensión del flujo de datos.
Menor encapsulamiento: Se pierde la ventaja de la encapsulación, lo que puede exponer la lógica interna de una clase.

Es importante considerar el uso de modificadores de acceso, como privado o protegido, para mejorar la calidad y robustez del código.

Valentina Hernández

student•

Acceso Privado (private)

Es como una caja cerrada con llave:

Solo el propio objeto puede usarlo. ¡Nadie más puede tocarlo desde afuera!

class Cofre { 
private secreto: string = "Tesoro escondido"; 
mostrarSecreto() { 
console.log(this.secreto); // ✅ Se puede ver desde adentro 
}}
const miCofre = new Cofre();// 
console.log(miCofre.secreto); // ❌ Error: es privado miCofre.mostrarSecreto(); // ✅ El cofre te muestra el secreto

Valentina Hernández

student•

Acceso Privado (private)

```js

class Cofre { private secreto: string = "Tesoro escondido"; mostrarSecreto() { console.log(this.secreto); // ✅ Se puede ver desde adentro }} const miCofre = new Cofre();// console.log(miCofre.secreto); // ❌ Error: es privado miCofre.mostrarSecreto(); // ✅ El cofre te muestra el secreto

Valentina Hernández

student•

Acceso Público (public)

Es como una puerta abierta: ¡Cualquiera puede ver o usar eso del objeto!

class Juguete {

public nombre: string = "Carro";

}

const miJuguete = new Juguete();

console.log(miJuguete.nombre); // ✅ Se puede ver

Valentina Hernández

student•

Acceso Público (public)

Es Acceso Privado (private) como una puerta abierta: ¡Cualquiera puede ver o usar eso del objeto!

class Juguete { 
public nombre: string = "Carro";
}
const miJuguete = new Juguete();
console.log(miJuguete.nombre); // ✅ Se puede ver

Es como una caja cerrada con llave: Solo el propio objeto puede usarlo. ¡Nadie más puede tocarlo desde afuera!

class Cofre { 
private secreto: string = "Tesoro escondido"; 
mostrarSecreto() { 
console.log(this.secreto); // ✅ Se puede ver desde adentro 
}}
const miCofre = new Cofre();// 
console.log(miCofre.secreto); // ❌ Error: es privado miCofre.mostrarSecreto(); // ✅ El cofre te muestra el secreto

Alfonso Neil Jiménez

student•

La única ventaja que tendría usar el "readonly" es para emplear propiedades o atributos constantes en las clases que estamos seguros no cambiarán su valor en el ciclo de vida de la aplicación y tampoco podrán modificarse tanto interna como externamente, es decir, solamente las usaríamos para consultas.

Carlos Mario

student•

Modificadores de acceso

Los modificadores de acceso son fundamentales para implementar el encapsulamiento, cuyo objetivo es controlar el acceso a los datos de un objeto o instancia, protegiéndolos de modificaciones no deseadas. Estos modificadores establecen niveles de acceso a los atributos y métodos de una clase, mejorando la seguridad y la integridad de nuestras aplicaciones. Determinan cómo se pueden acceder o modificar los campos y métodos, definiendo si pueden ser accesibles desde otras partes del programa o solo dentro de la misma clase.

Los modificadores de acceso en TypeScript son:

public: El método o atributo es accesible desde cualquier parte del programa.
private: Solo puede ser accedido desde dentro de la misma clase.
protected: Solo es accesible desde la misma clase y las clases que heredan de ella.
readonly: Se puede leer pero no modificar después de su inicialización (aunque no es un modificador de acceso, es importante mencionarlo).

class NombreClase {
    // Atributos o propiedades
    public atributo1: tipo; // Atributo accesible desde cualquier parte
    private atributo2: tipo; // Atributo solo accesible dentro de la clase
    protected atributo3: tipo; // Atributo accesible en la clase y en clases derivadas
    // Constructor
    constructor(parametro1: tipo, parametro2: tipo, parametro3: tipo) {
		    // Inicialización de atributos
        this.atributo1 = parametro1;
        this.atributo2 = parametro2;
        this.atributo3 = parametro3;
    }
    // Método accesible desde cualquier parte
    public NombreMetodo(): tipo_retorno {
        // Código del método
    }
    
    // Método solo accesible dentro de la clase
    private NombreMetodo(): tipo_retorno {
        // Código del método
    }
    
    // Método accesible en la clase y en clases derivadas
    protected NombreMetodo(): tipo_retorno {
        // Código del método
    }    
}

Ronaldo Delgado

student•

buen video nos enseña los accesos públicos que se pueden tener el un objeto

Paolo Joaquin Pinto Perez

student•

Code CLASS

export class MyDate {
  public year: number;
  month: number;
  day: number;

  constructor(year: number, month: number, day: number) {
    this.year = year;
    this.month = month;
    this.day = day;
  }

  printFormat(): string {
    return `${this.day}/${this.month}/${this.year}`;
  }

  add(amount: number, type: 'days' | 'months' | 'years') {
    if (type == 'days') {
      this.day += amount;
    }
    if (type == 'months') {
      this.month += amount;
    }
    if (type == 'years') {
      this.year += amount;
    }
  }
}

const myDate = new MyDate(1993, 7, 9);

console.log(myDate.day);

myDate.day = 12;
console.log(myDate.day);

Andrés Felipe Eslava Zuluaga

student•

// Acceso público significa que desde que usamos la clase para instanciar y crear objetos,
// tenemos acceso a sus propiedades y métodos para ejecutarlas y leerlas, respectivamente

// si no se le especifica cuál tipo de propiedad es, TS deja por defecto el acceso público