Uma breve introdução ao Java...

Rogério de Oliveira

O que é o Java?

Linguagem orientada a objetos:

classes e objetos
JVM, Java Virtual Machine:
Byte Code, independência de máquina, .java, .class
Linguagem para web:
aplicativos e applets em Java (executam sob um browser)

Arquivos .java Arquivos .class JVM

navegador
compatível

Boa prática: convenções

public class Student; // classes com maiúsculas

Student studentA; // objetos com minúsculas

int nVar; // tipos primitivos iniciam com letra indicando o tipo

char cVar; // (esta nem sempre uma boa prática...)
...

Hello world, aplicativo

Um aplicativo:

public class HelloWorld

{
public static void main(String args[])
{
System.out.println("Hello, world");
}
}
O método main executa um aplicativo Java.

Hello world, aplicativo 2... empregando caixas de diálogo

Um aplicativo ainda pode empregar caixas de diálogo como abaixo.

import javax.swing.JOptionPane; // import class JOptionPane

public class HelloWorld {

public static void main( String args[] )
{
JOptionPane.showMessageDialog(
null, "Hello\nWorld!" );

System.exit( 0 ); // terminate the program

}
}

O comando import indica ao compilador as classes que requerem ser incluídas

para uso das caixas de diálogo.

Comentários

// Isso é um comentário
/* Isso também

*/

Declaração de variáveis e tipos primitivos

// Tipo Var comentário, tamanho em bits, valor padrão

boolean bVar; // boolean, 8, False
byte yVar; // byte, 8, x00
char cVar; // caracter, 16, x0000
short sVar; // short, 16, 0
int nVar; // inteiro, 32, 0
long lVar; // long, 64, 0
float fVar; // ponto flutuante, 32, 0
double dVar; // dupla precisão, 64, 0

Literais iniciadas com 0X ou 0x são hexadecimais. Assim, 255 = 0xFF.

Os identificadores das varíáveis podem usar quaisquer caracteres unicode. Assim,

preço é um identificador válido.

Note String não é um tipo primitivo Java, mas uma classe, assim:

String cor = "azul";

inicializa o objeto cor do tipo String com o String anônimo "azul".

Cast, conversão de tipos

int nVar;
float fVar;

fVar = nVar; // funciona pois fVar tem precisão maior...

fVar = (float)nVar; // mas é preferível

nVar = fVar; // não funciona pois há perda de precisão...

nVar = (int)fVar; // deve-se escrever desse modo

Operadores

+-/*% // operadores aritméticos (% = resto da divisão)

==, != // operadores de igualdade ( = é atribuição )
++, -- // incremento e decremento
~ // complemento bit a bit
- // negação
&, |, ^ // and, or e exclusive or de bits
&& // AND lógico
|| // OR lógico
>> // deslocamento de bits com sinal (>>> sem sinal)
>,<,>=,<= // operadores relacionais

int n, nA, nB;

n = 2 + 3 * 4; // o resultado é 14 pela precedência do operador *
n = ( nA=4 ) / 2; // o resultado é 2

n = 1;
nA = ++n; // pré-incremento n=2 e nA=2
nB = n++; // pós-incremento n=3 e nB=2
 nB += 1; // nB = nB + 1... isso não seria mais simples?

O operador + ainda é definido para strings.

System.out.println("O valor de nA e\' " + nA + '\n');

// resulta na saída: O valor de nA é 2

Estruturas de controle

IF e IF-ELSE

if (nota >= 5.5 && faltas < 0.75)

{
System.out.println("Aprovado");
}

if (nota > 5.5)

{
System.out.println("Aprovado");
}
else
{
System.out.println("Reprovado");
}

WHILE

int p = 2;
while ( p <= 1000 ) p = p * 2;

...
int i = 0;
while ( i <= nAlunos )
{
if (nota[i] >= 5.5)
{
System.out.println("Aluno " + i + "aprovado");
}
else
{
System.out.println("Aluno " + i + "reprovado");
}
i++;
}
O operador break encerra a execução de um loop.

int i = 0;
while ( i <= nAlunos )
{
if ( i == 100 ) break; // sai imediatamente...
i++;
}

FOR

for (exp1; boolexp; expr2)

{
// instruções
}

1. avalia exp1;
2. avalia boolexp, se verdadeira executa o FOR, caso contrário encerra;
3. avalia exp2 e retorna para 2.

for (int i = 0; i < nAlunos; i++)

{
nota[i] = 5.0;
}

Arrays

// o trecho de código abaixo inicializa um array de inteiros com zeros

int [ ] nArray = new int[10];

for (int i = 0; i < 10; i++)
{
nArray[i] = 0;
}

Para arrays multidimensionais empregue mais pares de colchetes, [ ][ ] para

2 dimensões.

SWITCH

switch (exp1)
{
case cexpa:
// instruções...
break;
 case cexpb:
// instruções...
break;
default:
// instruções...
}

Atenção: somente empregue expressões cexpX constantes (valor é computado

em tempo de compilação).

HelloWorld, Applet

Applets são executados a partir de um navegador web...

import javax.swing.JApplet; // import class JApplet

import java.awt.Graphics; // import class Graphics

public class HelloWorld extends JApplet {

public void paint( Graphics g )
{
g.drawString( "Hello world!", 25, 25 );
}
}

Os comandos import indicam ao compilador onde encontrar as classes

necessárias para compilação do programa. Os applets são construídos
extendendo uma classe JApplet (existe uma classe equivalente mais antiga
Applet, mas devemos preferir aqui a versão mais atual).

O método paint é um dos 3 métodos chamados automaticamente no início da

execução de um applet. Os outros 2 métodos são os métodos start e init.

O método drawString desenha, então, a mensagem "Hello world!" na linha/coluna

25/25 da área de exibição do navegador.

HTML

Um applet, sendo executado por um navegador requer uma chamada através de

um html:

<html>
<applet code="HelloWorld.class" width=300 height=30>
</applet>
</html>
.class é o arquivo byte code compilado Java.

Um APLICATIVO completo para 2 somar números...

Aqui o aplicativo emprega janelas de diálogo para entrada de dados

(JOptionPane).

Exemplo do painéis de entrada e saída:

import javax.swing.JOptionPane; // import class JOptionPane

public class Addition {

public static void main( String args[ ] )
{
String firstNumber, // first string entered by user
secondNumber; // second string entered by user
int number1, // first number to add
number2, // second number to add
sum; // sum of number1 and number2

// read in first number from user as a string

firstNumber =
JOptionPane.showInputDialog( "Enter first integer" );

// read in second number from user as a string

secondNumber =
JOptionPane.showInputDialog( "Enter second integer" );

// convert numbers from type String to type int

number1 = Integer.parseInt( firstNumber );
 number2 = Integer.parseInt( secondNumber );

// add the numbers

sum = number1 + number2;

// display the results

JOptionPane.showMessageDialog(
null, "The sum is " + sum, "Results",
JOptionPane.PLAIN_MESSAGE );

System.exit( 0 ); // terminate the program

}
}

Uma versão simplificada de aplicativo com passagem de parâmetros

através do prompt C:\java soma.class <x> <y> também pode ser
empregado.

import java.io.*;

public class Soma {

public static void main( String args[] )
{
int x, y result;

x = Integer.parseInt( args[0] );
y = Integer.parseInt( args[1] );

result = x + y;
System.out.println( "A soma é " + result + '\n') ;

}
}

Um APPLET completo para somar 2 números...

Aqui o applet emprega janelas de diálogo para entrada de dados.

import java.awt.Graphics; // import class Graphics

import javax.swing.*; // import package javax.swing

public class AdditionApplet extends JApplet {

double sum; // sum of the values entered by the user

public void init()

{
 String firstNumber, // first string entered by user
secondNumber; // second string entered by user
double number1, // first number to add
number2; // second number to add

// read in first number from user

firstNumber =
JOptionPane.showInputDialog(
"Enter first floating-point value" );

// read in second number from user

secondNumber =
JOptionPane.showInputDialog(
"Enter second floating-point value" );

// convert numbers from type String to type double

number1 = Double.parseDouble( firstNumber );
number2 = Double.parseDouble( secondNumber );

// add the numbers

sum = number1 + number2;
}

public void paint( Graphics g )

{
// draw the results with g.drawString
g.drawRect( 15, 10, 270, 20 );
g.drawString( "The sum is " + sum, 25, 25 );
}
}

O método init é executado antes do método paint.

Tratando com exceções

public class TrataExceptions {

public static void main( String args[] )
{
try {
// suas instruções...
}
catch ( Exception e ) {
System.err.println( e.getMessage() + "\n" );
e.printStackTrace();
}
}
}

O bloco try inclui as instruções que no caso de uma ocorrência de exceção (um
erro) ativam as instruções do bloco catch.

Java, objetos e classes

Classes e métodos são denominados de módulos em Java. Uma classe pode ser
definida como:

public class MyClass{

/* atributos da classe */

public MyClass() { /* corpo do método construtor */ }

public metodo1() { ... }

public metodo2( <parâmetros> ) { ... }
public <retorno> metodo3( <parâmetros> ) { ... }
...
}

Uma classe, entretanto, pode ser uma abstração de qualquer objeto real: uma
conta, uma TV ou uma mercadoria. Abaixo uma classe Turma (turma de alunos)
com seus atributos (variáveis de instância) e seus comportamentos (métodos).

package Turma; // pacote a que pertence a classe

public class Turma {

// atributos da classe
public String nome;
public int numAlunos;
public int[] notas;

// método construtor
public Turma(String nome, int numAlunos) {
this.numAlunos = numAlunos;
this.nome = nome;
notas = new int[numAlunos];
for (int i = 0; i < numAlunos; i++)
{
notas[i] = 0;
}
}

// outros métodos da classe

public void notaAluno(int i, int nota) {
 notas[i] = nota;
}

public double mediaAlunos() {

double media = 0;
for (int i = 0; i < numAlunos; i++)
{
media = media + notas[i];
}
media = media / numAlunos;
return media;
}

public void lista() {

for (int i = 0; i < numAlunos; i++)
{
System.out.println("Nota aluno " + i + " : " + notas[i] + '\n');
}
}

Os atributos da classe Turma são:

public String nome; // nome da turma

public int numAlunos; // numero de alunos
public int[] notas; // vetor de notas

E os métodos:

Turma(String nome, int numAlunos) // construtor, cria turma com

// os parâmetros informados
void notaAluno(int i, int nota) // atribui nota ao aluno i
// void indica sem tipo de retorno
double mediaAlunos() // retorna em uma double a
// media da turma
void lista() // lista a nota da turma

Mas a criação de um objeto do tipo Turma requer uma "chamada" por aplicativo ou
applet Java que crie o objeto tipo Turma e invoque seus métodos. Abaixo o
módulo (uma classe aplicativo) ChamaTurma, cria 2 turmas (instância dois objetos
tipo turma) invocando alguns métodos da classe associada.

package Turma;

public class ChamaTurma{

 static String nomeT1 = "7D"; // nome de duas turmas
static String nomeT2 = "7J";

static int numT1 = 5; // num de alunos

static int numT2 = 4;

public static void main(String args[])

{

// criando as duas turmas...

Turma t1 = new Turma(nomeT1,numT1);

Turma t2 = new Turma(nomeT2,numT2);

// atribui notas a alunos 1,2 e 3 da turma t1...

t1.notaAluno(1,4);
t1.notaAluno(2,6);
t1.notaAluno(3,7);

// atribui notas a alunos 2 e 3 da turma t2...

t2.notaAluno(2,5);
t2.notaAluno(3,5);

// lista media da turma t1...

System.out.println("Media da turma : " + t1.nome + '\n');

System.out.println("Media da turma: " + t1.mediaAlunos() + '\n');

// lista notas da turma t2...

System.out.println("Notas da turma : " + t2.nome + '\n');

t2.lista();

}
}

A instrução package Turma; indica nas duas classes anteriores indicam ao

compilador Java que as classes formam um pacote de classes que operam em
conjunto.

A instrução abaixo cria o objeto tipo Turma t1 invocando o método construtor da

classe:
 Turma t1 = new Turma(nomeT1,numT1);

e, nesse caso equivale a instrução:

Turma t1 = new Turma("7D",5);

Java RMI, Remote Method Invocation

A RMI permite que objetos Java executando em um mesmo computador ou em

computadores separados se comuniquem através de chamadas de métodos
remotos. Segue abaixo um conjunto de classes exemplificando a codificação
desse tipo de chamada através de um "Hello" Java RMI. Um conjunto de módulos
RMI deve incluir:

Hello.java uma interface remota

HelloImpl.java classes server
uma ou duas classes que implementam o objeto remoto
(aqui empregamos uma única classe)
HelloApplet.java classes client
aplicativo ou applet cliente que chama o objeto remoto
(aqui empregamos um applet)

package examples.hello;

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface Hello extends Remote {

String sayHello() throws RemoteException;
}

package examples.hello;

import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.RMISecurityManager;
import java.rmi.server.UnicastRemoteObject;

public class HelloImpl extends UnicastRemoteObject

implements Hello {

public HelloImpl() throws RemoteException {

super();
}
 public String sayHello() {
return "Hello World!";
}

public static void main(String args[]) {

// Create and install a security manager

if (System.getSecurityManager() == null) {
System.setSecurityManager(new RMISecurityManager());
}
try {
HelloImpl obj = new HelloImpl();
// Bind this object instance to the name "HelloServer"
Naming.rebind("HelloServer", obj);
System.out.println("HelloServer bound in registry");
} catch (Exception e) {
System.out.println("HelloImpl err: " + e.getMessage());
e.printStackTrace();
}
}
}

package examples.hello;

import java.applet.Applet;
import java.awt.Graphics;
import java.rmi.Naming;
import java.rmi.RemoteException;

public class HelloApplet extends Applet {

String message = "blank";

// "obj" is the identifier that we'll use to refer

// to the remote object that implements the "Hello"
// interface
Hello obj = null;

public void init() {

try {
obj = (Hello)Naming.lookup("//" +
getCodeBase().getHost() + "/HelloServer");
message = obj.sayHello();
} catch (Exception e) {
System.out.println("HelloApplet exception: " +
 e.getMessage());
e.printStackTrace();
}
}

public void paint(Graphics g) {

g.drawString(message, 25, 50);
}
}

HTML para execução do applet

<HTML>
<title>Hello World</title>
<center> <h1>Hello World</h1> </center>

The message from the HelloServer is:

<p>
<applet codebase="myclasses/"
code="examples.hello.HelloApplet"
width=500 height=120>
</applet>
</HTML>

Exercícios

1. Crie uma classe Calculadora que executa as operações soma, subtrai,

multiplica e divide.
2. Crie uma aplicação e um applet que empreguem a classe Calculadora utilizando
caixas de diálogo.
3. Inclua na classe aplicativo do exercício anterior o tratamento de exceções.
4. Programe uma interface para a chamada remota dos métodos da classe
Calculadora.
5. Adapte a classe Calculadora para uma classe do tipo server de uma aplicação
Java RMI.
6. Faça um aplicativo Java client (não um applet) para invocar remotamente os
métodos da classe Calculadora.
7. Divida a classe do exercício 5 em um pacote de 2 classes separando os
serviços da classe Calculadora e do Java RMI.
8. Faz sentido a chamada de uma Calculadora remota? Imagine uma calculadora
poderosa e não somente com as quatro operações...

Referências

Deitel, H.M., Deitel, P.J. Java, como programar. Bookman, 2001.

Davis, S.R. Aprenda Java agora. Microsoft Press/Campus, 1997.
SUN, Getting started using Java RMI, online em java.sun.com/j2se/1.3/docs/
SOFTWARE, Jbuilder 3 University Edition.