What is the difference between object-oriented languages and non object-oriented languages?

Question

I have been hearing about how C is a non-object-oriented language and how java is an object-oriented language. I was wondering what the difference was?

Answer 1

Wow, a lot of big OOP terms being thrown around to this guy. Being one who started in procedural programming and is now mostly doing OOP, this is conceptually how I think of the difference (without all the big terms):

In C, you have things called structs that can hold state. They kind of seem like objects, for example you could have a struct called Car and create instances of Cars and set its make, model, and color fields. However, you cannot tell the Car struct instances to do anything. Instead, if you want to wash your car, you have to pass the car instance to some external function like this:

WashMyCar(myCar);

OOP languages use a different concept from structs called Classes, and objects are instances of those classes. Forget about those big words inheritance and polymorphism for now (those are more advanced topics for once you kind of get Classes). Just think of the example of a car. In Java, for example, you could define a class called Car as such:

public class Car {
  String make;
  String model;
  String color;
}

Then, you make an instance of a car like so:

Car myCar = new Car();
myCar.make = "Honda";
myCar.model = "Accord";
myCar.color = "Black";

This is real similar to a struct. Now, what makes OOP different is that you can expand the Class definition to define class methods - which are similar to functions in procedural except that they always operate on an object. So, let's add the wash method:

public class Car {
  String make;
  String model;
  String color;
  String condition;
  void washMe() {
    this.condition = "clean";
  }
  void goOffroad() {
    this.condition = "dirty";
  }
}

Now you can do this:

Car myCar = new Car();
myCar.make = "Honda";
myCar.model = "Accord";
myCar.color = "Black";

myCar.goOffroad();
System.out.println(myCar.condition); // dirty
myCar.washMe();
System.out.println(myCar.condition); // clean

Hopefully this example helps. There is, of course, much more to OOP (and procedural) than this simple example. But the core difference is in having classes of objects that "own" their own methods.

Answer 2

Procedural programming and OOP, both different programming paradigms, are the proverbial apples and oranges. PP relies on "subroutines". OOP sends "messages" to "objects", which change the "state" of the objects and send messages to other objects; furthermore, the behavior objects can be extended, creating new types of objects. Both rely on assignment and side-effects. Problems may have natural solutions in one paradigm, but rather baroque solutions in another. That is, a problem may be readily modeled by using objects passing messages, or by procedures.

Programming languages can support paradigms beyond ones they natively support, but it requires the programmer to implement the necessary structures. For example, you can do OOP with C; in fact, some OO extensions of C relied on preprocessors which produced C code as output.

As you progress in your studies, you'll want to look over the other paradigms, especially functional programming. It wouldn't hurt to look at logic programming (as exemplified by Prolog) and dataflow programming (see Pure Data for an example).