What is the difference between object-oriented lan

问题:

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?

回答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.

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

回答3:

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.

回答4:

I'll give you the most simple and intuitive answer you can get.

(Considering Java is an object-oriented language and C is a procedural language)

Object-Oriented Language

• core concept is objects (consider a car)
• objects have properties that define them, they can be constant or changing (a car is red, 2004 model, and has cruise control. It also currently has 100K on the odometer and 3/4 tank fuel)
• objects can be sent messages which affect it (a car can be driven from A to B, a car can be refueled)

Procedural Language

• core concept is process (consider placing on online order)
• for a process to complete it must go through several steps (an order must be (1) sent to warehouse, (2) boxed, and (3) shipped)
• one of the steps might be a process by itself, or it can be atomic

回答5:

OO languages make it easier to write object oriented programs, by offering you constructs to make data abstraction and polymorphism easy to implement.

回答6:

The object-oriented programming paradigm tells you to encapsulate state variables in entities called 'objects' which communicate via message passing, most often implemented as functions with a 'special' this or self argument.

An object-oriented programming language is a language designed to make using the oo paradigm easy. Its semantics and syntax are geared towards this goal. Inheritance (either class-based or prototypal) and subtype polymorphism are important techniques which make the abstract concept of oo feasible in practice.

回答7:

Object oriented languages are built around the idea of data structures, called objects, that each contain their own data and behaviours. By combining these objects and having them interact with eachother you can design a program that better reflects the domain of the problem you're trying to solve.

For example, in a banking application you might have objects that represent accounts, which each store data like the balance and implement certain behaviours like transferring money.

In a more traditional language, you would keep data and behaviour in different places.

回答8:

Apart from trying to characterize a language as having a particular paradigm at its core, you might find this paper from William R. Cook useful: On understanding data abstraction, revisited. There's a draft version available. It explores the difference between abstract data types and objects -- a distinction that, after years of absorption in various programming languages, I could no longer see.

I found the paper by way of Guy Steele's recent essay, Why Object-Oriented Languages Need Tail Calls.

回答9:

OOP makes it easier to break down one big problem into smaller self contained parts. You can then create something more complex by combining these parts.

回答10:

Object-Oriented Language is where you think in terms of objects. However, this takes lot of skills. You cannot take some C-code and stuff it into an object and call it OOP. Key concepts of OOP are inheritance, encapsulation and dynamic binding.

回答11:

A program can be conceptually organised in two ways,around its code or data. The first approach is called as process-oriented model.The second approach is called as object oriented model.