Programação JAVA

INTRODUÇÃO À PROGRAMAÇÃO EM JAVA

Engenharia de Software
Level: 200
Ano letivo 2020-2021

Objetivos
Este curso oferece uma introdução à linguagem de programação Java para estudantes que tiveram pouca experiência.
formação em programação. Com esse objetivo, os alunos aprenderão a:
- Escreva programas usando a linguagem Java. Os tópicos básicos considerados são os seguintes: programa java
estrutura, sintaxe Java, tipos de dados, fluxo de controle, classes, arrays, tratamento de exceções, recursão
Conectividade de banco de dados (JDBC), Programação básica de sockets e interfaces gráficas de usuário (GUIs).
- Compile e execute-os sob o Sun Microsystems, Inc. Java 2 Platform, Standard Edition, ou
outros Ambientes de Desenvolvimento Integrados (IDEs) como o NetBeans.

Conteúdos
I. Introdução........................................................................................................................................................................................... 1
1.1. O que é Java? .............................................................................................................................................................................. 2
1.2. Recursos do Java............................................................................................................................................................................... 2

1.3. Tipos de programas Java............................................................................................................................................................. 2

1.4. Ferramentas de desenvolvimento Java.............................................................................................................................................................. 3
a) O Kit de Desenvolvimento Java (JDK)............................................................................................................................................... 3
b) Ambientes de desenvolvimento Java................................................................................................................................................. 3
II. Elemento Básico da Linguagem Javas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2.1. Comentários................................................................................................................................................................................... 3

2.2. Tipos primitivos padrão em Java.............................................................................................................................................. 3

2.3. Operadors .................................................................................................................................................................................... 3
2.4. Declarações de variáveis................................................................................................................................................................. 3
2.5. Constantes.................................................................................................................................................................................... 3
2.6. Vetor......................................................................................................................................................................................... 3
2.7. Fluxo control ................................................................................................................................................................................ 4
2.8. Entrada e saída padrão........................................................................................................................................................ 4
2.9. Tratamento de Exceções em Javag ........................................................................................................................................................... 4
III. Programação Orientada a Objetos (POO)........................................................................................................................................... 5
3.1. Classes e objetoss ..................................................................................................................................................................... 5
3.1.1. Alguma terminologia de OOP em Javas ........................................................................................................................................ 6

3.1.2. Modificadores de acesso.............................................................................................................................................................. 6

3.2. Hereditariedade.................................................................................................................................................................................. 6
3.2.1. Cadeia de Construtores...................................................................................................................................................... 7
3.3. Polimorfismo............................................................................................................................................................................. 7
3.4. Métodos e Classes Abstratos.................................................................................................................................................. 7
3.5. Interfaces.................................................................................................................................................................................... 8
3.5.1. Diferenças Entre Interfaces e Classes Abstratas................................................................................................... 8
3.5.2. Por que as interfaces são importantes? ..................................................................................................................................... 8

3.6. Pacotes e declaração de importação................................................................................................................................................. 8

IV. Arquivos (Tutorial)
V. JDBC (Tutorial)
VI. Programação Básica de Socket (Tutorial)
VII. Programação de Interface Gráfica (Tutorial)

Eu. Introdução

1
Programação JAVA
1.1. O que é java? A coleta de lixo significa que há um automático
Java é uma linguagem de programação orientada a objetos funcionalidade que regularmente percorre o espaço do objeto e
desenvolvido pela Sun Microsystems, semelhante ao C e C++, verifica quais objetos ainda estão referenciados e quais não estão.
exceto sem algumas das confusas, mal compreendidas Aqueles que não são mais referenciados são inutilizáveis para o
recursos do C++ (sobrecarga de operadores, ponteiros…). programa, então é seguro liberar o espaço que eles usam. Em Java,
Em seu primeiro lançamento, o Java foi principalmente usado como um não há a palavra-chave “delete”, uma vez que um coletor de lixo em
linguagem para escrever aplicações para serem incorporadas em a JVM cuida da alocação e recuperação de memória.
navegadores (conhecidos como applets), mas cresceu em muitos Várias desvantagens do C e C++ eliminadas
outras áreas (Aplicações para servidor e empresarial) - Sem ponteiros de memória acessíveis, não
computadores, computadores de mesa, telefones móveis ...). Hoje, pré-processador.
thousands of programmers, Internet developers, Web - Limites de array verificados automaticamente.

editoras e empresas de software estão fazendo uso de Java. - Sem sobrecarga de operadores em Java.
Java inclui três plataformas principais: Herança múltipla substituída por interfaces
. Java Standard Edition (JSE): para computadores desktop (Elimina as complexidades da herança múltipla)
. Edição Móvel Java (JME): é a plataforma Java Orientado a objetos
para dispositivos de consumo e embarcados, como móveis - Orientado a objetos programação (POO)
telefones e organizadores pessoais. ao longo – sem codificação fora da aula
. Java Enterprise Edition (JEE): para servidores e definições.
computadores empresariais. Robustez
Java abrange vários componentes distintos: - Tratamento de exceções embutido, tipo forte
Uma linguagem de alto nível: o código-fonte à primeira vista parece verificação (ou seja, todas as variáveis devem ser atribuídas)

muito semelhante ao C e C++ mas é único de muitas maneiras. um tipo de dado explícito), variáveis locais devem ser
(A extensão do arquivo de origem é “.java”) inicializado.
Código byte do Java: Um compilador transforma o Java Independência de plataforma
código de linguagem para arquivos de instruções binárias e - O byte-code roda em qualquer plataforma com um
dados chamados byte-code que rodam na Java Virtual JVM compatível.
Máquina. - O ideal de "Escreva uma vez, execute em qualquer lugar" não tem

-Máquina Virtual Java (JVM): É um programa que foi alcançado (ajuste para diferentes plataformas
recebe byte-code como entrada e interpreta as instruções geralmente exigido), mas está mais próximo do que com outros
assim como se fosse um processador físico executando languages
código de máquina. A figura abaixo ilustra como um java - Portátil: Escreva uma vez, execute em qualquer lugar

o programa é compilado e executado. Essas características oferecem uma série de benefícios

comparado ao desenvolvimento de programas em outras linguagens. Para
exemplo, programas em C/C++ são afetados por erros resultantes de
ponteiros de memória direta, que são eliminados no Java.
Da mesma forma, a verificação de limites de array previne outro comum
fonte de erros. O coletor de lixo alivia o
programador do grande trabalho de gerenciamento de memória. É
frequentemente se diz que esses recursos levam a um aumento significativo na
desenvolvimento de programas e depuração comparados ao trabalho
com C/C ++.
1.3. Tipos de programas java
Aplicativo: Programa Java autônomo que pode ser executado
1.2. Java features independente de qualquer navegador da Web

Combinação de compilador/intérprete Applet: Programa Java que é executado dentro de um Java-

O código fonte é compilado para byte-code, que é navegador da Web ativado
interpretado por uma Máquina Virtual Java (JVM). Isso fornece Servlet: Software Java que é carregado em um Web
portabilidade e segurança para qualquer sistema operacional base servidor para fornecer adicional servidor
plataforma para a qual uma máquina virtual foi escrita. funcionalidade semelhante a programas CGI. (CGI=Comum
Coleta de lixo Interface de Gateway. É uma técnica que permite um
cliente para executar um programa específico em um servidor

2
Programação JAVA
1.4. Java development tools *@param largura o comprimento de um
*@param altura o comprimento
a) O Kit de Desenvolvimento Java (JDK)
@retornar a área do retângulo
O Kit de Desenvolvimento Java (JDK) é o arquivo mínimo */
você precisa desenvolver em Java. A versão que é destinada para
o ambiente Windows contém um instalador automático 2.2. Tipos primitivos padrão em Java
isso cuida da instalação. Apenas configurando o booleano verdadeiro ou falso
O PATH do Windows pode exigir alguma intervenção manual. caractere caractere de 16 bits, codificado usando Unicode 1.1.5
O JDK contém muitas ferramentas básicas: byte inteiro com sinal de 8 bits (-128 a +127)
javac: O Compilador da Linguagem Java que é utilizado para compilar
curto Número inteiro com sinal de 16 bits (-32.768 a 32.767)
programs written in the Java Programming Language into int Número inteiro com sinal de 32 bits (-2,15E+9 a +2,15E+9)
códigos de byte. longo Número inteiro com sinal de 64 bits (-4,61E+18 a +4,61E+18)
java: O Interpretador Java usado para executar programas escritos em
flutuar número real em ponto flutuante (1.0E-38 a
Java.
1.0E+38)
jre: O Interpretador de Tempo de Execução do Java que pode ser usado para executar
número real de ponto flutuante duplo (-1.0E-308 a 1.0E+308)
Aplicações Java. A ferramenta jre é semelhante à ferramenta java, mas
destina-se principalmente aos usuários finais que não necessitam de todos os
opções relacionadas ao desenvolvimento disponíveis com a ferramenta java.
2.3. Operadores
Eles são semelhantes ao operador C++. No entanto, são poucos.
appletviewer: É usado para executar applets sem um web
differences:
navegador.
"+" pode ser usado para concatenar strings
jar: Combina múltiplos arquivos em um único Arquivo Java
"instanceof" retorna verdadeiro ou falso dependendo de
arquivo (JAR).
se o objeto do lado esquerdo é uma instância de
objeto do lado direito
b) Ambientes de desenvolvimento Java
>>> desloca os bits para a direita, preenchendo com zeros
Existem muitos ambientes de desenvolvimento Java: Netbeans,
2.4. Declarações de variáveis
Eclipse, JBuilder, JDeveloper...
Declarações de variáveis consistem em três partes: modificadores,
Exemplo de programa Java
seguido por um tipo, seguido por uma lista de identificadores. O
o Crie um arquivo de origem (em qualquer editor de texto): Hello.java
modificadores são opcionais, mas o tipo e a lista de identificadores são obrigatórios
o Digite o código abaixo e salve:
não.
classe pública Olá {
exemplo: público int a, b, c; // "público" é um modificador
public static void main (String args[]) {
System.out.println("Olá Mundo!");
} 2.5. Constantes
} Em C++, constantes são definidas usando const ou #define. Em
java eles são definidos através da combinação de "final"
o Compile:javacHello.java
e "estático".
o Executar:javaHello (Este último comando iniciará
Sintaxe: público final <estático><tipo de dado><nome> =
a JVM)
<valor>;
exemplo: publicfinal staticdouble PI = 3.14;
II. Elementos Básicos da Linguagem Java
public final static int NumStudents = 60;
A sintaxe do Java é muito semelhante à de "C" e C++.
é verdade para comentários, nomes de variáveis e declarações e
2.6. Arrays
inicializações, fluxo de controle (se, senão, para, enquanto) etc.
Arrays são objetos em Java. Criar um array envolve
três etapas: declaração, criação e inicialização
2.1. Comentários
o Declaração: int [] tab; ou int tab [];
Tipo de comentários Exemplos
Isso significa que tabis são referência (comparar com referência
//Comentário de uma linha
Comentário de linha e ponteiro em "C" e C++ para um array de inteiros.
int cpt = 1 //Contador
o Criação: tab = nova aba[4];
/*Comentário na primeira linha
Comentário em bloco o Inicialização:tab[0] = 12;
Comentário da segunda linha*/
o A declaração, criação e inicialização podem ser
/**
Automatic documentação combinado
Esta sub-rotina calcula o
comentário área de um retângulo int [] tab = {1, 2, 3, 4}

3
JAVA Programming
o Matrizes <declarações-2> quebrar;
int a[][] = new int [10][3]; quebrar; caso 1:
println(a.length); // imprime 10 . caso 2:
println(a[0].length); // imprime 3 . // (mais casos) System.out.println("O ")
. o número é 1 ou 2.)
2.7. Controle de fluxo caso<constante-N>: quebrar;
Se declaração <declarações-N> caso 3:
Exemplo: quebrar; caso 4:
se (x < y && x < z) {//Assuma que x, y e z são inteiros default: // opcionalSystem.out.println("O
System.out.println("seguido por y e z na sua ordem correta"); caso padrão number is 3or 4.");
}
<statements-(N+1)> quebrar;
senão se (x > y && x > z) {
System.out.println ("saída y e z na ordem correta, seguidas por x");
} // fim do switchdefault:
} declaração System.out.println(" N>= 5.");
senão { }
System.out.println("saída x entre y e z na ordem correta");
}
2.8. Standard input and output
A classe global "System" contém os campos "in" e "out"
A instrução for e "err", que correspondem à entrada padrão, padrão
Sintaxe Exemplo saída e erro padrão. Usar estes é ilustrado por
classe ForDemo { exemplo seguinte:
public static void main(String[]
para (inicialização; args){ classStdioExample
encerramento; incremento) { for(int i=1; i<11; i++){ {
Declaração(s) System.out.println("A contagem é: " + i); public static void main(String args[]) throws IOException{
} } int n;
} BufferedReader stdin = new BufferedReader(new
} InputStreamReader(System.in));
System.out.print("Insira um inteiro: ");
As declarações while e do-while n = Integer.parseInt(stdin.readLine());
System.out.println("Quadrado: " + n*n + " Cubo: " + n*n*n);
Exemplo de Declaração
}
classe WhileDemo {
}
public static void main(String[] args){
int contagem = 1;
enquanto (contagem < 11) {
Funções de Conversão de Dados
Enquanto System.out.println("A contagem é: " + count);
contar++; Java contém um conjunto robusto de classes para converter de um dado
} digitar para outro
} Aulas Exemplo de conversão
} Longo String str1 = "488890001";
classe DoWhileDemo { long l = Long.parseLon(str1) ; // l=488890001 ;
public static void main(String[] args){ Interger Stringstr2 = “32776”;
int contagem = 1; int n = Interger.parseIn(str2) ; // n=32776
faça { Flutuar String str3 = "12.3";
Faça-enquanto System.out.println("A contagem é: " + count);
float f = Float.parseFloat(str3); // f=12.3
contar++; Duplo String str4 = “1.5”;
}enquanto (contagem < 11);
double d = Double.parseDouble(str4) ; // d = 1.5
}
Boolean String str5 = “true”
}
Boolean bool = Boolean.parseBoolean(str5); //
bool = true
Alternar
Sintaxe Exemplo 2.9. Tratamento de Exceções em Java
switch (<expressão>) { switch ( N ){ Uma exceção é um objeto que define algo incomum ou
caso <constante-1>: // Presuma que N é um inteiro situação errônea. É lançado por um programa ou um tempo de execução
<declarações-1> caso 0: ambiente e pode ser capturado e manuseado adequadamente.
quebrar; System.out.println("O Java suporta exceções definidas pelo usuário e exceções pré-definidas

caso<constante-2>: o número é 1.

4
Programação JAVA
(ExceçãoAritmética, ExceçãoDeÍndiceDeArrayForaDosLimites, System.out.println("Fim do Nível3");
}
FileNotFoundException, InstantiationException).
public void L2 ( ) {
O tratamento de exceções permite a um programador dividir um
System.out.println("Início do Nível 2");
programar em um fluxo normal de execução e uma exceção L3( );
fluxo de execução. Se uma exceção não for tratada, o programa System.out.println("Level2 ending");
}
terminará (anormalmente) e produzirá uma mensagem.
public void L1 ( ) {
Exemplo: System.out.println("Início do Nível1");
classe pública DivideBy0 { try { L2 ();
public static void main (String[] args) { } catch (ArithmeticException problema) {
System.out.println(problem.getMessage( ));
System.out.println(10 / 0);
System.out.println();
} problema.imprimirRastroPilha ( );
} }
Saída: System.out.println("Fim do Nível 1");
(Java.lang.ArithmeticException: / por zero }
em DivdeBy0.main(DivdeBy0:3)) }
classe Demonstração {

public static void main (String[] args) {

Instruções Try e Catch Exceção_Scope demo = new Exceção_Scope();
System.out.println("Início do programa");
Sintaxe Exemplo
demo.L1( );
public class ExemploDeExcecao {
System.out.println("Programa encerrando");
public static void main(String arg []){
}
int n; }
BufferedReader stdin = novo [Dê a saída após executar este pseudocódigo]
BufferedReader(novo
tente { Lançando uma Exceção
InputStreamReader(System.in));
statement-list1
System.out.println("Digite um número inteiro: "); Exemplo de método para resolver a equação quadrática (A*x*x + B*x + C = 0)
}
tente{ estático público duplo raiz( duplo A, duplo B, duplo C )
capturar (exceção- throwsIllegalArgumentException {
n = Integer.parseInt(stdin.readLine());
classe1 variável1) se (A == 0) {
System.out.println("Você entrou: " + n); lançar nova IllegalArgumentException("A não pode ser zero.");
{
} }
statement-list2 senão {
catch(IOException e1){
} double disco = B*B - 4*A*C;
System.out.println("IOException")
capturar (exceção-
ocorre se (disc < 0)
classe2 variável2)
}
{ throw new IllegalArgumentException("Discriminant <
catch(NumberFormatException e2){
statement-list3 zero."
System.out.println("Você deve inserir um ")
} catch ….
interger" );
e2.printStackTrace(); cláusula final
} Uma instrução try pode ter uma cláusula finally. A finally
} a cláusula define uma seção de código que é executada independentemente
} de como o bloco try é executado.
tente {
Se uma exceção for lançada em statement-list1, o controle é statement-list1
transferido para o manipulador de exceções apropriado. Após a execução } catch (classe-exceção1 variável1) {
as instruções na cláusula catch, a transferência de controle vai para o lista-de-declaração2
….
declaração após toda a instrução try.
} catch{ lista-de-instruçõesN}
} finalmente {
Propagação de Exceção lista-de-afirmações //Sempre execute este código.
Se uma exceção não for capturada e tratada onde ela }
ocorre, ele se propaga para o método chamador.
Exemplo III. Conceitos Orientados a Objetos e JAVA
class Escopo_Exceção {
3.1.1. Classes and objects
public void L3 ( ) {
System.out.println("Início do Nível 3");
System.out.println(10/0);

5
Programação JAVA
Uma classe é uma coleção de dados (atributos) e métodos - Privado:
que opera nesses dados. “Em Java, tudo é uma classe” Este modificador indica que atributos e métodos são
são classes fornecidas pelo Java e aquelas que você escreve). acessíveis apenas de dentro da classe onde estão
Todas as classes são derivadas de uma única classe raiz declarado. É usado para as operações internas do
calledObject. objeto. Isso é chamado de encapsulamento em POO.
Toda classe (exceto Object) tem exatamente um - Protegido:
superclasse imediata. Quando protegido é aplicado como um modificador de acesso a um

Apenas a herança simples é suportada membro em uma classe, esse membro pode ser usado em
Objetos são instâncias de uma classe. Eles são criados com o subclasses da classe na qual está definida, mas ela
"novo" palavra-chave, que retorna uma referência a um objeto que não pode ser usado em não-subclasses. Há uma exceção:
representa uma instância da classe. Um membro protegido também pode ser acessado por qualquer classe
no mesmo pacote que a classe que contém o
3.1.2. Algumas terminologias OOP em Java membro protegido.
- Membro: seja um atributo ou um método de uma classe - Não especificado
- Construtor: método que realiza objeto Se nenhum de os modificadores dados acima são usados, o

inicialização (não criação!) o membro tem a visibilidade padrão ou visibilidade 'pacote'.

- Referência de Objeto: variável que contém uma referência a
(realmente o endereço de memória de) um objeto
- Variável de Instância: atributo para o qual cada objeto
(instância) tem sua própria cópia
- Classe Variável: atributo para o qual existe apenas
uma cópia para a classe. Cada objeto (instância) 3.2. Herança
compartilha esta cópia. Também é chamada de variável estática A terminherança refere-se ao fato de que uma classe pode
- Método de Instância: método que opera sobre o herdar parte ou toda a sua estrutura e comportamento de outro
atributos de um objeto (instância) classe(Este mecanismo garante escalabilidade e reusabilidade de
- Método de Classe: método que não opera em um o código). Java suporta herança única usando o
objeto particular, mas executa alguma função de utilidade "extends" palavra-chave da seguinte forma: public class B extends

ou opera em variáveis estáticas. também é chamado de Aqui, "A" é chamada de subclasse e "B" de superclasse.
static method. •Uma subclasse pode sobrescrever um método em sua superclasse ao

- Assinatura do Método: o número, tipo e ordem de fornecendo uma nova definição para um método com o mesmo nome,
argumentos de um método tipo de retorno e assinatura.
- Sobrecarga de Métodos: definindo um método com o Todas as classes estendem implicitamente a classe Object.

mesmo nome, mas assinatura diferente (número e tipo) • Um membro protegido de uma classe pode ser acessado por qualquer

do parâmetro) como outro método na mesma classe método na mesma classe ou em uma subclasse. (Ele também pode ser

Sobrecarga de métodos
acesso por qualquer método em uma classe no mesmo pacote
classe Adder • Dentro de um método, a palavra-chave "this" representa o
{
objeto atual, enquanto "super" é uma variável que contém um
int add(int i, int j) {
retorna i + j; referência da super classe do objeto atual.
} Exemplo de herança
dobro adicionar(dobro i, dobro j) { // A é a superclasse public class ABTest {
retornar i + j; classe pública A{ public static void
} protegido int aData; main(String[] argv) {
} public A(int aData) Polimorfismo
{this.aData =aData;} A a = new A();
3.1.3. Modificadores de acesso B b = new B();
public A() {aData = 0;}
a.f();// Invoca o f() de A
Existem três modificadores de acesso que podem definir o protegido vazio f() { b.f();// Invoca o f() de B
System.out.println("Isto é de A's ") A a1 = b;
visibility of attributs, methods and classes: public, private, f"); a1.f();// Invoca o f() de B
//Casteamento para Cima
protegido. }
} A a2 = (A) b; // Ok
- Public: // B é a subclasse
Isso indica que um membro ou classe é acessível classe pública B estende A { //Down Casting
protected int bData; //B b1 = a; //Ilegal em
em qualquer lugar por qualquer pessoa.(Na filosofia da POO, atributos //tempo de compilação,
public B(int bData)
{this.bData = bData;} // explicit cast needed
não deve ser declarado público. É preferível usar //B b2 = (B) a; // Ok em
public B() {this(0);}
"getter" e "setter" protegido vazio f() {
//tempo de compilação,

6
Programação JAVA
System.out.println("This is B's // exceção em tempo de execução sobre o objeto que está agindo. Os três tipos de
f"); // Outras coisas
} int i = a.aData; /* Ok, mesmo polimorfismo são: sobrecarga de método, sobrescrita de método,
protegido vazio g() { pacote*/ e vinculação dinâmica de métodos.
System.out.println("Isto é de B's") //i = a.bData; /* Ilegal em
g"); tempo de compilação */ Métodos sobrecarregados são métodos com o mesmo nome
} //bData não definido em A
} //a.g(); mas ou um número diferente de parâmetros ou tipos diferentes
// Ilegal em tempo de compilação, na lista de parâmetros.
// g() não encontrado em A
} Métodos sobrescritos são métodos que são redefinidos
} dentro de uma classe herdada ou subclass. Eles têm o mesmo
a assinatura e a definição da subclasse são usadas.
3.2.1. Encadeamento de Construtores
A vinculação dinâmica (ou tardia) de métodos é a capacidade de um
O Java sempre invoca um construtor de superclasse quando um
programa para resolver referências a métodos da subclasse em
um objeto da subclasse é criado (já que o objeto da superclasse é
tempo de execução. Um exemplo de ligação dinâmica é dado abaixo.
"parte de" o objeto da subclasse). É possível chamar explicitamente
classe pública Poly
um construtor de superclasse usando uma chamada para super(...) como o primeiro
public static void main (String
linha de um construtor de subclasse: args[])
{
public B(int bData) {
System.out.println("Primeiro Teste");
super(); // Chamada explícita do construtor da superclasse classe Ponto
Ponto p = novo Ponto (3, 5);
this.bData = bData; {
p. exibir();
} público Ponto (int x, int y)
// chama display() de Point
{
Pointcol pc = new
this.x = x ; this.y = y ;
PontoCol (4, 8, (byte)2);
Se o construtor da superclasse não for invocado explicitamente, }
p = pc ; // p refere-se a um
então o construtor da superclasse sem argumentos é implicitamente public void mover(int dx, int
// instância de Pointcol
dy
chamou por você. Ou seja, o Java insere a chamada para "super()" p. exibir() ;
{
automaticamente. // chama display() de Pointcol
x += dx ; y += dy ;
p = new Point (5, 7) ;
Mas, se o construtor da superclasse estiver definido enquanto o }
// p agora referencia um
se nenhum argumento for fornecido, então é necessário chamar public void exibir()
//instância de Ponto
{
o construtor da superclasse na primeira linha da subclasse p.exibir() ;
System.out.println("meu
construtor. // chama display() de Point
posição é
System.out.println("Segundo Teste");
Exibição da superclasse Subclasse }
class Pointcol estende Point Point [] tabPts = new Point [4];
classe Ponto private int x, y ;
{ tabPts [0] = new Point (0, 2) ;
público Ponto (int x, int y) }
public Pointcol (int x, int y, tabPts [1] = novo
{
byte cor) PontoCol (1, 5, (byte)3);
this.x = x ; this.y = y ; class Pointcol estende Point
{super (x, y) ;// deve ser o tabPts [2] = novo
} {
//primeiro Pointcol (2, 8, (byte)9) ;
public void mover(int dx, int dy) público Pointcol (int x, int y,
instrução tabPts [3] = new Point (1, 2) ;
{ x += dx ; y += dy ; byte cor)
this.color = color ; para (int i=0 ;
} {
} i< tabPts.length ; i++)
public void exibir() super (x, y) ;/* deve ser o
public void exibir() tabPts[i].display();
System.out.println (" primeira instrução*/
{ super. display() ; }
minha posição é this.color = cor ;
System.out.println("e meu "); }
; }
color is: " + color) ; Saída
} public void exibir()
Primeiro Teste
} {
private int x, y ;
private byte cor ; minha posição é 3 5
} super. exibir();
} minha posição é 4 8
System.out.print("e meu ")
No entanto, se a primeira linha de um construtor usar o e minha cor é: 2
color is: " + color) ;
minha posição é 1,70
a sintaxe "this(...)" para invocar outro construtor da classe, }
Segundo Teste
então o Java não insere automaticamente a chamada para "super()" private byte cor ;
minha posição é 0 2
}
no construtor: minha posição é 1 5
public B() { e minha cor é: 3
this(0);// Chamada para super() não inserida automaticamente aqui. minha posição é 2 8
} e minha cor é: 9
minha posição é 1 2
3.3. Polimorfismo
Em linguagens de programação, polimorfismo é o 3.4. Métodos e Classes Abstratas
capacidade de uma ação ou método de realizar uma ação com base

7
Programação JAVA
Um método abstrato não tem corpo. É como um virtual puro. 3.5.2. Por que as Interfaces são Importantes?
função em C++. O método abstrato deve ser O tipo de um objeto refere-se essencialmente à OO
sobrescrito em uma subclasse com uma implementação real. interface de sua classe. Então, em Java, um objeto de uma classe que
Qualquer classe com um método abstrato é uma classe abstrata implementa várias interfaces tem muitos tipos. Além disso, objetos
e deve ser declarado abstrato. Uma classe abstrata não pode ser from many different classes can have the same type. This
instanciado. Além disso, se uma subclasse de uma classe abstrata não
permite escrever métodos que podem funcionar em objetos de muitos
fornecer implementações para todos os métodos abstratos de classes diferentes que podem até estar em heranças diferentes
sua superclasse, então a subclasse em si é abstrata. hierarquias.

// A classe Shape é uma classe base abstrata para uma forma geométrica.
classe abstrata pública Forma {
public abstract double area();//area() não tem corpo
} public void renderScreen(Drawable d) {
// A classe Retângulo é uma implementação concreta de uma Forma. // Renderizar este Drawable na tela.
public class Rectangle extends Shape { // Não importa se isto é DrawableRectangle,
protected double w;
// DrawableCircle, etc. Como o objeto é um Drawable, ele
protected double h;
public Rectangle(double w, double h) { // DEVE implementar o método Draw.
this.w = w; d.Desenhar();
this.h = h;
} 3.6.} Pacotes e declaração de importação
public double area() { return (w * h); } As classes Java podem ser agrupadas em um pacote.
}
Os pacotes têm várias vantagens:
- classes relacionadas podem ser agrupadas juntas (implica
3.5. Interfaces modularidade
Em Java, uma interface é uma especificação de um conjunto de - os membros podem ser acessíveis apenas aos métodos de
métodos abstratos. classes no mesmo pacote
Uma classe que implementa a interface deve fornecer Regras
uma implementação para todos os métodos abstratos em - A declaração de pacote deve aparecer como a primeira
a interface. declaração do arquivo fonte Java:
Uma classe pode implementar muitas interfaces, mas um pacote em 3;
uma classe só pode estender uma classe (Se nenhuma declaração de pacote estiver presente, o código é parte de
// A interface Drawable fornece a especificação para um desenhável o pacote padrão não nomeado
// objeto gráfico.
public interface Drawable {
public void Desenhar(); - Um nome Java totalmente qualificado para uma classe é:
} <Nome do Pacote>.<Nome da Classe>
// Classe DrawableRectangle implementa a interface Drawable.
public class DrawableRectangle extends Rectangle implements Drawable {
Exemplo: em3.Polimorfismo.Ponto
// Outro código aqui.
public void Draw() { A declaração de importação permite o uso de abreviações
// Corpo do Draw()
} nomes de classe em um arquivo fonte Java
} As classes estão sempre disponíveis por meio de seus nomes totalmente qualificados:

in3.Polymorphism.Ponto p = new in3.Polymorphism.Ponto();

3.5.1. Diferenças Entre Interfaces e Usando a declaração "importar", o código anterior é
Classes Abstratas abreviado da seguinte forma:
- Uma classe abstrata pode ter métodos não abstratos, in3.Polymorfismo.Ponto;
enquanto todos os métodos de uma interface são implicitamente (ou Ponto p = novo Ponto();
explicitamente) abstrato. É possível importar todas as classes de um pacote usando
- Uma classe abstrata pode declarar variáveis de instância; um a seguinte forma da declaração de importação:
a interface não pode import java.util.*;
- Uma classe abstrata pode ter uma definição de usuário (Isto importa todas as classes no pacote java.util)
construtor, enquanto uma interface não tem construtores
- Cada método de uma interface é implicitamente (ou
explicitamente) público; uma classe abstrata pode ter não-
métodos públicos.