JAVA - Cap01

Prévia do material em texto

Java
Notas de Aula
Prof. André Bernardi
Característica Básica
� http://java.sun.com
� Capacidade de execução em diferentes 
plataformas e sistemas operacionais, 
sem a necessidade de recompilação do 
código fonte.
Subdivisões da Tecnologia Java
� Java foi oficialmente apresentado em 
1995 pelo consorcio Sun.
� Em 1999 surge a chamada segunda 
edição do java na qual foram criadas as 
seguintes denominações:
� J2ME – Java Micro Edition
� J2SE – Java Standard Edition
� J2EE – Java Enterprise Edition
Ambiente Java
Ambiente Java
Java Application
// Welcome1.java - A first program in Java.
public class Welcome1
{
// main method begins execution of Java application
public static void main( String args[] )
{
System.out.println("Welcome to Java Programming!");
} // end method main
} // end class Welcome1
Compilação
� Obter e instalar o compilador java
gratuitamente na pagina da Sun
� http://java.sun.com
� http://java.sun.com/j2se/1.5.0/docs/api/
� javac Welcome1.java
� java Welcome1
Segundo exemplo
// Welcome4.java - Printing multiple lines in a dialog box
// import class JOptionPane
import javax.swing.JOptionPane;
public class Welcome4
{ // main method begins execution of Java application
public static void main( String args[] )
{
JOptionPane.showMessageDialog(null,
"Welcome\nto\nJava\nProgramming!" );
System.exit( 0 ); // terminate application
} // end method main
} // end class Welcome4
Terceiro Exemplo
Terceiro Exemplo
Quarto Exemplo
// Addition program that displays the sum of two numbers.
import java.util.Scanner; // program uses class Scanner
public class Addition
{
// main method begins execution of Java application
public static void main( String args[] )
{ // create Scanner to obtain input from command window
Scanner input = new Scanner( System.in );
int number1; // first number to add
int number2; // second number to add
int sum; // sum of number1 and number2
System.out.print( "Enter first integer: " ); // prompt
number1 = input.nextInt(); // read first number from user
System.out.print( "Enter second integer: " ); // prompt
number2 = input.nextInt(); // read second number from user
sum = number1 + number2; // add numbers
System.out.printf( "Sum is %d\n", sum ); // display sum
} // end method main
} // end class Addition
Operadores
Operadores Aritméticos
Operadores Relacionais
Operadores
Operadores Lógicos
Regras de precedência
Palavras reservadas
Estruturas de Controle
Estrutura Condicional
if ( studentGrade >= 60 )
System.out.println( "Passed" );
if ( studentGrade >= 60 )
System.out.println( "Passed" );
else
System.out.println( "Failed" );
Estrutura while
int product = 2;
while ( product <= 1000 )
product = 2 * product;
Estrutura for
for ( int counter = 1; counter <= 10; counter++ )
g.drawLine( 10, 10, 250, counter * 10 );
Estrutura switch
Estrutura do/while
int counter = 1;
do {
g.drawOval( 110 - counter * 10, 110 -
counter * 10, counter * 20,
counter * 20 );
++counter;
} while ( counter <= 10 ); // end do/while
Resumo das estruturas
Resumo das estruturas
Exercícios
1. Escreva um programa em Java que desenhe um Retângulo Na Tela,
com as seguintes personalizações possíveis:
� Possua largura e altura lidas pelo teclado;
� Leia o caractere que vai ser usado para desenhar a borda;
� Leia o caractere de preenchimento;
� Pergunte ao usuário se o retângulo vai ser preenchido ou não.
Como exemplo, se o programa executasse com largura = 12, altura = 5, 
com o caractere x para borda, o caractere . para preenchimento e o 
retângulo fosse preenchido, o resultado seria o mostrado abaixo:
xxxxxxxxxxxx
x..........x
x..........x
x..........x
xxxxxxxxxxxx
Exercícios
2. Crie um programa em Java calcular e 
imprimir os 20 primeiros números primos. 
Lembrar que um número primo é aquele que 
só é divisível por ele mesmo e por um.
3. Faça um aplicativo Java para calcular o 
fatorial de um número, digitado pelo usuário. 
Lembrar que :
n! = 1 * 2 * ... * (n-2) * (n-1) * n;
Métodos
Outra denominação para “função 
membro”
Métodos da Classe Math
Métodos da Classe Math
Geração de números aleatórios
� Método random() da classe Math
� Gera sempre valores em double na faixa 
0.0 ≤ x < 1.0
� Classe Random da biblioteca java.util
� Pode gerar varias formas de números 
aleatórios, através do uso das funções.
� nextInt, nextDouble, nextFloat, 
nextGaussian, nextLong, nextBoolean...
Geração de números aleatórios
int a = (int) ( deslocamento + 
Math.random()*escala);
� Gerar valores entre 100 e 899 
int a = (int) ( 100 + Math.random()*800); 
� Random randomNumbers = new Random(); 
int a = randomNumbers.nextInt(); 
int a = 100 + randomNumbers.nextInt(800); 
Exercício 1
1. Crie um método em Java que calcule a 
distância D (em metros) alcançada por um 
míssil lançado com uma velocidade inicial V 
(em m/s) e um ângulo de tiro A (em graus). 
Sabe-se da física básica que a expressão para 
esse cálculo (desconsiderando o atrito do ar) 
é a seguinte:
onde g = 9,8 m/s2g
AVD )2sin(.
2
=
Exercício 2
2. O comprimento do arco ABC de uma parábola é
dada por ,
onde a é a altura da parábola e b é a distância 
entre A e C (veja figura acima). Implemente um 
programa em Java que leia os valores a e b e 
calcule o comprimento do arco da parábola 
correspondente através do uso de uma função 
Programação orientada a objetos
� Baseada na criação de classes contendo métodos e atributos
public class GradeBook
{
private String atributo;
public void setAtributo(String a)
{
atributo = a;
}
public String getAtributo()
{
return atributo;
}
public void displayMessage()
{
System.out.println( “Hello World!! “ + getAtributo() );
} // end method displayMessage
} // end class GradeBook
Strings e Caracteres
Strings e Caracteres
Os objetivos deste tópico são:
� Criar e manipular conjuntos de caracteres 
não modificáveis, objetos da classe String
� Criar e manipular conjuntos de caracteres 
modificáveis, objetos da classe StringBuffer
� Criar e manipular Objetos da classe 
Character
� Compreender a utilização da classe 
StringTokenizer
Classe String - Construtores
String();
String( String );
String( charArray );
String( charArray, inicio, numero);
String( byteArray, inicio, numero);
String ( StringBuffer );
Classe StringString
Métodos length, charAt, getChars
long length()
char charAt(posicao)
void getChars(inicio, fim,
charArray, inicio)
Classe StringString
Métodos de Comparação
boolean equals(String); // true se iguais
boolean equalsIgnoreCase(String);
int compareTo(String);( <0, ==0, >0 )
boolean regionMatches(inicio, string,
inicio, cont); // true se iguais
boolean String.regionMatches(caseIgnore,
inicio, string, inicio, cont);
boolean String.startWith(String, offset);
boolean String.endWith(String);
Classe StringString
Localizando caracteres e substrings
int indexOf(String);
int indexOf(String, inicio);
int indexOf(char);
int indexOf(char, inicio);
int lastIndexOf(String);
int lastIndexOf(String, inicio);
int lastIndexOf(char );
int lastIndexOf(char, inicio);
Classe StringString
� Extraindo substrings
String substring(indice);
String substring(inicio,
final);
� Concatenando strings
String String.concat( String );
Classe StringString
Métodos Variados
String replace(charFrom, charTo)
String toLowerCase()
String toUpperCase()
String trim()
String toString()
char[ ] toCharArray()
Classe StringBufferStringBuffer
� Construtores
StringBuffer();
StringBuffer(int);
StringBuffer(String);
StringBuffer(StringBuffer);
� Métodos length, capacity
StringBuffer.length();
StringBuffer.capacity();
Classe StringBufferStringBuffer
StringBuffer.charAt(int);
StringBuffer.setCharAt(posicao, char);
StringBuffer.getChars(inicio, fim,
destino, inicio);
StringBuffer.reverse();
Classe StringBufferStringBuffer
StringBuffer.append(Object);
StringBuffer.append(String);
StringBuffer.append(char);
StringBuffer.append(char[]);
StringBuffer.append(char[], start,end );
StringBuffer.append(int);
StringBuffer.append(long);
StringBuffer.append(float);
StringBuffer.append(double);
Classe StringBufferStringBuffer
StringBuffer.insert(pos,Object);
StringBuffer.insert(pos,String);
StringBuffer.insert(pos,char);
StringBuffer.insert(pos,charArray);
StringBuffer.insert(pos,int);
StringBuffer.insert(pos,long);
StringBuffer.insert(pos,float);
StringBuffer.insert(pos,double);
StringBuffer.insert(pos,String);
StringBuffer.deleteCharAt(pos);
StringBuffer.delete(inicio,fim);
Classe CharacterCharacter
boolean Character.isDefined(char)
boolean Character.isJavaIdentifierStart(char)
boolean Character.isJavaIdentifierPart(char)
boolean Character.isDigit(char)
boolean Character.isLetter(char)
boolean Character.isLetterOrDigit(char)
boolean Character.isLowerCase(char)
boolean Character.isUpperCase(char)
boolean Character.isWhitespace(char)
� Faixa de valores do char
int Character.MIN_VALUE
int Character.MAX_VALUE
Classe StringTokenizerStringTokenizer
� long StringTokenizer.countTokens()
� boolean StringTokenizer.hasMoreTokens()
� String StringTokenizer.nextToken()
// Exemplo
StringTokenizer strT;
strT = new StringTokenizer
(“Uma frase com cinco palavras”);
while(strT.hasMoreTokens())
System.out.println(strT.nextToken());
Exercícios
Graphics e Java 2D
Notas de Aula
Prof. André Bernardi
Introdução
Contexto e Objeto Graphics
� O Contexto Graphics habilita o desenho 
em uma tela em Java
� O objeto Graphics gerencia um contexto 
gráfico.Possui controles de fonts e cores
� public void paint(Graphics g)
� public void repaint( )
� public void update( Graphics g );
Controle Color
Métodos da classe Color
� public Color( int r, int g, int b )
� public Color( float r, float g, float b )
� public int getRed()
� public int getGreen()
� public int getBlue()
� public Color getColor()
� public void setColor( Color c )
JColorChooser
� JColorChooser.showDialog( 
Component, “Titulo do diálogo", corInicial )
Controle Fonts
� public final static int 
PLAIN
� public final static int 
BOLD
� public final static int 
ITALIC
� public Font( String 
name, int style, int 
size )
� public int getStyle()
� public int getSize()
� public String getName()
public String getFamily()
� public boolean isPlain()
� public boolean isBold()
� public boolean isItalic()
� public Font getFont()
� public void setFont( Font f )
// Fig. 12.11: FontJPanel.java
// exibe strings em diferentes fontes e cores.
import java.awt.Font;
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JPanel;
public class FontJPanel extends JPanel
{
// exibe Strings em diferentes fontes e cores
public void paintComponent( Graphics g )
{
// chama o paintConponent da superclasse 
super.paintComponent( g ); 
// fonte configurada como Serif (Times), negrito, 12 pt
g.g.setFontsetFont( new ( new FontFont( "( "SerifSerif", ", FontFont.BOLD, 12 ) );.BOLD, 12 ) );
g.g.drawStringdrawString( "( "SerifSerif 12 12 pointpoint boldbold.", 20, 50 );.", 20, 50 );
// fonte monoespaçada (Courier), 24 pt itálico
g.setFontsetFont( new Font( "Monospaced", Font.ITALIC, 24 ) );
g.drawStringdrawString( "Monospaced 24 point italic.", 20, 70 );
// fonte SansSerif (Helvetica), simples, 14 pt
g.setFontsetFont( new Font( "SansSerif", Font.PLAIN, 14 ) );
g.drawStringdrawString( "SansSerif 14 point plain.", 20, 90 );
// fonte Serif (Times), 18 pt negrito/itálico
g.setColorsetColor( Color.RED );
g.setFontsetFont( new Font( "Serif", Font.BOLD + Font.ITALIC, 18 ) );
g.drawStringdrawString( g.getFont().getName() + " " + 
g.getFont().getSize() + " point bold italic.", 20, 110 );
} // fim do método paintComponent
} // fim da classe FontJPanel
Controle Fonts
� public int getAscent()
� public int getDescent()
� public int getLeading()
� public int getHeight()
� public FontMetrics getFontMetrics()
� public FontMetrics getFontMetrics( Font f )
Desenhando Linhas, 
Retângulos e ovais
� public void drawLine( int x1, int y1, int x2, int y2 )
� public void drawRect( int x, int y, int width, int height )
� public void clearRect( int x, int y, int width, int height )
� public void fillRect( int x, int y, int width, int height )
� public void drawRoundRect( int x, int y, int width, int height, 
int arcWidth, int arcHeight )
� public void fillRoundRect( int x, int y, int width, int height, 
int arcWidth, int arcHeight )
� public void draw3DRect( int x, int y, int width, int height, 
boolean b )
� public void fill3DRect( int x, int y, int width, int height, 
boolean b )
� public void drawOval( int x, int y, int width, int height )
� public void fillOval( int x, int y, int width, int height )
Desenhando Arcos
� public void drawArc( int x, int y, int width, int 
height, int startAngle, int arcAngle )
� public void fillArc( int x, int y, int width, int height, 
int startAngle, int arcAngle )
Desenhando Polígonos e Poli-
linhas
� public void drawPolygon( int xPoints[], 
int yPoints[], int points )
� public void drawPolyline( int xPoints[], 
int yPoints[], int points )
� public void drawPolygon( Polygon p )
� public void fillPolygon( int xPoints[], int 
yPoints[], int points )
� public void fillPolygon( Polygon p )
// Fig. 7.22: DrawRainbow.java
// Demonstra a utilização de cores em um array.
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JPanel;
public class DrawRainbow extends JPanel
{
// Define as cores índigo e violeta
final Color VIOLET = new Color( 128, 0, 128 );
final Color INDIGO = new Color( 75, 0, 130 );
// a utilizar no arco-íris, iniciando da parte mais interna
// As duas entradas em branco resultam em um arco vazio no centro
private Color colors[] =
{ Color.WHITE, Color.WHITE, VIOLET, INDIGO, Color.BLUE,
Color.GREEN, Color.YELLOW, Color.ORANGE, Color.RED };
// construtor
public DrawRainbow()
{
setBackground( Color.WHITE ); // configura o fundo como branco
} // fim do construtor DrawRainbow
// desenha um arco-íris utilizando círculos concêntricos
public void paintComponent( Graphics g )
{
super.paintComponent( g );
int radius = 20; // raio de um arco
// desenha o arco-íris perto da parte central inferior
int centerX = getWidth() / 2;
int centerY = getHeight() - 10;
// desenha arcos preenchidos com o mais externo
for ( int counter = colors.length; counter > 0; counter-- )
{
// configura a cor para o arco atual
g.setColor( colors[ counter - 1 ] );
// preenche o arco de 0 a 180 graus
g.fillArc( centerX - counter * radius,
centerY - counter * radius, 
counter * radius * 2, counter * radius * 2, 0, 180 );
} // for final
} // fim do método paintComponent
} // fim da classe DrawRainbow
Exemplo - DrawSmiley
// Fig. 6.16: DrawSmiley.java
// Demonstrates filled shapes.
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JPanel;
public class DrawSmiley extends JPanel
{
public void paintComponent( Graphics g )
{
super.paintComponent( g );
// draw the face
g.setColor( Color.YELLOW ); 
g.fillOval( 10, 10, 200, 200 ); 
// draw the eyes
g.setColor( Color.BLACK ); 
g.fillOval( 55, 65, 30, 30 ); 
g.fillOval( 135, 65, 30, 30 );
// draw the mouth
g.fillOval( 50, 110, 120, 60 );
// "touch up" the mouth into a smile
g.setColor( Color.YELLOW ); 
g.fillRect( 50, 110, 120, 30 );
g.fillOval( 50, 120, 120, 40 );
} // end method paintComponent
} // end class DrawSmiley
API Java2D
� Para acessar as funcionalidades da 
biblioteca Graphics2D devemos 
obter sua referencia a partir de um 
contexto gráfico.
� Graphics2D g2d = ( Graphics2D ) g
� g2d.translate(x, y)
� g2d.rotate(radianos)
Java2D Shapes
� java.awt.geom
� Ellipse2D.Double
� Rectangle2D.Double
� RoundRectangle2D.Double
� Arc2D.Double
� Line2D.Double
API Java2D
g2d.setPaint( new GradientPaint( 5, 30, 
Color.blue, 35, 100, Color.yellow, true ) );
g2d.fill( new Ellipse2D.Double( 5, 30, 65, 100 ) );
g2d.setPaint( Color.red );
g2d.setStroke( new BasicStroke( 10.0f ) );
g2d.draw( new Rectangle2D.Double( 80, 30, 65, 
100 ) );
API Java2D
BufferedImage buffImage =new BufferedImage( 10, 10, 
BufferedImage.TYPE_INT_RGB );
Graphics2D gg = buffImage.createGraphics();
gg.setColor( Color.yellow ); // draw in yellow
gg.fillRect( 0, 0, 10, 10 ); // draw a filled rectangle
gg.setColor( Color.black ); // draw in black
gg.drawRect( 1, 1, 6, 6 ); // draw a rectangle
gg.setColor( Color.blue ); // draw in blue
gg.fillRect( 1, 1, 3, 3 ); // draw a filled rectangle
gg.setColor( Color.red ); // draw in red
gg.fillRect( 4, 4, 3, 3 ); // draw a filled rectangle
API Java2D
g2d.setPaint( new TexturePaint( buffImage, new 
Rectangle( 10, 10 ) ) );
g2d.fill( new RoundRectangle2D.Double(155, 30, 75, 100, 
50, 50 ) );
g2d.setPaint( Color.white );
g2d.setStroke( new BasicStroke( 6.0f ) );
g2d.draw( new Arc2D.Double(240, 30, 75, 100, 0, 270, 
Arc2D.PIE ) ); //Arc2D.CHORD Arc2D.OPEN
API Java2D
g2d.setPaint( Color.green );
g2d.draw( new Line2D.Double( 395, 30, 320, 150 ) );
g2d.setPaint( Color.yellow );
g2d.setStroke( new BasicStroke( 4, 
BasicStroke.CAP_ROUND, 
BasicStroke.JOIN_ROUND, 10, dashes, 0 ) );
g2d.draw( new Line2D.Double( 320, 30, 395, 150 ) );
API Java2D
� GradientPaint( xi, yi, CorI, xf, yf, CorF, cicl )
� BufferedImage(lagura, altura, 
BufferedImage.TYPE_INT_RGB )
� buffImage.createGraphics();
� TexturePaint(buffImage, new Rectangle( lagura, 
altura ) )
� BasicStroke( 4, BasicStroke.CAP_ROUND, 
BasicStroke.JOIN_ROUND, 10, dashes, 0 ) );
Classe GeneralPath
� Podemos construir uma Shape
personalizada com a classe GeneralPath
� Utilizamos os métodos:
� moveTo( x , y )
� lineTo (x , y )
� curveTo(x1, y1, x2, y2, x3, y3)
� quadTo(x1, y1, x2, y2)
� closePath()
// Fig. 12.31: Shapes2JPanel.java
// Demonstrando um caminho geral.
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.GeneralPath;
import java.util.Random;
import javax.swing.JPanel;
public class Shapes2JPanel extends JPanel
{
// desenha caminhos gerais
public void paintComponent( Graphics g )
{
super.paintComponent( g ); // chama o paintComponent da superclasse
Random random = new Random(); // obtém o gerador de números aleatórios
int xPoints[] = { 55, 67, 109, 73, 83, 55, 27, 37, 1, 43 };
int yPoints[] = { 0, 36, 36, 54, 96, 72, 96, 54, 36, 36 };
Graphics2D g2d = ( Graphics2D ) g;Graphics2D g2d = ( Graphics2D ) g;
GeneralPathGeneralPath star = new star = new GeneralPathGeneralPath();(); // cria o objeto GeneralPath
// configura a coordenada inicial do General Path
star.moveTo( xPoints[ 0 ], yPoints[ 0 ] ); 
// cria a estrela -- isso não desenha a estrela
for ( int count = 1; count < xPoints.length; count++ )
star.lineTo( xPoints[ count ], yPoints[ count ] );
star.closePath(); // fecha a forma
g2d.translate( 200, 200 ); // translada a origem para (200, 200)
// gira em torno da origem e desenha estrelas em cores aleatórias
for ( int count = 1; count <= 20; count++ ) 
{
g2d.rotate( Math.PI / 10.0 ); // rotaciona o sistema de coordenadas
// configura cores aleatórias
g2d.setColor( new Color( random.nextInt( 256 ),
random.nextInt( 256 ), random.nextInt( 256 ) ) );
g2d.g2d.fillfill( star );( star ); // desenha estrela preenchida
} // for final
} // fim do método paintComponent
} // fim da classe Shapes2JPanel
Exercício
� Criar um programa em Java para 
desenhar círculos concêntricos usando 
duas cores alternadas como o desenho 
da figura abaixo:
Exercícios
Referencias
� Java How to program 3, 4, 5 e 6 ed.
Deitel e Deitel
� Sun
http://java.sun.com