Can you implement "object-oriented" programming without the class keyword?

Question

Say we want to provide an abstraction of an "account" in a bank. Here's one approach, using a function object in Python:

def account():
    """Return a dispatch dictionary representing a bank account.

    >>> a = account()
    >>> a['deposit'](100)
    100
    >>> a['withdraw'](90)
    10
    >>> a['withdraw'](90)
    'Insufficient funds'
    >>> a['balance']
    10
    """
    def withdraw(amount):
        if amount > dispatch['balance']:
            return 'Insufficient funds'
        dispatch['balance'] -= amount
        return dispatch['balance']
    def deposit(amount):
        dispatch['balance'] += amount
        return dispatch['balance']
    dispatch = {'balance': 0,
                'withdraw': withdraw,
                'deposit': deposit}
    return dispatch

Here's another approach using type abstraction (i.e., class keyword in Python):

class Account(object):
    """A bank account has a balance and an account holder.

    >>> a = Account('John')
    >>> a.deposit(100)
    100
    >>> a.withdraw(90)
    10
    >>> a.withdraw(90)
    'Insufficient funds'
    >>> a.balance
    10
    """



    def __init__(self, account_holder):
        self.balance = 0
        self.holder = account_holder

    def deposit(self, amount):
        """Add amount to balance."""
        self.balance = self.balance + amount
        return self.balance

    def withdraw(self, amount):
        """Subtract amount from balance if funds are available."""
        if amount > self.balance:
            return 'Insufficient funds'
        self.balance = self.balance - amount
        return self.balance

My teacher started the topic "Object oriented programming" by introducing the class keyword, and showing us these bullet points:

Object-oriented programming

A method for organizing modular programs:

• Abstraction barriers
• Message passing
• Bundling together information and related behavior

Do you think the first approach would suffice to satisfy the above definition? If yes, why do we need the class keyword to do object-oriented programming?

Answer 1

Congratulations! You rediscovered the well known fact that object orientation can be done without specific programming language support. It is basically the same way objects are introduced in Scheme in this classic text book. Note that Scheme does not have a class keyword or some kind of equivalent, and objects can be created without having even classes.

However, the object orientated paradigm was so successful that lots of languages - and Python is no exception - provide built-in support for it. This is simply to make it easier for developers to use the paradigm and to provide a standard form of object orientation for that language. It is essentially the same reason why lots of languages provide a for loop, though it could be emulated using a while loop with just one or two additional lines of code - simply ease of use.

Answer 2

I would agree that the first definition satisfies the three points your teacher made. I do not think we need the class keyword for anything. Under the covers, what else is an object but a data structure with with different types of data and functions to work with the data? Of course, the functions are data as well..

I would go even further and say that doing object oriented programming is not so much dependent on the keywords your language provides, you can do object oriented programming in C if you so wished! In fact, the linux kernel employs such techniques.

What you can infer from the class keyword here is, that the language provides support for this kind of construct out of the box, and you do not need to through all the hoops to re-implement the functionality yourself(which is pretty fun task in itself!). Not to mention all the syntactic sugar you might get as well.

Answer 3

Of course you can!

The Self programming language is a dynamic prototype-based object oriented language in which everything is an object and there is no sense of classes or whatsoever. It's focused in the idea of prototypical objects and the idea of cloning them instead of having classes as templates of how to create objects.

You should check http://www.selflanguage.org/ for more information. I think it is very interesting and if you like OOP it's a good idea to check something that is not that common.

Answer 4

Not always: it depends on the language. You've demonstrated the ability to do this in Python but (if your question is meant to be language agnostic despite the Python tag) not all languages can do this. Java, for example, mostly can't. Ignoring the class that contains main, there is no way to define arbitrary methods/fields on an object defined within main without the class keyword. Although anonymous classes do exist they require an interface and they can't have any public members except those defined in the interface. While it is possible to define custom interfaces then make anonymous classes for them, this is effectively the same (but less convenient) than simply using a class.

Doc Brown has a great answer but the point I'm trying to make is that I'm sure there's at least one language that won't allow your solution at all.

Answer 5

Your teacher's definition completely misses the most important point of object-oriented programming, the one thing that makes it useful and unique. "Message passing" is a bunch of nonsense dreamed up by the Smalltalk folks, and it's been a failure everywhere it's been tried. The true power of OOP is something known as Liskov substitution, and while the concept is fairly simple to describe and understand, the underlying implementation is complex enough that it's essentially impossible to do right without language-level support.

The idea of Liskov substitution is that anywhere where your code is expecting a variable of a certain type, it should be able to accept any type derived from that type and still work correctly without having to have knowledge of the details of the derived type.

For example, GUI frameworks use Liskov substitution all over the place. They tend to have a base Control class that can represent "any control", which defines an interface that knows about basic actions like drawing, resizing, and responding to user input. If you click on a control, the UI framework will call a Click method on the control without having to care about what kind of control it is, and then let the control handle the click in the appropriate way for its own class. A Button control should do something completely different when clicked on than a TextBox control, to give just one example.

So yes, you can create something kind of similar to objects using the nested functions trick described above, but because you can't get inheritance and Liskov substitution that way, it's an extremely limited substitute for true OOP.

Answer 6

Quick Short Answer

Yes, Programmers can apply the Object Oriented Programming without "Classes".

Long Boring Extensive Descriptive Answer

There are several variations of "Object Orientation", altought, the first concept that comes to the mind of many programmers is "Classes".

Yes, Programmers can apply the Object Oriented Programming without "Classes", but, is limited to the features and limitations from each programming language.

Your post is tagged as Python, therefore, your question title may be more like "How to implement Object Oriented Programming without Classes in Python".

I currently use the "Object and Class Oriented Programming" phrase, to identify from other variations like Javascript's "Prototyping", or Visual Basic "Based", or emulation in "Pure C" using "functors".