|
|
|
| Authored by: Anonymous on Monday, May 07 2012 @ 08:49 AM EDT |
I'm not sure how you would actually draw any lines between core/basic
Language/API but let me see if I can draw together some thought's I've been
throwing around this thread.....( I wrote before starting this, my conclusion it
seems is very different)
First (IMV):
Everything under java.*
Is a new word for the language
Everything under javax.*
Is a new word that is being tried out, or that might break something if it got
put in java.* so it needs to be kept apart
Everything outside that is not Java. (as indeed et cetera is not actually
English though frequently used)
Second: In Oracles View
All the above is nonsense, all that is "Core" to the language are a
few classes (not yet properly quantified, but broadly Object, Class, String,
Integer, Byte etc...)
Third: Separation of Core and API
I posted this thought just above.....
"Is it the case that the argument proposed by Oracle is that java[.exe]
constitutes the Java Language and rt.jar constitutes the API?"
Well we can look, if you find the rt.jar in your Java installation directory you
can execute the following command
jar -tvf rt.jar
I can highly recommend also adding a |less to that if you really want to try it
out, and a |grep -v "com/sun" before the |less to help a bit more.
(assuming unix CLI)
There's a lot of stuff in there. This is definitely the "API library"
Worthy of note is that you will not find java/lang/String.class
There is a String$1.class which I shall come to in a moment.
Nor will you find in rt.jar any of Class.class, Object.class Integer.class etc
(I have not done a definitive list, I leave that to my betters)
This looks like then we have found Oracles division point, if it is not in
rt.jar then it is in the JVM, if it is in the JVM it is Language, if it is in
rt.jar it is API.
Let's backtrack a bit and clarify what we are talking about, what is
java[.exe]/JVM/rt.jar?
java[.exe] is the JVM for unix[windows]
it is the 'binary' that executes your java program .class file
(note lower case j to distinguish from Java(tm) the platform)
rt.jar is a the class library that goes with the JVM, the API.
The loose analogy is the java=Linux Kernel,
while rt.jar is a zipped up version of the unix /lib and /usr/lib directories
It's not such a bad analogy, this is after all how java was designed to work, if
you place down three boxes and mark them kernel, lib, and usr.lib, and then
stack two boxes on top marked java and rt.jar and then a final one on top marked
application, you would see a fairly good representation of the java WORA stack,
the idea being you can rip out the bottom layer and replace it with something
else, such as Windows
so Oracle (ISTM) assert that java[.exe] is the Java Language and rt.jar is the
Java API
That would seem to bring with it a couple of 'gotchas' though.
There is no this bit, or that bit, it is not divided between two(or more)
things/places as unix is in /usr/lib and /lib /var/lib etc. it is all wrapped up
and packaged as one big massive heap, one file: rt.jar.
So you have one argument that says there's no split, if it's in rt.jar it is
core.
If it's not in rt.jar, it's something else and we don't care, if it is (and all
166 are AFAICS) then it's core, you cannot separate them. (technically you might
be able to, but they do not and AFAIK never have done).
Let's go back to the odd looking String$1.class
What is this? Well to indulge in a bit of technical gobbledegook, this is
something known as an anonymous inner class. What it means is that in the
implementation code for java.lang.String (which is part of java[.exe]) there is
something that creates a whole new class, which is private to the String class
and for use only by the String class.
Now readers might not fully grok what that says, but there is one very important
implication. java.lang.String (a Language Class, part of java[.exe]) cannot,
does not, and will not work without rt.jar being present, thus you cannot
separate java[.exe] the Language from it's APIs, it wouldn't even just be blind
and deaf, it would be most emphatically DoA.
Which is to suggest that even if you 'badge' it as a set of APIs it is required
for Java in the same way that fuel is required to make your car be anything more
than a lump of metal/plastic/rubber. That sounds pretty "Core" to
me.
And just because I'm in the mood to bang another nail in that coffin, here's
what Oracle have to say about it. (I'll make a clicky below for the lazy ones).
This is take from the JDK/JRE files structure description
http://docs.oracle.com/javase/1.5.0/docs/tooldocs/linux/jdkfiles.html
"rt.jar -- the bootstrap classes (the RunTime classes that comprise the
Java platform's core API). "
And there we see it, rt.jar in Oracles own words, is the "platforms core
API."
Even juicier though is the use of the word "bootstrap", another
concept and this has nothing to do with the things you wear on your feet.
"Bootstrapping is the process by which you load a very small and very
simple pure java program with no dependencies that, in turn, loads, configures,
and runs more complex programs with varying dependencies"
Java is java[.exe] is rt.jar is the Language is the API
Which takes me back to my first point, everything under java[x].* is Language
Oracle said so.
Is it done yet, or would you like me to baste it some more?
[ Reply to This | Parent | # ]
|
- clickable - Authored by: Anonymous on Monday, May 07 2012 @ 08:53 AM EDT
|
|
|
|
