Índice

1 Introdução ........................................................................................................................... 1

2 Objectivos ........................................................................................................................... 2

2.1 Objectivo Geral ........................................................................................................... 2

2.2 Objectivo Especifico ................................................................................................... 2

3 Explicar os conceitos e dar exemplos de classes, objectos, campos e métodos em Java ... 3

3.1.1 Classe ................................................................................................................... 3

3.1.2 Objectos ............................................................................................................... 3

3.1.3 Campos ................................................................................................................ 3

3.1.4 Método ................................................................................................................. 4

4 Definir classes com campos, métodos e construtores em Java........................................... 4

4.1.1 Campos (Atributos) .............................................................................................. 4

4.1.2 Métodos (Comportamentos) ................................................................................ 5

4.1.3 Construtores ......................................................................................................... 6

5 Criar e manipular objectos de classes em Java ................................................................... 7

6 Definir e utilizar tipos enumerados em Java ...................................................................... 8

7 Explicar os princípios de abstracção e encapsulamento em Java ....................................... 9

7.1.1 Princípio de Abstracção ....................................................................................... 9

7.1.2 Princípio de Encapsulamento ............................................................................. 10

8 Bibliografia ....................................................................................................................... 11

9 Código de manipular contas bancárias em Java ............................................................... 12

10 Conclusão...................................................................................................................... 13
1 Introdução
O presente trabalho de pesquisa aborda sobre os conceitos fundamentais de programação com
classes em Java.
Classe, objecto, campo e método são conceitos fundamentais na programação orientada a
objectos (POO).
Fara-se a pesquisa dos conceitos e exemplos lustrados através de imagens e códigos escritos.
Explicar os conceitos e dar exemplos de classes, objectos, campos e métodos.
Definir classes com campos, métodos e construtores.
Criar e manipular objectos de classes
Definir e utilizar tipos enumerados

1
2 Objectivos
2.1 Objectivo Geral
 Aplicar os conceitos fundamentais de programação com classes
2.2 Objectivo Especifico
 Explicar os conceitos e dar exemplos de classes, objectos, campos e métodos;
 Definir classes com campos, métodos e construtores;
 Criar e manipular objectos de classes;
 Definir e utilizar tipos enumerados;
 Explicar os princípios de abstracção e encapsulamento.

2
3 Explicar os conceitos e dar exemplos de classes, objectos, campos e métodos em
Java
3.1.1 Classe
Classe é uma definição abstracta que especifica os campos e métodos que os objectos terão.
Ela define um conjunto de propriedades (campos) e comportamentos (métodos) dos objectos
dessa classe.

Exemplo de uma classe:

Uma classe chamada "Cachorro". Pode ter os campos "nome", "idade" e "raça". A classe
Cachorro é a definição geral de um cachorro, mas não representa um cachorro específico.

3.1.2 Objectos
Objectos são instâncias concretas de uma classe, com seus próprios valores para os campos.
Os objectos possuem estado (valores de seus campos) e comportamento (acções executadas
por seus métodos).

Exemplo de um objecto:
Classe "Cachorro" Tem valores específicos para os campos "nome", "idade" e "raça", como
"Rex", 3 e "Labrador", respectivamente. "meuCachorro" é um objecto específico com base na
classe "Cachorro".

3.1.3 Campos
Campos são variáveis que armazenam dados, e os métodos são as acções que os objectos
podem realizar.
Os campos armazenam dados que pertencem a um objecto específico ou à classe como um
todo.

Exemplo de campos:
Na classe "Cachorro", os campos "nome", "idade" e "raça" seriam considerados campos.
Cada objecto da classe "Cachorro" teria seus próprios valores para esses campos.

3
3.1.4 Método
Método é um bloco de código que define o comportamento de uma classe ou de um objecto.
O método representa as acções que os objectos dessa classe podem realizar.
Os métodos podem receber parâmetros, executar tarefas e retornar valores.
Exemplo de um método:
Na classe "Cachorro", temos um método chamado "latir()". Esse método representaria o
comportamento de um cachorro ao latir. Quando chamado em um objecto da classe
"Cachorro", ele executara a acção de latir.

4 Definir classes com campos, métodos e construtores em Java

4.1.1 Campos (Atributos)
Os campos são variáveis que representam o estado de um objecto. Os atributos armazenam os
dados associados a um objecto específico. Os campos definem as características e
propriedades dos objectos pertencentes à classe.
Exemplo de declaração de campos em uma classe:

4
4.1.2 Métodos (Comportamentos)
Os métodos são blocos de código que definem as acções que os objectos podem realizar. Os
métodos representam o comportamento de uma classe e permite que realize operações e
manipule os campos da classe.
Exemplo de declaração de métodos em uma classe:

5
4.1.3 Construtores
Os construtores são métodos especiais usados para criar e inicializar objectos da classe. Os
construtores são chamados no momento da criação de um objecto e podem receber
argumentos para fornecer valores iniciais aos campos do objecto.
Exemplo de declaração de construtores em uma classe:

6
5 Criar e manipular objectos de classes em Java
A classe é uma estrutura que encapsula os campos (atributos) e os métodos (comportamentos)
que os objectos terão.
Exemplo de uma classe pessoa:

Criar um objecto
Para criar um objecto, usa-se a palavra-chave new seguida pelo nome da classe e, se
necessário, argumento para o construtor da classe.

7
6 Definir e utilizar tipos enumerados em Java
A sintaxe para definir um tipo enumerado pode variar ligeiramente dependendo da
linguagem. Cada valor constante é separado por vírgula e não precisa ser explicitamente
atribuído.
Tipos enumerados (enums), são uma forma de representar um conjunto fixo de valores em
uma linguagem de programação. Os tipos enumerados são úteis quando se precisa definir um
conjunto específico de constantes relacionadas.
Exemplo de um tipo enumerado:

8
7 Explicar os princípios de abstracção e encapsulamento em Java
7.1.1 Princípio de Abstracção
Princípio de abstracção permite representar conceitos complexos de forma simplificada,
enquanto o princípio de encapsulamento protege e controla o acesso aos detalhes internos de
uma classe.
A abstracção envolve a criação de classes e objectos que representam entidades do mundo
real. Essas classes abstractas fornecem uma base comum para as classes derivadas,
permitindo que defina métodos abstractos que as subclasses devem implementar.

Exemplo de uma Abstracção:

9
7.1.2 Princípio de Encapsulamento
O encapsulamento é o princípio de esconder os detalhes internos de uma classe e fornecer
uma interface controlada para interagir com ela. O encapsulamento envolve agrupar os
campos (atributos) e métodos (comportamentos) relacionados em uma unidade coesa, a
classe, e controlar o acesso a esses membros por meio de modificadores de acesso.
Ao aplicar o encapsulamento, define os membros de uma classe como públicos, privados ou
protegidos. O encapsulamento incentiva o acesso aos membros de uma classe apenas por
meio de métodos (getters e setters), em vez de a cessá-los directamente. Isso garante que o
estado interno da classe seja manipulado de forma controlada.
O encapsulamento oferece benefícios de segurança e modularidade. Impede que os dados
sejam alterados de forma inesperada e ajuda a manter a consistência interna da classe.
Permite alterar a implementação interna de uma classe sem afectar o código que a utiliza,
desde que a interface pública permaneça a mesma.

Exemplo de um encapsulamento:

10
8 Bibliografia
[Online] // dca.fee.unicamp.br. - Ivan.L.M.Ricart, 07 de Outubro de 2002. - 08 de Junho de
2023. - https://www.dca.fee.unicamp.br/cursos/PooJava/metodos/construtor.Java.

curso.br [Online] / autor Luiz Armando. - 21 de outubro de 2013. - 09 de Junho de 2023. -

https://www.inf.ufpr.br/cursos/ci067/Docs/NotasAula/notas-22_Tipo_Enumerado.Java.

Devmedia.com.br [Online] / autor pro Seja // Devmedia. - Jakart Edson, 13 de Março de

2020. - 08 de Junho de 2023.

11
9 Código de manipular contas bancárias em Java
Interface de código sendo gerado para criar e manipular conta bancaria

Código em execução da conta Bancaria

12
10 Conclusão
No presente trabalho de pesquisa aborda sobre que os conceitos fundamentais de
programação com classes em Java.
Percebi que ma classe é uma estrutura abstracta que encapsula o estado e o comportamento
dos objectos. Objecto é uma instância de uma classe que possuem estado (valores de seus
campos) e comportamento (acções executadas por seus métodos).
Os campos são variáveis que armazenam dados, e os métodos são as acções que os objectos
podem realizar.
O princípio de abstracção permite representar conceitos complexos de forma simplificada,
enquanto o princípio de encapsulamento protege e controla o acesso aos detalhes internos de
uma classe. Ambos os princípios são fundamentais na programação orientada a objectos para
criar código modular, flexível e de fácil manutenção.
Os princípios de abstracção e encapsulamento são fundamentais na programação orientada a
objectos (POO) e ajudam a promover a modularidade, a reutilização de código e a criação de
um código mais limpo e organizado.

13