---
# System prepended metadata

title: Untitled

---

<p><img src="https://i.imgur.com/8nLaU2i.png" alt="" title="Entre no nosso site e veja nossos cursos"></p><h1 id="-Java-WebDeveloper---Sábado-Manhã---Aula-19" data-id="-Java-WebDeveloper---Sábado-Manhã---Aula-19"><a class="anchor hidden-xs" href="#-Java-WebDeveloper---Sábado-Manhã---Aula-19" title="-Java-WebDeveloper---Sábado-Manhã---Aula-19"><span class="octicon octicon-link"></span></a><img class="emoji" alt=":coffee:" src="https://cdn.jsdelivr.net/npm/@hackmd/emojify.js@2.1.0/dist/images/basic/coffee.png"><span> Java WebDeveloper - Sábado Manhã - Aula 01</span></h1><h2 id="-Tema-da-aula" data-id="-Tema-da-aula"><a class="anchor hidden-xs" href="#-Tema-da-aula" title="-Tema-da-aula"><span class="octicon octicon-link"></span></a><img class="emoji" alt=":book:" src="https://cdn.jsdelivr.net/npm/@hackmd/emojify.js@2.1.0/dist/images/basic/book.png"><span> Tema da aula:</span></h2><p><li><span>Criação de projeto [Java Project], criação de pacotes, criação de classe de dados, criação de objeto e exibição de dados de seus atributos, criação de classe em pacote "utils" para exibição de mensagem, e criação de objeto de classe de outro pacote.</li></span></p>
<blockquote style="border-left-color: red;">
<p><span class="color" data-color="red"></span><span> </span><small><i class="fa fa-user"></i> Prof Edson Belém - profedsonbelem@gmail.com <!-- <i class="fa fa-clock-o"></i> Sábado, Jul 25, 2020--></small></p>
</blockquote><blockquote style="border-left-color: purple;">
<p><span class="color" data-color="purple"></span><span> </span><small><i class="fa fa-user"></i> Profa Luciana Medeiros - lucianamedeiros.coti@gmail.com <!-- <i class="fa fa-clock-o"></i> Sábado, Jul 25, 2020 --></small></p></blockquote>

</p><hr><h2 id="-Estrutura-do-projeto-depois-de-finalizado" data-id="-Estrutura-do-projeto-depois-de-finalizado"><a class="anchor hidden-xs" href="#-Estrutura-do-projeto-depois-de-finalizado" title="-Estrutura-do-projeto-depois-de-finalizado"><span class="octicon octicon-link"></span></a><img class="emoji" alt=":eye:" src="https://cdn.jsdelivr.net/npm/@hackmd/emojify.js@2.1.0/dist/images/basic/eye.png"><span> Estrutura do projeto depois de finalizado:</span></h2>

![](https://i.imgur.com/lXCkmIY.jpg)

<hr>
<h3>Para criar um projeto local (Java Project)</h3>

Clicar no menu > File New -> Java Project
![](https://i.imgur.com/JhiSaoR.jpg)

Digitar o nome do projeto -> next
![](https://i.imgur.com/e5c9615.jpg)

Clicar em Finish.
![](https://i.imgur.com/DD8sHzD.jpg)

Abrir a estrutura do projeto clicando na seta.
![](https://i.imgur.com/brCGtDQ.jpg)

:point_right: Abaixo do nome do projeto, quando abrimos sua estrutura, vemos o diretório **src**. É em **src** que vamos criar os pacotes do nosso projeto.

<h3>
Para criar o pacote ou diretório.
</h3>

Clicar em “src” com o botão direito -> new -> package.
Depois basta darmos um nome para o pacote e clicar em **finish**.

<h3>
Para criar uma classe.
</h3>

Clicar no nome do pacote criado com o botão direito -> new -> class.
![](https://i.imgur.com/zOmQIQ3.jpg)
:point_right: A primeira letra do nome de uma classe deve ser maiúscula.

Digitar o nome da classe -> finish.
<hr>
<h3>
Importando um Projeto Local
</h3>

Abrir o Eclipse. Clicar em File -> Import.

Clicar em general -> Existing Projects into Workspace -> Next.

Clicar em Browse e apontar onde está o diretório do projeto.
![](https://i.imgur.com/bp7pf7j.jpg)

Clicar na pasta -> OK.
![](https://i.imgur.com/2RsLZih.jpg)
Depois, é só clicar em Finish.
<hr>
<h3>
Orientação a objetos
</h3>
A Orientação a Objetos é uma maneira alternativa de pensar os problemas de sistemas de informação utilizando modelos organizados a partir de conceitos do mundo real. O artefato base é o “objeto” capaz de combinar estrutura e comportamento em uma única “entidade”. Tudo o que podemos ver no mundo real é considerado um objeto com atributos e comportamentos definidos. Na qualidade de método de modelagem, é tida como a melhor estratégia para se eliminar a dificuldade recorrente no processo de modelar o mundo real do domínio do problema em um conjunto de componentes de software que seja o mais fiel na sua representação deste domínio. 

Programação Orientada a Objetos (também conhecida pela sua sigla POO) é um modelo de análise, projeto e programação de software baseado na composição e interação entre diversas unidades chamadas de ‘objetos’. A POO é um dos 4 principais paradigmas de programação (as outras são programação imperativa, funcional e lógica). Os objetos são operados com o conceito de ‘this’ (isso) ou ‘self’ (si), de forma que seus métodos (muitas vezes) modifiquem os dados da própria instância. Os programas são arquitetados através de objetos que interagem entre si. Dentre as várias abordagens da POO, as baseadas em classes são as mais comuns: objetos são instâncias de classes, o que em geral 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. A alternativa mais usual ao uso de classes é o uso de protótipos. Neste caso, objetos são cópias de outros objetos, não instâncias de classes. Javascript e Lua são exemplos de linguagens cuja POO é realizada por protótipos. A diferença prática mais evidente é que na POO baseada em protótipos apenas a herança simples é implementada pela cópia do objeto. Assim, na POO, implementa-se um conjunto de classes passíveis de serem instanciadas como objetos, e.g. Python e C++ (ou objetos protótipos que são copiados e alterados, e.g. JavaScript e VimL). 

Em alguns contextos, o termo modelagem orientada ao objeto (MOO) é preferível 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, dada a relevância para a abstração de conceitos do mundo real. A MOO é considerada a melhor estratégia para diminuir o “gap semântico” (o hiato entre o mundo real e a representação dele), e facilita a comunicação das partes interessadas no modelo ou software (e.g. o modelador e o usuário final) na medida em que conceitos, terminologia, símbolos, grafismo e estratégias, são, potencialmente, mais óbvios, intuitivos, naturais e exatos. 

Muitas das linguagens de programação mais utilizadas atualmente (talvez a maioria) são multi-paradigma com suporte à POO. C++, C#, VB.NET, Java, Object Pascal, Objective-C, Python, SuperCollider, Ruby e Smalltalk são exemplos de linguagens de programação orientadas a objetos. ActionScript, ColdFusion, Javascript, PHP (a partir da versão 4.0), Perl (a partir da versão 5), Visual Basic (a partir da versão 4), VimL (ou Vim script) são exemplos de linguagens de programação com suporte a orientação a objetos. Vivace é um exemplo de linguagem sem suporte à POO. 

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, é chamado de encapsulamento. O encapsulamento foi responsável pelo conceito de ‘ocultamento de dados’, central para a POO. O encapsulamento pode ser realizado através de convenções (em Python, underscores demarcam métodos e atributos protegidos e privados), ou via recursos da linguagem (em Java ou C++, um método privado só é acessado pela própria classe). Encapsulamento incentiva o desacoplamento. 

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 ‘tem um’, usualmente uma meronímia. Já a herança (quase sempre suportada pelas linguagens que utilizam classes) apresenta relações ‘é um’ (i.e. ‘é um tipo de’), ou seja, relações de hiperonímia cujo resultado final é a árvore taxonômica. Na herança, tipicamente todos os atributos e métodos da classe pai/mãe estão também disponíveis na classe filha, embora seja comum que algumas características sejam substituídas. Assim, a herança permite reúso facilitado de características e muitas vezes reflete relações do mundo real de forma intuitiva. Ambas a ‘composição de objetos’ e a ‘herança’ constituem hierarquias entre as classes e objetos na POO.

<h3>Linguagem Java</h3>

Java é a base de praticamente todos os tipos de aplicativos em rede, e é o padrão global para desenvolvimento e fornecimento de aplicativos para celular, jogos, conteúdo on-line e software corporativo. Com mais de 9 milhões de desenvolvedores em todo o mundo, o Java permite desenvolver e implantar aplicativos e serviços incríveis de maneira eficiente. Com ferramentas abrangentes, um ecossistema sólido e um desempenho eficiente, o Java oferece a portabilidade de aplicativos mesmo entre os ambientes computacionais mais diferentes. 

<h3>Modificadores de acesso do Java</h3>

Em Java, podemos criar atributos ou métodos com os seguintes
modificadores de acesso:
<li>public - Acesso total, qualquer classe tem acesso ao método (não indicado
para usar em atributos de entidade).</li>
<li>protected - Acesso permitido por herança e por classes do mesmo pacote.</li>
<li>default / friendly - Acesso permitido somente a classes do mesmo pacote,este acesso é definido quando não declaramos nenhum modificador.</li>
<li>private - Acesso permitido somente dentro da própria classe. (indicado para atributos de classes de entidade).</li>

<h3>Modelagem de dados em Java com UML</h3>

O Objetivo deste artigo é fornecer uma introdução à modelagem de Classes em Java utilizando diagramas UML. Neste exemplo iremos abordar o primeiro tipo de relacionamento aprendido em Orientação a Objetos: SER (É-UM) utilizado entre Classes e também entre Interfaces. Para tal iremos partir do principio, ou seja, o tipo mais “puro” de objeto Java, denominado JavaBean.
<h3>
Classe JavaBean
</h3>

Classe Java de Entidade (Modelagem)
Características:

<li>Atributos privados
<li>Construtor default (vazio)
<li>Sobrecarga de Construtor (Entrada de dados)
<li>Encapsulamento
<li>Sobrescrita dos métodos de Object
<li>toString
<li>equals
<li>hashCode
<li>Serialização (Opcional)

<h3>
O que é uma classe
</h3>

![](https://i.imgur.com/hvXUatZ.jpg)

Uma classe define estado e comportamento de um Objeto geralmente implementando métodos e atributos (nomes utilizados na maioria das linguagens modernas). Os atributos, também chamados de campos (do inglês fields), indicam as possíveis informações armazenadas por um objeto de uma classe, representando o estado de cada objeto. Os métodos são procedimentos que formam os comportamentos e serviços oferecidos por objetos de uma classe.

Uma classe é uma estrutura que abstrai um conjunto de objetos com características similares. Uma classe define o comportamento de seus objetos -	através de métodos - e os estados possíveis destes objetos - através de atributos. Em outras palavras, uma classe descreve os serviços oferecidos por seus objetos e quais informações eles podem armazenar. Classes não são diretamente suportadas em todas as linguagens, e são necessárias para que uma linguagem seja orientada a objetos. Uma classe representa um conjunto de objetos com características afins. Uma classe define o comportamento dos objetos através de seus métodos, e quais estados ele é capaz de manter através de seus atributos.

<h3>
Objeto
</h3>

É uma instância de uma Classe. Armazenamento de estados através de seus atributos e reação a mensagens enviadas por outros objetos.

Cliente c1 = new Cliente();

[Classe] [Objeto] [Construtor -> Instância]

Um objeto, na vida real, é qualquer coisa a qual pudermos dar um nome. Um objeto, em programação orientada a objetos, é uma instância (ou seja, um exemplar) de uma classe. A Wikilivros é um exemplo de Wiki, ou, a Wikilivros é uma instância de Wiki. Isto poderia ser representado em um programa orientado a objetos com uma classe chamada Wiki e um objeto do tipo Wiki chamado Wikilivros. Um objeto é capaz de armazenar estados através de seus atributos e reagir a mensagens enviadas a ele, assim como se relacionar e enviar mensagens a outros objetos. Atributos são características de um objeto. Basicamente a estrutura de dados que vai representar a classe. Exemplos: um objeto da classe “Funcionário” teria como atributos “nome”, “endereço”, “telefone”, “CPF”, etc. O conjunto de valores dos atributos de um determinado objeto é chamado de estado.

<h3>
Padrão MVC - Model, View e Controller
</h3>

![](https://i.imgur.com/AqC6Zbv.jpg)

Esse padrão tem a finalidade de dividir o projeto em três camadas: 

1- **Camada Modelo**: A camada Modelo tem as classes de dados que define o domínio da aplicação, por exemplo, classe aluno, professor, turma se sua aplicação for de controle de turma.

2-** Camada View**: A camada View corresponde a qualquer entrada de dados da aplicação, por exemplo, leitura de dados pelo console, paginas jsp, xhtml entre outras.

3- **Camada Control**: A camada control corresponde à regra de negocio da aplicação e centralizando as informações vindas da camada view, passando para camada de modelo e voltando para camada de view.

<h3>
Encapsulamento
</h3>

![](https://i.imgur.com/Br94yjx.jpg)

É um conceito da orientação a objetos que significa como pode ser feito a entrada e saída de dados de uma classe. Na Linguagem existem duas formas para isso. A primeira seria pelos métodos gets ( Saída de Dados ) e sets ( Entrada de Dados ) e a outra seria pelo construtor cheio ( Entrada de Dados ) e o toString ( Saída de Dados ). E os atributos da classe sendo private.

Em linguagens orientadas a objetos, é possível encapsular o estado de um objeto. Em termos práticos, isso se realiza limitando o acesso a atributos de uma classe exclusivamente através de seus métodos. Para isso, as linguagens orientadas a objeto oferecem limitadores de acesso para cada membro de uma classe.

<hr>
<h3><img class="emoji" alt=":coffee:" src="https://cdn.jsdelivr.net/npm/@hackmd/emojify.js@2.1.0/dist/images/basic/coffee.png"><span> Aluno.java</span></h3>

:point_right: **Lembrando:**

Criamos novo projeto abrindo o **Eclipse** e selecionando *File >> New >> Other*. Em seguida digitamos java project, e selecionamos essa opção abaixo da caixa de texto onde digitamos.
O Eclipse abre a tela **Create a Java Project** e nessa tela, devemos observar a versão do Java com que vamos trabalhar, ou seja, **JAVA 8**, como na imagem abaixo. Feito isso, damos nome ao nosso projeto e seguimos com sua codificação.

![](https://i.imgur.com/By2TR05.jpg)


Criamos os pacotes clicando com o botão direito em **src** e selecionando **New >> Package** e dando um nome ao pacote.

Criamos nova classe, clicando com o botão direito no pacote e selecionando **New >> Class** e dando um nome à classe.

**Public** e **private** são *modificadores de acesso* do Java. **Public** libera acesso a qualquer objeto de qualquer classe que tenha acesso à classe que contém o atributo ou método declarado como public; e **private** libera esse acesso apenas à classe que contém o atributo ou método declarado como private.

**Get** é um método que lê, ou recupera o valor de um atributo. Não recebe nenhum parâmetro e retorna o tipo do atributo que recupera.

**Set** é um método que atribui valor a um atributo. Recebe como parâmetro, um valor do tipo do atributo que vai instanciar e não retorna nada [**void**].</p>

Precisamos testar se os valores que recebemos para os atributos dos objetos que criamos são válidos. Para isso criamos métodos que começam com o nome **is**.

O método **isNome** avalia se o comprimento do nome que digitamos é maior ou igual a dois. O método **trim()** remove espaços digitados antes e depois do nome, e o método **length()** retorna o número de caracteres digitados, sem espaços antes e depois.

O método **main** serve para testarmos a nossa classe. Esse método é público, estático e não retorna valor nenhum [**void**]. Método estático é um método que, assim que mandamos rodar uma classe, ele recebe espaço de memória para ser executado. Mais tarde, veremos como chamar métodos estáticos de outras classes.

Quando criamos um objeto de uma outra classe, vamos precisar importar essa classe para a nossa classe. Para isso, no nosso caso, criamos o objeto **m** [*Mensagem m = new Mensagem();*] e, em seguida, digitamos **ctrl-shift-o** e a importação da classe Mensagem é feita pelo **Eclipse**.

``` java=
package entity;

import utils.Mensagem;

public class Aluno {

	private Integer idAluno;
	private String nomeAluno;
	private String email;
	private Double cr = 0.;
	private String situacao;

	public Integer getIdAluno() {
		return idAluno;
	}

	public void setIdAluno(Integer idAluno) {
		this.idAluno = idAluno;
	}

	public String getNomeAluno() {
		return nomeAluno;
	}

	public void setNomeAluno(String nomeAluno) {
		this.nomeAluno = nomeAluno;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public Double getCr() {
		return cr;
	}

	public void setCr(Double cr) {
		this.cr = cr;
	}

	public String getSituacao() {
		return situacao;
	}

	public void setSituacao(String situacao) {
		this.situacao = situacao;
	}

	public Boolean isNome() {
		if (this.nomeAluno.trim().length() < 2) {
			return false;
		} else {
			return true;
		}

	}

	public Boolean isIdAluno() {
		if (this.idAluno == null) {
			return false;
		} else {
			return true;
		}

	}

	public static void main(String[] args) {

		Aluno obj = new Aluno();

		obj.setIdAluno(1000);
		obj.setNomeAluno("LU");

		Mensagem m = new Mensagem();

		if (obj.isIdAluno() && obj.isNome()) {
			System.out.println(obj.getNomeAluno() + "," 
					+ obj.getIdAluno());
			System.out.println(m.enviarMensagem("Tudo Passa", 
					obj.getNomeAluno()));
		} else {
			System.out.println("Dados Invalidos ...");
		}
	}

}

```
<hr>

<h3><img class="emoji" alt=":coffee:" src="https://cdn.jsdelivr.net/npm/@hackmd/emojify.js@2.1.0/dist/images/basic/coffee.png"><span> Mensagem.java</span></h3>

:point_right: **Lembrando:**

Utilizamos o pacote **utils** como um repositório de classes cujos métodos serão chamados por objetos de outras classes - para cálculos, impressão de mensagens *etc*

``` java=
package utils;

public class Mensagem {

	public String enviarMensagem(String mensagem, 
			String nomeAluno) {
		return mensagem + ",[" + nomeAluno + "]";
	}

}

```
:point_right: **Lembrando:**

Para rodar o **main** da classe Aluno:
Clicar na classe com o botão direito -> run as -> Java application

<br>
<blockquote style="border-left-color: blue;">
<p><span class="color" data-color="red"></span><span> </span><small><i class="fa fa-user"></i> Prof Edson Belém - profedsonbelem@gmail.com <!-- <i class="fa fa-clock-o"></i>Sábado, Jul 25, 2020 --></small></p>
</blockquote><blockquote style="border-left-color: green;">
<p><span class="color" data-color="purple"></span><span> </span><small><i class="fa fa-user"></i> Profa Luciana Medeiros - lucianamedeiros.coti@gmail.com <!-- <i class="fa fa-clock-o"></i> Sábado, Jul 25, 2020 --></small></p></blockquote>