no, please, don't misunderstand me, I am not advocating into reblessing objects wildly from one class into another. I am just saying that doing it in a controlled manner is an useful mechanism and it can be used without breaking encapsulation or any other OOP property.

Those controlled manners are at least two:

• Reblessing an object into a descendant class of its current class. For instance, when you get new information about the object (BTW, in C++ this is done all the time under the hood at object construction time).
• using several packages to implement a unique class that can change its behaviour dynamically, for instance:

  class TheHulk;
  
  sub new {
    bless $self, $class;
    $self->go_normal;
    $self;
  }
  
  sub go_normal {
    bless $self, TheHulk::_normal;
  }
  
  sub go_green {
    bless $self, TheHulk::_green;
  }
  
  sub relax {}
  
  sub make_angry {}
  
  package TheHulk::_normal;
  
  sub run {
    ...
  }
  
  sub make_angry {
    $self->go_green;
  }
  
  package TheHulk::_green;
  
  sub run {
    ...  
  }
  
  sub relax {
    $self->go_normal;
  }
  [download]

  three packages are used, but conceptually is just one class, so there is no messing with the internals of one class from another and the reblessing is always done from inside the class not from the outside.
• any other?