Programação OO com Java

Noções básicas de Java
Programa básico
Instruções de controle
Métodos
Classes
Objetos
Applets
Um programa simples
/*
O primeiro programa simples
*/
public class First
{
public static void main(String args[ ]){
// enviar mensagem para tela
System.out.println(“Hello World”);
}
}
Um programa simples
Usando o JDK (Java Development Kit):
 javac First.java
para compilar o programa
 java First
para executar o programa
Métodos
public class Second
{
public static void printIt(String message) {
System.out.println(message);
}
public static void main(String args[ ] ) {
printIt(“Hello World”);
}
}
Operadores
Operadores + - * /
Operadores ++ e - ++T é equivalente a T = T + 1
Operador +=
 T+=5 é equivalente a T = T + 5
Igualdade == e desigualdade !=
relacionais < <= >= >
And &&
Or
||
Instrução for
for (inicialização;teste;incremento) {
// corpo do laço for
}
exemplo:
int i;
for (i = 1; i <= 25; i++) {
System.out.println(“ï = “ + i);
}
Instrução while
while (condição booleana for verdadeira) {
// corpo do laço while
}
exemplo:
int i = 1;
while ( i <= 25) {
System.out.println(“ï = “ + i);
i++;
}
Instrução do-while
do {
// corpo do laço do-while
}while(condição booleana for verdadeira);
exemplo:
int i = 1;
do {
System.out.println(“ï = “ + i);
i++;
} while(i <= 25);
Instrução if
if (condição booleana é verdadeira){
// instrução(ões)
}
else if (condição booleana é verdadeira){
//outra(s) instrução(ões)
}
else{
ainda outra(s) instrução(ões)
}
Tipos de dados
Primitivos:
 boolean, char, byte, short, int, long, float e double
de referência:
 objetos e vetores
Classes e objetos
class Point
{
//dados da classe
private int xCoord; // coordenada x
private int yCoord; // coordenada y
// construtor para inicializar o objeto
public Point(int i, int j) {
xCoord = i;
yCoord = j;
}
// método para troca de valores entre x e y
public void swap( ) {
int temp;
temp = xCoord; xCoord = yCoord;
yCoord = temp;
}
}
Classes
Classe é a descrição de um molde que
especifica as propriedades e o
comportamento para um conjunto de
objetos similares.
Todo objeto é instância de apenas uma
classe.
Atributos e operações são parte da
definição de uma classe.
Criação de objetos em Java
Point pta;
pta = new Point(0,15);
Point ptb = new Point( );
// NÃO!!!
public Point( ){
xCoord = 0;
yCoord = 0;
}
Point ptb = new Point ( ); // Certo!
Métodos em Java
ptA.swap();
ptA.printIt();
métodos estáticos e de instância
modificadores private e public
public static final double PI = 3.14.159;
Objetos como referências
public class Third
{
public static void main(String args[ ]){
Point ptA = new Point(5,10);
Point ptB = new Point(-15,-25);
ptA.printIt();
ptB.printIt();
ptA.swap();
ptA.printIt();
Point ptC = ptB;
ptC.swap();
ptB.printIt();
ptC.printIt();
}
Objetos como referências
xCoord=5
yCoord=10
xCoord=-15
yCoord=-25
ptC
ptA
ptB
Arrays
byte[ ] numbers = new byte[10];
int [ ] primeNums = {3,5,7,11,13};
Point[ ] pts = new Point[5];
for (int i = 0; i < 5; i++) {
pts[i] = new Point(i,i);
pts[i].printIt();
}
Pacotes
Um pacote é um conjunto de classes
correlatas.
java.<nome do pacote>.<nome da classe>
java.lang.String
java.lang.Thread
java.util.Vector items = new
java.util.Vector();
import java.util.Vector;
Vector items = new Vector();
Tratamento de exceções
try {
// chama algum(ns) método(s) que
// podem resultar em uma exceção.
}
catch(theException e) {
// trate a exceção
}
finally {
// execute isto quer a exceção
// tenha ocorrido ou não.
}
Herança
public class Person
{
private String name;
private int age;
private String ssn;
public Person(String n, int a, String s) {
name = n;
age = a;
ssn = s;
}
public void printPerson(){
System.out.println(“Name: “+ name);
System.out.println(“Age:”+ age);
System.out.println(“Social Security:”+ ssn);
}
}
Herança
public class Student extends Person
{
private String major;
private double CR;
public Student(String n, int a, String s,
String m, double g) {
super (n, a, s);
major = m;
CR = g;
}
public void studentInfo(){
printPerson();
System.out.println(“Major:”+ major);
System.out.println(“CR:”+ CR);
}
}
Interface e classes abstratas
Interface é semelhante a uma definição
de classe, exceto que só contém uma lista
de métodos e seus parâmetros.
Classe abstrata é semelhante a uma
interface, mas pode conter métodos
abstratos e definidos.
Nem interfaces nem as classes abstratas
podem ser intanciadas.
Interface
public interface Shape
{
public double area();
public double circunference();
public static final double PI = 3.14159;
}
public class Circle implements Shape
{
private double radius;
public double area(){
return PI*radius*radius
}
public double circunference{
}
Classe abstrata
public abstract class Employee{
}
public class Manager extends Employee
{
private static final double BONUS = 2500;
public Manager(String n, double s){
super(n,s);
}
public void computeRaise{
salary += salary *.05 + BONUS;
}
}
Applets
import java.applet.*;
import java.awt.*;
public class FirstApplet extends Applet
{
public void init(){
//código da inicialização
}
public void paint(Graphics g){
g.drawString(“Java Primer Now Brewing!);
}
}
Applets
<applet
code = FirstApplet.class
width = 400
height = 200>
</applet>