Tecnologia e outros
"The code that is the hardest to debug is the code that you know cannot
possibly be wrong."
-Unknown
-Introdução-
Nesta página existem códigos de programas em Java. Quaisquer problemas ou erros, por favor, entrem em contato!
|
|
|
|
Clique aqui para ir até a página da lista de discussão sobre a API de Comunicação serial.
ENVIO DE LIVROS PARA COMENTÁRIOS clique aqui.
Uma Nota:
Pessoal, tem recebido várias mensagens com solicitação de ajuda. Peço um pouco de compreensão se demorar a responder, é que meu trabalho me impede de dedicar atenção total a correspondência eletrônica.
O colega Silmar apontou um bug na classe de comunicação serial. Onde se lê:
public void LerDados(){
if (Escrita == true){
Deve ser lido:
public void LerDados(){
if (Leitura == true){
Outro problema: Tenho recebido emails dizendo que a API não roda corretamente no Windows 98 e XP. Procurei a resposta no site da SUN e não encontrei. Vou entrar em contato com a SUN e espero que eles possam me responder.
Java serial por Douglas Vinícius Carvalho
O meu amigo Douglas Vinícius de Carvalho, dessa vez realmente detonou (no bom sentido). Ele escreveu uma aplicação utilizando a API da Sun para comunicar o PC com um painel digital. Com a permissão do atuor publico nesse link o código desenvolvido pelo colega. Parabéns! E obrigado por permitir que eu colocasse esse código aqui.
Comunicação com a Porta Paralela do PC
O colega Douglas Vinícius de Carvalho, desenvolvedor Java, está implementando comunicação com a porta paralela em Java utilizando a API Java Comm. Que eu saiba, é o único exemplo em Português do assunto. Parabéns Douglas!
package Impressora_Atual;
import java.io.*;
import java.util.*;
import javax.comm.*;
import javax.swing.JOptionPane;
/**
* Class declaration
*
*
* @author Douglas Vinícius de Carvalho
* @data 02/09/04
*/
public class Impressora_Teste {
static Enumeration portList;
static CommPortIdentifier portId;
static ParallelPort parallelPort;
static OutputStream outputStream;
static boolean outputBufferEmptyFlag = false;
public static void main(String[] args) {
boolean portFound = false;
String defaultPort = "LPT1";
String primeira_string;
String frame_="";
StringBuffer inicio_string = new StringBuffer("024C0D443131314A30303030303031383030313630");
String inicio_stringHexToString = new String("");
for(int i = 0; i < inicio_string.length(); i += 2){
String inicio_stringTemp = inicio_string.substring(i, i + 2);
inicio_stringHexToString += new Character((char)(Integer.valueOf(inicio_stringTemp,16).intValue())).toString();
frame_=inicio_stringHexToString;
}
StringBuffer final_string = new StringBuffer("0D450D");
String final_stringHexToString = new String("");
for(int i = 0; i < final_string.length(); i += 2){
String final_stringTemp = final_string.substring(i, i + 2);
final_stringHexToString += new Character((char)(Integer.valueOf(final_stringTemp,16).intValue())).toString();
frame_=final_stringHexToString;
}
primeira_string = JOptionPane.showInputDialog( "Digite o Codigo de Barras" );
StringBuffer meio_string = new StringBuffer(primeira_string);
for (int i = 0; i < primeira_string.length(); i++) {
char ch = primeira_string.charAt(i);
if (ch < 0x10)
meio_string.append(Integer.toHexString(ch & 0xFF));
}
String string_completa = inicio_stringHexToString + meio_string + final_stringHexToString;
if (args.length > 0) {
defaultPort = args[0];
}
portList = CommPortIdentifier.getPortIdentifiers();
while (portList.hasMoreElements()) {
portId = (CommPortIdentifier) portList.nextElement();
if (portId.getPortType() == CommPortIdentifier.PORT_PARALLEL) {
if (portId.getName().equals(defaultPort)) {
System.out.println("Found port " + defaultPort);
portFound = true;
try {
parallelPort =
(ParallelPort) portId.open("SimpleWrite", 2000);
} catch (PortInUseException e) {
System.out.println("Port in use.");
continue;
}
try {
outputStream = parallelPort.getOutputStream();
} catch (IOException e) {}
try {
parallelPort.notifyOnBuffer(true);
} catch (Exception e) {
System.out.println("Error setting event notification");
System.out.println(e.toString());
System.exit(-1);
}
System.out.println(
"Writing \""+ string_completa +"\" to "
+parallelPort.getName());
try {
outputStream.write( string_completa.getBytes() );
outputStream.flush();
} catch (IOException e) {}
try {
Thread.sleep(2000); // Be sure data is xferred before closing
} catch (Exception e) {}
parallelPort.close();
System.exit(1);
}
}
}
if (!portFound) {
System.out.println("port " + defaultPort + " not found.");
}
}
}
Comunicação serial (3)
Recebi um email de um colega que precisava comunicar um PC com um painel. Para encurtar a história: depois de algum tempo conseguimos fazer a comunicação.
A dificuldade consistia em enviar o frame corretamente. Se você analisar o código que havia escrito anteriormente,
//... saida.write(msg.getBytes()); Thread.sleep(100); //...
Note que a string msg é simplesmente convertida em bytes sem preocupação alguma. Para haver comunicação corretamente é preciso alterar esse código:
//...
for ( int i = 0 ; i < aux3HexToStringmsg.length() ; i++ ) {
saida.write(aux3HexToStringmsg.charAt(i));
Thread.sleep(5);
saida.flush();
}
//...
Assim, o código envia caracter por caracter para UART/SERIAL, com intervalos mínimos de 5 milisegundos. Assim, garantimos que o frame seja enviado corretamente. Abaixo, forneço os códigos completos. Note que retirei a parte de leitura de dados. Pretendo para bem logo, criar uma classe específica para a leitura de dados.
Programa Principal
//*****************************************************************************
//COMUNICAÇÃO SERIAL UTILIZANDO A API DA SUN
//*****************************************************************************
// CLASSE Scomm1.java É PARTE DO PACKAGE SrCom1
// CLASSE SerialComm1.java É PARTE DO PACKAGE SrCom1
//*****************************************************************************
//AUTOR : Daniel V. Gomes
//EMAIL: dansovg@ig.com.br
//Auxilio: Douglas Vinícius de Carvalho (dcarvalho@premiumbrazil.com.br)
//DATA INICIAL: 29/04/04
//DATA ATUAL: 12/08/04
//*****************************************************************************
// Controle de revisão:
// 01/08/04---> codigo alterado para enviar frame ao invés de uma string
// 14/08/04---> Implementação da comunicação de um frame
//*****************************************************************************
//NOTA: Você pode utilizar este código a vontade mas não me responsabilizo por
//erros durante sua execução. Quaisquer dúvidas ou sugestões,envie-me por email.
//*****************************************************************************
import SrCom1.*;
public class Stest3 extends SerialCom1 {
public Stest3(){
super();
}
public static void main(String[] args){
//preparação do frame de comunicação
StringBuffer aux3 =
new StringBuffer("0102018210466F676F206E6F207365746F7220342003A6");
String aux3HexToString = new String("");
for(int i = 0; i < aux3.length(); i += 2){
String aux3Temp = aux3.substring(i, i + 2);
aux3HexToString +=
new Character((char)
(Integer.valueOf(aux3Temp,16).intValue())).toString();
}
Stest3 st = new Stest3();
if ( st.PortaExiste("COM1") == true) {
System.out.println("Iniciando comunicação!");
SComm1 sc = new SComm1("COM1",19200,1000);
sc.HabilitarEscrita();
sc.ObterIdDaPorta();
sc.AbrirPorta();
sc.EnviarUmaString(aux3HexToString);
System.out.println(aux3HexToString);
sc.FecharCom();
} else {
System.out.println("Nenhuma porta");
}
}
}
Classe para reconhecer portas seriais
//*****************************************************************************
//COMUNICAÇÃO SERIAL UTILIZANDO A API DA SUN
//*****************************************************************************
// CLASSE Scomm1.java É PARTE DO PACKAGE SrCom1
// CLASSE SerialComm1.java É PARTE DO PACKAGE SrCom1
//*****************************************************************************
//AUTOR : Daniel V. Gomes
//EMAIL: dansovg@ig.com.br
//Auxilio: Douglas Vinícius de Carvalho (dcarvalho@premiumbrazil.com.br)
//DATA INICIAL: 29/04/04
//DATA ATUAL: 12/08/04
//*****************************************************************************
// Controle de revisão:
// 01/08/04---> codigo alterado para enviar frame ao invés de uma string
// 14/08/04---> Implementação da comunicação de um frame
//*****************************************************************************
//NOTA: Você pode utilizar este código a vontade mas não me responsabilizo por
//erros durante sua execução. Quaisquer dúvidas ou sugestões,envie-me por email.
//*****************************************************************************
package SrCom1;
import javax.comm.*;
import java.io.*;
import java.util.*;
public class SerialCom1 {
//*********************************
//Variáveis
//*********************************
//variáveis para identificar portas
protected String[] portas;
protected Enumeration listaDePortas;
//construtor
public SerialCom1(){
listaDePortas = CommPortIdentifier.getPortIdentifiers();
}
//retorna as portas disponíveis
public String[] ObterPortas(){
return portas;
}
//Copia portas para um Array
protected void ListarPortas(){
int i = 0;
portas = new String[10];
while (listaDePortas.hasMoreElements()) {
CommPortIdentifier ips =
(CommPortIdentifier)listaDePortas.nextElement();
portas[i] = ips.getName();
i++;
}
}
//pesquisa se a Porta existe
public boolean PortaExiste(String COMp){
String temp;
boolean e = false;
while (listaDePortas.hasMoreElements()) {
CommPortIdentifier ips =
(CommPortIdentifier)listaDePortas.nextElement();
temp = ips.getName();
if (temp.equals(COMp)== true) {
e = true;
};
}
return e;
}
//imprime as portas disponíveis
protected void ImprimePortas(){
for (int i = 0 ; i < portas.length ; i ++ ) {
if (portas[i] != null ) {
System.out.print(portas[i] + " ");
}
}
System.out.println(" ");
}
}//FIM DA CLASSE
Classe para comunicação de dados
//*****************************************************************************
//COMUNICAÇÃO SERIAL UTILIZANDO A API DA SUN
//*****************************************************************************
// CLASSE Scomm1.java É PARTE DO PACKAGE SrCom1
// CLASSE SerialComm1.java É PARTE DO PACKAGE SrCom1
//*****************************************************************************
//AUTOR : Daniel V. Gomes
//EMAIL: dansovg@ig.com.br
//Auxilio: Douglas Vinícius de Carvalho (dcarvalho@premiumbrazil.com.br)
//DATA INICIAL: 29/04/04
//DATA ATUAL: 12/08/04
//*****************************************************************************
// Controle de revisão:
// 01/08/04---> codigo alterado para enviar frame ao invés de uma string
// 14/08/04---> Implementação da comunicação de um frame
//*****************************************************************************
//NOTA: Você pode utilizar este código a vontade mas não me responsabilizo por
//erros durante sua execução. Quaisquer dúvidas ou sugestões,envie-me por email.
//*****************************************************************************
package SrCom1;
import javax.comm.*;
import java.io.*;
//classe Principal
public class SComm1 implements Runnable, SerialPortEventListener {
//propriedades
private String Porta;
public String Dadoslidos;
public int nodeBytes;
private int baudrate;
private int timeout;
private CommPortIdentifier cp;
private SerialPort porta;
//indicadores
private boolean IDPortaOK; //true porta EXISTE
private boolean PortaOK;// true porta aberta
private boolean Escrita;
//construtor default paridade : par
//baudrate: 9600 bps stopbits: 2 COM 1
public SComm1() {
Porta = "COM1";
baudrate = 19200;
timeout = 1000;
};
//um Objeto ComObj é passado ao construtor
//com detalhes de qual porta abrir
//e informações sobre configurações
public SComm1( String p , int b , int t ){
this.Porta = p;
this.baudrate = b;
this.timeout = t;
};
//habilita escrita de dados
public void HabilitarEscrita(){
Escrita = true;
Leitura = false;
};
//Obtém o ID da PORTA
public void ObterIdDaPorta(){
try {
cp = CommPortIdentifier.getPortIdentifier(Porta);
if ( cp == null ) {
System.out.println("A " + Porta + " nao existe!" );
System.out.println("ERRO!Abortando..." );
IDPortaOK = false;
System.exit(1);
}
IDPortaOK = true;
} catch (Exception e) {
System.out.println("Erro durante o procedimento. STATUS" + e );
IDPortaOK = false;
System.exit(1);
}
}
//Abre a comunicação da porta
public void AbrirPorta(){
try {
porta = (SerialPort)cp.open("SComm1",timeout);
PortaOK = true;
System.out.println("Porta aberta com sucesso!");
//configurar parâmetros
porta.setSerialPortParams(baudrate,
porta.DATABITS_8,
porta.STOPBITS_1,
porta.PARITY_NONE);
} catch (Exception e) {
PortaOK = false;
System.out.println("Erro ao abrir a porta! STATUS: " + e );
System.exit(1);
}
}
//Envia uma String que representa o frame de comunicação
public void EnviarUmaString(String aux3HexToStringmsg){
if (Escrita==true) {
try {
saida = porta.getOutputStream();
System.out.println("FLUXO OK!");
} catch (Exception e) {
System.out.println("Erro.STATUS: " + e );
}
try {
//System.out.println("Enviando um byte para " + Porta );
for ( int i = 0 ; i < aux3HexToStringmsg.length() ; i++ ) {
saida.write(aux3HexToStringmsg.charAt(i));
Thread.sleep(5);
saida.flush();
}
} catch (Exception e) {
System.out.println("Houve um erro durante o envio. ");
System.out.println("STATUS: " + e );
System.exit(1);
}
} else {
System.exit(1);
}
}
//função que fecha a conexão
public void FecharCom(){
try {
porta.close();
System.out.println("CONEXAO FECHADA>>FIM..");
} catch (Exception e) {
System.out.println("ERRO AO FECHAR. STATUS: " + e );
System.exit(0);
}
}
//Acessores
public String obterPorta(){
return Porta;
}
public int obterBaudrate(){
return baudrate;
}
}
Processamento de Imagens (2)
Embora pouco acessível (saber quais classes baixar e instalar é complicado), a SUN fornece uma API para manipulação de imagens. JAI (Java Advanced Image), que pode ser baixada em Sun JAI.
Há um livro online para aprender a API.
Imain.class
package daniel.Image;
//*****************************************************************************
//PROCESSAMENTO DE IMAGENS UTILIZANDO A API JAI DA SUN
//*****************************************************************************
//AUTOR : Daniel V. Gomes
//EMAIL: dansovg@ig.com.br
//DATA INICIAL: 03/06/2004
//*****************************************************************************
//NOTA: Você pode utilizar este código a vontade mas não me responsabilizo por
//erros durante sua execução. Quaisquer dúvidas ou sugestões,
//envie-me por email.
//*****************************************************************************
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.io.*;
public class Imain extends JFrame{
public File fileName;
public Imain(){
super("Image Processing");
Container container = getContentPane();
container.setLayout( new FlowLayout(FlowLayout.CENTER) );
JFileChooser fileChooser = new JFileChooser();
fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
int result = fileChooser.showOpenDialog(Imain.this);
if ( result == JFileChooser.CANCEL_OPTION )
return;
fileName = fileChooser.getSelectedFile();
}
}
Img.class
package daniel.Image;
//*****************************************************************************
//PROCESSAMENTO DE IMAGENS UTILIZANDO A API JAI DA SUN
//*****************************************************************************
//AUTOR : Daniel V. Gomes
//EMAIL: dansovg@ig.com.br
//DATA INICIAL: 03/06/2004
//DATA ATUAL: 07/06/2004
//*****************************************************************************
//NOTA: Você pode utilizar este código a vontade mas não me responsabilizo por
//erros durante sua execução. Quaisquer dúvidas ou sugestões,
//envie-me por email.
//*****************************************************************************
/**
* Esta classe faz operações com Imagens
* @author Daniel V. Gomes
* @version 1.0
*/
import java.awt.*;
import java.awt.event.*;
import java.awt.image.renderable.ParameterBlock;
import java.awt.image.RenderedImage;
import java.awt.image.Raster;
/*
import java.awt.image.DataBuffer;
import java.awt.image.ColorModel;
import java.awt.color.ColorSpace;
*/
import java.io.*;
import javax.media.jai.JAI;
//import javax.media.jai.PlanarImage;
import javax.media.jai.RenderedOp;
//import javax.media.jai.ColorCube;
import javax.media.jai.widget.ScrollingImagePanel;
import javax.media.jai.*;
//para transformadas IDFT e IDCT e DFT e DCT
import javax.media.jai.operator.DCTDescriptor;
import javax.media.jai.operator.DFTDescriptor;
import javax.media.jai.operator.IDCTDescriptor;
import javax.media.jai.operator.IDFTDescriptor;
//informações sobre a imagem
import javax.media.jai.PropertySource;
import com.sun.media.jai.codec.*;
public class Img {
/**
* Arquivos fonte e imagens renderizadas
*/
private RenderedOp img1;
/**
* Construtor
*/
public Img( String f ){
img1 = JAI.create( "fileload", f );
}
/**
* @return img1 a imagem renderizada
*/
public RenderedOp getImg1 () {
return img1;
}
/**
* Salva em arquivo a imagem transformada
* @param arquiv (Nome do Arquivo)
* @param im ( Imagem)
*/
public void SalvarEmArquivo( String arquiv , RenderedOp im ){
JPEGEncodeParam encodeParam = null;
FileOutputStream out1 = null;
try {
out1 = new FileOutputStream( arquiv );
} catch (Exception e) {
System.out.println("Error");
}
ImageEncoder encoder =
ImageCodec.createImageEncoder("JPEG", out1 , encodeParam );
try {
encoder.encode( im );
out1.close();
} catch (Exception e) {
}
}
/**
* Threshold a Imagem
* @param im (imagem) band (threshold) e a[3]
* @return RenderedOp Image
*/
public RenderedOp ThresholdI( RenderedOp im , int band , int[] a ){
Integer [] low, high, map;
low = new Integer[band];
high = new Integer[band];
map = new Integer[band];
for (int i = 0; i < band; i++) {
low[i] = new Integer(a[1]);
high[i] = new Integer(a[2]);
map[i] = new Integer(a[3]);
}
ParameterBlock pb = new ParameterBlock();
pb.addSource(im);
pb.add(low);
pb.add(high);
pb.add(map);
RenderedOp ths = JAI.create("threshold", pb);
return ths;
}
/**
* Converte para nível de cinza
* @ author extraído da web
*/
public RenderedOp ColorToGray( RenderedOp i ) {
double [][] matriz = { {0.114D, 0.587D , 0.299D, 0.0D} };
ParameterBlock pb = new ParameterBlock();
pb.addSource(i);
pb.add(matriz);
return ( JAI.create("bandcombine", pb , null ) );
}
/**
* Aplica filtro espacial passa baixas
* Convolui I(x,y) com o kernel
* @param i RenderedOp Image
* @return RenderedOp
*/
public RenderedOp PassaBaixa( RenderedOp i ) {
KernelJAI kernel;
float value = 1/9F;
float[] kernelData = { value , value , value,
value, value, value,
value , value, value };
kernel = new KernelJAI(3, 3, 1, 1, kernelData);
return JAI.create( "convolve", i , kernel );
}
/**
* Aplica filtro espacial passa alta
* Convolui I(x,y) com o kernel
* @param i RenderedOp Image
* @return RenderedOp
*/
public RenderedOp PassaAlta( RenderedOp i ) {
KernelJAI kernel;
float value = -1F;
float[] kernelData = { value , value , value,
value, value*9, value,
value , value, value };
kernel = new KernelJAI(3, 3, 1, 1, kernelData);
return JAI.create( "convolve", i , kernel );
}
/**
* Aplica filtro Laplaciano passa alta
* Convolui I(x,y) com o kernel
* @param i RenderedOp Image
* @return RenderedOp
*/
public RenderedOp Laplaciano( RenderedOp i ) {
KernelJAI kernel;
float[] kernelData = { 1F , -2F , 1F,
-2F, 5F, -2F ,
1F , -2F, 1F };
kernel = new KernelJAI(3, 3, 1, 1, kernelData);
return JAI.create( "convolve", i , kernel );
}
public RenderedOp Bordas( RenderedOp i ) {
float data_h[] = new float[] { 1.0F, 0.0F, -1.0F,
1.414F, 0.0F, -1.414F,
1.0F, 0.0F, -1.0F};
float data_v[] = new float[] {-1.0F, -1.414F, -1.0F,
0.0F, 0.0F, 0.0F,
1.0F, 1.414F, 1.0F};
KernelJAI kern_h = new KernelJAI(3,3,data_h);
KernelJAI kern_v = new KernelJAI(3,3,data_v);
// Create the Gradient operation.
RenderedOp dst = JAI.create("gradientmagnitude", i , kern_h, kern_v);
return dst;
}
/**
* Aplica Transformada Cosseno Discreta
* @param i RenderedOp Image
* @return RenderedOp
*/
public RenderedOp DCTransf( RenderedOp i ) {
ParameterBlock pb = new ParameterBlock();
pb.addSource(i);
RenderedOp dst = JAI.create("dct", pb, null);
return dst;
}
/**
* Aplica Transformada Fourier Discreta
* @param i RenderedOp Image
* @return RenderedOp
*/
public RenderedOp DFTransf( RenderedOp i ) {
ParameterBlock pb = new ParameterBlock();
pb.addSource(i);
//pb.add(DFTDescriptor.REAL_TO_COMPLEX);
RenderedOp dft = JAI.create("dft", pb, null);
int width = dft.getWidth();
int height = dft.getHeight();
Raster dftData = dft.getData();
double[] real =
dftData.getSamples(0, 0, width, height, 0, (double[])null);
double[] imag =
dftData.getSamples(0, 0, width, height, 1, (double[])null);
return dft;
}
/**
* Aplica Transformada Fourier Discreta Inversa
* @param i RenderedOp Image
* @return RenderedOp
*/
public RenderedOp IDFTransf( RenderedOp i ) {
ParameterBlock pb = new ParameterBlock();
pb.addSource(i);
//pb.add(IDFTDescriptor.COMPLEX_TO_COMPLEX);
RenderedOp idft = JAI.create("idft", pb, null);
return idft;
}
/**
* INVERTE IMAGEM
* @param i RenderedOp Image
* @return RenderedOp
*/
public RenderedOp InverteI( RenderedOp i ) {
return JAI.create("Invert", i );
}
/**
* BITWISE NOT
* @param i RenderedOp Image
* @return RenderedOp
*/
public RenderedOp NotBitW( RenderedOp i ) {
return JAI.create("Not", i );
}
/**
* Somar duas Imagens
* @param i1 , i2 RenderedOp Images
* @return RenderedOp
*/
public RenderedOp Somar2Imagens( RenderedOp i1 , RenderedOp i2 ){
ParameterBlock pb = new ParameterBlock();
pb.addSource( i1 );
pb.addSource( i2 );
return JAI.create( "add" , pb );
}
/**
* Subtrair duas Imagens
* @param i1 , i2 RenderedOp Images
* @return RenderedOp
*/
public RenderedOp Sub2Imagens( RenderedOp i1 , RenderedOp i2 ){
ParameterBlock pb = new ParameterBlock();
pb.addSource( i1 );
pb.addSource( i2 );
return JAI.create( "subtract" , pb );
}
/**
* Multiplicar duas Imagens
* @param i1 , i2 RenderedOp Images
* @return RenderedOp
*/
public RenderedOp Multi2Imagens( RenderedOp i1 , RenderedOp i2 ){
ParameterBlock pb = new ParameterBlock();
pb.addSource( i1 );
pb.addSource( i2 );
return JAI.create( "Multiply" , pb );
}
/**
* Multiplicar duas Imagens Complexas
* @param i1 , i2 RenderedOp Images
* @return RenderedOp
*/
public RenderedOp Multi2ImagensComplexas( RenderedOp i1 , RenderedOp i2 ){
ParameterBlock pb = new ParameterBlock();
pb.addSource( i1 );
pb.addSource( i2 );
return JAI.create( "MultiplyComplex" , pb );
}
/**
* Valor absoluto de Imagen
* @param i1 RenderedOp Image
* @return RenderedOp
*/
public RenderedOp Absoluto( RenderedOp i ){
ParameterBlock pb = new ParameterBlock();
pb.addSource( i );
return JAI.create( "Absolute" , pb );
}
}//fim da classe
Image.class
import java.awt.*;
import java.awt.event.*;
import java.awt.image.RenderedImage;
import javax.media.jai.RenderedOp;
import javax.media.jai.widget.ScrollingImagePanel;
import daniel.Image.*;
public class Image {
public Image(){};
/**
* Programa Principal
*/
public static void main ( String args[] ){
Imain application = new Imain();
application.addWindowListener(
new WindowAdapter(){
public void windowClosing (WindowEvent event)
{
System.exit( 0 );
}
}
);
Image ii = new Image();
Img i = new Img ( application.fileName.toString() );
RenderedOp i2 = i.ColorToGray( i.getImg1() );
ii.DisplayImage( i2 , application);
application.pack();
application.show();
}//fim do método main
/**
* Mostra uma imagem no JFrame Imain
* @param i (RenderedOp) e Imain (JFrame)
*/
public void DisplayImage( RenderedOp i , Imain im ) {
im.getContentPane().add(new
ScrollingImagePanel(i, i.getWidth(), i.getHeight()));
}
}
Processamento de Imagens (1)
Em processamento digital de imagens, geralmente, trabalhamos com uma imagem I de dimensão MxN. Assim, o trabalho consiste em carregar uma imagem, passar a imagem para uma matriz, processar a matriz e retornar a matriz processada. É basicamente isso que faz esse código abaixo.
O problema é que a classe PixelGrabber retorna um vetor ao invés de uma matriz. O código abaixo converte esse vetor para matriz, faz um processamento meia boca apenas ilustrativo e mostra a imagem processada.
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
import java.awt.image.*;
import javax.swing.*;
public class TImage extends JFrame {
Dimension d;
Image img;
Image imgt;
int iw, ih;
int pixels[];
int w, h;
public TImage(){
try {
img = getToolkit().getImage("C:/SeuDir/foto.jpg");
MediaTracker t = new MediaTracker(this);
t.addImage(img,0);
t.waitForID(0);
iw = img.getWidth(null);
ih = img.getHeight(null);
pixels = new int[ iw*ih ];
PixelGrabber pg =
new PixelGrabber( img , 0 , 0 , iw , ih , pixels, 0, iw);
pg.grabPixels();
//converte
int[][] ptransf = Convert2Array(pixels);
//TODO: código para processar Imagem
for ( int i = 0 ; i < ih ; i ++ )
for ( int j = 0 ; j < iw ; j++ ) {
ptransf[i][j] = ptransf[i][j]/2;
}
//converte
int[] pixelst = Convert2Vector(ptransf);
imgt = createImage(new MemoryImageSource(iw,ih,pixelst,0,iw));
} catch (InterruptedException e) {};
setVisible(true);
}
public void paint(Graphics g) {
super.paint(g);
g.drawImage(imgt, 25, 25, this);
}
public int[][] Convert2Array( int[] v ) {
int[][] myArray = new int[ih][iw];
for ( int i = 0 ; i < ih ; i++ ) {
for ( int k = 0 ; k < iw ; k++ ){
myArray[i][k] = v[k+iw*i];
}
}
return myArray;
}
public int[] Convert2Vector( int[][] I ) {
int[] myVector = new int[ih*iw];
int f = 0;
for ( int i = 0 ; i < ih ; i++ ) {
for ( int j = 0 ; j < iw ; j++ ) {
myVector[f] = I[i][j];
f++;
}
}
return myVector;
}
public static void main ( String args[] ){
TImage application = new TImage();
application.addWindowListener(
new WindowAdapter(){
public void windowClosing (WindowEvent event)
{
System.exit( 0 );
}
}
);
}
}
Package AdvanceMath
Andei revendo o código que eu fiz para aquelas classes e acabei achando melhor desistir da idéia e criar tudo de novo. Assim, como faz a Microsoft, o Tecnologia e Outros não fornece mais suporte no assunto hehehehehe. Falando sério, eu reformulei a classe para números complexos e a mostro abaixo.
Acabei de implementar a interface gráfica usando o JBuilder 9.0. Facilita mesmo. Claro, eu tive que fazer ajustes manuais, mas foi porque escolhi um JFrame ao invés de "Application".
São três classes: Package Com( classe Complex.java)
Package Com( classe NewN.java)
Package AdvanceMath (Complex.java
Complex e NewN implementam a interface gráfica.
Complex implementa números complexos em Java.
Faça o download do Jar executável (requer jre).
Comp.jar(26KBytes)
/**
* <dados>
* <autor>DANIEL VASCONCELOS GOMES</autor>
* <email>dansovg@ig.com.br</email>
* <version>1.2 : 2004_05_28</version>
* </dados>
*
* <description>
* Interface gráfica utilizando API SWING da SUN
* Auxilio do JBuiler 9.0 para Criar Interface
* </description>
*
* <copyright>
* <nota>Liberado para uso geral. Se possível cite a fonte </nota>
* <autor>Daniel Vasconcelos Gomes. 2003/2004 </autor>
* </copyright>
*
*/
//*****************************************************************************
//INTERFACE GRÁFICA PARA NÚMEROS COMPLEXOS EM JAVA
//*****************************************************************************
//*****************************************************************************
//AUTOR : Daniel V. Gomes
//EMAIL: dansovg@ig.com.br
//DATA INICIAL: 11/05/04
//DATA ATUAL: 28/05/04
//*****************************************************************************
//NOTA: Você pode utilizar este código a vontade mas não me responsabilizo por
//erros durante sua execução. Quaisquer dúvidas ou sugestões,
//envie-me por email.
//****************************************************************************
package comp;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import AdvanceMath.*;
import javax.swing.border.*;
public class Complex extends JFrame {
//COMPONENTES GRÁFICOS
BorderLayout borderLayout1 = new BorderLayout();
GridLayout gridLayout1 = new GridLayout(3,1);
GridLayout gridLayout2 = new GridLayout(3,1);
JPanel jPanel1 = new JPanel();
JPanel jPanel2 = new JPanel();
JButton jButton1 = new JButton();
JButton jButton2 = new JButton();
JButton jButton3 = new JButton();
JButton jButton6 = new JButton();
JButton jButton4 = new JButton();
JButton jButton5 = new JButton();
JButton jButton7 = new JButton();
JButton jButton9 = new JButton();
JTextField jTextField1 = new JTextField();
JTextField jTextField2 = new JTextField();
JLabel jLabel1 = new JLabel();
JLabel jLabel2 = new JLabel();
Border border1;
Border border2;
Border border3;
Border border4;
Border border5;
Border border6;
TitledBorder titledBorder1;
TitledBorder titledBorder2;
//VARIÁVEIS NUMÉRICAS
protected double x1;
protected double y1;
protected double x2;
protected double y2;
private AdvanceMath.Complex c1;
private AdvanceMath.Complex c2;
private AdvanceMath.Complex resultado;
private boolean jaInit = false;
//CONSTRUTOR
public Complex() {
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}
//PROGRAMA PRINCIPAL
public static void main(String[] args) {
Complex complex = new Complex();
complex.setVisible(true);
complex.setResizable(false);
complex.addWindowListener(
new WindowAdapter(){
public void windowClosing (WindowEvent event)
{
System.exit( 0 );
}
}
);
}
//INICIALIZA COMPONENTES GRÁFICOS NO JFRAME
private void jbInit() throws Exception {
border1 = BorderFactory.createLineBorder(Color.white,2);
border2 = BorderFactory.createEtchedBorder(new Color(3, 3, 3),Color.white);
border3 = BorderFactory.createLineBorder(Color.red,1);
titledBorder1 =
new TitledBorder(BorderFactory.createLineBorder(Color.lightGray,1),"Entrada De Dados");
border4 = BorderFactory.createLineBorder(SystemColor.controlHighlight,1);
titledBorder2 = new TitledBorder(border4,"Ferramentas");
border5 = BorderFactory.createLineBorder(Color.white,2);
border6 = BorderFactory.createLineBorder(Color.darkGray,2);
this.getContentPane().setBackground(SystemColor.control);
this.setEnabled(true);
this.setTitle("Números Complexos");
this.getContentPane().setLayout(borderLayout1);
jPanel1.setBackground(Color.lightGray);
jPanel1.setBorder(titledBorder1);
jPanel1.setDebugGraphicsOptions(0);
jPanel1.setLayout(gridLayout1);
jButton1.setText("Coordenadas Cart.");
jButton1.setEnabled(false);
jButton2.setText("Coordernadas Pol.");
jButton2.setEnabled(false);
jButton2.addActionListener(new Complex_jButton2_actionAdapter(this));
jPanel2.setBorder(titledBorder2);
jPanel2.setDebugGraphicsOptions(0);
jPanel2.setLayout(gridLayout2);
jButton3.setToolTipText("Clique Para Inicializar n.o Complexo");
jButton3.setText("Iniciar");
jButton3.addActionListener(new Complex_jButton3_actionAdapter(this));
jButton6.setToolTipText("Clique para limpar os campos");
jButton6.setText("Limpar");
jButton6.addActionListener(new Complex_jButton6_actionAdapter(this));
jTextField1.setBackground(Color.black);
jTextField1.setForeground(Color.white);
jTextField1.setAlignmentX((float) 0.5);
jTextField1.setBorder(border2);
jTextField1.setToolTipText("Tecle ENTER após digitar.");
jTextField1.setCaretColor(Color.white);
jTextField1.setText("");
jTextField1.setHorizontalAlignment(SwingConstants.LEFT);
jTextField1.addActionListener(new Complex_jTextField1_actionAdapter(this));
jTextField2.setBackground(Color.black);
jTextField2.setForeground(Color.white);
jTextField2.setBorder(border2);
jTextField2.setToolTipText("Tecle ENTER para confirmar.");
jTextField2.setCaretColor(Color.white);
jTextField2.setText("");
jTextField2.setHorizontalAlignment(SwingConstants.LEFT);
jTextField2.addActionListener(new Complex_jTextField2_actionAdapter(this));
jLabel1.setBackground(Color.gray);
jLabel1.setAlignmentY((float) 0.5);
jLabel1.setBorder(BorderFactory.createEtchedBorder());
jLabel1.setDoubleBuffered(false);
jLabel1.setToolTipText("");
jLabel1.setDisplayedMnemonic('0');
jLabel1.setText("");
gridLayout2.setRows(8);
jButton4.setText("Novo");
jButton4.setEnabled(false);
jButton4.addActionListener(new Complex_jButton4_actionAdapter(this));
jButton5.setText("Multiplicar");
jButton5.addActionListener(new Complex_jButton5_actionAdapter(this));
jButton7.setText("Dividir");
jButton7.addActionListener(new Complex_jButton7_actionAdapter(this));
jButton9.setText("Somar");
jButton9.addActionListener(new Complex_jButton9_actionAdapter(this));
gridLayout1.setRows(4);
jLabel2.setBorder(BorderFactory.createEtchedBorder());
jLabel2.setVisible(false);
this.getContentPane().add(jPanel1, BorderLayout.CENTER);
jPanel1.add(jTextField1, null);
jPanel1.add(jTextField2, null);
jPanel1.add(jLabel1, null);
jPanel1.add(jLabel2, null);
this.getContentPane().add(jPanel2, BorderLayout.EAST);
jPanel2.add(jButton1, null);
jPanel2.add(jButton2, null);
jPanel2.add(jButton3, null);
jPanel2.add(jButton6, null);
jPanel2.add(jButton4, null);
jPanel2.add(jButton9, null);
jPanel2.add(jButton5, null);
jPanel2.add(jButton7, null);
setSize(420,190);
}
//EVENTOS
void jButton6_actionPerformed(ActionEvent e) {
//apagar todos os valores dos Text Fields
jTextField1.setText("");
jTextField2.setText("");
jLabel1.setText("");
jLabel2.setText("");
jLabel2.setVisible(false);
c1 = new AdvanceMath.Complex(0,0,true);
c2 = new AdvanceMath.Complex(0,0,true);
resultado = new AdvanceMath.Complex(0,0,true);
jLabel1.setText( Double.toString(c1.obterx()) + " j "
+ Double.toString(c1.obtery()) );
if ( jaInit == true ) {
jButton3.setEnabled(true);
} else {
jButton3.setEnabled(false);
}
}
void jTextField1_actionPerformed(ActionEvent e) {
//inicializar coordenada x
String temp = jTextField1.getText();
x1 = Double.parseDouble(temp);
}
void jTextField2_actionPerformed(ActionEvent e) {
//inicializar coordenada y
String temp = jTextField2.getText();
y1 = Double.parseDouble(temp);
}
void jButton3_actionPerformed(ActionEvent e) {
//iniciar n.o complexo c1
c1 = new AdvanceMath.Complex( x1 , y1 , true );
jLabel1.setText( Double.toString(c1.obterx()) + " + j "
+ Double.toString(c1.obtery()) );
jButton3.setEnabled(false);
jButton2.setEnabled(true);
jButton4.setEnabled(true);
jaInit = true;
}
void jButton2_actionPerformed(ActionEvent e) {
//converter para coordenadas polares
c1.Cart2Pol();
jLabel1.setText( Double.toString( c1.obterraio() ) + " ["
+ Double.toString( c1.obterarg() ) +
"]");
jButton2.setEnabled(false);
jButton3.setEnabled(true);
}
void jButton4_actionPerformed(ActionEvent e) {
//
//Instancia classe NewN (diálogo para inserir
//um novo número
//
NewN n = new NewN( this,"Inserir número",true);
n.setSize( 200 , 200 );
n.show();// show() mostra diálogo e permite que
x2 = n.retornaX();//inicializemos x2 e y2
y2 = n.retornaY();
c2 = new AdvanceMath.Complex( x2 , y2 , true );
}
void jButton9_actionPerformed(ActionEvent e) {
//somar dois números
resultado = c1.Somar(c2);
jLabel2.setVisible(true);
jLabel2.setText( Double.toString( resultado.obterx() ) + " + j "
+ Double.toString( resultado.obtery() ) +
"");
}
void jButton5_actionPerformed(ActionEvent e) {
//Multiplica
resultado = c1.Multiplicar(c2);
jLabel2.setVisible(true);
jLabel2.setText( Double.toString( resultado.obterx() ) + " + j "
+ Double.toString( resultado.obtery() ) +
"");
}
void jButton7_actionPerformed(ActionEvent e) {
//Divide
resultado = c1.Dividir(c2);
jLabel2.setVisible(true);
jLabel2.setText( Double.toString( resultado.obterx() ) + " + j "
+ Double.toString( resultado.obtery() ) +
"");
}
}
//CLASSES CRIADAS PELO JBUILDER PARA GERENCIAR EVENTOS
class Complex_jButton6_actionAdapter implements java.awt.event.ActionListener {
Complex adaptee;
Complex_jButton6_actionAdapter(Complex adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.jButton6_actionPerformed(e);
}
}
class Complex_jTextField1_actionAdapter implements java.awt.event.ActionListener {
Complex adaptee;
Complex_jTextField1_actionAdapter(Complex adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.jTextField1_actionPerformed(e);
}
}
class Complex_jTextField2_actionAdapter implements java.awt.event.ActionListener {
Complex adaptee;
Complex_jTextField2_actionAdapter(Complex adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.jTextField2_actionPerformed(e);
}
}
class Complex_jButton3_actionAdapter implements java.awt.event.ActionListener {
Complex adaptee;
Complex_jButton3_actionAdapter(Complex adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.jButton3_actionPerformed(e);
}
}
class Complex_jButton2_actionAdapter implements java.awt.event.ActionListener {
Complex adaptee;
Complex_jButton2_actionAdapter(Complex adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.jButton2_actionPerformed(e);
}
}
class Complex_jButton4_actionAdapter implements java.awt.event.ActionListener {
Complex adaptee;
Complex_jButton4_actionAdapter(Complex adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.jButton4_actionPerformed(e);
}
}
class Complex_jButton9_actionAdapter implements java.awt.event.ActionListener {
Complex adaptee;
Complex_jButton9_actionAdapter(Complex adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.jButton9_actionPerformed(e);
}
}
class Complex_jButton5_actionAdapter implements java.awt.event.ActionListener {
Complex adaptee;
Complex_jButton5_actionAdapter(Complex adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.jButton5_actionPerformed(e);
}
}
class Complex_jButton7_actionAdapter implements java.awt.event.ActionListener {
Complex adaptee;
Complex_jButton7_actionAdapter(Complex adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.jButton7_actionPerformed(e);
}
}
//******************************************************************************
//FIM DO CÓDIGO
//2004/2003 DANIEL V. GOMES
//******************************************************************************
package AdvanceMath;
/**
* <dados>
* <autor>DANIEL VASCONCELOS GOMES</autor>
* <email>dansovg@ig.com.br</email>
* <version>1.2 : 2004_05_28</version>
* </dados>
*
* <description>
* Classe Complex : Implementa métodos para lidar com números complexos
* em Linguagem Java
* </description>
*
* <copyright>
* <nota>Liberado para uso geral. Se possível cite a fonte </nota>
* <autor>Daniel Vasconcelos Gomes. 2003/2004 </autor>
* </copyright>
*
*/
//*****************************************************************************
//NÚMEROS COMPLEXOS EM JAVA
//*****************************************************************************
//*****************************************************************************
//AUTOR : Daniel V. Gomes
//EMAIL: dansovg@ig.com.br
//DATA INICIAL: 11/05/04
//DATA ATUAL: 28/05/04
//*****************************************************************************
//NOTA: Você pode utilizar este código a vontade mas não me responsabilizo por
//erros durante sua execução. Quaisquer dúvidas ou sugestões,
//envie-me por email.
//****************************************************************************
public class Complex {
private double x;
private double y;
private double r;
private double teta;
private double complexn[];
private boolean ePolar;
/**
* Contrutor
* tipo = true -> Cartesiano
* tipo = false -> Polar
*/
public Complex( double a , double b , boolean tipo ) {
if ( tipo == true ) {
this.x = a;
this.y = b;
ePolar = false;
} else if ( tipo == false ) {
this.r = a;
this.teta = b;
ePolar = true;
}
}
/**
* retorna raio de um número complexo
*/
public double Raio(){
if ( ePolar == false ){
return Math.sqrt(Math.pow(this.x,2)+Math.pow(this.y,2));
} else {
return this.r;
}
}
/**
* Converte um número complexo de coordenadas cartesianas
* para coordenadas polares
*/
public void Cart2Pol(){
if ( ePolar == false ) {
this.teta = Math.atan(x/y);
this.r = Math.sqrt(Math.pow(x,2)+Math.pow(y,2));
ePolar = true;
} else {
System.out.println("Erro: Já iniciado em Coordenadas Cartesianas.");
}
}
/**
* Converte um número complexo de coordenadas polares
* para coordenadas cartesianas
*/
public void Pol2Cart(){
if ( ePolar == true ) {
x = r*Math.cos(teta);
y = r*Math.sin(teta);
ePolar = false;
} else {
System.out.println("Erro: Já iniciado em Coordenadas Polares.");
}
}
/**
* Obtém coordenada real
*/
public double obterx(){
if ( ePolar == true ) {
this.Cart2Pol();
}
return this.x;
}
/**
* Obtém coordenada imaginária
*/
public double obtery(){
if ( ePolar == true ) {
this.Cart2Pol();
}
return this.y;
}
/**
* Obtém raio
*/
public double obterraio(){
if ( ePolar == false ) {
this.Pol2Cart();
}
return this.r;
}
/**
* Obtém argumento
*/
public double obterarg(){
if ( ePolar == false ) {
this.Pol2Cart();
}
return this.teta;
}
/**
* Soma dois números complexos em coordenadas cartesianas
*/
public Complex Somar( Complex c1 ) {
if ( this.ePolar == true ){
this.Pol2Cart();
};
if ( c1.ePolar == true ){
c1.Pol2Cart();
};
Complex c2 = new Complex( this.x + c1.x , this.y + c1.y , true );
return c2;
}
/**
* Multiplica um número complexo por uma constante K
*/
public void MultiplicarPorConstante( double k ) {
x = x*k;
y = y*k;
}
/**
* Divide dois números complexos em coordenadas cartesianas
*/
public Complex Dividir( Complex c1 ){
double a , b , c , d ;
if ( this.ePolar == true ){
this.Pol2Cart();
};
if ( c1.ePolar == true ){
c1.Pol2Cart();
};
a = this.x;
b = this.y;
c = c1.x;
d = c1.y;
double f = Math.pow(c,2)+Math.pow(d,2);
double g = a*c+b*d;
double h = a*d-c*b;
Complex c2 = new Complex( g/f , h/f , true );
return c2;
}
/**
* Multiplica dois números complexos em coordenadas cartesianas
*/
public Complex Multiplicar( Complex c1 ){
double a , b , c , d ;
if ( this.ePolar == true ){
this.Pol2Cart();
};
if ( c1.ePolar == true ){
c1.Pol2Cart();
};
a = this.x;
b = this.y;
c = c1.x;
d = c1.y;
double f = a*c - b*d;
double g = a*d - b*c;
Complex c2 = new Complex( f , g , true );
return c2;
}
/**
* Retorna o conjugado de um número complexo
*/
public Complex Conjugado(){
if ( this.ePolar == true ){
this.Pol2Cart();
};
Complex c2 = new Complex( this.x , - this.y , true );
return c2;
}
}
package comp;
import java.awt.*;
import javax.swing.*;
import javax.swing.border.*;
import java.awt.event.*;
public class NewN extends JDialog {
private double x = 0 ;
private double y = 0 ;
JPanel panel1 = new JPanel();
GridLayout gridLayout1 = new GridLayout();
JTextField jTextField1 = new JTextField();
JTextField jTextField2 = new JTextField();
GridLayout gridLayout2 = new GridLayout();
JButton jButton1 = new JButton();
JLabel jLabel1 = new JLabel();
JLabel jLabel2 = new JLabel();
Border border1;
Border border2;
public NewN(Frame frame, String title, boolean modal) {
super(frame, title, modal);
try {
jbInit();
pack();
}
catch(Exception ex) {
ex.printStackTrace();
}
}
public NewN() {
this(null, "", false);
}
private void jbInit() throws Exception {
border1 = BorderFactory.createLineBorder(Color.white,2);
border2 = BorderFactory.createLineBorder(Color.white,2);
panel1.setLayout(gridLayout2);
this.getContentPane().setLayout(gridLayout1);
jButton1.setText("OK");
jButton1.addActionListener(new NewN_jButton1_actionAdapter(this));
gridLayout1.setColumns(2);
gridLayout1.setRows(3);
jTextField1.setBackground(Color.black);
jTextField1.setForeground(Color.white);
jTextField1.setCaretColor(Color.white);
jTextField1.setText("");
jTextField1.addActionListener(new NewN_jTextField1_actionAdapter(this));
jTextField2.setBackground(Color.black);
jTextField2.setForeground(Color.white);
jTextField2.setCaretColor(Color.white);
jTextField2.setText("");
jTextField2.addActionListener(new NewN_jTextField2_actionAdapter(this));
jLabel1.setBorder(border1);
jLabel1.setText("x");
jLabel2.setBorder(border2);
jLabel2.setText("y");
getContentPane().add(panel1, null);
panel1.add(jLabel1, null);
this.getContentPane().add(jTextField1, null);
this.getContentPane().add(jLabel2, null);
this.getContentPane().add(jTextField2, null);
this.getContentPane().add(jButton1, null);
}
void jTextField1_actionPerformed(ActionEvent e) {
String temp = jTextField1.getText();
x = Double.parseDouble(temp);
}
void jTextField2_actionPerformed(ActionEvent e) {
String temp = jTextField2.getText();
y = Double.parseDouble(temp);
}
public double retornaX(){
return x;
}
public double retornaY(){
return y;
}
void jButton1_actionPerformed(ActionEvent e) {
this.setVisible(false);
}
}
class NewN_jTextField1_actionAdapter implements java.awt.event.ActionListener {
NewN adaptee;
NewN_jTextField1_actionAdapter(NewN adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.jTextField1_actionPerformed(e);
}
}
class NewN_jTextField2_actionAdapter implements java.awt.event.ActionListener {
NewN adaptee;
NewN_jTextField2_actionAdapter(NewN adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.jTextField2_actionPerformed(e);
}
}
class NewN_jButton1_actionAdapter implements java.awt.event.ActionListener {
NewN adaptee;
NewN_jButton1_actionAdapter(NewN adaptee) {
this.adaptee = adaptee;
}
public void actionPerformed(ActionEvent e) {
adaptee.jButton1_actionPerformed(e);
}
}
Lendo dados em console e escrevendo dados em arquivos
Essas duas classes estão dentro de um package FileMang. Como você deve perceber, eu ainda acho que essas classes são legais.
Leitura de dados em Console
package FileMang;
import java.io.*;
//---------------------------------------------------------
// Esta classe lê os dados no console
//---------------------------------------------------------
public class LeituraDeDados {
BufferedReader buffr;
String fileName;
int meuinteiro = 0;
int meudouble = 0;
String entrada;
//Construtor
public LeituraDeDados() {
buffr = new BufferedReader(new InputStreamReader(System.in));
}
public String BufferDadosString() {
try {
entrada = buffr.readLine();
} catch (Exception e) {
System.out.println("Erro" + e);
}
return(entrada);
}
public int BufferDadosInteger() {
try {
entrada = buffr.readLine();
meuinteiro = Integer.parseInt(entrada);
} catch (Exception e) {
System.out.println("Erro" + e);
}
return(meuinteiro);
}
public double BufferDadosDouble() {
try {
entrada = buffr.readLine();
meudouble = Integer.parseInt(entrada);
} catch (Exception e) {
System.out.println("Erro" + e);
}
return(meudouble);
}
public void Mensagens(String mensagem) {
System.out.println("*******************************************");
System.out.println(mensagem);
System.out.println("*******************************************");
}
public void MensagemLeitura(String mensagem) {
System.out.println(mensagem+">");
}
}//Fim
Escrevendo dados em arquivos
package FileMang;
import java.io.*;
import java.io.File;
//---------------------------------------------------------
// Esta classe recebe os dados e os escreve em um arquivo
// o nome deste arquivo é passado como referência ao Construtor
// FluxoDeDados:
// dados é um array
// N é a dimensão
// Arq é o nome do arquivo
public class ApresentarDados {
double meusdados[];
double xx[];
String myFil;
//construtor
public ApresentarDados (double dados[],int N, String Arq) {
meusdados = new double[N];
myFil = Arq;
for(int i = 0; i < N ; i++) {
meusdados[i] = i;
};
System.arraycopy(dados,0,meusdados,0,meusdados.length);
}
public ApresentarDados (double dados[], double x[],int N, String Arq) {
meusdados = new double[N];
xx = new double[N];
myFil = Arq;
for(int i = 0; i < N ; i++) {
meusdados[i] = i;
xx[i]=i;
};
System.arraycopy(dados,0,meusdados,0,meusdados.length);
System.arraycopy(x,0,xx,0,x.length);
}
//Métodos
public void EscreveEmArquivo() {
try {
FileWriter fw = new FileWriter(myFil);
PrintWriter pw = new PrintWriter(fw);
for(int i=0; i < meusdados.length; i++) {
pw.println(" " + xx[i] + "%" + meusdados[i]);
};
pw.close();
}
catch (IOException e)
{
System.out.println("IOError" + e);
}
}
public void EscreverNaTela () {
for(int i = 0; i < meusdados.length;i++) {
System.out.println(meusdados[i]);
}
}
}//Fim
Um pouco de swing para relaxar
Eu estava indo pra casa almoçar, quando veio uma idéia! Se eu quiser uma área para imprimir um gráfico eu só preciso de um JPanel, ou melhor de um JPanel extendido!
Claro, ainda é rústico, mas não vai mudar muito não!
Antes uma animação maluca
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class JavaGrafi1 extends JFrame{
Dimension d;
public JavaGrafi1(){
super("Gráficos em Java!");
setSize( 500 , 500 );
setVisible( true );
}
public void paint(Graphics g){
super.paint(g);
d = getSize();
int xo=0;
int yo=0;
int x=0;
int y=0;
int r = 0;
int g_ = 0;
int b = 0;
for( int i = 0 ; i < 4000; i ++ ){
r = 10*(int)Math.random();
g_ = 5*(int)Math.random();
b = 6*(int)Math.random();
if ( r > 255) r = 100;
if ( g_ > 255) r = 10;
if ( b > 255 ) b = 190;
Color c1 = new Color( r , g_ , b );
g.setColor(c1);
if (x > 500) x = 200;
if (y > 500) y = 200;
g.drawOval(x,y,1+i,1+i);
//g.drawRect(x,y,i,i+3);
}
try {
Thread.sleep(1000*(int)Math.random());
} catch (Exception e) {
}
repaint();
}
public static void main ( String args[] ){
JavaGrafi1 application = new JavaGrafi1 ();
application.addWindowListener(
new WindowAdapter(){
public void windowClosing (WindowEvent event)
{
System.exit( 0 );
}
}
);
}
}
Agora, o que interessa:
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
class myJPanel extends JPanel {
private BorderLayout borderLayout1 = new BorderLayout();
private int [] XData;
private int [] YData;
private Dimension d;
public myJPanel() {
try {
jbInit();
setVisible(true);
}
catch(Exception ex) {
ex.printStackTrace();
}
}
void jbInit() throws Exception {
this.setLayout(borderLayout1);
}
//dados
public void obterDados( int[] x , int[] y ){
XData = new int[x.length];
YData = new int[y.length];
System.arraycopy(x,0,XData,0,x.length);
System.arraycopy(y,0,YData,0,y.length);
}
//desenhar gráfico
public void paint(Graphics g){
d = getSize();
super.paint(g);
for ( int i = 0 ; i < XData.length ; i++ ) {
if (XData[i]>d.width) XData[i]= 0;
if (YData[i]>d.height) YData[i]= 0;
g.drawLine(XData[i],YData[i],XData[i],YData[i]);
};
}
}
public class JavaGrafi2 extends JFrame{
Dimension d;
protected myJPanel myJ;
int[] x ;
int[] y ;
public JavaGrafi2(){
super("Gráficos em Java!");
Container container = getContentPane();
myJ = new myJPanel();
initFnc();
myJ.obterDados( x , y );
container.add(myJ);
setSize( 500 , 500 );
setVisible( true );
}
private void initFnc(){
x = new int[1000];
y = new int[1000];
for( int i = 0 ; i < 1000 ; i++ ){
x[i] = i;
y[i] = i;
}
}
public static void main ( String args[] ){
JavaGrafi2 application = new JavaGrafi2 ();
application.addWindowListener(
new WindowAdapter(){
public void windowClosing (WindowEvent event)
{
System.exit( 0 );
}
}
);
}
}
Enviando um email em Java
É bem simples, mas antes você deve fazer o download da API JavaMail
//*****************************************************************************
//Classe para enviar emails utilizando a API JavaMail
//*****************************************************************************
//AUTOR : Daniel V. Gomes
//EMAIL: dansovg@ig.com.br
//DATA INICIAL: 05/05/04
//*****************************************************************************
//NOTA: Você pode utilizar este código a vontade mas não me responsabilizo por
//erros durante sua execução. Quaisquer dúvidas ou sugestões,
//envie-me por email.
//*****************************************************************************
import javax.mail.*;
import javax.mail.internet.*;
import java.util.*;
public class EnviarEmail {
private Properties prop;
private Session conexaoEmail;
private Address endEnvia; //email do remetente
private Address endRecebe;//email do destinatário
private Message msg;//Corpo da mensagem
//funções de status
private boolean ErroDuranteInicialização;
private boolean ErroDuranteEnvio;
//construtor
public EnviarEmail( String mesg ,//string com a mensagem
String serverenvio ,
String paraquem ,
String dequem ,
String assunto ){
try {
//Configuração do servidor de envio
prop = new Properties();
prop.put("mail.host",serverenvio);
//Estabelece a sessão de comunicação
conexaoEmail = Session.getInstance(prop,null);
//Instancia a o tipo de mensagem
msg = new MimeMessage(conexaoEmail);
//Instancia remetenente e destinatário
endEnvia = new InternetAddress(dequem);
endRecebe = new InternetAddress(paraquem);
//estabelece conteúdo do email
msg.setContent(mesg,"text/plain");
msg.setFrom(endEnvia);
msg.setRecipient(Message.RecipientType.TO,endRecebe);
msg.setSubject(mesg);
ErroDuranteInicialização = false;
} catch (Exception e) {
ErroDuranteInicialização = true;
}
} //fim do construtor
//main para debug
//apague para criar uma classe
public static void main(String[] args){
EnviarEmail e = new EnviarEmail("Oi",
"smtp.papainoel.com",
"coelhodapascoa@ovo.de.chocolate",
"saciperere@sitio.do.picapau.amarelo",
"teste");
System.out.println(e.obterIniStatus());
e.EnviaMensagem();
System.out.println(e.obterEnvStatus());
}
//***********************
//retorna status da inicialização
public boolean obterIniStatus(){
return ErroDuranteInicialização;
}
public void EnviaMensagem(){
try {
Transport.send(msg);
ErroDuranteEnvio = false;
} catch (Exception e) {
ErroDuranteEnvio = true;
}
}
//retorna status de envio do email
public boolean obterEnvStatus(){
return ErroDuranteEnvio;
}
}
Comunicação Serial: Parte 2
Como já disse no meu Z-LoG, já havia programado comunicação serial em Assembly. O microprocessador era bastante rústico e não possuía UART/USART. Era bem complicado. Imagine que a entrada seja um trem de pulsos, seu código deverá reconhecer stop bits, os dados e ainda deve estar sincronizado. Com o padrão atual de microprocessadores, não é preciso esse trabalho, basta usar os recursos de alto nível. Para WIN32 temos as opções selvagens das APIs e Visual Basic. E a melhor delas todas, por ser um meio termo, é a API Java Communications da Sun. Basta que você defina os parâmetros e faça o reconhecimento da porta, e a prepare para enviar ou receber os dados. A máquina virtual Java faz o trabalho sujo para você. Para testar, espete um multímetro na saída TX da sua porta COM2 colocando o polo + na saída TX e o negativo no pino GND.
Olhe abaixo, a pinagem do conector da porta serial do seu PC (chamada de conector serial DB9). Se você quiser monitorar os dados de saída espete o multímetro entre os terminais 3 (TX- Transmitted data) e 5 (terra). Se você ler dados, espete o seu gerador de bits entre os pinos 2 (RX- Received Data) e 5 (terra).
Pinagem do conector DB9
Ligação de hardware externos
É claro, há mais detalhes envolvidos, mas é essencialmente isso. Um detalhe importante, os bits devem ser serializados na entrada e deve atender o nível de tensão do padrão EIA-232, 12 Volts. O clock dos pulsos deve ser igual a 1/9600 ou a 1/baudrate escolhido. Normalmente, chamamos de drivers, os circuitos que fazem essa conversão. Dispositivos seriais, usam drivers 232 prontos. Mas, para efeito de testes basta um trem de pulsos.
A UART converte os dados seriais para dados paralelos, e esses dados são lidos pela CPU do PC. Não há muito com que se preocupar. Agradeça ao encapsulamento.
Chamados de DTE o dispositivo serial que envia os dados e de DCE dispositivo que os recebe. Suponha que queremos disparar um tiristor que aciona um motor. Enviamos um trem de pulsos digitais para saída e este sinal é ligado a base do tiristor que é disparado. Da mesma forma, podemos gerar um PWM para acionar um motor. Será preciso apenas um driver de potência que aumenta a tensão para os valores necessários para acionar o motor.
De modo semelhante, podemos medir uma temperatura utilizando um resistor que varia com a temperatura. A tensão no resistor é convertida para valores digitais, por um conversor A/D e em seguida este valor é serializado em um trem de pulsos e lido na porta serial.
O Package SrCom possui, por enquanto duas classes: SerialComm e SComm. SerialComm reconhece as portas disponíveis e SComm, envia um mensagem para a porta especificada. Também pode ler uma mensagem. Para isso a classe SComm implementa as interfaces Runnable e o listener de eventos da porta serial.
Detalhes sobre comunicação serial EIA-232 e Instalação da API de Comumicações seriais: Informações
Os códigos são bem extensos, para visulizá-los, veja abaixo:
Programa principal |
Stest2.java | Veja o código |
Classe SComm.java |
SComm.java | Veja o código |
Classe SerialCom |
SerialCom.java | Veja o código |
Comunicação Serial: Parte 1
A Sun fornece para download a API de Comunicação Serial e Paralela em Java. É bem mais simples do que o equivalente em WIN32 e é orientado à objeto.
Essa API não vem incluída no pacote J2SE, você precisará baixá-la no link. Você também poderá baixar a especificação da API do site.
No exemplo abaixo, eu tomei um exemplo do livro Java CookBook sobre o assunto, que trata de reconhecer as portas seriais e paralelas do micro. Eu eliminei a interface gráfica e simplifiquei a classe para que ela pudesse retornar Strings.
import javax.comm.*;
import java.io.*;
import java.util.*;
public class SerialCom {
//variáveis para identificar portas
protected HashMap hm = new HashMap();
protected Enumeration listaDePortas;
protected String[] portas;
//construtor
SerialCom(){
VerificarPortas();
ImprimePortas();
}
//programa principal
public static void main (String[] args){
//
SerialCom s = new SerialCom();
}
//verifica portas e imprime dados
protected void VerificarPortas(){
Enumeration listaDePortas = CommPortIdentifier.getPortIdentifiers();
portas = new String[10];
int i = 0;
while (listaDePortas.hasMoreElements()) {
CommPortIdentifier ips =
(CommPortIdentifier)listaDePortas.nextElement();
portas[i] = ips.getName();
/*
Retire os comentários para obter informações
sobre as portas
System.out.println( "PORTA: " + ips.getName() + " "
+ "TIPO: " + ips.getPortType() + " "
+ "UTILIZADA?: " + ips.isCurrentlyOwned()
); */
i++;
}
}
//imprime as portas disponíveis
protected void ImprimePortas(){
for (int i = 0 ; i < portas.length ; i ++ ) {
if (portas[i] != null ) {
System.out.println(portas[i]);
}
}
}
}
Interfaces para resolver sistemas lineares
Estava tentando criar uma interface gráfica em Swing para o código que elaborei para resolver sistemas lineares. Penei um pouco e encontrei duas soluções. A 1.a insere uma JTable após o usuário clicar no botão. Inicialmente, achei que não funcionava, mas só faltou um método pack(), que redimensiona a JFrame. A segunda, insere dinamicamente a tabela. O problema é que, embora o código funcione em Pascal e C++, parece haver problemas com a dimensão das matrizes. Como sempre dizem, C++ e Java são parecidos mas não são iguais.
Interface 1
Interface 2
Mais outra interface para as classes do calculador
Ainda não instanciei as classes que calculam os valores, mas a interface está pronta. No laço switch vou inserir a instância das classes para calcular os valores conforme a escolha do usuário.
Abaixo mostro a captura da tela:
O código está bastante comentado. Assim que estiver finalizado, incluirei aqui os códigos finais. A 1.a versão estava muito ruim e cheia de bugs, que eu consegui corrigir. Agora os dados estão sendo passados das tabelas para os Arrays. Falta validar a entrada de dados.
//******************************************************************
//Interface para classes de análise de funções
//******************************************************************
//Autor: Daniel Vasconcelos Gomes
// Inicio[12/04/2004]
// Revisão Atual[14/04/2004]
//******************************************************************
//Utiliza as classes do pacote AdvanceMath para
//calcular e analisar funcoes discretas
//******************************************************************
//
//************************Métodos***********************************
//
// public MathF3 () -> Construtor
// public static void main ( String args[] ) -> Programa Principal
// private double CalculaSaida( int indic, JTable X, JTable Y )
// -> Calcula saída
// private boolean EstaVazia(String s) -> Verifica se célula da tabela
// está vazia
//
//********************Gerenciadores de Eventos**********************
//
// private class myHandler implements ActionListener -> inner class
// private class myHandler2 implements ItemListener -> inner class
//******************************************************************
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import AdvanceMath.*;
public class MathF3 extends JFrame {
//*************************************
//*************************************
//Declaraçao dos componentes Swing
//*************************************
private JLabel XAxis;
private JLabel YAxis;
private JComboBox Options;
private JPanel myPanel;
private JButton Calcular;
private JTable DataTableX;
private JTable DataTableY;
//*************************************
//*************************************
// Strings de opçoes para o Combo Box
//*************************************
private String[] OptionTypes = {
"Escolha a Função",
"Máximo da Função",
"Mínimo da Função",
"Derivada da Função",
"Derivada da Função (ordem 2)"};
//*************************************
//Opção escolhida
//*************************************
private int indice;
public MathF3 (){
//*************************************
super("Math Calcs");
//instancia o container
Container container = getContentPane();
container.setLayout( new FlowLayout(FlowLayout.CENTER) );
//instancia o Panel
myPanel = new JPanel();
myPanel.setLayout(new GridLayout(1,2));
//instancia o combo box
Options = new JComboBox(OptionTypes);
//instancia botão de ação
Calcular = new JButton("Calcular");
Calcular.setEnabled(false);
//labels para os valores de X e Y
XAxis = new JLabel("Valores de X:");
YAxis = new JLabel("Valores de Y:");
//tabela que receberá os valores de X
/*final JTable*/ DataTableX = new JTable(20,1);
DataTableX.setRowHeight(20);
//tabela que receberá os valores de Y
/*final JTable*/ DataTableY = new JTable(20,1);
DataTableY.setRowHeight(20);
//adiciona combo box ao Frame
container.add(Options);
//adiciona o botão de ação ao Frame
container.add(Calcular);
//adiciona as tabelas com seus labels ao Panel
myPanel.add(XAxis);
myPanel.add(DataTableX);
myPanel.add(YAxis);
myPanel.add(DataTableY);
//adiciona o Panel ao JFrame
container.add(myPanel);
//instancia do gerenciador de eventos p/botões
myHandler handler = new myHandler();
//instancia do gerenciador de eventos do combo box
myHandler2 handler2 = new myHandler2();
//adiciona o listener ao combox box
Options.addItemListener(handler2);
Calcular.addActionListener(handler);
setSize( 500 , 500 );
setVisible( true );
//*************************************
}
//*************************************
public static void main ( String args[] ){
MathF3 application = new MathF3();
application.addWindowListener(
new WindowAdapter(){
public void windowClosing (WindowEvent event)
{
System.exit( 0 );
}
}
);
}
//*************************************
//*************************************
//Eventos de botão
//*************************************
private class myHandler implements ActionListener {
private String value;
public void actionPerformed ( ActionEvent event ){
if (event.getSource() == Calcular){
//
int a = Options.getSelectedIndex();
double v = CalculaSaida( a , DataTableX , DataTableY );
System.out.println(v);
}
}
}
//*************************************
//*************************************
//Eventos do Combo Box
//*************************************
private class myHandler2 implements ItemListener {
public void itemStateChanged( ItemEvent event ){
if (event.getSource() == Options) {
//
if (event.getStateChange()== ItemEvent.SELECTED){
//
indice = Options.getSelectedIndex();
if (indice == 0) {
if (Calcular.isEnabled()==true){
Calcular.setEnabled(false);
} else {
Calcular.setEnabled(true);
}
}else {
Calcular.setEnabled(true);
}
}
}
}
}
//*************************************
//Parâmetros: Tabelas X e Y representam
//os valores discretos das funções
//indic é o valor escolhido da função
//*************************************
private double CalculaSaida( int indic, JTable X , JTable Y ){
double valuetoReturn = 0;
int n = X.getRowCount();
int m = Y.getRowCount();
//debug
System.out.println("Dimensao de JTableX: " + n);
System.out.println("Dimensao de JTableY: " + m);
//apagar
double[] Xvalues = new double[X.getRowCount()];
double[] Yvalues = new double[Y.getRowCount()];
//debug
System.out.println("Dimensao de X: " + Xvalues.length);
System.out.println("Dimensao de Y: " + Yvalues.length);
//apagar
javax.swing.table.TableModel model1 = X.getModel();
javax.swing.table.TableModel model2 = Y.getModel();
//obter os valores de X das tabela
try {
for ( int i = 0 ; i < n ; i++ ){
Object temp1 = model1.getValueAt(i,0);
//adicionar diálogo q valida dados da
//célula
String temp2 = String.valueOf(temp1);
if (EstaVazia(temp2)== true) {
Xvalues[i] = 0;
} else {
Xvalues[i] = Double.parseDouble(temp2);
}
};
} catch (Exception e ) {
System.out.println("Erro1 [Valor de X]: " + e );
}
//obter os valores de Y da tabela
try {
for ( int i = 0 ; i < n ; i++ ){
Object temp1 = model2.getValueAt(i,0);
//adicionar diálogo q valida dados da
//célula
String temp2 = String.valueOf(temp1);
if (EstaVazia(temp2)== true) {
Yvalues[i] = 0;
} else {
Yvalues[i] = Double.parseDouble(temp2);
};
}
} catch (Exception e ) {
System.out.println("Erro2 [Valores de Y]: " + e );
}
//*************************************
//op 2 = "Máximo da Função"
//op 3 = "Mínimo da Função"
//op 4 = "Derivada da Função"
//op 5 = "Derivada da Função (ordem 2)
//*************************************
switch (indic) {
case 1:
//calcular op 2
//
valuetoReturn = Yvalues[10];
break;
case 2:
//calcular op 3
//
break;
case 3:
//calcular op 4
//
break;
case 4:
//calcular op5
//c);
break;
default:
//default
//
};
return valuetoReturn;
}//*************************************
//*************************************
// Verifica se A célula da tabela está
// vazia
//*************************************
private boolean EstaVazia(String s) {
boolean b = false;
if ( s=="") {
b = true;
}else if( s!="") {
b = false;
};
return b;
}//*************************************
} //fim da classe
Um esqueleto de Interface gráfica
O código abaixo cria um frame interno. Trata-se de um esqueleto para um programa maior.
//********************************************************************
//Interface Gráfica Java utilizando SWING
//1.a versão : 04-03-12
// Daniel Vasconcelos Gomes
//********************************************************************
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class MyGui_05 extends JFrame {
//*************************************
//declarar aqui os componentes swing
private JDesktopPane theDeskTop;
private JMenuItem new_ ;
private JMenuItem save_ ;
private JMenuItem exit_ ;
private MyJPanel panel ;
//***********************************
public MyGui_05 (){
//*************************************
super("Menu com frame interno");
try {
UIManager.setLookAndFeel("Metal");
SwingUtilities.updateComponentTreeUI(this);
} catch (Exception el){
};
//Instanciar componentes
JMenu fileMenu = new JMenu("File");
fileMenu.setMnemonic('F');
new_ = new JMenuItem("New");
new_.setMnemonic('N');
save_ = new JMenuItem("Save");
save_.setMnemonic('S');
exit_ = new JMenuItem("Exit");
exit_.setMnemonic('E');
//***********************************
//adicionar ao fileMenu
fileMenu.add( new_ );
fileMenu.add( save_ );
fileMenu.add( exit_ );
//adicionar file menu a uma barra de menu
JMenuBar bar = new JMenuBar();
setJMenuBar( bar );
bar.add(fileMenu);
//adicionar ao container
// Não é necessário para menus
//***********************************
theDeskTop = new JDesktopPane();
theDeskTop.setBackground( Color.white );
getContentPane().add( theDeskTop );
//criar os gerenciadores de evento
myHandler handler1 = new myHandler();
new_.addActionListener( handler1 );
save_.addActionListener( handler1 );
exit_.addActionListener( handler1 );
//***********************************
setSize( 600 , 400 );
setVisible( true );
//*************************************
}
//*************************************
public static void main ( String args[] ){
MyGui_05 application = new MyGui_05();
application.addWindowListener(
new WindowAdapter(){
public void windowClosing (WindowEvent event)
{
System.exit( 0 );
}
}
);
}
//*************************************
//*************************************************
//Classe interna para gerenciar eventos de ação
//*************************************************
private class myHandler implements ActionListener {
private String value;
public void actionPerformed ( ActionEvent event ){
//Eventos para os itens do Menu File
if (event.getSource()== new_){
JOptionPane.showMessageDialog(MyGui_05.this,
"E ai 0, não tô sabendo HORRORES?");
JInternalFrame frame = new JInternalFrame(
"Frame Interno", true, true, true, true );
Container container = frame.getContentPane();
MyJPanel panel = new MyJPanel();
container.add( panel, BorderLayout.CENTER );
frame.pack();
theDeskTop.add ( frame );
frame.setVisible( true );
};
if (event.getSource()== save_){
JOptionPane.showMessageDialog(MyGui_05.this,
"Este salvaria um novo arquivo!");
};
if (event.getSource()== exit_){
JOptionPane.showMessageDialog(MyGui_05.this,
"Até mais!");
System.exit(0);
};
//
}
}
//*************************************
//*************************************************
//Classe interna para gerenciar eventos de itens
//*************************************************
private class myHandler2 implements ItemListener {
public void itemStateChanged( ItemEvent event ){
//
}
}
//*************************************
//*************************************
}
class MyJPanel extends JPanel {
//aqui incluir componentes da Janela filha
public MyJPanel(){
//
}
}
JDBC Microsoft Access
O JDBC faz uma ponte entre o driver ODBC do sistema operacional e o banco
de dados MS Access. O driver JDBC/ODBC para se conectar ao banco Access já vem
incluído na distribuição do JSDK. Portanto siga os passos abaixo:
1.o: Faço o registro do seu banco de dados no Windows. Veja este
link
.
2.o: Veja o código abaixo.
O código, não orientado à objeto, está abaixo comentado.
import java.sql.*;
import java.io.*;
//Bando db
//tabela people
//campos name e address
public class dbaccess {
public static void main (String args[]) {
//********************************************
try {
//driver ODBC
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
//conecta-se ao banco
Connection con = DriverManager.getConnection("jdbc:odbc:db","","");
//cria uma variável statment para receber a STRING de query SQL
Statement stm = con.createStatement();
//STRING SQL para query dentro do banco
String query = "SELECT name, address FROM people";
//executa a query
ResultSet results = stm.executeQuery(query);
//itera sobre os resultados
//results.getString() retorna o valor de cada coluna da tabela
while (results.next()) {
System.out.print(results.getString(1) + " ");
System.out.println(results.getString(2));
}
con.close();//fecha conexão
//essas duas exceções DEVEM ser capturadas
} catch (ClassNotFoundException e1){
System.out.println("ERRO1!");
//
} catch (SQLException e2){
//
System.out.println("ERRO2!");
}
//********************************************
}
}
Em seguida, comecei a orientar à objeto. Para isso criei um package para conter as classes.
Abaixo, o código exemplo acima, utilizando a interface gráfica SWING.
package DBFerramentas;
import java.sql.*;
import java.io.*;
import javax.swing.JOptionPane;
import javax.swing.JTextArea;
public class IniBanco {
//***************************************************
//Inicio da Declaração da Classe
//***************************************************
//************************************
//Conectar ao banco Access com alias malias
//nota: você dever ter previamente configurado
//o driver ODBC do Windows
//************************************
protected boolean Sucesso;
protected Connection con;
protected Statement stm;
protected ResultSet results;
//construtor
public IniBanco(String malias){
try {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection con =
DriverManager.getConnection("jdbc:odbc:"+malias,"","");
Sucesso = true;
} catch (ClassNotFoundException e1){
System.out.println("ERRO1!");
Sucesso = false;
}
catch (SQLException e2){
System.out.println("ERRO2!");
Sucesso = false;
}
}
//************************************
//retorna true se o banco foi criado com sucesso
public boolean IniBancoOK(){
return Sucesso;
}
//************************************
//realiza consulta ao banco
public void QueryBanco(String query){
if (IniBancoOK()==true) {
try {
Statement stm = con.createStatement();
ResultSet results = stm.executeQuery(query);
} catch (SQLException e2){
//
System.out.println("ERRO2!");
}
}
}
//************************************
public void MostrarBanco(){
JTextArea outText_ = new JTextArea();
outText_.setText("Nome\tAddress\n");
if (IniBancoOK()==true) {
try {
while (results.next()) {
outText_.append(results.getString(1)+"\t"+results.getString(2)+
"\n");
}
JOptionPane.showMessageDialog( null, outText_,"DataBase",
JOptionPane.INFORMATION_MESSAGE);
System.exit(0);
} catch (SQLException e2){
//
System.out.println("ERRO2!");
}
}
}
//Atualiza banco de dados
public void InsereRegBanco( String s1, String s2){
if (IniBancoOK()==true) {
try {
Statement stm = con.createStatement();
stm.executeUpdate(
"INSERT INTO people " +
"VALUES (s1,s2)");
} catch (SQLException e2){
//
System.out.println("ERRO2!");
}
}
}
//************************************
public void AtualizaBanco( String s1, String s2){
if (IniBancoOK()==true) {
try {
Statement stm = con.createStatement();
stm.executeUpdate("UPDATE people " +
"SET address= " + s1 +
"WHERE name LIKE " + s2);
} catch (SQLException e2){
//
System.out.println("ERRO2!");
}
}
}
//************************************
//fecha a conexao com o banco
public void closeBanco(){
try {
con.close();
} catch (SQLException e2){
//
System.out.println("ERRO2!");
}
}
//************************************
//*****************************************************
//Fim da Declaração da Classe
//***************************************************
}