Entenda o motivo do projeto Eclipse fazer tanto sucesso e com trabalha a Eclipse Foundation:
http://www.ibm.com/developerworks/blogs/page/ctaurion?entry=eclipse_e_open_innovation_network
Arquivo da categoria ‘Java’
// Declaração do pacote – Para melhor organizar o projeto
package basico;
// Declaração da classe
//public significa que a classe é visível para todo o projeto
public class Empregado {
// Declaração dos atributos da classe
// private significa que os atributos só são visíveis para a classe
// Encapsulamento
private int matricula;
private String nome;
private float salario;
// Declaração de variável estática, só da classe. Não faz parte dos objetos da classe
private static int novamatricula = 0;
// Declaração de método estático, só da classe. Não faz parte dos objetos da classe
public static int getNovaMatricula(){
novamatricula ++;
return novamatricula;
}
// Declaração de construtor default
public Empregado(){}
// Declaração de construtor (sobrecarga)
public Empregado(String nome, float salario) {
this(getNovaMatricula(),nome, salario);
// this referencia o objeto corrente
}
// Declaração de construtor (sobrecarga)
public Empregado(int matricula, String nome, float salario) {
this.matricula = matricula;
this.nome = nome;
this.salario = salario;
}
// Declaração de método
public int getMatricula() {
return matricula;
}
// Declaração de método
public void setMatricula(int matricula) {
this.matricula = matricula;
}
// Declaração de método
public String getNome() {
return nome;
}
// Declaração de método
public void setNome(String nome) {
this.nome = nome;
}
// Declaração de método
public float getSalario() {
return salario;
}
// Declaração de método
public void setSalario(float salario) {
this.salario = salario;
}
// Declaração de método
public void print() {
System.out.println(matricula + ” ” + nome + ” ” + salario);
}
// Declaração de método
public void aumentarSalario(double percentual) {
salario *= 1 + percentual / 100;
}
}
************************************************************************************
package teste;
import basico.Empregado;
public class TesteEmpregado {
public static void main(String[] args) {
Empregado[] equipe = new Empregado[3];
equipe[0] = new Empregado(“José”, 100);
equipe[1] = new Empregado(“Maria”, 200);
equipe[2] = new Empregado(“Pedro”, 300);
int i;
for (i = 0; i < 3; i++) equipe[i].aumentarSalario(5);
for (i = 0; i < 3; i++) equipe[i].print();
}
}
************************************************************************************
package basico;
public class Departamento {
private int codigo;
private String nome;
private Gerente gerente;
public Departamento(int codigo, String nome, Gerente gerente) {
this.codigo = codigo;
this.nome = nome;
this.gerente = gerente;
}
public int getCodigo() {
return codigo;
}
public void setCodigo(int codigo) {
this.codigo = codigo;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public Gerente getGerente() {
return gerente;
}
public void setGerente(Gerente gerente) {
this.gerente = gerente;
}
}
************************************************************************************
package basico;
// A classe Empregado está disponível para uso
import basico.Empregado;
// Herança – extends indica que a classe Gerente é uma subclasse de Empregado
// ela herda os atributos e métodos da superclasse (Empregado)
public class Gerente extends Empregado{
private float comissao;
// super se referencia à superclasse, no caso está chamando o construtor.
public Gerente(int matricula, String nome, float salario, float comissao) {
super (matricula, nome, salario);
this.comissao = comissao;
}
public float getComissao(){
return this.comissao;
}
public void setComissao(float comissao){
this.comissao = comissao;
}
// polimorfismo – o método está sendo redefinido. Este método também foi definido em Empregado
public void aumentarSalario(double percentual) {
float salario = 0;
salario *= 1 + percentual / 100;
this.setSalario(salario);
comissao *= 1 + percentual / 100;
}
}
************************************************************************************
package teste;
import basico.Departamento;
import basico.Gerente;
import basico.Empregado;
public class TesteDepartamento {
public static void main(String[] args) {
Gerente gerente = new Gerente(1, “José”, 100, 30);
Departamento departamento = new Departamento(1, “Vendas”, gerente);
System.out.println(departamento.getCodigo() + ” ” + departamento.getNome() + ” ” + departamento.getGerente().getNome() + ” ” + departamento.getGerente().getComissao() );
gerente.aumentarSalario(5);
System.out.println(departamento.getCodigo() + ” ” + departamento.getNome() + ” ” + departamento.getGerente().getNome() + ” ” + departamento.getGerente().getComissao() );
}
Java é uma linguagem orientada a objetos e, com isso, não é possível desenvolver nenhum programa sem seguir tal paradigma. Um sistema orientado a objetos é composto por um conjunto de classes e objetos bem definidos que interagem entre si, de modo a gerar o resultado esperado.
O que é?
O avanço das tecnologias na área de análise, projeto, desenvolvimento e qualidade de software permite que aplicações mais flexíveis e poderosas sejam construídas. A necessidade de integrar estas aplicações criou uma nova metodologia de análise e desenvolvimento: a Orientação à Objetos.
A Orientação à Objetos modela o mundo real com classes e instâncias. Cada classe é a estrutura de uma variável, ou seja, um tipo de dado. Nela, são declarados atributos e métodos que poderão ser executados ou acessados nas instâncias da mesma classe. As classes possuem uma função muito importante na modelagem orientada a objetos, elas dividem o problema, modularizam a aplicação e baixam o nível de acoplamento do software.
Variáveis de uma classe são chamadas de instâncias de classe. Por exemplo: Se existe uma classe Pessoa existe a instância (variável) pessoa que é do tipo Pessoa. Um Objeto, ou instância, é uma entidade cujas informações podem incluir desde suas características até suas atividades, ou seja, uma abstração de um domínio de um problema.
Abaixo há uma série de definições sobre a arquitetura de orientação a objetos em Java.
- Pacote: Conjunto de classes e demais arquivos que possuem interesses comuns ou atuam com dependências entre si. Fisicamente são pastas do sistema operacional.
- Instância, objeto: Uma variável do tipo de uma classe.
- Construtor: Responsável por iniciar a criação e inicialização de uma instância de classe.
- Método: Funções referenciados aquela classe.
- Modificador de acesso: Descreve que outras classes podem ter acesso a classe que está se criando. Também é usado para indicar que uma classe pode ser acessada de fora de seu pacote.
- Hierarquia de classes: Um grupo de classes que estão relacionadas por herança.
- Superclasse: É a classe que é estendida por uma determinada classe.
- Subclasse: É a classe que estende determinada classe.
- Classe base: A classe de determinada hierarquia que é uma superclasse de todas as outras classes. A classe? pai de todas?
É a declaração de desvio usada para sair de um laço antes do normal. O tipo determina para onde é transferido o controle. O break é transfere o controle para o final de uma construção de laço (for, do, while ou switch). O laço vai encerrar independentemente de seu valor de comparação e a declaração após o laço será executada. Exemplo:
int i = 0;
while (true) {
System.out.println(i);
if ( i++ >= 10 )
break;
}
Este exemplo imprime os valores da variável i de 0 até 9.
A declaração continue faz com que a execução do programa volte imediatamente para o início do laço, porém para a próxima interação. O continue faz o interpretador pular para a próxima iteração e obriga-o a testar a condição. Exemplo:
for (int i = -10; i<10; i++) {
if ( i == 0 )
continue;
System.out.println(i);
}
No exemplo, é impresso os valores de – 10 até 9 pulando o número zero.
Chegamos ao final de mais uma etapa. Na próxima veremos um pouco sobre Orientação a Objetos.
Laços controlam uma repetição de execução de acordo com uma condição imposta. Em Java, assim como tantas outras linguagens, existem três tipos de laço: for, while e do.. while.
Comando: for
O comando for cria um laço de repetição no fluxo do programa baseado em três parâmetros:
- expressão inicial: Onde é executado apenas uma vez, na entrada do laço.
- condição: É executado a cada iteração do laço e determina quando o programa deve sair do mesmo. Caso a condição seja verdadeira, repete-se os do laço uma vez, caso seja falsa, o programa pula para a próxima instrução seguinte ao laço.
- incremento: É uma operação normal, executada a cada iteração. Geralmente é usada para incrementar contadores ou configurar variáveis.
Sintaxe:
for (<expressão inicial>; <condição>; <incremento>) {
<comandos>
}
Exemplos:
public class ExemploFor {
public static void main(String[] args) {
for (int i=0; i<10; i++) {
System.out.println("Contador é " + i);
}
for (;;) {
System.out.println("Laço infinito.");
}
}
}
O primeiro for do exemplo acima irá apresentar 10 mensagens indicando o contador de 0 até 9. Quando o valor do inteiro i ser igual a 10 o interpretador java alternará o fluxo para o início do outro for.
No segundo for do exemplo o código entra num laço infinito, ou seja o programa não termina, sequer sairá do laço, já que não existe condição para que tal evento ocorra.
Comando: while
O comando while é utilizada quando não se quer que o corpo do laço seja necessariamente executado. A expressão de comparação é avaliada antes que o laço seja executado, enquanto ela for verdadeira os são repetidos.
Sintaxe:
while (<condição>) {
<comandos>
}
Exemplos:
public class ExemploWhile {
public static void main(String[] args) {
int i=0;
while(i++<10) {
System.out.println("Contador é " + i);
}
while(true) {
System.out.println("Laço infinito.");
}
}
}
Assim como nos exemplos com o comando for, o primeiro exemplo imprime contadores de 0 até 9 e o segundo é um laço infinito, pois o resultado da condição sempre será verdadeiro.
Comando: do.. while
O comando do.. while é utilizada quando se quer que o corpo do laço seja executado pelo menos uma vez. A expressão de comparação é avaliada depois que o laço foi executado, enquanto ela for verdadeira os são repetidos.
Sintaxe:
do {
<comandos>
} while (<condição>);
Exemplos:
public class ExemploDoWhile {
public static void main(String[] args) {
int i=0;
do {
System.out.println("Contador é " + i);
} while(++i<10)
do {
System.out.println("Laço infinito.");
} while(true);
}
}
Assim como nos exemplos anteriores, o primeiro exemplo do comando do.. while imprime contadores de 0 até 9 e o segundo é um laço infinito, pois o resultado da condição sempre será verdadeiro. Embora a diferença entre os dois comandos while sejam mínimas, cada uma é utilizada em uma determinada ocasião.
Linguagens de alto nível implementam várias estruturas de controle do fluxo do programa para facilitar o desenvolvimento de programas e promover um melhor estilo de programação. Os comandos de seleção e repetição são mais empíricos do que os comandos tradicionais em linguagem de máquina.
Java possui duas instruções de desvio condicionais mais uma palavra reservada que não deve ser usada. Todas elas existem em várias outras linguagens e plataformas.
Comando: if
O comando if executa um trecho de código apenas uma vez, dependendo de sua condição. A sintaxe segue a sintaxe abaixo.
if ( <condição> ) {
<comandos>
} else {
<comandos>
}
A condição é uma expressão da linguagem java e pode ser qualquer conjunto de operações que retornem um valor booleano. Ex: (i > = 0) ou (a = = 5 & & b! = 5 | | c = = a) O ” comandos 1 ” e ” comandos 2 ” são um conjunto de um ou mais comandos da linguagem Java. No caso de ser apenas um comando o uso de {} não é necessário.
Se a condição for verdadeira o interpretador executará o ” comandos 1 ” caso contrário o bloco ” comandos 2 ” será executado. Exemplo:
public class ExemploIf {
public static void main(String[] args) {
int i = 8;
// If que dirá se o valor do i é igual a 1 ou igual a dois.
if (i \% 2)
System.out.println("Oito é divisível por dois");
else
System.out.println("Oito não é divisível por dois");
// Verifica se o nome é Vitor.
String nome = "Vitor";
if (nome.equals("Vitor")) {
System.out.println("Nome é Hachid");
} else {
System.out.println("Nome não é Hachid");
}
}
}
No primeiro if do exemplo é testado se o valor de i é divisível por 2, ou seja, se valor de i é par. Se for divisível, é impresso o texto Oito é divisível por dois, caso contrário é impresso o texto Oito não é divisível por dois na linha de comando.
No segundo exemplo é feito um teste para saber se a variável String nome é igual a Vitor. Em comparação de objetos sempre usa-se o método equals. Se o valor de nome for Vitor é impresso Nome é Vitor, caso contrário é impresso Nome não é Vitor.
Comando: switch
O comando switch é o mesmo do C e é semelhante ao case do Delphi. Permite selecionar o bloco de código a ser executado baseado no teste lógico de uma expressão. O switch é a forma evoluída para o if, podendo tratar mais de dois blocos de execução.
Sintaxe:
switch ( <expressão> ) {
case <valor1>:<comandos 1>
[break;]
case <valor2>:<comandos 2>
[break;]
case <valor3>:<comandos 3>
[break;]
case <valor4>:<comandos 4>
[break;]
...
default: <comandos default>
}
O comando switch executa a expressão e compara o valor encontrado com os valores: , , , etc. Quando encontra a igualdade ele executa o bloco de comandos daquele valor. A execução continuará até o final do switch ou até que ele encontre um break;. Exemplos:
public class ExemploSwitch {
public static void main(String[] args) {
int i = 2;
// Switch que irá imprimir na tela o valor 2
switch (i) {
case 1 : System.out.println("Valor de i é 1");
break;
case 2 : System.out.println("Valor de i é 2");
break;
case 3 : System.out.println("Valor de i é 3");
break;
default: System.out.println("Default");
}
// Switch que irá imprimir na tela o valor "Hachid"
String nome = "Vitor";
switch (nome.hashcode()) {
case "Vitor".hashCode() : System.out.println("Valor de nome é Hachid");
break;
case "Paulo".hashCode() : System.out.println("Valor de nome é Linus");
break;
default: System.out.println("Default");
}
}
}
Não é necessário utilizar as chaves ({}) para delimitar um bloco de comandos, pois o interpretador executará todos eles até encontrar um break ou o switch finalizar.
A única limitação do switch é que a deve retornar um valor numérico inteiro, qualquer um de seus quatro tipos primitivos. O switch não funciona com String, float, char e boolean por exemplo. E é por este motivo que no segundo switch do exemplo é utilizado o método hashcode (), que retorna um código inteiro único para cada String diferente.
Comando: goto
Há um consenso entre os desenvolvedores de software de que instruções goto devem ser usadas somente para criar estruturas de controle, de seleção ou repetição, caso elas não existam na linguagem trabalhada. E é exatamente por isso que, embora a palavra goto seja uma palavra reservada do Java, ela não pode ser utilizada, o compilador Java acusará erro se encontrá-la no código.
Os especialistas afirmam que o goto polui o código fonte e se não for utilizado adequadamente pode se tornar um problema maior do que o próprio software.
Este capítulo apresentará o extremamente necessário para a construção de qualquer sistema em Java. Declaração de variáveis, comandos de decisão, repetição e desvio de fluxo no programa. 4.1 Declaração e Inicialização de Variáveis
A declaração de variáveis em Java pode ser feita em qualquer local do código fonte desde que esteja dentro de uma classe. Quando a declaração da variável é feita globalmente, ou seja, na estrutura da classe, é dita que a variável é um atributo, caso contrário ela continua sendo chamada de variável. O escopo ou a vida de uma variável em Java dura de acordo com o bloco onde ela foi declarada. A variável é criada no primeiro acesso a ela e destruída após o interpretador sair do bloco de execução ao qual ela pertence. Em Java a declaração de variáveis é feita pelo tipo e depois um identificador. A declaração muitas vezes é acompanhada pela inicialização a qual acrescenta o sinal de atribuição e um valor literal ou variável.
A declaração de uma variável é feita no formato:
Tipo identificador [= valor_inicial];
Observando o exemplo 4.1 pode-se identificar várias maneiras de declarar inicializar tipos primitivos e objetos. Na linha 3 existe uma declaração simples, ela está criando uma variável byte e o valor de bt será 0. Na linha 4 há a declaração de três variáveis do tipo short: sht1, sht2 e sht3. Todas as três serão inicializadas com zero. Na linha 5 existe a declaração de um inteiro i e a sua inicialização atribuindo o valor 9 para a variável. Na linha 6 há duas variáveis sendo criadas: f1 e f2, ambas receberão o mesmo valor 98.76. Na última linha existe a declaração de uma variável de tipo complexa String. String é a classe que armazena uma cadeia de caracteres sem tamanho definido em Java. No exemplo, ela está sendo inicializada com a cadeia ” TESTE “. Exemplo:
public class DeclarandoVariáveis {
int atributo = 9; // Declarando uma variável global => Atributo.
public void main(String[] args) {
byte bt; // Declaração simples
short sht1, sht2, sht3; // Declaração múltipla
int i = 9; // Declaração e inicialização
float f1, f2 = 98.76 // Declaração e inicialização múltipla
String str = "TESTE" // Declaração e criação de um objeto String
}
}
Já foi apresentado o operador de atribuição ” = “. Porém este operador pode funcionar em conjunto com outros operadores reduzindo o tempo de processamento de determinadas chamadas. O operador de atribuição composto junta um operador aritmético ou de bitwise com o operador de atribuição. É sempre utilizado na sintaxe var = var como no exemplo abaixo:
public class OperadorAtribuicaoComposto {
public static void main (String [] args) {
int x = 1;
x + = 5;
}
}
Neste exemplo a variável inteira x é inicializada com 1 e na linha seguinte é realizado uma operação composta: A soma e atribuição. Esta instrução é semelhante a esta: x = x + 5;. O resultado em x será 6. Outros exemplos são:
public class OperadorAtribuicaoComposto {
public static void main (String [] args) {
int x = 1; // Atribui 1 a x
x += 5; // Equivalente a x = x + 5; x é igual a 6
x *= 2; // Equivalente a x = x * 2; x é igual a 12
x /= 2; // Equivalente a x = x / 2; X é igual a 6
x -= 3; // Equivalente a x = x - 3; x é igual a 3
x %= 5; // Equivalente a x = x % 5; x é igual a 3
x |= 4; // Equivalente a x = x | 4; x é igual a 7
x ^= 1; / / Equivalente a x = x ^ 1; x é igual a 6
x &= 255; / / Equivalente a x = x & 255; x é igual a 6
x <<= 2; / / Equivalente a x = x << 2; x é igual a 24
x >>= 4; // Equivalente a x = x > > 3; x é igual a 1
x >>>= 7; / / Equivalente a x = x > > > 7; x é igual a 0
}
}
Os operadores bitwise são aqueles que alteram o valor das variáveis em operações lógicas diretamente no processador, tornando-as muito mais performáticas. Estas operações são geralmente chamadas de ? tratamento por bits ? pois são operações que comparam e modificam a variável bit por bit.
Op Nome Uso Descrição ~ Inversão ~x Inversão dos bits de x. & E lógico x & y AND bit a bit entre x e y. | OU lógico x | y OR bit a bit entre x e y. ^ OU excl. lógico x ^ y XOR bit a bit entre x e y. << Desloc. a esq. x << y Desloc. a dir os bits de x, y vezes. >> Desloc. a dir. x >> y Desloca a direita os bits de x, y vezes. >>> Desloc. a dir. x >>> y Preenche zero a esquerda de x, y vezes.
Os operadores relacionais e lógicos são utilizados em testes e condições de entrada em um fluxo do programa. Abaixo estão todos eles relacionados.
Op Nome Uso Descrição
> Maior que x > y x maior que y.
>= Maior ou igual a x >= y x maior ou igual a y.
< Menor que x < y x menor que y
<= Menor ou igual a x <= y x menor ou igual a y.
== Igual a x == y x igual a y.
!= Diferente de x != y x diferente de y.
! NÃO lógico (NOT) !y contrário de y.
&& E lógico (AND) x && y x e y.
|| OU lógico (OR) x ||y x ou y.
instanceof Verif Instância x instanceof X x é instância da classe X
WebDrops 