使用JAVA先说明由几个类；然后确定类和类（接口）的关系，画出类图；再编程来实现模拟天天酷跑中的主人公，主角(Actor)可以有一个宠物,宠物可以有猫，狗，免，主角在跑的时侯，他的宠物可以跟着一起跑；

在这个问题中，我们可以定义以下类：

1. Actor 类 - 表示天天酷跑中的主角，拥有一个宠物；
2. Pet 类 - 表示主角的宠物，可以是猫、狗、免等；
3. Cat 类 - 表示宠物中的猫；
4. Dog 类 - 表示宠物中的狗；
5. Rabbit 类 - 表示宠物中的兔子。

根据这些类之间的关系，我们可以画出以下类图：

+------------------+      +------------------+
|      Actor       |      |       Pet        |
+------------------+      +------------------+
|  - name: String   |      |  - name: String   |
|  - pet: Pet       |      +------------------+
+------------------+           /       \
        |                     /         \
        |                    /           \
+------------------+      +------------------+
|       Pet        |      |       Cat        |
+------------------+      +------------------+
|  - name: String   |      |  - color: String  |
+------------------+      +------------------+

+------------------+      +------------------+
|       Pet        |      |       Dog        |
+------------------+      +------------------+
|  - name: String   |      |  - breed: String  |
+------------------+      +------------------+

+------------------+      +------------------+
|       Pet        |      |      Rabbit      |
+------------------+      +------------------+
|  - name: String   |      |  - weight: int    |
+------------------+      +------------------+

Actor 类中包含一个 Pet 类的对象，表示主角拥有一个宠物。Pet 类是一个抽象类，表示宠物；Cat、Dog、Rabbit 类继承自 Pet 类，分别表示不同种类的宠物。

下面是使用 Java 代码实现的示例：

abstract class Pet {
    protected String name;

    public Pet(String name) {
        this.name = name;
    }

    public abstract void run();
}

class Cat extends Pet {
    private String color;

    public Cat(String name, String color) {
        super(name);
        this.color = color;
    }

    @Override
    public void run() {
        System.out.println("Cat " + name + " is running.");
    }
}

class Dog extends Pet {
    private String breed;

    public Dog(String name, String breed) {
        super(name);
        this.breed = breed;
    }

    @Override
    public void run() {
        System.out.println("Dog " + name + " is running.");
    }
}

class Rabbit extends Pet {
    private int weight;

    public Rabbit(String name, int weight) {
        super(name);
        this.weight = weight;
    }

    @Override
    public void run() {
        System.out.println("Rabbit " + name + " is running.");
    }
}

class Actor {
    private String name;
    private Pet pet;

    public Actor(String name, Pet pet) {
        this.name = name;
        this.pet = pet;
    }

    public void run() {
        System.out.println(name + " is running.");
        pet.run();
    }
}

public class Main {
    public static void main(String[] args) {
        Pet cat = new Cat("Tom", "white");
        Pet dog = new Dog("Snoopy", "beagle");
        Pet rabbit = new Rabbit("Peter", 2);

        Actor actor1 = new Actor("Alice", cat);
        Actor actor2 = new Actor("Bob", dog);
        Actor actor3 = new Actor("Charlie", rabbit);

        actor1.run();
        actor2.run();
        actor3.run();
    }
}

在这个示例中，我们定义了 Pet 类作为宠物的抽象类，包含了一个 name 属性和一个抽象的 run() 方法。Cat、Dog、Rabbit 类继承自 Pet 类，分别实现了 run() 方法。

Actor 类表示主角，包含一个 Pet 类型的属性 pet，表示主角拥有一个宠物。在 Actor 类的 run() 方法中，先输出主角的名字，再调用宠物的 run() 方法。

最后，在 Main 类中创建了几个 Actor 对象，分别携带不同种类的宠物，并调用它们的 run() 方法。