Interface gráfica “Swing” , cálculo I.M.C

Olá  😀

Neste exemplo mostramos o uso de alguns itens do pacote Swing “javax.swing.*”,
este aplicativo tem a finalidade de calcular o Índice de Massa Corporal-IMC,
criamos 3 classe em um único arquivo “.java”, sendo:
1)GuiPrincipal = interface com usuário;
2)EventoCalculaIMC = evento para o botão calcular;
3)AplCalculaIMC = classe “Main” onde executa o aplicativo;

A seguir o código completo:

import java.awt.Color;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.DecimalFormat;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JTextField;

/**
 * classe é um Jframe interface com usuário
 * @author Roberto Silva
 */
class GuiPrincipal extends JFrame{
	//variaveis dos componentes
	private JTextField edtPeso;
	private JTextField edtAltura;
	private JButton btnCalcula;
	private JLabel lblPeso;
	private JLabel lblAltura;
	private JLabel lblResultado;

	/**
	 * construtor
	 */
	public GuiPrincipal(){
		//chamando metodo de configuração
		setConfig();
	}

	/**
	 * seto todas configurações do formulario
	 */
	private void setConfig() {
		//configuração do JFrame
		this.setTitle("Calcula IMC");//titulo
		this.setSize(600, 150);//tamanho do Jframe
		this.setLayout(new GridLayout(0, 2));//layout se comporta como uma tabela, mais detalhes: http://docs.oracle.com/javase/tutorial/uiswing/layout/grid.html
		this.setDefaultCloseOperation(EXIT_ON_CLOSE);//fecha aplicação como padrão
		this.setLocationRelativeTo(null);//centraliza o JFrame
		this.getContentPane().setBackground(Color.YELLOW);//cor de fundo é amarelo
		
		//instanciando componentes
		edtPeso=new JTextField();
		edtAltura=new JTextField();
		btnCalcula=new JButton("Calcular");
		lblPeso=new JLabel("Peso:");
		lblAltura=new JLabel("Altura:");
		lblResultado=new JLabel("Resultado: ");
		
		//add evento ao botão de calculo
		btnCalcula.addActionListener(new EventoCalculaIMC());
		
		//add componentes ao Jframe
		this.add(lblPeso);
		this.add(lblAltura);
		this.add(edtPeso);
		this.add(edtAltura);
		this.add(lblResultado);
		this.add(btnCalcula);
	}

	/**
	 * classe interna é um evento para o botão de calculo
	 * @author Roberto Silva
	 */
	class EventoCalculaIMC implements ActionListener{
		@Override
		public void actionPerformed(ActionEvent e) {
			try {

				//converte string em double
				double peso=Double.parseDouble(edtPeso.getText());
				double altura=Double.parseDouble(edtAltura.getText());
				//calcula imc
				double imc=peso/Math.pow(altura,2);

				//objeto para formatar saida, com uma decimal
				DecimalFormat df=new DecimalFormat("#0.0");

				String resultado="Resultado: "+df.format(imc);
				
				//abaixo comparo valor do imc e concatena a string resultado
				if(imc < 18.5){
					resultado+=" Abaixo do peso";
				}
				else if(imc < 24.9){
					resultado+=" Peso ideal";
				}
				else if(imc < 29.9){
					resultado+=" Levemente acima do peso";
				}
				else if(imc < 34.9){
					resultado+=" Primeiro grau de obesidade";
				}
				else if(imc < 39.9){
					resultado+=" Segundo grau de obesidade";
				}
				else
					resultado+=" Obesidade mórbida";

				//seta texto em label
				lblResultado.setText(resultado);

			}catch (ArithmeticException ar) {
				JOptionPane.showMessageDialog(null, "Erro aritmético, causa: "+ar.getMessage());
			} catch (Exception ex) {
				JOptionPane.showMessageDialog(null, "Erro desconhecido, causa: "+ex.getMessage());
			}
		}
	}

}

/**
 * classe principal onde é executado o sistema
 * @author Roberto Silva
 */
public class AplCalculaIMC {
	public static void main(String[] args) {
		//instanciando e exibindo
		new GuiPrincipal().setVisible(true);
	}
}

Ao executar…
GUI_IMC

Espero que tenha gostado, até o próximo post 😉

Criando classe de conexão Java – Parte 2 [MVC+JDBC+CRUD]

Olá 😀

Este post é uma continuação do post anterior, nele irei exemplificar uma arquitetura MVC com C.R.U.D – [CREATE,READ,UPDATE,DELETE].
Cada classe será responsável unicamente por sua tarefa, seguindo o padrão singleton.

Teremos a seguinte estrutura:
ScreenHunter_03 Jul. 05 20.51

Esta é a tabela que precisamos criar no banco de dados:

--execute este DDL, antes de executar o programa
CREATE TABLE EMPREGADO(
	ID   	 NUMBER(8),
	CONSTRAINT ID_PK PRIMARY KEY(ID),
	NOME 	 VARCHAR(30),
	DAT_NASC DATE,
	SALARIO  NUMBER(15,2)
);

COMMIT WORK;

Vamos criar os pacotes, aperte a combinação [CTRL+N] digite package ou vá na aba Java > package, crie os pacotes:
br.modelo
br.visual

No pacote br.modelo aperte a combinação [CTRL+N], digite class ou vá na aba Java > class, coloque o nome de Empregado, esta classe é do tipo padrão chamado JavaBeans
Primeiro escreva a classe e seus atributos:

package br.modelo;

import java.sql.Date;

/**
 * classe Bean tem os campos da entidade EMPREGADO
 * @author Roberto Silva
 *
 */
public class Empregado {
	private int id;
	private String nome;
	private Date dat_nasc;
	private double salario;
}

Agora vamos gerar os métodos, clique com botão direito do mouse sobre a classe, siga para Source > Generate Getters and Setters, selecione todos atributos [OK].

Após isto iremos criar o método toString(), ele irá exibir o nosso Empregado de forma legível, siga para Source > Generate toString() [OK].

Após estes processos teremos os seguinte resultado:

package br.modelo;

import java.sql.Date;

/**
 * classe Bean tem os campos da entidade EMPREGADO
 * @author Roberto Silva
 *
 */
public class Empregado {
	private int id;
	private String nome;
	private Date dat_nasc;
	private double salario;
	/**
	 * @return the id
	 */
	public int getId() {
		return id;
	}
	/**
	 * @param id the id to set
	 */
	public void setId(int id) {
		this.id = id;
	}
	/**
	 * @return the nome
	 */
	public String getNome() {
		return nome;
	}
	/**
	 * @param nome the nome to set
	 */
	public void setNome(String nome) {
		this.nome = nome;
	}
	/**
	 * @return the date
	 */
	public Date getDat_nasc() {
		return dat_nasc;
	}
	/**
	 * @param date the date to set
	 */
	public void setDat_nasc(Date dat_nasc) {
		this.dat_nasc = dat_nasc;
	}
	/**
	 * @return the salario
	 */
	public double getSalario() {
		return salario;
	}
	/**
	 * @param salario the salario to set
	 */
	public void setSalario(double salario) {
		this.salario = salario;
	}

	/* (non-Javadoc) - exibe os atributos de Empregado
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		return " id=" + id + ", nome=" + nome + ", dat_nasc="
				+ dat_nasc + ", salario=" + salario + " \n ";
	}
}

Agora vamos criar a classe responsável pela persistência dos dados em Empregado,
ficará no pacote br.modelo e chama-se EmpregadoDAO.Esta classe é do tipo DAO-Data Acess Object.

package br.modelo;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import br.controle.AcessoBD;

/**
 * classe faz a persistencia com a entidade EMPREGADOS do ORACLE
 * @author Roberto Silva
 * criado em: 04/07/2013
 */
public class EmpregadoDAO {

	private Connection conn;
	private PreparedStatement pstm;
	private ResultSet rs;

	private final String SELECT=" SELECT * FROM EMPREGADO ";
	private final String INSERT=" INSERT INTO EMPREGADO(ID,NOME,DAT_NASC,SALARIO)VALUES(?,?,?,?) ";
	private final String UPDATE=" UPDATE EMPREGADO SET NOME=?,DAT_NASC=?,SALARIO=? WHERE ID=? ";
	private final String DELETE=" DELETE FROM EMPREGADO WHERE ID=? ";

	/**
	 * metodo seleciona registros de EMPREGADO
	 * @param nome
	 * @return
	 * @throws Exception
	 */
	public List selecionar(){
		List empregados=new ArrayList();
		Empregado emp=null;
		try {
			conn=AcessoBD.conectar();
			pstm=conn.prepareStatement(SELECT);
			rs=pstm.executeQuery();

			while(rs.next()){
				emp=new Empregado();
				emp.setId(rs.getInt("id"));
				emp.setNome(rs.getString("nome"));
				emp.setDat_nasc(rs.getDate("dat_nasc"));
				emp.setSalario(rs.getDouble("salario"));

				empregados.add(emp);
			}

		} catch (Exception e) {
			System.err.println("Ocorreu um erro, causa:"+e.getMessage());
			e.printStackTrace();
		}finally{
			AcessoBD.desconectar(conn, pstm, rs);
		}

		return empregados;
	}

	/**
	 * faz a inserção de EMPREGADO
	 * @param empregado
	 * @throws Exception
	 */
	public void inserir(Empregado emp){
		try {
			conn=AcessoBD.conectar();
			pstm=conn.prepareStatement(INSERT);
			pstm.setInt(1, emp.getId());
			pstm.setString(2, emp.getNome());
			pstm.setDate(3, emp.getDat_nasc());
			pstm.setDouble(4, emp.getSalario());

			pstm.executeUpdate();
		} catch (Exception e) {
			System.err.println("Ocorreu um erro, causa:"+e.getMessage());
			e.printStackTrace();
		}finally{
			AcessoBD.desconectar(conn, pstm, rs);
		}
	}

	/**
	 * faz a atualização de EMPREGADO
	 * @param empregado
	 * @throws Exception
	 */
	public void atualizar(Empregado emp){
		try {
			conn=AcessoBD.conectar();
			pstm=conn.prepareStatement(UPDATE);
			pstm.setString(1, emp.getNome());
			pstm.setDate(2, emp.getDat_nasc());
			pstm.setDouble(3, emp.getSalario());
			pstm.setInt(4, emp.getId());

			pstm.executeUpdate();
		} catch (Exception e) {
			System.err.println("Ocorreu um erro, causa:"+e.getMessage());
			e.printStackTrace();
		}finally{
			AcessoBD.desconectar(conn, pstm, rs);
		}
	}

	/**
	 * faz a exclusão de Empregado
	 * @param id
	 * @throws Exception
	 */
	public void excluir(int id){
		try {
			conn=AcessoBD.conectar();
			pstm=conn.prepareStatement(DELETE);
			pstm.setInt(1, id);

			pstm.executeUpdate();
		} catch (Exception e) {
			System.err.println("Ocorreu um erro, causa:"+e.getMessage());
			e.printStackTrace();
		}finally{
			AcessoBD.desconectar(conn, pstm, rs);
		}
	}
}

E por último temos a classe visual, que será criada no pacote br.visual, o nome dela será Principal:

package br.visual;

import java.sql.Date;
import java.text.SimpleDateFormat;

import br.modelo.Empregado;
import br.modelo.EmpregadoDAO;

/**
 * classe onde executa o programa
 * @author Roberto Silva
 *
 */
public class Principal {
	public static void main(String[] args) throws Exception{
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
		EmpregadoDAO empDao=new EmpregadoDAO();

		Empregado emp1=new Empregado();
		Empregado emp2=new Empregado();
		Empregado emp3=new Empregado();

		//setando o empregado 1
		emp1.setId(1);
		emp1.setNome("Roberto");
		emp1.setDat_nasc(new Date(sdf.parse("1983-08-12").getTime()));
		emp1.setSalario(5500.45);

		//setando o empregado 2
		emp2.setId(2);
		emp2.setNome("Katia");
		emp2.setDat_nasc(new Date(sdf.parse("1983-08-12").getTime()));
		emp2.setSalario(4500.50);

		//setando o empregado 3
		emp3.setId(3);
		emp3.setNome("Rose");
		emp3.setDat_nasc(new Date(sdf.parse("1983-08-12").getTime()));
		emp3.setSalario(6500.50);

		//inserindo
		empDao.inserir(emp1);
		empDao.inserir(emp2);
		empDao.inserir(emp3);

		//exibe os dados após a inserção
		System.out.println("Inserção:\n"+empDao.selecionar());

		//alterando os salarios, tiveram um aumento 🙂
		emp1.setSalario(6000.70);
		emp2.setSalario(5000.50);
		emp3.setSalario(7000.70);

		//atualizando os dados
		empDao.atualizar(emp1);
		empDao.atualizar(emp2);
		empDao.atualizar(emp3);

		//exibe os dados após a atualização
		System.out.println("Alteração do sálario:\n"+empDao.selecionar());

		//coloca em um array de Empregado
		Empregado []emps={emp1,emp2,emp3};

		//for each irá exclui um a um empregado do array
		for(Empregado empIn:emps)
		empDao.excluir(empIn.getId());

		System.out.println("Exclusão, total de registros :"+empDao.selecionar().size());
	}
}

Código simples e bem comentado, procurei deixar de maneira que fique “auto-explicativo”.
Execute o programa com banco de dados levantado.
A saída será:
ScreenHunter_02 Jul. 05 20.35

Github:clique aqui
Download do projeto:clique aqui

Obrigado pela visita, até mais 😉

Criando classe de conexão Java – Parte 1.

Olá.

Neste post iremos criar uma classe de conexão java.
Esta classe fará leitura de um arquivo de propriedades, nele conterá todo parâmetro para conexão.

Desta maneira não teremos acomplamento a um tipo de banco de dados, ou seja ,
não será necessário escrever na própria classe “hard code” a conexão com o banco de dados.

Obs:Se quiser seguir o tutorial a risca faça os downloads, senão ignore os passos seguintes e use o banco de dados que melhor servir, juntamente com seu driver JDBC.Depois é só editar o arquivo de propriedades que iremos criar.
1°)Faça os seguintes downloads, caso não possua estes arquivos:
Oracle Express 11g
ojdbc14.jar
Obs:o arquivo ojdbc14.jar ou qualquer outro driver jdbc,deve ser colocado na raiz do projeto, que iremos criar.
Clique em aceitar, para liberar o download e siga os procedimentos…
ScreenHunter_01 May. 26 00.15
2°)Após baixar os arquivos instale o Oracle Express 11g, que será nosso banco de dados, para este exemplo.
Siga os assistente de instalação, quando pedir uma senha digite “Tiger”, essa senha será do usuário SYSTEM que é o usuário padrão do Oracle.
Em caso de dúvida, segue um link com um video tutorial:
Instalação Oracle 11g

Abra o eclipse crie um novo projeto “Java Project“, aperte a combinação [CTRL+N], em “Project name” coloque ConexaoJDBC.

Novo projeto

Selecione o projeto, clique com botão direito do mouse e siga p/ Buid Path > Configure Build Path.
Como na imagem abaixo…
build path
Clique em [Add External Jars], e adicione o arquivo ojdbc14.jar ou o driver JDBC de sua preferência, após isso clique em [OK].

Após este passo, criaremos a classe de conexão Java, aperte a combinação [CTRL+N], o arquivo é do tipo Class.
Nome da classe “Name” será “AcessoBD” e no pacote “package” coloque “br.controle”.

ScreenHunter_01 Jun. 09 20.30

Agora que foi criado a classe e o pacote, teremos que criar os métodos da classe, conectar e desconectar.
Digite conforme o código abaixo ou copie e cole.


package br.controle;

import java.io.File;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;
/**
*
* @author Roberto Silva
*/
public class AcessoBD{

    public static Connection conectar() throws Exception {
        Connection connection = null;
        String driver = "";
        String usuario = "";
        String senha = "";
        String url = "";
        String banco = "";

        //so renomear se precisar do outro properties
        File prop_file = new File(new File("").getAbsolutePath() + "/jdbc.properties");

        if (!prop_file.isFile()) {
            throw new Exception("Não achou a arquivo de propriedade, caminho:" + prop_file.getAbsolutePath() + " , errado.");
        }

        Properties properties = new Properties();
        //Setamos o arquivo que será lido
        FileInputStream fis = new FileInputStream(prop_file.getAbsolutePath());

        //método load faz a leitura através do objeto fis
        properties.load(fis);

        //Captura o valor da propriedade, através do nome da propriedade(Key)
        usuario = properties.getProperty("jdbc.user");
        senha = properties.getProperty("jdbc.pass");
        driver = properties.getProperty("jdbc.driver");
        url = properties.getProperty("jdbc.url");
        banco = properties.getProperty("jdbc.dataBase");

        Class.forName(driver);

        connection = DriverManager.getConnection(url + banco, usuario, senha);

        return connection;
    }

    //sobrecarga dos metodo desconectar,
    //na sobrecarga muda somente a assinatura dos metodos ou seja os parâmetros
    public static void desconectar(Connection conn) {
        try {
            if (conn != null) {
                conn.close();
            }
        } catch (Exception e) {
            System.out.println("Exceção, causa:" + e.getClass());
            e.printStackTrace();
        }
    }

    public static void desconectar(Connection conn, PreparedStatement pstm) {
        try {
            if (pstm != null) {
                pstm.close();
            }

            if (conn != null) {
                conn.close();
            }

        } catch (Exception e) {
            System.out.println("Exceção, causa:" + e.getClass());
            e.printStackTrace();
        }
    }

    public static void desconectar(Connection conn, PreparedStatement pstm, ResultSet rs) {
        try {

            if (rs != null) {
                rs.close();
            }

            if (pstm != null) {
                pstm.close();
            }

            if (conn != null) {
                conn.close();
            }

        } catch (Exception e) {
            System.out.println("Exceção, causa:" + e.getClass());
            e.printStackTrace();

        }
    }
}

Como podemos observar o método conectar(), retornará um objeto do tipo java.sql.Connection,este objeto é da API JDBC, para uso do SQL.Também que fará leitura de um arquivo de propriedades,conforme este trecho:

 FileInputStream fis = new FileInputStream(prop_file.getAbsolutePath());

Vamos criá-lo neste momento, aperte a combinação [CTRL+N] para criar um novo arquivo, na árvore General, siga para o tipo File aperte [Next]. O nome do arquivo será “jdbc.properties”.

general_file
Digite o conteúdo abaixo.

#parametros de conexao com banco.
jdbc.dataBase=XE
jdbc.url=jdbc:oracle:thin:@localhost:1521:
jdbc.driver=oracle.jdbc.driver.OracleDriver
jdbc.user=SYSTEM
jdbc.pass=Tiger

No próximo post iremos criar uma tabela no Oracle e testar a persistência com o banco de dados.

Obrigado pela visita.Até o próximo post.

Simples tabela Java na IDE Eclipse – JTable

Olá pessoal!

Neste post abordaremos como criar uma JTable “Tabela”, esta por sua vez é uma API Java.

Abra a IDE Eclipse, crie um novo projeto Java, nomeie de MyJTable.

Crie uma classe Java chamada de GuiPrincipal.

  public class GuiPrincipal{
  }

Após o nome da classe “GuiPrincipal” digite: “extends JFrame”, importe as API’s abaixo:

  import java.awt.Dimension;
  import java.awt.FlowLayout;
  import javax.swing.JFrame;
  import javax.swing.JScrollPane;
  import javax.swing.JTable;

  public class GuiPrincipal extends JFrame{
  }

Esta classe extende de JFrame é uma API Java é semelhante a um “formulário”.Colocaremos nossa JTable neste “formulário”.

Abaixo o código completo comentado.


import java.awt.Dimension;
import java.awt.FlowLayout;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;

public class GuiPrincipal extends JFrame{
	
        //variaveis para uso da JTable 
	private JTable table;
	private final String colunas[]={"Nome:","Idade:","Sexo:"};
	private final String dados[][]={
			{"Jack","19","Masculino"},
			{"Eddie","56","Masculino"},
			{"Gina","34","Feminino"},
			{"Klaus","18","Masculino"},
			{"Erika","20","Feminino"},
			{"Roberto","29","Masculino"},
			{"Maria","30","Feminino"}};
	
        /*Construtor da classe ,
          antes de executar o metodo main(),
          irá construir o JFrame e a JTable*/
	public GuiPrincipal() {
		setLayout(new FlowLayout());//tipo de layout
		setSize(new Dimension(600, 200));//tamanho do Formulario
		setLocationRelativeTo(null);//centralizado
		setTitle("Exemplo JTable");//titulo
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//setando a ação padrão de fechamento do Formulário,
                                                               // neste caso  irá fechar o programa
		
                //instanciando a JTable
		table=new JTable(dados,colunas);
		table.setPreferredScrollableViewportSize(new Dimension(500,100));//barra de rolagem
		table.setFillsViewportHeight(true);
		
                //adicionando a tabela em uma barra de rolagem, ficará envolta , pela mesma 
		JScrollPane scrollPane=new JScrollPane(table);
                
                //adicionando ao JFrame "Formulário" a JTable "Tabela" 
		add(scrollPane);
	}
	
        //este é o método onde é executado nosso programa
	public static void main(String[] args) {
		new GuiPrincipal().setVisible(true);
	}
	
}

jtable

Até o próximo post, obrigado pela visita! 🙂

Sobrecarga “Overload”.

Olá pessoal!

Neste post iremos criar uma classe, com métodos em sobrecarga.A sobrecarga é muito usada, como por exemplo em uma classe de conexão com Banco de Dados “Connection Factory”.

Ela se caracteriza quando temos um método com mesmo nome só mudamos a assinatura ou seja os parâmetros, por exemplo:

public class Teste1 {

	static boolean testeTipo(Object object){
		System.out.print("is Object  : ");
		return object instanceof Object;
	}

	static boolean testeTipo(String string){
		System.out.print("is String  : ");
		return string instanceof String;
	}

	static boolean testeTipo(Number number){
		System.out.print("is Number  : ");
		return number instanceof Number;
	}

	static boolean testeTipo(Double doub){
		System.out.print("is Double  : ");
		return doub instanceof Object;
	}

	static boolean testeTipo(Integer integer){
		System.out.print("is Integer : ");
		return integer instanceof Integer;
	}

	public static void main(String[] args) {
		
		System.out.println(testeTipo(15));
		System.out.println(testeTipo(10.5));
		System.out.println(testeTipo(new StringBuffer("Hello Word")));
		System.out.println(testeTipo(15l));
		System.out.println(testeTipo("solutionbto.wordpress.com"));

	}
}

Ao executar irá perceber que invoca o metodo mais genérico ou seja compatível com argumento passado.

Até o próximo post, obrigado pela visita!

Passo a Passo – 1º Programa Java “Hello World”.

Olá Pessoal,

Bom neste post, iremos criar um simples programa na IDE Eclipse, exibiremos uma mensagem na tela.
Caso não tenha a IDE Eclipse clique neste link Download Eclipse IDE.Neste link há várias versões do Eclipse baixe a “Eclipse IDE for Java EE Developers”.

DownloadEclipse

Descompacte na raiz do HD “C:\” ou fica ao seu critério, depois execute o eclipse.exe.

Dê um nome para seu espaço de trabalho “workspace”, neste exemplo nomeei de Programas, irá ser criado uma pasta para seus projetos.
work_space

Abrirá uma tela de Bem Vindo “Welcome”, Clique em File > New > Project ou se preferir CTRL + N, depois Project Java.

Dê o nome de HelloWorld para o projeto, depois clique em finish.
Project

Criaremos um pacote “package”, clique com botão direito do mouse em cima do projeto, New > Package ou CTRL + N e Package.
Dê o nome de teste, depois clique em finish.
package

Criaremos uma classe Java, clique com botão direito do mouse em cima do projeto, New > Class ou CTRL + N e Class.
Dê o nome de HelloWorld, depois clique em finish.
create_class

Irá criar a classe, criaremos o método main da classe, é bem simples digite main depois CTRL + ESPAÇO, o eclipse irá ativar um recurso de auto-completa dê ENTER e em seguida irá criar o método.
main

Após criar o método main, digite dentro do método main sysout depois CTRL + ESPAÇO irá auto-completar, dentro do println digite entre aspas  “Hello World”.

Vamos compilar nosso pequeno programa, CTRL + F11 ou aperte o pequeno botão verde que parece um play.ScreenHunter_05 Dec. 22 02.29

Irá exibir no console “Hello World”.

console

 

Abaixo a classe HelloWorld.java

package teste;
public class HelloWorld {
      public static void main(String[] args) {
            System.out.println("Hello World");
      }
}

Agradeço pela visita e até o próximo post.

Como configurar o JDK no Windows?

Olá pessoal!

Para começar a programar em Java, é preciso baixar o JDK – Java Development Kit,  nele contém tudo o que precisa para começar, não é necessário baixar o JRE, pois já está incluso no JDK.

Clique neste link  JDK  para o download.

Após fazer a instalação do JDK é preciso configurar as “Variáveis de Ambiente”, vamos lá:

Entre no  Painel de Controle > Sistemas > Avançado,  entre em “Variáveis de Ambiente”;
Sistema

Ao abrir a Janela haverá dois grupos, neste caso criaremos as variáveis em  “Variáveis do Sistema”.
Variaveis de Ambiente

Clique em novo, em  nome digite  “JAVA_HOME” , em valor coloque o  local onde o JDK  foi instalado, exemplo: “C:\Arquivos de programas\Java\jdk[versão]” , clique em OK;
JAVA_HOME

Clique novamente em novo,  em  nome digite “CLASSPATH”,  no  valor   “.;%JAVA_HOME%\lib” , clique em OK;
CLASS_PATH

Agora vamos editar uma variável já existente que chama-se “Path”, selecione esta variável e clique em editar,  editaremos o valor dela, no final do valor coloque “;%JAVA_HOME%\bin”, clique em OK;
Path

Pronto!

Terminamos de criar as variáveis necessárias para começar a desenvolver,  clique em OK  para fechar a janela  “Variáveis de Ambiente”.

Agora vamos testar,  no prompt de comando do Windows e digite:

java -version

depois…

javac -version

Deverá aparecer a versão de ambas, como nesta imagem.

config_java

Qualquer dúvida , sugestão ou crítica só postarem nos comentários.

Agradeço pela visita, até o próximo post.