从Java开发者角度看JavaScript（二）

对象和类

在 Java 中，您可以创建一个类来表示一个概念，例如User类。User类有一个构造函数、一些字段和方法。并且使用它的构造函数实例化一个User对象。Java中的每个对象都是相关类的实例，这些类提供了在其实例之间共享代码的功能。您可以继承User类来创建一个类，比如一个TeamMember类。

在JavaScript中，有几种创建对象的方法：

• Object()构造函数
• 对象直接量
• function构造函数
• Object.create()方法
• 对象工厂方法
• ES6 class关键字

让我们一次说明一个方法。

Object()构造函数看起来是这样的：

// Call the Object constructor with new
var user = new Object();
user.name = 'Sunny';
user.interests = ['Traveling', 'Swimming'];
user.greeting = function () {
  console.log('Hi, I\'m ' + this.name + '.');
};
user.greeting(); // Hi, I'm Sunny.

Object构造函数创建一个对象包装器。这不是一个推荐的方法，尽管它在JavaScript中是有效的。在实践中，最好使用对象直接量，这样可以使代码紧凑。

对象直接量方法如下所示：

// Create a user with object literal
var user = {
	name: 'Sunny',
	interests: ['Traveling', 'Swimming'],
	greeting: function () {
		console.log('Hi, I\'m ' + this.name + '.');
	}
}
user.greeting();// Hi, I'm Sunny.

对象直接量是一种用于在JavaScript中创建对象的紧凑语法，相比使用new Object()，更推荐使用这种方法来创建对象。从ES5开始，对象直接量也支持getter和setter访问器，如下所示：

var user = {
	get role() {
		return 'Engineer';
	}
} 
user.role;// Engineer

如果尝试为role属性赋值，它将保持不变，因为没有为role属性定义setter访问器。

构造函数方法如下所示：

// Create a constructor function
function User (name, interests) {
	this.name = name;
	this.interests = interests;
	this.greeting = function () {
		console.log('Hi, I\'m ' + this.name + '.');
	}
}
// Call the constructor with new to create a user object
var user = new User('Sunny', ['Traveling', 'Swimming']);
user.greeting(); // Hi, I'm Sunny.

这种语法非常接近Java中的语法。JavaScript非常灵活，在调用构造函数时可以省略括号。但是，这将不会将任何参数传递给构造函数，如下所示：

var user = new User;
console.log(user.name); // undefined

同样，即使这在 JavaScript 中是有效的，也不建议省略括号。

Object.creat()方法如下所示：

// Use Object.create() method with the prototype of
// User constructor function created above
var user = Object.create(User.prototype, {
	name: { value: 'Sunny' },
	interests: { value: ['Traveling', 'Swimming']}
}); 
user.greeting(); // Uncaught TypeError: user.greeting() is not a //function

greeting()不是user对象的函数的原因是，因为 object.create ()方法使用构造函数的原型对象创建了一个新对象，而greeting函数并没有在 User.prototype 中定义，也没有在 Object.create ()的第二个参数中传递。为了让用户能够打招呼，我们可以在第二个参数中传递 greeting函数，或者将它添加到User构造函数的原型对象中。不同之处在于，第一种方法只是向当前用户对象添加了greeting函数。如果您在没有传入greeting函数的情况下创建了另一个用户，那么该用户将不具有greeting函数。另一方面，向原型对象添加函数将会向由该构造函数创建的所有对象添加greeting函数。现在让我们把它添加到User原型对象：

// Add greeting to prototype object
User.prototype.greeting = function () {
	console.log('Hi, I\'m ' + this.name + '.');
}
user.greeting(); // Hi, I'm Sunny.

实际上，使用原型就是超类在 JavaScript 中为子类提供继承方法的方式。我们稍后将详细讨论这个问题。

工厂模式方法看起来是这样的：

// Use a creator function with an object as its return value
function createUser (name, interests) {
	var user = {};
	user.name = name;
	user.interests = interests;
	user.greeting = function () {
		console.log('Hi, I\'m ' + this.name + '.');
	};
	return user;
}
// Call the creator function with parameters
var user = createUser('Sunny', ['Traveling', 'Swimming']);
user.greeting(); // Hi, I'm Sunny.

这里的creator函数是一个工厂方法，类似于用于在Java中实例化对象的静态工厂方法。它仅仅是一个模式，因为函数里面包装了创建对象的具体细节。

ES6 class关键字方法如下所示：

// Create User class
class User {
	// Equivalent to User constructor function
	constructor (name, interests) {
		this.name = name;
		this.interests = interests;
	}
	// Equivalent to User.prototype.greeting
	greeting () {
		console.log('Hi, I\'m ' + this.name + '.')
	}
}
let user = new User('Sunny', ['Traveling', 'Swimming']);
user.greeting(); // Hi, I'm Sunny.

这非常接近于Java的语法。除了使用class关键字显式声明外，你也可以使用class表达式来创建一个类：

// Use class expression
let User = class {
	constructor (name, interests) {
		this.name = name;
		this.interests = interests;
	}
	greeting () {
		console.log('Hi, I\'m ' + this.name + '.')
	} 
}

尽管使用相同的关键字class，JavaScript中的类与Java中的类有很大的不同。例如，JavaScript中没有静态类和私有类。我们将在ES6部分讨论更多关于类的内容。