Java aprendendo linguagem.ppt

JAVA
APRENDENDO A LINGUAGEM
Instituição: SENAC
Módulo : Aplicações para WEB – Java
Carga Horária: 60 horas
Instrutor: Ricardo José Menezes Maia

CONCEITOS DE PROGRAMAÇÃO ORIENTADA A OBJETOS
Para programarmos em uma linguagem orientada a objetos é necessário conhecer os
seguintes conceitos:
• Objeto
• Mensagem
• Classe
• Herança
Logo após será necessário traduzir os conceitos acima em código java

OBJETO
Possui comportamento e características/estados
cachorro – característica/estado(cor, nome, raça, fome)
– comportamento(latir, balançar rabo)
Estados e características atributos.
Comportamento métodos.
Um objeto que contenha características e comportamento específico é chamado de instância.
Ex: vira-lata é uma instância de cachorro.
// Ponto.java
class Ponto {
Ponto(int x, int y) {
System.out.println("Novo objeto ponto criado ("+x+", "+y+")");
}
public static void main(String s[]) {
Ponto p = new Ponto(2, 3);
Ponto p1 = new Ponto(3, 4);
}
}

ATRIBUTO
// Ponto.java
class Ponto {
int x;
int y;
this.x = x;
this.x = x;
System.out.println("Novo objeto ponto criado ("+this.x+", "+this.y+")");
}
}
}

MÉTODO
class metodo {
int x, y;
metodo(int x, int y) {
this.x = x;
this.y = y;
System.out.println("Novo objeto metodo criado ("+this.x+", "+this.y+")");
}
void Move(int deslocamento) {
this.x = this.x + deslocamento; // this.x += deslocamento
}
void ExibeCoordenada() {
System.out.println("Coordenada ("+this.x+", "+this.y+")");
}
metodo p = new metodo(2, 3);
p.Move(20);
p.ExibeCoordenada();
}
}

MÉTODO CONSTRUTOR
class metodo {
int x, y;
metodo(int x, int y) {
this.x = x;
this.x = x;
System.out.println("Novo objeto metodo criado ("+this.x+", "+this.y+")");
}
void Move(int deslocamento) {
this.x = this.x + deslocamento; // this.x += deslocamento
}
void ExibeCoordenada() {
System.out.println("Coordenada ("+this.x+", "+this.y+")");
}
metodo p = new metodo(2, 3);
p.Move(20);
p.ExibeCoordenada();
}
}

MENSAGEM
Objetos comunicam-se através de mensagens.
// Ponto.java
class Ponto {
int x;
int y;
this.x = x;
this.y = y;
}
void desloca_x(int x) {
this.x = this.x+x;
}
}
// Desenha.java
public class Desenha {
p.desloca_x(2);
}
}

SOBRECARGA
É permitido incluir numa classe métodos que possuem o mesmo nome e o mesmo tipo de
retorno, mas que diferem pelo número e/ou pelos tipos dos argumentos.
// Ponto.java – sobrecarga de construtor
class Ponto {
int x, y;
double a, b;
this.x = x;
this.y = y;
System.out.println(“Construtor int”);
}
Ponto(double x, double y) {
this.a = x;
this.b = y;
System.out.println(“Construtor double”);
}
Ponto p = new Ponto(2,3);
Ponto p1 = new Ponto(2.4,5.9);
}
}

CLASSE
Define atributos e métodos comuns a todos objetos de um certo tipo.
// Ponto.java
class Ponto {
System.out.println("Novo objeto ponto criado ("+x+", "+y+")");
}
}
}

HERANÇA
superclasse
subclasse subclasse
Conjunto das propriedades e especificações assim transmitidas de uma classe para
outra(s)
// filho.java
public class pai {
}
class filho extends pai {
}

PACOTE
Coleção de tipos relacionados.
|___grafico
|____ponto
|____linha
Criar pasta grafico
// ponto.java
package grafico;
public class ponto {
}
// linha.java
package grafico;
public class linha {
}
// Desenhar.java
import grafico.*; // import grafico.ponto;
public class Desenhar {
ponto p;
}
}

Exercício:
Colocar ponto dentro do pacote game, o qual deverá ser criado

NÍVEIS DE ACESSO
SIMSIMSIMSIMpublic
NÃOSIMSIMSIMprotected
NÃONÃOSIMSIMNão definido
NÃONÃONÃOSIMprivate
TodosSubclassePacoteClasse
CONTROLANDO ACESSO A MEMBROS DE UMA CLASSE

Somente a classe tem acesso.
PRIVATE
// Ponto.java
class Ponto {
private int x, y;
Ponto (int x, int y) {
this.x=x;
this.y=y;
}
private void desloca_x(int desloc) {
x = x + desloc;
}
}
// Desenho.java
class Desenho {
public static void main(String args[]) {
p.x=3;
p.desloca_x(4);
}
}

Desenho.java:5: x has private access in Ponto
p.x=3;
^
Desenho.java:6: desloca_x(int) has private access in Ponto
p.desloca_x(4);
^
2 errors
ERRO
javac Desenho.java

PRIVATE
// Ponto.java
class Ponto {
private int x, y;
this.x=x;
this.y=y;
}
private void desloca_x(int desloc) {
x = x + desloc;
}
}
// Desenho.java
class Desenho extends Ponto {
Desenho(int x, int y) {
super(x,y);
}
Desenho des = new Desenho(2,3);
System.out.println(des.x);
}
}

Desenho.java:19: x has private access in Ponto
System.out.println(des.x);
^
1 error
javac Desenho.java
ERRO

Exercício:
Nos dois programas anteriores mudar de private para protected e verificar o que
ocorre.

PROTECTED
package grafico;
// Ponto.java
class Ponto {
protected int x, y;
this.x=x;
this.y=y;
}
protected void desloca_x(int desloc) {
x = x + desloc;
}
}
import grafico.*;
// Desenho.java
class Desenho {
System.out.println(p.x);
}
}
Somente a classe e quem herda tem acesso.
Criar a pasta grafico
Copiar Ponto.java para a pasta grafico

Desenho.java:31: grafico.Ponto is not public in grafico; cannot be accessed from
outside package
^
Desenho.java:31: grafico.Ponto is not public in grafico; cannot be accessed from
outside package
^
2 errors
javac Desenho.java
ERRO

Exercício:
Fazer com que Desenho herde Ponto e verificar o que será necessário ou não ajustar
para que Desenho seja compilado corretamente.

INTERFACE
Assim como a classe uma interface define métodos, sendo que os métodos nunca são
implementados na interface.
Classes que implementam interface devem implementar os métodos definidos pela interface.
Uma classe pode implementar múltiplas interface.
interface cachorro {
public void latir();
}
public class vira_lata implements cachorro {
public void latir() {
}
vira_lata dog = new vira_lata();
}
}

ABSTRACT
A classe representa um modelo que será instanciado.
abstract class cachorro {
public void latir(){
}
abstract void comer();
}
public class vira_lata extends cachorro {
public void latir() {
}
void comer() {
}
vira_lata dog = new vira_lata();
}
}

// nome do arquivo: polimorf.java
interface Gritador {
void grita();
}
class Humano implements Gritador {
public void grita() {
System.out.println("AAAAAAHHHHH");
}
}
class Macaco implements Gritador {
System.out.println("IIIIIIIIHHHHHHHI");
}
}
public class polimorf {
void facaAlgo(String especie) {
Gritador b;
if(especie.compareTo("humano")==0) {
b = new Humano();
} else {
b = new Macaco();
}
b.grita(); // chamada polimórfica
}
public static void main(String argumento[]) {
polimorf p = new polimorf();
p.facaAlgo(argumento[0]);
}
}
POLIMORFISMO

// nome do arquivo: polimorf.java
interface Gritador {
void grita();
}
class Humano implements Gritador {
System.out.println("AAAAAAHHHHH");
}
}
class Macaco implements Gritador {
System.out.println("IIIIIIIIHHHHHHHI");
}
}
public class polimorf {
Gritador b;
b = new Humano();
} else {
b = new Macaco();
}
}
polimorf p = new polimorf();
}
}
POLIMORFISMO - INTERFACE

// nome do arquivo: polimorf1.java
class Gritador {
void grita() {
System.out.println("generico");
}
}
class Humano extends Gritador {
System.out.println("AAAAAAHH");
}
}
class Macaco extends Gritador {
System.out.println("IIIIIIIIHHHHH");
}
}
public class polimorf1 {
Gritador b;
b = new Humano();
} else {
b = new Macaco();
}
}
polimorf1 p = new polimorf1();
}
}
POLIMORFISMO - HERANÇA

VARIÁVEIS
Nome
Começa com letras
Pode ter número ou _
Scopo (tempo de vida)
// Scopo.java
class Scopo.java {
int a=34;
if (a!=0) {
int b = 17;
}
System.out.println(“Valor b “+ b);
}
}

true ou falseA valor boleano (true or false)boolean
16-bit caracter UnicodeUm simples characterchar
Outros Tipos
64-bit IEEE 754
Dupla precisão de ponto
flutuante
double
32-bit IEEE 754
Simples precisão de ponto
flutuante
float
Números Reais
64-bit complemento de 2Inteiro longolong
32-bit complemento de 2Inteiroint
16-bit complemento de 2Inteiro curtoshort
8-bit complemento de 2Bytebyte
Inteiros
Tamanho/FormatoDescrição
Palavra
Reservada
Tipos de Dados Primitivos

Sinal (1) | Expoente (8) | Mantissa (23)
Bits
IEEE 754
Para número negativo usar complemento de 2
NÚMERO EM PONTO FLUTUANTE

//inteiros
byte largestByte = Byte.MAX_VALUE;
short largestShort = Short.MAX_VALUE;
int largestInteger = Integer.MAX_VALUE;
long largestLong = Long.MAX_VALUE;
//números reais
float largestFloat = Float.MAX_VALUE;
double largestDouble = Double.MAX_VALUE;
//outros tipos primitivos
char aChar = 'S';
boolean aBoolean = true;
INICIALIZAÇÃO

// Constante.java
class Constante {
final int aFinalVar = 0;
Constante c = new Constante();
c.aFinalVar=23;
System.out.println(c.aFinalVar);
}
}
CONSTANTE

OPERADORES
op-- --op--
op++ ++op++
op1 % op2%
op1 / op2/
op1 * op2*
op1 - op2-
op1 + op2+
Uso
Operador
Aritmético

public class AritimeticaDemo {
public static void main(String[] args) {
//poucos numeros
int i = 37;
int j = 42;
double x = 27.475;
double y = 7.22;
//adição
System.out.println("Adição...");
System.out.println(" i + j = " + (i + j));
//subtração
System.out.println("Subtração...");
System.out.println(" i - j = " + (i - j));
//Multiplicação
System.out.println(" i * j = " + (i * j));
//Divisão
System.out.println(" i / j = " + (i / j));
//Resto de divisão
System.out.println(" i % j = " + (i % j));
//misturando tipos
System.out.println(" i * x = " + (i * x));
}
}

// Operador.java
class Operador {
int i=5;
System.out.println(“(i++/2)” + (i++/2));
System.out.println(i);
}
}
Mudar para ++i, --i, i-- e verificar os resultados

OPERADOR
op1 != op2!=
op1 == op2==
op1 <= op2<=
op1 < op2<
op1 >= op2>=
op1 > op2>
Uso
Operador
Condicional

public class RelacionalDemo {
int i = 37;
int j = 42;
int k = 42;
//maior
System.out.println(" i > j = " + (i > j)); //false
//maior igual
System.out.println(" i >= j = " + (i >= j)); //false
//menor
System.out.println(" i < j = " + (i < j)); //true
//menor igual
System.out.println(" i <= j = " + (i <= j)); //true
//igual
System.out.println(" i == j = " + (i == j)); //false
//diferente
System.out.println(" i != j = " + (i != j)); //true
}
}

op1 ^ op2Bit^
op1 | op2Bit|
op1 & op2Bit&
!opnegação!
op1 || op2Ou||
op1 && op2E&&
UsoFunçãoOperador

op1 >>> op2>>>
op1 >> op2>>
op1 << op2<<
UsoOperador

op1 = op1 >>> op2op1 >>>= op2>>>=
op1 = op1 >> op2op1 >>= op2>>=
op1 = op1 << op2op1 <<= op2<<=
op1 = op1 ^ op2op1 ^= op2^=
op1 = op1 | op2op1 |= op2|=
op1 = op1 & op2op1 &= op2&=
op1 = op1 % op2op1 %= op2%=
op1 = op1 / op2op1 /= op2/=
op1 = op1 * op2op1 *= op2*=
op1 = op1 - op2op1 -= op2-=
op1 = op1 + op2op1 += op2+=
DescriçãoUsoOperador

op1 instanceof op2instanceof
Criar objetosnew
(type) op // cast(type)
parâmetros(parâmetros)
objetos.
array[ ]
op1 ? op2 : op3?:
UseOperador

break, continue, label:,
return
Paradas, retornos e
mudanças no fluxo
do loop
try-catch-finally, throwException
if-else, switch-caseDecisão
while, do-while, forLoop
Palavra chave

while (expression) {
statement
}
do {
statement(s)
} while (expression);
for (initialization; termination; increment) {
statement(s)
}

public class SwitchDemo {
int mes = 8;
switch (mes) {
case 1: System.out.println("Janeiro"); break;
case 2: System.out.println("Fevereiro"); break;
case 3: System.out.println("Março"); break;
case 4: System.out.println("Abril"); break;
case 5: System.out.println("Maio"); break;
case 6: System.out.println("Junho"); break;
}
}
}

EXERCÍCIOS
1) Escreva um programa em java que possua um método para exibir na tela os
números de 1 a 10. (Usando for)
números de 1 a 10. (Usando while)
números de 1 a 10. (Usando do while)

// 1 – usando for
public class loop1 {
int i=0;
for(i=1; i<=10; i++)
System.out.print(i + " ");
i=1;
}
// 2 – usando do ...while
int i=1;
do {
i++;
} while(i<=10);
}
}
// 2 – usando while
int i=1;
while(i<=10) {
i++;
}
}
}

TRATAMENTO DE EXCEÇÃO
É um evento que ocorre durante a execução de um programa que sai do fluxo normal.
try {
comandos
} catch (TipoExceção nome) { // executado quando ocorrer exceção
comandos
} finally { // executado mesmo que não haja exceção
comandos
}

// excecao.java
public class excecao {
void divide(int numerador, int denominador) {
System.out.println(numerador/denominador);
}
excecao e = new excecao();
try {
e.divide(2,0);
} catch (Exception exc) {
System.out.println(“Erro de excecao");
} finally {
System.out.println(“Denominador deve ser diferente de zero");
}
}
}

// excecao1.java
public class excecao1 {
void divide(int numerador, int denominador) throws Exception {
if(denominador == 0)
throw new Exception();
System.out.println(numerador/denominador);
}
excecao e = new excecao();
try {
e.divide(2,0);
} catch (Exception exc) {
System.out.println("Erro");
} finally {
System.out.println("Denominador deve ser diferente de zero");
}
}
}

Criando ARRAY
// ArrayDemo.java
public class ArrayDemo {
int[] anArray; // declarando um array de inteiros
anArray = new int[10]; // cria um array de inteiros
for (int i = 0; i < anArray.length; i++) {
anArray[i] = i;
System.out.print(anArray[i] + " ");
}
System.out.println();
}
}

// ArrayDemo.java
public class ArrayDemo {
int[] anArray = {1,2,3,4,5,6,7,8,9,10}; // inicializando array
for (int i = 0; i < anArray.length; i++) {
System.out.print(anArray[i] + " ");
}
}
}
INICIALIZANDO ARRAY

ARRAY DE OBJETOS
public class ArrayStringsDemo {
String[] anArray = { "String UM",
"String DOIS",
"String TRES" };
for (String s: anArray) {
System.out.println(s.toLowerCase());
}
}
}

ARRAY DE ARRAYS
public class ArrayArrayDemo {
int[][] aMatrix = new int[4][];
//populate matrix
for (int i = 0; i < aMatrix.length; i++) {
aMatrix[i] = new int[5]; //create sub-array
for (int j = 0; j < aMatrix[i].length; j++) {
aMatrix[i][j] = i + j;
}
}
//IMPRIME matriz
for (int i = 0; i < aMatrix.length; i++) {
for (int j = 0; j < aMatrix[i].length; j++) {
System.out.print(aMatrix[i][j] + " ");
}
}
}
}

APPLET
//AloMundo.java
import javax.swing.JApplet;
import java.awt.Graphics;
public class AloMundo extends JApplet {
String mensagem=“”;
public void init() {
mensagem += “init.. ”;
}
public void start() {
mensagem += “start.. ”;
}
public void paint(Graphics g) {
g.drawRect(0, 0,
getSize().width - 1,
getSize().height - 1);
g.drawString(mensagem+”Alo Mundo!!”, 5, 15);
}
}

<html>
<applet code=AloMundo width=300 height=300> </applet>
</html>
teste.html

Compila applet
javac AloMundo.java
Executa applet
appletviewer teste.html
abrir teste.html por um browser (IExplorer ou Mozilla)

PACOTES
java.applet – Possui classes necessárias a criação de applet
java.awt – Contém classes necessárias a criação de interfaces com o usuário e para
desenhar gráficos e imagens.
java.io – Contém classes que permitem realizar operações de i/o através de streams,
serialização e arquivos.
java.lang – comtém classes fundamentais para o desenvolvimento de programas java. (este
pacote é importado por padrão)
java.net / javax.net – contém classes para implementar aplicações em rede.
java.sql – Contém classes que permitem acessar e processar dados armazenados em um
banco de dados (usualmente um banco de dados relacional).
java.util - Contém classes diversas para tratar de forma especial:coleções,vetores, strings,
números randomicos, strings entre outros.
javax.swing – melhoramento de java.awt a possibilidade de utilizar outros recursos

import java.io.*;
public class teste9 {
BufferedReader d = new BufferedReader(new InputStreamReader(System.in));
try {
System.out.println(d.readLine());
}
catch (IOException ioe) {
System.out.println(ioe+"");
}
}
}

Java aprendendo linguagem.ppt

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (6)

Ähnlich wie Java aprendendo linguagem.ppt

Ähnlich wie Java aprendendo linguagem.ppt (20)

Java aprendendo linguagem.ppt