Can superclass become subclass?

Well, the concept of inheritance is somewhat misunderstood though simple. Inheritance in O.O. not just reuse code (unlike many people say), that's just a consequence. Inheritance must be applied when a class is clearly an extension of another class.

In your situation, you could not use inheritance, as far as I realize, if the idea is just to reuse attributes (not behaviors), you could choose composition:

public class DadosVersao {
   private Tipo atributoA;
   private Tipo atributoB;
}

public class VersaoSoftware {
   private DadosVersao atributos = new DadosVersao();
}

public class VersaoHardware {
   private DadosVersao atributos = new DadosVersao();
}

You could receive the attributes in the class constructor.

But if you really want to use inheritance, I think it makes sense for your class to be abstract, because it does not make sense to exist alone.

public abstract class Versao {
...
}

If you want to create a stereotype for the version, simply create an abstract method that forces the child classes to implement:

public abstract class Versao {
   public abstract String getTipo();
}

public class VersaoSoftware extends Versao {

   @Override
   public String getTipo() {
       return "software";
   }

}

And, if it is popular data of the daughter class with attributes of the mother, simple:

public class VersaoSoftware extends Versao {

   public VersaoSoftware(Atributo atributoEspecificoSoftware, Atributo atributoVersao) {
      this.atributoEspecificoSoftware = atributoEspecificoSoftware;
      super.setAtributoVersao(atributoVersao); //pode usar um atributo protected diretamente ou, ainda, não precisa do super se for o setter publico ;P
   }

   @Override
   public String getTipo() {
       return "software";
   }

}

There are many options for this, but it is best to use inheritance when it makes sense of the specialization of the class in behavioral rather than just characteristic.

I think you've already figured it out. The best way, and a well-regarded architectural practice, is the builder copy. Something like:

 Versao versao = new Versao();
 versao.setName("Versao");

 VersaoSoftware versaoSoft = new VersaoSoftware(versao);
 VersaoFirmware versaoFirm = new VersaoFirmware(versao);

In the base class, you would do a function that would be called by the constructor functions:

 public Clone(Versao origem)
 {
       this.prop1 = origem.prop1;
       this.prop2 = origem.prop2; // etc...
 }

This causes you to change the base class without affecting other builders, after all they would always call the same function no matter what version of the software.

You could follow this same architecture for possible future changes in your daughter classes (or daughters extending daughters). So you do not have to worry about setting the properties of the parent class in the child classes, which would be a dangerous repetition of code if someone ever extends the parent class and forget to look at all the daughters.     

Problem

I think you're thinking the wrong way (you should write your requirement to us, not what you already thought). I'll try to focus on the description of your problem. Going by parts, you said that:

• You have a Equipment
• In practice the user can add one or more versions to a equipment
• When it finishes adding the versions, it should select the type of versions, VersaoFirmware or VersaoSoftware (this one was confused, after all a equipment has N versions or I have used the worst case scenario, being 1 equipment for N version, if necessary, you adapt later)

View your diagram :

Being:

• 1Versionhas1TypeVersion(Iusedenumforsimplicity,butyoucanswitchtoahigherlevelentity)
• 1VersionhasNPropertiesVersion

OutputthatIimagineyouwant

Testing classes

public class Equipamento {
    public String nome;
    public List<Versao> versoes = new ArrayList<Versao>();
}

public class Versao {
    public TipoVersao tipoVersao;
    public List<PropriedadeVersao> propriedadesVersao = new ArrayList<PropriedadeVersao>();
}

public enum TipoVersao {
    HARDWARE, SOFTWARE
}

public class PropriedadeVersao {
    public String nome;
    public String valor;
}

Sample excerpt with classes

    Equipamento equipamento = new Equipamento();
    equipamento.nome = "TV Samsung";

    // VERSAO DE HARDWARE

    Versao versaoHardware = new Versao();
    versaoHardware.tipoVersao = TipoVersao.HARDWARE;

    PropriedadeVersao propriedadeVersaoChipset = new PropriedadeVersao();
    propriedadeVersaoChipset.nome = "Chipset";
    propriedadeVersaoChipset.valor = "111.1";
    versaoHardware.propriedadesVersao.add(propriedadeVersaoChipset);

    PropriedadeVersao propriedadeVersaoAquecimentoMaximo = new PropriedadeVersao();
    propriedadeVersaoAquecimentoMaximo.nome = "Aquecimento Maximo";
    propriedadeVersaoAquecimentoMaximo.valor = "20º";
    versaoHardware.propriedadesVersao.add(propriedadeVersaoAquecimentoMaximo);

    equipamento.versoes.add(versaoHardware);

    // VERSAO DE SOFTWARE       

    Versao versaoSoftware = new Versao();
    versaoSoftware.tipoVersao = TipoVersao.SOFTWARE;

    PropriedadeVersao propriedadeVersaoFabricante = new PropriedadeVersao();
    propriedadeVersaoFabricante.nome = "Fabricante";
    propriedadeVersaoFabricante.valor = "Microsoft";
    versaoSoftware.propriedadesVersao.add(propriedadeVersaoFabricante);

    equipamento.versoes.add(versaoSoftware);

    // IMPRIME DADOS

    System.out.println("Equipamento: " + equipamento.nome);

    for (Versao versao : equipamento.versoes) {
        System.out.println("- Versao: " + versao.tipoVersao.toString());            
        for (PropriedadeVersao propriedadeVersao : versao.propriedadesVersao) {
            System.out.println("-- " + propriedadeVersao.nome + " = " + propriedadeVersao.valor);
        }
    }

Use composition:

// coisas comuns, ainda não definiu se firmware/software
Versao versao = new Versao(1, "0.0.1");
// se firmware...
VersaoFirmware firmware = new VersaoFirmware(versao, "Firmware");
// se software...
VersaoSoftware software = new VersaoSoftware(versao, "software");

Having as superclass:

abstract class PossuiVersao {
  final Versao versao;
  PossuiVersao(Versao versao) {
    this.versao = versao;
  }
  // métodos delegam para Versao, 
  // assim PossuiVersao comporta-se como Versao.
  public int getId() {
    return versao.getId();
  }
  public String getName() {
    return versao.getName();
  }
}

And the subclasses:

class VersaoFirmware extends PossuiVersao {
  final String coisaFirmware;
  VersaoFirmware(Versao versao, String coisaFirmware) {
    super(versao);
    this.coisaFirmware = coisaFirmware;
  }
  void somenteFirmware() {
    // comportamento específico firmware
  }
}

class VersaoSoftware extends PossuiVersao {
  final String coisaSoftware;
  VersaoSoftware(Versao versao, String coisaSoftware) {
    super(versao);
    this.coisaSoftware = coisaSoftware;
  }
  void somenteSoftware() {
    // comportamento específico software
  }
}