**Course Title:** Mastering TypeScript: From Basics to Advanced Applications **Section Title:** Classes and Object-Oriented Programming **Topic:** Static properties and methods, and abstract classes. ### Overview In this topic, we'll explore two essential concepts in TypeScript: static properties and methods, and abstract classes. These concepts help developers build more organized, maintainable, and efficient object-oriented code. By the end of this topic, you'll have a solid understanding of how to apply static properties and methods to classes and how to create abstract classes to define a blueprint for other classes. ### Static Properties and Methods In TypeScript, you can define static properties and methods on a class. These properties and methods belong to the class itself, not to instances of the class. They are shared by all instances of the class and can be accessed without creating an instance of the class. Here's an example of a class with static properties and methods: ```typescript class MathHelper { static PI = 3.14159; static calculateArea(radius: number): number { return Math.PI * radius * radius; } static calculateCircumference(radius: number): number { return 2 * Math.PI * radius; } } console.log(MathHelper.PI); // 3.14159 const area = MathHelper.calculateArea(10); console.log(area); // 314.159 const circumference = MathHelper.calculateCircumference(10); console.log(circumference); // 62.8318 ``` In the above example, `MathHelper.PI` is a static property, and `calculateArea()` and `calculateCircumference()` are static methods. **Key Takeaways:** 1. Static properties are created using the `static` keyword followed by the property name and assigned value. 2. Static methods are also defined using the `static` keyword followed by the method name and its parameters. 3. Both static properties and methods belong to the class itself, not to instances of the class. ### Abstract Classes An abstract class in TypeScript is a blueprint for other classes that cannot be instantiated on its own. Abstract classes define properties and methods that must be implemented by any non-abstract subclass. Abstract classes are useful when you want to provide a common set of properties and methods that can be shared among multiple related classes. Here's an example of an abstract class: ```typescript abstract class Animal { abstract makeSound(): void; protected eat(): void { console.log('Eating'); } } class Dog extends Animal { makeSound(): void { console.log('Woof!'); } } class Cat extends Animal { makeSound(): void { console.log('Meow!'); } } const dog = new Dog(); dog.makeSound(); // Woof! dog.eat(); // Eating const cat = new Cat(); cat.makeSound(); // Meow! cat.eat(); // Eating ``` In the above example, `Animal` is an abstract class with the abstract method `makeSound()` and the protected method `eat()`. The `Dog` and `Cat` classes extend the `Animal` class and provide their own implementation of `makeSound()`. **Key Takeaways:** 1. An abstract class can have abstract properties and methods that are declared using the `abstract` keyword and do not have an implementation. 2. Abstract classes can also have non-abstract properties and methods that have an implementation. 3. Non-abstract subclasses of an abstract class must implement all of the abstract properties and methods declared in the abstract class. ### Conclusion In this topic, we covered static properties and methods in TypeScript classes, as well as abstract classes that define a blueprint for other classes. ### Additional Learning Resources: For further learning, we recommend: * [TypeScript Handbook](https://www.typescriptlang.org/docs/) - This is the official TypeScript documentation and provides an exhaustive guide to TypeScript. * [TypeScript Static and Instance Members](https://www.logicbig.com/tutorials/misc/typescript/static-instace-members.html) - This provides an overview of using static and instance members in TypeScript. ### Feedback and Comments If you have any questions or feedback regarding this topic, feel free to leave a comment below and we will get back to you. In the next topic, we'll be discussing 'Implementing interfaces in classes.'.