Fundamentos da Programação Java em

Capitulo I - Fundamentos e Operações
Básicas
Vamos ser obrigados em alguns momentos colocar métodos e classes antes mesmo
de explicar o que significam. Por isto, se vocês não sabem o que significa uma classe ou um
método e nem sabe para que servem, ignore-os durante os capitulo I e II. É suficiente saber
apenas que os programas são executados nestas estruturas. A classe serve para guardar
dados e métodos e métodos operam sobre estes dados. A classe está sempre identificada
pelo comando "class" e método terá ao lado "()". O importante, por enquanto, é saber o
que acontece dentro das chaves "{}" de um método.
1.1 - Tipos de Dados

Tipos de dados são uma forma de qualificar o dado, variável ou constante (mais
adiante veremos que também método). Quando fazemos:
"int x" dizemos que "x" é um inteiro e "char y" dizemos que "y" é um caracter para a Java
Virtual Machine (que é software que faz o Java funcionar), porque "int" significa inteiro e
"char" caracter. Nenhuma variável ou constante pode ficar sem o "tipo", caso contrário a
JVM acusará irregularidade. A seguir veremos os tipos primitivos de dados. Por serem
palavras chaves começam por letras minúsculas. São tipos primitivos, os tipos que foram
criados logo no começo da linguagem Java e se tornaram palavras chaves. "String" será
incluído entre os tipos de dados, apesar de não ser primitivo.
Tipos de Primitivas de Dados
Tabela 1
Tipo Categoria Número de Alcance

Bits
byte Número 8 -128 a 127
Inteiro
short Número 16 -32.768 a 32.767
Inteiro
int Número 32 -2.147.483.648 a
Inteiro 2.147.483.647
long Número 64 -9x10e18 a 9x10e18
Inteiro
float Número Real 32 3x10e38 a 3x10e38 (6
dígitos significativos)
double Número Real 64 -1,7x10e308 a
1,7x10e308 (15 dígitos
significativos)
char Caracter 16 subconjunto o ASCII
boolean Lógico true/false True ou False
1.1.1 - Tipo boolean

Tipo "boolean" caracterizam as variáveis e métodos lógicos. Estes só assumem valores
"true" (verdadeiro) ou "false" (falso).
boolean k=true;
boolean c=false;
1.1.2 - Tipo byte, short, int, long

Tanto "byte", "short", "int" e "long" são tipos para as variáveis e métodos de números
inteiros. A diferença está no valor máximo e mínimo que eles podem alcançar e na
quantidade de memória que eles consomem.Veja a tabela 1. O tipo byte cria variáveis ou
constantes que vão de -128 a 127. Variáveis ou constantes deste tipo não podem receber
valores fora desta faixa. Exemplo:
byte x=180; // está errado, pois x>127

byte y= -130; // está errado, pois y < -128
byte z= 64; // está certo, pois z está entre o intervalo [-128, 127]
Há uma espécie de hierarquia de tipos inteiros:
byte < short < int < long
O tipo "long" é o mais extenso de todos. Vai de -9x10e18 a 9x10e18. É recomendável

o uso de "L" ou "l" no final do número na hora da declaração.
Exemplo: long x=334L; // Use "L" maúsculo para não ter confusão com o número "1".
Observação 1:
Se você tem a opção de usar o tipo "long" porque você vai usar o tipo "byte"? A razão é
simples, o tipo byte economiza memória e tempo de processamento. Pode ser muito útil em
operações binárias em simulações que tomam muito tempo processamento como no caso
de algoritmos genéticos. Cada tipo seja "byte", "short", "int" ou "long" lhe darão a opção
entre consumir mais memória e a extensão dos números.
Observação 2:
Na prática, o Java, hoje em dia, não é muito usado para resolver modelos computacionais,
científicos e matemáticos que exigem alto grau de desempenho e otimização (como a
linguagem C). O uso mais difundido do Java é para resolver problemas relacionados a
Web, por isto, geralmente se usa mais a primitiva "int" que engloba uma boa extensão de
números, sem ser excessivamente extenso como "long".
1.1.3 - Tipo float e double

Os tipos de números reais são dados por "float" e "double". São conhecidos também por
"Ponto Flutuante". O consumo de memória e o alcance destes números são dados pela
tabela 1. Os números "float" são acrescidos de "F" ou "f", os números "double" são
acrescidos de "D" ou "d". Exemplo:
float x= 3.45F;
double y= 6.45D;
Ordem dos tipos

float < double
Observação 1:
Os Números Reais são considerados tipos maiores que os tipos de Números Inteiros.
Observação 2:
Na prática, o tipo "double" é mais usado do que o tipo "float", porque o primeiro (double)
tem um grau de precisão maior e isto faz a diferença em calculos matemáticos que envolva
números fracinados.
Observação 3:
O nome "double" (dobro) vem do fato de que este tipo usa duas vezes mais memória que o
tipo "float".
1.1.4 - Tipo Char

Uma variável, constante ou método do tipo "char" armazena caracteres. Caracteres são
símbolos admitidos pela linguagem de programação Java.
Em geral são letras, admitidas na tabela ASCII e encontradas no teclado do computador.
Exemplo de declaração:
char a ='t';
char b='?';
char c='&';
char d ='9'
podendo ser qualquer caracter, desde de que seja apenas um caracter de cada vez e
colocando entre apóstrofes ' '.
Observação:
Na prática o tipo "char" é pouco usado, sendo mais usado o tipo String, apesar de este
último não ser um tipo primitivo.
1.1.5 - String
"String", diferentemente dos tipos primitivos, é uma classe por isto começa com letra
maúscula. Todavia, ela para um programador, que a veja de maneira superficial, se semelha
a primitiva, dá um tipo de uma variável. "String" dá o tipo de uma variável que armazena
um conjuto de caracteres, é como se fosse um agrupamento de "char" :
String nome="Professor Edson Belem";
"nome" armazenará inclusive os espaços na frase.
// Tirar dúvida com o Belém e ver se as primitivas não na verdade classes.
1.1.6 - Conversão de Tipos:

Variáveis de tipos diferentes podem ser atribuídas entre si por meio de um processo de
conversão chamado de "casting".
Exemplo:
float d=7.8f;
short c=13;
long a=5L;
int r=10;
r=(int)a;
System.out.println(r); // Resultado é 5
r=(int)c;
r=(int)d;
Repare que diferentes tipos foram convertidos para ser adequado a variável "r" do tipo
"int". Repare também que no último resultado foi simplesmente desprezado as casais
decimais de 7.8f, pois "long" é um tipo inteiro que não aceita "." , entretanto não é preciso
fazer esta conversão explicitamente quando se faz de uma variável de um tipo menor para
um tipo maior.
r=a; // dá erro de compilação o tipo de "a" (long) é maior do que o

tipo de "r" (int)
r=c; // está certo, pois o tipo de "c" (short) é menor do que o tipo de
"r"(int)
r=d; // dá erro de compilação o tipo de "d" (float) é maior do que o tipo
de "r"(int)
1.2 - Operadores
Tabela 2
Operador Significado Categoria de

Operador
+ Soma Aritmético
- Subtração Aritmético
* Multiplicação Aritmético
/ Divisão Aritmético
% Módulo Aritmético
== Igualdade Relacional
!= Desigualdade Relacional
< Menor Relacional
> Maior Relacional
<= Menor Igual Relacional
>= Maior Igual Relacional
= Atribui Valor de Atribuição
&& AND Lógico
|| OR Lógico
! NOT Lógico
^ XOR Lógico
1.2.1 - Operadores Aritméticos

As tabelas 2 é bastante ilustrativa de como funciona operadores aritméticos, por isso, não
vamos me alongar muito sobre o assunto. Apenas vamos falar sobre o módulo. Módulo (%)
é um operador que dá como resultado o resto da operação entre dois números. Exemplo:
47 % 10 = 7 // O resto da divisão de 47 por 10 é 7.
Os demais operadores aritméticos são:

+ soma
- subtração
* - multiplicação
/ - divisão
Operador Operação Resultado

+ 5+4 9
- 5-4 1
* 5*4 20
/ 20/4 5
% 23%4 3
1.2.2 - Operadores Relacionais

Como o nome diz, ele relaciona valores entre si. Esta relação pode só dar dois resultados:
"true" ou "false". O operador "==" indica igualdade entre dois valores, dando como
resultado: falso(false) ou verdadeiro(true). Exemplo:
6==6; // o resultado é "true"

7==6; // o resultado é "false"
Os demais operadores relacionais são:

< menor
> maior
<= menor ou igual
>= maior ou igual

== 5==4 false
== 6==6 true
!= 6!=5 true
!= 5!=5 false
< 5<4 false
< 4<5 true
>= 5>=4 true
<= 4<=4 true
<= 4<=5 true
<= 10<=5 false
Estes operadores são muito usados em controle de fluxo e laços ("while", "for", "do while",
"if"), exemplo:
public void teste(){

int x=4;
if (x<=4) {
System.out.println("entrou no if");
}
while(x<10){
System.out.println(entrou no while);
x++;
}
}
Observação muito Importante:
Um cuidado importante, não confundir "==" com "=".
"==" dá como resultado: "true" ou "false",
"=" faz atribuição é correspondente ao operador matemático "←" não existente no
Java. Portanto, x==4 é diferente de x=4.
Exemplo:
public void comparacao() {

int x=15;
System.out.println(x==4); // resultado é "false"
System.out.println(x=4); // resultado é 4, corresponde a x ← 4
System.out.println(x==4); // agora o resultado é "true"
1.2.3 - Operadores Lógicos

São operadores usados (veja o exemplo da tabela 4) em operações lógicas tradicionais na
matemática:
&& - AND (também conhecido como "E"), equivalente a Intercessão. Terá que ter todos
os valores verdadeiros ("true") para expressão ser verdadeira, caso contrário a expressão
será falsa. Ou seja, basta somente um valor ser falso, para a expressão inteira ser falsa
também.
|| - OR (também conhecido como "OU"), equivale a União. Terá que ter todos os valores
falsos ("false") para expressão ser falsa, caso contrário a expressão será verdadeira. Ou seja,
basta somente um valor ser verdadeira, para a expressão inteira ser verdadeira também.
! - NOT, equivale a Negação. Todo valor ou expressão que for false ("false") vira
verdadeira ("true") e vice-versa. Ou seja, todo valor ou expressão que for "true" vira
"false".
^ - XOR, equivale ao OR exclusivo ou OU exclusivo. A expressão será verdadeira se dois
valores lógicos forem diferentes: falso ("false") e outro verdadeiro("true"). Caso contrário,
será falso. Ou seja, se ambos os valores ou expressões forem falsas o resultado será falso,
se ambos os valores forem verdadeiras o resultado será falso.
Exemplo:
Vamos supor uma declaração:
public static void comparacao(){

int x=10;
int y=20;
System.out.println((4<x)&&(y==20)); // (4<x) é verdadeiro e (y==20) é verdadeiro,
o equivale a true&&true → true.
// É verdadeiro pois ambos os valores são
verdadeiros
System.out.println((9<=x)&&(5>y)); // true&&false → false, a expressão é falsa
porque basta um valor falso para tornar a expressão falsa.
System.out.println((10<=x)||(30>y)); // true||true → true, é verdadeira porque ambos
os valores são verdadeiros.
System.out.println((5<x)||(10<=y)); // true||false → true, é verdadeiro porque basta
um valor verdadeiro para tornar a expressão verdadeira.
System.out.println((x<=3)||(8>y)); // false||false → false, é falsa porque basta um
valor ser falso para tornar a expressão falsa.
System.out.println(!(x==6)); // !false → true
System.out.println(!(y==20)); // !true → false
System.out.println((x>=12)^(30>y)); // false^true → true // é verdadeira, pois os
valores lógicos são distintos.
System.out.println((x<=20)^(y>=20)); // true^true → false // é falso porque
os valores lógicos são iguais.
System.out.println((x==15)^(35==y)); // false^false → false // é falso porque os
valores lógicos são iguais.

&& (4<10)&&(20== true
20)
&& (9<=10)&&(5>2 false
0)
|| (10<=10)|| true
(30>20)
|| (5<10)|| true
(10<=20)
|| (10==3)||(8>20) false
! !(10==6) true
! !(20==20) false
^ (10<=12)^(30>2 true
0)
^ (10<=20)^(20> false
=20)
^ (10==15)^(35= false
=20)

Não confundir "&&" e "&", " || " e " | " . "&" e "|" estes operadores quando sozinhos, eles
apenas realizam operações binárias, ou seja, operações entre "0" e "1".
Observação 1:
O operador de "xor" dado por " ^ " é válido tanto para expressões envolvendo "true" e
"false", como para operações binárias, envolvendo "0" e "1".
Observação 2:
Na prática, o operador " ^ " é pouco usado com variáveis "true" ou "false", sendo mais
usado para operações binárias.
Observação 3:
O uso da palavra "expressão" não é a mais adequada em termos de lógica, o certo seria
proposição ou sentença. Todavia, achamos melhor usar o termo "expressão" por ser mais
familiar ao leitor e facilitar o entendimento.
1.2.4 - Operadores de Atribuição
Atribuir é mesmo que dar novo valor a variável. O operador de atribuição tanto no Java
quanto C e C++ pode ser abreviado: em vez de escrever: "i=i+1", escreve-se: "i++".
++ serve para acrescentar uma unidade ao variável.

-- serve para decréscimo de uma unidade na variável.
x++; equivale a x=x+1; só acrescenta o valor na próxima linha de comando.
++x; equivale a x=x+1; acrescenta valor logo na mesma linha de comando.
x--; equivale a x=x-1; só acrescenta o valor na próxima linha de comando.
--x; equivale a x=x-1; acrescenta valor logo na linha de comando.
public void atribuicao(){
int x=1;
int y=1;
System.out.println("x++ é " + (x++));
System.out.println("++y é " + (++y));
}
Resultado:
x++ é 1
++y é 2
Outras atribuições
x+=y; equivale a x=x+y;

x -= y; equivale a x = x - y
x *= y; equivale a x = x * y
x /= y; equivale a x = x / y
Arquivo 74_java pag. 6

Estruturas de Programação
JAVA
Por
Gilberto Hiragi
Março/2006
Página
Introdução à
Linguagem Java
por Christian Cleber Masdeval Braz
pag. 13 / 52_Java
pag. 9 / Apostila de Java
1.3 - Entrada e Saída

Instruções de Entrada são aquelas que fazem a JVM (o software que roda o Java) a
captar dados apartir do usuário advinda de um console(prompt) ou de uma tela ou de uma
página da web. Instruções de Saída são aquelas que ajudam a fazer a JVM mostrar um
resultado para o usuário no console ou na tela ou na web. Nesta apostila, trabalharemos
apenas com instruções de entrada e saída local, ou seja, via console.
1.3.1 - Saída
A forma mais usada para saída de dados no Java Local é "System.out.println (expressão);".
Quando se deseja escrever algum texto basta colocá-lo entre aspas: " ". As expressões são
separadas por '+'.
Exemplo 1:
public void saida(){

int a=3, b=4;
System.out.println (" a + b = " + (a+b));
}
Resultado:
a+b=7
O operador ' + ' é usado tanto para juntar expressões como para realizar somas. No
exemplo 1 Se não fosse colocados os parênteses, o compilador iria imprimir invidualmente
os valores de "a" e "b"

int a=3, b=4;
System.out.println (" a + b = " + a + b);
}
Resultado:
a + b = 34 // não é o que realmente queríamos!
O compilador entendeu que o programador queria que os valores fossem exibidos literal e
individualmente.
Se todavia, forem tirados "a+b", o compilador entenderá que é uma soma:

int a=3, b=4;
System.out.println (a + b);
}
Resultado:
7
-------------------------
Há duas forma de impressão mais conhecidas: "System.out.print()" e

"System.out.println()". Este "ln" a mais indica que a impressão deve pular de linha. Sem ele
tudo é impressão ao lado. Veja o seguintes exemplos:
Exemplo 1:
public void mostra1(){
String a="A única coisa ";

String b="que eu sei ";
String c="é que nada sei. ";
String d="Frase de Sócrates, ";
String e="filósofo grego.";
System.out.print(a);
System.out.print(b);
System.out.print(c);
System.out.print(d);
System.out.print(e);
Caso este fragmento de código seja acionado, teremos o seguinte resultado:

A única coisa que eu sei é que nada sei. Frase de Sócrates, filósofo grego.
Nele, percebemos que as palavras todas foram colocadas na mesma linha como se é
esperado para "System.out.print()".
Exemplo 2:
public void mostra2(){
String a="A única coisa ";

String b="que eu sei ";
String c="é que nada sei. ";
String d="Frase de Sócrates, ";
String e="filósofo grego.";
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
System.out.println(e);
O segundo fragmento de código dará o seguinte resultado:
A única coisa
que eu sei
é que nada sei.
Frase de Sócrates,
filósofo grego.
Usando "System.out.println()" as coisas mudam. "a","b","c","d" e "e" têm contida uma

pequena frase que são mostradas na tela separadamente ao pular as linhas. Na primeira
linha mostra o que estava contido no "a", na segunda linha no "b" e assim por diante.
Observação:
Ignore o que significa "public void mostra1()" e "public void mostra2()" por enquanto. É
suficiente apenas dizer que são métodos e que todas aperações acontecem dentro dele.
Concentre-se na execução do fragmento de código entre chaves.
1.3.2 - Entrada
A forma de entrada mais comum no Java Local usa a classe "Scanner" é dada pela
expressão:
"Scanner input = new Scanner(System.in); " seguida vem uma atribuição a uma variável
advinda de um método:
"input.nextShort();" - Possibilita a leitura da variável de tipo "short".

"input.nextInt();" - Possibilita a leitura da variável de tipo "int".
"input.nextDouble();" - Possibilita a leitura da variável de tipo "double".
"input.nextFloat();" - Possibilita a leitura da variável de tipo "float".
"input.nextLong();" - Possibilita a leitura da variável de tipo "long".
"input.input.nextLine();"- Possibilita a leitura de palavras ou frase inteira.
Mas antes de fazer isto tudo deve-se colocar: import java.util.Scanner; que possibilitará o
uso da classe Scanner.
Exemplo:
import java.util.Scanner; // possibilita que os comandos de entrada sejam usados no

programa.
public class Entrada_Dados{
public void entrada(){
int numero_inteiro;
double numero_real;
String nome;
Scanner input = new Scanner(System.in);
System.out.println ("Coloque o número inteiro: ");

numero_inteiro=input.nextInt(); // faz leitura de variável inteira.
System.out.println ("Coloque o número real (tipo double): ");

numero_real=input.nextDouble(); // faz leitura de variável real do tipo "float".
System.out.println ("Coloque uma palavra ou frase: ");

nome=input.nextLine(); // faz leitura de frase.
System.out.println ("Você digitou respectivamente: " + numero_real + " " +

numero_real + " "+ nome);
}
Poderemos ter o seguinte resultado:

Coloque uma palavra ou frase:
Professor David
Coloque o número inteiro:
7
Coloque o número real (tipo double):
8,3
Você digitou respectivamente: Professor David 7 8.3

É essencial não esquecer de escrever a instrução: "import java.util.Scanner" sem ela
nada funciona.
Observação:
Repare que foi digitado 8,3 e saída foi de 8.3 . A razão desta diferença é que a entrada de
dados (representada pela classe Scanner) deve usar o padrão brasileiro que usa " , "
vírgula para separar casas decimais, enquanto a de saída usa normas americanas que usa
"." .
Capítulo II - Controle de Fluxo
2.1- Controle de Fluxo Condicional
São estruturas que impõem condições para executar instruções. As condições são
avaliadas apenas uma vez e a estrutura não retorna para início da estrutura para ser repetida
como nos laços ou nos loops.
2.1.1 - if ----else
"if" (significa "se" em inglês) é estrutura básica de decisão. Executa os comandos caso a
expressão que estiver em parêntese for "verdadeiro". Caso contrário, executa o "else".
if( verdadeiro){
executa estes comandos;
}else{
não executa estes comandos;
}
------------
if( falso){
não executa estes comandos;
}else{
executa estes comandos;
}
------------------------------------------------------------------------
public void comparacao() {
int n1, n2;

System.out.println ("Coloque o valor de n1: ");
n1=input.nextInt(); // este comando possibilita entrada de dados
// por meio de prompt
System.out.println ("Coloque o valor de n2: ");
n2=input.nextInt();
// será executado um console pedindo o valor de "n1" e "n2"
if (n1>n2)
System.out.println (n1 + " é maior que " + n2); // Se houver apenas um comando, não
precisa de colocar chaves "{}"
else if (n2>n1)
System.out.println (n2 + " é maior que " + n1);
else
System.out.println (n1 + " é igual a " + n2);
}
Resultado:
Coloque o valor de n1:
10
Coloque o valor de n2:
8
10 é maior que 8
2.1.2 - switch
É usado para avaliar uma expressão com vários resultados possíveis. Só aceita variáveis de
tipo "char", "byte", "short" ou "int". O valor é procurado nas declarações "case" que vem
declarado no switch e dento dos "cases" os comandos são executados.
switch ( expressão ) {
case valor1:
executa comandos1; // se a "expressão"=="valor1";
break;
case valor2 :
executa comandos2; // se a "expressão"=="valor2";
break;
...
default : executa comandos //caso nenhum case tenha sido executado;

}
Exemplo:
public void opcao(){

int numero;
System.out.println ("Coloque o valor de numero: ");
numero=input.nextInt();
switch (numero){
case 0: System.out.println(“Comando 0”);
break;
break;
break;
default: System.out.println(“Comando 3”);
}
}
Um resultado possível:
Coloque o valor de numero:

1
Comando 1
Outro resultado possível:

9
Comando 3

"break" interrompe a instrução "switch". Sem o "break" o compilador continuaria
executando todos os demais "cases":
Um resultado possível:

1
Comando 1
Comando 2
Comando 3
2.2 - Loops ou Laços

Laço ou loop é uma estrutura de repetição. Ou melhor, é uma estrutura que impõe
repetições as suas instruções até que determinado condição seja atendida. Cada vez que o
fluxo se repete, a execução volta ao começo da instrução.
2.2.1 - while
"while(expressão)" executa os comandos enquanto a expressão dentro do parêntese for
verdadeira.
while (enquanto a expressão for verdadeira) {

Executa comandos;
}
O laço não necessariamente é executado. Isto acontece se a expressão entre parênteses for
falsa.
public void laco(){

int x=1;
int y =1;
int i=1;
while ( i <5 ){ // as instruções abaixo são executadas até o valor de "i" ser igual a 5.
x = x * 2;
System.out.println("O valor de i é " + i );
System.out.println("O valor de x é " + x );
i++;
}
while(i<5){ // nenhuma instrução será executada, pois "i" já é 5 e "5<5" é falso portanto
não entra sequer no loop.
y = y* 2;
System.out.println("O valor de y é " + y );
i++;
}
}
Resultado:
O valor de i é 1
O valor de x é 2
O valor de i é 2
O valor de x é 4
O valor de i é 3
O valor de x é 8
O valor de i é 4
O valor de x é 16
Repare que sequer o segundo "while" é executado, porque "i" é igual a 5 e "5<5" é falso.
2.2.2 - do - while
O laço é executado pelo menos uma vez. O loop é executado enquanto a expressão dentro
do "while(expressão)" seja verdadeira.
int x=1;
int i=0;
do {
// se "i" for maior que 10, este laço vai ser executado somente uma vez.
x = x * 2;
i++;
}while ( i < 10 );
2.2.3 - for
O "for" tradicional do Java (pois há um outro nas versões mais novas do Java) tem as
condições definidas para seu funcionamento dentro dos parênteses em ordem ternária, ou
melhor, são colocados três tipos de expressões dentro do parentese em ordem, primeiro são
inciadas as variáveis, segundo são colocadas as condições "booleanas" ou lógicas e terceiro
são colocados os incrementos ou decrementos.
for (declaração e inicialização das variáveis; condição_booleana; incremento ou

decremento)
{
Execução dos comandos;
}
public void laco(){
int x=1;
int y=1;
for (int i = 0; i < 3; i++){
x=x*2;
System.out.println("O valor de x é " + x );
}
for (int i = 3; i > 0; i--){
y=y*2;
System.out.println("O valor de y é " + y );
}
}
Resultado:
O valor de i é 0
O valor de x é 2
O valor de i é 1
O valor de x é 4
O valor de i é 2
O valor de x é 8
O valor de i é 3
O valor de y é 2
O valor de i é 2
O valor de y é 4
O valor de i é 1
O valor de y é 8
Observação: Nos casos do "for", "while" e do "do-while", o termo usado expressão não é
o termo mais correto em termos de lógica, o certo seria "sentenção lógica" ou
"proposição". Todavia, usou-se aqui como "expressão", pois é um termo mais familiar ao
aluno e de mais fácil entendimento.
74_java
Definições
Capítulo III - Orientação a Objeto

3.1 - Classe
3.1.1 - Uma primeira chance de entender o que é uma

classe
Para facilitar o entendimento, expliquemos a sua origem. Como se sabe, o Java
advinda do aperfeiçoada do "C". No "C" existia uma instrução chamada "struct" que servia
para agregar dados equivalente ao "register" no pascal. Na verdade, o que ficava na
estrutura era um conjunto de variáveis ou constantes que guardavam valores e que também
eram declaradas lá dentro (ou melhor, ganhavam tipos: "int", "float", "char" etc.).
E por que esta necessidade de criar uma separada para armazenar dados nas
variáveis? Apesar de um programa em geral ter um grande objetivo, este objetivo pode ser
dividido em objetivos menores. Esta divisão facilita o trabalho do programador que tem que
lidar com menor quantidade de informação e facilita ainda mais quando estas informações
estão relacionadas entre si, além disso, tornava o trabalho mais organizado. Todos os dados
inter-relacionados, ficavam guardados em variáveis que ficavam por sua vez agregadas em
pequenas estruturas chamadas "struct".
Exemplo:
Vamos supor que fosse feito um programa que ajude a planejar as Finanças de um
clube de Futebol XPTO. O objetivo maior e geral do programa é "planejar as finanças do
XPTO Futebol Clube". Mas este grande objetivo pode ser dividido em objetivo menores,
planejamento financeiro: da arrecadação no estádio, de vendas de produtos, do dinheiro
advindo do patrocinador, da compra e venda de jogadores, da despezas com time, das
despezas com funcionários, despezas de infraestrutura. Se os dados referentes a toda esta
série de objetivos não forem agrupados, o programador teria que lidar com variáveis do
tipo: "quantidade de camisas vendidas", "pagamento do bicho ao jogador de futebol",
"número de ingressos vendidos", "número de toalhas a serem compradas" etc. Há de
convir que seria uma enorme bagunça colocar estes dados juntos! Melhor seria colocar
uma estrutura por categoria ou afinidade de objetivo. Poderíamos criar uma estrutura com
o nome de "produtos" e colocar lá: "quantidade de camisas vendidas", "preço das
camisas", "quantidade de meias vendidas", "preço das meias" etc. e ir fazendo estruturas
para cada outro objetivo (arrecadação no estádio, patrocinador etc.), categorizando assim
os dados.
Nas linguagens posteriores orientadas a objeto que vieram a sucesseder "C" como
C++ e Java, criou-se uma forma mais generalizada de "struct" chamada "classe". "classe"
seria um "struct" com mais recursos que agrupa não só declarações de variáveis e as
informações(atributos) contidas nele, como declara e executa métodos (equivalente a
funções no C), além de registringir ou não seu acesso.
Exemplo:
Agora que temos os dados agrupados e organizados pela categoria de problema a
ser resolvido, ou melhor, de objetivo a ser alcançado. Por que agrupar somente os dados e
não as ações também? Nesta mesma, estrutura "produto" eu poderia colocar as ações:
"obter os custos", "obter o faturamento", "obter o lucro" etc. A estrutura responsável pelas
ações são chamadas métodos e exigem operações. Porque todo método exige alguma
forma de operação. Neste caso, uma operação matemática. Para o método "obter_custo"
precisamos somar outras despezas: com empregados, com a compra de produtos junto ao
fornecedor, com a infraestrutura da loja etc. fazer algumas operações de soma, subtração
e multiplicação e chegar a algum resultado. Tudo isto é trabalho de método.
Este agregar de dados e ações em uma única estrutura é o que chamamos de
classe.
3.1.2 - Definição de Classe (segunda chance)
Classe é uma "estrutura" que agrupa os atributos e métodos por afinidade de

objetivo. Entenda os atributos, em princípio, como se fossem armazenadores de dados do
programa ou variáveis globais dentro desta estrutura até arranjarmos uma definição melhor.
Entenderemos os métodos como equivalente a funções em outras linguagens de
programação. Tanto os atributos quanto os métodos são chamados genericamente de
membros da classe.
É bastante óbvio de se visualizar o que é classe já que está acompanhada do
comando “class”. É recomendado pela SUN (criadora do Java) que as classes comecem
sempre com letras maúsculas. As classes podem ser simples como aqui está em baixo:
public class A {
Esta classe acima é uma classe que não faz nada, mas ainda assim uma classe. Podemos ter
classes mais complexa como está aqui abaixo:
----------------------------------------------------------------------------
A classe pode ser mais complexa como esta:
public class Inclusao extends HttpServlet {
protected void processRequest(HttpServletRequest request, HttpServletResponse

response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
Cliente cliente = new Cliente();
String id=request.getParameter("id");
ClienteDao clientedao=new ClienteDao();
if (id.equals("1"))
{
cliente.setCod(Integer.parseInt(request.getParameter("cod")));
cliente.setNome(request.getParameter("nome"));
cliente.setEmail(request.getParameter("email"));
clientedao.open(out);
clientedao.inclusao(out,cliente);
}
else if (id.equals("2"))
{
clientedao.open(out);
clientedao.consultaGeral(out);
}
out.print("<br><a href=index.jsp>Voltar</a>");
out.close();
}
---------------------------------------------------------------------------------------------------
Em resumo: atributos fornecem e armazenam os dados e os métodos resolvem
problemas específicos. Todos eles têm objetivos em comum ficam agregados numa
estrutura chamada classe. Geralmente a classe recebe o nome do objetivo ou a categoria de
objetivo a ser alcançada com ela.
Vamos daqui por diante usar um programa de referência para entender os conceitos
relacionados orientação a objeto.
3.1.3 - Classe Main

É Main (que significa principal) é a primeira classe que a JVM de um Java local vê
quando inicia a execução. De lá são criados objetos (veremos o que é objeto mais adiante)
ou chamados métodos de outras classes. É como se fosse um centralizador, é como se fosse
um chefe dá ordem as outras classes. De lá o programa inicia a execução e volta se for
necessário.
3.2 - Programa de Referência

Observe programa, ele será nosso programa de referência:
package primeiro;
public class Main { // classe Main que chama as demais classes
public static void main(String[] args) { // método main que chama os demais métodos
Calcula calcula=new Calcula(); // cria um objeto
calcula.calcula_media1(); // chama o método calcula_media1()
System.out.println(calcula.calcula_media2(30, 40)); // chama o método
calcula_media2(double c, double d) e dá o valor do método ao final da operação
}
public Main() {
}
}
--------------------------------------
package primeiro;
public class Calculo {
double a=70; // atributo que veremos mais adiante.

double b=90; // atributo
double media; // atributo
public void calcula_media1(){ // método sem retorno

media=(a+b)/2;
System.out.println(media); // dá o valor dá média ao final da operação
}
public double calcula_media2(double c, double d){ // método com retorno

media = (c+d)/2;
return media;
public Calculo() { // construtor
3.3 - Atributos
Os Atributos são também denominadas de variáveis de instância. São
armazenadores de dados do programa. São variáveis que podem ser utilizadas em qualquer
lugar da classe, ao contrário das variáveis locais que são utilizáveis somente dentro do
corpo (ou melhor, entre as chaves) dos métodos. São exemplo de atributos no programa de
referência acima:
double a=70;
double b=90;
double media;
Repare que não passam de variáveis, mas que são "visíveis", ou melhor, podem ser
manipuladas em toda a classe. Estas variáveis recebem valores iniciais, como nos atributos
"a" e "b" ou ficam apenas declaradas sem receber valores como no atributo "media", mas na
espectativa de receber valor no futuro. Os atributos não necessariamente são double, podem
ter qualquer tipo como, no exemplo, retirado de um fragmento de código do professor
Edson Belém:
public class Tipos {

String nome; // Possibilita armazenar em "nome" um texto
byte n1; // declara "n1" inteiro e usa 8 bits de memória.
short n2; //inteiro, usa 16 bits
int idade; //inteiro, 32 bits (default)
long n3; //inteiro, usa 64 bits
float num1; //real, usa 32 bits
double num2; //real 64 (default)
char letra; //tipo de letra um caracter
boolean logica; //verdadeiro ou falso (true ou false)
Date d=new Date(); //Quando vou trabalhar com datas
List grupo=new ArrayList();//grupos de dados
// Eis exemplo de atributos acima. O atributo sempre tem um tipo: "byte", "short" , "int"
etc.
// o tipo é: byte, short, int etc. O atributo em si neste caso é "n1", "n2", "idade" etc.
public Tipos() {
}
52_Java
3.3 - Método
Métodos são equivalentes a uma subroutina ou programa em linguagens
estruturadas. No C e C++, são semelhantes a Função, no Pascal ao Procedimento
(Procedure) e Função. Ele é responsável pelas operações dentro da classe. Estas operações
podem ser operações matemática mesmo como "soma", multiplicação" etc. ou podem ser
operações de outro tipo, como as que possibilitam a consulta de um banco de dados ou que
escrevem mensagens ou criam arquivos etc. Método é o responsável por realizar as tarefas,
ou melhor, praticar as ações, ou melhor ainda,"fazer acontecer", pegando os dados que ele
tem (advindos ou não de atributos) para fazer realizar alguma tarefa de desejo do
programador. Mas geralmente são tarefas específicas.
Exemplo:
Desejo calcular área de um triangulo, então criamos um método para isso, você
pode criar o nome de "area_triangulo()" que realiza as tarefas de calculo do triangulo
para o programador. Mas se desejamos calcular área de vários tipos de figuras
geométricas, teremos que criar um método para cada forma geométrica diferente: um para
área da circunferência, outro para área de um quadrilátero, outro para um pentágono e
assim por diante e poderiam ser assim os métodos: "area_circunferencia()",
"area_quadrilatero()", "area_pentagono()". É fácil reconhecer um método, ele sempre vem
acompanhado de parânteses "()", sejam eles estando vazios ou com algo dentro: "(double
x, float y, String z, etc)" .
Busquemos o programa de referência. Precisamos calcular a média de "a" e "b",
o que devemos fazer? Você terá que recorrer ao método, pois você precisa dele para fazer
operações, lembra? e neste caso pode ser "calcula_media1()". Há um método alternativo
semelhante é "calcula_media2(double c, double d)" realizam a mesma tarefa: fazer
média. Uma diferença é que no "calcula_media2(double c, double d)" há uma passagem de
parâmetros, ou seja, são mandados valores as variáveis entre parêntese, "c" recebe algum
valor e "d" recebe algum outro valor. E de onde vem estes valores? Vem de:
"calcula.calcula_media2(30, 40)" da classe Main e método "public static void
main(String[] args)".
Outra diferença de "calcula_media1()" e "calcula_media2(double c, double d)" é
que o primeiro não retorna valor e o segundo retorna. "public void calcula_media1()"
por não retornar nada é que este método recebe o qualificador "void"(significa vazio).
"public void calcula_media1()" é equivalente ao Procedimento no Pascal. Ao contrário
de uma função no pascal, ele não recebe nenhum valor no final da operação (é o que
chamamos de "não retornar valor").
"public void calcula_media2(double c, double d)" é equivalente a Função no
Pascal. Ele retorna valor. Quando falo em retornar valor, estou dizendo que
"calcula_media2(double c, double d)" terá algum valor (podendo ser número ou uma
"string" ou um número "booleano") depois que for feita a obtenção da média: "media =
(c+d)/2;". Voltando ao método:
public double calcula_media2(double c, double d){

media = (c+d)/2;
return media;
}
Os valores advindos de outra classe passados são: c=30 e d=40 da chamada da

função: "calcula.calcula_media2(30, 40)". Ao fazermos isto, há uma atribuição nas
variáveis como se fosse: "calcula_media2(c=30,c=40)" daí fazemos a operação dentro do
escopo do método, ou melhor, dentro das chaves:
media = (30+40)/2= 35 , no final, este valor é atribuído a função. Seria como se fosse:
"calcula_media2(double c=30, double d=40) =35"; (Mas não tentem escrever este código
desta maneira, pois ele dará erro no compilador) , tanto isto é verdade que você pode
colocar o método na instrução de saída: "System.out.println(calcula.calcula_media2(30,
40))" o resultado desta operação é: 35. Já se você tentar fazer o mesmo com um método
"void" que não tem retorno, haverá erro:
"System.out.println(calcula.calcula_media1())" // Não Tentem fazer isto, pois dará
erro!
Pelo fato de "calcula_media2(double c, double d)" receber um valor, o método
tem que receber um "tipo", neste caso foi "double": double calcula_media2(double c,
double d) equivale a dizer "calcula_media2(double c, double d)" é um real. Mas em vez
de "double", poderia ser "float", "long", "boolean" ou qualquer outro tipo desde que
seja o tipo válido no Java e esteja condizente com a lógica do que se quer do programa. Os
valores passados por parâmetro(os valores dentro dos parênteses) também tiveram que
receber um tipo, é que em java todo o valor deve receber um tipo. "c" e "d" recebem
valores por isto, devem ter um tipo e neste caso é double.
Observação Importante 1:
Aqui demos exemplo de um método que faz passagem parâmetro e dá retorno e outra do
tipo "void" que não retorna valor e nem faz passagem de parâmetro. Poderia acontecer o
contrário, um método retornar e não passar parâmetro e um método ser do tipo "void"
(sem retorno) e passar parâmetro:
double m=40;
double n=80;
double media;
public void calcula_media3(double f, double g){

media=(f+g)/2;
System.out.println(media);
}
public double calcula_media4(){

media = (m+n)/2;
System.out.println(media);
}
São métodos possíveis de serem criados.
Observação Importante 2:
Você não precisa criar uma nova variável para calcular a média, simplesmente basta fazer
o cálculo na impressão("System.out.println") ou no retorno "return". O código passaria
a ficar assim:
double m=40;
double n=80;
double media;
public void calcula_media3(double f, double g){

System.out.println((f+g)/2);
}
public double calcula_media4(){

return (m+n)/2;
}
3.3.1 - Método public static void main(String[] args)

É método que inicia a execução do programa Java. Ele chama todos os demais
métodos de outras classes. É o método que é visto inicialmente pelo Java Local e sugere-se
que seja o primeiro método a ser procurado quando se lê um programa Java, assim como a
classe Main deve ser a primeira classe a ser procurada. No programa de referência temos:
package primeiro;
public class Main {
public static void main(String[] args) {
Calcula calcula=new Calcula();
calcula.calcula_media1();
System.out.println(calcula.calcula_media2(30, 40));
}
public Main() {
}
}
Repare que dentro método "main" não é realizado nenhuma operação de cálculo. As
operações de calculo ou de banco de dados etc. podem ser feitas sim na main, mas NÃO
devem, pois quebraria o modelo de orientação a objeto. Por esta diretriz, deve haver um
número pequeno de instruções, se possível estas instruções devem se limitar a chamada de
métodos de outras classes.
Lembrete: Lembre-se que Java é "case sensive", ou seja, o fato de a letra ser
maúscula e minúscula faz diferença. "Main" e "main" são coisas distintas, o primeiro é
classe principal e o segundo método principal.
3.4 - Objeto
Um objeto é como se fosse um clone ou uma cópia da classe (veja Observação 1).
No programa de referência veja as seguintes instruções:"Calcula calcula=new Calcula()".
O "new" (novo, se refere a um novo objeto) faz a chamada do construtor "Calcula()" ao
mesmo tempo em que cria um objeto baseado na classe Calcula. Tudo o que você precisa
entender é que "calcula" como se fosse uma cópia da classe "Calcula" (veja Observação
2) e, portanto, "calcula" tem todos atributos e métodos advindos da classe Calcula. Veja o
fragmento de código advindo do programa referência:
Calcula calcula=new Calcula(); // criou o objeto, "calcula" é como se fosse o objeto

sendo uma cópia da classe "Calcula"
calcula.calcula_media1(); // executa o método "calcula_media1()" que agora faz
parte do objeto "calcula".
calcula.calcula_media2(30, 40);// executa o método "calcula_media2(double c
,double d)" que agora faz parte do objeto "calcula".
// atribui aos parâmetros "c" e "d" os valores respectivos de 30 e 40.
Por que usamos a cópia da classe e não a classe propriamente dita? É porque a
classe é como se fosse um molde que não pode ser mexido:
Vamos supor um livro que tenha espaços em branco para serem preenchidos.
Ninguém vai usar o livro original até porque fazer um livro original dá muito trabalho, por
isto, vai para prensa o molde original para fazer cópias. O livro original escrito
diretamente pelo autor é a classe, a cópia é objeto. Se o livro cópia, como é o caso, tem
espaços em branco para serem preenchidos pelos alunos, cada exemplar poderá assumir
uma forma diferente, pois diferentes alunos preencherão os espaços em branco (como se
cada cópia assumisse um novo estado) e cada aluno fará o que quiser com seu exemplar,
desde que o livro original ofereça este recurso, pode-se ler somente os capitulos que lhe
interessa e fazer os exercícios que estão dispuníveis. Assim também é o objeto, teve uma
forma original advinda da classe, mas pode ser usado como quiser pelo usuário.
Observação 1:
A definição mais correta de objeto é: o local da memória onde é armazenado o Estado da
Classe. Todavia, entendemos que esta definição é pouco assimilável para um aluno
iniciante em Java. Caso fique mais fácil entender por esta definição ou por outra
definição, fique a vontade.
Observação 2:
"calcula" (repare que está em letra minúscula) é a variável de referência que aponta para
o objeto, ou melhor, detem o endereço de memória do objeto propriamente dito. Mas
facilita o entendimento pensar em "calcula" como se fosse o objeto em si e como uma
cópia da classe "Calcula". Seria como estivéssemos usando a própria classe em si.
Observação 3:
Como é padrão, a SUN recomenda que a variável referência (que estamos chamando de
objeto por uma questão de simplicidade) deve ter o nome da classe, mas com a primeira
letra minúscula. Na prática, podemos chamar a variável de referência do que quisermos.
Em vez de "calcula" podemos dar o nome de "c" substituindo por exemplo:
"calcula.calcula_media1()" por "c.calcula_media1()".
3.5 - Encapsulamento set/get

São usados para encapsular atributos.
public class Teste {
public int num1;
public float num2;

public String nome;
public void metodo_teste(){
Apesar de ser possível declarar os atributos como públicos, não é conveniente em

termos de segurança. Por isto, é necessário que as variáveis continuem privativas as classes.
Mas como então as demais classes poderão usar as variáveis se elas estão privadas? A
solução é criar métodos que recebam os valores das variáveis e só trabalhar com eles. Além
disso, os métodos podem ser tratados e modificados sem alterar fundamentalmente as
propriedades da variável. Os métodos passam a representar os atributos como se tivessem
uma "procuração" deles. Dois tipos de métodos são criados para o encapsulamento um
que começa com "get" que seria responsável por exibir os valores do atributo e "set" seria
responsável receber novos valores e repassá-lo para o atributo.
Eis um exemplo comparativo: É como se o atributo fosse o Presidente da

República, por uma questão de segurança, ninguém pode ter acesso diretamente a ele e
nem ao Palácio do Planalto (este seria como se fosse uma classe), exceto alguns
funcionários internos e casos excepcionais. Como o presidente não pode ter contato direto
com o povo, ele têm que ter representantes que possam ser sua "voz" e seus "ouvidos",
ele envia uma espécie de embaixadores um para ouvir as reclamações ou pedidos do povo,
o ouvidor e outro para falar por ele ao povo, o porta voz. O ouvidor recebe mensagens do
povo para o presidente e exibe as mensagens do presidente para o povo. O set faria o
papel de ouvidor, aquele que recebe valores para o atributo e o get seria que mostra os
valores do atributo.
Abaixo mostra um exemplo de encapsulamento em que os atributos "num1", "num2" e

"nome" tem métodos correspondentes a eles.
public class Teste {

private int num1=10;
private float num2=30;
private String nome="carro";
public void metodo_teste(){

}
public int getNum1() {

return num1;
}
public void setNum1(int num1) {

this.num1 = num1;
}
public float getNum2() {

return num2;
}
public void setNum2(float num2) {

this.num2 = num2;
}
public String getNome() {

return nome;
}
public void setNome(String nome) {

this.nome = nome;
}
Vamos pegar um exemplo um atributo e ver como foi feito o encapsulamento dele:
int num1;
Para fazer que "num1" seja visível fora da classe temos que criar um método, ele
terá que começar com a palavra "get" e primeira letra deverá depois desta palavra deve ser
maúscula. O método ficará assim: "getNum1()", ele terá que ter o mesmo tipo de "num1"
e terá que ter o mesmo valor dele. Para isto, criamos um método de retorno:
public int getNum1() {
return num1;
Como foi dito quando falamos anteriormente sobre métodos, o método de retorno,
recebe o valor que estiver no comando "return". Neste caso, "retun num1" seria como se
atribuíssemos um valor ao método: "getNum1() = num1", mas não tentem fazer isto pois
dará erro. Como sabemos que "num1" tem o valor inicial de 10, "getNum1()" passa a ter
o mesmo valor.
public void setNum1(int num1) {
this.num1 = num1; // este comando atualiza o valor de "num1"

}
Se por outro lado, passarmos valores para dentro do parentese do "setNum1()" em verdade
estaremos atribuindo o valor de dentro do parêntese ao num1.
3.6 - Herança
Herança é o mecanismo pelo qual uma classe obtém características (métodos e
atributos) de outra classe. A classe "filho" que recebe estas características é chamada de
"subclasse" e a classe "pai" que passa estas características são chamadas de "superclasse".
vejamos o exemplo do Código 1:
public class Ser_Humano {
String classe_de_animal = "mamífero";
String geracao_de_energia="metabolismo";
String alimentacao_infantil="leite";
String animal = "Ser Humano";
String alimentacao_adulta="onivora";
int espectativa_de_vida=70;
double velocidade_maxima=30;
public void metodo_mamifero(){
System.out.println("A temperatura corporal é regulada pelo " + geracao_de_energia);
System.out.println("A alimentação na infância é o " + alimentacao_infantil);
}
public void metodo_Ser_Humano(){
System.out.println("Este animal é um " + animal);
System.out.println(animal + " é um " + classe_de_animal);
System.out.println("Tem espectativa de vida de " + espectativa_de_vida +" anos");
System.out.println("E chega a uma velocidade de " + velocidade_maxima+" km/h");
}
}
Obvervando a classe, verificamos que ela fala das características do ser humano.
Entre as características estão as que se relacionam esclusivamente com a espécie humana:
espectativa de vida, forma de alimentação durante a fase adulta, velocidade máxima que ele
pode atingir. Há também características comuns a outros mamíferos como: alimentação
infantil e geração de energia. Há um pequeno problema, vamos supor que queiramos fazer
classes para outros animais também mamíferos como a Zebra e o Guepardo. As
características do mamífero não podem ser aproveitadas nestas outras classes (Zebra e
Guepardo). Mas justamente reaproveitamento de código é a chave da orientação a objeto,
economiza tempo ao evitar-se de ter que reescrever o código a cada vez que façamos uma
classe de um animal mamífero. Por isso, vamos retirar da classe Ser_Humano todo o
código que se referir ao Mamífero e, em seguida, vamos criar uma classe só para mamífero
que será Mamifero:
O Código 2 ficaria assim:
package mamifero;
public class Mamifero{
public void metodo_mamifero(){
}
}
----------------------------
package mamifero;
public class Ser_Humano extends Mamifero{
// é como se todas as carcterísticas da Classe "Mamifero" fossem colocadas na classe
"Ser_Humano"
public void metodo_Ser_Humano(){
}
}
Os códigos referentes ao mamífero foram retirados da classe "Ser_Humano" e
passaram a ter uma classe só para eles, a classe "Mamífero". A Classe Ser_Humano não
perdeu nada com esta retirada de código de seu escopo (entre as chaves ou o corpo da
classe). Ao contrário, além de ter ficado um código mais "claro", menor, mais "limpo", ele
ainda herda da classe Mamífero todas as características, como o tipo de alimentação na
infância e a geração de energia. Agora só falta acrescentar a classe "Main" com o método
"main" para chamar e executar os métodos da classe "Ser_Humano":
---------------------------------
package mamifero;
public class Main {
Ser_Humano homem = new Ser_Humano();
homem.metodo_mamifero();
homem.metodo_Ser_Humano();
}
}
------------------------------------------------------
O resultado deste programa será:
Este animal é um Ser Humano
Ser Humano é um mamífero
Tem espectativa de vida de 70 anos
E chega a uma velocidade de 30.0 km/h
A temperatura corporal é regulada pelo metabolismo
A alimentação na infância é o leite
---------------------------------------------------------
O ser humano herda características comuns a todo o mamífero como alimentação
por leite e energia corporal produzida por metabolismo (diferentemente dos répteis que
usam a energia solar). Fizemos exatamente a mesma relação entre a classe "Ser_Humano"
e a "Mamífero". A instrução "extends" permite que seja feita esta relação de herança.
"Ser_Humano extends Mamífero" significa literalmente: a classe "Ser_Humano" herda
ou recebe atributos e métodos da classe "Mamífero" . Todavia nem sempre se herda todos
os atributos e métodos, os privados a classe (são aqueles com modificadores de acesso:
"private") não o são (não colocamos nenhum atributo ou método privado neste exemplo).
Agora que criamos a classe "Mamifero", as características de mamífero podem ser
reaproveitada para as classes "Zebra" e "Guepardo". Como no fragmento de código a
seguir:
package mamifero;
public class Zebra extends Mamifero{
String animal = "Zebra";
String alimentacao_adulta="herbivora";
float espectativa_de_vida=30;
public void metodo_zebra(){

System.out.println(" Este animal é uma" + animal);
System.out.println("Tem espectativa de vida de " + espectativa_de_vida+"anos");
System.out.println("Ele chega a uma velocidade de " + velocidade_maxima+"km/h");
}
}
------------------------------
package mamifero;
public class Guepardo extends Mamifero{
String alimentacao_adulta="canivora";
String animal = " Guepardo";
float espectativa_de_vida=8;
public void metodo_Guepardo(){
System.out.println(" Este animal é um" + animal);
System.out.println("Tem espectativa de vida de " + espectativa_de_vida +"anos");
System.out.println("Ele chega a uma velocidade de " + velocidade_maxima+"km/h");
}
}
---------------------------------------------
Repare que as características próprias do animal Zebra como
"espectativa_de_vida" ou "velocidade_maxima" e "metodo_Guepardo()", enquanto as
características que não pertencem somente a este animal ficam na superclasse ou classe pai
"Mamífero".

Não serão herdados métodos e atributos que tiverem o qualificador de acesso "private",
são privados a própria classe e portanto não são passados as classes filhos. Veremos isto
mais adiante.
Observação:
Não há no Java herança multipla como no C++. Se colocarmos "public class Ser_Humano
extends Mamifero extends Bipede" dará erro, mesmo que a classe "Bipede" exista.
3.7 - Classe Abstrata
Vamos supor que não queiramos usar a classe em si por acharmos que mamífero é
algo "abstrato" demais! Melhor dizendo, mamífero pode ser um monte de espécie de
animais que sequer podem ser visualizados como um só, afinal, um "elefante" é bem
diferente de um "rato", no entanto, são ambos mamíferos. Por isto, podemos não querer
saber sobre o mamífero em si por ser genérico demais ou por não fazer sentido querer usá-
lo. Assim transformamos esta classe "Mamifero" em abstrata e código da classe passa a ser:
package mamifero;
public abstract class Mamifero{ // usamos o qualificador abstract para dizer que é uma
classe abstrata

public void caracteristica_mamifero(){
}
}
Repare que apenas colacamos o qualificador "abstract" para dizer que a classe é abstrata.
As classes "Ser_Humano" e "Main" continuarão inalteradas. O que muda nesta estória é
que não podemos criar na main a seguinte instrução:
package mamifero;
public class Main {
Mamífero mamifero=new Mamifero(); // Aqui teremos um erro! Classe Abstrata
não pode criar objeto.
homem.metodo_mamifero();
homem.metodo_Ser_Humano();
}
}
Portanto não é uma classe que não existe, aparentemente pode-se pensar, mas uma
classe cuja única finalidade é passar atributos e métodos para uma subclasse. As classes
abstratas não fazem sentido se não tiverem uma classe para deixar como herança atributo
ou método.
3.8 - Métodos Abstratos

São métodos declarados em classe abstrata e não realizam nenhuma tarefa ou
operação, apenas são declarados. A finalidade do método abstrato é obrigar que as
subclasses tenham os mesmos nomes e tipos dos métodos da superclasse. É como se fosse
um contrato, você herda as características desta classe e as suas vantagens e também a
obrigação de executar certas tarefas por meio de métodos com mesmo nome.
Vamos supor que queiramos obrigar que a superclasse mamífero as suas classes
"filhos", ou melhor, as suas subclasses, que todas tenham um método que dê o número de
pernas de cada animal. Para isso, criamos um método abstrato: "public abstract void
numero_de_pernas()" todas as subclasses que herdarem "Mamifero" (desde que sejam
classes concretas) inclusive a classe "Ser_Humano" terá que executar um método
concreto: public void numero_de_pernas(). Vejamos como fica no código a seguir:
A classe "Mamifero" passa a ser:
package mamifero;
public abstract class Mamifero{

public abstract void numero_de_pernas();

// indica que as subclasses terão que criar um método concreto equivalente a este
método

}
public Mamifero(){
-----------------------------------------------------------
package mamifero;
public void numero_de_pernas(){ // este método foi obrigado a ser criado

System.out.println("Homem tem duas pernas");
}
public void caracteristica_Ser_Humano(){

}
Observação 1:
Métodos abstratos sempre terminam com ";" já que são apenas declarações e não
executam nada. Ao contrário dos métodos concretos comum que sempre terão que ter
chaves "{ }".
Observação 2:
A classe abstrata não é necessariamente composta de métodos abstratas.
Observação 3:
O método que será executado é o da classe filho. O processo em que o método da classe
filho se impõe sobre o da superclasse é chamado de sobrescrita.
3.9 - Interface:
É semelhante a uma classe abstrata com algumas diferenças. Uma classe pode
herdar apenas uma classe abstrata ou concreta, mas pode implementar várias interfaces.
Outra diferença é que a interface só tem métodos abstratos, isto obriga a classe que
implementa a interface a ter os métodos correspontes de mesmo nome e com os mesmos
parâmetros. Aliás, a finalidade de uma interface é esta mesma, obrigar a criação de
métodos com as mesmas características definidas na interface.
Eis aqui um exemplo de uso da interface baseado no programa criado em sala de
aula pelo professor Belém no dia 12/03/2008. Vamos supor que o O Arquiteto do projeto
queira que os demais programadores criem um pequeno cadastro de cliente. Mas ele quer
amarrar o programa de forma que os programadores não deixem de colocar nome, telefone
e e-mail do cliente. Ele fará obrigando a criar métodos de atributos encapsulados:
"getNome()", "getEmail()" e "getTel()". Ele também quer que seu auxliar crie também
métodos de leitura para "nome", "email" e "telefone" pois entende que ficaria padronizado
segundo o modelo que ele tem nada cabeça. Então ele quer obrigar também que seja criado
os seguintes métodos: "public void lerNome()", "public void lerTel()" e "public void
lerEmail()". Para que isto tudo aconteça, ele cria seguinte interface:
public interface ICliente {
// os métodos e atributos abaixo serão obrigados a serem executados pelas

// classes que implementam ICliente
public void lerNome();

public void lerTel();
public void lerEmail();
public String getNome();

public String getEmail();
public String getTel();
}
Por sua vez, o programador que realizar o projeto terá que implementar método por
método. É como se fosse um projeto de programa que o auxliar é obrigado a implementar.
Veja o programa que o auxiliar criou.
-----------------------------------------------------------------
package projeto3a;
import java.util.Scanner;
public class Cliente implements ICliente{ // implementa a interface ICliente
// caso os atributos e os "gets" correspondentes não sejam declarados

// como estão na interface ICliente, o compilador reclamará
private String nome; // atributos

private String tel;
private String email;
// métodos que fazem leitura de dados

public void lerNome(){
System.out.println("Nome : ");
Scanner in=new Scanner(System.in);
nome = in.nextLine(); // faz leitura de uma frase inteira inclusive os espaços
}
public void lerTel(){
System.out.println("Telefone : ");
tel = in.nextLine();
}
public void lerEmail(){
System.out.println("E-mail : ");
email = in.nextLine();
}
// encapsulamento dos atributos: nome, tel, email.

// Só foi criado get pois os atributos serão apenas exibidos
// não serão atribuídos valores a eles.
public String getNome(){

return nome;
}
public String getTel(){
return tel;
}
public String getEmail(){
return email;
}
public Cliente() {
}
}----------------------------------------------------------------------------
Resultado possível:
Nome :
Professor David
E-mail :
David@coti.com.br
Telefone :
23232323
Professor David
David@coti.com.br
23232323
------------------------------------------------------------------------------------------------------------
"implements" é um comando para implementar uma interface e equivalente ao

"extends" das classes abstratas, só que ele é usado exclusivamente para interfaces.
Podemos fazer uma comparação entre uma "interface" e um projeto de engenharia.
Suponhamos um engenheiro civil programador queira que o programador faça um
programa para ele de construção de um prédio. O engenheiro quer também amarrar o
programa de forma que seja como se fosse um projeto de engenharia. Ele diz que o projeto-
programa deve ter: quatidade de cimento, quantidade de concreto, quatidade de vigas de
metal e número de operários. Além disso, ele quer no programa: cálculo estrutural e
cálculo das despezas. Para isto, o engenheiro cria uma interface assim:
package engenharia;
public interface IEdificil {
double getQtde_cimento();
double getQtde_concreto();
int getQtde_viga();
int getQtde_operario();
public void calcular_estrutura();

public void calcular_despezas();
}
---------------------------------------------------------
O programador sabe que baseado na interface, ele deve criar outra classe que no mínimo
deve ficar assim:
package engenharia;
public class Edificil implements IEdificil {
private double qtde_cimento;

private double qtde_concreto;
private int qtde_viga;
private int qtde_operario;
public Edificil() {
}
public double getQtde_cimento() {

return qtde_cimento;
}
public double getQtde_concreto() {

return qtde_concreto;
}
public int getQtde_viga() {

return qtde_viga;
}
public int getQtde_operario() {

return qtde_operario;
}
public void calcular_estrutura() {

}
public void calcular_despezas() {

}
}
-----------------------------------------------
Quanto ao que fazer com estes métodos, é uma outra estória. O que se sabe é que no
mínimo o programa deve ter este métodos e que eles dêem um resultado útil para que o
programador não seja mandado embora. O engenheiro mostra as fórmulas e diz para que
servem e fala para o programador, "te vira" e "tchau".
3.10 - Polimorfismo
Polimorfismo vem do grego e significa muitas formas. Em programação está
relacionado a técnica de colocar métodos diferentes com o mesmo nome para realizar
tarefas semelhantes em princípio (se for mau programado podem fazer coisas
completamente distintas). O polimorfismo é dividido em Polimorfismo Estático e
Dinâmico.
3.10.1 - Polimorfismo Estático (Sobrescrita)
Polimorfismo Estático é o mesmo que sobreescrita. Um exemplo de sobrescrita é o

caso do fragmento de código apresentado anteriormente no item 3.8 (métodos abstratos)
em que dois métodos estavam envolvidos. Na classe "Mamífero", havia um método
abstrato: "public abstract void numero_de_pernas()", este método foi substituída por um
método não abstrato, ou melhor, método concreto, com mesmo nome na subclasse:
"public void numero_de_pernas()". Este processo de substituição de um método de uma
superclasse por um método de uma subclasse é o que chamamos de sobrescrita ou
polimorfismo estático.
A sobrescrita não necessariamente é feita entre um método abstrato e outro
concreto, pode ser também entre dois métodos concretos.
A classe "Mamifero" passa a ser:
package mamifero;
public abstract class Mamifero{

public abstract void numero_de_pernas();

// indica que as subclasses terão que criar um método concreto equivalente a este
método

}
public Mamifero(){
-----------------------------------------------------------
package mamifero;

public void numero_de_pernas(){ // este método foi obrigado a ser criado

System.out.println("Homem tem duas pernas");
}
public void caracteristica_Ser_Humano(){

}
Observação:
É chamado de polimorfismo dinâmico porque é em tempo de execução que a JVM decide
que método deve ser implementado.
3.10.2 - Polimorfismo Estático (Sobrecarga)
Sobrecarga é o processo em que métodos distintos tem o mesmo nome, mas se
diferenciam pelo tipo de parâmetros passados, ou melhor, o tipo de variáveis entre os
parênteses é que vai diferenciar um método e outro. O compilador vai decidir quais os
parâmetros são mais adequados e assim, vai escolher o método a ser executado.
package sobrecarga;
public class Sobrecarga {
public int metodo_sobrecarregado(){ // não passa nenhum valor
System.out.println("método sobrecarregado 1");
return 0;
}
public float metodo_sobrecarregado(int a){ // passa uma variável inteira

return 0f;
}
public long metodo_sobrecarregado(float b){ // passa uma variável "float"

return 0L;
}
public int metodo_sobrecarregado(double c, boolean d){ // passa dois parâmetros
return 0;
}
}
Ao serem chamados estes métodos, a Java VM procura o método com o parâmetro
correspondente a chamada:
-----------------------------------------------------------------------------------------
package sobrecarga;
public class Main {
public Main() {
}
Sobrecarga sobrecarga = new Sobrecarga();
sobrecarga.metodo_sobrecarregado(5f); // chama o terceiro método, pois é único que

não tem parâmetro float a ser passado.
sobrecarga.metodo_sobrecarregado(); // chama o primeiro método, pois é único que não
tem parâmetro a ser parêntese.
sobrecarga.metodo_sobrecarregado(10d, true); // chama o último método acima, pois é
único que tem estes dois tipos "double" e "boolean".
}
------------------------------------------------------------------------------------
Resultado:
método sobrecarregado 3
-------------------------------------------------------------------------------------
3.11 - Qualificadores ou Modificadores de Acesso:

Dão o grau de privacidade do método, do atributo ou mesmo da classe.
public - Métodos ou Atributos declarados como "public" podem ser chamados por outros
métodos da própria classe e pelos métodos de qualquer outra classe, inclusive de outros
pacotes.
protected - Métodos ou variáveis declarados como "protected" podem ser chamados por
outros métodos da própria classe e pelos métodos da classe "filho".
private - Métodos ou variáveis declarados como "private" só podem ser chamados por
outros métodos da própria classe.
Há ainda o tipo "default" que é um modificador de acesso padrão. Sempre que não
for colocado nenhum modificador de acesso, a JVM (Java Virtual Machine) o colocará para
você, mas não ficará visível para o programador (ele fica implícito). O modificador
"default" permite a classe ser acessada somente por classes do mesmo pacote. Vejamos
como exemplo o programa desenvolvido pelo professor Belém em sala de aula no dia
05/03/2008 :
package rede;
public class Administrador extends Acesso {
public Administrador() {
}
public void mostraPerfil(){ // método que é chamado no método "main()" na "classe
Main" no comando "a.mostraPerfil();"
System.out.println("Estamos na classe Administrador: ");
perfil1(); // "perfil1()" chamam o método correspondente ao nome. Não é

necessário a criação de objeto.
// Porque os métodos são herdados da "classe Acesso".
perfil2();
perfil3(); // é "default" é herdado por "Administrador" por estar no mesmo pacote de

"Acesso".
// se for colocado "perfil4()" dará erro de compilação, já que ele é privado,

// "Administrador" só herda os métodos e atributos públicos, protegidos e default,
// se estiver no mesmo pacote.
------------------------------------------
package rede;
public class Acesso {
public Acesso() {
}
protected void perfil1(){ // Este é um método protegido, ele somente é acessível dentro da
classe e
// dentro das classes "filhos" da classe "Acesso", neste caso é a classe
Administrador.
System.out.println("Perfil1 é protegido acessível a classe Acesso e as classes filhos ");

}
public void perfil2(){ // Este é um método público, ele é acessível em qualquer classe.
// Sendo que fora da classe "Acesso" e das classes "filhos"
// o acesso é possível criando objeto por meio da chamada de um
construtor, usando "new".
System.out.println("Perfil2 acessível em qualquer classe");

}
void perfil3(){ // Este é um método "default", ele somente é acessível dentro de classes no
pacote local.
System.out.println("Perfil3 é default e acessível somente dentro do pacote");
}
private void perfil4(){ // Não permite acesso fora desta classe. Nem mesmo as classes
filhos têm acesso a esta classe.
System.out.println("Acesso ao perfil do usuario somente dentro desta classe");
}
}
---------------------------------------------
package local;
import rede.*; // Como a classe "Usuario" está em pacote diferente da classe "Acesso" é
necessário
// importar o pacote de "Acesso" que é "rede".
public class Usuario extends Acesso{
public void mostraPerfilUsuario(){

System.out.println("Estamos na classe Usuario: ");
perfil1();
perfil2();
// se for colocado "perfil3()" haverá erro de compilação, pois é "default" só acessível em

classe do mesmo pacote,
// mesmo havendo importação do pacote "rede"
-----------------------------------------------------------------------------------------------
projeto Rede
---------------------------------
package rede;
public class Main {

public Main() {
}

Administrador a=new Administrador (); // Criação do objeto "a" com todas as
características da classe Administrador.
// "new Administrador" cria o objeto que permite
acesso ao "clone" da classe
System.out.println("Estamos na classe Main: ");
a.mostraPerfil(); // chama o método "mostraPerfil" contido da

classe "Administracao()"
local.Usuario u = new local.Usuario(); // local.Usuario - local é o pacote, Usuario a
classe.
// isto foi feito porque a classe se encontra fora do
pacote.
// Fazer isto é dispensável se fizéssemos: "import
local.Usuario;"
System.out.println("Estamos na classe Main: ");

u.mostraPerfilUsuario(); // chama o método mostraPerfilUsuário();
}
3.12 - Construtor
É muito parecido com o método, mas tem propriedades que o diferencia dele (que
serão vistas somente mais adiante em um curso mais avançado). O construtor possibilita o
acesso a informações da classe e a criação de um objeto. O construtor pode estar explícito
ou implícito na classe, ou seja, vc pode ver ou não na classe, mas ele sempre estará lá! No
programa de referência, você vai encontrá-lo no fragmento de código:
public Main() {
}
public Calculo() {
Ao contrário do método, o construtor não retorna valor nunca. Ele pode realizar
tarefas, como operações matemática, por exemplo, de dentro de seu escopo (o lugar entre as
chaves { }) como um método normal. É fácil reconhecer um construtor, ele é parecido com
o método, tem um parêntese ao lado (com ou sem parâmetros dentro dele) e seu escopo é
delimitado por {} como no método. Todavia tem o mesmo nome da classe e começa com
letra maúscula. Como método comum, ele pode fazer passagem de parâmetros comum.
Veja o exemplo deste código em que o construtor é usado como se fosse um método
comum no programa do professor Belém feito em aula no dia 05/03/2008 :
package oobasico3;
public class Main {
public Main() {
}

Classe1 c= new Classe1("Jorge",23);
System.out.println (c.getNome());
System.out.println(c.getIdade());
------------------------------------------------------------------------------------------
package oobasico3;
public class Classe1 {

private String nome;
private int idade;
public Classe1(String n, int i) { // o construtor aqui é usado como se fosse um método comum.
nome = n;
idade = i;
}
public String getNome(){// o retorno pode ser feito de 2 formas ou get ou toString
return nome;
}
public int getIdade(){

return idade;
}
public String toString(){//Objeto retorna todos os dados juntos

return nome + " " + idade;
}
-----------------------------------------------------------------------------------------------------------------------
Resultado:
Jorge
23
Recomendações:
1 - Não trabalhar com variáveis fora das classes, somente trabalhe com métodos set/get
correspondentes as variáveis. Faça, portanto, encapsulamento, caso os dados sejam usados
fora da classe. Os atributos devem ser privados (usando private) e os métodos com
set/get deverão fazer o papel dos atributos.
2 - Não criar métodos dentro da classe "Main" todas as operações deverão ser realizadas
em métodos de outras classes criadas para as tarefas específicas. Lembre-se o método
main(), assim como a classe Main são como se fossem chefes, eles não realizam tarefas
em si, eles só mandam os outros realizar as tarefas.
3 - Usar somente uma classe por arquivo, ela deve ser pública e começar com letra
maúscula.
4 - Usar uma classe por categoria de tarefas e um método por tarefa a ser executada.
5 - Classes devem começar por letras maúscula. Métodos e Variáveis devem escritos com
letras minúsculas. Constantes devem ser escritas em caixa alta e dentro de "interface".
Capítulo IV - Funcionalidades
Importantes
4.1 - Vetor
Vetor agrupa elementos com mesmo tipo(String, double, int etc.), sendo que cada
elemento fica em uma posição correspondente a índice, exemplo:
Suponhamos que eu tenha guardado no vetor "v[ ]" números na seguinte ordem
{7,5,9,8,5,9}. Se quisermos exibir elementos do vetor teremos que colocar valores no
índice. O vetor começa com a posição "0" nesta posição ficará o número "7", na posição
"1" ficará o valor "5", na posição "2" ficará "9" e assim por diante. Se quisermos, por
exemplo, ver o que há na posição na posição, teremos que colocar o valor da posição entre
as chaves "[ ]" e imprimir o resultado: "System.out.println(v[3])". Será mostrado como
resultado, o valor: "8".
Para atribuirmos os valores listados em {7,5,9,8,5,9}ao vetor podemos fazer variar o índice
do vetor:
v[0]=7;
v[1]=5;
v[2]=9;
v[3]=8;
v[4]=5;
v[5]=9;
Só que fazer isto dá muito trabalho, imagina fazer isto para um vetor que tenha tamanho de
"1000"! uma forma de diminuir nosso trabalho é colocar todos estes valores de uma só vez.
String v[] ={7,5,9,8,5,9};
Neste caso atribuímos os valores ao vetor, ao mesmo tempo em que declaramos o

tipo do vetor. Nem sequer é necessário dimensionar o tamanho do vetor, pois o tamanho já
está implícito.
Supondo que queiramos colocar os valores em tempo de execução em um outro vetor, o
vetor "v2[]" pode nos ajudar "for":
Scanner input=new Scanner(System.in);
for(int k=0;k<6;k++){
v2[k]=input.nextInt();
Entretanto, ainda ficou faltando declarar e dimensionar o tamanho do vetor. Isto

pode ser feito da seguinte forma neste caso:
"int v[]=new int[10]" estamos dizendo aí que é um vetor de "10" posições, lembrando
que o índice começa do "0", por isto, o valor vai variar de "0" até "9".
Uma pergunta que o leitor deve estar se fazendo, se o vetor tem tamanho de seis,
por que colocamos o tamanho dele em "10". Na hora da declaração, podemos não saber,
em alguns casos, que tamanho máximo o vetor pode assumir, por isto, é recomendável se
colocar um valor em que tenhamos certeza que o vetor não vai "estourar", ou melhor,
tamanho que garanta que o vetor guarde todos os elementos desejados na pior das
hipóteses.
Lembrete: Scanner só funciona fazendo a importação de: import java.util.Scanner;
A declação do vetor é genericamente:
<tipo> <nome do vetor>[] = new <tipo>["tamanho do vetor"]
<tipo> pode ser String, double, int etc. <nome do vetor> é arbitrário depende da
conveniência do usuário. [Tamanho do vetor] deve ser o tamanho máximo que um vetor
pode atingir. Exibir:
-----------------------------------------------------------------
package teste;
public class Vetor {

double v1[]=new double [3];
String v2[]={"A","B","C"};
String v3[]=new String[3];
public void vetor_metodo(){
v3[0]="F";
v3[1]="G";
v3[2]="H";
for(int k=0;k<3;k++){
v1[k]=2*k;
}
for(int i=0;i<3;i++){
System.out.println("no vetor v1 na posição " + i + " o valor do vetor é " +

v1[i]);
System.out.println("no vetor v2 na posição " + i +" o valor do vetor é " + v2[i]);
System.out.println("no vetor v3 na posição " + i + " o valor do vetor é " +
v3[i]);
}
-----------------------------------------------------------------------------------
package teste;
public class Main {
public Main() {
}
Vetor v=new Vetor();

v.vetor_metodo();
}
---------------------------------------------------------------------------------------
Resultado:
no vetor v1 na posição 0 o valor do vetor é 0.0
no vetor v2 na posição 0 o valor do vetor é A
no vetor v3 na posição 0 o valor do vetor é F
no vetor v2 na posição 1 o valor do vetor é B
no vetor v3 na posição 1 o valor do vetor é G
no vetor v2 na posição 2 o valor do vetor é C
no vetor v3 na posição 2 o valor do vetor é H
4.2 - Lista
Lista é semelhante a um vetor, só que não tem tamanho determinado e os valores
são alocados sem necessidade de se saber sua posição ou índice.
A Lista em Java é feita sem a necessidade de uso de ponteiro de maneira explícita. Para
criar a Lista é necessário a criação de objeto: "List nome_da_lista = new ArrayList()".
Há a adição de um novo elemento na lista por meio do método 'add("expressão")'. Se
fizermos por exemplo:
List lista = new ArrayList();.

public void lista_add(){
lista.add("A");
lista.add("B");
lista.add("C");
System.out.println("A lista é: "+ lista);
Se o método "lista_add()" se chamado terá o seguinte resultado:
A lista é: [A, B, C]
--------------------------------------------------------------------------------------------------------------
-----------------------------
O método mostra o elemento gravado na lista é o 'get(indice)'. Índice começa a partir do 0.
public void lista_get(){

lista.add("A");
lista.add("B");
lista.add("C");
System.out.println("Na posição 0 está: "+ lista.get(0));
}
Se "lista_get()" for executado teremos o seguinte resultado:
Na posição 0 está: A
Na posição 1 está: B
Na posição 2 está: C
--------------------------------------------------------------------------
Eis aqui um exemplo de um programa completo feito pelo professor Edson Belém em aula
no dia 25/04/2008.
package array;
public class Main {
public Main() {
}

Array1 a = new Array1();
a.addNumero(14*2);
a.addTexto("adsfsdsd");
System.out.println(a.listagem());
Array2 a2 = new Array2();

a2.addNome("Ewerton");
a2.addNome("Thiago");
a2.addNome("Gustavo");
a2.addNome("Antony");
System.out.println(a2.listagemNome());
System.out.println(a2.getListagemNome(3));
---------------------------------------------------------------------------------------------------
package array;
public class Cliente {

private int idade;
public Cliente() {
}

return nome;
}
public void setNome(String nome) {

this.nome = nome;
}
public int getIdade() {

return idade;
}
public void setIdade(int idade) {

this.idade = idade;
}
}
-------------------------------------------------------------------------------------------------------
package array;
import java.util.ArrayList;
import java.util.List;
public class Array1 {
List lista1 = new ArrayList();

//vetor de tamanho indeterminado
public void addNumero(double n1){
lista1.add(n1);
//método add é para vetor, armazena qualquer tipo de campo no vetor
}
//add também irá possuir listagem
public void addTexto(String texto){
lista1.add(texto);
}
public List listagem(){

return lista1;
//Mostra todos os dados armazenados
}
public Array1() {
}
--------------------------------------------------------------------------------------------------------------
--------------
package array;
import java.util.ArrayList;
import java.util.List;
public class Array2 {
List lista1 = new ArrayList();

String nome;
public void addNome(String n){

lista1.add(n);
}//addVariável(Método para adicionar)
//listagemVariável() retorna todo o conteúdo
//getListagemVariavel(pos) retorna a posição especificada
public List listagemNome(){

return lista1;
}
public Object getListagemNome(int pos){

return lista1.get(pos);
}
public Array2() {
}
}
----------------------------------------
Terá o seguinte resultado:
[28.0, adsfsdsd]
[Ewerton, Thiago, Gustavo, Antony]
Antony
4.3 - Controle de Excessões

Não dá para analisar try, catch e finally em separados, por isto, iremos analizá-los
conjuntamente. Incluímos "try-catch-finally" em controle de fluxo por ser desviado o fluxo
de execução quando eles são acionados em caso de erro.
4.3.1 - try - catch - finally
O "try" faz tentativa de execução das instruções. É usado para os casos em que há
risco grande de os comandos não serem executados. "try" terá que estar acompanhado de
um dos dois comandos: "catch" ou "finally" ou de ambos, caso isto não aconteça a JVM
"reclamará". Ele interromperá a instrução de onde há um erro e dará um salto para o
"catch" (caso este exista) ou para "finally"(caso este exista). O comando "catch" tem
como finalidade mostrar uma mensagem de erro caso a operação não seja feita. "finally" é
executado havendo erro ou não durante a execução.
Eis um fragmento de código que é necessário o uso de "try-catch-finally":
package tentativa;
public class Tentativa_de_Calculo {
public void tentando_calcular(){

System.out.println("Este programa calcula a divisão de dois números");
try{
System.out.println("Ponha o primeiro número: ");
double num1=input.nextDouble();
System.out.println("Ponha o segundo número: ");
System.out.print("O Resultado da divisão de "+num1+"/"+num2+"=");

System.out.println(num1/num2);
System.out.println("Calculo realizado com sucesso!");
}catch(Exception e){
System.out.println("");
System.out.println("Alguma falha ocorreu durante a execução.");
} finally{
System.out.println("Obrigado pela preferência do nosso serviço, volte sempre!");
}
}
}
-------------------
Se eu digitar "15" e "3" depois da mensagem "Ponha o primeiro número: " e "Ponha o
segundo número:" respectivamente teremos o seguinte resultado:
Este programa calcula a divisão de dois números

Ponha o primeiro número:
15
Ponha o segundo número:
3
O Resultado da divisão de 15.0/3.0=5.0
Calculo realizado com sucesso!
Obrigado pela preferência do nosso serviço, volte sempre!
Por que é tão arriscado assim fazer esta conta matemática? Afinal, é apenas uma divisão
simples entre dois números (num1/num2).
Em verdade, muita coisa pode dar errado. Vamos supor que por distração coloquemos um
caracter em vez de número quando for solicitado. Teremos o seguinte resultado:

c
Alguma falha ocorreu durante a execução.

Repare que "finally" é executado apesar de ter havido erro.
4.3.2- throw - throws

Vamos agora supor que por alguma distração, coloquemos "0" no segundo número.
Curiosamente, não teremos erro:

15
0
O Resultado da divisão de 15.0/0.0=Infinity
Calculo realizado com sucesso!
A JVM deu como resultado infinito, o compilador aceitou a divisão por zero. Mas
talvez o programador não aceite este resultado e queira que quando houver uma divisão por
zero, seja mostrado no console uma mensagem de erro. Para isto, devemos usar uma classe
de Excessão, além de comandos: throw-throws. Usando estas ferramentas, vamos colocar
a seguinte mensagem: "Erro! Divisão por Zero". O código ficará assim:
package tentativa;
public class Tentativa_de_Calculo {
public void tentando_calcular() throws Throwable{

System.out.println("Este programa calcula a divisão de dois números");
try{
Exception e=new Exception();
System.out.println("Ponha o primeiro número: ");
System.out.println("Ponha o segundo número: ");
if(num2==0) throw new Throwable("Erro! Divisão por Zero");
System.out.print("O Resultado da divisão de "+num1+"/"+num2+"=");
System.out.println(num1/num2);
System.out.println("Calculo realizado com sucesso!");
System.out.println("");
System.out.println("Alguma falha ocorreu durante a execução");
} finally{
System.out.println("Obrigado pela preferência do nosso serviço, volte sempre!");

}
}
------------------------------------------------------------------------------
Agora se escrevermos o código teremos o seguinte resultado:

15
0
Exception in thread "main" java.lang.Throwable: Erro! Divisão por zero
at tentativa.Tentativa_de_Calculo.tentando_calcular(Tentativa_de_Calculo.java:20)
at tentativa.Main.main(Main.java:17)
Java Result: 1
------------------------------------------------------------------
package tentativa;
public class Main {
public Main() {
}
public static void main(String[] args) throws Throwable{
Sistema sistema = new Sistema();

// sistema.mostra1();
// sistema.mostra2();
Tentativa_de_Calculo tc= new Tentativa_de_Calculo();
tc.tentando_calcular();
}
---------------------------------------------------------------------
A divisão não foi executada e nossa mensagem de erro apareceu! Para que isto
ocorresse foi acrescentado a linha de comonado:
'if(num2==0) throw new Throwable("Erro! Divisão por Zero")' esta linha diz a JVM
se "num2" for igual a zero desvie a execução para a mensagem de erro: '("Erro! Divisão
por Zero")' e não execute mais nada! E nada mais foi executado. Inclusive sequer entrou
na estrutura do "catch". Throwable é responsável pelo tratamento de excessões, ou melhor,
de erro. Tratar erro significa simplesmente identificar onde está ocorrendo o erro, parar
execução e mandar uma mensagem se possível identificando que erro ocorreu. Repare
também que foi colocado também o comando: throws Throwable no método. É para dizer
que dentro deste método haverá um tratamento de erro advindo Throwable.
-------------------------------------------------------------------------------------
4.4 - Arquivos
Há algumas classes muito úteis para criação e gravação em arquivos, entre elas
estão: PrintWriter e RandomAccessFile. Em baixo, no próprio cometário está explicado
como trabalha as funcionalidades. Trabalhar com arquivos é sempre uma operação
arriscada pois o arquivo ou diretório podem não estar acessíveis ou impossibilitados de
serem criados. Por isto, é sempre necessário o uso de "try" toda vez que lidamos com
gravação, criação de arquivos ou qualquer operação com arquivos. As seguintes chamadas:
"PrintWriter p = new PrintWriter (new FileWriter("c:/banco.txt"));" e
"RandomAccessFile rw=new RandomAccessFile("c:/banco1.txt","rw");" criam
respectivamente os arquivos vazios "banco.txt" e "banco1.txt". Para gravar nos arquivos
foram usados "p.print(nome)" e "rw.writeBytes("próxima
frase:"+"\n"+nome+"\n")", sem estes comandos o arquivos continuariam vazios.
package oobasico1;
import java.io.*;
public class Cliente {


System.out.println ("Escreva uma frase: ");
Scanner in=new Scanner (System.in);
nome=in.nextLine();
}
return nome;
}
public Cliente() {
}
public void grava(){ // este método faz a gravação
try{ // try faz tentativa de execução dos comandos a seguir

// é usado para os casos em que há risco grande de os comandos
// não serem executados
PrintWriter p = new PrintWriter (new FileWriter("c:/banco.txt"));
// comando acima cria o arquivo banco.txt
p.print(nome);
// grava o valor digitado, mas se vc executar novamente o arquivo,
// tudo o que vc escrever vai sobrescrever o que foi escrito anteriormente.
p.close(); // fecha o arquivo.

System.out.println ("Dados Gavados no banco.txt");
// caso a tentativa de gravação dê errado, "catch" é acionado.

System.out.println (e.getMessage()); // e.menssage exibe a mensagem
//de erro padrão
}
}
public void grava2(){
try{
// os comandos abaixo também criam e gravam arquivos.
RandomAccessFile rw=new RandomAccessFile("c:/banco1.txt","rw");
// comando acima cria o arquivo banco.txt
rw.seek(rw.length()); // este comando não deixa gravar por cima
rw.writeBytes("próxima frase:"+"\n"+nome+"\n"); // escreve na linha abaixo
rw.close(); // fecha o arquivo
System.out.println("Dados Gavados no banco1.txt");
}catch (Exception e){

System.out.println (e.getMessage());
}
}
4.5 - Banco de Dados
Aqui vamos falar de uma consulta simples e inserção em um banco de dados do

mysql. Para estabelecer a conexão no banco de dados do mysql sempre precisaremos dos
comandos a seguir (como se fosse uma receita de bolo): "Connection con=null",
"Class.forName("com.mysql.jdbc.Driver")" e
"con=DriverManager.getConnection("jdbc:mysql://localhost:3306/banco3","root","coti")"
estão relacionados ao drive do banco de dados e a conexão em si.
"PreparedStatement stmt= con.prepareStatement("comando sql")" é responsável por
executar comandos sql, quando temos, por exemplo: "PreparedStatement stmt=
con.prepareStatement("select * from aluno")" estamos dizendo para o mysql execute o
comando: select * from aluno; este comando mostra tabela inteira cujo o nome é aluno (Veja no
Apendice B os comandos básicos do mysql) (Este apendice ainda não existe).
O "PreparedStatement stmt=con.prepareStatement("insert into aluno values(?,?)")"
faz um comando sql:"insert into aluno values(?,?);" comando é responsável inserção de valores
na tabela "aluno". Ficaram faltando os valores na posição onde se encontram os pontos de
interrogações(?), estes valores são dados por: "stmt.setString(1,alu.getNome())" e
"stmt.setInt(2,alu.getIdade())" , "1" indica que stmt.setString(1,alu.getNome()) será gravado na
posição 1, ou melhor, em cima da primeira interrogação e o "2" na segunda posição ou em cima da
segunda interrogação. Seria como se fizesse: insert into aluno values(alu.getNome()
,alu.getIdade()).
Despois eu tiro as gozações no programa:

Banco 26-3
-------------------------------------------------------------------------------------------------------
package banco;
public class Main {
public Main() {
}

Aluno aluno=new Aluno();
aluno.lerNome();
aluno.lerIdade();
BancoAluno gb=new BancoAluno();

gb.abreBanco();
gb.insereTabela(aluno);
gb.consultaTabela();
}
----------------------------------------------------------------------------------------------------------
package banco;
public class Aluno {

private String nome; //no MySQL o nome foi varchar
private int idade;

System.out.println("Nome");
Scanner in = new Scanner(System.in);
nome=in.nextLine();
}
public void lerIdade(){
System.out.println("Idade");
Scanner in = new Scanner(System.in);
idade=in.nextInt();
}
public Aluno() {
}

return nome;
}
public int getIdade() {

return idade;
}
}
----------------------------------------------------------------------------------------------------------
package banco;
import java.sql.Connection; // Biblioteca necessaria para mysql
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
public class BancoAluno {

Connection con=null;
public void abreBanco(){
try{
Class.forName("com.mysql.jdbc.Driver");
// Acessa o drive do mysql. Mysql é banco usando sql da Microsoft
con=DriverManager.getConnection("jdbc:mysql://localhost:3306/banco3","root","coti
");
// Con recebe dados de conexão. root é o login e coti é a senha.
}
}
public void insereTabela(Aluno alu){
try{
PreparedStatement stmt=con.prepareStatement("insert into aluno values(?,?)");
// prepareStatement prepara a conexão para receber comandos sql
// insert into aluno values(?,?), são comandos sql para inserir dados na tabela
// aluno. As interrogas pedem os comandos abaixo, no primeiro ? entra
// "alu.getNome()" e no segundo ? entra "alu.getIdade()"
stmt.setString(1,alu.getNome()); // 1 indica que "alu.getNome()" está na primeira "?"
// setString é usado para atribuir valores inteiros
stmt.setInt(2,alu.getIdade()); // 2 indica que "getIdade()" está na segunda "?"
// setInt é usado para atribuir valores inteiros
stmt.execute(); // executa os comandos sql
stmt.close(); // fecha a execução.
System.out.println("Dados Gravados");
}
}
public void consultaTabela(){
try{
PreparedStatement stmt= con.prepareStatement("select * from aluno");
// prepara o comando para obter a tabela
ResultSet rs = stmt.executeQuery();
// executa a consulta
while (rs.next()){
//percorre do inicio ao fim (do primeiro registro ao ultimo da tabela)
System.out.println("Nome" + rs.getString("nome"));
System.out.println("Idade" + rs.getInt("idade"));
System.out.println("----------------------");
}
rs.close();
stmt.close();
System.out.println("Consulta Realizada");
}
}
public BancoAluno() {
}
}
--------------------------------------------------------------------------------------------------------------
/////////Startar o mySQL///////{
1º Clica em iniciar>executar e digita services.msc
2º Na aba Serviços (local) escolha MySQL
}
//Cria o banco
mysql> create database banco3;
//conecta o banco
mysql> use banco3
Database changed
//Cria a tabela
mysql> create table aluno(nome varchar (35), idade int);
//Inserir os dados na tabela

mysql> insert into aluno values ('Diego',20);
mysql> insert into aluno values ('Escadinha',19);
mysql> insert into aluno values ('Lentilha',15);
//Descrição da tabela
mysql> desc aluno;
+-------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| nome | varchar(35) | YES | | NULL | |
| idade | int(11) | YES | | NULL | |
+-------+-------------+------+-----+---------+-------+
//Mostra o conteudo da tabela;

mysql> select * from aluno;
+-----------+-------+
| nome | idade |
+-----------+-------+
| Diego | 20 |
| Escadinha | 19 |
| Lentilha | 15 |
+-----------+-------+
//Atualiza a tabela aluno mudando o nome para thiago quando a idade for 15
update aluno set nome='Thiago' where idade=15
//Update e delete estão sempre em condição.
Apendice A
Tabela 1 - Palavras reservadas em Java:
abstract class extends implements null strictfp

true assert const false import package
super try boolean continue final instanceof
private switch void break default finally
int protected synchronized volatile byte do
float interface public this while case
double for long return throw catch
else goto native short throws char
enum if new static transient
As palavras reservadas já tem uma função pré-definida no java e não podem ser usadas em
outra coisa, senão nas funções originalmente
definidas pela SUN (criadora do Java).
Aqui eu darei uma receita de bolo para se criar uma classe. Ainda está em construção
Receita de bolo:
<qualificador de acesso> class <nome da classe>{
<qualificador de acesso><tipo><nome do atributo>

<qualificador de acesso>void<nome do método>(<tipo><parâmetro>// caso
existam){ // método sem retorno
<realizar as operações>
}
<qualificador de acesso><tipo><nome do método>( <tipo><parâmetro>// caso
existam){ // método com retorno
<realizar as operações>
return <valor>
}
}

Fundamentos da Programação Java em

Загружено:

Сведения о документе

Исходное описание:

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Fundamentos da Programação Java em

Загружено:

Авторское право:

Доступные форматы

Capitulo I - Fundamentos e Operações

1.1 - Tipos de Dados

Tipos de Primitivas de Dados

Tipo Categoria Número de Alcance

1.1.1 - Tipo boolean

1.1.2 - Tipo byte, short, int, long

byte x=180; // está errado, pois x>127

Há uma espécie de hierarquia de tipos inteiros:

byte < short < int < long

O tipo "long" é o mais extenso de todos. Vai de -9x10e18 a 9x10e18. É recomendável

1.1.3 - Tipo float e double

Ordem dos tipos

1.1.4 - Tipo Char

String nome="Professor Edson Belem";

"nome" armazenará inclusive os espaços na frase.

// Tirar dúvida com o Belém e ver se as primitivas não na verdade classes.

1.1.6 - Conversão de Tipos:

r=a; // dá erro de compilação o tipo de "a" (long) é maior do que o

Operador Significado Categoria de

1.2.1 - Operadores Aritméticos

47 % 10 = 7 // O resto da divisão de 47 por 10 é 7.

Os demais operadores aritméticos são:

Operador Operação Resultado

1.2.2 - Operadores Relacionais

6==6; // o resultado é "true"

Os demais operadores relacionais são:

Operador Operação Resultado

public void teste(){

public void comparacao() {

1.2.3 - Operadores Lógicos

Vamos supor uma declaração:

public static void comparacao(){

Operador Operação Resultado

Observação muito Importante:

1.2.4 - Operadores de Atribuição

++ serve para acrescentar uma unidade ao variável.

public void atribuicao(){

x+=y; equivale a x=x+y;

Arquivo 74_java pag. 6

pag. 9 / Apostila de Java

1.3 - Entrada e Saída

public void saida(){

public void saida(){

public void saida(){

Há duas forma de impressão mais conhecidas: "System.out.print()" e

public void mostra1(){

String a="A única coisa ";

Caso este fragmento de código seja acionado, teremos o seguinte resultado:

public void mostra2(){

String a="A única coisa ";

O segundo fragmento de código dará o seguinte resultado:

Usando "System.out.println()" as coisas mudam. "a","b","c","d" e "e" têm contida uma

"input.nextShort();" - Possibilita a leitura da variável de tipo "short".

import java.util.Scanner; // possibilita que os comandos de entrada sejam usados no

public class Entrada_Dados{

public void entrada(){

System.out.println ("Coloque o número inteiro: ");

System.out.println ("Coloque o número real (tipo double): ");

System.out.println ("Coloque uma palavra ou frase: ");

System.out.println ("Você digitou respectivamente: " + numero_real + " " +

Poderemos ter o seguinte resultado:

Observação muito Importante: