How do you explain OO to new programmers? [closed]

Answer 1

I assume the target knows how to use graphical user interfaces. I found the best way is to describe OOP with stuff that they are really used for. Say

Class

A Window is a class. It has methods like

• Show a window
• Enable a window
• Set the window's title

A Window has attributes. That is data associated with it. It is encapsulated into the class, together with the functions that operate on them

• A Window has dimensions. Width and height.
• A Window has possibly a parent window, and possibly children.
• A Window has a title

Object

There are many windows. Each particular window is an object of the class Window. A Parent window containing 10 windows makes 11 Window objects.

Deriveration

A Button is a Window. It has dimensions has a parent window and has a title, the label of a button. It's a special kind of a window. When you ask for a window object, someone can give you a Button. A Button can add functions and data that are specific for a button:

• A Button has a state. It can be in a pressed state, and unpressed state.
• A Button can be the default button in a Window.

Answer 2

Since the issue is to explain to a new programmer and not to a mother or a wife, I would go right straight to the point. OO is about three main concepts:

1. Inheritance: a dog is an animal, parent-child, is-a relationship test, etc.
2. Encapsulation: public-private (protected), information hiding, internal underlying details are not important to the users of the class, protect users from future changes in the implementation.
3. Polymorphism: run-time binding, late binding, method that gets invoked depends on the type of the object and not the reference or pointer to the object.

Also, depending on how much the new programmer has been doing a procedural language, I would need to help him/her unlearn that the functions or procedures are no longer central.

Answer 3

If they're old enough to have ever filled out a tax form, show them a 1040EZ and explain that an instance of a class is like a filled-out form: each blank is a member variable of the object, and the form also includes instructions for what to do with the member variables, and those instructions are the member functions of the object. A class itself is like a master copy of the form, from which you can print off an endless number of blank forms to fill out.

One thing that I would counsel to AVOID in trying to communicate the concepts of OO to new programmers is using only examples where objects (in the OO sense) represent real-world physical objects. This will actually make students more confused when they encounter objects used to represent non-physical objects (such as a color scheme, or most of the behavioral patterns in "Design Patterns") or objects used just as a useful way to store related functions and related data in the same place (think Java's java.lang.Math for an example.)

Answer 4

Read the Java tutorials for some good ideas and real world examples.

Answer 5

How about "each molding is built using a mold", or "each model is built using a template", and so "each object is built using a class" ?

Note that it works for class-oriented OOP (which is what you want), but not for prototype-oriented OOP.

As for explaining OOP to a programmer, I'd add examples illustrating:

Separating state from behavior

Most of the time, an instance describe a state, and a class describe a behavior.

Delegation

An instance delegates its behavior to its class, and the class in turn can delegate its behavior to its superclasses (or mixins or traits)

Polymorphism

If class A inherits from class B, an instance of A can be used anywhere an instance of class B can be used.

Messages & methods

A message (or generic function, or virtual function) is like a question. Most of the time, several classes can answer to this question.

A corresponding method is a possible answer to the question, that resides in a class.

When sending a message to an instance, the instance looks up for a corresponding method in its class. If found, it calls it (with the instance bound to 'self' or 'this'. Otherwise, it looks for a corresponding method in its mixins, traits, or superclasses, and calls it.

Answer 6

Seriously use Animals, it works great. And that's what nailed the concept for me years ago. Just found this C# code. It seems good

    // Assembly: Common Classes
    // Namespace: CommonClasses

    public interface IAnimal
    {
        string Name
        { 
             get; 
        }
        string Talk();
    }

    // Assembly: Animals
    // Namespace: Animals

    public class AnimalBase
    {
        private string _name;
        AnimalBase(string name)
        {
           _name = name;
        }
        public string Name
        {
           get
           {
              return _name;
           }
        }
    }

    // Assembly: Animals
    // Namespace: Animals

    public class Cat : AnimalBase, IAnimal
    {
        public Cat(String name) :
            base(name)
        {
        }

        public string Talk() {
            return "Meowww!";
        }
    }

    // Assembly: Animals
    // Namespace: Animals

    public class Dog : AnimalBase, IAnimal
    {
        public Dog(string name) : 
            base(name)
        {
        }

        public string Talk() {
            return "Arf! Arf!";
        }
    }

    // Assembly: Program
    // Namespace: Program
    // References and Uses Assemblies: Common Classes, Animals

    public class TestAnimals
    {
        // prints the following:
        //
        // Missy: Meowww!
        // Mr. Bojangles: Meowww!
        // Lassie: Arf! Arf!
        //
        public static void Main(String[] args)
        {
            List<IAnimal> animals = new List<IAnimal>();
            animals.Add(new Cat("Missy"));
            animals.Add(new Cat("Mr. Bojangles"));
            animals.Add(new Dog("Lassie"));

            foreach(IAnimal animal in animals)
            {
                 Console.WriteLine(animal.Name + ": " + animal.Talk());
            }    
        }
    }

And once he's got this nailed, you challenge him to define Bird (fly), and then Penguin (fly!?)