Java - Cambiare la classe di una variabile

Ho delle classi A1,A2,A3... che estendono A.

Esempio delle classi:

public class A{
  public A(String s){
    if(CONDIZIONE1)
      //A diventa A1
    else if(CONDIZIONE2)
      //A diventa A2
    [...]
    else
      //A diventa A5
  }
  [...]//Altri metodi
}

public class A1 extends A{
  [...]//Altri metodi
  void metodo(int x){
    [...]
    //questo oggetto diventa un A2 o A3
    [...]
  }
}

public class A2 extends A{
  [...]//Altri metodi
  void metodo(int x){
    [...]
    //questo oggetto diventa un A1 o A3
    [...]
  }
}

Devo poter fare così:

A var=new A("...");  // diventa ad es A1
[...]
var.metodo(3);   //var diventa ad es A2 o A3

Spero di essermi spiegato bene. Si può fare una cosa del genere?
Grazie

Hai bisogno di una abstract factory.

Grazie

Ho letto un po' su internet, ma non mi è chiara una cosa:

Per la Factory non ho problemi:

public class Factory{
  public A make(String s){
    if(CONDIZIONE-per-A1)
      //return A1
    else if(CONDIZIONE-per-A2)
      //return A2
    [...]
    else
      //return A5
  }
  [...]//Altri metodi
}

Altre classi:

public class A1 extends A{
  public void metodoCambiaA2(){[...]}
  public void metodoCambiaA4(){[...]}
  [...]//Altri metodi
}
 
public class A2 extends A{
  public void metodoCambiaA1(){[...]}
  [...]//Altri metodi
}

Poi in un altro metodo: (ad esempio in un metodo della classe B, o anche in un metodo di una classe A):

public class B{
  public void metodo(){
    A x,y;
    x=Factory.make("a1");  //x ora è A1
    y=Factory.make("a2");  //y ora è A2
    [...]
    x.metodoCambiaA2(); //x(A1) diventa A2
    x.metodoCambiaA4(); //x(A2) diventa A4
    y.metodoCambiaA1(); //y(A2) diventa A1 
    [...]
  }
  [...]//Altri metodi
}

Non ho capito che cosa devo mettere in metodoCambiaA1[2,3,4,5...]() per far si che x cambi la classe.
Me lo potresti spiegare? Grazie.

Uhmmmm....ncs (non ci siamo), mi sa' che c'hai un po' di confusione in testa, oppure, me l'hai fatta venire a me...heheheh
Messo così, senza l'uso della Factory pare che tu non abbia ben compreso polimorfismo ed ereditarietà.
Con la factory, invece, mi sembra che tu ne stia facendo un uso improprio e, per altro, solo parzialmente corretto.
Alla fine, infatti, quando i nodi vengono al pettine ti sei giustamente chiesto: "cosa ci dovrei mettere nel metodoCambiaX?".
La risposta è che non ci puoi mettere nulla perchè, ad esempio, metodoCambiaA1 dell'oggetto A2 (pur essendo una sottoclasse di A) non sa' (e NON DEVE sapere!) dell'esistenza delle classi A1 e A2. Quindi: Come fai ad istanziarle?
Se vuoi cambiare il "comportamento" dell'oggetto non ha molto senso creare un oggetto con un tipo per poi cambiarlo subito dopo. Avrebbe più senso affidarsi al polimorfismo ed utilizzare uno strategy pattern che penso sia ciò che serve a te. Cioè un oggetto strategy che "ritorni" al client una variabile polimorfica. Una variabile che, in base a certe scelte, possa comportarsi come un oggetto di una una qualunque delle classi A1, A2, ecc. sottoclassi della classe A.
Non sarebbe male cmq se postassi il motivo concreto che ti ha spinto a trovare una soluzione di questo tipo, cioè cosa devi ottenere in realtà.

Ciao, grazie di aver risposto.
Sono io che ho un po' di confusione in testa e probabilmente non mi sono spiegato bene. Il motivo concreto è che mi servono delle classi per gestire i numeri reali:
Quindi avrò una classe "Numero" (A) e poi le varie classi "Intero", "Frazione", "Radice", "Potenza" (A1, A2, A3 ...), fin qui nessun problema ma se devo ad esempio moltiplicare una variabile x di classe "Intero" per una (y) di classe "Frazione" la variabile x deve diventare una Frazione. esempio:

Numero x=NumeroFactory.make("4");//quindi "Intero"
Numero y=NumeroFactory.make("1/2");//quindi "Frazione"
x.moltiplica(y);

x dopo moltiplica() deve diventare "Frazione" e contenere "2".
Come posso risolvere?
Grazie

Ok, dunque, se non ho capito male stai cercando di creare una specie di calcolatrice virtuale.

A mio parare, probabilmente, java potrebbe non essere il linguaggio più adatto per questo compito.
A te serve una caratteristica chiamata "Operators overloading" che java non possiede (forse la 8?!). Dovresti rivolgerti a C++ o C# (che usa i delegates). Li puoi fare una cosa del tipo:

public static T operator -(T foo, T bar)

Ma se volessi proprio farlo in java ti consiglierei di studiare i generics. In ogni caso ti avviso subito che la quantità di codice da scrivere non credo sarà limitata.
Con Java e generics probabilmente dovresti partire da una cosa di questo tipo:

public interface Calcolatrice<T extends Number> {
    public T somma(T a, T b);
}

e poi implementare ogni classe come se fosse una singola calcolatrice in grado di fare una sola operazione (Addizione, moltipl..ecc):

public class CalcolatriceIntero implements Calcolatrice<Integer> {
    public Integer somma(Integer a, Integer b) { return a + b; }
}

L'ho buttata li al volo. Potrebbero esserci certamente soluzioni più eleganti, ma in java non credo sia cmq una passeggiata.

Avevo deciso di fare questo programma in java perché così dopo aver fatto la versione desktop, avrei potuto facilmente portarla su android (dove non ho mai lavorato) così da avere il cuore dell'app già funzionante e potermi dedicare all'interfaccia grafica.
Grazie dei consigli, studierò i generics.