Is Java 100% object oriented? [closed]

问题:

Java has primitive data types which doesn't derive from object like in Ruby. So can we consider Java as a 100% object oriented language? Another question: Why doesn't Java design primitive data types the object way?

回答1:

When Java first appeared (versions 1.x) the JVM was really, really slow. Not implementing primitives as first-class objects was a compromise they had taken for speed purposes, although I think in the long run it was a really bad decision.

"Object oriented" also means lots of things for lots of people. You can have class-based OO (C++, Java, C#), or you can have prototype-based OO (Javascript, Lua).

100% object oriented doesn't mean much, really. Ruby also has problems that you'll encounter from time to time.

What bothers me about Java is that it doesn't provide the means to abstract ideas efficiently, to extend the language where it has problems. And whenever this issue was raised (see Guy Steele's "Growing a Language") the "oh noes, but what about Joe Sixpack?" argument is given. Even if you design a language that prevents shooting yourself in the foot, there's a difference between accidental complexity and real complexity (see No Silver Bullet) and mediocre developers will always find creative ways to shoot themselves.

For example Perl 5 is not object-oriented, but it is extensible enough that it allows Moose, an object system that allows very advanced techniques for dealing with the complexity of OO. And syntactic sugar is no problem.

回答2:

No, because it has data types that are not objects (such as int and byte). I believe Smalltalk is truly object-oriented but I have only a little experience with that language (about two months worth some five years ago).

I've also heard claims from the Ruby crowd but I have zero experience with that language.

This is, of course, using the definition of "truly OO" meaning it only has objects and no other types. Others may not agree with this definition.

---

It appears, after a little research into Python (I had no idea about the name/object distinction despite having coded in it for a year or so - more fool me, I guess), that it may indeed be truly OO.

The following code works fine:

#!/usr/bin/python
i = 7
print id(i)
print type(i)
print i.__str__()

outputting:

6701648
<type 'int'>
7

so even the base integers are objects here.

回答3:

To get to true 100% OO think Smalltalk for instance, where everything is an object, including the compiler itself, and even if statements: ifTrue: is a message sent to a Boolean with a block of code parameter.

回答4:

The problem is that object-oriented is not really well defined and can mean a lot of things. This article explains the problem in more detail: http://www.paulgraham.com/reesoo.html

Also, Alan Kay (the inventor of Smalltalk and author(?) of the term "object-oriented") famously said that he hadn't C++ in mind when thought about OOP. So I think this could apply to Java as well.

The language being fully OO (whatever that means) is desirable, because it means better orthogonality, which is a good thing. But given that Java is not very orthogonal anyway in other respects, the small bit of its OO incompleteness probably doesn't matter in practice.

回答5:

Java is not 100% OO. Java may going towards 99% OO (think of auto-boxing, Scala). I would say Java is now 87% OO.

Why java doesn't design primitive data types as object way ?

Back in the 90's there were Performance reasons and at the same time Java stays backward compatible. So they cannot take them out.

回答6:

No, Java is not, since it has primitive data types, which are different from objects (they don't have methods, instance variables, etc.). Ruby, on the other hand, is completely OOP. Everything is an object. I can do this:

1.class

And it will return the class of 1 (Fixnum, which is basically a number). You can't do this in Java.

回答7:

Java, for the reason you mentioned, having primitives, doesn't make it a purely object-oriented programming language. However, the enforcement of having every program be a class makes it very oriented toward object-oriented programming.

Ruby, as you mentioned, and happened to be the first language that came to my mind as well, is a language that does not have primitives, and all values are objects. This certainly does make it more object-oriented than Java. On the other hand, to my knowledge, there is no requirement that a piece of code must be associated with a class, as is the case with Java.

That said, Java does have objects that wrap around the primitives such as Integer, Boolean, Character and such. The reason for having primitives is probably the reason given in Peter's answer -- back when Java was introduced in the mid-90's, memory on systems were mostly in the double-digit megabytes, so having each and every value be an object was large overhead.

(Large, of course is relative. I can't remember the exact numbers, but an object overhead was around 50-100 bytes of memory. Definitely more than the minimum of several bytes required for primitive values)

Today, with many desktops with multiple gigabytes of memory, the overhead of objects are less of an issue.

回答8:

"Why java doesn't design primitive data types as object way ?"

At Sun developer days, quite a few years ago I remember James Gosling answering this. He said that they'd liked to have totally abstracted away from primitives - to leave only standard objects, but then ran out of time and decided to ship with what they had. Very sad.

回答9:

So can we consider java as 100% object oriented language?

No.

Another question : Why java doesn't design primitive data types as object way?

Mainly for performance reasons, possibly also to be more familiar to people coming from C++.

回答10:

One reason Java can't obviously do away with non-object primitives (int, etc.) is that it does not support native data members. Imagine:

class int extends object
{
    // need some data member here.  but what type?
    public native int();
    public native int plus(int x);
    // several more non-mutating methods
};

On second thoughts, we know Java maintains internal data per object (locks, etc.). Maybe we could define class int with no data members, but with native methods that manipulate this internal data.

Remaining issues: Constants -- but these can be dealt with similarly to strings. Operators are just syntactical sugar and + and would be mapped do the plus method at compile time, although we need to be careful that int.plus(float) returns float as does float.plus(int), and so on.

Ultimately I think the justification for primitives is efficiency: the static analysis needed to determine that an int object can be treated purely as JVM integer value may have been considered too big a problem when the language was designed.

回答11:

I'd say that full-OO languages are those which have their elements (classes, methods) accessible as objects to work with.

From this POV, Java is not fully OOP language, and JavaScript is (no matter it has primitives).

回答12:

According to Concepts in Programming Languages book, there is something called Ingalls test, proposed by Dan Ingalls a leader of the Smalltalk group. That is:

Can you define a new kind of integer, put your new integers into rectangles (which are already part of the window system), ask the system to blacken a rectangle, and have everything work?

And again according to the book Smalltalk passes this test but C++ and Java do not. Unfortunately book is not available online but here are some supporting slides (slide 33 answers your question).

回答13:

No. Javascript, for example, is.

What would those Integer and Long and Boolean classes be written in? How would you write an ArrayList or HashMap without primitive arrays?

回答14:

This is one of those questions that really only matters in an academic sense. Ruby is optimized to treat ints, longs, etc. as primitives whenever possible. Java just made this explicit. If Java had primitives be objects, there would be IntPrimitive, LongPrimitive, etc (by whatever name) classes. which would most likely be final without special methods (e.g. no IntPrimitive.factorial). Which would mean for most purposes they would be primitives.

回答15:

Java clearly is not 100% OO. You can easily program it in a procedural style. Most people do. It's true that the libraries and containers tend not to be as forgiving of this paradigm.

回答16:

Java is not fully object oriented. I would consider Smalltalk and Eiffel the most popular fully object oriented languages.