REPÚBLICA DE ANGOLA

MINISTÉRIO DA EDUCAÇÃO
GOVERNO PROVINCIAL DE LUANDA
INSTITUTO TÉCNICO MÉDIO LUIZA ANDALUZ (IMTLA)

TÉCNICAS DE LINGUAGEM DE PROGRAMAÇÃO (TLP)

TEMA:

PROGRAMAÇÃO ORIENTADA A OBJETO

(POO)

Docente

___________________________

Adilson Edgar Mulemo Matita

Luanda, aos 2024

 TEMA:

PROGRAMAÇÃO ORIENTADA A OBJETOS (POO)

GRUPO Nº 4

CURSO: INFORMÁTICA
TURNO: TARDE
TURMA: B
CLASSE: 11ª
SALA: 7

MEMBROS DO GRUPO:

Nº NOME NOTA

N 19 Josimar Antônio

N 20 Júlia Carlos

N 21 Manuel Da Silva

N 22 Marinela Manuel

N 23 Matilde Job

N 29 Regina Quitoco

Docente

___________________________

Adilson Edgar Mulemo Matita

Luanda aos 2024

 Sumário
Agradecimento....................................................................................................................................... 4
Introdução .............................................................................................................................................. 5
Fundamentação Teórica........................................................................................................................ 6
Caracteristicas da POO ........................................................................................................................ 8
Classe .................................................................................................................................................. 8
Objetos ............................................................................................................................................... 9
Atributos ............................................................................................................................................ 9
Métodos ............................................................................................................................................ 10
Mensagem ........................................................................................................................................ 10
Pilares da Programação Orientada a Objeto .................................................................................... 11
Abstração ......................................................................................................................................... 11
Encapsulamento .............................................................................................................................. 12
Poliformismo.................................................................................................................................... 13
Herança ............................................................................................................................................ 15
Linguagens da POO ............................................................................................................................ 19
Vantagens da POO .............................................................................................................................. 21
Desvantagens da LPOO ...................................................................................................................... 22
Conclusão ............................................................................................................................................. 23
Referência Bibliográfica ..................................................................................................................... 24
 Agradecimento

Expresamos a nossa gratidão a Deus por ter nos dado a chance de chegar até aqui e
concluir este trabalho. Agradecer a equipe de trabalhho, aos nossos colegas e professores que
tem nos apoiado e que nos incentivam durante este processo de produção do nosso aprendisa-
do.

4
 Introdução

Programação Orientada a Objetos é um paradigma de programação baseado no

conceito de “objetos”, que podem conter dados na forma de campos, também
conhecidos como atributos, e códigos, na forma de procedimentos, também
conhecidos como métodos.

Ela se destaca pela organização e reutilização do código, baseando-se na

representação de elementos do mundo real.

A Orientação Objetos surgiu na Noruega, em 1962.

Naquele ano, dois pesquisadores do Centro Norueguês de Computação,

Kristen Nygaard e Ole-Johan Dahl, iniciaram um projeto que almejava criar uma
linguagem de Simulação de Eventos Discretos.

A propósito, Simulação de Eventos Discretos ou Discrete Events Simulation é

um dos modelos matemáticos usados para descrever como o computador compreende
a lógica dos eventos diários.

Em meados da década de 70, Alan Kay, pesquisador da Xerox Parc,

Califórnia, aventurou-se em um projeto. Seu objetivo era desenvolver uma linguagem
para computadores pessoais.

Com isso, a linguagem SmallTalk-71 e posteriormente, a SmallTalk-80 foram

desenvolvidas e são responsáveis pela propagação de Orientação a Objetos até os
nossos dias atuais.

Consequentemente, as linguagens SmallTalk-71 e SmallTalk-80 contribuíram

para o uso de uma interface básica amigável, o ambiente de aprendizagem integrado
(IDE) e a capacidade de ser executada em máquinas de pequeno porte.

A programação de orientação a objetos visa um pensamento mais próximo

possível da vida real. Ao programar na linguagem orientada a objetos não teremos
apenas funções que são chamadas uma seguida da outra, mas sim objetos que possuem
estado e comportamento.

5
 Fundamentação Teórica

Alan Curtis Kay é um informático estadunidense. É conhecido por ter sido um

dos inventores da linguagem de programação Smalltalk, e um dos pais do conceito de
programação orientada a objetos, que lhe valeu o Prêmio Turing em 2003. Concebeu o laptop
e a arquitetura das modernas interfaces gráficas dos computadores.

Alan Kay pensou em como contruir um sistema de software a partir de agentes autô-
nomos que interagissem entre si, estabelecendo principios de que, para a orientação objectos
qualquer coisa é um ojecto, um objeto realizaria tarefas através de requisições de serviços,
cada objecto pertence a uma determinada classe, uma classe agrupa objectos similares, uma
classe possui comportamentos associados ao objecto e as classes são organizada em hierar-
quia.

A Programação Orientada a Objeto (também conhecida pela sua sigla POO) ou

Modelagem Orientada ao Objeto, é um modelo/paradigma de projeto e programação de
software baseado na abstração digital do mundo real, através da composição e interação entre
diversas unidades chamadas de 'objetos' e ‘classes’ (representando objetos reais contendo
identidade, propriedades e métodos). Baseado-se então, em quatro principais componentes da
programação: Abstração, Encapsulamento, Herança e Polimorfismo.

Em alguns contextos, o termo modelagem orientada ao objeto (MOO) é preferível em

relação ao termo POO. De fato, o paradigma "orientado ao objeto" tem origem nos estudos da
cognição e influenciou a inteligência artificial e a linguística.

Dentre as várias abordagens da POO, as baseadas em classes são as mais comuns:

usando um objeto que pode ser manipulado, criado a partir de uma classe através do
instanciamento. Estes possuem métodos que modificam seus próprios dados, definindo o tipo
do objeto. A classe determina o comportamento (métodos), estados possíveis (atributos) e, o
relacionamento com os outros objetos. A maior alternativa das classes é o uso de protótipos,
onde objetos são cópias de outros, onde apenas a herança simples é implementada pela cópia.

Os atributos e métodos podem ser referentes a uma classe (e todas as suas instâncias)
ou a uma única instância. O vínculo dos atributos aos métodos, é de forma a manter uma
interface bem definida para operação sobre os dados, e a evitar corrupção dos dados, isto é
chamado de encapsulamento. O encapsulamento é responsável pelo conceito de ocultamento
de dados central para a POO.
6
 Quando um objeto contém outros objetos, diz-se que há composição de
objetos. A composição de objetos é usada para representar uma relação entre classes.

A programação orientada a objetos surge para possibilitar ao desenvolvedor a

ter:

✓ Velocidade na prototipagem de sistemas

A prototipagem rápida é um processo que visa aumentar a velocidade e a

flexibilidade, assim como, reduzir os custos de desenvolvimento de protótipos.
Consequentemente, ela também pode acelerar o lançamento do produto no mercado e
reduzir os custos de armazenamento;

✓ Ambiente de desenvolvimento perfeito

Um ambiente de desenvolvimento é um espaço de trabalho que permite aos

desenvolvedores criar um aplicativo ou fazer alterações nele sem afetar a versão ativa
do produto de software. Essas alterações podem incluir manutenção, depuração, etc;

✓ Reutilização de códigos

A reutilização de código, também chamada de reutilização de software, é o uso

de software existente, para a construção de um novo software;

✓ Modularidade no desenvolvimento

A modularidade no desenvolvimento é uma estratégia para a construção de

produtos mais complexos a partir de subsistemas, sendo estes desenvolvidos
individualmente, mas com o funcionamento integrado permitindo assim a produção de
diferentes produtos através de combinação de subsistemas.

✓ Abstração do mundo real

Isto é anslizar coisas que já existem, pegar algo real e transformar em uma
ideia para uso vivtual.

7
 Caracteristicas da POO

Classe

Uma classe define as características de uma coleção de objetos. Consistem em

descrições de métodos e atributos que objetos que pertencem à classe irão possuir.
Uma classe é similar a um tipo abstrato de dados no sentido que ela define toda uma estrutura
(características e comportamentos) para que todos os seus objetos possam tê-los.

Figura 1- Representação de uma classe com uma coleção de objetos.

Classes Abstratas
É um tipo de classe especial que não pode ser instanciada, apenas herdada. Sendo
assim, uma classe abstrata não pode ter um objeto criado a partir de sua instanciação. Essas
classes são muito importantes quando não queremos criar um objeto a partir de uma classe
“geral”, apenas de suas “subclasses”.
Imagine que possuímos três classes (Conta, Conta Corrente e Conta Poupança), sendo
a classe Conta uma classe “geral” (comumente chamada de classe “pai”). Ao ir em um banco,
nós não criamos uma nova Conta, mas sim uma Conta Corrente ou uma Conta Poupança.
Sendo assim, não faz sentido que a classe Conta possa ser instanciada, já que é um
erro na regra de negócio caso isso ocorra. É aí que entra o termo “abstrato” desse tipo de
classe, por não haver a necessidade de criar objetos com base em uma classe “pai”, não há
porquê ela permitir a instanciação de novos objetos.
Agora, ao invés de criarmos um objeto do tipo Conta, só será permitido a criação de
objetos do tipo Conta Corrente ou Conta Poupança, o que faz mais sentido.

8
 Por não permitir a instanciação de novos objetos com base em uma classe
abstrata, este tipo de classe é utilizada para implementar o conceito de Herança da OO.
Ou seja, as classes abstratas irão armazenar atributos e métodos comuns às classes que
a irão herdar, permitindo um maior reaproveitamento de código.

Objetos
Um objeto é algo que pode ser manipulado, é criado a partir de uma classe
através do processo de programação chamado instanciamento (instanciar um
objeto), onde os objetos são operados com o conceito de 'this' (isto) ou 'self' (si), de
forma que seus métodos muitas vezes modifiquem os dados da própria instância, que
também define o tipo do objeto. Cada classe determina o comportamento (definido
nos métodos) e estados possíveis (atributos) de seus objetos, assim como o
relacionamento com outros objetos.

Atributos

Os Atributos em Programação Orientada a Objetos são os elementos que

definem a estrutura de uma classe. Os atributos também são conhecidos como
variáveis de classe, e podem ser divididos em dois tipos básicos: atributos de instância
e de classe.

Atributo de classe: Um atributo de classe possui um estado que é

compartilhado por todos os objetos de uma classe. Atributos de classe podem ser
chamados também de atributos estáticos ou dinâmicos. Constantes são
considerados atributos de classe quando estão fora de qualquer método.

Atributo de instância: Atributos de Instância são aqueles que definem o

estado do objeto. O Próprio nome já diz, pois se chama atributo de instância ou objeto,
ou seja, são atributos particulares a cada objeto.

9
 Métodos

Métodos são uma parte fundamental da programação orientada a objetos. É por

meio deles que alteramos e consultamos atributos dos nossos objetos.

Assim, os métodos são as ações que o objeto pode realizar. Tudo o que o objeto faz é
através de seus métodos, pois é através dos seus métodos que um objeto se manifesta, através
deles que o objeto interage com os outros objetos.

Figure 1- Representação de atributos e métodos dentro da classe principal (pessoa).

Os métodos mais utilizados, que inclusive geraram em diversas IDEs soluções prontas
para a criação deles são os métodos conhecidos como "Getters and Setters", basicamente são
os métodos utilizados para se obter a informação sobre algum atributo do objeto (getters) e
definir o valor de algum atributo do objeto (setters).

Mensagem

Os objetos se comunicam a partir da troca de mensagens.

Uma mensagem é um sinal enviado de um objeto a outro, o qual requisita um serviço,

usando uma operação programada no objeto chamado. Por exemplo, para que um objeto
execute um método, é necessário enviar a este objeto uma mensagem solicitando a execução
do método desejado.

As mensagens somente ocorrem entre objetos que possuem uma Associação.

As mensagens também são programadas. Quando uma mensagem é recebida, uma

operação é invocada no objeto chamado.

10
 Pilares da Programação Orientada a Objeto

Um pilar é um elemento estrutural vertical usado normalmente para receber os

esforços diagonais de uma edificação e transferi-los para outros elementos, da mesma
forma a poo tem elementos que agem como pilares suportando as ações do sistema

Os principais pilares da programação orientada a objetos são:

Figure 3- Os quatro pilares que sustentam essa abordagem.

Abstração

Consiste em um dos pontos mais importantes dentro de qualquer linguagem

Orientada a Objetos. Como estamos lidando com uma representação de um objeto real
(o que dá nome ao paradigma), temos que imaginar o que esse objeto irá realizar
dentro de nosso sistema. São três pontos que devem ser levados em consideração
nessa abstração que são:

- O primeiro ponto é darmos uma identidade ao objeto que iremos criar;

- O segundo ponto diz respeito a características do objeto;

- O terceiro ponto é definirmos as ações que o objeto irá executar.

11
 Encapsulamento

Isto significa separar o programa em partes, o mais isoladas possível. A idéia é

tornar o software mais flexível, fácil de modificar e de criar novas implementações.

Figura 4- Os dados ficam armazenados de uma forma semelhante a uma capsula ou até mes-
mo uma pilha.

A técnica facilita a realização de testes unitários, pois permite testar o comportamento

dos objetos isoladamente, sem depender de outros objetos ou de partes do sistema. Sem contar
que pode ser usada para proteger dados e métodos de uma classe de acesso indevido,
impedindo a violação de informações confidenciais

O encapsulamento funciona com a utilização de modificadores de acesso para

restringir o acesso aos atributos e aos métodos de um objeto. Garante que somente as classes
apropriadas possam acessar as informações e ajuda a assegurar que os atributos e os métodos
sejam usados de forma consistente e previsível.

Os modificadores de acesso mais comuns são:

 private - Os atributos e os métodos marcados como “private” só podem ser

acessados dentro da própria classe em que foram declarados;
 protected - Os atributos e os métodos marcados como “protected” podem ser
acessados dentro da própria classe e das subclasses;
 public - Os atributos e os métodos marcados como “public” podem ser
acessados por qualquer classe.
Para acessar os atributos e os métodos encapsulados, é preciso usar métodos públicos
chamados getters e setters, que permitem acessar e modificar os atributos encapsulados de
forma controlada.
12
 Poliformismo

Polimorfismo é a habilidade de objetos de classes diferentes responderem a

mesma mensagem de diferentes maneiras. Ou seja, várias formas de responder à
mesma mensagem

Figura 5- Com o Polimorfismo, os mesmos atributos e objetos podem ser utili-

zados em objetos distintos, porém, com implementações lógicas diferentes.

O polimorfismo é caracterizado quando duas ou mais classes distintas

têm métodos de mesmo nome, de forma que uma função possa utilizar um objeto de
qualquer uma das classes polimórficas, sem necessidade de tratar de forma
diferenciada conforme a classe do objeto.

Uma das formas de implementar o polimorfismo é através de

uma classe abstrata, cujos métodos são declarados mas não são definidos, e através de
classes que herdam os métodos desta classe abstrata.

Esta é uma classe abstrata que representa qualquer operação matemática.

Podemos imaginar diversas operações que se encaixam na sua interface, como soma,
subtração, multiplicação ou divisão, entre outras. Note que, mesmo que a natureza do
cálculo mude, a semântica do método calcular não muda, ou seja, ele sempre calculará
o resultado da operação matemática que está sendo trabalhada. Definamos então, duas
subclasses, Soma e Subtracao, que extendem a classe OperaçãoMatematica:

13
Suponha o seguinte exemplo escrito em java:

public abstract class OperacaoMatematica {

public abstract double calcular(double x, double y);

public class Soma extends OperacaoMatematica {

public double calcular(double x, double y) {

return x + y;

}}

public class Subtracao extends OperacaoMatematica {

public double calcular(double x, double y) {return x - y;}}

14
 Herança

A herança, tal como na vida real, é o processo pelo qual os objetos ganham algumas
das características dos seus pais. Embora, uma classe deva sempre introduzir
comportamento e características próprias, mas através do mecanismo de herança é
possível criar relações entre diferentes classes e reutilizar código. É um mecanismo
muito importante em linguagens POO.

Figure 6- A “SubClasse” herda todas as propriedades e métodos da “Super-

Classe”. Neste caso é utilizado “ : ” (dois pontos) para implementar a herança de
classes.
Logo abaixo temos aí um exemplo de herança que também engloba o polimorfismo:

SuperClasse
public class Veiculo {
private string tipo;
public string Tipo {
get { return tipo; }
set { tipo = value; }
}
public Veiculo (string tipoVeiculo)
{
}
this.tipo = tipoVeiculo;
public virtual void Mover() { }
public virtual void Parar() {} 15
}
 SubClasse SubClasse
public class Aeronave : Veiculo { using System;
public Aeronave (string tipoVeiculo) namespace Teste
: base(tipoVeiculo) {
{} public class Automovel : Veiculo
public override void Mover() {
{ public Automovel (string
tipoVeiculo)
Console.WriteLine("Decolando a aeronave");
: base(tipoVeiculo)
}
{}
public override void Parar()
public override void Mover()
{
{
Console.WriteLine("Estou aterrisando a aeronave.");
Console.WriteLine("Acelerando o
} veículo");
} }
public override void Parar()
{
Console.WriteLine("Estou
brecando o veículo.");
}
}
}

16
 Instanciação de objetos
Instanciação é o processo de leitura ou de especificação de informações, como tipo de
armazenamento e valores para um campo de dados.

Exemplo de um processo de instanciação:

// Classe

class Animal

// Atributo

protected string especie;

// Construtor

public Animal(string especie)

this.especie = especie;

// Execução

static void Main(string[] args)

// Instâncias

Animal cachorro = new Animal("Canis lupus familiaris");

Animal gato = new Animal("Felis catus");

Animal lobo = new Animal("Canis lupus");

17
 Na instanciação de objeto encontramos palavras chaves ou identificadores que servem
para definir e modificar atributos e metods das subclasses, são eles :

➢ new: Cria instâncias de objetos e outras estruturas.

➢ virtual: Usado para definir métodos ou propriedades que podem ser
sobrescritos em subclasses.
➢ override: Permite a modificação de métodos ou propriedades definidos
como virtual na superclasse.

Em linguagem de Programação Orientadas a Objeto quando uma

novainstânciadoobjetofor criada é chamado o método Construtor, este método geralmente é
responsável pela alocação de recursos necessários ao funcionamento do objeto além da
definição inicial das variáveis de estado (atributos).

18
 Linguagens da POO

A linguagem de programação é um método padronizado, formado por um conjunto de

regras sintáticas e semânticas, de implementação de um código fonte - que pode ser
compilado e transformado em um programa de computador, ou usado como script
interpretado - que informará instruções de processamento ao computador

Como você viu até aqui, a POO é um paradigma de programação. Esse

modelo, portanto, surgiu na década de 70, e se tornou o mais popular entre as pessoas
desenvolvedoras. Nesse sentido, a POO suporta muitas linguagens de programação,
entre elas:

C++;
C#;
Java;
Object;
pascal;
VB.NET;
Objective-C;
Python;
Figure 8- Linguagens de programação orien-
tadas a objeto.
C++: É uma linguagem de programação open source orientada a objetos,
utilizada tanto como linguagem de máquina quanto para softwares empresariais,
acadêmicos, jogos, edição de imagens, fotos e vídeos.

C#: É uma linguagem de programação, multiparadigma, de tipagem forte,

desenvolvida pela Microsoft como parte da plataforma .NET. A sua sintaxe orientada a
objetos foi baseada no C++ mas inclui muitas influências de outras linguagens de
programação, como Object Pascal e, principalmente, Java.

Java: É uma linguagem de programação orientada a objetos desenvolvida na

década de 90 por uma equipe de programadores chefiada por James Gosling, na
empresa Sun Microsystems, que em 2008 foi adquirido pela empresa Oracle
Corporation.
19
 Object pascal: É uma ramificação de linguagens derivativas de Pascal, com suporte a
orientação a objetos. As principais ferramentas para programar em Object Pascal são o IDE
Embarcadero Delphi e o Lazarus. Foi usada nas sete primeiras versões do ambiente Delphi.

VB.NET: Uma linguagem de programação totalmente orientada a objetos e com

suporte total a UML, criada pela Microsoft e distribuída com o Visual Studio .NET.

Objective-C: É uma linguagem de programação reflexiva orientada a objecto que

adiciona transmissão de mensagens no estilo Smalltalk para o C. Também é definida como um
conjunto de adições à linguagem C, Ela dá ao C suporte à construções orientadas a objetos
como as da Smalltalk.

Python: É uma linguagem de programação interpretada de alto nível e que suporta

múltiplos paradigmas de programação: imperativo, orientado a objetos e funcional. É uma
linguagem com tipagem dinâmica e gerenciamento automático de memória.

20
 Vantagens da POO

O paradigma de orientação a objetos traz consigo vantagens inerente a toda

linguagem que faz seu uso. Devido à busca pela representação do mundo real na programação
de computadores por meio de objetos e classes, esses benefícios sempre são alcançados.

A seguir, são apresentadas as características de um software desenvolvido com

POO. Parte-se da definição aplicável a um sistema e sua respectiva explanação.

1. Confiável

A geração de código baseado no conceito de objetos e classes fornece uma

grande independência ao programa. Assim, qualquer intervenção que seja necessária
não afetará outros pontos do sistema. Isso confere robustez e confiabilidade.

2. Oportuno

A criação paralela de código torna todo o processo bastante ágil. Ganha-se em

tempo e eficiência, tornando um software com paradigma POO oportuno. Várias
equipes podem trabalhar no mesmo projeto de forma independente.

3. Ajustável

Essa característica diz respeito ao processo de manutenção do código-fonte. Ao

atualizar uma parte pequena, o conceito de herança garante que, automaticamente,
todas as partes que utilizarem tal método sejam beneficiadas.

4. Extensível

O uso do princípio da reutilização do software adiciona funcionalidades ao

sistema já existente. Não é preciso “reinventar a roda”, reescrevendo o código. Isso
confere maior capacidade de estender um sistema já existente.

5. Reutilizável

Um mesmo objeto pode ser utilizado em aplicações diferentes, desde que

sejam compatíveis. Se tivéssemos um objeto “aluno”, por exemplo, ele poderia ser
utilizado em sistemas de empresas diferentes, desde que elas contassem com alunas e
alunos na sua estrutura.
Assim, tanto uma escola de música como uma academia poderiam fazer uso do
objeto “aluno” em um possível software para uso próprio, pois ambas as empresas têm
essas pessoas como seu público.
21
 Desvantagens da LPOO

1. A duração dos programas desenvolvidos usando a linguagem OOP é muito maior

do que a abordagem procedural. Como o programa fica maior em tamanho, ele requer mais
tempo para ser executado, o que leva a uma execução mais lenta do programa;
2. Não podemos aplicar OOP em todos os lugares, pois não é uma linguagem universal.
É aplicado apenas quando necessário. Não é adequado para todos os tipos de problemas;
3. Os programadores precisam ter habilidades brilhantes de design e programação,
juntamente com o planejamento adequado, porque usar OOP é um pouco complicado;
4. Tudo é tratado como objeto em POO, portanto, antes de aplicá-lo, precisamos ter um
excelente raciocínio em termos de objetos;
5. Complexidade no aprendizado para desenvolvedores de linguagens estruturadas;
6. A Maior uso de memória (heap), por exemplo para aplicações móveis em Java;
7. Maior esforço na modelagem de um sistema POO do que estruturado;
8. Funcionalidades limitadas por interface, quando estas estão incompletas (problemas na
modelagem);
9. A Dependência de funcionalidades já implementadas em superclasses no caso da
herança, implementações espalhadas em classes diferentes.

22
 Conclusão

Mediante o exposto podemos concluir que a linguagem de Programação Orientada a

Objetos tem o objetivo de prover mecanismos para visualizar a complexidade do
desenvolvimento de software da mesma forma que visualizamos a complexidade do mundo
real. Isso permite acelerar o desenvolvimento de softwares com base na modularidade
e acoplamento e melhorar a qualidade do software desenvolvido.

A POO está em nosso dia-a-dia facilitando as nossas vidas. Muitas das vezes
estamos desfrutando dos seus benefícios sem mesmo perceber, por exemplo: quando
falamos ao celular, utilizamos o PC e, até mesmo quando estamos fazendo uma
simples compra no supermercado, não temos essa percepção mas, a maioria dos
programas instalados nesses equipamentos foi desenvolvido em linguagem de POO.

A linguagem de POO possui ainda inúmeras ferramentas e aplicativos

facilitadores que interagem ajudando os desenvolvedores e, apresenta aos iniciantes
um leque de opções, dando há oportunidade de se identificarem com a linguagem de
POO ou de continuar a procura de uma nova ferramenta de estudo ou de trabalho.

23
 Referência Bibliográfica

Classes Abstratas vs Interfaces. Disponível em:

<https://www.treinaweb.com.br/blog/classes-abstratas-vs-interfaces>. Acesso em: 24 jan.
2024.
Conceitos e Exemplos – Instanciação: Estrutura da Linguagem. Disponível em:
<https://www.devmedia.com.br/conceitos-e-exemplos-instanciacao-estrutura-da-
linguagem/18817>. Acesso em: 24 jan. 2024.
Instância (ciência da computação). , 9 fev. 2023. (Nota técnica).
O que são métodos na programação orientada a objetos? Com exemplos em Java
e Python. Disponível em: <https://www.academicotech.com/post/o-que-sao-metodos-na-
programacao-orientada-a-objetos-com-exemplos-em-java-e-python>. Acesso em: 24 jan.
2024.
Operações e Atributos de uma Classe. Disponível em:
<https://homepages.dcc.ufmg.br/~amendes/GlossarioUML/glossario/conteudo/classe/ope
racoes_e_atributos.htm>. Acesso em: 24 jan. 2024.
POO: Os 4 pilares da Programação Orientada a Objetos. Disponível em:
<https://www.devmedia.com.br/os-4-pilares-da-programacao-orientada-a-objetos/9264>.
Acesso em: 24 jan. 2024.
Vantagens e desvantagens de OOP – Acervo Lima. Disponível em:
<https://acervolima.com/vantagens-e-desvantagens-de-oop/>. Acesso em: 24 jan. 2024.

24