Sobre o "." em JAVA

Java é uma linguagem orientada a objetos. O ponto significa dizer que você está usando algum membro de um objeto.

Por exemplo, se você tem a seguinte classe com métodos e atributos:

public class A {
  public void m1() {
  }

  public int x9() {
    return 9;
  }

  public long xpto;
}

Quando você cria um objeto da classe A, você pode executar (invocar/chamar) os membros públicos deste objeto, que são os métodos m1 e x9, além do atributo xpto, no caso desta classe. E é através do ponto que você faz relação do membro ao objeto ao qual ele pertence. Exemplo:

A objA = new A(); // criando um objeto da classe A
objA.m1(); // executando método m1 de objA
objA.x9(); // executando método x9 de objA
objA.xpto = 10L; // atribuindo valor ao atributo xpto de objA

Em C++, ao invés do ponto, é usado uma seta.

objX->metodoLegal();

Mas isso é uma outra história!

Muito obrigado pela explicação, ja me esclareceu bastante.

Mas e em relação a metodo().metodo() como isso acontece, saberia me explicar?

thiago189:

Muito obrigado pela explicação, ja me esclareceu bastante.

Mas e em relação a metodo().metodo() como isso acontece, saberia me explicar?

Isso se chama encadeamento de metodos, por exemplo, suponha que vc tenha essa classe “Cliente” que implementa um metodo chamado getNome() que retorna uma String.

public class Cliente {
      
     String name ; 

     public Cliente(String name ) {
         this.name = name ;
     }
   
     public String getNome() {
          return name ;
     }     

}

Se vc fizer agora :

Cliente cliente = new Cliente("Joazinho");

int size = cliente.getNome().length();

size vai conter o tamanho da String “joaozinho”.
Metodos encadeados sao executados da esquerda pra direita, ou seja, quando vc chamar cliente.getNome().length()
primeiro vai chamar o metodo getNome() que vai retornar uma String contendo o nome “joaozinho”, objetos do tipo String implementam o metodo length() por isso vc pode chamar o length logo apos getNome().

//Daniel

danieldestro:

Em C++, ao invés do ponto, é usado uma seta.

objX->metodoLegal();

Mas isso é uma outra história!

Só em caso de ponteiros. Normalmente, em objetos no stack e em referências (que, num programa bem estruturado, chegam a ser mais comuns que ponteiros), usa-se o ponto mesmo.

ViniGodoy:

danieldestro:

Em C++, ao invés do ponto, é usado uma seta.

objX->metodoLegal();

Mas isso é uma outra história!

Só em caso de ponteiros. Normalmente, em objetos no stack e em referências (que, num programa bem estruturado, chegam a ser mais comuns que ponteiros), usa-se o ponto mesmo.

Uma coisa que acho legal em C++ é que nada é o que parece - por exemplo, estarei usando algum ponteiro aqui?

std::string str = "Hello, world!";
for (std::string::const_iterator p = str.begin(); p != str.end(); ++p) {
    cout << *p;
}

A resposta simples é "não" , apesar de estar usando o operador "*" que normalmente é usado para desreferenciar ponteiros.

Apesar que se for pra escolher uma linguagem onde nada é o que parece, eu preferiria Ruby.

o ". " diz: invoca, chama o que vem apos ele… quando ver algo assim:

mulher.chamaomarido();

leia o objeto mulher chama o metodo marido…

flw!

thiago189:

Muito obrigado pela explicação, ja me esclareceu bastante.

Mas e em relação a metodo().metodo() como isso acontece, saberia me explicar?

como já falaram esse ponto e quando voce está usando algum membro de um objeto, até ai acho que tu já intendeu, mas a questão nesse caso do
metodo().metodo() e que o metodo anterior te retornar um objeto logo você pode usar algum membro ou operação dele tambem, derrepente pra facilitar o intendimento no inicio você pode usar uns parenteses a mais, para saber com qual objeto você esta lidando exemplo:

(Objeto1.getNome()).toString();

outro exemplo:

(Lista.getNome(“thiago”).getEndereco()).toUpperCase();

então e so pensar que o metodo ta fazendo a operação de algum objeto anterior,que foi um objeto criado pelo metodo anterior, neste ultimo exemplo:
um Objeto para guardar o endereço foi criado no momento que eu chamei getEndereço e ele me retornou uma String, e ele so vive dentro do escopo daquele parenteses, isso pode ser mais facil do que criar uma variavel, para referenciar um objeto que você não ira usar mais, metodo().metodo() e apenas uma facilitador para não ficar criando variaveis de referencia.

Acho que é por isso que a Sun é tão reticente quanto a sobrecarga de operadores em Java. Se você fizer direitinho, pode ser o céu. Se fizer errado, pode ser o inferno. Aliás, eu vi uma biblioteca para gráficos simples em C++, onde você podia usar uma sintaxe assim:

#include "koolplot.h" int main() { Plotdata x(-3.0, 3.0), y = sin(x) - 0.5*x; plot(x, y); return 0; }

Note que ficou uma notação bem matemática e muito limpa. Define-se x e depois y em função de x. Como você falou, nada é como parece. Os operadores criam novos objetos, a função de seno também. Esses objetos são usados pela função plot para efetivamente fazer o cálculo no futuro. O mesmo programa, em java, teria uma sintaxe rebuscada, no mínimo assim:

Plotdata x = new PlotData(-3.0, 3.0), y = PlotData.sin(x).minus(x.multiply(0.5));
   plotGraphic.plot(x, y);

Mas enfim… é um recurso que pode ser muito interessante se bem aproveitado (seria legal usar um ArrayList com a mesma notação de um vetor primitivo, tal como o std::vector, ou um map como um “vetor primitivo que aceita objetos no índice” como o std::map), mas certamente pode tornar o código bastante obscuro para quem lê e dá manutenção, especialmente quando os operadores fazem algo bem fora do padrão…

Agora, obscuro por obscuro… é só olhar os códigos esquisitos das fluent interfaces (não para quem usa, mas para quem mantém) e ver que recursos poderosos geralmente exigem programadores, no mínimo, bastante fuçadores.