Java and Smalltalk syntax compared

This is a table comparing elements of Java syntax to Smalltalk syntax [This originated from a request by Doug Edmunds <dae@paclink.com>]. An entry of <null> and <nil> mean the feature does not exist in the corresponding language, although there will frequently be alternatives that are similar. If a column is blank it means that the other column entry goes with the line above (usually as an example alternative with close semantics).

Java syntax is 1.1. I picked Smalltalk-80 syntax (some other current Smalltalk's have some features ST-80 doesn't have). Also, this is not meant to be exaustive of either language, but it has enough to get a feel of each (although I think it is easier if you see a translated piece of code). Some of the following use my own naming convention and libraries.

Notes

1. Java has no class object for each class (Class has no subclasses)
2. But it does have a meta object (basically the protocol of 'Class' itself)
3. Although the java message could be a static function
4. My Java method naming convention
5. The 'this' allows you to get to a shadowed iv
6. Smalltalk does not allow public access to another object's ivs
7. In most Smalltalk's but see SmalltalkAgents for example
8. No direct equivalence is ST, but many alternatives
9. No message cascades in Java
10. Pseudo Smalltalk for the rest of the declaring section (to avoid long message sends). Also see Allen Wirfs-Brock's OOPSLA'96 presentation on declarative Smalltalk:
    • http://www.bell-labs.com/people/cope/oopsla/#AllenWirfsBrock
    • http://www.parcplace.com/oopsla/stwrkshp.html
11. Smalltalk does not have explicit interfaces, but implicit ones by what messages an object/class responds to
12. No non-object types in Smalltalk, so no int,long,boolean primitive types
13. Just ignore the return value in Smalltalk
14. But sort of equivalent to x isKindOf: Bar or one of the other alternatives
15. Smalltalk methods are public
16. By convention this would be in a 'private' protocol
17. Smalltalk does not have exposed instance variables
18. 'protected' is approximately equivalent to standard Smalltalk private. Approximately because in Java 'protected' allows objects of the same class to access an object's protected areas. Java is encapsulated by Class, Smalltalk is encapsulated by object.
19. Not visible to subclasses
20. Ignoring the typing differences. Note that I also have a Java preprocessor that converts:

        [String a, String b | return a + b;]
    

    into the highly noisy

        new Function2Arg() {public Object valueWith_with(Object a, Object b) {
            return (String) a + (String) b
        }};
    

    so there is hope for Java having something close to (and actually in many ways better than) blocks.
21. Note that c must be "final": the variable must only be allow to reference one object in a given context execution
22. Some because of unicode, some are available as characters but not in literal strings

I didn't include the static or package stuff in this table. Partially I didn't get to it, and partially it would all map to <nil> and <null> between Smalltalk and Java. Java's static methods are not even close to a Class object's methods (static methods aren't even methods, they are functions or procedures bound at compile time) and there is no real reason to map between the two. Most Smalltalk's don't have any modular structure for the name space, so there is no equivalent to a Java package.

What is Java?