Alguem sabe explicar?

Não sei se compreendi bem a sua dúvida, mas vamos lá.
Tente aplicar o teste o é um… (is a…).

Aplicando ao seu exemplo:

Trebble t2 = new Trebble();

Trebble é um Trebble, portanto a atribuição é válida.

Base b2 = (Base) t2;

Treble não é um Base, portanto a conversão é inválida, embora Base seja um Trebble.

Central c2 = (Central) b2;

Base não é um Central, portanto a conversão também é inválida.

E porque assim funciona ?

public void wynyard() {  
     Trebble t = new Central();  
     Base b = (Base) t;  
     b.name();  
  }

-> Trebble nao é um Base, Base é um Trebble

Por que nao da erro de Cast ?

javaAurelio:

E porque assim funciona ?

public void wynyard() {  
     Trebble t = new Central();  
     Base b = (Base) t;  
     b.name();  
  }

-> Trebble nao é um Base, Base é um Trebble

Por que nao da erro de Cast ?

Funciona por que Central é um Base.
O cast vai tentar converter a referência para o objeto instanciado, que no caso é do tipo Central, para uma referência do tipo Base. No caso, o objeto instanciado é do tipo Central, como Central extende Base, Central é um Base, e a conversão ocorre normalmente.

Trebble t = new Central();   // certo, Trebble é a super classe de Central, sendo que referenciando Trebble com o objeto Central sendo criado
Base b = (Base) t;   // Cast de t que é o objeto(Central) sendo transformado em base, ja que Base é pai e Central extends Base, ta ok, esta transformando um filho no pai, um filho em algum dia pode ser um pai, mais um pai não pode volta a ser filho.

Trebble t2 = new Trebble(); // vai contra a OO mais ta blz.
Base b2 = (Base) t2; //  ta dando cast(transformando) t2 que é uma super classe em uma classe filha(subclasse) chamada base, base é um Trebble, base extends Trebble, base é filho(subclasse) de Trebble(superclasse). um pai(Trebble) nunca vai se transformar em um filho(base).

Me corrijam se estiver errado, esse assunto esta meio vago ainda na minha mente.

taaqui:

Trebble t = new Central();   // certo, Trebble é a super classe de Central, sendo que referenciando Trebble com o objeto Central sendo criado
Base b = (Base) t;   // Cast de t que é o objeto(Central) sendo transformado em base, ja que Base é pai e Central extends Base, ta ok, esta transformando um filho no pai, um filho em algum dia pode ser um pai, mais um pai não pode volta a ser filho.

Trebble t2 = new Trebble(); // vai contra a OO mais ta blz.
Base b2 = (Base) t2; //  ta dando cast(transformando) t2 que é uma super classe em uma classe filha(subclasse) chamada base, base é um Trebble, base extends Trebble, base é filho(subclasse) de Trebble(superclasse). um pai(Trebble) nunca vai se transformar em um filho(base).

Me corrijam se estiver errado, esse assunto esta meio vago ainda na minha mente.

Acho que é isso mesmo cara, exceto este comentário: "// vai contra a OO mais ta blz. ".
Não consegui identificar problema quanto a OO nesta linha.

Quando se tratar de conversões (casts), preste atenção sempre ao tipo declarado e ao tipo efetivamente instanciado. A conversão irá sempre atuar sobre o tipo instanciado.

E aí javaaurelio blz?? Eu testei o seu código aqui e não deu erro de compilação não. Onde apareceu o erro?? Para mim o seu cast está correto. As classes estão na mesma árvore de herança, e como você esta passando uma referência de uma superclasse para uma subclasse, o cast é obrigatório e deveria funcionar acho eu.

douglas_vidotto:

Ah, o código que eu testei foi aquele que voce disse que tava dando errado. Aqui deu certo...

public class Trebble {  
    public void name() {  
    System.out.println("trebble ");  
    }  
}  

class Base extends Trebble {  
     
    @Override
    public void name() {  
    System.out.println("base");  
    }  
      
} 

class Central extends Base {  
    public static void main(String argv[]) {  
    Central c = new Central();  
    c.wynyard();  
    }  
  
    public void wynyard() {  
    Trebble t = new Trebble();  
    Base b = (Base) t;  
    b.name(); 
    Central c2 = new Central();
    c2.name();
    }  
}

Assim da erro. Em Base b = (Base) t;

ok, se vc estiver trabalhando com isto:

Trebble t = new Trebble();
Base b = (Base) t;

Vc não vai conseguir fazer este cast pois t NÃO É um objeto da classe Base, logo o cast é impossivel.

Base É UM Trebble, mas o contrario não é, necessariamente, verdade.

Imagine este exemplo

class Homem extends Animal{}

Animal cachorrofofo = new Animal();
Homem fulano = (Homem) cachorrofofo;

Não faz sentido, certo? Um homem pode passar por Animal pois ele é uma especialização, mas o contrario não é possivel.

Agora isso é.

Trebble t = new Base();

Base b = (Base) t;

Percebe a diferença?