Histori Java

Prévia do material em texto

2
Programação Orientada a Objetos
Leonardo Vinícius Neves
leovinicius1992@gmail.com
Categoria de Classificação: Artigo Acadêmico
São Paulo
2015
Introdução
Este trabalho tem como o informativo falar mais a respeito da linguagem de programação Java, com o objetivo de passar orientações em ralação a historia, citando suas mudanças e dificuldades ao longo de seu período.
Discussão ampliada a respeito da história do Java, desde seus primórdios até os dias atuais, explore as dificuldades e as principais mudanças que ocorreram durante esse longo período de vida da linguagem.
Java é uma linguagem de programação orientada a objetos que começou a ser criada em 1991, na Sun Microsystems. Teve inicio com o Green Project, no qual os mentores foram Patrick Naughton, Mike Sheridan, e James Gosling. Este projeto não tinha intenção de criar uma linguagem de programação, mais sim de antecipar a “próxima onda” que aconteceria na área da informática e programação. Os idealizadores do projeto acreditavam que em pouco tempo os aparelhos domésticos e os computadores teriam uma ligação.
A primeira invenção desta equipe foi o *7 (StarSeven), um controle remoto com interface touchscreen, o aparelho tinha um “mascote” que ensinava o usuário a utilizar o controle. Um dos desenvolvedores do controle nomeou a linguagem de programação de Oak, o nome de uma árvore. Este controle foi um antecessor da ideia de interação digital, que esta presente nos televisores digitais atualmente, infelizmente a tecnologia da época não estava preparada para tamanho avanço.
Nesta época, a internet estava ficando cada vez mais popular, e a equipe do Green Project começou a pensar em aplicações para o Oak na internet, onde a palavra chave é interação. Eles conseguiram adaptar a linguagem Oak para a internet, e em 1995 foi lançado o Java, que era uma versão atualizada do Oak para a internet.
A tecnologia Java teve uma enorme utilização, e logo grandes empresas como a IBM, anunciaram que estariam dando suporte ao Java, ou seja, os produtos destas empresas iriam rodar aplicativos feitos em Java,. Estimativas apontam que a tecnologia Java foi a mais rapidamente incorporada na historia da informática. Em 2003 o Java já tinha mais de 4 milhões de desenvolvedores. A ideia inicial do Green Project começou a se concretizar. A linguagem deles passou a ser utilizada em dezenas de produtos diferentes. Computadores, celulares, palmtops, e a maioria dos produtos da Apple.
Em 2006 muitas partes do Java estavam sendo passadas para a licença de Software livre, e a maioria já estava disponível para o publico gratuitamente, tudo Sob licença GNU. O Java foi uma revolução na interatividade, sua utilização aumenta a cada dia. Java é uma linguagem relativamente simples e dinâmica, permite criar programas e aplicações para a Web sem depender de outra linguagem.
Dificuldades Java
A maior dificuldade em Java são os comandos de linha , por que maior parte deles e bem difícil de ser memorizados, pois acaba assustando com as ferramentas básicas que fazem parte do Java Development Kit (JDK). É extremamente importante que você aprenda essas ferramentas, pois elas te obrigam a entender algumas coisas que as ferramentas visuais acabam por esconder.
Mas para o desenvolvimento em Java existem dezenas de ferramentas, e entre elas existem ferramentas tão e até mais sofisticadas do que as ferramentas existentes para outras linguagens. 
Principais mudanças do Java
Melhoria no laço for
A primeira modificação que apresento é referente ao laço for. Um exemplo da sintaxe até o Java 2 para iterar num array ou coleção usando for pode ser vista abaixo:
 //Acessando um array de inteiros
 int[] a = {1,2,3,4};
 for (int i = 0; i < a.length; i++)
 {
 //utiliza os elementos do array
 }
 //Acessando uma coleção
 ArrayList<Color> b = new ArrayList<Color>();
 for(Iterator<Color> i = b.iterator(); i.hasNext(); )
 {
 //utiliza os elementos da coleção
 Color c = i.next();
 .
 } 
 
Desvantagens dessa sintaxe:
1. É mais trabalhosa do que necessitaria ser. A variável de iteração (i nos exemplos) ocorre três vezes em cada laço. A necessidade de escrevê-la várias vezes traz maior chance de se cometer erros. 
2. Considere o código:
 1 List stores = ...;
 2 List people = ...;
 3 List clientList = new ArrayList();
 4 for(Iterator<Store> i = stores.iterator(); stores.hasNext(); )
 5 for(Iterator<People> j = people.iterator(); people.hasNext())
 6 clientList.add(new Client(i.next(), j.next()));
Você consegue perceber o erro? O problema é que o método next() é chamado mais vezes do que deveria na coleção do “outer” loop. Na linha 6 o i.next() executa o mesmo número de vezes que o j.next(), o que é um erro de lógica. Uma forma de corrigir o problema é acrescentando uma variável intermediária para fixar o valor do “outer” loop:
 for(Iterator<Store> i = stores.iterator(); stores.hasNext(); )
 {
 Store aux = stores.next();
 for(Iterator<People> j = people.iterator(); people.hasNext())
 method1(aux, j.next());
 }
Com o novo for o código acima pode ser escrito da seguinte maneira:
 //Acessando um array de inteiros
 int[] a = {1,2,3,4};
 for (int i : a)
 {
 //utiliza os elementos do array
 }
 //Acessando uma coleção
 ArrayList<Color> b = new ArrayList<Color>();
 for(Color c : b)
 {
 //utiliza os elementos da coleção
 } 
O “:” pode ser lido como “em” e o laço todo como “para cada cor c em b”.
Vantagens:
1. Código mais simples e claro, conseqüentemente menos suscetível a erros.
2. O problema descrito acima, no item 2, passa a não existir. O novo código fica:
 for(Store store : stores)
 for(People p : people)
 clientList.add(new Client(store,p));
Limitações:
· Como um iterator não é declarado com o novo for não é possível escrever código para remover ou acrescentar elementos na coleção.
· Pelo mesmo motivo anterior, não é possível iterar em mais de uma coleção paralelamente.
Autoboxing
Não é possível atribuir diretamente um primitivo a um objeto de uma das classes wrapper ou mesmo para um objeto do tipo Object. Sendo assim, para atribuir um int a um Integer, fazemos:
 Integer num = new Integer(10);
 Object num = new Integer(10);
e para atribuir um Integer a uma variável do tipo int:
 int x = num.intValue();
Também não é possível inserir primitivos em coleções; pode-se inserir apenas objetos. Quando há a necessidade de inserir algum tipo primitivo, isso deve ser feito através de uma das classes de wrapper. Por exemplo:
 List<Integer> lista = new ArrayList<Integer>();
 lista.add(new Integer(10));
O novo mecanismo de autoboxing elimina a distinção entre um primitivo e um objeto permitindo que se faça a atribuição entre ambos livremente (respeitando-se é claro os tipos). O Java 5 automaticamente converte, quando necessário, tipos primitivos de um determinado tipo para seu wrapper equivalente (box) e vice-versa (unbox). Portanto, os códigos acima ficam da seguinte forma:
 Integer num = 10; //10 é convertido para Integer
 Object num = 10; //10 é convertido para Integer
 int x = num; //num é convertido para int
 List<Integer> lista = new ArrayList<Integer>();
 lista.add(10); //10 é convertido para Integer
O efeito disso é que em qualquer parte do código podemos tratar os primitivos e seus wrappers indistintamente. Observe mais um trecho de código:
 Boolean canMove = new Boolean(true); 
 if(canMove)
 { 
 System.out.println("This code is legal in Java 5!"); 
 }
O comando if espera por um primitivo do tipo boolean mas recebe um objeto Boolean. Não tem problema! O compilador irá fazer um unbox e gerar o código apropriado.
Enumerações
Uma enumeração é um tipo especialde classe que cria um novo tipo de dado com domínio pré-definido. Considere a declaração,
 enum Season {WINTER, SPRING, SUMMER, FALL}
a palavra reservada enum foi adicionada e permite definir tipos enumerados. Um tipo enumerado pode assumir apenas valores previstos e, ao mesmo tempo que possue um valor numérico, possue também um textual. Observe o código abaixo:
 1 Season s = Season.WINTER; 
 2 System.out.print(s); //imprime WINTER
 3 System.out.print(s.ordinal()); //imprime 0
 4 s = Season.SPRING; 
 5 System.out.print(s); //imprime SPRING
 6 s = 3; //erro pois espera receber algo do tipo Season
 7 for(Season aux : Season.values())
 8 System.out.print(aux); //imprime todos os valores da enumeração Season 
O tipo Season define as quatro estações do ano – WINTER, SPRING, SUMMER e FALL – enumerados de 0 a 3. Uma variável declarada como sendo do tipo Season pode assumir apenas valores deste domínio (typesafe). Para acessar o valor textual basta chamar o método toString() e para acessar o numérico o método ordinal(). Na linha 7 o método estático values() é chamado para retornar todos os valores de uma enumeração num array. Pode-se ainda adicionar dados e comportamentos a uma enumeração. O exemplo abaixo ilustra isso.
 public enum Planet
 {
 MERCURY (3.303e+23, 2.4397e6),
 VENUS (4.869e+24, 6.0518e6),
 EARTH (5.976e+24, 6.37814e6),
 MARS (6.421e+23, 3.3972e6),
 JUPITER (1.9e+27, 7.1492e7),
 SATURN (5.688e+26, 6.0268e7),
 URANUS (8.686e+25, 2.5559e7),
 NEPTUNE (1.024e+26, 2.4746e7),
 PLUTO (1.27e+22, 1.137e6);
 private final double mass; // in kilograms
 private final double radius; // in meters
 Planet(double mass, double radius)
 {
 this.mass = mass;
 this.radius = radius;
 }
 public double mass() { return mass; }
 public double radius() { return radius; }
 //universal gravitational constant (m3 kg-1 s-2)
 public static final double G = 6.67300E-11;
 public double surfaceGravity()
 {
 return G * mass / (radius * radius);
 }
 
 public double surfaceWeight(double otherMass)
 {
 return otherMass * surfaceGravity();
 }
 }
Cada planeta conhece sua massa e seu raio (mass e radius) e pode calcular a gravidade (surfaceGravity) em sua superfície e o peso (surfaceWeight) de um objeto no planeta. O código abaixo recebe o peso de algum objeto na Terra e calcula e imprime este peso nos demais planetas.
 public static void main(String[] args)
 {
 double earthWeight = Double.parseDouble(args[0]);
 double mass = earthWeight/Planet.EARTH.surfaceGravity();
 for(Planet p : Planet.values())
 System.out.printf("Your weight on %s is %f%n",p, 
 p.surfaceWeight(mass));
 }
 $ java Planet 175
 Your weight on MERCURY is 66.107583
 Your weight on VENUS is 158.374842
 Your weight on EARTH is 175.000000
 Your weight on MARS is 66.279007
 Your weight on JUPITER is 442.847567
 Your weight on SATURN is 186.552719
 Your weight on URANUS is 158.397260
 Your weight on NEPTUNE is 199.207413
 Your weight on PLUTO is 11.703031
Por fim, é possível ainda criar métodos particulares para cada uma das constantes de uma enumeração. Para isso, pode-se declarar um método abstrato e sobrescrevê-lo com um método concreto em cada uma das constantes. Segue um exemplo dessa abordagem.
 public enum Operation
 {
 PLUS { double eval(double x, double y) { return x + y; } },
 MINUS { double eval(double x, double y) { return x - y; } },
 TIMES { double eval(double x, double y) { return x * y; } },
 DIVIDE { double eval(double x, double y) { return x / y; } };
 // Do arithmetic op represented by this constant
 abstract double eval(double x, double y);
 }
Varargs
Em versões passadas da linguagem, para que um método pudesse receber um número arbitrário de valores era necessário passá-los num array como argumento do método. Ainda é verdade que múltiplos argumentos são passados em um array, mas no Java 5 isso é automatizado e transparente para o usuário. O método format da classe MessageFormat, por exemplo, possui a seguinte declaração:
 public static String format (String pattern, Object... argumentos);
Os três pontos no final do último parâmetro indica que o último argumento pode ser passado como um array ou uma sequencia de valores. Varargs podem ser usados apenas como último argumento de um método.
Static Import
Para acessar membros estáticos de uma classe é necessário qualificar as referências com o nome da classe onde estes estão declarados. Veja o código abaixo por exemplo,
 double r = Math.cos(Math.PI * theta);
os elementos estáticos da classe Math só podem ser referenciados através do nome da classe. A importação estática permite acesso direto a estes da seguinte forma:
 import static java.lang.Math.PI;
para disponibilizar apenas um elemento, ou
 import static java.lang.Math.*;
para disponibilizar todos os elementos estáticos de uma classe. Uma vez feito isso, o código inicial pode ser escrito da seguinte forma:
 double r = cos(PI * theta);
Algumas considerações devem ser observadas na utilização do static import. Utilize este artifício apenas quando for requerido acesso muito freqüente a membros estáticos de uma ou duas classes. A utilização em excesso poluirá o espaço de nomes do seu programa e tornará seu código menos legível. Ficará difícil distinguir a qual classe uma variável estática pertence. A importação de todos os membros estáticos de uma classe é particularmente problemático; se você precisa apenas de um ou dois elementos importe-os individualmente.
Desenvolvimento 
O desenvolvimento deste trabalho teve um certo nível de complexidade, pelo seu período de tempo de entrega, mas muito informativo, pois o mesmo ajudou muito a solucionar duvidas frequentes. 
 
Conclusão
Das linguagens em análise, e Java, poderemos concluir que são bastante similares nas funcionalidades de alto nível que implementam, embora o façam de formas distintas. Todas são linguagens adequadas ao desenvolvimento de agentes de software, permitem o desenvolvimento de código robusto e portável, implementam mecanismos de segurança, comunicação, de invocação remota de programas ou objetos e de migração de agentes entre computadores de uma rede.
Numa análise mais detalhada das funcionalidades próprias de cada linguagem são notórias algumas vantagens da linguagem Java. Desde logo, permite a criação de processos responsáveis pela execução de tarefas em paralelo com o processo inicial o que entre outras vantagens permite a resposta a eventos múltiplos de um sistema. Permite o desenvolvimento e integração de componentes (módulos) numa aplicação o que disponibiliza a reutilização de código já implementado e testado em diferentes aplicações. A integração do motor Java nos navegadores da Internet (browsers) é outro ponto a favor desta linguagem já que evita que o utilizador tenha de instalar o ambiente de execução Java.
 
Referencias
 
Devmedia, 2014
http://www.devmedia.com.br/java-historia-e-principais-conceitos/25178 
Wikipedia ,2014
http://pt.wikipedia.org/wiki/Java_%28linguagem_de_programa%C3%A7%C3%A3o%29, 
Olhar digital ,2013
http://olhardigital.uol.com.br/noticia/linguagem-java-um-pouco-de-historia/35728 ,