I changed your code so that it compiles and runs.
Is this what you meant?

Code:

Hashtable animation = new Hashtable();
void setup(){
  String msg="off";
  animation.put("off", new Anim1());
  animation.put("standby", new Anim2()); 
  Anim objtemp = (Anim)animation.get(msg); // Here is the line to change for dynamic
  objtemp.update();
}
interface Anim
{
  void update();
}
class Anim1 implements Anim{
  void update(){    
    rect(random(122), random(98), random(120), random(84));
  }
}

class Anim2 implements Anim {
  void update(){
    ellipse(random(200), random(200), random(50), random(50) );
  }
} 

Interfaces are a kind of contract: classes implementing it must implement the methods of the interface.
So when you get an object typified by an interface, you are sure it has a given set of methods.
Note an object can implement several interfaces.

On the other hand, you can make a class to inherit from (extend) another. The interest is that you can define methods common to all derived classes (default implementation) and derived classes can override these methods to do their own.

The parent class can be abstract, meaning you can't create a new instance of it. Eg. the abstract class 'Fruit' is extended to 'Banana' and 'Apple': you can create an apple but not a fruit, too abstract.

You can do:
Code:

interface Anim
{
  void update();
}

abstract class Base{
  String name;
  Base(String n){
    name = n; 
  }
}

class Anim1 extends Base implements Anim{
  Anim1(String n){
    super(n);
  }
  void update(){    
    rect(random(11), random(11), random(120), random(84));
  }
}

class Anim2 extends Base implements Anim{
  int an;
  Anim2(String n){
    super(n);
    an = n.length();
  }
  void update(){
    ellipse(random(11), random(11), random(50), random(50) );
  }
}   
 

or even just drop the interface:
Code:

abstract class Anim{
  String name;
  Anim(String n){
    name = n; 
  }
  abstract void update();
}

class Anim1 extends Anim{
  Anim1(String n){
    super(n);
  }
  void update(){    
    rect(random(11), random(11), random(120), random(84));
  }
}

class Anim2 extends Anim{
  int an;
  Anim2(String n){
    super(n);
    an = n.length();
  }
  void update(){
    ellipse(random(11), random(11), random(50), random(50) );
  }
}   
 

Quote:

Well, if you don't implement the interface, you cannot use the class in a generic way, like in the first answer. So it is still mandatory.

Interface vs. abstract class: it is a bit conceptual. There is lot of literature on the topic, eg. interface vs abstract class.

Somehow, an interface defines a behavior, a capability, a contract. A class can inherit several classes: eg. it can be a Map, can be Serializable, and can be Clonable.
An abstract class is deeper, it is a parent-child relation. By telling you extends an abstract class, you define a "is-a" relation: a Circle is-a Shape, a Lion is-a Creature, etc.
Both relations have their uses.

Note: lot of people think one should favor has-a relation, ie. composition, declaring objects in the class to get their properties, preferably to inheritance. A tendency is to say to reserve inheritance to frameworks, base classes, libraries, etc., but to keep it to minimum in end programs.