Code refactoring - Create base class/interface when is needed

When I made the last code review on a project I found the following lines of code:
Original version

public abstract class FooBase
{
  Person _person;
  public void string PersonId()
  {
    if(_person is Student)
    {
      return ((Student)_person).Id;
    }
    if(_person is Worker)
    {
      return ((Worker)_person).Id;
    }

    return _someDefaultValue;
  }
  public void string ScreenName()
  {
    if(_screen is MainScreen)
    {
      return ((MainScreen)_screen).Name;
    }
    if(_screen is SettingsScreen)
    {
      return ((SettingsScreen)_screen).Name;
    }

    ((DefaultScreen)_screen).Name ;
  }
}

After some new functionality was added:

public abstract class FooBase
{
    Person _person;
    public void string PersonId()
    {
        if(_person is Student)
        {
            return ((Student)_person).Id;
        }
        if(_person is Worker)
        {
            return ((Worker)_person).Id;
        }
        if(_person is Vampire)
        {
            return ((Vampire)_person).Id;
        }

        return _someDefaultValue;
    }
    public void string ScreenName()
    {
        if(_screen is MainScreen)
        {
            return ((MainScreen)_screen).Name;
        }
        if(_screen is SettingsScreen)
        {
            return ((SettingsScreen)_screen).Name;
        }
        if(_screen is TimeScreen)
        {
            return ((TimeScreen)_screen).Name;
        }

        ((DefaultScreen)_screen).Name;
    }
}

If you ask you’re self if the Person class contains the Id property, the response is not. The original team didn’t look over the code and add common items to the base class.
What we can observe in the above code?
First of all, the screens and persons could have a base class or at least a base interface.
The changes are made without trying to improve the code and design. Extracting a base class (interface) is a mandatory think to do before marking a task as done.
There are times when the developer don’t want to make changes to the code because is afraid that he can brake something. Maybe, if the code is covered with strong unit tests than the developer would feel more comfortable to make changes. If you are a developer and see that the code is not covered with test and because of this you cannot improve the design that you should begin to write some test first. After that you should refac. this methods.
After we make the refac our FooBase class should look something similar to this:

public abstract class FooBase
{
    // Add the Id property to the base class (Person)
    Person _person;
    public void string PersonId()
    {
        if(_person == null)
        {
            return _someDefaultValue;
        }
        return _person.Id
    }
    public void string ScreenName()
    {
    // Define a base Screen class that contains the Name property
    return _screen.Name;
    }
}

As a developer, don’t be afraid to improve the code. If the first team that implemented this class would made the refac. we would never had this problem. But in the same time, the second developer that made the changes should look over the code and try to improve it.