Oracle revela planos de longo prazo para o Java

Assuntos Gerais Notícias
#41

O C# já faz isso hoje. Você pode fazer coisas como:

…[/quote]
Seria interessante que colocassem algo como inferência de tipos, mais ou menos como temos em Scala. Assim o tipo a ser retornado seria o tipo requerido, sendo chamado o método de conversão mais conveniente.

[/quote]

tipo uma conversão implícita? como fazem nas sobrecargas de operadores?[/quote]
Parecido com isto. No caso de Scala pode não ser indicado o tipo, sendo este inferido a partir do tipo do dado que está sendo recebido:

Como em Java o tipo deve ser indicado ele poderia ser usado para escolher uma função de conversão apropriada do lado direito da expressão. Assim:

poderia ser escrito como:

Mas qual a vantagem disso:

em relação a isso?

#42

[quote=juliocbq]

Mas qual a vantagem disso:

em relação a isso?

Na verdade o primeiro codigo criaria uma variável String o segundo cria uma variável int (pois ele infere que 10 é um inteiro).

#43

[quote=AbelBueno][quote=juliocbq]

Mas qual a vantagem disso:

em relação a isso?

Na verdade o primeiro codigo criaria uma variável String o segundo cria uma variável int (pois ele infere que 10 é um inteiro).[/quote]
Sim, mal qual a vantagem de um em relação ao outro?

Pra mim parecem funcionar da mesma maneira.

#44

Na verdade para algo simples assim, não faz muita diferença mesmo.

Quando você tem declarações mais complexas (Map de Map) ou aproveitar diretamente o retorno de uma função para definir o tipo, só digitar menos já começa a compensar.

Um exemplo mais prático é a possibilidade de tipos anônimos.

Em scala você pode fazer algo assim:

  val objetoSemTipo = new Object() {  def falaOi = println("oi")  }

  objetoSemTipo.falaOi
  objetoSemTipo.falaOi

No Java, você não consegue chamar o método falaOi, sem definir uma classe para isso.
Aqui o var vai capturar que é uma classe anônima e dar acesso a todos os métodos que definir nela.

O .NET faz uso disso no Linq, se não me engano, para montar objetos com o resultado das queries.

#45

Pois é, isso ajuda em situações muito específicas. Na grande maioria das situações, não muda quase nada.

#46

Na verdade para algo simples assim, não faz muita diferença mesmo.

Quando você tem declarações mais complexas (Map de Map) ou aproveitar diretamente o retorno de uma função para definir o tipo, só digitar menos já começa a compensar.

Um exemplo mais prático é a possibilidade de tipos anônimos.

Em scala você pode fazer algo assim:

  val objetoSemTipo = new Object() {  def falaOi = println("oi")  }

  objetoSemTipo.falaOi
  objetoSemTipo.falaOi

No Java, você não consegue chamar o método falaOi, sem definir uma classe para isso.
Aqui o var vai capturar que é uma classe anônima e dar acesso a todos os métodos que definir nela.

O .NET faz uso disso no Linq, se não me engano, para montar objetos com o resultado das queries.
[/quote]

eu entendi seu ponto de vista. mas há um problema implícito nisso.

vejamos!

ficaria assim:

a1 = SeuFactory.CreateObjfalaOi(); a1.falaOi;

correto?

imagine agora o código maior

[code]
a1 = SeuFactory.CreateObjfalaOi(“ptbr”);
a1.falaOi;

aI = SeuFactory.CreateObjfalaOi(“eng”);
a1.falaOi;[/code]

teve algum erro ai? o compilador perceberia?

no java hoje não teria esse risco. pq a sintaxe distingue mt bem o q é declaração do q é apenas uso.

ou seria:

ou seria:

mas eu concordo com vc q ajudaria se pudesse ter a tipagem na declaração implicita. tipo o with do pascal.
pq o with passa o contexto baseado no retorno e não na declaração.

#47

Na verdade daria erro de compilação pois a variável al não foi declarada.
A declaração continua obrigatória, o que é opcional é você deixar explícito o tipo.

Se você quiser, pode especificar o tipo também:

val  a:String = "uma string" 
val b = "outra string"

O scala é estaticamente tipado, assim como o Java.
Não tem esse risco de usar variáveis que não existem por engano.

#48

mas no java o q indica q é declaração é justamente o tipo.
se omitir o tipo, só sobra o

xx = qqCoisa;

ou entendi errado?

como ficaria a declaração “sem tipo” no java?

#49

[quote=GilsonNunes]mas no java o q indica q é declaração é justamente o tipo.
se omitir o tipo, só sobra o

xx = qqCoisa;

ou entendi errado?

como ficaria a declaração “sem tipo” no java?[/quote]

Para esse tipo de recurso é criada uma palavra reservada para declarar variaveis.

Em C# é usado o "var"
Em Scala, você pode usar “var” para variaveis normais e “val” para variaveis que não podem ser reatribuidas (estilo final do java)

#50

ai sim!!

e apesar de alguns terem dito q não via vantagem nisso, creio q existe sim, uma q poderia destacar, é o fato de assim não ser necessário os “imports”.

#51

[quote=GilsonNunes]ai sim!!

e apesar de alguns terem dito q não via vantagem nisso, creio q existe sim, uma q poderia destacar, é o fato de assim não ser necessário os “imports”.[/quote]

e como funcionaria isso?

#52

Não gostei da mudança de tipos primitivos para Objetos (forçadamente), pra mim poderiam mesmo era criar uma cópia de todos os Objetos que podem ser primitivos em primitivos para que possamos escolher.

até String virar string, nem sempre queremos tratar uma String apenas salvar um texto nela.

Imagine a piora no processamento eu usar assim;

Integer x;
for(x=0, x < 10000; x++)

:shock: :shock: :shock: :shock: :shock: :? :? :?

#53

[quote=namor]
Imagine a piora no processamento eu usar assim;

Integer x;
for(x=0, x < 10000; x++)

:shock: :shock: :shock: :shock: :shock: :? :? :? [/quote]

Se internamente a máquina virtual entender a sua necessidade e trabalhar esse código como um tipo primitivo, não vejo problemas.

#54

[quote=marcosalex][quote=namor]
Imagine a piora no processamento eu usar assim;

Integer x;
for(x=0, x < 10000; x++)

:shock: :shock: :shock: :shock: :shock: :? :? :? [/quote]

Se internamente a máquina virtual entender a sua necessidade e trabalhar esse código como um tipo primitivo, não vejo problemas.[/quote]

sim, é tudo uma questão de “compilador bom”. Você pode ter até uma linguagem de extremo alto nível, sendo o compilador bom o suficiente pra otimizar tudo isso.
O problema é o custo do software, desse jeito precisa de mais memória ram, e o java é a plataforma mais custosa que existe atualmente.

#55

[quote=juliocbq][quote=marcosalex]
Se internamente a máquina virtual entender a sua necessidade e trabalhar esse código como um tipo primitivo, não vejo problemas.[/quote]

sim, é tudo uma questão de “compilador bom”. Você pode ter até uma linguagem de extremo alto nível, sendo o compilador bom o suficiente pra otimizar tudo isso.
O problema é o custo do software, desse jeito precisa de mais memória ram, e o java é a plataforma mais custosa que existe atualmente.[/quote]

Entendo.
Falar nisso, todo mundo aqui já está usando a versão 7 do Java?

#56

[quote=juliocbq][quote=GilsonNunes]ai sim!!

e apesar de alguns terem dito q não via vantagem nisso, creio q existe sim, uma q poderia destacar, é o fato de assim não ser necessário os “imports”.[/quote]

e como funcionaria isso?[/quote]

simplesmente a declaração sendo implícita.

vejamos:

import PacoteFalantes;
...
...
...
ClassFala a1 = SeuFactory.CreateObjfala("ptbr");  
a1.falaOi;  
a1.falaOla;  
a1.falaFui;  
  
a1 = SeuFactory.CreateObjfala("eng");  
a1.falaOi;  
a1.falaOla;  
a1.falaFui;

se não fosse a declaração:

SeuFactory.CreateObjfala("ptbr").falaOi;  
SeuFactory.CreateObjfala("ptbr").falaOla;  
SeuFactory.CreateObjfala("ptbr").falaFui;  
  
SeuFactory.CreateObjfala("eng").falaOi;  
SeuFactory.CreateObjfala("eng").falaOla;  
SeuFactory.CreateObjfala("eng").falaFui;

assim não precisaria do import, aja vista, não houve referencia explicita à classe.
mas ai teve chamadas a CreateObjfala excessivamente e erradamente
no pascal vc poderia fazer assim:

with SeuFactory.CreateObjfala("ptbr") do
begin
  falaOi;  
  falaOla;  
  falaFui;  
end;

with SeuFactory.CreateObjfala("eng") do
begin
  falaOi;  
  falaOla;  
  falaFui;  
end;

então, segundo a sugestão, creio q ficaria assim:

with a1 = SeuFactory.CreateObjfalaOi("ptbr");  
a1.falaOi;  
a1.falaOla;  
a1.falaFui;  
  
with a1 = SeuFactory.CreateObjfalaOi("eng");  
a1.falaOi;  
a1.falaOla;  
a1.falaFui;
#57

Eu gosto para isso aqui:

Que pode estar substituindo isso aqui:

No C++, a palavra chave auto faz essa declaração.

#58

Muito boa. O “with” realmente deveria ser parte integrante para evitar rechear o código daquela maneira.

#59

[quote=juliocbq][quote=GilsonNunes]

simplesmente a declaração sendo implícita.

vejamos:

import PacoteFalantes;
...
...
...
ClassFala a1 = SeuFactory.CreateObjfala("ptbr");  
a1.falaOi;  
a1.falaOla;  
a1.falaFui;  
  
a1 = SeuFactory.CreateObjfala("eng");  
a1.falaOi;  
a1.falaOla;  
a1.falaFui;

se não fosse a declaração:

SeuFactory.CreateObjfala("ptbr").falaOi;  
SeuFactory.CreateObjfala("ptbr").falaOla;  
SeuFactory.CreateObjfala("ptbr").falaFui;  
  
SeuFactory.CreateObjfala("eng").falaOi;  
SeuFactory.CreateObjfala("eng").falaOla;  
SeuFactory.CreateObjfala("eng").falaFui;

assim não precisaria do import, aja vista, não houve referencia explicita à classe.
mas ai teve chamadas a CreateObjfala excessivamente e erradamente
no pascal vc poderia fazer assim:

with SeuFactory.CreateObjfala("ptbr") do
begin
  falaOi;  
  falaOla;  
  falaFui;  
end;

with SeuFactory.CreateObjfala("eng") do
begin
  falaOi;  
  falaOla;  
  falaFui;  
end;

então, segundo a sugestão, creio q ficaria assim:

with a1 = SeuFactory.CreateObjfalaOi("ptbr");  
a1.falaOi;  
a1.falaOla;  
a1.falaFui;  
  
with a1 = SeuFactory.CreateObjfalaOi("eng");  
a1.falaOi;  
a1.falaOla;  
a1.falaFui;

[/quote]

Muito boa. O “with” realmente deveria ser parte integrante para evitar rechear o código daquela maneira.[/quote]

O comando with realmente faz falta, não apenas esse comando, mais vários outros.

Oracle vamos agilizar as novas features…,

#60

Interessante a idéia do with :smiley:
Talvez dê para simular isto usando as features do projeto lambda.