Uma breve introdução ao Java

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;
Student studentA;
// classes com maiúsculas
// objetos com minúsculas
int nVar;
char cVar;
...
// tipos primitivos iniciam com letra indicando o tipo
// (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
boolean
byte
char
short
int
long
float
Var
bVar;
yVar;
cVar;
sVar;
nVar;
lVar;
fVar;
comentário, tamanho em bits, valor padrão
// boolean, 8, False
// byte, 8, x00
// caracter, 16, x0000
// short, 16, 0
// inteiro, 32, 0
// long, 64, 0
// 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
float
nVar;
fVar;
fVar = nVar;
// funciona pois fVar tem precisão maior...
fVar = (float)nVar; // mas é preferível
nVar = fVar;
nVar = (int)fVar;
// não funciona pois há perda de precisão...
// 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;
n = ( nA=4 ) / 2;
// o resultado é 14 pela precedência do operador *
// o resultado é 2
n = 1;
nA = ++n;
nB = n++;
nB += 1;
// pré-incremento n=2 e nA=2
// pós-incremento n=3 e nB=2
// 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;
i++;
}
// sai imediatamente...
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;
public int numAlunos;
public int[] notas;
// nome da turma
// numero de alunos
// vetor de notas
E os métodos:
Turma(String nome, int numAlunos)
void notaAluno(int i, int nota)
double mediaAlunos()
void lista()
// construtor, cria turma com
// os parâmetros informados
// atribui nota ao aluno i
// void indica sem tipo de retorno
// retorna em uma double a
// media da turma
// 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";
static String nomeT2 = "7J";
static int numT1 = 5;
static int numT2 = 4;
// nome de duas turmas
// num de alunos
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
HelloImpl.java
HelloApplet.java
uma interface remota
classes server
uma ou duas classes que implementam o objeto remoto
(aqui empregamos uma única classe)
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.