Master private fields and defaults in this exercise by creating a user class and secure bank account properties, enhancing your coding skills effectively.

Private Fields And Defaults

[00:00] Alright. Let's jump into this. So let's make our class user, and this user is going to have a name, email, and a role. And, the AI generated a default value for the role. But the interesting thing about that is we actually also have a default value for the role here.

[00:17] So which do we actually need? What would happen if I said, admin right here? Which one of these would actually end up being the default value? Well, it kinda depends. If you were to say console log this dot, role right here, then this dot role would actually be admin at that point.

[00:36] And then if you set it right here, after we set the role, then this dot role would be user or it would be whatever the user set the role to. So that's the reason I'm actually glad that the AI generated it this way so we can have this conversation because, if you are going to allow users or or people outside of the class to set a a value for a particular property, during in the constructor, then there's no reason to use a default value right here, in this position, because you're going to override it anyway when, you are setting the role to whatever the user, are is providing. And so here just to, to set the or, be a little more specific about this. If I were to do this test where we're making Alice and Alice is not providing a role but Bob is providing the role of admin, then we're gonna see that Alice role is defaulted to user, even though my default right here is defaulting the role to admin. And so, again, this default is meaningless, because we have this one here.

[01:40] Now, if you didn't want to allow anybody to, be able to specify a role, then this actually would be useful and we would get rid of this because we're not accepting the role. We would get rid of this and save that and now the default is user. If I didn't have this, then we would see, the role is undefined. So, having a default is useful, but you have to just keep in mind, am I letting external users of my user class control this property? And if you are, then there's no reason to, to have a default here.

[02:15] You would instead put the default in this position, which is what we're going to end up doing because we do want people to be able to control that role. Role is admin. That is what Oh, What are we doing? Type of Python here? What's going on?

[02:30] Alright. Sweet. So that is that. Now let's talk about private, values. So here's our bank account.

[02:38] We have an account number. We have a balance and a constructor, but we're not going to allow people to set the balance. And in fact, well, we technically, actually, we could. We're not going to, but we, you could absolutely set an initial balance and then set that. Sure.

[02:52] I'll leave that there. Yeah. Whatever. And then we don't need a default there because we're, taking the default there. But, the point here is that this special syntax right here is a private variable.

[03:06] And, actually, if we do a test here really quick, let's, comment out these. We're gonna deal with that later. You'll notice that, even though we are setting the balance on the instance of the bank account, we're not seeing that balance show up in here at all. So that is the, how the private fields work is they are only accessible within their own methods. And so here, we can have deposit and get balance, where deposit accepts an amount and changes the balance, and then get balance can return the balance.

[03:38] Now if you're gonna just have a way to get the value, then, do you really care so much about making it private? Well, yes, because it means that you can't set the value. So we we can get the balance at any time, but the only way that we can change the balance is through deposits. And maybe that's what you need for the design that you have, in mind for your, project. So, there we go.

[04:01] Now we can we deposit a $100, then we, lock the account, and then we get that, balance, and we got a $100. Woo hoo. Where are we getting you know, I'm buying or whatever. Alright. Let's do one more just for good measure.

[04:17] And, this, we have a class config. It has a host port and debug boolean. And for each one of these, we are accepting, values, but we're going to have a default. And so here we're gonna accept those. And, that's, like, pretty straightforward.

[04:33] You can see this new config, has all the defaults and then we overrode the defaults here. One thing that I didn't explicitly have you do, but I want to change is, once you get, like, two or three arguments or, parameters for your class or even even any kind of function, it can be a little unwieldy to know, okay. So wait. Is this example.com? And then we got 80eighty.

[04:58] And what's this true thing? Like, what is that what is that for? And so now I have to go into the implementation to figure out, oh, I see. Okay. That's the debug.

[05:05] Like, enable that. Or we can actually change this constructor completely to be an object instead. So here, I can say options. Whoops. And we're gonna need to fix that.

[05:18] There we go. Oh, no. What have I done? Hold on. Yeah.

[05:22] Yeah. The types will be here. We'll default those, and then there we go. Something like that. Alright.

[05:29] I messed it up royally, but watch this. Fix this, and the AI will just you know what I mean. You know what I'm trying to do. Oh, man. Alright.

[05:38] Fine. We'll have the AI turn this into an options object, and it'll it'll figure it out this time. It knows. It knows what I want. That's what I want.

[05:48] Thank you. Okay. This is actually pretty common, so the AI knows exactly what I'm trying to do here. So here I'm accepting an object and then I'm destructuring. So if you Maybe to make it a little bit more clear, I'd say options and then we'd say, that equals options.

[06:04] Okay. So don't destructor right in the top and that might make it more clear. So instead of three arguments, we're gonna accept an object that can, that has all those as properties. And what's really nice about that is it allows me to give named properties to all of my configuration options. It makes it easier for me to have them in any order I want.

[06:27] I can, enable or disable these really easily. So I do this a lot in not only classes, but in all of my functions. It's super, super helpful. The other thing to note about this, because all of these are optional, I also make the entire object optional. And so that's why we can say new config without providing an object because we're saying, hey, the object is optional.

[06:49] All of the properties are optional. We have default values for all of those things, that we're distracting from the options. Now if this is my code base and I was gonna live with this for a long time, this is how I would write it. I know maybe it's a lot of curly braces and stuff, but I promise, you get used to it, and now I can read it just as clear as anything else. So, yeah.

[07:11] That there you go. Then we can export these. All of these classes are just functions. It's amazing. And, yeah.

[07:18] I hope that you enjoyed this one. We've we've got, private fields. They're only accessible within the class. We've got default values. We've got We talked about options.

[07:27] It's a really good stuff in here. So good job on this one.

[00:00] Okay. In this exercise, we're gonna talk about private fields and we're also gonna do some more with the default stuff. So you're gonna, create a user class and a bank account and you don't want the bank account, information to be public or anything. So, you're going to, take that and make it a private, property. It's got a special syntax for that.

[00:19] So jump into this one, and we'll see you when you're done.

Most modern JavaScript and TypeScript development leans heavily on functions and plain objects. But classes, interfaces, and inheritance aren't going away. You'll encounter them in libraries, frameworks, and codebases across the industry, and if you don't understand how they work, you'll struggle to work with the code that uses them.

The problem is that without a clear mental model, you'll misuse inheritance where composition would be simpler, skip interfaces where they'd save you from brittle coupling, and create class hierarchies that become impossible to follow three levels deep.

In this workshop, you'll learn how to build classes with proper encapsulation, implement interfaces for polymorphism, extend base classes when inheritance makes sense, and reach for composition when it doesn't.

Every section pairs the "how" with the "why," so you don't just learn the syntax, you learn when each pattern earns its place and when simpler alternatives are the better choice.

## Classes

Classes are the fundamental building block of object-oriented TypeScript. They bundle data and behavior together into a single unit-- a user has a name and email, a shopping cart has items and a total. If you've only worked with plain objects and functions, classes introduce a new way to organize your code.

In this section, you'll build classes from scratch while learning how they work under the hood:

- Creating classes with properties, constructors, and methods
- Using `new` to create instances and understanding what `this` refers to
- Initializing properties with default values instead of constructor arguments
- Making fields private with the `#` syntax to control access
- Refactoring constructors to accept an options object instead of positional arguments

## Interfaces and Classes

An interface on its own is just a shape-- a contract that says "anything claiming to be this type must have these methods." The real power shows up when multiple classes implement the same interface, because now you can write functions that accept any of them without knowing which specific class they'll get.

This section teaches you how interfaces enable polymorphism in practice:

- Defining interfaces with method signatures that classes must implement
- Using the `implements` keyword to enforce a contract on a class
- Implementing multiple interfaces on a single class
- Programming to abstractions by accepting interfaces instead of concrete classes
- Writing functions that work with any implementation of a given interface

## Inheritance and Polymorphism

Inheritance lets one class build on another. A circle is a shape. A square is a rectangle. The child class inherits everything from the parent and can override specific behavior-- like calculating area differently for each shape.

Here you'll work through the mechanics of inheritance and understand where it helps and where it hurts:

- Extending a base class with the `extends` keyword
- Forwarding constructor arguments to the parent with `super`
- Overriding methods to provide specialized behavior in child classes
- Using substitutability to pass any child class where the parent is expected
- Understanding why deep inheritance chains become difficult to maintain

## Composition vs Inheritance

Inheritance says "this thing is a that." Composition says "this thing has a that." A car isn't an engine-- it has one. The distinction matters because inheritance creates tight coupling between parent and child, while composition lets you swap out parts without rewriting the class that uses them.

This section shows you when to reach for each approach and why composition is usually the better default:

- Distinguishing "is a" relationships (inheritance) from "has a" relationships (composition)
- Injecting dependencies through constructor arguments instead of hardcoding them
- Swapping implementations at runtime by passing different objects (file logger, console logger, silent logger)
- Using dependency injection to make classes testable with mock objects
- Defaulting to composition and reserving inheritance for clear "is a" cases


Programming Foundations

Structured Data

Type Safety

Object Oriented TypeScript

Advanced TypeScript

Practical TypeScript: Foundations to Fluency

Master object-oriented principles in TypeScript, including classes, inheritance, and polymorphism, to enhance your development skills and project quality.

Intro to Object Oriented TypeScript

Introduction to Object Oriented TypeScript

Master TypeScript classes to enhance your object-oriented programming skills. Discover properties, methods, and best practices for efficient coding.

Intro to Classes

Master the fundamentals of object-oriented TypeScript by creating and implementing classes with essential properties and instances in this engaging exercise.

Class Basics

Boost your coding skills with effective break techniques that enhance retention and prepare you for the next challenge. Refresh and recharge your learning!

Break Classes

1. Classes

Master polymorphism with interfaces and classes, and discover how to implement multiple interfaces like flyable and swimmable in your projects.

Intro to Interfaces and Classes

Master interface implementation by creating a class that showcases its benefits, enhancing your coding skills and understanding of object-oriented design.

Implementing Interfaces

Master interface implementation and unlock powerful programming abstractions to enhance code flexibility and efficiency with this engaging exercise.

Programming To Abstractions

Master breaking interfaces and classes to enhance your coding skills, improve polymorphism understanding, and solidify your programming knowledge.

Break Interfaces and Classes

2. Interfaces and Classes

Master inheritance and polymorphism in OOP. Discover how to extend classes and override methods to create flexible, reusable code in your projects.

Intro to Inheritance and Polymorphism

Master class inheritance and polymorphism by exploring the extends keyword. Gain essential skills to elevate your coding proficiency today!

Extends

Master method overriding by exploring how shapes like circles and rectangles can redefine properties, enhancing your object-oriented programming skills.

Method Overriding 

Master polymorphism by creating a versatile media player that seamlessly plays audio and video files, enhancing your development skills.

Substitutability 

Master breaking inheritance and polymorphism in coding to enhance your programming skills, making your projects more efficient and adaptable.

Break Inheritance and Polymorphism

3. Inheritance and Polymorphism

Master the key differences between composition and inheritance in object-oriented programming to enhance your coding clarity and efficiency.

Intro to Composition vs Inheritance

Master the use of composition vs inheritance in classes. Discover when to apply has-a vs is-a relationships to enhance your coding skills.

When To Use

Master dependency injection to simplify testing and enhance your code's flexibility. Boost your development skills with this essential design pattern.

Dependency Injection (Solution)

Dependency Injection

Master the differences between composition and inheritance in web development to enhance your coding skills and build more efficient applications.

Break Composition vs Inheritance

4. Composition vs Inheritance

Celebrate your mastery of Object Oriented TypeScript, from classes to polymorphism, and get ready to build amazing projects in the digital world!

Object Oriented TypeScript

Object Oriented TypeScript

Transcript

Private Fields And Defaults

Transcript