Objota O mundo orientado a objetos

De volta ao Blog

Posted on julho 30, 2013

Posted by Pedro

Olá galerinha,

Bom, esse post é mais para justificar, nos próximos meses voltarei a publicar várias dicas e exemplos aqui no Blog. Os assuntos que vou focar é mobile, visto que existe uma demanda muito grande de conhecimentos referente a iOS, Windows Phone e Android.

Espero que gostem dos meus novos post.

E pra quem esperou tanto tempo para ver novamente meus posts, um muito Obrigado pela paciência.

Categorias: Java 3 Comentários

hashDoS a falha de segurança que afeta a maioria das linguagens WEB

Posted on janeiro 1, 2012

Posted by Eder Freire

Recentemente na Alemanha aconteceu a 23ª edição da Chaos Computer Club, uma conferência de segurança muito conhecida entre os hackers de todo mundo e, pra variar, as primeiras palestras foram assustadoras. Um pesquisador encontrou uma brecha que afeta milhões de celulares no mundo todo nas redes 2G GSM, mas o que realmente me chamou atenção foi uma dupla de pesquisadores avisou que milhões de sites estão vulneráveis a um novo tipo de ataque DoS (Denial of Service), chamado hashDoS, que pode deixá-los fora do ar se não tratado com rapidez.

Os pesquisadores Alexandre Klink e Julian Wälde gesticularam e demonstraram que o problema está na maneira que certas linguagens usadas em servidores web armazenam valores em uma tabela hash. A grande maioria utiliza do mesmo método e pessoas mal-intencionadas podem tirar vantagens disso, enviando valores pré-determinados que sabem sabem que não serão tratados da forma que deveriam ser tratados. Essas requisiões, no final das contas, acaba gerando uma função quadrática que sobrecarrega os servidores.

Para provar que o método funciona, durante a apresentação, eles enviaram requisições do tipo HTTP POST com 2 MB de tamanho para um servidor WEB rodando Apache Tomcat, isso foi o suficiente para que o processamento do servidor subisse para a marca de 100% de consumo e permanecesse neste nível durante toda a palestra.

Quais linguagens afetadas?

A lista não é nada pequena. Nela constam PHP, ASP.NET, Java, Python, Ruby, Apache Tomcat, Apache Geronimo, Jetty, Glassfish, e até a V8, engine de renderização de JavaScript do Google.

Note que aqui temos interpretadores e servidor de aplicação, nessa os servidores WEB e o protocolo HTTP escaparam, sempre alvos de ataques de hackers.

Quais linguagens ja iniciaram o processo de correção e em qual versão isso ja está corrigida?

JRuby >= 1.6.5.1
PHP >= 5.3.9 (ainda está em Release Candidate), 5.4.0 RC4
Ruby >= 1.8.7-p357, 1.9.x
Apache Tomcat >= 5.5.35, 6.0.35, 7.0.35
Rack >= 1.4.0, 1.3.6, 1.2.5, 1.1.3

A Microsoft ja anunciou que vai liberar uma atualização para o ASP.NET que soluciona esse problema.

Os mais afetados com certeza serão os sites com PHP, hoje 77% dos sites em PHP rodam sob o PHP 5.2, que não teve nenhum suporte a este buf-fix. O certo é migrar-mos nossos sites para o PHP 5.3.9 RC, a 5.3 ja é a versão estável do PHP, o que garante atualizações de segurança e novos recursos.

Há linguagens que não entraram na lista, pois isso não era novidade para seus criadores, uma que vale a pena destacar, a qual eu sou fã, é o Perl, eles trataram esse problema em meados de 2003, pois ja haviam identificado essa falha.

A explicação é extramamente complexa, vale a pena dar uma olhada no vídeo da apresentação no Youtube .

Você também pode conferir o anúncio oficial.

APP Corinthians

Posted on setembro 30, 2011

Posted by Pedro

Para alegria de todos os torcedores de carteirinha do Timão. Foi anunciado o lançamento da versão completa do aplicativo MeuCorinthians, para iPhone. Em 1 mês e meio o aplicativo já chega perto dos 1000 downloads, crescendo a cada semana a freqüência de usuários.

Baixamos o App e fuçamos. Ao que parece, o aplicativo dentre os que o iTunes dispõe, parece ser o mais completo. Dentre as principais funcionalidade do app, destacamos:

- Tabelas dos campeonatos atualizadas

- Tudo o que você queria saber, até lista de uniformes já usados pelo Corinthians o app têm

- Design/interface bem resolvidas

- Nova versão free

Para baixar o aplicativo no iTunes, clique aqui.

Ausência de POST

Posted on agosto 14, 2011

Posted by Pedro

Galera venho nesse POST informar que infelizmente vou ficar mais um tempo afastado do blog, pois a Faculdade, Trabalho e  Freelas estão me tirando o sono e por isso não consigo planejar os novos tutoriais.

Por esse POST além de informar venho pedir desculpas também!!!

Até a próxima!

Categorias: Java 3 Comentários

Drive MySql de conexão para Eclipse

Posted on setembro 13, 2010

Posted by Rodrigo Ireno

Olá, neste artigo iremos focar em como utilizar o drive de conexão do Mysql na IDE eclipse. Veremos passo-a-passo como instalar, o que é uma coisa muito simples, e alguns comandos SQL com Java.

Quem já me conhece sabe que costumo escrever sobre php. Então já deve ter visto o artigo sobre PDO. E advinha em que o PDO foi baseado? Em? O Java!

Vamos aos passos:

1º - Faça download do Eclipse se não estiver instalado, neste link:
http://www.eclipse.org/downloads/packages/eclipse-ide-java-developers/heliosr

- para este artigo sugiro utilizar a versão clássica para java SE.

2º - Faça download do drive de conexão com o banco de dados mysql. No próprio site deles, neste link:
http://www.mysql.com/downloads/connector/j/

Escolha o tipo de arquivo que deseja baixar e clique em download, você será redirecionado para uma página que irá sugerir um cadastro, porém isso não é necessário, clique no link
» No thanks, just take me to the downloads!” e siga em frente para fazer download.

Depois disso você será direcionado a página com o link de download. Clique no link, como na imagem abaixo, pode ser qualquer um com as bandeiras do Brasil:

3º - Agora precisamos do Banco de dados, claro! Você pode adquirir o banco de dados gratuitamente no próprio site Mysql.com, porém sua configuração iria estender um pouco mais a coisa, e até tornar um pouco mais complicado. Para tanto, utilize um gerenciador que já instala pra você o Mysql – entre outras coisas -, e uma interface de administrador. O mais fácil e que eu sugiro é o xampp.

O xampp é gratuito e de fácil instalação. Depois de instalado, para acionar o banco de dados mysql é só clicar no botão "start", e para usar o phpMyAdmin (interface para administração do banco) é preciso iniciar também o Apache com "start".

Veja um artigo utilizando o xampp.

Você pode fazer download do xampp neste link:
http://www.baixaki.com.br/download/xampp.htm

Bom, se tudo ocorreu bem até agora, você já deve ter os ingredientes:
Eclipse, drive de conexão, xampp  (cujo "m" da sigla é de Mysql)

Vamos por a mão na massa então! Instale o xampp e o eclipse.

Com o xampp iniciado clique em start para o mysql e o Apache;

Depois clique no botão admin para o mysql;

Ele irá abrir em seu browser padrão o phpMyAdmin. Crie um banco de dados com o nome tutorial.

não iremos entrar em maiores detalhes no phpMyAdmin, pois este não é o foco deste artigo, conteudo sobre phpMyAdmin

Interface phpmyadmin

Depois de criado, ele irá aparecer na lateral esquerda do browser. Clique no nome do Banco de dados que você acabou de criar com o nome tutorial e depois na aba SQL, à direita. E excute esta query, ou crie uma tabela equivalente.


CREATE TABLE IF NOT EXISTS `cliente` (

`id` int(11) NOT NULL AUTO_INCREMENT,

 `nome` varchar(80) NOT NULL,

 `fone` varchar(80) NOT NULL,

PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

Após isso crie um novo projeto no eclipse com o nome de sua preferência. Dentro deste projeto crie as seguintes classes abaixo.

Antes de tudo, vamos esclarecer que este artigo não visa utilizar nenhum padrão de desenvolvimento específico. É somente um “Oi banco de dados”

package tutorial;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class Conexao {

	// Carrega driver JDBC
	static {
		try {
			Class.forName("com.mysql.jdbc.Driver");
		} catch (ClassNotFoundException e) {
			throw new RuntimeException(e);
		}
	}

	//Obtem conexao com banco de dados
	public Connection obtemConexao() throws SQLException{
		return DriverManager.getConnection(
				"jdbc:mysql://localhost/tutorial","root","");
	}
}

package tutorial;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.ResultSet;

public class Cliente {

	private int idCliente;
	private String nome;
	private String fone;

	public Cliente(){

	}

	public Cliente(int idCliente) {
		this.idCliente = idCliente;
	}

	public Cliente(String nome, String fone) {
		this.nome = nome;
		this.fone = fone;
	}

	public int getIdCliente() {
		return idCliente;
	}

	public void setIdCliente (int idCliente) {
		this.idCliente = idCliente;
	}

	public String getNome() {
		return nome;
	}

	public void setNome(String nome) {
		this.nome = nome;
	}

	public String getFone() {
		return fone;
	}

	public void setFone(String fone) {
		this.fone = fone;
	}

	//  Inclusao de clientes
	public void incluir(Connection conn) {

		//Armazena a string contento o comando sql numa variavel.
		//Repare nos pontos de interrogação, pois eles serão preenchidos!

		String sqlInsert = "INSERT INTO cliente(nome, fone) VALUES ( ?, ?)";

		//inicio um objeto que prepara a instrução a ser executada.
		 //Veja o 'null'.Ele ainda está vazio

		PreparedStatement stm = null;
		try {

			 	//Agora sim. Atraves do objeto Connection eu
			 	//recupero o objeto 'preparador de instrução'.
			 	//veja que já inseri a variavel que tem o comando sql!

			stm = conn.prepareStatement(sqlInsert);

			 //Lembra dos pontos de interrogação, no seu comando sql?
			 //o método setString seta estes pontos de interrogação.
			 //substituindo-os pelo valor que vem no segundo parâmetro.
			 //Portanto...

			//Aqui, substitui a primeira interrogação pelo nome do cliente
			stm.setString(1, getNome());

			//Aqui, substitui a segunda interrogação pelo fone (telefone) do cliente
			stm.setString(2, getFone());

			//E finalmente depois de tudo devidamente preparado ele chama
			// o comando execute()
			stm.execute();

		} catch (Exception e) {
			//Caso tenha uma exceção printa na tela
			e.printStackTrace();
				try {
					//Aqui ele 'tenta' retroceder, na ação que deu errado.
					// quese um Ctrl+Z da vida.
					conn.rollback();
				} catch (SQLException e1) {
					System.out.print(e1.getStackTrace());
				}
		} finally {
			// Comando finally sempre é executado
			if (stm != null) {
				try {
					// Encerra as operações.
					stm.close();
				} catch (SQLException e1) {
					System.out.print(e1.getStackTrace());
				}
			}
		}
	}

	public void buscar(Connection conn) {

		String sqlSelect = "SELECT nome, fone FROM cliente WHERE cliente.id = ?";

		PreparedStatement stm = null;

		  // Aqui temos uma nova estrela no pauco.
		  // O objeto ResultSet é responsavel por manipular
		  // os resultados de uma query de busca.

		ResultSet rs = null;

		try {
			//vide explicaçao anterior
			stm = conn.prepareStatement(sqlSelect);

			//ponto de interrogação por valor getIdCliente()
			stm.setInt(1, getIdCliente());

			//O comando abaixo retorna um objeto ResultSet
			//com os valores dos dados buscados.

			rs = stm.executeQuery();

			//use next() para verificar se ele veio preenchido
			//de dados. Ele também pode ser usado em um while,
			//para querys que resultem em mais de um registro.

			if (rs.next()){

				//Acima no nosso select foi declarado:
				//SELECT nome, fone FROM..
				//portanto o 1 = nome e o
				//2 = fone

				//getString(1) refere-se ao atributo 'nome' da nossa query
				this.setNome(rs.getString(1));

				//Já o getString(2) refere-se ao atributo 'fone'
				this.setFone(rs.getString(2));
			}

		} catch (Exception e) {
			e.printStackTrace();
				try {
					conn.rollback();
				} catch (SQLException e1) {
					System.out.print(e1.getStackTrace());
				}
		} finally {
			if (stm != null) {
				try {
					stm.close();
				} catch (SQLException e1) {
					System.out.print(e1.getStackTrace());
				}
			}
		}
	}
}

package tutorial;

import java.sql.SQLException;
import java.sql.Connection;

 public class Teste {

    public static void main(String[] args) {

      Connection conn = null;

      Cliente cl;

      try {

      // obtem conexao com o banco
    	 Conexao bd = new Conexao();
         conn = bd.obtemConexao();

         conn.setAutoCommit(false);

      //  Inclusao do Primeiro Cliente
         cl = new Cliente("Mariana Soares", "1127991999");
         cl.incluir(conn);

      // Inclusao do Segundo Cliente
         cl = new Cliente();
         cl.setNome("João Neves");
         cl.setFone("1160606161");
         cl.incluir(conn);

      // Inclusao do Terceiro Cliente
         cl = new Cliente("Maria Oliveira", "1121212121");
         cl.incluir(conn);

      // efetiva inclusoes
         conn.commit();
         System.out.println("Inclusão concluída");
         System.out.println("Buscando...");

      // Busca Cliente com id 2
         cl = new Cliente(2);
         cl.buscar(conn);

         String saida = "Nome: "+cl.getNome()+
         				 "\nTelefone: "+cl.getFone()+
         				 "\nid: "+cl.getIdCliente();

         System.out.println(saida);
      }
          catch (Exception e) {
            e.printStackTrace();
            if (conn != null) {
               try {
                  conn.rollback();
               }
                   catch (SQLException e1) {
                     System.out.print(e1.getStackTrace());
                  }
            }
         }
      finally {
         if (conn != null) {
            try {
               conn.close();
            }
                catch (SQLException e1) {
                  System.out.print(e1.getStackTrace());
               }
         }
      }
      System.exit(0);
    }
}

Veja minha estrutura para este projeto:

Depois que as classes já estiverem ok iremos adicionar aquele drive ao nosso projeto. Para isso clique com o botão direito sobre o seu projeto.
Siga o caminho: Build Path > Configure Build Path >
escolha a aba Libraries.
Agora clique no botão “Add External JARs...”
Encontre o drive que você baixou, com extensão “.JAR”. Clique nele, depois em Abrir.
(ele precisa estar descompactado, ele era um .zip lembra?)
Pronto seu driver já foi instalado.

Para testar a coisa toda:

O xampp deve estar ligado, com mysql e apache iniciados. phpMyAdmin aberto, para você checar as alterações na sua tabela.

O script foi feito para inserir  três clientes toda vez que for rodado, e buscar um pelo id. Rode a classe Teste, agora veja o resultado no phpMyAdmin. Para atualizar a visualização, basta clicar na aba visualizar.

Esse artigo fica por aqui, qualquer dúvida postem. Obrigado e até a próxima!

O objeto ArrayList

Posted on junho 29, 2010

Posted by Rodrigo Ireno

Neste artigo vou abordar brevemente o objeto ArrayList. Ele permite fazer uma coleção de valores e/ou objetos, ou seja, ele aceita valores primitivos e objetos. E é estremamente fácil de utilizar, pois não é necessário inicializar ele com um tamanho fixo, ele trabalha com um tamanho variável. Sendo que em qualquer momento você pode adicionar elementos e remover elementos.

Ele porém não faz parte do pacote padrão do java: java.lang...

Sendo assim é necessário fazer a importação de seu pacote, desta forma:

import java.util.ArrayList;

Este comando importa a classe ArrayList que se encontra no pacote java.util. Neste pacote existem outras classes, Como Iterator que pretendo demonstrar seu uso em futuros artigos.

Existe também a possibilidade de importar todo o conteúdo do pacote, porém isso deixa sua aplicação mais pesada:

import java.util.*;

esse comando importa todo o conteúdo do pacote.

Vejamos abaixo uma classe e um trecho de código, para executar:

//Aqui importo o pacote para dentro de minha classe
import java.util.ArrayList;

public class MinhaLista {
    private ArrayList lista;

    public MinhaLista(){
        //Instancio o objeto ArrayList
        lista = new ArrayList();
    }

    public void addItem(String valor){
        //O método add() adiciona um valor ao array, detalhe:
        //isso aumenta o seu tamanho dinamicamente
        lista.add(valor);
    }

    public void removerItem(int indice){
        //Este método remove o objeto que ocupa
        //o indice indicado por parâmetro
        lista.remove(indice);
    }

    public void setItem(int indice, String valor){
        //Este método altera o objeto que o ocupa o índice indicado
        lista.set(indice, valor);
    }

    public String getItem(int indice){
        // O método get() retorna o endereço de memória do objeto
        //que se encontra no índice fornecido por parâmetro
        //Por este motivo é preciso fazer uso de um casting (conversão de tipo)
        //Isso diz ao ArrayList que você quer o objeto e não seu endereço de memória

        return (String) lista.get(indice);
    }

    public void mostrar(){

        //Este é o loop for. Uma estrutura de controle que repete um comando
        //por um numero determinado de vezes

        for(int i=0; i < lista.size();i++){
            String n = (String) lista.get(i);

            //Este método println() recebe uma String como parâmetro
            //e imprime na tela.
            System.out.println(n);
        }
    }
}

Agora fiz uma outra classe para executar a classe MinhaLista. Abaixo temos o uso do método main() que  executa uma aplicação java.

public class TestaMinhaLista {
    public static void main(String[] args){
        MinhaLista obj = new MinhaLista();

        //Adicionando um item ao índice 0
        obj.addItem("Java");

        //Adicionando um item ao índice 1
        obj.addItem("Brasil");

        //Adicionando um item ao índice 3
        obj.addItem("Texto a ser removido");

        //Adicionando um item ao índice 4
        obj.addItem("Programação");

        obj.removerItem(2);

        //Mostro o conteúdo de minha lista
        obj.mostrar();

        System.exit(0); //Este comando encerra a aplicação
    }
}

Para ver este exemplo em funcionamento. Crie dois arquivos, sendo que o nome do arquivo que você criar deve ter exatamente o mesmo nome da classe, ex:

criei um arquivo no JGrasp com o nome de MinhaLista.java e dentro deste arquivo eu coloco a classe MinhaLista, aproveite pois é só copiar e colar. Em seguida clique no botão com símbolo "+" (na cor verde) e isso compila a sua classe .java e será visível a você que surge um arquivo com o mesmo nome do original, porém com uma estenção .class. Faça o mesmo com o arquivo TestaMinhaLista, compile-o e este em especial, por possuir o método main(), irá executar o programa. No JGrasp, visualizando a classe TestaMinhaLista execute o programa com o botão RUN. Veja o que acontece.

Dúvidas, por favor comente.

Arrays em java

Posted on junho 29, 2010

Posted by Rodrigo Ireno

Deixando de lado ( só um pouco) as classes, vamos agora tratar de um elemento muito útil em qualquer linguagem de programação. O array.

Um array e um elemento que existe em praticamente todas as linguegens de programação, que é capaz de armazenar vários valores dentro dele. Sendo possível armazenar diversos valores dentro dele, tembém é preciso um modo de recuperar este falor, que é atravez de um índice.

Algumas linguagens possuem arrays de tamanho fixo e variável, que é o caso do java. Em outras como php o array tem tamanho sempre variável. Bom sendo assim vamos exemplificar como seria o armazenamento de valores dentro de um array, em java.
No java,  elementos não primitivos são objetos e todos os objetos devem ser inicializados com a palavra chave new. Para utilizar um array de tamanho fixo em java é preciso especificar seu tamanho durante a inicialização, veja:


int[] meuArray = new int[16];

 meuArray[0] = 23;
 meuArray[15] = 40;

Tomando nota do código acima, já é possível ter uma idéia de como funciona. Tenho um array de números inteiros, vamos aos detalhes.

Ao instanciar um array de tamanho fixo, é preciso determinar o número exato de elementos que ele poderá suportar. Neste caso o array suporta 16 números inteiros. Para poder referenciar um valor dentro deste array, eu utilizo a chave ou índice do array. É aquele [indice] abre-colchete :  índice  : fecha colchete. Sendo que a contagem dos índices começa a partir do zero, então o primeiro elemento está no índice 0, e o último elemento está no índice 15.

Veja que eu atribui um valor 40 ao índice 15, portanto meuArray[15] retornará a partir de então o valor 40.

Arrays são muito utilizados em conjunto com loops, estruturas de controle que repetem determinado comando. veja um exemplo:


//    Veja um exemplo com o loop for

int[] meuArray = new int[3];

meuArray[0] = 50;
meuArray[1] = 25;
meuArray[2] = 48;

// ou esqueça o feito anterior e faça assim..

int[] meuArray = {50, 25, 48};

// O resultado é o mesmo

for(int i=0; i < meuArray.length;i++){

 System.out.println(meuArray[i]);

}

//    O loop acima itera por todo o array e imprime na tela todo o seu conteudo.

Bom este é o exemplo de array de tamanho fixo, porém o java possui um array de tamanho variável, ou seja, você não precisa determinar um tamanho específico para ele. E é usado justamente quando não se tem certeza do que vem por aí para preencher o array.

Apresento, o ArrayList do  pacote java.util.ArrayList. Como ele faz parte de um pacote não incluso por padrão, ele deve ser importado com o comando import.

Mostrarei um exemplo completo no próximo artigo. desta vez com classes inteiras.

até.

Instanciando objetos

Posted on junho 29, 2010

Posted by Rodrigo Ireno

Como visto no artigo anterior, construímos uma classe para representar um objeto do mundo real. Nós pegamos o objeto em questão e utilizamos como atributo somente o que nos for relevante, digo, o que for relevante para nosso módulo ou sistema.

No artigo passado, representei um objeto caneta. Porém para exemplificar vou utilizar um objeto um pouco mais simples. É o clássico é muito usado durante o aprendizado de iniciantes "objeto pessoa", não é nada de especial, porém muitos autores utilizam, pois é de fácil entendimento. Vamos a definição:

O que é preciso para diferenciar uma pessoa de outra no mundo... ..tá.. vamos pensar um pouco mais pequeno. Como representar uma pessoa como única em uma aplicação, pensando apenas no seu pais. É fácil! é só utilizar um atributo CPF. Agora,  seria bom colocar nome também, ora sejamos mais humanos! um atributo NOME já está de bom tamanho.

Já que definimos os atributos de nosso objeto, vamos montar sua estrutura em uma classe bem simples. Somente os atributos métodos de acesso e construtor. Vamos lá !

Classe pessoa:

public class Pessoa {

	private String cpf;

	private String nome;

	public Pessoa(String cpf,String nome ){
                //this.nome é o atributo da classe
                //e "nome" é o valor que vem por parâmetro
		this.nome = nome;

		this.cpf = cpf;

	}

	public String getNome(){
		return this.nome;
	}

	public String getCpf(){
		return this.cpf;
	}

}

Objeto construido, vamos a instanciação. Mas afinal de ocntas o que é instanciar..

Instanciar ou inicializar um objeto é o ato de trazer ele de uma lógica escrita para um objeto armazenado na memória em tempo de execução. Ou seja seu objeto vai para a memória do computador enquanto o aplicativo estiver rodando.

A palavra chave do java, usada para instanciar objetos,  e de muitas outras linguagens é new. Vejamos um exemplo:


//Declaro um objeto do tipo Pessoa

Pessoa obj = new Pessoa("333.666.777-22","Rodrigo");

//Pronto o objeto já está na memória e disponível para manipulação

Bom agora,  se eu utilizar o método getNome() terei acesso ao  dado armazenado no atributo nome, em tempo de execução. Agora para fixar melhor a idéia não tem jeito, tem que praticar. Para isso no próximo artigo pretendo falar de arrays, uma variável capaz de armazenar várias dentro dela.
Pretendo utilizar a nossa classe Pessoa, então até a próxima.

Construindo uma classe

Posted on junho 29, 2010

Posted by Rodrigo Ireno

Vamos iniciar este artigo fazendo um link com o anterior que falava sobre abstração e modularização.  Pois bem, quanto à modularização podemos dizer que a idéia é transformar um problema “grande” em vários pequenos. Assim fica mais fácil você se concentrar em um problema de cada vez...  E uma vez resolvidos passo a passo, os pequenos, você irá sanar o problema maior. Já quando se fala de abstração, estamos falando do “ato” que se realiza para construir uma classe. Vamos construir uma classe simples neste artigo, pode até ser com o bloco de notas. Porém, se quiserem já começar a utilizar uma IDE, dou todo o apoio. Aconselho a começar pela IDE JGrasp. Para os interessados segue:

(A ordem de instalação é importante, primeiro o JDK e depois a IDE)

1° - baixem o JDK – instalem. Não tem segredo o assistente de instalação fará tudo por vocês.

2º - baixem a IDE JGrasp – tem um link para download na barra lateral deste blog em “links úteis”. Esse também não tem segredo algum.

Bom para quem já tem tudo certinho funcionando, vamos começar a construção da classe. Primeiramente vamos lembrar o que é uma classe. Uma classe é uma entidade lógica que representa um objeto com suas ações e características, nem sempre um objeto é visível como em outras formas de desenvolvimento, como por exemplo ActionScript ou JavaScript.

Vamos então ao nosso objeto. É uma caneta. Quando se fala de caneta sei que existem vários tipos, porém me refiro a uma simples caneta esferográfica. Pois bem, vamos pensar que atributos uma caneta teria. Inicialmente eu diria de cara o atributo COR depois vem mais algum como tamanho: COMPRIMENTO e talvez um teste boleano (verdadeiro ou falso, no caso do Java usa-se as palavras chave true e false) para saber se existe tinta. Bem vamos então escrever a classe com estes atributos:

cor – da caneta
comprimento – em milímetros
temTinta  - verdadeiro ou falso, indica se há tinta na caneta.

Abaixo explicarei mais sobre esta estrutura.


public class Caneta{
private String cor;
private double comprimento;
private boolean temTinta;

// Construtor
public  Caneta(String novaCor, double novoComprimento, boolean novoValorTemTinta ){
cor = novaCor;
comprimento = novoComprimento;
temTinta = novoValorTemTinta;
}

// Métodos de acesso
public String getCor(){
return cor;
}
// (…)

// Métodos modificadores
public void setCor(String novaCor){
cor = novaCor;
}
//(...)
}

A estrutura: public class Caneta{  aqui vem o conteúdo da classe }

Indica que a classe é pública (outras classe podem usá-la) e que seu nome é “Caneta”, detalhe toda classe deve ser nomeada começando com uma letra maiúscula. Dentro das chaves, vai o conteúdo da classe.

Dentro dela são apresentados os seus atributos:


private String cor;
private double comprimento;
private boolean temTinta;

A palavra chave private indica que estes atributos só são visíveis dentro desta classe, e para que outra classe possa utilizar destes atributos é necessário implementar métodos específicos para isso. Veremos adiante. Em seguida vem o tipo do atributo, String indica que o atributo pode armazenar somente caracteres, ex: “ABCDabcd1234” – sempre dentro de aspas duplas. E por último vem o nome do atributo, que deve ser nomeado com letras minúsculas. Isso é considerado uma boa prática de programação.

Exemplo de boa prática de programação está na nomenclatura de seus atributos e variáveis

private String cor;    -    bom
private String Cor;    -   Não aconselhável
private String  nome;  -    bom
private String sobreNome;   -    bom, pois fica visualmente menos agrecivo.
private String SobreNome; - Não aconselhável

O método construtor


// Construtor

public  Caneta(String novaCor, double novoComprimento, boolean novoValorTemTinta ){
cor = novaCor;
comprimento = novoComprimento;
temTinta = novoValorTemTinta;
}

O método construtor é o responsável por inicializar um objeto com seu valor default. Um método construtor pode ter um conteúdo em seu bloco ou não. O bloco abriga as ações a serem executadas pelo método. O bloco é indicado abaixo:


public Caneta(){
//Aqui, entre as chaves,  vem o conteúdo do bloco.
}

O que vem entre seus parênteses, são os chamados parâmetros.
Parâmetros são valores que vem de fora do método para serem usados dentro do método. Neste caso eu estou atribuindo os valores dos parâmetros (valores que vem de fora) aos atributos: cor, comprimento,  temTinta.
veja:

cor = novaCor;

Se  a variável novaCor, que vem como parâmetro, armazena dentro dela o valor “amarelo” seria o mesmo que dizer:

cor  = “amarelo”;

Será mais fácil compreender estes conceitos quando instanciarmos objetos desta classe, porém vamos só tratar de entende-la, mesmo que superficialmente.

Métodos de acesso

// Métodos de acesso
public String getCor(){
return cor;
}

Métodos de acesso servem para acessar o valor de um atributo, por tanto cada atributo tem que ter um método de acesso. Vamos analisar a assinatura deste método. Ele inicia pela palavra chave public, que indica que ele é um método público, ou seja, visível tanto dentro da classe como foram dela. Em seguida vem a palavra String que indica o tipo de valor retornado pelo método. Por último vem o nome do método seguido de parênteses. O bloco é naturalmente indicado por um par de chaves {}. E dentro do bloco é utilizada a palavra chave return que no caso retorna o valor do atributo cor.

obs: Assinatura de um método indica entre outras coisas seu nome e parâmetros que recebe.
public void setCor()   // assinatura
{
//Aqui vem o bloco ou corpo do método
}
Métodos modificadores

// Métodos modificadores
public void setCor(String novaCor){
cor = novaCor;
}

O método modificador basicamente tem a função de modificar o valor de um atributo. Ele recebe um valor como parâmetro e atribui esse novo valor ao atributo. Note que na assinatura do método não é indicado um tipo de retorno, pois quando se usa a palavra chave void indica-se que não existe um valor a ser retornado. Visto que sua função é modificar e não retornar.

Bem caros leitores, por hora é somente isso. Nos próximos artigos veremos como instanciar objetos.

Um pouco sobre a JVM – Java Virtual Machine

Posted on junho 29, 2010

Posted by Rodrigo Ireno

Olá, neste artigo vou comentar um pouco sobre a JVM (Java Virtual Machine) que é responsável por interpretar suas classes feitas em Java. Vamos ser diretos quanto aos fatos.

A linguagem Java possui um alto nível de portabilidade. O que seria? Portabilidade significa que o seu código é portável para diferentes plataformas, por tanto os programadores Java não precisam se preocupar a fundo com o sistema operacional para o qual está sendo feito o seu aplicativo. Como isso é possível?

Simples, quando o programador faz uma classe ou em um projeto inteiro, onde muitos profissionais atuam. O projeto consiste, geralmente, de milhares de classes. Todas escritas em linguagem Java. Os arquivos são salvos com a extensão “.java”.
exemplo: “filter.java” - exemplo de um arquivo que contenha alguma classe

Dentro de um arquivo como este, está tudo escrito em Java. Quando se compila o código Java em uma IDE qualquer, é gerado um arquivo filter, porém com uma extensão “.class” . Este arquivo “filter.class” contém o bytecode este por sua vez é executado pela Java Virtual Machine. Então por definição, quem executa uma aplicação feita em Java é a Virtual Machine, software free disponibilizado para download no site da Sun. Por isso a portabilidade do código fonte é tão grande, existem versões da Java Virtual Machine para quase todas, se não todas as plataformas existentes no mercado.

Isso tudo também leva a uma conclusão. Java é uma linguagem compilada e interpretada, e o que muitos profissionais já sabem é que isso acaba tornando-a lenta. Isso impossibilita seu uso em alguns projetos em que desempenho do software e uma prioridade.

É isso meus caros, espero ter enriquecido um pouco mais seus conhecimentos sobre Java. Até a próxima.

Conceitos básicos de POO – Abstração e Modularização

Posted on junho 29, 2010

Posted by Rodrigo Ireno

Olá, vamos abordar alguns assuntos importantes antes de iniciar na prática POO.
Antes de adentrar mais aos conceitos de POO, vamos fazer um breve comparativo entre o modo estruturado de programar e o Orientado a Objetos.  A programação estruturada é seqüencial, tudo é executado de uma vez em milhares de linhas com loops gigantescos e condicionais para controlar o fluxo da aplicação. Isso tornava o trabalho muito confuso depois de certo tempo desenvolvendo o projeto e a manutenibilidade mais complicada ainda.
A programação Orientada a Objetos é organizada em classes, entidades lógicas que representam objetos com suas características.
Sendo assim vamos a algumas das vantagens de se programar OO. A primeira melhoria que se vê neste jeito de se programar é a organização da aplicação, que é distribuída em diferentes classes. Cada uma fazendo uma tarefa específica. Juntas formam a aplicação.
Vamos então, abordar alguns conceitos básicos:

Abstração:
Faz-se uso deste conceito ao abstrair as coisas do mundo real e pegar somente o que for relevante para sua classe. Por exemplo, se eu quisesse fazer uma aplicação para manipular e armazenar dados de um carro para um estacionamento, eu deveria pegar os dados relevantes dos carros-clientes, como: Número da placa, cor, modelo, ano. Estes são chamados atributos. Muito falaremos de “atributos”, como sendo partes de classes. Um veículo tem muitas características, porém só nos interessa pegar o que nos for relevante para a aplicação.

Modularização:
Este é um conceito aplicado quando se trabalha em equipe. Uma vez que o engenheiro de software e analista validaram toda a lógica do projeto e já se tem em mãos a documentação das classes, o programador pode trabalhar em uma classe enquanto outros programadores fazem outras partes da aplicação. Um exemplo simples para entender como isso acontece:
Imagine um técnico em elétrica responsável pelas instalações de uma empresa em fase de construção. Ele não precisa saber como as paredes foram feitas ou de que material foram feitas para iniciar as instalações, só precisa de uma documentação, no caso uma planta do projeto que indique como serão feitas as instalações e quais os parâmetros que ele deverá seguir. Isso define bem a idéia, pois no caso de um programador, ele não precisa conhecer todas as implementações do projeto (o que chega a ser impossível), desde que ele tenha uma documentação adequada para fazer a sua parte.

Bom, é isso. Espero ter esclarecido um pouco mais alguns conceitos de POO.
Obrigado leitor, e até o próximo artigo.