JAVA - Compilação 6 primeiras Aulas Gravadas, AulasWeb e outras informações

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

JAVA
	7	JAVA	A01 - W: 28/02/2018 - 02:34	W	Web Aula
	Tópico	P	A02 - W: 31/12/2017 - 11:08	W	Web Aula	Dom	Seg	Ter	Qua	Qui	Sex	Sáb	Web Aula
	Introdução ao Java	01	A03 - W: 28/02/2018 - 02:34	W	Web Aula	Web Aula + Aula gravada
	As convenções do Java 	02	A04 - W: 19/05/2018 - 18:44	W	Web Aula	Aula gravada
	Net Beans IDE - Intr às interfaces gráficas	03	
	Princípios da Orientação a Objetos	04	A06	
	HERANÇA	05	A07	
	Encapsulamento e Associações de Classes	06	A08	
	07	A09	
	08	A10	
	09	Aulas do Professor Gustavo Guanabara
	10
	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	Aula + Aula gravada	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	- 06/08/12: Aula 1	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	- 13/08/12: Aula 2	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	- 20/08/12: Aula 3	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	- 27/08/12: Aula 4	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	- 03/09/12: Aula 5	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	- 10/09/12: Aula de Revisão (1 a 5)	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	- 24/09/12: Aula 6	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	- 01/10/12: Aula 7	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	- 08/10/12: Aula 8	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	- 16/10/12: Aula 9	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	- 23/11/12: Aula 10	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	- 29/10/12: Aula de Revisão (6 a 10)	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	JAVA	Fonte: http://wwwyoutubecom/watch?v=uuayJEdbNyc	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	Temático I	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
		ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	Vamos lá pessoal!
Questão 1:
Qual a importância da Ergonomia na Engenharia de Usabilidade?	ALFREDO NAZARENO PEREIRA BOENTE respondeu em 19/02/2013 12:01	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	Bom, ao meu ver,
ela tem um papel fundamental, pois sem o estudo adequado da IHC para o ambiente ou produto a ser desenvolvido, poderá levar ate mesmo ao fracasso de um projeto Pois abrira presente para possíveis erro de projeção e configuração, possibilitando assim o uso não correto do ambiente ou “objeto”
Uma vez que o estudo e feto de forma abrangente, assim como e a IHC, possibilita ver as variações correta que o ambiente ou objeto poderá ter, bem como avaliar seu impacto na vida humana ao manipular o mesmo Trazendo assim redução de desgaste, físico ou psicológico, e encontra partida aumentando a valorização do objeto ou ambiente, pois ao trabalhar ou realizar lazer em um ambiente bem planeja, da prazer no que esta fazendo e ao usar um objeto de forma que atenda suas necessidades o fara ganhar tempo na tarefa a ser realizada com o mesmo 
 	RONALD MARTINS ROQUE respondeu em 20/02/2013 22:12 	ERROR:#REF!	ERROR:#REF!	ERROR:#REF!
	Temático III
	Temático IV
	A lei 9279, lei de propriedade industrial, trata da chamada licença compulsória quando do abuso do privilégio que é dado pelo Estado, para exploração de uma patente Assim sendo, apresente um fator que relacione o institui da licença compulsória com a função social da propriedade intelectual
	Introdução
	1 - Identificar a importância das linguagens de programação;
2 - Identificar as características da linguagem de programação java;
3 - Conhecer os tipos de programas java;
4 - Identificar os requisitos necessários para se programar;
5 - Construir um ambiente de programação para a linguagem java;
6 - Desenvolver pequenos programas com estruturas básicas
	Aula I - Introdução ao Java
	Linguagem de programação orientada a objetos desenvolvida por um time de programadores, liderados por Patrick Naughton, Mike Sheridan e James Gosling, na empresa Sun Microsystems
Linguagem de Alto desempenho, suporta multithreading, compilação just-in-time e utilização de código nativo
	É uma linguagem que é compilada para um “bytecode”, que é interpretada por uma máquina virtual – JVM
	Portabilidade	O Java pode ser executado em qualquer plataforma ou equipamento que possua um interpretador Java e que tenha sido especialmente compilado para o sistema a ser utilizado
	Orientada a Objetos	Contém a sintaxe similar a linguagem C/C++, mas é baseada no modelo Simula67
	Segurança	Pode ser executado via rede, com restrições de execução, além de proteger o sistema do cliente contra possíveis ataques não intencionais 
	Disciplina e muito esforço!
	Por que estudar JAVA?
	Orientação a Objetos: totalmente 00 - permitindo herança e reutilização de código de forma dinâmica e estática
Dinamismo: permite ser aumentado durante a execução
Facilidade: Derivada do C/C++ - Bem familiar O ambiente retira do programador a responsabilidade de gerenciar a memória e os ponteiros
	J2SE	Java2 Standard Edition – Fornece as principais APIs e enfoca o desenvolvimento de aplicações na arquitetura Cliente – Servidor Não permite distribuição de objetos nem oferece suporte a tecnologias para Internet
	J2EE	Java2 Enterprise Edition – Fornece um conjunto de APIs para o desenvolvimento corporativo e enfoca na integração entre sistemas Disponibiliza alta distribuição de objetos e oferece total suporte a tecnologias para Internet
	J2ME	Java2 Micro Edition – Fornece as APIs para o desenvolvimento de aplicações para computação móvel, em pequenos dispositivos ou tecnologias embarcadas
	Tipos De Programas Java
	Stand Alone	Stand - alone – Aplicações baseadas na J2SE que tem total acesso aos recursos do sistema, memória, disco, rede, dispositivos, etc 
	Java applets	Pequenas aplicações que não têm acesso aos recursos de hardware, necessitando de um navegador com suporte a J2SE para serem executados
	Java Servlets	Programas desenvolvidos para serem executados em servidores Web, baseados na J2EE, comumente usados para gerar conteúdos dinâmicos para websites
	Java midlets	Pequenas aplicações, extremamente seguras e construídas para serem executadas dentro do J2ME
	Java beans	São componentes de software escritos em Java que podem ser manipulados visualmente com a ajuda de uma ferramenta de desenvolvimento
	Construindo Um Ambiente Para Programação  Em Java 
	Para desenvolver programas em Java, precisamos obter o Kit de Desenvolvimento Java, que é gratuito e disponível para download no seguinte endereço:
	http://wwworaclecom/technetwork/java/javase/downloads/indexhtml
	Neste link, a Sun disponibiliza uma série de kit’s para cada perfil Sugerimos o JDK – JRE
É necessário, ainda, que o usuário escolha a plataforma (o computador e sistema operacional) onde o kit será instalado
	Para instalar, clique no arquivo baixado e siga as instruções do site para efetuar a correta instalação 
No link abaixo, existe um artigo que auxilia o usuário na instalação do J2SE no Windows 2000/XP
	http://wwwgujcombr/articleshowlogic?id=163
	Escrevendo E Executando O Primeiro Programa
	1 Abra o bloco de notas e digite o código 
	public class PrimeiroPrograma{
                                       public static void main(String args[]){
                                                           Systemoutprintln(“Bem vindo ao Mundo Java”);
                                       }
}
	2 Em Java, uma classe pública deve ser salva em um arquivo com o mesmo nome, com a extensão java Como nossa classe se chama PrimeiroPrograma, devemos salvar este arquivo como PrimeiroProgramajava Muita atenção com a caixa da letra, pois o Java faz diferença entre letras maiúsculas e minúsculas
	Para saber mais sobre os tópicos estudados nesta aula, pesquise na internet sites, vídeos e artigos relacionados ao conteúdo visto Se ainda tiver alguma dúvida, fale com seu professor online utilizando os recursos disponíveis no ambiente de aprendizagem
Para esta aula sugiro as seguintes tarefas:
Leitura do capítulo 2: Introdução a aplicativos Java, do livro Java Como Programar 4ª edição
Resolução dos exercícios de 27 até 235 do capítulo 2 do livro Java Como Programar
Visitar os seguintes sites:
- Para baixar o Java, baixar a máquina virtual, tutoriais e possibilidades
 http://wwwjavacom/pt_BR/
 http://javasuncom/
http://javanet/
- Para informações sobre o maior fórum de desenvolvedores em Java http://wwwgujcombr/homeindexlogic
Para baixar IDE’s:
- Eclipse
 http://wwweclipseorg/
- NetBeans
 http://wwwnetbeansorg/
	Aula II - As convenções do Java 
	A linguagem de programação Java é “Case Sensitive” Existem várias convenções utilizadas São elas:
	Variáveis e métodos começam com letras minúsculas
	Nomes de CLASSES iniciam com letras MAIÚSCULAS
	Nomes compostos: Utilizar letras MAIÚSCULAS para as iniciais das palavras
	Letras MAIÚSCULAS para as CONSTANTES
	Comentários: 3 formas
	//	Uma linha
	/* */	Uma ou mais linhas
	/** */	Quando colocado acima de uma declaração de variável ou função, indica que o comentário pode ser incluído automaticamente em uma página HTML pelo comando javadoc - gerador de documentação do Java
	Tipos de Dados em Java
	O Java é uma linguagem de programação fortemente tipada, ou melhor, necessita que todas as variáveis tenham um tipo declarado Existem 8 tipos primitivos Seis deles são numéricos, um é o caractere e o último é o booleano 
	Declarando E Atribuindo Valores A Variáveis
	A declaração de variáveis em Java exige que o tipo da variável seja declarado Você inicia a declaração, indicando o tipo da variável e o nome desejado, como nos exemplos a seguir:
	int x, y; //declarando duas variáveis inteiras
	                    x = 6; //atribuindo valores a variáveis
	                    y = 1000;
	 
	                    float f = 3,141516f; //ponto flutuante
	                    double w = 3,2310834; //ponto flutuante de dupla precisão
	                    char ch = ‘a’; //Caractere
	 
	                    final int MAX = 9; Define a constante MAX com o valor de 9
	Estruturas de PROGRAMAÇÃO
	Os comandos da linguagem permitem controlar o fluxo do programa e expressões condicionais 
	BLOCOS
	Conjunto de linhas de códigos situadas entre um abre e um fecha chaves( {} ) É permitido criar blocos dentro de blocos 
	 
	{ //início de bloco
	   /*bloco de comandos*/
	} //fim de bloco
	Escopo das variáveis
	Escopo de uma variável indica em que parte do código ou bloco de comandos do programa que podemos utilizar ou enxergar a variável Existem variáveis locais e variáveis globais O escopo define também quando a variável será criada e destruída da memória As locais estão visíveis apenas dentro do bloco enquanto as globais estão disponíveis em qualquer bloco do programa
	Observação: escopo é diferente de visibilidade, o qual se aplica as variáveis de classe e tem a ver com a utiliza
	Comando CONDICIONAL - if Switch
	Desvios de fluxo: break e continue
	Estruturas de repetição ou laço: while, do e for
	Manipulando Strings
	Java é uma linguagem totalmente orientada a objetos Então, todos os valores utilizados são objetos descritos por classes Os tipos primitivos de dados permitem que possamos criar todos os tipos de objetos necessários para se implementar qualquer sistema Um dos objetos mais utilizados é o String (com S maiúsculo porque, como vimos nas convenções, String é uma classe)
	String é uma sequência de caracteres
	Ex:
	String um = “Curso”;
	String dois = “Java”;
	Objetos da classe String não devem ser comparados usando os operadores relacionais, porque são objetos Existem métodos especiais para executar tais funções O objeto String em Java possui mais de 50 métodos diferentes
	Manipulando Vetores
	Vetores são estruturas utilizadas para armazenar um conjunto de dados do mesmo tipo Esses podem ser de qualquer tipo, desde variáveis primitivas até objetos complexos A sua alocação na memória é sempre contínua
	Conversão Entre Tipos De Dados
	Quando trabalhamos com expressões, o resultado de uma expressão pode ser de um tipo diferente dos seus operandos Ou ainda, temos dois tipos de dados diferentes e queremos efetuar uma operação Não é possível efetuar comparações ou operações com tipos diferentes Para resolver este problema, podemos converter os tipos de dados
	Existem, basicamente, dois tipos de conversões de dados A conversão implícita e a explícita de dados
	implícita	O primeiro caso ocorre sem a necessidade do programador interferir Os valores são convertidos automaticamente Isso ocorre na conversão de inteiro para real, de números para strings ou com o uso de operadores unários
Ex:
double x;
int i = 20;
 
x = i; // x recebe um valor inteiro
Systemoutprint(“i= ” + x); /* O valor de x é convertido para string e concatenado com a outra string para ser apresentada na tela */
	explícita	O segundo caso, o programador controla a conversão informando qual tipo será utilizado, através de um operador unário 
Ex:
float eventos = 257;
float dias = 72;
 
x = (int) (eventos / dias); // O resultado é o inteiro 3, pois 25/3 é 357
	public class TesteConvByte{	Resultado: -119
	public static void main(String args[]){
	393
	int l=393;	110001001
	byte b;	137
	b=(byte)l;	119
	Systemoutprintln("Conteudo da variável b:" +b);	1101110111
	}
	}
	Aula 3 - Net Beans IDE - Introdução às interfaces gráficas
	Nesta aula, você irá:
	1 Identificar e utilizar ides;
	2 Utilizar netbeans;
	3 Criar interfaces básicas, realizando operações simples;
	4 Entender a hierarquia do pacote swing
	Introdução às IDEs - Introdução às interfaces gráficas
	IDE, do inglês Integrated Development Enviroment ou Ambiente Integrado de Desenvolvimento, é um software que engloba características e ferramentas para o desenvolvimento de programas 
As IDEs facilitam a técnica de RAD que têm como principal objetivo a maior produtividade de seus desenvolvedores
Existem várias IDEs disponíveis Abaixo, a lista de algumas IDEs 
RAD- Rapid Application Development – Desenvolvimento Rápido de Aplicativos
	Baixado e não instalado
	Baixado e instalado
	Baixado e instalado
	Conhecendo a IDE Net Beans
	O NetBeans é uma IDE gratuita e de código aberto, totalmente escrito em Java para desenvolvedores de software na linguagem Java, C/C++, PHP, Groovy, Ruby e muito mais Por ser escrito em Java, é multi-plataforma, ou melhor, funciona em vários ambientes como Windows, Linux, Solaris e MacOS O NetBeans IDE oferece aos desenvolvedores ferramentas necessárias para criar aplicativos profissionais de desktop, empresariais, Web e móveis
Com projeto iniciado em 1996 por dois estudantes tchecos, teve como primeiro nome Xelfi, em alusão ao Delphi, porém foi totalmente desenvolvido em Java
Em 1999, o projeto já havia evoluído para uma IDE proprietário, com o nome de NetBeans DeveloperX2, nome este que veio da idéia de reutilização de componentes, que era a base do Java
	Nessa época, a empresa Sun Microsystems havia desistido de sua IDE Java Workshop e, procurando por novas iniciativas, adquiriu o projeto NetBeans DeveloperX2 ,incorporando-o à sua linha de softwares
Por alguns meses, a Sun mudou o nome do projeto para Forte for Java e o manteve por um bom tempo como software proprietário, porém, em junho de 2000, a Sun disponibilizou o código fonte do IDE NetBeans tornando-o uma plataforma OpenSource Desde então, a comunidade de desenvolvedores que utilizam e contribuem com o projeto não parou de crescer, tornando-se uma das IDE´s mais populares atualmente
	O NetBeans é considerado a melhor IDE para desenvolvedores iniciantes, pois, facilita o processo de programação, compilação e execução dos programas Este sistema cria um ambiente completo de teste O único problema é que para montar todo este ambiente, esta IDE exige uma configuração de hardware um pouco melhor, principalmente a quantidade de memória 
Existem várias opções de download A partir desta aula, iremos utilizar o NetBeans 691 
	public static main(String[] args){
//TODO code application logic here
                     int num1=2;
                     int num2=8;
                     int soma;
 
soma = num1+num2;
Systemoutprintln(“A soma é %d\n”, soma);
}	Primeiro programa no NET BEANS (OK)
	Introdução A Concepção De Interfaces Gráficas
	Muitos dos programas conhecidos interagem
com os usuários através da troca de informações O meio pelo qual a parte humana solicita ao programa a execução de tarefas, alguma resposta, ou qualquer comunicação entre as partes é feito pela Interface Muitas vezes confundida com o programa em si 
A interface gráfica com o usuário (GUI) fornece a um programa um conjunto consistente de componentes intuitivos, familiarizando o usuário com as diversas funções e diminuindo o tempo de aprendizado da nova ferramenta As GUIs são construídas a partir de componentes GUI, que são objetos com o qual o usuário interage através dos dispositivos de entrada, ou seja, o mouse, o teclado, a voz, etc
	Imagine que construir interfaces consiste em colar adesivos em uma tela de vidro ou colocar componentes em um contêiner de componentes Antes de tudo, é necessário possuir uma tela, que será representada pelos contêineres Também dispor de adesivos de diversos tamanhos que podem ser distribuídos e anexados livremente pela superfície do vidro Tais adesivos elementares serão os painéis Além disso, dispor de adesivos mais elaborados que já estão pré-definidos com figuras de botões, rótulos, etc Estes podem ser colados diretamente no vidro, ou sobre os outros adesivos rudimentares (painéis), tal qual é a nossa vontade, embora se limitando à capacidade do espaço físico disponível Na imagem você pode ver alguns dos componentes que estudaremos mais a frente
	Criação de Interfaces Gráficas 
	Em Java, as classes necessárias para criação de componentes gráficos, bem como para fornecer-lhes funcionalidade, estão agrupadas em dois grandes pacotes: javaawt (pct de núcleo) e javaxswing (pct de extensão) Os dois pacotes definem componentes com peculiaridades distintas e que serão discutidas a seguir
	O pacote javaxswing foi criado em 1997 e inclui os componentes GUI que se tornaram padrão em Java a partir da versão 12 da plataforma Java 2 A maioria dos componentes Swing é escrita, manipulada e exibida completamente em Java, estes são conhecidos como componentes Java puros Isso oferece a eles um maior nível de portabilidade e flexibilidade Os nomes de tais componentes recebem um “J”, como, por exemplo: JLabel, JButton, JFrame, JPanel, etc Tal peculiaridade se justifica para diferenciar esses componentes dos que serão mencionados logo adiante Os componentes Swing fornecem funcionalidade e aparência uniforme em todas as plataforma, sendo denominada de aparência de metal 
O Swing também fornece flexibilidade para personalizar a aparência e o comportamento dos componentes de acordo com o modo particular de cada plataforma, ou mesmo alterá-los enquanto o programa está sendo executado As opções são a personalização com o estilo do Microsoft Windows, do Apple Macintosh ou do Motif (UNIX)
metal look-and-feel
	O esquema ao lado mostra a maioria das classes que compõem o Java Swing e também a relação entre as classes AWT (claro) e as classes Swing (escuro):
	Painéis
	São áreas que comportam outros componentes, inclusive outros painéis Em outras palavras, são elementos que fazem a intermediação entre um container e os demais GUI anexados São criados com a classe JPanel, que é derivada da classe Container A classe JPanel não tem painel de conteúdo como JFrames, assim, os elementos devem ser diretamente adicioandos ao objeto painel Além de agregar um conjunto de componentes GUI para fins de layout, pode-se criar áreas dedicadas de desenho e áreas que recebem eventos do mouse
	Criando O Primeiro Formulário
	Componentes Swing	import javaxswing*; 
public class Frm01 
{ 
          public void criaTela() 
          { 
                 JFrame f= new JFrame(); 
                 fsetSize(290,100); 
                 fsetTitle("Cadastro"); 
                 fsetLocation(10,10); 
                 fsetDefaultCloseOperation(JFrameEXIT_ON_CLOSE); 
                 fsetVisible(true); 
         } 
}
	Componentes básicos
	Inserindo componentes na tela	import javaxswing*;
public class Frm02
{
public void criaTela()
{
//criando o Frame
JFrame f= new JFrame();
fsetSize(300,100);
fsetTitle("Cadastro de Categorias");
fsetLocation(150,200);
fsetDefaultCloseOperation(JFrameEXIT_ON_CLOSE);
//criando o Painel
JPanel pl = new JPanel();
plsetLayout(null);// gerenciador de Layout	//Criando os componentes:
//Label
JLabel meuLabel = new JLabel("Código");
meuLabelsetBounds(10, 10, 60, 20);
// Campo de Texto
JTextField meuCampoTexto = new JTextField(" ");
meuCampoTextosetBounds(80, 10, 60, 20);
// Botão
JButton meuBotao = new JButton("NomeBotão");
meuBotaosetBounds(150, 10, 100, 20);
//colando os componentes no Painel
pladd(meuLabel);
pladd(meuCampoTexto);
pladd(meuBotao);
//colando o painel no frame
fadd(pl);
fsetVisible(true);
}
}
	Para saber mais sobre os tópicos estudados nesta aula, pesquise na internet sites, vídeos e artigos relacionados ao conteúdo visto Se ainda tiver alguma dúvida, fale com seu professor online utilizando os recursos disponíveis no ambiente de aprendizagem
	Para esta aula sugiro as seguintes tarefas:
	Leitura do capítulo 14: Introdução a aplicativos Java, do livro Java Como Programar 8ª edição
	Resolução dos exercícios de 144 até 1420 do capítulo 14 do livro Java Como Programar
	Aula 4 - Princípios da Orientação a Objetos
	Nesta aula, você irá:
	1 Identificar os conceitos básicos da Orientação à Objetos;
	2 Criar e manipular classes e objetos em Java;
	3 Utilizar interfaces gráficas interagindo com objetos e classes previamente definidos;
	4 Implementar classes e instanciar objetos em Java
	Introdução Classes e Objetos
	•Todo sistema orientado à objetos pode ser definido como um conjunto de objetos que trocam mensagens entre si Então, quando programamos em Java, que é uma linguagem de programação orientada à objetos, estamos escrevendo ou definindo um conjunto de objetos que trocam mensagens 
	•Bom, mas o que é um Objeto? O que é uma classe? O que é mensagem?
	Classes
	•As classes definem a estrutura e o comportamento de um tipo de objeto Observe a figura abaixo:
	•A classe Árvore define um arcabouço de qualquer tipo de árvore Uma árvore real, será um objeto com estrutura a estrutura definida pela classe, mas os valores de cada árvore serão únicas
	Um protótipo que define os atributos e os métodos comuns a todos os objetos de um determinado tipo e da própria classe, com a finalidade de servir de molde para a criação de objetos
	Objetos
	São a representação de uma entidade do mundo real, que tem identificador único, propriedades embutidas e a habilidade de interagir com outros objetos e consigo mesmo  Um objeto é uma instância de uma classe A classe descreve todas as características e funcionalidades de um objeto Modelamos os objetos através das classes
	Abstração
	•Extrair tudo que for essencial e mais nada para o escopo do sistema;
	•É o processo de filtragem de detalhes sem importância do objeto real, para que apenas as características apropriadas que o descrevam e que tenham relevância para o sistema permaneçam;
	Conceito aplicado a criação de software baseado em objetos, partindo do princípio que devemos considerar a essência de cada objeto e não pensar em todos os detalhes de implementação;
	Classes e Objetos em Java
	•Na caixa de dialogo do novo projeto, escolhemos um aplicativo Java
	•Um programa Java é uma coleção de objetos que são descritos por um conjunto de arquivos texto, onde são definidas as classes Pelo menos uma destas classes é “public” e contém o método main(), que possui esta forma específica: =>
	•Como vimos nas aulas anteriores todos os programas feitos tinham esta estrutura E o nome da classe era o nome do arquivo Então, podemos concluir que uma classe em Java é construída dentro de um arquivo texto com o mesmo nome da classe e extensão java
	•Lembro que a classe que contém o método main() é chamada de classe principal
	Encapsulamento
	•Mecanismo utilizado em orientação a objetos para obter segurança, modularidade e autonomia dos objetos;
	•Implementamos através
da definição de visibilidade privada dos atributos;
	•Então, devemos sempre definir os atributos de uma classe como privados;
	•Este mecanismo protege o acesso direto aos dados do objeto;
	•Permite acesso através dos métodos públicos;
	Nível de Encapsulamento
	•É a disponibilização de uma interface pública, com granularidade controlada, para manipular os estados e executar as operações de um objeto ( * acesso permitido )
	Em outras palavras, os atributos e métodos de um objeto podem ser escondidos de outros objetos por uma interface pública de métodos, de modo a impedir acesso indevidos
Para definir diferentes níveis de encapsulamento, faz-se uso do conjunto de modificadores de acesso disponíveis no Java para os membros de classe, com mostrado na tabela
	Definindo uma classe em Java
	•São definidas através do uso da palavra-chave class
	• Construindo uma classe:
	•A primeira linha é um comando que inicia a declaração da classe Após a palavra-chave class, segue-se o nome da classe, que deve ser um identificador válido para a linguagem O modificador modif é opcional; se presente, pode ser uma combinação de public e abstract ou final A definição da classe propriamente dita está entre as chaves { e }, que delimitam blocos na linguagem Java 	ABSTRACT NÃO SÃO INSTANCIADAS
	Corpo da Classe	Ninguém herda de uma classe FINAL
	1As variáveis de classe (definidas como static), ordenadas segundo sua visibilidade: iniciando pelas public, seguidos pelas protected, pelas com visibilidade padrão (sem modificador) e finalmente pelas private 
	2Os atributos (ou variáveis de instância) dos objetos dessa classe, seguindo a mesma ordenação segundo a visibilidade definida para as variáveis de classe 	Atributo público não deve ser feito
	3Os construtores de objetos dessa classe 	Isso rompe o encapsulamento A linguagem permite, mas
	4Os métodos da classe, geralmente agrupados por funcionalidade 
	Criando Objetos em Java	O método à direita do operador new é o construtor da classe ClasseNome 
Podemos instanciar quantos objetos forem necessários, desde que guardemos a referência para o objeto em questão, que é como poderemos acessar aquele objeto 
Caso um objeto não tenha mais nenhuma referência para ele, o coletor de lixo (garbage collector - GC) elimina o objeto, liberando a memória
	•Toda classe possui atributos e métodos Em especial, toda classe tem um construtor, que é um método responsável pela instanciação do objeto 
	•Este processo faz com que o objeto seja criado com as características desejadas 
	•O construtor é o responsável por alocar a memória do objeto 
	•A criação de um objeto se dá através da aplicação do operador new
	ClasseNome objeto = new ClasseNome();
	Atributos e Métodos
	•Atributos
	–Eles representam as características de um objeto Devem ser privados, para manter o encapsulamento A definição de atributos de uma classe Java reflete de forma quase direta a informação que estaria contida na representação da classe em um diagrama UML 
	•A sintaxe utilizada para definir um atributo de um objeto é: 
	[modificador] tipo nome [ = default]; 
	•Onde: 
	–modificador é opcional, especificando a visibilidade diferente da padrão (public, protected ou private); 
	–tipo deve ser um dos tipos primitivos da linguagem Java ou o nome de uma classe; 
	–nome deve ser um identificador válido da linguagem Java; 
	–valor default é opcional; se presente, especifica um valor inicial para a variável 
	•Métodos
	–Os métodos representam as funcionalidades que os objetos podem desempenhar São essencialmente procedimentos que podem manipular atributos de objetos para os quais o método foi definido Além dos atributos de objetos, métodos podem definir e manipular variáveis locais; também podem receber parâmetros por valor através da lista de argumentos 	O usuário "fala" via método, não via atributo
	•A forma genérica para a definição de um método em uma classe é 
	 [modificador] tipo nome(argumentos) { 
	corpo do método 
	} 
	•Onde: 
	–o modificador (opcional) é uma combinação de: public, protected ou private; abstract ou final; e static 
	–o tipo é um indicador do valor de retorno, sendo void se o método não tiver um valor de retorno; 
	–o nome do método deve ser um identificador válido na linguagem Java; 
	–os argumentos são representados por uma lista de parâmetros separados por vírgulas, 
	onde para cada parâmetro é indicado primeiro o tipo e depois (separado por espaço) o nome 
	Boas Práticas de Programação	Como ocorre para a definição de atributos, a definição de métodos reflete de forma quase direta a informação que estaria presente em um diagrama de classes UML, a não ser por uma diferença vital: o corpo do método 
Métodos de mesmo nome podem co-existir em uma mesma classe desde que a lista de argumentos seja distinta, usando o mecanismo de sobrecarga 
	•Os métodos devem ser simples, atendendo a sua funcionalidade
	•O nome do método deve refletir de modo adequado a tarefa realizada
	•Se a funcionalidade do método for simples, será fácil encontrar um nome adequado para o método 
	•Métodos de mesmo nome podem co-existir em uma mesma classe desde que a lista de argumentos seja distinta, usando o mecanismo de sobrecarga 
	Exemplo
	public class Ponto2D { 	mínimo a fazer e liberar o recurso
	private int x; 
	private int y; 
	public Ponto2D(int a, int b) { 
	x = a; 
	x = a; 
	y = b; 	y = b; 
	} 
	public double distancia(Ponto2D p) { 
	double distX = px - x; 
	double distY = py - y; 
	return Mathsqrt(distX*distX + distY*distY); 
	} 
	}
	•Neste exemplo, definimos a classe Ponto2D com dois atributos e dois métodos Os atributos são, x e y enquanto os métodos são:
	•Ponto2D – Construtor
	•distancia – método que calcula a distância entre o ponto e um outro dado
	Aula 5- HERANÇA
	Nesta aula, você irá:
	1Apresentar os conceitos de Herança
	2Criar e manipular classes e objetos que se relacionem através de herança
	3Sobrecarga de métodos
	4Utilizar interfaces gráficas interagindo com objetos e classes previamente definidos;
	HERANÇA
	•Significa a capacidade de incorporar as características e as funcionalidades de uma classe Assim como a herança de todas as operações e dados, você pode especializar métodos da super classe e especificar novas operações e dados, para refinar, especializar, substituir ou estender a funcionalidade da classe progenitora
	•Uma classe define um conjunto de dados – Atributos – e um conjunto de métodos 
	•Todos os objetos de uma classe mantêm o mesmo conjunto de atributos e métodos 
	•Através do mecanismo de herança, tendo definido uma classe base é possível criar classes derivadas que: 
	–herdam os atributos e métodos da classe base 
	–definem novos atributos e métodos 
	–podem redefinir os métodos herdados
	Terminologias
	•Estender – Criar uma nova classe que herda todo o conteúdo da classe existente
	•Superclasse – Uma classe progenitora ou base
	•Subclasse – Uma classe filha que herda ou estende uma superclasse
	Classe Abstrata
	•Uma classe abstrata em Java define atributos e métodos 
	•Numa classe abstrata, um método pode ser definido com o modificador “abstract” Nesse caso: 
	–A classe abstrata não implementa os método abstratos 
	–As classes derivadas devem implementar os métodos abstratos 
	•Uma classe abstrata é utilizada quando deseja-se fornecer uma interface comum a diversos membros de uma hierarquia de classes Os métodos declarados na classe abstrata serão implementados em suas subclasses, através de polimorfismo
	•Imagine uma classe que no seu sistema, a uma funcionalidade existente em todas as subclasses quer ser apresentada na superclasse Este método é definido na superclasse como Abstract Nas subclasses, estes métodos serão implementados, cada um com a sua peculiaridade
	Notas importantes
	•Como visto anteriormente, subclasses podem redefinir (sobrepor) um método de sua superclasse 
	•Para indicar que um método de uma classe deve necessariamente ser redefinido em cada uma de
suas subclasses devemos usar o modificador abstract 
	•Uma classe que contém um ou mais métodos abstratos deve ser declarada explicitamente como abstrata Essa classe, no entanto, pode ter construtores e métodos concretos (não-abstratos) 
	•Se uma classe é declarada como abstract, não podem ser criados objetos desta classe 
	•Se uma subclasse é derivada de uma superclasse que contém um método abstrato e se esse método abstrato não for redefinido na subclasse, esse método permanece abstract na subclasse Com isso, a subclasse deverá ser declarada explicitamente como abstract 
	•Declarar um método como abstrato é uma forma de obrigar o programador a redefinir esse método em todas as subclasses para as quais se deseja criar objetos 
	•Como um método abstrato deve ser redefinido nas subclasses, na superclasse ele não precisa ter implementação alguma
	Exemplo
	Vamos imaginar a seguinte hierarquia de classes:
	•onde Chefe, PorComissao, PorItem e PorHora são classes finais
	•Todas essas subclasses vão precisar redefinir o método ganha() Como se tratam de tipos diferentes de empregado, cada um ganha de uma forma: 
	–Chefe: salário fixo e predefinido; 
	–PorComissao: valor fixo + comissão * vendas; 
	–PorItem: valor por produção * quantidade produzida; 
	–PorHora: valor por hora * total de horas trabalhadas
	Chefejava	PorComissãojava
	PorItemjava	PorHorajava
	Aula 6 - Encapsulamento e Associações de Classes
	Nesta aula, você irá:
	1 Apresentar os conceitos de encapsulamento e associações de classes;
	2 Criar e manipular classes e objetos, com seus atributos encapsulados, e que se relacionem através de associações;
	3 Utilizar interfaces gráficas interagindo com objetos e classes previamente definidos;
	4 Explorar o conceito de encapsulamento e associações de classes, em exemplos e exercícios;
	Encapsulamento
	•Mecanismo utilizado na Programação Orientada à Objetos que visa obter segurança, modularidade e autonomia para os objetos;
	•Conseguido através da definição de visibilidade privada dos atributos, ganhando-se assim autonomia para definir o que o mundo externo a classe poderá visualizar e acessar, normalmente através de métodos públicos
	CONCLUINDO
	•Sempre defina os atributos de uma classe como privados, a não ser que tenha uma boa justificativa para isso
	•O Encapsulamento protege os atributos de acesso direto
	•Permite apenas acesso através de métodos públicos
	Modificadores de Visibilidade 
	•Modificadores de Acesso (São 4): public, protected, private e sem modificador (default)
	•Modificadores de Não Acesso: final e abstract
	 –public – Atributos e métodos são acessíveis em todos os métodos de todas as classes Este é o nível menos rígido de encapsulamento, que dizemos que o encapsulamento foi rompido (Não deve ser utilizado para definir um atributo É abominável)
	 –private - Atributos e métodos são acessíveis somente nos métodos da própria classe Este é o nível mais rígido de encapsulamento 
	 –protected - Atributos e métodos são acessíveis no pacote, nos métodos da própria classe e suas subclasses (Também rompe o encapsulamento)
	 –Sem Modificador – A visibilidade nas classes do mesmo pacote e a própria classe (Também rompe o encapsulamento)
	Tabela de Visibilidades
	Outros Modificadores
	•abstract – Um método abstrato não implementa nenhuma funcionalidade, somente assina o método e faz com que a primeira subclasse concreta seja obrigada a implementar Uma classe que possui um método abstrato deve ser obrigatoriamente abstrata, como vimos na aula passada
	•final – Pode ser aplicado em classes, métodos e atributos Indica que esta é a última atribuição ou definição da estrutura Não será permitida uma nova re-escrita Para uma classe, não há herança em classes final Um método não pode ser sobrescrito E um atributo é considerado uma constante
	static – Um método ou atributo estático define que este pode ser executado sem que exista uma instância da classe – o objeto
	Exemplo: sem encapsulamento
	class NaoEncapsulado {
	//implicitamentamente há modificador de acesso, 
	//mas não é o mais restritivo
	int semProtecao;
	}
	public class TesteNaoEncapsulado {
	public static void main(String[] args) {
	NaoEncapsulado ne = new NaoEncapsulado(); 	//ne é uma instância de NaoEncapsulado
	nesemProtecao = 10; //acesso direto ao atributo
	Systemoutprintln("Valor sem proteção: " + nesemProtecao); 	//acesso direto aos atributos
	}
	}
	Exemplo: COM encapsulamento
	class Encapsulado {
	//private é um modificador de acesso de restrição máxima
	private int comProtecao;
	public void setComProtecao(int comProtecao) {
	thiscomProtecao = comProtecao;
	}
	public int getComProtecao() {
	return thiscomProtecao;
	}
	}
	public class TesteEncapsulado {
	public static void main(String[] args) {
	Encapsulado e = new Encapsulado(); 	// O Objeto "e" é uma instância de Encapsulado
	ecomProtecao = 10; //Esta linha dá erro
	esetComProtecao(10);
	Systemoutprintln("Valor com proteção: " + egetComProtecao() ); 
	}
	}
	Métodos Get’s e Set’s
	•Como vimos, é preciso criar um mecanismo para acessar os campos private de uma classe Para isso, é comum fornecer métodos públicos para acessar as informações encapsuladas Esses métodos são chamados de set e get O método set atribui valores ao atributo, enquanto que o método get obtém seus valores
	•A composição do nome destes métodos é sempre com o nome set + <nome atributo> ou get + <nome atributo>
	Exemplo
	Exercício
	•A partir da classe Automoveljava apresentada abaixo, encapsule seus métodos e crie mecanismos públicos para acessar estas características
	–Crie mais um atributo na classe do tipo boolean – estadoMotor
	–Crie métodos ligarMotor() e desligarMotor(), atualizando o valor de estadoMotor 
	Crie uma classe de teste para instanciar Automóvel
	Automoveljava
	public class Automovel {
	String modelo, cor;
	int ano;
	}
	Associação de Classes
	•É um vínculo que permite que objetos de uma ou mais classes se relacionem Através destes vínculos, é possível que um objeto troque mensagens ou chame os métodos de outros objetos
	•Na UML, quando estamos modelando o diagrama de classes, temos a Associação, a Composição e a Agregação, como tipos de Associações
	–As Associações têm acoplamento fraco
	–As Composições têm acoplamento forte
	–A Agregação faz parte de
	•Na implementação, não há diferença entre as abordagens, o que as distingue são os controles adicionados pelo desenvolvedor
	Exemplo
	public class Aviao {  
	  	Motor motor = new Motor();      //  composição  - O Avião é composto de Motor
	   	public void adiciona(Passageiro p){  // isto é agregação  
	      	pembarque(this);  
	}  
	   	public void remove(Passageiro p){  
	      	pdesembarque(this)  
	   	}  
	  // isto é uma associação  
	public void setControladorVoo (ControladorVoo controlador);  
	public ControladorVoo getControladorVoo ();  
	}  
	public class Passageiro {  
	Aviao aviao ; 
	public  void embarque(Aviao aviao ){  
	if (thisaviao ==null){  
	throw new IllegalStateException("O passageiro já embarcou Remova-o antes de o incluir em outro");  
	}  
	thisaviao = aviao ; 
	}  
	public void desembarque(Aviao aviao){  
	if (aviaoequals(thisaviao)){  
	thisaviao = null;  
	}  
	}  
	} 
	Composição
	•Tipo de associação onde uma nova classe usa classes existentes como atributos; 
	•Relacionamento “tem um”
	•Ex: 
	–uma conta tem um dono (cliente), 
	–um cliente tem um nome (string); 
	Exemplo - Composição
	class Aleatorio { 
	int numero; 
	Aleatorio(int max) { numero = new Random()nextInt(max); }
	} 
	public class NumeroAleatorio { 
	private String nome; 
	private Aleatorio valor; 
	NumeroAleatorio(String nome, int valor) { 
	thisnome = nome; 
	thisvalor = new Aleatorio(valor); }
	public static void main(String[] args) { 
	NumeroAleatorio
n; 
	n = new NumeroAleatorio("Número secreto", 50); 
	} 
	}
	Multiplicidade de Associações
	•Podemos ter as seguintes multiplicidades de associações:
	–1 para 1
	–1 para *
	–* para *
	•Onde * equivale a muitos
	Exemplos de Associações
	•Um automóvel tem um motor instalado
	public class Carro {  
	  	private String modelo;      
	private short ano;
	private Motor motor; // Atributo gerado pela associação           
	public void Carro(short a, String mod, Motor m){
	thismodelo = mod;
	thisano = a;
	thismotor = m;
	}    
	}  
	public class Motor {  
	private String combustivel;      
	private float potencia;
	public void Motor(float pot, String comb){
	thispotencia = pot;
	thiscombustivel = comb;
	}  
	} 
	 public class TestaCarro { 
	public static void main(String[] args) { 
	Motor motFusca = new Motor(999f, “gasolina”);
	Carro fusca82 = new Carro(“Fusca”,(short)1982, motFusca);
	Carro kombi2010 = new Carro(“Kombi”,(short)2010, new Motor(1399f,”flex”));
	}
	}