🏛️ Classes na Programação: Construindo os Alicerces do Seu Código!

Olá HaWker! Jeff Bruchado por aqui.

Esse é mais um artigo da nossa série de artigos que vai cobrir a nossa jornada para Aprender Programação do Zero.

Bom, as Classes no mundo da programação são como os personagens principais de um filme, cada uma com seu próprio conjunto de características e habilidades.

No JavaScript, uma classe é como um molde para criar objetos. É um jeito de definir características (propriedades) e ações (métodos) que um certo tipo de objeto terá.

Por que mergulhar no mundo das Classes é uma boa?

• Organização: Classes ajudam a organizar seu código. É como ter diferentes capítulos em um livro, cada um contando uma parte da história.
• Reutilização: Com classes, você cria um modelo uma vez e o reutiliza para criar quantos objetos quiser. Como fazer várias cópias de uma chave mestra.
• Herança: Classes podem herdar características de outras classes. Isso significa menos código repetido e uma estrutura mais clara.
• Encapsulamento: Classes permitem encapsular dados, o que significa que você pode esconder detalhes internos e mostrar apenas o necessário para o uso externo.

Mas Jeff, como funcionam as Classes no JavaScript❓

Definição

Você começa definindo uma classe com a palavra-chave class, seguida do nome da classe. Dentro dela, você define propriedades e métodos.

Construtor

Dentro de uma classe, você pode ter um método especial chamado constructor. Este método é chamado quando você cria um novo objeto da classe. Ou seja, ele sempre é chamado ao instanciar uma classe.

Instância de Objetos

Depois de definir uma classe, você pode criar objetos (instâncias) dessa classe usando a palavra-chave new.

Herança

Com extends, uma classe pode herdar propriedades e métodos de outra classe. Ou seja, você pode criar classes e mesclá-las com outras classes.

Por exemplo:

class Animal {  constructor(nome) {    this.nome = nome;  }  falar() {    console.log(`${this.nome} faz um som.`);  }}class Cachorro extends Animal {  falar() {    console.log(`${this.nome} late.`);  }}let meuCachorro = new Cachorro('Rex');meuCachorro.falar(); // Rex late.

Neste exemplo, Animal é uma classe com um método falar(). Cachorro é uma subclasse de Animal e tem sua própria versão do método falar().

Então, veja só:

Classes são como esqueletos que dão forma e função aos objetos no seu código. Elas são super úteis para manter tudo organizado, reutilizável e fácil de manter. É como ter um conjunto de ferramentas que você personaliza para construir várias coisas diferentes, mas todas com a mesma base.

Sensacional, né? Vamos nos aprofundar mais a seguir.

Classes

É uma forma de definir um modelo para um objeto, em explicações mais antigas, basicamente é a abstração de entidades do mundo real no mundo virtual.

É uma forma de definir as propriedades e comportamentos (métodos) que um objeto deve ter, de maneira que você possa criar vários objetos que são da mesma "categoria", com as mesmas características.

A seguir um exemplo de classe:

class Person {  constructor(name, age) {    this.name = name;    this.age = age;  }  greet() {    console.log(      `Hello, my name is ${this.name} and I am ${this.age} years old.`    );  }}

Neste exemplo, estamos criando uma classe chamada "Person", que possui dois atributos (name e age) e um método (greet).

O método "constructor" é um método especial que é chamado quando você cria um novo objeto a partir dessa classe. Ou seja, esse método irá realizar a construção do seu Object.

Para criar um novo objeto a partir dessa classe, você pode fazer assim:

const person1 = new Person('Jefferson', 25);const person2 = new Person('Lucas', 40);

Com isso, você pode acessar as propriedades e métodos desses objetos da seguinte forma:

console.log(person1.name); // Jeffersonconsole.log(person2.age); // 40person1.greet(); // Hello, my name is Jeff and I am 25 years old.person2.greet(); // Hello, my name is Lucas and I am 40 years old.

Além do método "constructor" que já mencionei, as classes também podem ter outros métodos.

Por exemplo:

class Person {  constructor(name, age) {    this.name = name;    this.age = age;  }  greet() {    console.log(      `Hello, my name is ${this.name} and I am ${this.age} years old.`    );  }  incrementAge() {    this.age += 1;  }}const person1 = new Person('Jefferson', 25);person1.incrementAge();console.log(person1.age); // 26

Neste exemplo, criamos uma classe "Person" com dois métodos: "greet" e "incrementAge". O método "incrementAge" incrementa a idade da pessoa em 1.

Outra coisa importante a saber é que as classes são "construtores", ou seja, você pode usá-las para criar novos objetos usando a palavra-chave "new".

Por exemplo:

const person1 = new Person('Jeff', 25);const person2 = new Person('John', 40);

Esses objetos criados a partir da classe "Person" são chamados de "instâncias" da classe.

Eles possuem todas as propriedades e métodos definidos na classe, mas cada um tem seus próprios valores para essas propriedades.

Além disso, é possível criar novas classes que "estendem" outras classes.

Isso significa que a nova classe terá todas as propriedades e métodos da classe pai, e também pode ter propriedades e métodos adicionais.

Por exemplo:

class Person {  constructor(name, age) {    this.name = name;    this.age = age;  }  greet() {    console.log(      `Hello, my name is ${this.name} and I am ${this.age} years old.`    );  }  incrementAge() {    this.age += 1;  }}class Student extends Person {  constructor(name, age, major) {    super(name, age); // chama o construtor da classe pai    this.major = major;  }  study() {    console.log(`I am studying ${this.major}.`);  }}const student1 = new Student('Jeff', 25, 'Computer Science');student1.greet(); // Hello, my name is Jeff and I am 25 years old.student1.study(); // I am studying Computer Science.

Neste exemplo, criamos uma classe "Student" que estende a classe "Person".

A classe "Student" tem um novo atributo (major) e um novo método (study).

No construtor da classe "Student", chamamos o construtor da classe pai usando a palavra-chave "super".

Bom, anteriormente eu mencionei a palavra super, e a seguir nós vamos entender mais detalhadamente como o super funciona.

Super

O "super" é uma palavra-chave usada dentro de uma classe que estende outra classe (ou seja, que é uma "subclasse").

Ela se refere ao construtor da classe pai (ou "superclasse").

Quando você cria uma subclasse, é comum que ela tenha um construtor próprio, que deve chamar o construtor da classe pai para inicializar as propriedades da subclasse.

Para fazer isso, você pode usar o "super" como um método, passando os argumentos necessários.

Por exemplo:

class Person {  constructor(name, age) {    this.name = name;    this.age = age;  }  greet() {    console.log(      `Hello, my name is ${this.name} and I am ${this.age} years old.`    );  }}class Student extends Person {  constructor(name, age, major) {    super(name, age); // chama o construtor da classe pai    this.major = major;  }  study() {    console.log(`I am studying ${this.major}.`);  }}const student1 = new Student('Jeff', 25, 'Computer Science');student1.greet(); // Hello, my name is Jeff and I am 25 years old.student1.study(); // I am studying Computer Science.

Neste exemplo, a classe "Student" estende a classe "Person".

No construtor da classe "Student", chamamos o construtor da classe pai usando "super(name, age)".

Isso inicializa as propriedades "name" e "age" da subclasse.

Além de ser usado no construtor de uma subclasse, "super" também pode ser usado para acessar métodos da classe pai.

Por exemplo:

class Person {  constructor(name) {    this.name = name;  }  greet() {    console.log(`Hello, my name is ${this.name}.`);  }}class FriendlyPerson extends Person {  greet() {    super.greet(); // chama o método greet da classe pai    console.log("It's nice to meet you!");  }}const friendlyPerson1 = new FriendlyPerson('Jeff');friendlyPerson1.greet();// Output:// Hello, my name is Jeff.// It's nice to meet you!

Neste exemplo, a classe "FriendlyPerson" estende a classe "Person" e tem um método "greet" próprio.

No entanto, o método "greet" da classe "FriendlyPerson" também chama o método "greet" da classe pai usando "super.greet()".

Isso permite que a classe "FriendlyPerson" herde o comportamento do método “greet” da classe pai (Person) e adiciona mais um comportamento a ele.

Além de ser usado no construtor e nos métodos de uma subclasse, "super" também pode ser usado para acessar propriedades da classe pai.

Por exemplo:

class Person {  constructor(name) {    this.name = name;  }}class Student extends Person {  constructor(name, major) {    super(name);    this.major = major;  }  getDescription() {    return `${super.name} is studying ${this.major}.`;  }}const student1 = new Student('Jeff', 'Computer Science');console.log(student1.getDescription()); // Jeff is studying Computer Science.

Neste exemplo, a classe "Student" estende a classe "Person" e tem um método "getDescription" que retorna uma string com o nome e a major do estudante.

No método "getDescription", usamos "super.name" para acessar a propriedade "name" da classe pai.

Conclusão

Em resumo, as classes são uma ferramenta poderosa para o desenvolvimento porque permitem que você crie objetos que possuem propriedades e métodos.

Elas fornecem uma maneira de organizar e estruturar seu código de maneira mais clara e fácil de entender. Além disso, as classes também permitem que você crie herança, o que significa que você pode criar novas classes com base em classes existentes, compartilhando suas propriedades e métodos.

💡O conhecimento sobre classes é importante porque pode ajudar a tornar seu código mais organizado e fácil de entender.

Pois bem HaWker, chegamos ao fim de mais um artigo.

Como sempre, se tiver qualquer dúvida ou quiser explorar mais algum ponto, é só responder com a sua dúvida, nesse email.

E lembre-se, estou aqui para te ajudar a melhorar 1% a cada novo artigo!

Se você chegou até aqui, como de costume, por favor, responda esse email com "Consegui entender as Classes na Programação".

Dessa forma eu vou saber que essa série de artigos está sendo útil pra você, e que você está acompanhando e aproveitando.

Como você já sabe! Somente um verdadeiro HaWker chega até o final.

Parabéns!

Estou feliz em te ter aqui.

Te vejo em breve.

Bora pra cima! 🦅

• Jeff Bruchado.

Quando sentir que é o momento existem 2 maneiras em que posso te ajudar:

01) Aprendendo JavaScript do Zero: Torne-se um programador de valor e aprenda a programar usando JavaScript, com um conteúdo organizado e condensado pensado no que realmente importa você aprender. O conteúdo possui todos os artigos que venho disponibilizando semanalmente pra você, e também possui exercícios práticos, com as respostas pra você aprender a teoria e já sair colocando a mão na massa.

02) Consultoria: Faça parte da minha mentoria e tenha aulas diretamente comigo. Se você se interessar por isso, responda esse email com "Tenho interesse na mentoria."

Parabéns por chegar até aqui, HaWker! 🎉

Nesse momento que você aprendeu sobre classes na programação, que tal testar seus conhecimentos? Participe do quiz abaixo e veja o quanto você absorveu do nosso artigo.

É uma ótima maneira de fixar o aprendizado e se preparar para os próximos passos na sua jornada de programação.

Aperte para acessar o quiz.

Boa sorte e divirta-se!