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

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); // dirtymyCar.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.

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).

Java is a language mostly used for object oriented programming and C a language mostly used for procedural oriented programming

There is a great explanation on Wikipedia about Procedural programming vs object oriented programming:

Comparison with object-oriented programming The focus of procedural programming is to break down a programming task into a collection of variables, data structures, and subroutines, whereas in object-oriented programming it is to break down a programming task into objects with each "object" encapsulating its own data and methods (subroutines). The most important distinction is whereas procedural programming uses procedures to operate on data structures, object-oriented programming bundles the two together so an "object" operates on its "own" data structure. Nomenclature varies between the two, although they have much the same semantics: object-oriented procedural methods functions objects modules message argument attribute variable

But to make things more basic you can think of objects like you think of objects in the real world such as a car would have all the attributes of a car as other objects like windows and tires.