When I use object.method (). method ()? [closed]

In a nutshell whenever the method returns an object it will allow it to be accessed through the dot.

For example:

I have this first class here, the Dog class, which will have as attributes a name of type String, an age of type int and finally an object of type Owner. This donoDoCachorro attribute will behave the same as the other attributes, being able to access its properties, also note that the name is also an object, since the String is an object. After having understood this, we will soon see a builder who receives a Owner object and a barking method, this method will only print on the "Au Au" screen.

public class Cachorro{
   String nome;
   int idade;
   Dono donoDoCachorro;

   public Cachorro(Dono dono){
       this.donoDoCachorro = dono;
   }

   public void latir(){
      System.out.println("Au Au");

   }
}

Remember that in the Puppy class we had a Dono attribute? Well, that's his class. It has several attributes, such as name, phone, age all of type String, just below has a default constructor and then a display method, which will print the name and age of the owner.

public class Dono{
   String nome;
   String idade;
   String telefone;
   String endereco;

   public Dono(){

   }

   public void apresentar(){
      System.out.println("Olá, meu nome é " + nome + " tenho " + idade " 
                          anos, tudo bem com você?");
   }
}

Well done and explained both classes, we will instantiate it (create the classes). in the first lines you created a Owner object and instanced it, and then created a dog object that also instantiated only this time passed as an owner argument. I hope you have understood so far.

public class Teste{
   public static void main(String[] args){

      Dono dono = new Dono();
      Cachorro rex = new Cachorro(dono);

      // Agora queremos fazer o cachorro latir, para isso devemos chamar o
      // nome do objeto Cachorro que chamamos de rex, e depois através do 
      // ponto ( . ) acessar os métodos e atributos daquele objeto.

      // veja que acessamos o método latir do cachorro, mas também podemos
      // acessar atributos através do ponto.
      rex.latir();

      // Digamos que queremos sabe a idade do cachorro, basta chama o nome 
      // do objeto, colocar ponto ( . ) e depois colocar o nome do atributo.
      // nesse caso não precisa de parenteses, já que estamos acessando um
      // atributo e não um método.
      rex.idade;

      // Agora queremos acessar o atributo dono do objeto cachorro,
      // lembra-se que esse esse atributo é um objeto? bom prossigamos.
      rex.dono;

      // Bom já acessamos o atributo dono do rex. Mas o atributo dono é 
      // um objeto, isso que dizer que todo vez que estivemos acessando 
      // um atributo que seja um objeto ou um método que retorne um objeto
      // podemos acessar suas propriedades.

      // Por exemplo depois que acessei o atributo dono do rex, quero
      // que o dono se apresente.
      rex.dono.apresentar();

   }
}

We can do this infinitely, and through methods and attributes.

For example like this:

objeto.metodo().metodo().metodo();

or so:

objeto.atributo.objeto();

or even so:

objeto.atributo.objeto().atributo.objeto().atributo;

Remember everything that is object or return object you can do this. the scenario is it will tell you when and how you should use it this way, for example in the code we made we wanted to access the owner attribute of the dog object. and then access the submit method of the owner attribute. There is no rule for this, only practice will tell you this.

This is called method chaining.

It can be used to give more clarity in the code and to use you need each method to return an instance of the object that has, in turn, the method to be called in the sequence. For example:

class Pessoa {

 private String nome;
 private int idade;
 private String profissao;

 public Pessoa setNome(String nome) {
  this.nome = nome;
  return this;
 }

 public Pessoa setIdade(int idade) {
  this.idade = idade;
  return this;
 }

 public Pessoa setProfissao(String profissao) {
  this.profissao = profissao;
  return this;
 }
}

Each of the methods, after being called, returns an instance of the class itself, and that is what allows us to chain (ie, call in sequence) the methods we want.

In our code we would use this:

Pessoa pessoa = new Pessoa().setIdade(30).setNome("Maria").setProfissao("Programadora");