# Classes TypeScript: como defini-las e utilizá-las As classes do TypeScript oferecem uma forma clara e estruturada de organizar dados e comportamentos dentro de um **objeto**. Dessa forma, é possível modelar entidades e conceitos no código de maneira mais fácil e compreensível. ## Para que servem as aulas de TypeScript? As classes são fundamentais na linguagem de programação TypeScript, que é baseada em JavaScript. Elas fornecem um método estruturado para definir objetos e **aplicar a programação orientada a objetos (OOP)**. As classes do TypeScript são como uma espécie de planos para a criação de objetos, que agrupam dados e métodos relacionados de maneira lógica. [O TypeScript](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/typescript/) contém todas as funções do JavaScript e inclui **tipagem estática**, o que permite especificar tipos de dados para [funções no TypeScript](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/funcoes-typescript/), variáveis e classes, bem como detectar erros em tempo de compilação. Além da segurança de tipos, as classes do TypeScript também suportam conceitos como herança e abstração, o que facilita o desenvolvimento de aplicações complexas. As classes do TypeScript permitem estabelecer uma **hierarquia clara de classes** que herdam propriedades e métodos. Isso incentiva a reutilização e a estruturação do código. Os construtores nas classes possibilitam a inicialização de instâncias e garantem uma criação de objetos consistente. ## A sintaxe das classes do TypeScript A sintaxe das classes no TypeScript é semelhante à do **ECMAScript 6 (ES6)** e é uma versão ampliada da sintaxe das classes do JavaScript. Uma classe pode conter vários elementos para definir a estrutura e o comportamento dos objetos. Estes são os seus principais componentes: - **Propriedades**, - **construtor** e - **métodos**. ### Propriedades As propriedades ou properties determinam o **estado de um objeto**. Elas armazenam valores de dados e podem ser anotadas com tipos de dados para garantir que contenham apenas valores válidos. ```typescript class ClassName { propertyName: propertyType; } ``` - **ClassName**: o nome da classe. - **propertyName**: o nome da propriedade que pretende definir. - **propertyType**: o tipo de dados da propriedade. Veja este exemplo: ```typescript class Person { name: string; } ``` Primeiro, define-se uma classe chamada `Person` (pessoa) com uma propriedade denominada `name` (nome) do tipo `string`. Isso significa que as instâncias da classe `Person` têm uma propriedade `name` que armazena **cadeias de texto (strings)**. ### Construtor O construtor em TypeScript é um método especial que é chamado ao criar uma instância (um objeto) de uma classe. Ele é usado para **inicializar as propriedades (properties) de um objeto**. Basicamente, o construtor define o estado inicial de uma instância. Você pode especificar parâmetros no construtor para passar valores ao instanciar classes de TypeScript. A estrutura básica de um construtor em TypeScript tem a seguinte aparência: ```typescript class ClassName { constructor(parameter1: Type1, parameter2: Type2, ...) { } } ``` - **construtor**: cada classe pode ter apenas um construtor. Se nenhum for definido, um construtor vazio é criado por padrão. - **parâmetro: Tipo**: os parâmetros podem ser necessários ou não, dependendo do que a classe precisa fazer. É útil indicar que tipo de dados se espera para cada parâmetro. Aqui apresentamos um exemplo de construtor: ```typescript class Person { firstName: string; lastName: string; constructor(firstName: string, lastName: string) { this.firstName = firstName; this.lastName = lastName; } } ``` No exemplo anterior, a classe `Person` tem um construtor que aceita dois parâmetros: `firstName` (nome) e `lastName` (sobrenome). Ao **criar uma instância** dessa classe, esses parâmetros são passados e o construtor inicializa as propriedades `firstName` e `lastName` da instância com os valores correspondentes. A palavra-chave `this` refere-se à instância atual da classe na qual o código está a ser executado. ### Métodos Em TypeScript, os métodos são funções que podem ser definidas nas classes e aplicadas às suas instâncias. Com eles, é possível realizar **determinadas ações ou operações** no contexto de uma classe. ```typescript class ClassName { // ... methodName(parameter1: Type1, parameter2: Type2, ...): ReturnType { } // ... } ``` - **methodName**: nome do método. - **parameter: Tipo**: parâmetros opcionais que o método aceita. - **ReturnType**: é o tipo de dados que determina qual valor o método retorna. Se o método não retorna nada, pode especificar `void`. Para chamar uma propriedade ou um método numa instância de uma classe, utilize o operador ponto `.` seguido do nome do método e dos argumentos necessários, se o método esperar parâmetros. ```typescript class Person { firstName: string; lastName: string; constructor(firstName: string, lastName: string) { this.firstName = firstName; this.lastName = lastName; } getFullName(): string { return this.firstName + " " + this.lastName; } } const person = new Person("John", "Doe"); const fullName = person.getFullName(); ``` O método `getFullName` serve para criar o nome completo da pessoa e devolvê-lo. Recorre aos valores das propriedades `firstName` e `lastName` que foram definidas na classe e inicializadas no construtor. O objeto `person` é gerado utilizando a palavra-chave `new` seguida do nome da classe e dos parâmetros correspondentes. **Quando o método é chamado, ele concatena as duas cadeias** e retorna o nome completo como uma cadeia ou string. Portanto, a saída para o objeto `person` é “John Doe”. ## Exemplos de aplicação das classes do TypeScript As classes do TypeScript têm vários mecanismos para organizar e controlar **a estrutura e o comportamento dos objetos**. A seguir, apresentamos alguns conceitos para sua utilização. ### Visibilidade A visibilidade nas classes do TypeScript controla o acesso às propriedades e métodos dentro e fora da classe. O TypeScript fornece três modificadores de visibilidade: `public`, `private` e `protected`. - **público (padrão)**: as propriedades e métodos marcados com `public` podem ser chamados de qualquer lugar, tanto dentro como fora da classe. - **private**: refere-se a propriedades e métodos que só podem ser chamados dentro da própria classe. São inacessíveis para partes de código externas. - **protected**: as propriedades e métodos marcados com `protected` podem ser chamados pela própria classe e pelas classes derivadas (por herança), mas não por código externo. ```typescript class Person { private socialSecurityNumber: string; constructor(ssn: string) { this.socialSecurityNumber = ssn; } greet() { console.log("Hello, I am a person with SSN: " + this.socialSecurityNumber); } } const person = new Person("123-45-6789"); person.greet(); ``` No exemplo anterior, `socialSecurityNumber` (número da Segurança Social) é uma propriedade privada que só pode ser acedida dentro da classe `Person`. Em contrapartida, o método `greet` pode ser chamado a partir do exterior. ### Herencia A herança é um conceito fundamental na programação orientada a objetos (POO) que é usado no TypeScript e em muitas outras linguagens de programação web. Ela permite criar uma nova classe a partir de uma **classe base ou superclasse** existente. A classe derivada (subclasse) herda as propriedades e métodos da classe base e pode ampliá-los ou adaptá-los. ```typescript class Animal { name: string; constructor(name: string) { this.name = name; } makeSound() { console.log("Some generic sound"); } } class Dog extends Animal { makeSound() { console.log(this.name + " barks"); } } const myDog = new Dog("Buddy"); myDog.makeSound(); ``` No código anterior, a classe `Dog` (cão) herda da classe base `Animal` utilizando a palavra-chave `extends`. A classe derivada `Dog` sobrescreve o método `makeSound` para adicionar um comportamento específico enquanto assume a propriedade `name` de `Animal`. ### Somente leitura Ao utilizar a palavra-chave `readonly`, pode declarar propriedades das classes TypeScript ou objetos como **somente leitura**. Isso significa que, uma vez que uma propriedade é inicializada como somente leitura, o seu valor não poderá ser alterado posteriormente. ```typescript class Circle { readonly pi: number = 3.14159; radius: number; constructor(radius: number) { this.radius = radius; } getArea() { return this.pi *this.radius* this.radius; } } const myCircle = new Circle(5); console.log(myCircle.getArea()); // Output: ≈ 78,54 ``` Neste exemplo, a propriedade `pi` é somente leitura e é inicializada no construtor. Após a inicialização, `pi` não pode ser modificada. Se você tentar modificar o valor de `pi` após a inicialização, o TypeScript gerará um erro de compilação. This is a markdown version of: [https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/classes-typescript/](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/classes-typescript/) for AI/LLM consumption.