( Informatica) - Jose M R S Júnior - Java

Prévia do material em texto

José Maria Rodrigues Santos Júnior
Java Standard
Aracaju, 16 de julho de 2002
�
4Introdução	�
4Java como Linguagem de Programação	�
7Java como Plataforma de Desenvolvimento de Aplicações	�
8Conceitos Básicos	�
8A Máquina Virtual Java	�
9Coleta de lixo (Garbage Collector)	�
10Java Development Kit - JDK	�
11Ambiente Integrado de Desenvolvimento - IDE	�
13Tipos de Programas Java: Applications, Applets e Servlets	�
14Estrutura de um Programa Java	�
15Aplicações Java - Application	�
16A Linguagem Java	�
16Comentários	�
17Identificadores	�
17Palavras Reservadas	�
18Variáveis e Constantes	�
22Arrays	�
23Lendo e Escrevendo Variáveis	�
24Operadores	�
29Comandos	�
39Introdução a Orientação a Objetos	�
40Tipos de Dados Abstratos	�
40Classe	�
40Objeto	�
40Encapsulamento	�
41Mensagem	�
41Herança	�
42Orientação a Objetos em Java	�
42Pacotes	�
43Arquivos JAR (Java Archive) e CLASSPATH	�
44Classe	�
46Encapsulamento	�
47Membros de Classe	�
47Atributos	�
48Métodos	�
49Objeto	�
50Mensagem	�
51Sobrecarga de Métodos	�
52Herança	�
56Redefinição de Métodos	�
57Classes e Métodos Abstratos	�
59Classes, Métodos e Variáveis Final	�
60Membros Estáticos	�
61Classes Internas	�
62Interfaces	�
63Polimorfismo	�
64Tratamento de Exceções	�
68JavaDoc	�
71Code Conventions	�
72API Java	�
73java.lang	�
81java.util	�
82java.text	�
93java.io	�
101Threads	�
102java.net	�
107javax.swing	�
122java.sql.jdbc	�
136Fontes de Pesquisa	�
137Exercícios	�
�
�
Introdução
“Java é uma Linguagem de Programação e uma Plataforma de Desenvolvimento de Aplicações”
Java como Linguagem de Programação
A linguagem de programação Java é de alto nível com as seguintes características:
	Simples
	Orientada a Objetos
	Distribuída
	Compilada
	“Interpretada”
	Segura
	Robusta
	Portável
	Arquitetura Neutra
	Multithread
	Alto desempenho
	Dinâmica
	Site(s)
	http://java.sun.com/docs/white/langenv/Intro.doc2.html
�
Java possui a singular característica de ser compilada e interpretada obtendo o melhor desses dois mecanismos de tradução/execução de programas. Primeiro o compilador Java transforma um programa fonte em bytecodes e posteriormente, na execução, os bytecodes são interpretados pela máquina virtual Java (JVM).
Com isso um programa Java é um conjunto de instruções para a JVM, dessa forma o mesmo é independente de plataforma, pois basta que haja uma implementação de máquina virtual para a plataforma a ser utilizada.
�
Observação : Esse foi o modelo inicial para execução de programas Java, a fim de possibilitar independência de plataforma, sendo que atualmente o processo de interpretação foi substituído por outra compilação, sendo que, não mais para bytecodes e sim para código executável dependente de plataforma. Dessa forma a perda de performance com a interpretação foi eliminada e o programa em bytecodes continua independente de plataforma, pois a MVJ de cada plataforma será responsável pela compilação em executável.
	Site(s)
	http://www.javasoft.com/products/hotspot/
�
Java como Plataforma de Desenvolvimento de Aplicações
O termo plataforma normalmente é definido como a combinação de sistema operacional mais hardware, sendo que a plataforma Java é definida apenas em software, por isso o conceito de máquina virtual. 
A plataforma Java possui dois componentes:
1.	Máquina Virtual Java (JVM)
2.	Interface para Desenvolvimento de Aplicações (API Java)
�
Conceitos Básicos
A Máquina Virtual Java
A Especificação da Máquina Virtual Java define a JVM (Máquina Virtual Java) como:
Uma máquina imaginária que é implementada através da emulação em um software executado em uma máquina real. 
A Especificação da Máquina Virtual Java fornece as especificações da plataforma de hardware para a qual todo o código Java está compilado. Essa especificação permite que os programas Java sejam independentes de plataforma já que a compilação é feita para uma máquina imaginária. Cabe ao Interpretador Java de cada plataforma de hardware assegurar a execução do código compilado para a JVM. 
A especificação da JVM fornece definições concretas para a implementação dos seguintes itens:
Conjunto de Instruções (equivalente ao conjunto de instruções de uma CPU)
Conjunto de registradores
Formato do arquivo de classe
Pilha
Heap (coletado como lixo)
Área da memória
�
Coleta de lixo (Garbage Collector)
Várias linguagens de programação permitem a alocação dinâmica da memória no tempo de execução. O processo de alocação de memória varia baseado na sintaxe da linguagem, mas sempre envolve o retorno de um ponteiro ao endereço inicial do bloco de memória. 
Quando a memória alocada não é mais necessária (quando o ponteiro que faz referência à memória está fora do escopo), é aconselhável que o ambiente do programa ou do tempo de execução desaloque a memória para evitar que o programa seja executado com falta de memória. 
No C e C++ (e outras linguagens), o desenvolvedor do programa é responsável pela desalocação da memória. Esse procedimento algumas vezes pode ser trabalhoso, principalmente porque nem sempre é possível saber antecipadamente quando a memória deve ser liberada. Os programas que não são desalocados da memória podem, conseqüentemente, sofrer algum tipo de falha caso não haja memória suficiente a ser alocada pelo sistema. Esses programas têm, portanto, vazamentos de memória. 
A linguagem Java realiza a liberação da memória, que antes era responsabilidade do programador, fornecendo um thread em segundo plano, em nível de sistema, que registra cada alocação de memória e mantém uma contagem do número de referências feitas a cada ponteiro de memória. Durante os ciclos ociosos, no tempo de execução da Máquina Virtual Java, o thread da coleta de lixo verifica se existe algum ponteiro de memória em que o número de referências tenha baixado para 0. Se houver, a memória marcada pelo thread da coleta de lixo será varrida (desalocada). 
A coleta de lixo ocorre automaticamente durante o tempo de vida de um programa Java e dispensa a desalocação de memória, além de eliminar os vazamentos de memória. 
�
Java Development Kit - JDK
Conjunto de ferramentas para o desenvolvimento em JAVA fornecidas pela Sun, sendo os principais:
	Ferramenta
	Descrição
	javac
	Compilador
	java
	Executor de Programas
	javadoc
	Gerador de documentação da API
	appletviewer
	Visualizador de applet
	jar
	Gerenciador de arquivos .jar
	jdb
	Debuger
	javap
	Faz engenharia reversa de classes
Versões Existentes:	JDK 1.0.x	JDK 1.1.x	JDK 1.2.x	JDK 1.3.x	JDK 1.4.x
	Site(s)
	http://www.javasoft.com/products/
�
Ambiente Integrado de Desenvolvimento - IDE
Ambiente com interface gráfica que interage com o JDK para oferecer um ambiente de desenvolvimento mais produtivo.
Exemplos:
	Inprise JBuilder
	Microsoft Visual J++
	Symantec Visual Café
	Tek-Tols Kawa
	Sun Forte CE
	
Jbuilder 6.0 Foundation
Ferramenta da Borland, de uso livre e utilizando apenas a API padrão. Possui os mesmos recursos de edição das versões comerciais.
	Site(s)
	http://www.borland.com/jbuilder/foundation/download/windows.html
	
Demonstração
JBuilder
	Configurando o ambiente : “Tools\IDE Options...” : (Editor/Block Ident e Tab Size =2)
Criação de Projeto
Novo Projeto (C:\CursoJava\Standard\Fontes\ProjetoDemo.jpr)
Propriedades do Projeto
Nova Classe
Edição/Compilação/Execução
�
	Exercício :
	/**
 * Demonstração de um Application Java
 */
/* Definição do pacote */
package introducao;
/* Definição da classe */
public class Aplicacao {
	/* Método main, o qual define um application */
	public static void main(String[] args) {
		/* Escrevendo os parâmetros passados na saida padrao */
		for (int i = 0; i < args.length; i++ ) {
			System.out.println( args[i] );
		}
 }
}
�
Tipos deProgramas Java: Applications, Applets e Servlets
A linguagem Java possui diferentes tipos de programas, sendo que a classificação é feita através da modalidade/localização de execução dos mesmos.
Applications
Aplicações stand-alone com "todos" os recursos de acesso ao Sistema Operacional. Semelhantes aos programas convencionais.
Applets
Programas que são carregadas através de uma rede TCP/IP (Internet/Intranet) e são executadas na JVM de um browser. A máquina virtual impõe sérias restrições aos Applets, em relação ao uso de recursos do sistema operacional local, para evitar problemas de segurança.
Servlets
Programas que são executadas remotamente no servidor Web através de um Gerenciador de Servlets (Servlet Engine). São utilizados em aplicações para Internet/Intranet, os quais são executadas no servidor, evitando assim problemas de compatibilidade, distribuições de versões e aumentando a segurança.
�
Estrutura de um Programa Java
Todo programa Java é uma classe e mesmo possuindo três possíveis modalidades para programas Java (Applications, Applets e Servlets) a estrutura básica é sempre a mesma : "uma classe".
Um Programa Java é organizado em arquivos texto com a extensão .java e cada arquivo contem apenas uma classe pública. O nome do arquivo da classe Java deve possuir exatamente o mesmo nome da classe pública, pois a máquina virtual procura o arquivo da classe através do nome da classe. O comando package informar a qual pacote (diretório) a classe pertence. Quando uma classe utilizar outras classes, estas devem ser importadas através do comando import, o qual deve indicar o pacote da classe importada e o seu nome.
	Programa(s) Demonstração
	introducao.ClasseJava.java
	/**
 * Demonstração de uma classe Java
 */
/* Definição do pacote */
package introducao;
/* Definição da classe (O mesmo nome do arquivo fonte) */
public class ClasseJava {
	/* Corpo da Classe */
	/* Atributos */
	/* Construtore(s) */
	public ClasseJava ( /* Parâmetros */ ) {
		/* procedimentos de inicialização da classe */
	}
	/* Finalizador */
	protected void finalize () {
		/* procedimentos de finalização da classe */
	}
	/* Métodos */
}
�
Aplicações Java - Application
Como demonstrado anteriormente, a linguagem de programação Java possui três tipos de programas. Dessa forma iremos nos aprofundar um pouco mais no tipo Application, pois os recursos básicos da linguagem Java serão demonstrados através de Application.
Um application Java nada mais é que uma classe Java possuindo um método específico que o caracteriza como uma aplicação para a Máquina Virtual Java. Dessa forma, todo programa/classe Java que possuir o método com o seguinte assinatura “public static void main (String[] argumentos){ }“ será um application. E o corpo desse método será executado automaticamente quando o programa for submetido a JVM. Um detalhe importante é que o array String[] argumentos contém os parâmetros de linha de comando passados ao programa.
	Programa(s) Demonstração
	introducao.Aplicacao.java
	/**
 * Demonstração de um Application Java
 */
/* Definição do pacote */
package introducao;
/* Definição da classe */
public class Aplicacao {
	/* Método main, o qual define um application */
	public static void main(String[] args) {
		/* Escrevendo os parâmetros passados na saida padrao */
		for (int i = 0; i < args.length; i++ ) {
			System.out.println( args[i] );
		}
 }
}
�
A Linguagem Java
Comentários
Existem três tipos de comentários em Java, sendo eles :
	//
	Usado para indicar comentários em uma única linha, pode ser inserido em qualquer posição de uma linha, e todo o texto até o final do marcador de linha é tratado como comentário.
	/* */
	Usados para indicar comentários que se estendem por uma ou mais linhas.
	/** */
	Comentário de documentação. Devem ser inseridos imediatamente antes de uma declaração de classes, variável ou método e indicam que o comentário deve ser incluído em qualquer documentação gerada automaticamente (como os arquivos HTML gerados pelo comando javadoc)
	Programa(s) Demonstração
	introducao.Comentarios.java
	/**
 * Descriçao: <p>Aplicação java demonstrando os tipos de comentários
 * Empresa: <p>Infonet
 * @author José Maria Rodrigues Santos Junior
 * @version 1.0
 */
//Definição do pacote
package introducao;
//Definição de classe
public class Comentarios {
	/**
 	 * Método main da Aplicação
 * @param args parâmetros da linha de comando
 	 */
 public static void main(String[] args) {
		/*
		 * O laço abaixo irá passar por todos os parâmetros fornecidos na linha
		 * de comando e irá escrevê-los na saída padrão
		 */
		int i = 0; // Variável inteira
		System.out.print("Parâmetros : ");
		while (i < args.length) {
			/* Ecreve posição i do array args na saída padrão */
			System.out.print(args[i] + " ");
			i++; // Incrementa a variável i de 1 unidade
		}
	}
}
�
Identificadores
Os identificadores em Java devem seguir as seguintes regras :
	1.
	A primeira posição deverá ser com uma letra, “_” ou “$”
	2.
	Ser formado por caracteres UNICODE
	3.
	Não ser uma palavra reservada
	4.
	Não ser igual as literais : true, false ou null
	5.
	Não ser repetido dentro do seu escopo
Observação : Os identificadores Java são case-sensitive
Palavras Reservadas
	abstract
	double
	int
	strictfp
	boolean
	else
	interface
	super
	break
	extends
	long
	switch
	byte
	final
	native
	synchronized
	case
	finally
	new
	this
	catch
	float
	package
	throw
	char
	for
	private
	throws
	class
	goto
	protected
	transient
	const
	if
	public
	try
	continue
	implements
	return
	void
	default
	import
	short
	volatile
	do
	instanceof
	static
	while
�
Variáveis e Constantes
Podem ser declaradas em qualquer lugar dentro de uma classe ou de um método. Uma constante é definida com a palavra reservada final e o seu conteúdo uma vez atribuído não poderá mais ser alterado.
A declaração de variáveis e constantes em Java é feita colocando o identificador do tipo seguido do identificador da variável.
	tipo variável [ = ValorInicial ];
final tipo CONSTANTE [ = ValorInicial ];
Tipos de Dados Primitivos
Java é uma linguagem de programação fortemente orientada a objetos e, com exceção dos tipos primitivos, “qualquer” coisa em Java é uma classe/objeto. 
Tipos Numéricos Inteiros
	Tipo
	Tamanho em bits
	Faixa
	byte
	8
	-128 até +127
	short
	16
	-32,768 até +32,767 
	int
	32
	-2,147,483,648 até+2,147,483,647
	long
	64
	-9,223,372,036,854,775,808 até
+9,223,372,036,854,775,807
Tipos Numéricos Reais
	Tipo
	Tamanho em bits
	Faixa
	float
	32
	-3.40292347E+38 até +3.40292347E+38
	double
	64
	-1.79769313486231570E+308 até
+1.79769313486231570E+308
�
Tipo caracter
	Tipo
	Tamanho em bits
	Faixa
	char
	16
	UNICODE - 65536 caracteres possíveis
Observação: Um caracter é delimitado por apóstrofos ‘caracter’. O que causa confusão, pois as Strings são delimitadas por aspas “String”.
Caracteres Especiais de Escape:
	'\u0000' a
'\uFFFF'
	caracteres Unicode
	\b
	retrocesso
	\t
	tab
	\n
	avanço de linha
	\r
	retorno de carro
	\”
	aspas
	\'
	apóstrofo
	\\
	barra invertida
Observação: A linguagem Java não possui o tipo primitivo string, bastante conhecido em várias outras linguagens. Para manipulação de texto são utilizadas as classes String e StringBuffer.
�
Tipo Lógico
	Tipo
	Faixa
	boolean
	true ou false
Conversão entre tipos primitivos
É possível transformar um tipo primitivo em outro, através de uma operação chamada typecast, colocando o tipo destino da transformação, entre parêntesis, antes da expressão a ser convertida.Esse tipo de conversão é chamado de conversão explícita. Por outro lado existe a conversão implícita, a qual é realizada pela MVJ, mesmo sem possuir operador de typecast, isso quando o tipo de retorno é menos abrangente que o tipo que o recebe.
�
	Programa(s) Demonstração
	introducao.TiposPrimitivos.java
	/**
 * Demonstração de Tipos Primitivos
 */
package introducao;
public class TiposPrimitivos {
 public static void main ( String[] args ) {
		/* Declarando tres variaveis do tipo float */
		float nota1, nota2, nota3;
		/* Inicializando as tres variáveis float */
		nota1 = 10;
		nota2 = 7;
		nota3 = 3;
		/* Declarando e inicializando três variaveis float*/
		float n1 = 5, n2 = 2, n3 = 9;
		int idade = 28;
		char sexo = 'M'; //Lembrar de usar apóstofros
		double salario = 3000.00;
		boolean achou = false;
		/*
		 * quando uma variável é declarada como final a mesmo não pode ter seu
		 * conteúdo alterado
		 */
		final char FLAG = 'F';
		/*
		 * Erro, pois literais numéricas com casas decimais são double
		 */
		// nota1 = 8.5
		nota1 = 8.5f; 			// conversão explicita para float
		nota2 = 7.0f; 			// conversão explicita para float
		nota3 = (float) 9.0; 	// conversão explicita para float
		System.out.println("Dados do Aluno");
		System.out.print("Idade \t= " + idade + "\n" );
		System.out.println("Sexo \t= " + sexo);
		System.out.println("Notas \t= " +
						 nota1 + "\t" +
						 nota2 + "\t" +
						 nota3);
		System.out.println("Achou \t= " + achou);
		System.out.println("Flag \t= " + FLAG);
		/* Conversão de double para int */
		double d = 34.78;
		int i = (int) d;
		System.out.println("double : " + d + "\n int : " + i);
 }
}
�
Arrays
São estruturas homogêneas e estáticas. A linguagem Java possui somente arrays unidimensionais, sendo que arrays multidimensionais podem ser simulados, através da definição de array de array. A propriedade length representa o tamanho do array. A primeira posição de um array é 0 e a última (length – 1)
	Programa(s) Demonstração
	introducao.Array.java
	/**
 * Demonstração de array
 */
package introducao;
public class Array {
 public static void main(String[] args) {
		/* declarando dois arrays do tipo int*/
		int[] a1;
		int[] a2;
		/* instanciando os dois arrays */
		a1 = new int[ 10 ]; // array com 10 posições de int
		a2 = new int[ 30 ]; // array com 30 posições de int
		/* imprimindo o tamanho dos array a1 e a2 */
		System.out.println("a1 tamanho : " + a1.length);
		System.out.println("a2 tamanho : " + a2.length);
		/* declarando, instanciando e atribuindo valores ao array notas */
		float[] notas = { 7.5f , 9.0f , 10.0f };
		/* imprimindo as posições do array notas */
		System.out.println("Notas : " + notas[0] + " - " +
										notas[1] + " - " +
										notas[2]);
		/* simulando array bidimensional*/
		int[][] matriz = new int[ 3 ][ 4 ];
		System.out.println("Linhas da Matriz : " + matriz.length);
		System.out.println("Colunas da Matriz : " + matriz[0].length);
		matriz[0][0] = 1;
		matriz[0][1] = 2;
		matriz[0][2] = 3;
		matriz[0][3] = 4;
		matriz[1][0] = 5;
		matriz[1][1] = 6;
		matriz[1][2] = 7;
		matriz[1][3] = 8;
		matriz[2][0] = 9;
		matriz[2][1] = 10;
		matriz[2][2] = 11;
		matriz[2][3] = 12;
		/* Imprimindo o array */
		for (int i = 0; i < matriz.length; i++)
			for (int j = 0; j < matriz[0].length; j++)
				System.out.print(matriz[i][j] + " ");
 }
}
�
Lendo e Escrevendo Variáveis
A linguagem Java não possui comandos específicos para leitura de variáveis, pois a entrada e saída de dados são tratadas de forma independente de dispositivo, através das classes do pacote java.io. Dessa forma foi criada uma classe (Keyboard), contendo métodos "estáticos" para leitura de variáveis do tipo int, char, float e String, afim de facilitar a prática dos conceitos visto durante o curso.
Para escrever variáveis na saída padrão podem ser utilizados os comando:
	System.out.print(String);
System.out.println(String); //Salta Linha
Observação: Tipos primitivos/“objetos” podem ser concatenados com o sinal "+". 
	Programa(s) Demonstração
	introducao.Teclado.java
	/**
 * Demonstração do uso da classe Keyboard
 */
package introducao;
import util.Keyboard;
public class Teclado {
	public static void main (String[] args) {
		/* Lendo uma Variável int */
		System.out.print("int : ");
		int i = Keyboard.readInt();
		System.out.println(i);
		/* Lendo uma Variável float */
		System.out.print("float : ");
		float f = Keyboard.readFloat();
		System.out.println(f);
		/* Lendo uma Variável char */
		System.out.print("char : ");
		char c = Keyboard.readChar();
		System.out.println(c);
	}
}
�
Operadores
Aritméticos
	Operador
	Uso
	Descrição
	+
	op1 + op2
	Adiciona op1 e op2
	-
	op1 - op2
	Subtrai op2 de op1
	*
	op1 * op2
	Multiplica op1 por op2
	/
	op1 / op2
	Divide op1 por op2
	%
	op1 % op2
	Resto de op1 / op2
Incremento
	Operador
	Uso
	Descrição
	++
	var++
++var
	usa a variável e depois incrementa
incrementa a variável e depois usa
	--
	var--
--var
	usa a variável e pois decrementa
decrementa a variável e depois usa
Relacionais
	Operador
	Descrição
	==
	Igual
	!=
	Diferente
	<
	Menor
	>
	Maior
	<=
	Menor ou igual
	>=
	Maior ou igual
�
Atribuição
	Operador
	Uso
	Equivale a
	=
	
	
	+=
	Op1 += op2
	Op1 = op1 + op2
	-=
	Op1 -= op2
	Op1 = op1 - op2
	*=
	Op1 *= op2
	Op1 = op1 * op2
	/=
	Op1 /= op2
	Op1 = op1 / op2
	%=
	Op1 %= op2
	Op1 = op1 % op2
	&=
	Op1 &= op2
	Op1 = op1 & op2
	|=
	Op1 |= op2
	Op1 = op1 | op2
	^=
	Op1 ^= op2
	Op1 = op1 ^ op2
	<<=
	Op1 <<= op2
	Op1 = op1 << op2
	>>=
	Op1 >>= op2
	Op1 = op1 >> op2
	>>>=
	Op1 >>>= op2
	Op1 = op1 >>> op2
�
Binários
	Operador
	Descrição
	>>
	shift binário para direita
	<<
	shift binário para esquerda
	>>>
	shift binário para direita (unsigned)
	&
	AND binário
	|
	OR binário
	^
	XOR binário
	~
	complemento binário
Lógicos
	Operador
	Descrição
	&&
	AND com curto-circuito
	||
	OR com curto-circuito
	!
	NOT
	&
	AND sem curto-circuito
	|
	OR sem curto-circuito
�
Condicional
	Operador
	Uso
	Descrição
	?:
	expressão_logica?val1:val2
	Caso a expressão lógica seja verdade o val1 será retornado, caso contrário será retornado val2
Precedência dos Operadores
Os operadores estão listados na ordem decrescente de precedência;
Os operadores na mesma linha têm a precedência igual;
Todos os operadores binários, à exceção dos operadores de atribuição, são avaliados da esquerda para direita;
	Descrição
	Operadores
	operadores do sufixo
	[ ] . () Chamada de função
	operadores unários
	!, ~, +, -, ++, --
	Criação
	(Type-cast), new
	multiplicativos
	*, /, %
	aditivos
	+, -
	SHIFT
	<<, >>, >>>
	relacional
	<, >, <=, >= instanceof
	igualdade
	==, !=
	AND binário
	&
	XOR binário
	^
	OR binário
	|
	AND lógico
	&&
	OR lógico
	||
	Condicional
	?:
	Atribuição
	+=, -=, *=, /=, %=, &=, ^=, |=, <=, <=, >>, >=, >>, =
�
	Programa(s) Demonstração
	introducao.Operadores.java
	/**
 * Demonstração do Operadores
 */
package introducao;
import util.Keyboard;
public class Operadores {
	public static void main(String[] args) {
		/* declarando e inicializando 3 variáveis inteiras */
		int i1 = 7;
		int i2 = 3;
		int i3;
		i3 = i1 + i2; // adição
		i3 = i1 - i2; // subtração
		i3 = i1 * i2; // multiplicação
		i3 = i1 / i2; // divisão inteira, pois n1 e n2 são do tipoint
		i3 = i1 % i2; // resto da divisão inteira
		/* declarando e inicializando 3 variáveis float */
		float f1 = 12.8f; // conversão explícita para float
		float f2 = 6.4f;
		float f3;
		f3 = i1 * f2; // conversão implícita para float
		f3 = f2 / i2; // divisão float, pois o numerador é float
		f3++; // incremento
		f3--; // decremento
		f1 = ++f2 + f3; // a variável i2 será incrementada antes da atribuição
		f1 = f2++ + f3; // a variável i2 será incrementada após a atribuição
		/* Operador relacional */
		System.out.println( f1 > f2 ? f1 : f2 );
		System.out.println( "f1 = " + f1 );
		System.out.println( "f2 = " + f2 );
		/* Calculo do preço de venda um produto baseado no preço de compra e
		 e no percentual de lucro */
		float preçoCompra;
		float percentualLucro;
		System.out.print( "Preço de Compra : " );
		preçoCompra = Keyboard.readFloat();
		System.out.print("Percentual de Lucro : ");
		percentualLucro = Keyboard.readFloat();
		float lucro = preçoCompra * (percentualLucro/100);
		float preçoVenda = preçoCompra + lucro;
		System.out.println("Preço de Compra : " + preçoCompra +
						 "\nPercentual de Lucro : " + percentualLucro +
						 "\nLucro : " + lucro +
						 "\nPreço de Venda : " + preçoVenda);
		int i = 10;
		System.out.println( " i " + i );
		i = i << 1;
		System.out.println( " i " + i );
		i = i >> 2;
		System.out.println( " i " + i );
		int a = 5;
		int b = 10;
		int c = a | b;
		int d = a & b;
		System.out.println( "a = " + a + "\nb = " + b +
							"\nc = " + c + "\nd = " + d);
	}
}
�
Comandos
Sequência { sequência }
Cria uma seqüência, a qual agrupa comandos e variáveis. Quando uma sequência possuir apenas um comando os operadores { e } são opcionais, caso contrários são obrigatórios e cada comando dentro da sequência deve ser terminado por “;”
�
Comando if – else
Comando de seleção, o qual permite analisar uma expressão lógica e direcionar a execução do programa. Caso a expressão lógica seja verdadeira (true) a sequência do if será executado e caso a expressão lógica seja falsa (false), e exista a cláusula else, a sequência do else será executada.
	if ( expressão_lógica )
	Sequência;
if ( expressão_lógica )
	Sequência_1;
else
	Sequência_2;
if ( expressão_lógica )
	Sequência_1;
else if ( expressão_lógica )
	Sequência_2;
else if ( expressão_lógica )
	Sequência_3;
else if ( expressão_lógica )
	Sequência_4;
else
	Sequência_5;
�
	Programa(s) Demonstração
	comandos.ComandoIF.java
	/**
 * Demonstração do comando if else
 */
package comandos;
import util.Keyboard;
public class ComandoIF {
	public static void main(String[] args) {
		/* Validando uma data */
		int dia, mes, ano;
		System.out.print("Dia : ");
		dia = Keyboard.readInt();
		System.out.print("Mês : ");
		mes = Keyboard.readInt();
		System.out.print("Ano : ");
		ano = Keyboard.readInt();
		boolean data = false;
		/* meses de 30 dias */
		if ( mes == 4 || mes == 6 || mes == 9 || mes == 11) {
			if ( dia >= 1 && dia <= 30 ) {
				data = true;
			}
		} else {
			/* meses de 31 dias */
			if ( mes == 1 || mes == 3 || mes == 5 || mes == 7 ||
				 mes == 8 || mes == 10 || mes == 12 ) {
				if ( dia >= 1 && dia <= 31 ) {
					data = true;
				}
			} else {
				/* fevereiro */
				if ( mes == 2 ) {
					if ( dia >= 1 && dia <= 28 ) {
						data = true;
					} else {
						/* 29 de fevereiro */
						if ( dia == 29 ) {
							/* Ano bissexto */
							boolean bissexto = ( (ano % 4 == 0) &&
										 (ano % 100 != 0) ) ||
										 (ano % 400 == 0);
							if ( bissexto ) {
								data = true;
							}
						}
					}
				}
			}
		}
		System.out.print(dia + "/" + mes + "/" + ano + " : ");
		if ( data )
			System.out.println("Data Válida");
		else
			System.out.println("Data Inválida");
	}
}
�
Comando switch
Compara (igualdade) uma variável ( byte, char, short ou int ) a uma relação de valores, permitindo associar comandos a cada valor da relação.
	switch (variável) {
	case valor1 	: sequência_1;
	case valor2 	: sequência2;
	...
	case valorN 	: sequênciaN;
 	[ default 		: sequênciaDefault; ]
}
Obs : O comando break normalmente é utilizado como último comando de cada sequência, indicando que, quando uma sequência for executada todas as outras serão ignoradas.
�
	Programa(s) Demonstração
	comandos.ComandoSwitch.java
	/**
 * Demonstração do comando switch
 */
package comandos;
import util.Keyboard;
public class ComandoSwitch {
	public static void main(String[] args) {
		/* Validando uma data */
		int dia, mes, ano;
		System.out.print("Dia : ");
		dia = Keyboard.readInt();
		System.out.print("Mês : ");
		mes = Keyboard.readInt();
		System.out.print("Ano : ");
		ano = Keyboard.readInt();
		boolean data = false;
		switch (mes) {
			/* meses de 30 dias */
			case 4 :
			case 6 :
			case 9 :
			case 11 :
				if ( dia >= 1 && dia <= 30 )
					data = true;
				break;
			/* meses de 31 dias */
			case 1 :
			case 3 :
			case 5 :
			case 7 :
			case 8 :
			case 10 :
			case 12 :
				if ( dia >= 1 && dia <= 31 )
					data = true;
				break;
			/* fevereiro */
			case 2 :
				if ( dia >= 1 && dia <= 28 ) {
					data = true;
				} else {
					/* 29 de fevereiro */
					if ( dia == 29 ) {
						/* Ano bissexto */
						boolean bissexto = ( (ano % 4 == 0)&&
									 (ano % 100 != 0) ) ||
									 (ano % 400 == 0);
						if ( bissexto ) {
							data = true;
						}
					}
				}
			default : data = false;
		}
		System.out.print(dia + "/" + mes + "/" + ano + " : ");
		if ( data )
			System.out.println("Data Válida");
		else
			System.out.println("Data Inválida");
	}
}
�
Comando while
Executa a sequência do comando enquanto a expressão lógica for verdadeira. Sendo que, antes de cada execução a expressão lógica é analisada.
 
	while ( expressão_lógica )
	Sequência;
	Programa(s) Demonstração
	comandos.ComandoWhile.java
	/**
 * Demonstração do comando while
 */
package comandos;
import util.Keyboard;
public class ComandoWhile {
	public static void main( String[] args ) {
		int numero;
		int fatorial;
		System.out.println("Calculo do fatorial (flag < 0)");
		System.out.print("Número : ");
		numero = Keyboard.readInt();
		while ( numero >= 0 ) {
			fatorial = 1;
			while ( numero > 1 ) {
				fatorial *= numero;
				numero--;
			}
			System.out.println( "Fatorial : " + fatorial );
			System.out.print( "Número : ");
			numero = Keyboard.readInt();
		}
		System.out.println( "Fim" );
 }
}
�
Comando do while
Executa a sequência do comando enquanto a expressão lógica for verdadeira. Sendo que, após a execução da sequência a expressão lógica é analisada.
	do
	Sequência;
while ( expressão_lógica );
	Programa(s) Demonstração
	comandos.ComandoDoWhile.java
	/**
 * Demonstração do comando do while
 */
package comandos;
import java.lang.String;
import util.Keyboard;
public class ComandoDoWhile {
	public static void main(String[] args) {
		int numero;
		int fatorial;
		System.out.println("Calculo do fatorial (flag = 0)");
		do {
			System.out.print("Número : ");
			numero = Keyboard.readInt();
			fatorial = 1;
			while (numero > 1) {
				fatorial *= numero;
				numero--;
			}
			System.out.println("Fatorial : " + fatorial);
		} while (numero != 0);
 }
}
�
Comando for
Executa a sequência do comando enquanto a expressãológica for verdadeira. Sendo que permite inicializar variável, na entrada do comando e incrementar variável a cada repetição.
	for ( expressão_inicializacao ; expressão_lógica ; expressão_incremento )
	Sequência;
	Programa(s) Demonstração
	comandos.ComandoFor.java
	/**
 * Demonstração do comando for
 */
package comandos;
import util.Keyboard;
public class ComandoFor {
	public static void main(String[] args) {
		final int inicio = 10;
		final int fim = 10;
		int resultado = 0;
		System.out.print("Tabuada de (+ x) : ");
		char tabuada = Keyboard.readChar();
		for (int i = 0; i <= inicio; i++ ) {
			for (int j = 0; j <= fim; j++) {
				switch (tabuada) {
					case '+' :
						resultado = i + j;
						break;
					case 'x' :
						resultado = i * j;
						break;
				}
				System.out.print(i + " " + String.valueOf(tabuada) + " " + j +
								 " = " + resultado + "\t");
			}
			System.out.println();
		}
 }
}
�
Comando break
Força a saída de um comando de repetição ou do comando switch
Comando continue
Força o início da próxima iteração de um comando de repetição
	Programa(s) Demonstração
	comandos.ComandoBreakContinue.java
	/**
 * Demonstração do comando break e continue
 */
package comandos;
public class ComandoBreakContinue {
	public static void main(String[] args) {
		for (int i = 0; i <= 1000 ; i++ ) {
			if ( i == 10 )
				break;
			System.out.print(i + " ");
		}
		System.out.println();
		for (int i = 0; i <= 20 ; i++) {
			if ( i <= 10 )
				continue;
			System.out.print(i + " ");
		}
 }
}
�
	Exercício(s)
	Exercício 2: Resolva os problemas abaixo com applications Java
	Problema 1: "Leia um valor inteiro representando o valor solicitado para saque num caixa eletrônico, em seguida, sabendo que o caixa está alimentado com notas de 1, 5, 10, 50 e 100 reais, calcule e escreva quantas notas de cada valor serão necessárias para atender a solicitação de saque"
Problema 2: "Leia um salário, atualize e escreva-o de acordo com a tabela abaixo"
Faixa salarial
Percentual de aumento
até 1.000,00
30%
acima de 1.000,00 e até 2.000,00
20%
acima de 2.000,00
10%
Problema 3: Ler três valores float e imprimir se estes podem ou não formar os lados de um triângulo e qual triângulo seria (Equilátero, Isóceles ou escaleno).
Observação: Para formar os lados de um triângulo cada um dos valores deve ser menor que a soma dos outros dois. Um triângulo pode ser : equilátero (3 lados iguais), isósceles (apenas 2 lados iguais) e escaleno (3 lados diferentes).
Problema 4: Leia o nome, as três notas e o número de faltas de um aluno e calcule e imprima sua situação ("Aprovado", "Reprovado por Falta" ou "Reprovado por média").
Observação: A média para aprovação é 5,0 (cinco) e o limite de faltas é 18 e a reprovação por falta sobrepõe a reprovação pode média.
Problema 5: Leia um conjunto de números inteiros, onde o flag será o valor 0 (zero) e em seguida escreva a média dos números lidos e o maior valor lido.
Problema 6: Leia (ou inicialize) um vetor com 10 elementos de números inteiros e em seguida leia um conjunto de números inteiros e para cada número lido informe se o mesmo está ou não presente no vetor.
Problema 7: Leia (ou inicialize) uma matriz 5x5 de números inteiros e em seguida escreva cada valor presente na matriz e quantas vezes o mesmo aparece na matriz.
�
Introdução a Orientação a Objetos
A metodologia orientada a objetos representa um modo muito diferente dos enfoques usuais sustentados por linguagens de programação estruturadas. Os recursos fornecidos pela metodologia orientada a objetos suportam conceitos que tornam a solução de problemas pelo computador uma atividade mais humanizada.
A programação orientada a objetos é um método relativamente novo na concepção e implementação de sistemas de software. Seus maiores objetivos são aumentar a produtividade do programador através de uma maior expansibilidade e reutilização de software, além de controlar a complexidade e o custo de manutenção do mesmo.
A programação orientada a objetos centraliza-se nos seguintes conceitos : Tipos de dados abstratos, herança e polimorfismo.
O objetivo principal da orientação a objetos é permitir que os programas sejam organizados de forma a espelhar o modo como os objetos são organizados no mundo real.
�
Tipos de Dados Abstratos
Representam a parte central da metodologia orientada a objetos. Um tipo de dado abstrato é um modelo formado por propriedades (atributos) e operações (métodos), onde estas definem o comportamento básico do mesmo. Tipo de dado abstrato permite a modelagem de entidades do mundo real de uma forma mais natural, pois estamos acostumados a lidar com "objetos" os quais possuem características "atributos" e funcionalidades "métodos".
Classe
Representa a implementação de um tipo de dado abstrato, onde a mesma possuirá a declaração dos atributos e implementação dos métodos. Uma classe representa o "molde" através do qual os objetos serão criados, assim a definição de uma classe possui todas as propriedades e funções que caracterizam o comportamento de qualquer objeto da classe.
Objeto
É a instância de uma classe possuindo valores próprios para os atributos definidos na classe.
Encapsulamento
Mecanismo utilizado com o objetivo de esconder detalhes de implementação das classes, permitindo assim, maior domínio da complexidade, pois uma classe deve ofertar apenas o que ela pode fazer e não como ela faz. Uma classe deve impedir o acesso aos seus atributos e métodos internos e disponibilizar métodos públicos, os quais representam a "real" funcionalidade da classe. Dessa forma é possível utilizar uma classe como um objeto real, pois assistimos televisão, ouvimos rádio, ..., sem ter a menor idéia de como os mesmos funcionam internamente, basta apenas saber como interagir (ligar, desligar, mudar de canal, ...) com os mesmos.
�
Mensagem
É a forma como um objeto interage com outro objeto, corresponde a chamada (execução) de um método do objeto, o que pode exigir a passagem de parâmetro(s).
Herança
É a capacidade de herdar atributos e métodos de uma classe já definida (superclasse), possibilitando estender o comportamento de uma classe adicionando novos atributos e métodos (subclasse). A grande vantagem da herança é permitir o reaproveitamento de código, pois a subclasse recebe os atributos e métodos da superclasse e permite a implementação de novas funcionalidades.
�
Orientação a Objetos em Java
Pacotes
As classes Java são organizadas em pacotes, os quais são estruturas de diretórios com a finalidade de melhor agrupar e organizar as classes. Outras vantagens obtidas com a utilização de pacotes são evitar conflito de nomes e proteger o acesso às classes. A criação de um pacote consiste na criação de uma estrutura de diretório, colocação das classes nesses diretórios e definição do pacote nas classes através do identificador package seguido do nome do pacote. Para utilizar classes é necessário importá-las através do identificador import seguido de nomeDoPacote.NomeDaClasse ou nomeDoPacote.* quando for necessário importar todas as classes do pacote (diretório).
	Programa(s) Demonstração
	oo.controleEstoque.*
�
Arquivos JAR (Java Archive) e CLASSPATH
São arquivos compactados e independentes de plataforma que agregam classes Java e arquivos utilizados por estas classes. Os applets normalmente são colocados num arquivo .jar contendo os arquivos .class, imagens e sons utilizados pelo applet, facilitando assim o download do mesmo. 
Normalmente bibliotecas de classes são distribuídas em arquivos .jar, os quais podem ser inseridos na variável CLASSPATH da máquina virtual Java, após o que as classes contidas no jar podem ser importadas (utilizadas).
O arquivo .jar usa o mesmo algoritmo de compactaçãodo programa zip, tendo a peculiaridade de possuir no diretório meta-inf o arquivo Manifest.MF, o qual possui atributos para os arquivos contidos no jar e pode indicar qual a classe main a ser executada quando o comando “java –jar arquivo.jar” for executado.
	Programa(s) Demonstração
	..\CursoJava\Standard\Fontes\jar\ControleEstoque.jar
�
Classe
Em Java uma classe é definida através da palavra reservada class, normalmente cada classe fica num arquivo fonte separado. A definição de uma classe é dividida em declaração e corpo da classe, onde na declaração são definidas a sua visibilidade, nome, superclasse e interfaces. E no corpo da classe são definidos os atributos e os métodos. Normalmente as classes possuem um tipo de método especial chamado construtor, o qual possui o mesmo nome da classe e é utilizado para instanciar objetos da classe. É possível também definir um método com a assinatura protected void finalize(), o qual será executado pelo garbage collector antes do objeto ser retirado da memória.
A definição de uma classe é feita de acordo com a sintaxe abaixo
	public
	Acesso público
	abstract
	Não pode ser instanciada
	final
	Indicação que nenhuma outra classe pode herdá-la
	class NomeDaClasse
	Nome da Classe
	extends SuperClasse
	Classe a ser estendida (Herança)
	implements Interfaces
	Interfaces a serem implementadas
	{
Corpo da Classe 
}
	
Atributos e métodos
�
	Programa(s) Demonstração
	oo.cadastroDeClientes.Cliente.java
	/**
 * Classe modelando cliente com o objetivo de demonstrar os seguintes
 * conceitos de orientação a objetos : Classe, Encapsulamento e Membros
 * (Atributos e Métodos)
 */
package oo.cadastroDeClientes;
/* Definição da classe */
public class Cliente {
	/* Corpo da classe */
	/* Atributos da classe */
	private int matrícula;	//Matrícula do cliente
	private String nome;	//Nome do cliente
	private char plano;		//Plano de assinatura do cliente
	/* Métodos da classe */
	/* Construtor */
	public Cliente() {
		super();
	}
	/* Construtor */
	public Cliente (int matrícula, String nome, char plano) {
		setMatrícula(matrícula);
		setNome(nome);
		setPlano(plano);
	}
	/* Métodos para leitura e escrita dos atributos */
	public void setMatrícula (int matrícula) {
		this.matrícula = matrícula;
	}
	public void setNome (String nome) {
		this.nome = nome;
	}
	public void setPlano (char plano) {
		this.plano = plano;
	}
	public int getMatrícula () {
		return matrícula;
	}
	public String getNome () {
		return nome;
	}
	public char getPlano () {
		return plano;
	}
	/* Método que escreve os atributos do cliente na saída padrão */
	public void escreve() {
		System.out.print(matrícula + " | " + nome);
		if (plano == '1')
			System.out.println(" | 20 horas");
		else if (plano == '2')
			System.out.println(" | Horas livres");
		else
			System.out.println(" | Plano Inválido");
	}
}
�
Encapsulamento
O encapsulamento é feito através da definição da visibilidade de classes, atributos e métodos. A visibilidade é definida pelos identificadores: private, protected e public. Quando nenhum destes identificadores é usado a visibilidade definida é package. Classes somente podem possuir visibilidades public ou package.
	Identificador
	Visibilidade
	public
	Qualquer classe de qualquer pacote.
	private
	Apenas na própria classe.
	protected
	Na própria classe, sub-classes e classes no mesmo pacote.
	package
	Classes do mesmo pacote.
Observação: Normalmente os atributos de uma classe devem ser privados e o acesso (atribuição e leitura) destes devem ser feitos através de métodos públicos. É comum também a existência de métodos privados com a finalidade de auxiliar os métodos públicos, esses métodos privados são comumente chamados de métodos de serviço. Os métodos públicos representam o que a classe oferece.
�
Membros de Classe
Os atributos e métodos de uma classe são chamados de membros da classe e os mesmo são definidos no corpo da classe.
Atributos
São as variáveis da classe podendo ser de tipos primitivos ou outras classes. Onde as mesmas são definidas de acordo com a sintaxe abaixo.
	
Visibilidade Tipo nomeDoAtributo [ = ValorInicial ];
�
Métodos
Cada método possui uma assinatura e corpo, onde a assinatura é definida por: Visibilidade, Tipo de Retorno, Nome e Lista de Parâmetros. E o Corpo representa a implementação do método.
No corpo de um método o identificador this pode ser utilizado para fazer referência a uma variável da classe, pois é comum que parâmetros possuam nomes iguais a variáveis de classe, dessa forma o identificador this serve para resolver conflitos de nomes entre parâmetros e variáveis da classe. Na verdade o identificador this é uma referência ao objeto corrente, ou seja, aquele no qual o método está sendo executado. E this() representa uma chamada ao construtor da classe.
A declaração de um método é feita de acordo com a sintaxe abaixo.
	Visibilidade TipoDeRetorno/void nomeDoMétodo ([Lista de Parâmetros]) 
{
	Corpo do método
	[ return expressão_de_retorno ]
}
Sendo que, quando o método não necessitar retorna valor, no lugar do TipoDeRetorno deve ser utilizado o identificador void e a expressão "return expressão_de_retorno" não deverá existir no corpo do método.
Observação: Em Java todo parâmetro é passado por valor para um método.
	Programa(s) Demonstração
	oo.cadastroDeClientes.Cliente.java
�
 Objeto
Um objeto é criado a partir de uma classe através do identificador new seguido do construtor da classe. O nomeDoObjeto na verdade é uma referência para o objeto criado.
	
TipoDoObjeto nomeDoObjeto [= new Construtor([Parâmetros])];
�
Mensagem
É a chamada a um método através do nome da classe ou objeto seguido de ".", nome do método e lista de parâmetros entre parêntesis.
	NomeDaClasse.nomeDoMétodo([ Lista de Parâmetros ])
	nomeDoObjeto.nomeDoMétodo([ Lista de Parâmetros ])
	Programa(s) Demonstração
	oo.cadastroDeClientes.ClienteApp
	/**
 * Application Demonstrandos as classes : Cliente, ClientePF, ClientePJ e
 * Clientes
 */
package oo.cadastroDeClientes;
public class ClienteApp {
	public static void main (String[] args) {
		/* Declarando e instanciando um objeto do tipo Clientes */
		Clientes clientes = new Clientes(50);
		/* Declarando um objeto do tipo Cliente */
		Cliente cliente;
		/*Instanciando um objeto do tipo Cliente */
		cliente = new Cliente(1, "Pelé", '2');
		/* inserindo em clientes */
		clientes.insere(cliente);
		cliente = new Cliente(2, "Guga", '1');
		clientes.insere(cliente);
		cliente = new Cliente(3, "Popó", '2');
		clientes.insere(cliente);
		cliente = new Cliente(4, "Senna", '2');
		clientes.insere(new Cliente(5,"Anderson",'8'));
		System.out.println(clientes.quantidade() + " Clientes");
		clientes.escreve();
		/* Instanciando um objeto do tipo ClientePF */
		ClientePF clientePF = new ClientePF(5, "José Maria",
							 '1', "661.764.335-68");
		clientePF.escreve();
		clientes.insere(clientePF);
		/* Instanciando um objeto do tipo ClientePJ */
		ClientePJ clientePJ = new ClientePJ(6, "Infonet",
							 '2', "99.999.999.9999");
		clientePJ.escreve();
		clientes.insere(clientePJ);
		System.out.println("\nTodos os Clientes");
		/*
		 * Exemplo de Polimorfismo, pois os métodos escreve() de
		 * ClientePF e ClientePJ são chamados automaticamente
		 */
		System.out.println(clientes.quantidade() + " Clientes");
		clientes.escreve();
		/* Conversão explícita de Cliente ClientePJ */
		cliente = new ClientePJ(6, "Sefaz",'1', "99.999.999.9999");
		System.out.println(((ClientePJ)cliente).cgc());
	}
}
�
 Sobrecarga de Métodos
Em Javaé possível que uma classe possua métodos com o mesmo nome, desde que, as listas de parâmetros sejam diferentes em quantidade, tipo ou em ordem. Esse tipo de polimorfismo é chamado de sobrecarga de métodos.
Observação: O tipo de retorno não diferencia métodos, ou seja, não é possível definir métodos com nome iguais e lista de parâmetros iguais, mesmo que possuam tipos de retorno diferentes.
	Programa(s) Demonstração
	oo.sobreCarga.*
	/**
 * Classe com o objeto de demonstrar a sobrecarga de métodos
 */
package oo.sobreCarga;
public class SobreCarga {
	public static float media (int a, int b) {
		return ( a + b ) / 2;
	}
	public static float media (float a, float b) {
		return ( a + b ) / 2;
	}
	public static float media (int a, int b, int c) {
		return ( a + b + c ) / 3;
	}
	public static float media ( float a, float b, float c ) {
		return ( a + b + c ) / 3;
	}
	/* Não é possível ter um método com apenas o tipo de retorno diferente */
/*
	public static double media ( float a, float b, float c ) {
		return ( a + b + c) / 3;
	}
*/
}
	/**
 * Classe com o objeto de demonstrar a sobrecarga de métodos
 */
package oo.sobreCarga;
public class SobreCargaApp {
	public static void main (String[] args) {
		System.out.println( SobreCarga.media( 5, 7 ) );
		System.out.println( SobreCarga.media( 5, 7, 3 ) );
		System.out.println( SobreCarga.media( 8f, 2f ) );
		System.out.println( SobreCarga.media( 5.3f, 7.9f, 3.1f ) );
		/* Conversão explicita pra float */
		System.out.println( SobreCarga.media( 8f, 4 ) );
	}
}
�
Herança
Para que uma classe Java (SubClasse) herde atributos e métodos de outra classe Java (SuperClasse) basta que na declaração da SubClasse o identificador extends seja seguido do nome da SuperClasse. Assim todos os membros "públicos" serão herdados pela SubClasse. Uma SubClasse apenas pode possuir uma SuperClasse, ou seja, herança múltipla não é permitida em Java. Caso métodos tenham sido redefinidos e seja necessário chamar os métodos da SuperClasse o identificador super deve ser utilizado (super.MetodoDaSuperClasse()), sendo que super() representa o construtor da SuperClasse. Toda classe Java é automaticamente subclasse de Object.
�
	Programa(s) Demonstração
	oo.cadastroDeClientes.*
	/**
 * Classe modelando cliente com o objetivo de demonstrar os seguintes
 * conceitos de orientação a objetos : Classe, Encapsulamento e Membros
 * (Atributos e Métodos)
 */
package oo.cadastroDeClientes;
/* Definição da classe */
public class Cliente {
	/* Corpo da classe */
	/* Atributos da classe */
	private int matrícula;	//Matrícula do cliente
	private String nome;	//Nome do cliente
	private char plano;		//Plano de assinatura do cliente
	/* Métodos da classe */
	/* Construtor */
	public Cliente() {
		super();
	}
	/* Construtor */
	public Cliente (int matrícula, String nome, char plano) {
		setMatrícula(matrícula);
		setNome(nome);
		setPlano(plano);
	}
	/* Métodos para leitura e escrita dos atributos */
	public void setMatrícula (int matrícula) {
		this.matrícula = matrícula;
	}
	public void setNome (String nome) {
		this.nome = nome;
	}
	public void setPlano (char plano) {
		this.plano = plano;
	}
	public int getMatrícula () {
		return matrícula;
	}
	public String getNome () {
		return nome;
	}
	public char getPlano () {
		return plano;
	}
	/* Método que escreve os atributos do cliente na saída padrão */
	public void escreve() {
		System.out.print(matrícula + " | " + nome);
		if (plano == '1')
			System.out.println(" | 20 horas");
		else if (plano == '2')
			System.out.println(" | Horas livres");
		else
			System.out.println(" | Plano Inválido");
	}
}
	/**
SubClasse de Cliente com o objetico de demonstrar os seguintes conceitos de
orientação a objetos : Herança, Redefinição de Métodos, Polimorfismo e
SobreCarga de Métodos
 */
package oo.cadastroDeClientes;
public class ClientePF extends Cliente {
	private String cpf;
	/* Construtores */
	public ClientePF () {
		super();
	}
	public ClientePF (int matrícula, String nome, char plano) {
		/* Chamando o construtor da superclasse (Cliente) */
		super( matrícula, nome, plano );
	}
	public ClientePF (String cpf) {
		/* Chamando o construtor da superclasse (Cliente) */
		super(0, “”, ‘1’);
		setCPF( cpf );
	}
	public ClientePF (int matrícula, String nome, char plano, String cpf) {
		/* Chamando o construtor da superclasse (Cliente) */
		super(matrícula, nome, plano);
		setCPF ( cpf );
	}
	/* Métodos para leitura e escrita dos atributos */
	public void setCPF (String cpf) {
		this.cpf = cpf;
	}
	public String getCPF () {
		return cpf;
	}
	/* Redefinição do método escreve da superclasse Cliente */
	public void escreve () {
		System.out.println(“*****************************”);
		System.out.println(“Cliente Pessoa Física”);
		/* Chamndo escreve da superclasse */
		super.escreve();
		System.out.println(“cpf : “ + cpf);
		System.out.println(“*****************************”);
	}
}
�
	/**
 * SubClasse de Cliente com o objetico de demonstrar os seguintes conceitos de
 * orientação a objetos : Herança, Redefinição de Métodos, Polimorfismo e
 * SobreCarga de Métodos
 */
package oo.cadastroDeClientes;
public class ClientePJ extends Cliente {
	private String cgc;
	public ClientePJ () {
		super();
	}
	public ClientePJ (int matrícula, String nome, char plano, String cgc) {
		super(matrícula, nome, plano);
		this.cgc = cgc;
	}
	public void cgc (String cgc) {
		this.cgc = cgc;
	}
	public String cgc () {
		return cgc;
	}
	public void escreve () {
		System.out.println("*****************************");
		System.out.println("Cliente Pessoa Jurídica");
		super.escreve();
		System.out.println("cgc : " + cgc);
		System.out.println("*****************************");
	}
}
�
Redefinição de Métodos
É possível que métodos herdados sejam redefinidos, ou seja, implementados de uma forma diferente bastando para isso que seja criado um método com a mesma assinatura que o método a ser redefinido (Caso o método herdado seja final não é possível redefini-lo).
	Programa(s) Demonstração
	oo.cadastroDeClientes.*
�
Classes e Métodos Abstratos
Numa hierarquia de classes, quanto mais alta for uma classe, mais abstrata é sua definição. Uma classe no topo (raiz) de uma hierarquia de classes define o comportamento e atributos comuns a todas as subclasses, e quando mais as classes estiveram próximas das folhas (abaixo) na hierarquia de classes, mas especializadas elas serão. Assim é possível definir classes em Java que sirvam apenas como base para uma hierarquia de classe, sendo que classes abstratas não podem ser instanciadas. A sua utilidade é apenas servir como superclasse, onde as subclasses irão acrescentar e redefinir seus métodos a medida da necessidade.
Para definir uma classe como abstrata basta colocar o identificador abstract na definição da mesma.
�
	Programa(s) Demonstração
	oo.classeAbstrata.*
	/**
 * Classe asbstrata pessoa
 */
package oo.classeAbstrata;
public abstract class Pessoa {
	private String identificacao;
	private String nome;
	private String dataNascimento;
	private char sexo;
	public Pessoa (String id, String nome, String datNasc, char sexo) {
		this.nome = nome;
		this.dataNascimento = datNasc;
		this.sexo = sexo;
	}
	public void id (String id) {
		this.identificacao = id;
	}
	public void nome (String nome) {
		this.nome = nome;
	}
	public void dataNascimento (String dataNascimento) {
		this.dataNascimento = dataNascimento;}
	public void sexo (char sexo) {
		this.sexo = sexo;
	}
	public String id () {
		return identificacao;
	}
	public String nome () {
		return nome;
	}
	public String dataNascimento () {
		return dataNascimento;
	}
	public char sexo () {
		return sexo;
	}
	public String toString () {
		return(nome + " | " + dataNascimento + " | " + sexo);
	}
}
�
Classes, Métodos e Variáveis Final
É possível definir uma classe, método ou variável como final, significando que :
Classes final não podem ser herdadas
Métodos final não podem ser redefinidos
Variáveis final não podem ter seu conteúdo alterado.
Para definir uma classe, método ou variável como final, basta acrescentar o identificador final na definição dos mesmos.
Observação: Métodos final são executados com maior eficiência pela JVM.
Observação: Todos os métodos de uma classe final também são final, independente de possuir o identificador final na sua declaração.
Observação: Algumas das classes da API Java são final tais como : java.lang.String, java.lang.Math, java.net.InetAddress, ...
	Programa(s) Demonstração
	oo.classeFinal.MinhaString
	/**
 * Classe que tentar herdar de String, mas não é possível, pois
 * String é final e não pode ser superclasse
 * Será gerado erro de compilação
 */
package oo.classeFinal;
public class MinhaString /* extends String */ {
 public MinhaString() {
 }
}
�
Membros Estáticos
Atributos e métodos podem ser de classe ou de objeto (instância). A diferença entre ambos está no fato de que os membros de instância são propriedades de cada objeto e os membros de classe são compartilhados por todos os objetos. Assim quando houver a necessidade de compartilhar o conteúdo de um atributo com todos os objetos de uma classe, esse atributo deverá ser estático. Já os métodos estáticos possuem a características de poder serem chamados diretamente através da classe, sem a necessidade de instanciar um objeto. Os métodos estáticos somente podem utilizar atributos estáticos. Para definir um membro como estático basta colocar o identificador static na sua declaração.
	Programa(s) Demonstração
	oo.membrosEstáticos.*
	/**
 * Classe para demonstrar membros estáticos
 */
package oo.membrosEstaticos;
public class MembrosEstaticos {
	/* Atributo estático */
	private static int contObjetos = 0;
	public MembrosEstaticos () {
		contObjetos++;
	}
	/* Método estático */
	public static void numeroDeOjetos () {
		System.out.println("Número de objetos instanciados : " + contObjetos);
	}
}
	/**
 * Application para demonstrar membros estáticos
 */
package oo.membrosEstaticos;
public class MembrosEstaticosApp {
	public static void main (String[] args) {
		for (int i = 1; i <= 10; i++) {
			MembrosEstaticos me = new MembrosEstaticos();
			/* chamada ao método estático */
			me.numeroDeOjetos();
		}
		/* chamada ao método estático */
		MembrosEstaticos.numeroDeOjetos();
	}
}
�
Classes Internas
São classes definidas dentro de outras classes. Normalmente são utilizadas para simular a estrutura de dados conhecida como registro.
Observação: As classes internas geram arquivos .class diferentes sendo que o nome segue o seguinte formato : Classe$ClasseInterna.class
	Programa(s) Demonstração
	oo.classeInterna.*
	/**
 * Classe Alunos contendo a classe interna Aluno
 */
package oo.classeInterna;
public class Alunos {
	private Aluno[] alunos;
	private int posNovoAluno = 0;
	public Alunos() {
		alunos = new Aluno[10];
	}
	public void insere (int mat, String nome, float n1, float n2, float n3)	{
		alunos[posNovoAluno] = new Aluno(mat, nome, n1, n2,n3);
		posNovoAluno++;
	}
	public void escreve () {
		String linha = "****************************************************";
		System.out.println(linha);
		for (int i = 0; i < posNovoAluno; i++) {
			alunos[i].escreve();
		}
		System.out.println(linha);
	}
	/* Classe Interna : Aluno */
	class Aluno {
		int matricula;
		String nome;
		float nota1, nota2, nota3;
		Aluno (int mat, String nome, float n1, float n2, float n3) {
			this.matricula = mat;
			this.nome = nome;
			this.nota1 = n1;
			this.nota2 = n2;
			this.nota3 = n3;
		}
		void escreve() {
			String linha = "_________________________________________________";
			System.out.println(linha +
							 "\nMatrícula : \t" + matricula +
							 "\nNome : \t" + nome +
							 "\nNotas : \t" + nota1 + "\t" + nota2 + "\t" +
												nota3 +
							 "\n" + linha);
		}
	}
}
�
Interfaces
Representam a definição de comportamentos esperados na definição de classes, contendo apenas definições de métodos abstratos e constantes, ou seja, não possuem variáveis de instância ou implementação de métodos.
A definição de uma interface é feita semelhante a uma classe, sendo que no lugar do identificador class é usado interface. Uma interface não pode ser instanciada, seu objetivo é definir um modelo de comportamento abstrato para classes. Para que uma classe implemente uma interface, na definição da classe deve ser colocado o identificador implements seguido da lista de interfaces separadas por vírgulas. Quando uma classe implementa uma interface, é obrigado a essa classe implementar todos os métodos definidos na interface e a classe pode acessar qualquer constante definida na interface.
	Programa(s) Demonstração
	oo.classeAbstrata. *
	
/**
 * Interface modelando as operações de verificação da situação final
 * de alunos
 */
package oo.classeAbstrata;
public interface SituacaoAcademica {
	public static final float MEDIA = 5.0f;
	public static final int FALTAS = 18;
	public static final String AP = "Aprovado";
	public static final String RF = "Reprovado por Falta";
	public static final String RM = "Reprovado por Média";
	public abstract void faltas (int faltas);
	public abstract void notas (float n1, float n2, float n3);
	public abstract void nota1 (float n);
	public abstract void nota2 (float n);
	public abstract void nota3 (float n);
	public abstract String situacaoFinal ();
	public abstract float media ();
	public abstract int faltas ();
	public abstract float nota1 ();
	public abstract float nota2 ();
	public abstract float nota3 ();
}
�
Polimorfismo
Em Java todo objeto de uma subclasse pode ser tratado como um objeto da superclasse, e isso permite que objetos sejam tratados de forma genérica dentro de uma hierarquia de classe. É possível também realizar uma conversão explicita de um objeto de uma classe para outra, essa operação é conhecida como typecast e para isso é necessário colocar o tipo da classe, entre parêntesis antes do objeto a ser convertido: (Classe) Objeto. Sendo que as classes origem e destino da conversão devem ter relação de herança.
Obaservação : O typecast de uma subclasse para uma superclasse é automático e garantido, mas o inverso não é garantido e é necessário o typecast explícito.
É possível verificar se um objeto é de uma determinada classe através do operador instanceof.
	Programa(s) Demonstração
	oo.cadastroDeClientes.*
�
Tratamento de Exceções
Uma exceção em Java é um sinal que alguma condição excepcional aconteceu. Por exemplo, solicitação de abertura de um arquivo não encontrado, índice de um array fora de faixa ou uma conexão de rede perdida. Verificações com recursos convencionais de programação por essas situações indesejadas, normalmente levam a programas de difícil compreensão e manutenção, pois é comum haver mais código tratando tais situações, que código desempenhando realmente o objetivo do programa. Java prover um mecanismo para tratar de forma sistemática essas situações indesejadas denominado tratamentode exceções.
Exceções em Java são objetos e a hierarquia de classe possui diversas classes representando exceções. O uso da API Java, em muitos casos, exige o tratamento dessas exceções para verificar as potenciais situações de erros na execução dos programas.
Esse mecanismo é baseado no paradigma Tentar-e-Capturar (try-and-catch), onde, quando um comando puder gerar exceções, o mesmo será tentado (executado) e caso a exceção ocorra, a mesma será capturada.
Para tratar exceções à linguagem Java fornece a seguinte estrutura de comandos:
	try {
	/* Comandos do Try */
} catch ( TipoDaExceção1 ObjetoDaExceção1 ) {
	/* Tratamento da Exceção1*/
} ... {
} catch ( TipoDaExceção2 ObjetoDaExceção2 ) {
	/* Tratamento da Exceção2*/
} finally {
	/* Comandos do Finally*/
}
, onde :
	1º
	Os Comandos do Try serão executados
	2º
	Caso ocorram exceções, o Tratamento da Exceção ocorrida será executado
	3º
	Os Comandos do Finally serão executados
Observações
Podem existir diversos catchs.
Apenas uma cláusula Finally pode ser usada por try.
Assim que um tratamento de exceção for executado os demais serão ignorados.
Os Comandos do Finally sempre serão executados.
Assim como qualquer classe uma exceção deve ser importada para ser usada.
Caso um método possa gerar uma exceção é possível que na definição do mesmo seja utilizado o identificador throws seguido da lista das possíveis exceções geradas, dessa forma fica "obrigado" (Existem exceções que não obrigam) ao usuário do método, tratar tais exceções. Ainda assim é possível o levantamento explícito de uma exceção através do identificador throw seguido de new e o construtor da classe da exceção.
	Programa(s) Demonstração
	oo.tratamentoDeExcecoes.*
	
/**
 * Classe representando um array de inteiros, com o objetivo de demonstrar
 * Tratamento de Exceções
 */
package oo.tratamentoDeExcecoes.arrayDeInteiros;
import java.lang.NegativeArraySizeException;
import java.lang.ArrayIndexOutOfBoundsException;
import java.lang.ArithmeticException;
public class ArrayDeInteiros {
	private int[] array;
	int posNovo ;
	public ArrayDeInteiros() {
		posNovo = 0;
		array = new int[10];
	}
	/* Obrigando o usuário do método a capturar e tratar a exceção */
	public ArrayDeInteiros( int tam ) throws NegativeArraySizeException {
		posNovo = 0;
		array = new int[tam];
	}
	public ArrayDeInteiros( int[] array ) {
		this.array = array;
	}
	/* Personalizando a mensagem da exceção e lançando-a */
	public void insere ( int pos, int valor )
				throws ArrayIndexOutOfBoundsException {
		try {
			array[pos] = valor;
		} catch ( ArrayIndexOutOfBoundsException e ) {
			String msg = " Erro-> Posição inválida do array : " + pos;
			throw new ArrayIndexOutOfBoundsException(msg);
		}
	}
	/* Personalizando a mensagem da exceção e lançando-a */
	public void insere ( int valor )
				throws ArrayIndexOutOfBoundsException {
		try {
			array[posNovo] = valor;
			posNovo++;
		} catch ( ArrayIndexOutOfBoundsException e ) {
			String msg = e.getMessage() +
			" Erro-> quantidade máxima de elementos encontrada " + array.length;
			throw new ArrayIndexOutOfBoundsException(msg);
		}
	}
	/* Capturando e tratando a exceção */
	public float media (int posInicial, int posFinal)
						throws ArrayIndexOutOfBoundsException,
							 ArithmeticException {
		float soma = 0;
		float media = 0;
		int quantElementos = (posFinal - posInicial + 1);
		if ( quantElementos == 0 ) {
			throw new DivideByZeroException();
		}
		try {
			for (int i = posInicial; i <= posFinal; i ++) {
				soma += array[i];
			}
			media = ( soma / quantElementos );
		} catch (ArrayIndexOutOfBoundsException e1 ) {
			String msg = "Erro: Intervalo[" + posInicial + "..." + posFinal +
						 "] Inválido";
			throw new ArrayIndexOutOfBoundsException(msg);
		} catch ( ArithmeticException e2 ) {
			String msg = "Divisao por zero";
			throw new ArrayIndexOutOfBoundsException(msg);
		}
		return media;
	}
	public float media () {
		try {
			return media(0, array.length - 1);
		} catch ( DivideByZeroException e ) {
			System.out.println("Erro :" + e.getMessage());
		} finally {
			return 0;
		}
	}
	public String toString() {
		StringBuffer sb = new StringBuffer();
		sb.append("[");
		for (int i = 0; i < (array.length - 1); i ++) {
			sb.append(array[i] + ",");
		}
		/* Caso o tamanho do array seja 0 */
		try {
			sb.append(array[array.length - 1]);
		} catch (ArrayIndexOutOfBoundsException e) {
			/* */
		};
		sb.append("]");
		return sb.toString();
	}
	public void escreve () {
		System.out.println( toString() );
	}
	/* Exemplo de throws com uma exceção que obriga o seu tratamento*/
	public void preenche (int valor) throws Exception {
		for (int i = 0; i < array.length; i ++) {
			array[i] = valor;
		}
	}
}
�
	package oo.tratamentoDeExcecoes.arrayDeInteiros;
public class DivideByZeroException extends ArithmeticException {
	public DivideByZeroException() {
		super("Divisão por zero.");
	}
	public DivideByZeroException(String msg) {
		super(msg);
	}
}
	/**
 * Application demonstrando o uso da classe ArrayDeInteiros
 */
package oo.tratamentoDeExcecoes.arrayDeInteiros;
public class ArrayDeInteirosApp {
 public static void main(String[] args) {
		int[] n = {6,1,2,3,4,5,6,7,8,9} ;
		ArrayDeInteiros inteiros = new ArrayDeInteiros( n );
		inteiros.escreve();
		try {
			inteiros.insere(0,0);
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println( e.getMessage() );
		}
		inteiros.escreve();
		try {
			inteiros.insere(-1,0);
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println( e.getMessage() );
		}
		try {
			System.out.println(inteiros.media(2,1));
		} catch ( Exception e ) {
			System.out.println( e.getMessage() );
		}
		try {
			inteiros.preenche(5);
		} catch (Exception e) {}
		inteiros.escreve();
 }
}
�
JavaDoc
JavaDoc é uma ferramenta para geração de documentação de classes, distribuída com o jdk (Java Development Kit), sendo que, processa classes java e transforma os comentários /**...*/ em documentos html, os quais possibilitam um "fácil" entendimento e uso das classes (API) documentadas. Para que a documentação seja gerada adequadamente tags reconhecidas pelo JavaDoc devem ser inseridas nos comentários. 
	Tag
	Descrição
	@author
	autor
	@version
	versão
	@param
	parâmetro do método
	@return
	retorno do método
	@exception
	exceção
	@see
	veja também
�
	Programa(s) Demonstração
	controleEstoque.*
	/**
 * @author José Maria Rodrigues Santos Junior
 * zemaria@infonet.com.br - www.unit.br/zemaria
 *
 */
package oo.controleDeEstoque.cliente;
import oo.controleDeEstoque.util.Registro;
import oo.controleDeEstoque.util.Endereco;
/**
 * Classe representando um cliente
 * @see oo.controleDeEstoque.util.Registro
 * @see oo.controleDeEstoque.util.Endereco
 * @see oo.controleDeEstoque.cliente.DataAniversario
 */
public class Cliente extends Registro {
	/** data de aniversário */
	public	DataAniversario aniv;
	/** telefone */
	private String fone;
	/** observacao */
	private String obs;
	/** endereço */
	public Endereco end;
	/**
	 * Construtor da classe
	 * @param cod código do cliente
	 * @param nome nome do cliente
	 * @param end endereço do cliente
	 * @param aniv data de aniversário
	 * @param fone telefone
	 * @param obs observação
	 */
	public Cliente (int cod, String nome, Endereco end,
					DataAniversarioaniv,
					String fone, String obs) {
		super(cod,nome);
		this.end 	= end;
		this.aniv 	= aniv;
		this.fone 	= fone;
	}
	/**
	 * atribui o nome
	 * @param nome nome do cliente
	 */
	public void nome (String nome) {
		desc(nome);
	}
	/**
	 * obtem o nome
	 * @return nome do cliente
	 */
	public String nome () {
		return super.desc();
	}
	/**
	 * obtem a data de aniversário
	 * @return data de aniversário
	 * @see controleDeEstoque.cliente.DataAniversario
	 */
	public DataAniversario dataAniversario () {
		return aniv;
	}
	/**
	 * Retorna a representação string do objeto
	 * @return objeto como string
	 */
	public String toString () {
		return "[" + chave() + ", " + desc() + ", " + end + ", " + aniv +
				", " + fone + "]";
	}
}
	Comando JavaDoc para geração da documentação das classes do exemplo, executado no diretório "C:InfoNet\Treinamento"
	C:\devtools\jdk1.3\bin\javadoc.exe -d docs -version -author java\oo\controleDeEstoque\util\Registro.java java\oo\controleDeEstoque\util\Endereco.java java\oo\controleDeEstoque\util\Arquivo.java java\oo\controleDeEstoque\produto\Produtos.java java\oo\controleDeEstoque\produto\Produto.java java\oo\controleDeEstoque\fornecedor\Fornecedores.java java\oo\controleDeEstoque\fornecedor\Fornecedor.java java\oo\controleDeEstoque\fornece\Fornecimentos.java java\oo\controleDeEstoque\fornece\Fornece.java java\oo\controleDeEstoque\cliente\DataAniversario.java java\oo\controleDeEstoque\cliente\Clientes.java java\oo\controleDeEstoque\cliente\Cliente.java java\oo\controleDeEstoque\CliForPro.java
	Site(s)
	http://java.sun.com/products/jdk/javadoc/index.html#javadoc1.3documents
�
Code Conventions
Um fator determinante na qualidade de um programa é como o mesmo está escrito, dessa forma, veremos algumas regras que devem ser seguidas para padronizar a escrita de programas em Java a fim de evitar dificuldades na leitura dos mesmo, regras estas extraídas de publicação da própria Sun como proposta para a padronização da escrita de programas em Java.
	Regras de Padronização na Escrita de Programas Java
	O conteúdo de arquivos fontes JAVA segue a seguinte ordem:
Comentários iniciais
Parâmetros de Pacotes (package) e importação (import)
Declaração de Classes (class) ou Interfaces (interface)
	Todo programa JAVA deve começar com um comentário contendo : identificação do programador, data de atualização, informação de direitos autorais e uma breve descrição do objetivo do programa.
	A tabela a seguir descreve os componentes da declaração de uma classe ou interface e indica em qual ordem os mesmos devem aparecer.
1	Comentário de documentação da Classe/Interface 
2	Parâmetro class ou interface
3	Comentário de implementação da classe/interface
4	Variáveis de classe (static) na ordem : public, protected e private
5	Variáveis de instância, na ordem : public, protected e private
6	Construtores
7	Métodos. Os quais devem ser agrupados por funcionalidade
	Quatro espaços devem ser usados como unidade de endentação (Tab Space = 4) 
	Uma linha não deve possuir mais de 80 caracteres
	Quando uma expressão não couber inteiramente em uma linha, a mesma deve ser quebrada seguindo os seguintes princípios :
Quebrar após uma vírgula
Quebrar após um operador
Quebrar preferencialmente em parênteses de nível mais alto
Alinhar a nova linha de acordo com a expressão na linha anterior
	Linhas em branco facilitam a leitura de programas, pois delimitam seções de código relacionadas logicamente. 
	Cada palavra dos identificadores de classes deve começar com letras maiúsculas
	Identificadores de pacotes, métodos e variáveis/objetos devem começar com letras minúsculas, sendo que, quando possuir outras palavras, às mesmas deverão começar com letra maiúscula
	Identificadores de constantes devem ser escritos em letras maiúsculas e as palavras separadas por "_"
	Programa(s) Demonstração
	oo.controleEstoque.*
	Site(s)
	http://java.sun.com/docs/codeconv/index.html
�
API Java
A API Java é bastante extensa. O JavaDoc da API Java é a melhor referência para o programador Java.
Os principais pacotes são :
	Pacote
	Descrição
	java.applet
	Applets
	java.awt
	Interface com usuário
	java.beans
	JavaBeans
	java.io
	Entrada e Saída de Dados
	java.lang
	Classes fundamentais à programação Java
	java.math
	Operações matemáticas
	java.net
	Implementação de aplicações de rede
	java.rmi
	Chamada Remota de Métodos
	java.security
	Segurança
	java.sql
	Acesso a Banco de Dados
	java.text
	Formatação de texto, datas e números
	java.util
	Classes utilitárias. As principais representam estrutura de dados.
	javax.accessibility
	Acessibilidade
	javax.naming
	Serviço de Acesso de Nomes
	javax.rmi
	RMI-IIOP
	javax.sound
	Som - MIDI (Musical Instrument Digital Interface)
	javax.swing
	Interface Gráfica com o usuário
�
java.lang
Contém classes básicas para a programação Java e suas classes não precisam ser importadas, pois todo o pacote java.lang é importado automaticamente por qualquer classe Java.
	Classe
	Descrição
	System
	Representa o sistema no qual as aplicações são executadas.
	Runtime
	Representa o ambiente de execução.
	Object
	Superclasse de toda classe Java (Raiz da hierarquia de classe), ou seja, qualquer objeto Java é um Object.
	Class
	Representação de classes e interface na execução de programas Java. Útil para extrair em tempo de execução informações sobre objetos, tais como : atributos, métodos, superclasse, etc.
	String
StringBuffer
	Classes para tratamento de cadeias de caracteres, sendo que a classe String não permite alteração na cadeia de caracteres armazenados.
	Classes Wrappers
	Classes que encapsulam os tipos primitivos, sendo elas : Boolean, Byte, Character, Double, Float, Integer, Long e Short.
	Math
	Operações matemáticas
�
	Programa(s) Demonstração
	api.java.lang.JavaLangSystem
	/* @author José Maria R S Junior
 * zemaria@unitnet.com.br / www.unit.br/zemaria
 *
 * Aplicação para demonstrar as principais classes do pacote java.lang
 * Math, Object, String, StringBuffer, System, Execptions e Wrappers
 *
 **/
package api.java.lang;
import java.util.Properties;
import java.util.Enumeration;
import java.io.IOException;
public class JavaLangSystem {
	public static void main (String[] args) {
		/* Classe System */
		/* Imprindo na saída padrão */
		System.out.println("Olá Mundo");
		/* Obtendo e imprimindo informações do Sistema */
		Properties prop = System.getProperties();
		Enumeration nomesProp = prop.propertyNames();
		while (nomesProp.hasMoreElements()) {
			String nomeProp = nomesProp.nextElement().toString();
			String valorProp = System.getProperty(nomeProp);
			System.out.println(nomeProp + " = " + valorProp);
		}
		/* Executando o Garbage Collector */
		System.gc();
	}
}
�
	Programa(s) Demonstração
	api.java.lang.JavaLangObject
	package api.java.lang;
public class JavaLangObject {
	/* Classe demonstrando o método equals */
	static class Objeto {
		String chaveA;
		String chaveB;
		Objeto ( String ca, String cb ) {
			chaveA = ca;
			chaveB = cb;
		}
		public boolean equals ( Objeto obj ) {
			return 	chaveA.equals( obj.chaveA ) &&
					chaveB.equals( obj.chaveB );
		}
		public String toString () {
			return "[" + chaveA + ", " + chaveB + "]";
		}
	}
	public static void main (String[] args) {
		Objeto obj1 = new Objeto( "valor A", "valor B" );
		Objeto obj2 = new Objeto( "valor A", "valor B" );
		Objeto obj3 = new Objeto( "A", "B" );
		Objeto obj4 = obj1;
		System.out.println( obj1.equals( obj2 ) );
		System.out.println( obj1.equals( obj3 ) );
		System.out.println(