Geralmente a primeira dica é a correta, entretanto devemos perder um tempinho analisando as outras. Um bom exemplo aconteceu comigo trabalhando com JDBC: Em determinado momento eu estava trabalhando com PreparedStatement e a dica do Eclipse, para os imports, era com.mysql.jdbc.PreparedStatement porém, naquele momento, me interessava o java.sql.PreparedStatement. Não prestei a atenção e o eclipse me pedia, estranhamente, um cast numa determinada linha aonde não precisava.

Detalhe que este import errôneo não iria prejudicar a minha classe naquele momento: ela funcionaria sem maiores problemas. O problema era uma dependência adicional com o driver mysql: eu teria problemas se quisesse migrar de banco. Um problema bem simples, bastaria corrigir a classe, mas que me faria perder algum tempo no futuro.

Sem falar que, pela lei de Murphy, esse problema poderia surgir quando ele fosse o mais devastador possivel.

public class A {        public static void main(String args[]) {            @Shared int acumulador = 0;

            {int => int } xxx  = { int i =>  acumulador += i; i};

            System.out.println(xxx.invoke(1));            System.out.println(xxx.invoke(2));            System.out.println(xxx.invoke(3));            System.out.println("o valor do acumulador eh " + acumulador );

        }}

Só eu estou achando divertido?

http://gafter.blogspot.com/2008/08/java-closures-prototype-feature.html

public class A {        public static void main(String args[]) {                exec( { int a, int b => a + b });                exec( { int a, int b => a * b });                exec( { int a, int b =>                         System.out.println("closure " + a + ":" + b);                         (a * a) + (b * b)                 });        }        public static void exec({ int, int => int } closure){                System.out.println(closure.invoke(3,2));        }}

$ java -Xbootclasspath/p:./closures-2008-08-04/lib/closures.jar   A56closure 3:213

Divertido

Fonte:
http://guj.com.br/posts/list/99477.java

Vejamos:
1) O número de faltas é acima do permitido?. Aqui entra um if dos bons com uma comparação numérica, quando um número é maior ou igual a outro.
2) A média é basicamente somar as X notas e dividir por X (se for média aritmética). Somar e dividir são operações matemáticas básicas.

Uma forma de fazer é:
if( numero_de_faltas > maximo_de_faltas_toleradas) {
// reprovado por faltas
} else if ( media_do_aluno < media_para_passar ){
// reprovado por nota
}
// se nem um nem outro, esta aprovado


O ruim dessa abordagem é que o aluno estar aprovado é uma condição “que sobra”. Se passarmos a focar a aprovação do mesmo ficaria assim:

if( media_do_aluno >= media_para_passar && numero_de_faltas <= maximo_de_faltas_toleradas) {
// aprovado!
} else {
// reprovado!
}

É claro que eu posso que eu posso querer saber o motivo pelo qual o aluno foi reprovado:

if( media_do_aluno >= media_para_passar && numero_de_faltas <= maximo_de_faltas_toleradas) {
// aprovado!
} else if(numero_de_faltas > maximo_de_faltas_toleradas){
// reprovado pelo número de faltas: ignoro a média.
} else {
// aqui só sobra a reprovação por nota,
// basta fazer a tabela-verdade dessas expressões
}

Se o foco do professor for o algoritmo, isso é o que deveria ser analisado. Quem implementa corretamente um método que recebe X notas e um número de faltas e consegue responder a essas perguntas consegue descrever facilmente os casos de teste para verificar se a implementação corresponde ao que se espera.

Um programa que tenha algum tipo de interação (seja Swing ou console) ajuda a fazer um macarrão de código, mesclando o algoritmo com o controle de estado dos “menuzinhos”. No fim vemos laços de repetição aonde não são necessários, calculo de média errado, etc.

Ok, não acho que um marinheiro de primeira viagem devesse começar por JUnit, mas uma com boa noção dos fundamentos da linguagem e evitando a interação desnecessária com o usuario (poderia ser usado até os parâmetros do main), acredito num melhor desempenho. O risco é o aluno acreditar que java é dificil ou que tudo se resume a getters/setters e gigantescos try/catch’s onde as exceptions são varridas pra debaixo do tapete.

Eu colocaria TDD num segundo momento, mas ai sem perdão, ensinando o caboclo a fazer do jeito certo o quanto antes. O que é dificil se eles conseguem passar sem saber fazer aritmética básica.

 public void testEhPar() throws Exception{  assertTrue("2 deve ser par",algoritmo.ehPar(2));  assertTrue("4 deve ser par",algoritmo.ehPar(4));  assertTrue("6 deve ser par",algoritmo.ehPar(6));

  assertTrue("1 NAO deve ser par",!algoritmo.ehPar(1));  assertTrue("3 NAO deve ser par",!algoritmo.ehPar(3));  assertTrue("5 NAO deve ser par",!algoritmo.ehPar(5));   }

Dentro de uma classe de teste, usando o framework JUnit, a leitura dessas linhas é a seguinte:

Eu tenho um objeto chamado algortimo.
A chamada algoritmo.ehPar(2) deve retornar true, pois 2 é par, e este método informa se o parâmetro informado é, ou não, par.
O método assertTrue recebe dois parâmetros: uma mensagem informando o significado deste teste, e o resultado do mesmo.

Se o método estivesse com algum problema e retornasse false, isso:

assertTrue(“2 deve ser par”,algoritmo.ehPar(2));

seria o mesmo que

assertTrue(“2 deve ser par”,false);

Logo, o teste falha, pois 2 deve ser par.

Esta é uma forma programática de garantir o comportamento do código que eu desenvolvo: testando. Se o meu método só depende dos parâmetros informados, é muito simples verificar o seu funcionamento.

Desenvolvendo os testes antes de implementar o código, tendo apenas as assinaturas dos métodos (por isso recorri a uma interface aqui, lembra?), eu posso pensar nos comportamentos esperados e, então, vou desenvolvendo até que todos os testes estejam passando.

Não é nada fácil, funciona melhor quando o projeto que estás desenvolvendo está começando, porém os resultados são excelentes: veja o quanto de tempo estás economizando! Se tu pretendes determinar se um código teu está funcionando por programas que perguntam os valores, escrever

$ ant clean test

é muito mais rápido!

O problema surge quando queremos fazer algo complexo, pois a dificuldade de testar mostra problemas na arquitetura adotada, por exemplo. Quanto temos objetos que tem objetos, herança, polimorfismo, tecnicas mais avançadas podem ser usadas como usar Mocks de objetos (e prover os mecanismos para injetar estes Mocks).

No caso desse exemplo, esta é uma solução:

public boolean ehPar(int numero){      return numero % 2 == 0;}

Muitos alunos desconhecem as operações de divisão e módulo entre inteiros. O 1, inteiro, dividido por 2, inteiro, não é 0.5, (em java), e sim 0, pois este é o resultado da divisão inteira. O resto da divisão, simbolizado por %, retorna 1. Dessa forma, o resto da divisão de um numero par por 2 é 0, caso contrario é um número inteiro. São operações básicas que precisam ser dominadas. Repare que eu fiz um código que funcione, não tentei nada mais maquiavélico que dê 0.0001 milissegundos mais rápido. Evite a otimização precoce.

Programar profissionalmente é uma tarefa de muita responsabilidade. Desenvolver testes para garantir a qualidade provê excelentes resultados a longo prazo.

Entretanto tão bizarro quanto são os exercícios propostos: um programa que leia pergunte 2 numeros e retorne a soma, ou um programa para calcular alguma coisa que pergunte ao usuário… perai, pergunte? Um programa perguntando? Como?

Este é o típico programa ‘interativo’ com o usuário. Quando não usa a entrada padrão (algo completamente misterioso para boa parte dos alunos), usam algum recurso SWING. Mas sera que ninguem pensa o quão PREJUDICIAL são estes exercícios?

Normalmente o aluno se preocupa com a apresentação do mesmo, fazendo frescuras de menuzinhos, asteriscos pra lá e pra cá… e o algoritmo que é bom nada. Sinceramente: dane-se os menuzinhos. Sabem quantos programas com menuzinhos e que vão perguntar alguma coisa pro usuario vcs vão fazer na vida profissional de vcs? 0! Zero! Nenhum!

Existem muitas formas de interação com o usuario, hoje em dia vc pode ter interfaces web, por exemplo. Eu acho que, num primeiro momento, a única interação com o usuario deveria ser escrever na tela. Nada mais que isso se o camarada não sabe o que significa um NullPointerException.

Exemplo pratico:

- Prepare um diretório para trabalhar (suponho que vc vai usar linux, senão deve ser facil portar este exemplo para outros sistemas operacionais).
- Crie um diretorio lib e copie o junit-4.4.jar pra lá (use o google pra baixar esse arquivo, se vc não conseguir saia do curso de informática).
- Crie a estrutura abaixo, ainda no diretório de trabalho:
src/java
src/test
- Instale o aplicativo ant (de novo o google te ajuda, alias vc tem algum JDK instalado, certo??).
- Crie um arquivo chamado build.xml no diretorio de trabalho.
- Baixe o arquivo ant-junit.jar daqui [ http://www.java2s.com/Code/Jar/ANT/Downloadantjunitjar.htm ] e copie o .JAR para ~/.ant/lib (se não existe, crie).

Agora vem a proposta: baseado nessa interface:

public interface Algoritmo{/* dado um numero, retorna true se for par */        boolean ehPar(int numero);/* calcula o valor absoluto ou modulo de um numero, ex: -1 vira 1, 1 vira 1 */int calculaModulo(int numero);/* calcula algum termo da série de fibonacci: se 0, mostra o primeiro, se 1 mostra o segundo...*/int calculaFibonacci(int elemento);/* calcula o fatorial do numero indicado */long calculaFatorial(int numero);}

Vais criar uma classe chamada, digamos, SuaClasse que implementa esta interface (percebeu que tudo deve ficar em src/java não é?). Não pense na implementação dessa classe ainda.

No diretorio src/test vc vai salvar esta classe:

import junit.framework.TestCase;

public class AlgoritmoTeste extends TestCase{ Algoritmo algoritmo; public void setUp(){  algoritmo = new SuaClasse(); }

 public void tearDown(){  algoritmo = null;   }

 public void testEhPar() throws Exception{  assertTrue("2 deve ser par",algoritmo.ehPar(2));  assertTrue("4 deve ser par",algoritmo.ehPar(4));  assertTrue("6 deve ser par",algoritmo.ehPar(6));

  assertTrue("1 NAO deve ser par",!algoritmo.ehPar(1));  assertTrue("3 NAO deve ser par",!algoritmo.ehPar(3));  assertTrue("5 NAO deve ser par",!algoritmo.ehPar(5));   }

 public void testCalculaModulo() throws Exception{  assertTrue("modulo de  3 deve ser 3",algoritmo.calculaModulo(3) == 3);  assertTrue("modulo de -3 deve ser 3",algoritmo.calculaModulo(-3) == 3);  assertTrue("modulo de  5 deve ser 5",algoritmo.calculaModulo(5) == 5);  assertTrue("modulo de -5 deve ser 5",algoritmo.calculaModulo(-5) == 5);   }

 public void testCalculaFibonacci() throws Exception{  assertTrue("elemento  0 da serie fibonacci deve ser   0",algoritmo.calculaFibonacci(0) == 0);  assertTrue("elemento  1 da serie fibonacci deve ser   1",algoritmo.calculaFibonacci(1) == 1);  assertTrue("elemento  2 da serie fibonacci deve ser   1",algoritmo.calculaFibonacci(2) == 1);  assertTrue("elemento  3 da serie fibonacci deve ser   2",algoritmo.calculaFibonacci(3) == 2);    assertTrue("elemento  4 da serie fibonacci deve ser   3",algoritmo.calculaFibonacci(4) == 3);  assertTrue("elemento  5 da serie fibonacci deve ser   5",algoritmo.calculaFibonacci(5) == 5);  assertTrue("elemento  6 da serie fibonacci deve ser   8",algoritmo.calculaFibonacci(6) == 8);  assertTrue("elemento  7 da serie fibonacci deve ser  13",algoritmo.calculaFibonacci(7) == 13);    assertTrue("elemento 11 da serie fibonacci deve ser  89",algoritmo.calculaFibonacci(11) == 89);  assertTrue("elemento 13 da serie fibonacci deve ser 223",algoritmo.calculaFibonacci(13) == 233);   }

 public void testCalculaFatorial() throws Exception{  assertTrue("Fatorial de  1 deve ser        1",algoritmo.calculaFatorial(1) == 1);  assertTrue("Fatorial de  2 deve ser        2",algoritmo.calculaFatorial(2) == 2);  assertTrue("Fatorial de  3 deve ser        6",algoritmo.calculaFatorial(3) == 6);  assertTrue("Fatorial de  4 deve ser       24",algoritmo.calculaFatorial(4) == 24);  assertTrue("Fatorial de  5 deve ser      120",algoritmo.calculaFatorial(5) == 120);  assertTrue("Fatorial de  6 deve ser      720",algoritmo.calculaFatorial(6) == 720);  assertTrue("Fatorial de 10 deve ser 3628800L",algoritmo.calculaFatorial(10) == 3628800L);   }}

Uma ideia sobre o JUnit pode ser encontrada aqui: [ http://guj.com.br/java.tutorial.artigo.40.1.guj ], alias o guj, na sessão de tutoriais, explica varias coisas, é ótimo material de referência!

Ok, vc tem a interface que vc deve respeitar e um arquivo de teste. Vamos falar do arquivo de build do ant.

<project name="Meu Projeto" basedir="." default="dist">        <description>                Aprendendo a fazer um build.xml para o ant        </description>

        <property name="lib"   location="lib"/>        <property name="src"   location="src/java"/>        <property name="test"  location="src/test"/>

        <property name="build" location="build"/>        <property name="dist"  location="dist"/>

        <path id="classpath.test">                 <pathelement location="${test}" />                <pathelement location="${build}" />                <pathelement location="${lib}/junit-4.4.jar" />        </path>

        <target name="init">                <!-- Create the time stamp -->                <tstamp/>                <!-- Create the build directory structure used by compile -->                <mkdir dir="${build}"/>        </target>

        <target name="compile" depends="init" description="compile the source " >                <!-- Compile the java code from ${src} into ${build} -->                <javac srcdir="${src}" destdir="${build}"/>        </target>

        <target name="dist" depends="compile" description="generate the distribution" >                <!-- Create the distribution directory -->                <mkdir dir="${dist}/lib"/>

                <!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file -->                <jar jarfile="${dist}/lib/Algortimo-${DSTAMP}.jar" basedir="${build}"/>        </target>

        <target name="clean" description="clean up" >                <!-- Delete the ${build} and ${dist} directory trees -->                <delete dir="${build}"/>                <delete dir="${dist}"/>        </target>

        <target name="test" depends="compile">                <javac srcdir="${test}">                        <classpath refid="classpath.test"/>                </javac>                <junit>                        <classpath refid="classpath.test" />                        <formatter type="brief" usefile="false" />                        <test name="AlgoritmoTeste"/>                </junit>        </target></project>

A utilização desse arquivo é muito simples, não se amedronte pelo tamanho do arquivo, o formato xml do ant é bizarro e verboso, sou muito mais um Makefile, porém uma vez com ele feito basta ir adicionando coisas “com cuidado”. Sem falar que tudo tem documentação oficial cheia de exemplos, só não aprende quem não quer.

$ ant
isso deve compilar a sua classe e gerar um jar (pode ser util no futuro).

$ ant clean
limpa os diretorios que vc acabou de criar com as suas paradas compiladas.

$ ant test
compila e executa os testes unítarios.

É claro que vc vai dizer, e agora??? Bom, veja isso:

public class SuaClasse implements Algoritmo{        public boolean ehPar(int numero){return false;}        public int calculaModulo(int numero){ return -1;}        public int calculaFibonacci(int elemento){return -1;}        public long calculaFatorial(int numero){return -1;}}

Olha que legal! Uma classe que tem o minimo pra compilar! Agora vamos testar…

$ ant testBuildfile: build.xml

init:    [mkdir] Created dir: /home/GLOBO.COM/peczenyj/test/junit/build

compile:    [javac] Compiling 2 source files to /home/GLOBO.COM/peczenyj/test/junit/build

test:    [javac] Compiling 1 source file    [junit] Testsuite: AlgoritmoTeste    [junit] Tests run: 4, Failures: 4, Errors: 0, Time elapsed: 0.005 sec    [junit]     [junit] Testcase: testEhPar(AlgoritmoTeste):        FAILED    [junit] 2 deve ser par    [junit] junit.framework.AssertionFailedError: 2 deve ser par    [junit]     at AlgoritmoTeste.testEhPar(Unknown Source)    [junit]     [junit]     [junit] Testcase: testCalculaModulo(AlgoritmoTeste):        FAILED    [junit] modulo de  3 deve ser 3    [junit] junit.framework.AssertionFailedError: modulo de  3 deve ser 3    [junit]     at AlgoritmoTeste.testCalculaModulo(Unknown Source)    [junit]     [junit]     [junit] Testcase: testCalculaFibonacci(AlgoritmoTeste):     FAILED    [junit] elemento  0 da serie fibonacci deve ser   0    [junit] junit.framework.AssertionFailedError: elemento  0 da serie fibonacci deve ser   0    [junit]     at AlgoritmoTeste.testCalculaFibonacci(Unknown Source)    [junit]     [junit]     [junit] Testcase: testCalculaFatorial(AlgoritmoTeste):      FAILED    [junit] Fatorial de  1 deve ser        1    [junit] junit.framework.AssertionFailedError: Fatorial de  1 deve ser        1    [junit]     at AlgoritmoTeste.testCalculaFatorial(Unknown Source)    [junit]     [junit]     [junit] Test AlgoritmoTeste FAILED

BUILD SUCCESSFULTotal time: 1 second

Agora basta escrever codigo de verdade na SuaClasse e testar, estara pronto quando TUDO estiver passando. São 4 métodos básicos, sabendo lidar com variaveis locais, if e for, vc consegue muita coisa.

Se eu fosse professor eu daria exercícios assim: o projeto deveria compilar e todos os testes deveriam passar senão o aluno leva 0. A nota viria de acordo com o que eu espero, posso usar um EMMA e ver a cobertura de código, posso avaliar a presença de um Javadoc que preste, etc.

Enfim, eu seria um professor muito malvado }-)

Não perca a parte 2 aqui, e uma introdução ao TDD aqui.

Ao meu ver o estudo da linguagem deveria focar o domínio do mecanismo de herança e a construção de classes, domínio dos métodos, tipos de retorno, escopos de variavel, conversão de tipos, domínio das estruturas condicionais, de loops e de tratamento de erros, domínio das operações matemáticas e lógicas e,principalmente, domínio da classe String (ok, domínio pode ser uma palavra forte, talvez uma boa noção fosse suficiente em algumas situações).

Com disso tudo, o aluno deveria primeiro trabalhar com argumentos de linha de comando (o que vc acha que o main recebe?), depois passar a estudar a leitura e escrita em arquivo texto e, por fim, leitura pela entrada padrão.

Pois leitura pela entrada padrão é o que vc menos vai fazer em Java. Ninguem faz programa com menuzinho em Java pra console no mercado. Temos coisas mais complexas pela frente e sem conhecer tudo aquilo que eu listei antes só é possivel fazer gambiarras (como as famosas class functions, gigantescos métodos que fazem centenas de coisas com nomes adequados do tipo createTree3).

Ensina-se Java ao contrário: primeiro o camarada programa como se fosse C, perdendo tempo em fazer menus e estruturas de controle pois o usuario pode ter dado um enter, tab, “ç” ou ter digitado algo inválido quando deveria aprender os fundamentos da linguagem. Cria-se vícios que pode ser custoso para remover (como encher o código de getters/setters sem necessidade). A prova disso é que invariavelmente temos comparação de Strings usando o operador == quando deveria ser utilizado os métodos adequados para isso (imagina o susto quando a galera descobre o equalsIgnoreCase).

Eu vejo muitos estudantes incapazes de compilar e executar uma classe (o famoso hello world) pois os mesmos nunca fizeram uso da linha de comando muito menos foram apresentados ao conceito de classpath. Vejo barbaridades típicas de quem não conhece (ou não sabe ler) o javadoc das classes básicas. Fico me perguntando quando esses jovens serão capazes de ler um “Effective Java”, por exemplo.

Aqui tem um excelente começo.

Espero que os professores acordem para essa realidade e que os alunos percebam que estão sendo prejudicados e passem a estudar por sua conta os tópicos necessários para sair arrasando pro ai.

Já aviso, estou tentando aprender e achei este exemplo interessante. Este post é uma tentativa de análise orientada à objetos feita de forma progressiva, comentários são bem vindos.

A primeira proposta foram 2 matrizes bidimensionais, uma com os professores disponíveis naquele dia e outra com as turmas, distribuidas ao longo de uma semana. Eu logo percebi que isso podia ser um problema de modelagem, pois se vc vai utilizar matrizes, paineis, interface textual ou seja lá o que for, isto é apenas uma camada – a visão. Um modelo muito mais rico pode ser criado, vejamos este exemplo em Java:

class Professor{}class Disciplina{}class Turma{ Disciplina disciplina; Professor  professor;}public class Main{ public static void main(String[] args) {  Professor  oseias     = new Professor();  Disciplina matematica = new Disciplina();  Turma matA = new Turma();

  matA.disciplina = matematica;  matA.professor  = oseias; }}

A minha classe Main mostra como seriam as operações sobre estas 3 classes. Basicamente eu tenho uma classe Professor, uma classe Disciplina e uma classe Turma. Se vc observarem qualquer instituição de ensino vão perceber que uma turma tem-um professor e tem-uma disciplina associados (composição).

Percebam também que eu não fui até uma escola ou universidade e fiquei horas levantando requisitos, criado diagramas uml ou documentos no word – apenas criei uma casca inicial de código (cheio de problemas por sinal). Também não me importo, ainda, com nenhum aspecto temporal. Sem falar que esta escola todos os professores podem dar qualquer disciplina – agora vamos implementar direito.

Vejamos… uma turma não troca de disciplina facilmente, mas de professor sim. Faz sentido, então, ter um setter de professor e um construtor que receba uma disciplina. Outra coisa, eu não defini nada nas outras classes, então está na hora de definir 2 atributos : id (numérico) e nome (String). Vou diferenciar os objetos pelo código, isto é, o seu id, e o nome será utilizado como descrição. Vou sobreescrever os métodos equals e toString.

Como o nome desses objetos é importante, vou coloca-los no construtor também (assim como o id).

class Professor{ long id; private String nome; public Professor(long id,String nome){  this.id = id;  this.nome = nome; } public long getId(){ return id; } public String toString(){ return this.nome ; } public boolean equals(Object o){  boolean test = false;

  if (!(o instanceof Professor))   test = super.equals(o);  else    test = ((Professor) o).getId() == this.id;   return test; } }class Disciplina{ long id; private String nome; public Disciplina(long id,String nome){  this.id = id;  this.nome = nome; } public long getId(){ return id; } public String toString(){ return this.nome ; } public boolean equals(Object o){  boolean test = false;

  if (!(o instanceof Disciplina))   test = super.equals(o);  else    test = ((Disciplina) o).getId() == this.id;   return test; }}class Turma{ long id; private String nome; private Disciplina disciplina; private Professor  professor; public Turma(long id, String nome,Disciplina disciplina){  this.id = id;  this.nome = nome;  this.disciplina = disciplina; } public void setProfessor(Professor  professor){  this.professor = professor; } public long getId(){ return id; } public String toString(){   return this.nome + " [" + this.disciplina          + "] c/ " + this.professor ;  } public boolean equals(Object o){  boolean test = false;

  if (!(o instanceof Turma))   test = super.equals(o);  else    test = ((Turma) o).getId() == this.id;   return test; } }public class Main { public static void main(String[] args) {  /* objetos bem comportados */  Professor  oseias     = new Professor(1L,"Oseias");  Disciplina matematica = new Disciplina(1L,"Matematica");  Turma matA = new Turma(1L,"Matematica A", matematica);  matA.setProfessor(oseias); 

  System.out.println("Professor  " + oseias);      System.out.println("Disciplina " + matematica);    System.out.println("Turma      " + matA);

  /* objetos mal comportados    * Sujeitos a NullPointerException    */  Professor juca = new Professor(2L,null);  Disciplina calculo = new Disciplina(2L,null);  Turma matB = new Turma(2L,"Matematica B", null);  matB.setProfessor(null); // nem precisava mas...  Turma matC = new Turma(3L,"Matematica C",calculo);    Turma matD = new Turma(4L,"Matematica D",calculo);  matD.setProfessor(juca);

  System.out.println("Juca?   " + juca);  System.out.println("Calculo?" + calculo);  System.out.println("matB?   " + matB);    System.out.println("matC?   " + matC);  System.out.println("matD?   " + matD); }}

Mas que raios eu estou fazendo? veja a saída desse programa:

Professor  OseiasDisciplina MatematicaTurma      Matematica A [Matematica] c/ OseiasJuca?   nullCalculo?nullmatB?   Matematica B [null] c/ nullmatC?   Matematica C [null] c/ nullmatD?   Matematica D [null] c/ null

Qual o significado? Bom... eu tenho uma forma razoavel de representar um professor, disciplina e turma, porém não é pratico, o construtor está gigante e, em muitas situações, eu posso ter parâmetros nulos, o que pode ser uma fonte de problemas. Existem muitas formas de refatorar estas classes, eu nem toquei no HashCode, enfim, tem muito pano pra manga.

Apresento a vcs o desenvolvimento em etapas, iterativo. Eu estou chutando requisitos aos poucos, é verdade, mas eu entrego um codigo testável e completo e cada ciclo. Com os usuarios testando esse código (nesse caso, uma API, mas enfim...) eu obtenho um feedback interessante. O que vc acha?

/** O Bope foi criado para atuar quando a policia perde o controle* E no rio de janeiro isso acontece com bastante frequencia*/class Bope{

 private String nome;  private int vitimas;

 public Bope(String nome){  this.nome = nome;  this.vitimas =0; }

 public void matou(int tantas_vitimas_agora){      this.vitimas = this.vitimas + tantas_vitimas_agora; }

 public int quantas_vitimas(){  return this.vitimas; }}

public class Programa{ public static void main(String [] xxx){  // Apresento o capitão nascimento  Bope capitao = new Bope("Capitao Nascimento");

  // quando o capitão sobe a favela, é pra matar, não pra morrer  capitao.matou(1000);

  // agora ele subiu o morro de novo, com ele não tem erro.  capitao.matou(2000);

  // e a farda dele não é azul, é PRETA  System.out.println("O Bope matou: " + capitao.quantas_vitimas()); }}

Entendeu? Não?

ENTÃO PEDE PRA SAIR, GUERREIRO!
TU É CORRUPTO, TEU LUGAR É COM .NET, É COM VB! JOCKEY DE IDE! PEDE PRA SAIR AGORA!

Iniciado pela Universidade das Filipinas e apoiado pela Sun Microsystems, nasce através do Java Research & Development Center, a iniciativa JEDI (Java Education and Development Initiative), em Fevereiro de 2005.

A partir desta data, o JEDI vem sendo desenvolvido como um projeto colaborativo, que conta com o apoio da comunidade Java em todo o mundo. Tem como principais objetivos o de melhorar a experiência do ensino e da aprendizagem; Aumentar a qualidade dos graduados em Ciência da Computação e Tecnologia da Informação (disponibilizando os materiais de seus cursos gratuitamente para quem se interessar); Aumentar o banco de especialistas em Java e, Fornecer serviços e produtos a altura das necessidades do mercado mundial.

Tecnologia Java

A tecnologia Java está presente, hoje, em 2 bilhões de dispositivos tecnológicos em todo o planeta – e também fora dele, já que podemos localizar dispositivos Java rodando até em Marte. Existem hoje, no mundo, cerca de 579 milhões de celulares com Java, 93 operadoras de telefonia móvel, 750 milhões de cartões SmartCard (do tipo JavaCard) distribuídos, 650 milhões de computadores pessoais e com 2 milhões de cópias da plataforma empresarial J2EE. Por isto, 68% das novas aplicações, hoje, são desenvolvidas em Java, que substituiu o C++ como a competência mais procurada pelos profissionais. É executado em múltiplas plataformas e em uma ampla gama de dispositivos, indo de um pequeno chip em SmartCards aos servidores dos Grandes Data Centers.

Demanda por Profissionais

Com tudo isso, existe hoje, uma demanda por 2 milhões de novos profissionais de TI a cada ano. Desenvolvedores Java, devem prover soluções nas mais diversas áreas de tecnologia. Torna-se crescente a necessidade, por exemplo, do desenvolvimento de soluções para aparelhos celulares que demandam uma integração com sistemas legados, de maneira a fornecer soluções corporativas. A partir disto, o conhecimento de Java e de sistemas abertos, são imprescindíveis para profissionais de TI.

Além da demanda, a tendência é um outro fator motivador para este mercado. No Brasil, esta aponta para direção de trabalhos realizados para clientes de fora do país – o outsourced. É crescente a procura por parte das organizações, o desenvolvimento de projetos baseados em tecnologia Java, distribuindo-se as aplicações desenvolvidas aqui pela Internet.

Todavia, a busca do mercado por esse perfil de profissional vai de encontro com a capacidade de fornecimento do conhecimento Java. O fato é que, o mercado tem dificuldade em encontrar desenvolvedores com competência nos fundamentos de Tecnologia da Informação, orientação a objetos, conhecimento e experiência em Java avançado, competência em comunicação e nas relações interpessoais.

A industria de software supre o despreparo dos profissionais formados pelo mercado, com a necessidade de re-treinamento interno dos novos contratados, muitos graduados sem conhecimento em TI. A grande maioria não tem uma certificação, que tem um valor adicional no mercado, especialmente para trabalhos executados fora do pais. Outro fator que colabora para o despreparo do profissional é fato do treinamento oficial Java da Sun ser relativamente caro e os programas de treinamento interno das empresas atuais serem pouco abrangentes. Disso resulta uma contratação de apenas 5% dos currículos recebidos nas empresas.

Academicamente o treinamento é, muitas vezes gratuito e de boa qualidade, é acessível. Contrastando, os professores não possuem experiência prática das demandas da indústria e não há, por parte de centros acadêmicos, a compreensão com respeito ás preocupações da industria de software, que não conseguem cobrir as necessidades que o mercado exige. Aliado a isso, está a dificuldade de alterar os currículos acadêmicos.

E o JEDI ?

O JEDI, entra neste contexto de forma totalmente gratuita para a comunidade e disponibiliza todo o acesso aos cursos e materiais. O aluno terá ao seu dispor manuais, slides de apresentação das aulas, provas, exercícios e material de referência e vídeo-aulas. Contando ainda com os softwares, o treinamento de instrutores, o acesso a suporte e a lista de discussão da comunidade.

Na Filipinas já existe uma estrutura acadêmica dividida em fases. Na primeira fase foram disponibilizados os cursos de Introdução a programação I (versão 1.3); Introdução a Programação II (versão 1.1) e Estruturas de Dados (versão1.1). Na segunda fase os cursos de Engenharia de software (versão 1.0); Desenvolvimento de aplicações móveis (versão 1.0); Programação Web (versão 1.0). Na terceira fase, os cursos de Web Services; Segurança em Java e Programação, modelagem e análise orientada à objetos. Completando quatro semestres de curso com: Sistemas operacionais; Gerenciamento de projetos orientados à objetos e Inteligência artificial. Todo este material está atualmente disponível para download, em Inglês, no site Java.net.

A comunidade JEDI tem contribuído bastante para o sucesso desta iniciativa, em todo o mundo existem mais de 80 pessoas contribuindo ativamente. Os treinamentos são realizados pelos membros do JEDI que conduzem os testes e recebem cada vez mais pessoas como voluntárias. O JEDI possui, atualmente, parcerias globais nas Filipinas através de JP Petines (Java champion), no Brasil através de Daniel deOliveira (Java champion), na França através de Vicent Brabant (Java champion) e de coordenações na Malásia, Tailândia, Singapura, Japão e Vietnam.

Hoje o JEDI concentra o maior número de membros nas Filipinas. Desde fevereiro de 2005 até abril de 2006 são 110 escolas – 10% de todas as universidades e faculdades das Filipinas aderentes ao programa; Foram realizados 13 treinamentos e formados 207 instrutores multiplicadores, que formaram 1.318 instrutores que atendem a 48.205 estudantes.

Países de Língua Portuguesa

O Brasília Java Users Group – DFJUG é responsável pela coordenação do JEDI em países de língua portuguesa. Angola, Cabo Verde, Guiné-Bissau, Brasil, Moçambique, Portugal, São Tomé e Príncipe; Timor Leste serão países que poderão fazer o treinamento em língua nativa, com todos os recursos que a iniciativa provê. O DFJUG possui mais de 9.900 membros e é totalmente baseado em trabalho voluntário, sem personalidade jurídica e patrocinado pelo Instituto CTS, OSCIP, voltada para a pesquisa e desenvolvimento de tecnologias de software, que fornece ao grupo apoio logístico, administrativo e jurídico.

Atualmente, o Brasil conta, segundo a SUN Microsystems, com 70 mil desenvolvedores Java e 43 grupos de usuários Java, com mais de 25 mil membros participantes. É através do apoio destes grupos distribuídos em todos os estados da nação que esta iniciativa espera se consolidar, para elevar o nível de aprendizado Java, provendo melhores profissionais para atender as exigências do mercado mundial.

Como participar do JEDI ?

No momento estamos trabalhando na tradução e adaptação do material utilizado na Filipinas. Um vez que este esteja concluído, os cursos poderão ser acessados pelo site. Ao concluir o processo cada aluno terá que fazer uma prova presencial para obter a sua certificação, que será oferecida agentes que serão certificados em todo Brasil.

O DFJUG necessita de pessoas para corrigir e dar opiniões sobre todo o material produzido e realizar testes de Stress no site aonde o JEDI será hospedado, isso é um trabalho que somente poderá ser realizado com o apoio de toda a comunidade javanesa existente no Brasil. Quem quiser participar da iniciativa, no Brasil, deve acessar a página do DFJUG (www.dfjug.org) e entrar em contato com o grupo. Junte-se a nós, participe no instrutor ou como aluno desta iniciativa, poderemos assim enriquecer o conhecimento da linguagem e difundi-la de uma forma totalmente gratuita, voluntária e colaborativa, no Brasil e em diversos paises de língua portuguesa, será seu trabalho e seu empenho que ajudará elevar o Brasil ao hall dos melhores desenvolvedores JAVA no mundo.