Contenido del curso
Fundamentos de POO
POO Avanzada
Asincronismo y consumo de APIs
Genéricos
Próximos pasos
Acceso protegido
Contenido del curso
Carlos Rodríguez
Oier Solabarrieta Egues
Abraham Gonzalez
Axel Enrique Galeed Gutierrez
Miguel Angel Reyes Moreno
Kevin Daniel Guzman Delgadillo
Gerardo Ferreyra
Cesar Eduardo Valle Pino
Víctor Andrés Córdova Poma
Axel Enrique Galeed Gutierrez
Anibal Español
Adriana Paredes Salinas
Jordy Mairena Montoya
Ronaldo Delgado
Jose Martinez
Eduardo Robles
Ulises capistran martinez
Ronaldo Delgado
Diego Raciel Ortega Hernandez
Migdualy Alejandra Gonzalez Martinez
Josue Cerron Tuesta
Andrés Felipe Eslava Zuluaga
Lo que hizo el profe con el método move() es polimorfismo, es reescribir el método que adopta otro comportamiento en la clase hija, pero ene ste caso este otro comportamiento es un agregado de funcionalidad adicional antes de su ejecucíon por eso al final llama al move() del padre con super()
En verdad lo que hizo con el método move(), como bien dices, es una sobreescritura del método de la clase padre. Pero el polimorfismo no es exactamente eso, más bien consiste en poder asignar una instancia de clase hija a una variable de clase padre. Aquí hay un artículo donde se explica genial el concepto de polimorfismo:
Teniendo en cuenta el ejemplo de la clase, a una variable de tipo "Animal" le podemos asignar una instancia de tipo "Dog".
const animal: Animal = new Dog();
Hola Oier, permíteme aclarar un poco tu contribución.
La sobreescritura (overriding) es el mecanismo que nos permite implementar el polimorfismo (en este caso).
Dog sobreescribe la implementación de move() heredada de Animal para proporcionar un comportamiento específico para los perros.
Si no hubieras sobreescrito move() en Dog, entonces chase.move() habría ejecutado la implementación de Animal. En ese caso, no habría polimorfismo en este contexto específico.
Hay otras forma de implementar el polimorfismo como sobrecarga de métodos (overload).
¿Qué es protected?
Básicamente, es la forma de heredar propiedades y métodos.
Es similar a como funciona una propiedad o método privado, pero nos permite realizar herencia.
Sintaxis
class FatherClass { constructor ( protected property1: dataType, propertyN: dataType ) { statemenst } } class ChildClass extends FatherClass { constructor (properties and Inheritedproperties) { super(Inheritedproperties) statemenst } }
protected es un modificador de acceso que permite que los atributos y métodos de la clase sean accesibles desde la misma clase y desde las clases que heredan de esta.
En realidad este conocimiento de los modificadores de acceso de las propiedades de las clases es transversal a todos los lenguajes de programación:
protected a diferencia de private, permite heredar propiedades de una clase padre a sus clases hijas
Para llamar métodos de la clase padre con super no se puede hacer si las funciones son arrow functions.
Una consulta.
¿JavaScript tiene alguna palabra reservada que tenga la misma función que protected?, como el private class fields #en JavaScript que tienen la misma función de private en TypeScript.
Gracias. :D
Al parecer no hay nada equivalente en javascript, estuve observando el archivo transpilado .js y no vi diferencia al usar protected o public. Me parece que typescript solo "previene" que se acceda a una propiedad protected mostrando un error tanto en el editor de código como al momento de transpilar, esta es la escencia de typescript, el static type checking.
Podemos hacer que typescript ignore una linea donde hay un "error", colocando esto encima de la linea: //@ts-ignore
En JavaScript, puedes lograr un comportamiento similar usando convenciones de nomenclatura y el uso del comodín # para los private class fields, que son una característica introducida en ECMAScript 2022 (también conocido como ES12).
My code
export class Animal { protected _name: string; protected _sound: string; constructor(name: string, sound: string) { this._name = name; this._sound = sound; } get name(): string { return this._name; } set name(name: string) { this._name = name; } get sound(): string { return this._sound; } set sound(sound: string) { this._sound = sound; } move() { console.log('I am moving'); } greet() { console.log(this._sound); } } class Mammals extends Animal { protected _race: string; constructor(name: string, sound: string, race: string) { super(name, sound); this._race = race; } // override -> overwrite move() { super.move(); console.log(`I am ${this._name}`) } get race(): string { return this._race; } set race(race: string) { this._race = race; } } const cat = new Animal('kity', 'miauuuuu'); cat.move(); cat.greet(); const dog = new Mammals('Look', 'Guauuuu', 'Pitbul'); dog.greet(); dog.move();
tremendo
si queremos que nuestras propiedades sean privada pero tambien poder usarlas en las clases que heredan esas propiedades, tenemos que usar el modificador protected.
aaah no entendia porque yo no tenia ni un tipo de problema con las variables privadas y es que yo puse setters y getters para todo asi que realmente no accedia a la propiedad privada directamente sino por una propiedad publica el get name
muy bien :).
se aprende mucho
Finalmente entendi el polimorfismo y para que se usa el protected. :000
😱
wow!
// **protected** solo se puede usar de forma interna, por lo cual permite la herencia (hereda de forma privada) // **super** me permite tener acceso a las propiedades y atributos de la clase pladre