与其他语言相比，Java中的具体类型和抽象类型

Question

I am preparing for my finals and trying to solve exercise problems on the back of the textbook when i came across this question:

In Java, if the concrete type of p is Foo, p.getClass() and Foo.class will return the same thing. Explain why a similar equivalence could not be guaranteed to hold in Ruby, Python, or JavaScript.

Can anyone shed some light on this. Thanks in advance!

Answer 1

The answer is strongly typed vs weakly typed programming languages. In Java (or C++, C#, VB etc.) a type must be explicitly defined at compile time. So let's say you have a class in Java that looks like this:

class Foo{
    String a;
    public void DoNothing(){}
}

The moment you hit the compile button, your class is fixed; you cannot change it at runtime. That is to say, let's say you have a variable p, which is an instance of Foo, you cannot do:

p.b = 12345;

The compile will yell at you. And you know FOR SURE, p will have a property called "a", it HAS to be a String, and a method DoNothing() which returns no type.

JavaScript, on the other hand, does not have a concept of a "class", because you can dynamically add (or remove) properties or fields to an object at runtime. So you can do:

var x = {}; //declares a new object, it is empty right now
x["name"] = "Hello World!";
x.doWork = function() { ... };

The result is, you will not know whether the variable "x" contains the field called "name" or a function called "doWork" until the moment you execute that line at runtime.

Same argument applies for Python and Ruby.

Answer 2

Not quite sure what is asked.

If you have in python

class Foo(object):
    pass

p = Foo()

then p.__class__ would return Foo as an object. The class name could be printed with

p.__class__.__name__

or on class

Foo.__name__

Of course in python you can do something like this

class Foo2(object):
    pass

p.__class__ = Foo2

But yes, it's dynamic language.

So the last option is quite rare and in general I can't see difference.

Answer 3

Ruby, Python and JavaScript are all dynamically typed languages, but this is not a question of static vs. dynamic typing. Rather, I think it is to do with the fact that Java's getClass() is final (cannot be overridden) while the other languages do not have such restrictions:

# Ruby
class Foo
  def class­()
    retur­n Strin­g
  end
end
String.new().class() == String # => true
Foo.new().class() == Foo # => false

# Python
class Foo: pass
class Bar: pass
p = Foo()
p.__class__ == Foo # => True
p.__class__ = Bar
p.__class__ == Foo # => False

// JavaScript
function Foo() { }
function Bar() { }
var p = new Foo();
p.constructor == Foo; // => true
p.constructor = Bar;
p.constructor == Foo; // => false

Interestingly, in Python's case setting the __class__ member actually affects method lookup so it could be argued that the concrete type of p is now Bar , which does not violate the equivalence.