Concorda que o seu código primeiro executa essa linha

d1 *= (m + n);

pra depois executar essa?

d1 *=m;

Logo, como você passou o valor 3 para o atributo, fica assim:

d1 = 3

//primeira operação
d1 = d1*(3+3)

d1 = 18

//segunda operação
d1 = d1*3

d1 = 54

Olá Matheus,

foi a ordem com a qual ele executou as instruções que fez ele devolver 54. Se quiser, depois uma ferramenta de debug que você verá que ele vai executar exatamente este passo a passo que vou descrever abaixo.

Antes vamos supor que na verdade o código está assim

public class Classe1 {
    public float d1;

    public Classe1 (float p) {
        this.d1 = p;
    }
    public void metodo3 (float m, float n) {
        d1 *= (m + n);
    }
    public void metodo2 (float m) {
        this.metodo3(m, m);
        d1 *=m;
    }
    public void metodo1() {
        this.metodo2 (this.d1);
    }
}
class Program {
    static void Main (string[] args) {
        Classe1 c1 = new Classe1 (3);
        c1.metodo1();
        System.Console.WriteLine (c1.d1);
    }
}

Mudei o nome dos métodos para facilitar um pouco.

Primeiro quando o código roda new Classe1 (3), então o d1 ganhará o valor 3.

Ai chamar o método c1.metodo1(), como não recebe nenhum parâmetro, ele executa este código aqui:

public void metodo1() {
        this.metodo2(this.d1);
}

Este código chama o método2 passando como parâmetro valor de d1 que é 3 por enquanto. Então o método2 que ele executa é este aqui:

public void metodo2(float m) {
        this.metodo3 (m, m);
        d1 *=m;
}

Sendo que m então recebeu o valor 3. A primeira coisa que ele faz é chamar o metodo3 que recebe dois floats como parâmetro. Ambos ele passa o 3 do m para isso. Então ele está rodando o metodo3 agora:

 public void metodo3 (float m, float n) {
        d1 *= (m + n);
}

Sendo que o m e o n está com o valor 3. O que ele faz nesta linha é primeiro a soma de m + n, que dá 6. Então o que ele está fazendo depois seria um código assim d1 *= 6, que é a mesma coisa que d1 = d1 * 6. Como d1 está por enquanto com o valor 3, então o novo valor de d1 será 3 * 6. Ou seja, agora o valor de d1 passa a ser 18.

Como ele termina de executar o metodo3, então ele volta a executar o metodo2. O comando que falta ele fazer do metodo2 é d1 *=m, que é a mesma coisa que d1 = d1 * m. Como d1 está com o valor 18 e o m está com o valor 3, então o novo valor de d1 será 18 * 3. Pronto, o novo valor de d1 fica em 54.

Assim, ele termina de executar o metodo2 e o metodo1 e só imprime o valor no console.

Simplesmente lindoooooooooooo !!!!

vlww

Ordem das chamadas comentada.

public class Classe1 {
    public float d1;

    public Classe1 (float p) { //2
        this.d1 = p;
    }
    public void metodo1 (float m, float n) {
        d1 *= (m + n); //6
    }
    public void metodo1 (float m) {
        this.metodo1 (m, m); //5
        d1 *=m; //7
    }
    public void metodo1() { 
        this.metodo1 (this.d1); //4
    }
}
class Program {
    static void Main (string[] args) {
        Classe1 c1 = new Classe1 (3); //1
        c1.metodo1();  //3
        System.Console.WriteLine (c1.d1); //8
    }
}

E ai Matheus,

Tranquilo?

Vamos lá, por partes, você tem duas classes, Classe1 e Program, certo?

Ao iniciar o Program, você cria a variavel c1, ao fazer isso você chama o método público da Classe1 que alimenta a variável d1 com o valor passado, no caso 3,

Então temos d1 = 3.

Logo após isso você chama o metodo1, sem parâmetros, então você chama este método:

public void metodo1() {
        this.metodo1 (this.d1);
    }

Então por sua vez ele chama o outro metodo1 mas que recebe 1 parâmetro, neste caso o parâmetro d1, que vale 3.

Que por sua vez chama o outro metodo1 que recebe 2 parâmetros, e faz a seguinte conta:

public void metodo1 (float m, float n) {
        d1 *= (m + n);
    }

ou seja, d1 (que vale 3) recebe ele mesmo vezes (3 + 3) d1 agora é 18

E depois ele volta pro metodo1 com 1 parâmetro com o valor de d1 = 18, então d1 = d1 * 3 = 54 // CHEGAMOS NO NÚMERO!!!!

que por sua vez volta pro método que não tem parametro nenhum então ele continua com o processo do Program que chega na linha

System.Console.WriteLine (c1.d1);

Que acessa a classe c1, e mostra a variável d1, que tem o valor de 54 o/

Espero que tenha conseguido entender a lógica que eu já me perdi aqui hahahahahah mas é isso aí o/

ele entra em um método, e depois em outro, e depois em outro, e vai alimentando uma única variável.

Abraços