问：Java和JavaScript有什么关系？

答：Java和JavaScript的关系与雷锋和雷峰塔的关系一样的。

雷锋和雷峰塔只是名字相似，但Java和JavaScript就不只是命名上的相似了。JavaScript借鉴了很多Java的思想和语法（同时还有C\C++），Java早时曾被叫做C加加减减，而JavaScript则被称作C减减，可见JavaScript与众多高级语言有很多相似之处。

但是，由于JavaScript是一种基于对象（object-based）的语言而不是严格意义上的面向对象（object-oriented）语言，在进行编程时则与Java有很大区别。在这篇文章里，我将把Java和JavaScript在面向（基于）对象编程方面进行简单的对比。

实例属性（变量）的定义与调用

Java：

public class ClassA {
    public int a = 1;
    public int b = 2;
}
ClassA obj = new ClassA();
System.out.println(obj.a); //输出:1
System.out.println(obj.b); //输出:2

JavaScript：

function ClassA {
    this.a = 1; //第一种：调用this指针
};
ClassA.prototype.b = 2; //第二种：调用prototype（对象原型）
obj = new ClassA();
console.log(obj.a); //输出:1
console.log(obj.b); //输出:2

可以发现，在JavaScript中对象的属性定义有两种方法，其中调用this指针的方法与Java最为相似。

实例方法（函数）的定义与调用

Java：

public class ClassA {
    public int a() {
        return 1;
    }
    public int b() {
        return 2;
    }
}
ClassA obj = new ClassA();
System.out.println(obj.a()); //输出:1
System.out.println(obj.b()); //输出:2

JavaScript：

function ClassA() {
    this.a = function() {
        return 1;
    };
};
ClassA.prototype.b = function() {
    return 2;
}
obj = new ClassA();
console.log(obj.a()); //输出:1;
console.log(obj.b()); //输出:2;

方法和属性的定义、使用是非常相似的，没有太多变化。

类属性（静态属性）的定义与调用

Java：

public class ClassA {
    public static int A = 1;
}
System.out.println(ClassA.A); //直接调用类，输出:1
ClassA obj = new ClassA();
System.out.println(obj.A); //调用由类产生的实例，输出:1

JavaScript：

function ClassA() {
} //首先初始化对象
ClassA.A = 1; //定义“类变量”（本质是函数的变量）
console.log(Class.A); //直接调用类，输出:1

obj = new ClassA();
 // 不能通过用new产生的实例调用类属性
//console.log(obj.A);

在Java中，我们可以通过由类产生的实例调用静态属性，但JavaScript中不允许这样做，这和JavaScript中使用函数表示对象的设计有关。定义类方法
与此类似，不在赘述。

子类的定义与调用

Java：

public class ClassA {
    public int x;
    public ClassA(int a) {
        this.x = a;
    } //构造器
    public void print() {
        System.out.println("x=" + this.x);
    }
} //定义类ClassA

public class ClassB extends ClassA {
    public int y; //定义新变量

    public ClassB(int a, int b) {
        super(a); //调用父类的构造器
        this.y = b;
    } //重写构造器

    @Override
    public void print() {
        super.print(); //调用父类的方法
    } //重写父类方法

    public int sum() {
        return this.x + this.y;
    } //定义新方法
} //定义继承于ClassA的类ClassB

ClassA objA = new ClassA(1);
objA.print(); //调用ClassA的实例的print方法，输出：x=1

ClassB objB = new ClassB(2,3);
objB.print(); //调用ClassA的实例的print方法，输出：x=2\ny=3
System.out.println('x+y=' + objB.sum()); //输出：x+y=5

JavaScript：

function ClassA(a) {
    this.x = a;
    this.print = function() {
        console.log('x=' + this.x);
    };
} //定义类ClassA

ClassB.prototype = new ClassA(1);
function ClassB(a, b) {
    ClassB.prototype.constructor.apply(this, arguments); //调用父类的构造器
    this.y = b;
    this.print = function() {
        ClassB.prototype.print.call(this); //调用父类的方法
        console.log('y=' + this.y);
    }
    this.sum = function () {
        return this.x + this.y;
    }
} //定义继承于ClassA的类ClassB

var objA = new ClassA(1);
objA.print(); //输出：x=1

var objB = new ClassB(2,3);
objB.print(); //输出：x=2\ny=3
console.log('x+y=' + objB.sum()); //输出：x+y=5

JavaScript中类的继承比较复杂，这是因为JavaScript是基于对象的语言而不是面向对象的，在JavaScript中并没有“类”的概念，一切皆是函数。在这里我只是采用了一种最为通用的子类使用方法，除此之外还有很多方法，这篇文章的最后链接了很多解决方案。

最后，我在node.js的源码中找到了util.inherits的定义，如果使用node.js环境开发可进行调用。

/**
 * Inherit the prototype methods from one constructor into another.
 *
 * The Function.prototype.inherits from lang.js rewritten as a standalone
 * function (not on Function.prototype). NOTE: If this file is to be loaded
 * during bootstrapping this function needs to be revritten using some native
 * functions as prototype setup using normal JavaScript does not work as
 * expected during bootstrapping (see mirror.js in r114903).
 *
 * @param {function} ctor Constructor function which needs to inherit the
 *     prototype.
 * @param {function} superCtor Constructor function to inherit prototype from.
 */
exports.inherits = function(ctor, superCtor) {
  ctor.super_ = superCtor;
  ctor.prototype = Object.create(superCtor.prototype, {
    constructor: {
      value: ctor,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
};