一、常见函数对象的方法
 
先理清楚函数对象的几种创建方法：
 1、使用function操作符创建
 
函数声明语法创建
函数表达式创建（匿名函数）
 
2、使用Function构造函数创建
 
二、代码示例
 
下面是不同创建方法对应的代码示例：
 1.函数声明语法创建
 
//使用函数声明语法创建函数对象，最常用
function sum (num1, num2) {
	return num1 + num2;
}
 
2.函数表达式方法创建（匿名函数）
 
//使用函数表达式创建函数对象
var sum = function(num1, num2){
	return num1 + num2;
};
 
注意，使用函数表达式创建函数对象时，function 关键字后面没有函数名。这是因为在使用函数表达式定义函数时，没有必要使用函数名——通过变量 sum 即可以引用函数。另外，还要注意函数末尾有一个分号，就像声明其他变量时一样。
 
3.使用Function构造函数创建
 
//使用Function构造函数——不推荐使用
var sum = new Function("num1", "num2", "return num1 + num2"); 
 
Function 构造函数可以接收任意数量的参数，但最后一个参数始终都被看成是函数体，而前面的参数则枚举出了新函数的参数。——不推荐使用
 
三、比较
 
1.函数表达式和函数声明有什么不同之处
 在js中，函数声明可以在函数调用之后出现，但是如果以函数表达式形式定义函数，必须出现在函数调用之前：
 
//函数声明可以在函数调用之后出现
alert(sum(10,10));
function sum(num1, num2){
	return num1 + num2;
}
//不可行，报错
alert(sum(10,10));
var sum = function(num1, num2){
	return num1 + num2;
};
 
但是，这是为什么呢？因为js在代码执行之前会有一个函数声明提升function declaration hoisting的过程，读取并将函数声明添加到执行环境中。这个执行环境可以理解为作用域。
 
2.使用function创建函数对象和使用Function有什么区别
 其实格式上的区别比较大，并且创建函数对象，多使用function操作符，不推荐使用Function构造函数
 
 
Reference：
 
《JS高级程序设计》

对象数组的概念：
 如果一个数组中的元素是对象类型，则称该数组为对象数组。
 当需要一个类的多个对象时，应该用该类的对象数组来表示，通过改变下标值就可以访问到不同的对象。
 对象数组的定义和使用：
 对象数组的定义与一般数组的定义类似，但是需要为每一个元素实例化。
 对象数组的声明形式是：
 类名 对象数组名 [ ];
 为对象数组分配内存空间：
 对象数组名=new 类名[数组长度]；//注意 ：此处不是构造方法了
 可以将对象数组的声明和创建用一条语句来完成。例如：定义一个学生类对象数组，可以用下面的语句定义：Student stu[ ]=new Student[30]; stu [ ]是对象数组名，它所表示的数组一共有30个元素，每一个元素都是Student类的对象名，还没有实例化，所以还必须为每一个元素实例化。比如如下的过程：
 for(int i=0;i<stu.length;i++)
 stu[i]=new Student()；
 实例化以后就可以使用每一个元素对象。
 设计一个雇员类，并创建雇员类的对象数组，输出每个雇员的信息
 
//设计一个雇员类，并创建雇员类的对象数组，输出每个雇员的信息
class Employee {   //雇员类
 private String id;  //编号
 private String name; //姓名
 private int age;     //年龄
 private String vocation; //职务
 public Employee(){} //构造方法一
 public Employee(String id,String name,int age,String vocation){
  set(id,name,age,vocation);
 }
 //设置属性的方法
 public void set(String id,String name,int age,String vocation){
  this.id=id;
  this.name=name;
  this.age=age;
  this.vocation=vocation;
 }
 public String toString() {
  String mess=id+","+name+","+age+","+vocation;
  return mess;
 }
}
public class Example4  {
 public static void main(String[] args) {
  Employee 雇员[]=new Employee[3];
  int i;
  for(i=0;i<雇员.length;i++)//为对象数组中每一个元素实例化
  雇员[i]=new Employee();//如果没有写构造方法一，而这样写，会出错
  //因为类中有有参的构造方法，系统就不会在默认给无参的构造方法了，
  //所以当类中写了有参的构造方法后，要用无参的构造方法时必须写出来
  
  //每一个对象元素分别初始化
  雇员[0].set("0001","张文军",50,"总经理");
  雇员[1].set("0002","李琦",45,"副经理");
  雇员[2].set("1016","张丽",28,"秘书");
  for (Employee employee:雇员)
   System.out.println(employee.toString());
 }
}
 

 普通型for循环和增强型for循环
 普通型
 
a={1,2,3,4,5};
for(int i=0;i<a.length;i++) {
 System.out.println9(a[1]);
}
 
增强型
 
for(int element:a) {
System.out.println(element);
}
 
两者结果相同，但是增强型更为简洁
 
对象数组还可以采用初始化的方法创建。创建形式是：
 类名 对象数组名[ ]={对象列表}；
 
设计一个雇员类，创建雇员类的对象数组并初始化，输出每个雇员的信息，仍然沿用上面的Employee类，程序如下
 
class Employee {   //雇员类
 private String id;  //编号
 private String name; //姓名
 private int age;     //年龄
 private String vocation; //职务
 public Employee(){} //构造方法一
 public Employee(String id,String name,int age,String vocation){
  set(id,name,age,vocation);
 }
 //设置属性的方法
 public void set(String id,String name,int age,String vocation){
  this.id=id;
  this.name=name;
  this.age=age;
  this.vocation=vocation;
 }
 public String toString() {
  String mess=id+","+name+","+age+","+vocation;
  return mess;
 }
}
public class Example11 {
 public static void main(String[] args) {
  //先创建3个雇员对象
  Employee employee1=new Employee("0001","张文军",50,"总经理");
  Employee employee2=new Employee("0005","李琦",45,"副经理");
  Employee employee3=new Employee("1016","张丽",28,"秘书");
  //声明对象数组并直接初始化
  Employee 雇员1[]={employee1,employee2,employee3};
  output(雇员1);//输出雇员信息
  System.out.println("------------------");//分割线
  //声明对象数组并直接初始化，初始化元素直接调用
  //构造方法创建对象
  Employee 雇员2[]={new Employee("0001","张文军",50,"总经理"),
  new Employee("0005","李琦",45,"副经理"),
  new Employee("1016","张丽",28,"秘书")};
  output(雇员2);
 }
 //定义方法用于输出雇员信息，注意方法是private,static
 private static void output(Employee 雇员[]){
  for(Employee employee:雇员)
   System.out.println(employee.toString());
 }
}
 

Java对象创建的流程
 


 
文章目录
 
Java对象创建的流程
1.Java普通对象的创建
1.1new指令
1.2分配内存
1.3初始化
1.4对象的初始设置
1.5``方法
   
2.Java对象内存布局
2.1对象头
2.2实例数据
2.3对齐填充
  
 

 
 
1.Java普通对象的创建
 
这里讨论的仅仅是普通Java对象，不包含数组和Class对象。
 
1.1new指令
 
​ 虚拟机遇到一条new指令时，首先去检查这个指令的参数是否能在常量池中定位到一个类的符号引用，并且检查这个符号引用代表的类是否已被加载、解析和初始化过。如果没有，那么须先执行相应的类加载过程。
 
1.2分配内存
 
​ 接下来虚拟机将为新生代对象分配内存。对象所需的内存的大小在类加载完成后便可完全确定。分配方式有“指针碰撞（Bump the Pointer）”和“空闲列表（Free List）”两种方式，具体由所采用的垃圾收集器是否带有压缩整理功能决定。
 
1.3初始化
 
​ 内存分配完成后，虚拟机需要将分配到的内存空间都初始化为零值（不包括对象头），这一步操作保证了对象的实例字段在Java代码中可以不赋初始值就直接使用，程序能访问到这些字段的数据类型所对应的零值。
 
1.4对象的初始设置
 
​ 接下来虚拟机要对对象进行必要的设置，例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对象的哈希码、对象的GC分代年龄等信息。这些信息存放在对象的对象头（Object Header）之中。根据虚拟机当前的运行状态的不同，如对否启用偏向锁等，对象头会有不同的设置方式。
 
1.5<init>方法
 
​ 在上面的工作都完成了之后，从虚拟机的角度看，一个新的对象已经产生了，但是从Java程序的角度看，对象创建才刚刚开始—<init>方法还没有执行，所有的字段都还为零。所以，一般来说，执行new指令后悔接着执行init方法，把对象按照程序员的意愿进行初始化（应该是将构造函数中的参数赋值给对象的字段），这样一个真正可用的对象才算完全产生出来。
 
2.Java对象内存布局
 
​ 在HotSpot虚拟机中，对象在内存中存储的布局可以分为3块区域：对象头（Header）、实例数据（Instance Data）、对其填充（Padding）。
 
 
2.1对象头
 
​ HotSpot虚拟机的对象头包含两部分信息，第一部分用于存储对象自身的运行时数据，如哈希码(HashCode)、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等。
 ​ 对象的另一部分类型指针，即对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例（并不是所有的虚拟机实现都必须在对象数据上保留类型指针，也就是说，查找对象的元数据信息并不一定要经过对象本身）。
 ​ 如果对象是一个Java数组，那在对象头中还必须有一块用于记录数组长度的数据。
 
元数据：描述数据的数据。对数据及信息资源的描述信息。在Java中，元数据大多表示为注解。
 
2.2实例数据
 
​ 实例数据部分是对象真正存储的有效信息，也是在程序代码中定义的各种类型的字段内容，无论从父类继承下来的，还是在子类中定义的，都需要记录起来。这部分的存储顺序会虚拟机默认的分配策略参数和字段在Java源码中定义的顺序影响（相同宽度的字段总是被分配到一起）。
 
2.3对齐填充
 
​ 对齐填充部分并不是必然存在的，也没有特别的含义，它仅仅起着占位符的作用。由于HotSpot VM的自动内存管理系统要求对象的起始地址必须是8字节的整数倍，也就是说，对象的大小必须是8字节的整数倍。而对象头部分正好是8字节的倍数（1倍或者2倍），因此，当对象实例数据部分没有对齐时，就需要通过对齐填充来补全。

 
 
 今天在学习《js高程》时看到了使用对象字面量创建对象的表示法，了解到对象字面变量是对象定义的一种简写形式，目的在于简化创建包含大量属性的对象的过程，举一个简单的例子var person = {name : "tom",age : 21};
 
 这里，左边的花括号表示对象字面变量的开始，因为它出现在了表达式上下文中。然后我们定义了name属性，之后是一个冒号，再后面是这个属性的值。在对象字面量中，使用逗号来分隔不同的属性，因此“tom”后面是一个逗号，但是在age属性的值29的后面不能添加逗号，因为age是这个对象的最后一个属性。在最后一个属性后面添加逗号，会在IE7以及更早版本和Opera中导致错误。
 
 在使用对象字面量语法时，属性名也可以使用字符串，如下面这个例子：var person = {"name" : "tom", "age" : 21, 5 : true};这个例子会创建一个对象，包含三个属性：name,age和5，但这里的数值属性名会自动转换为字符串。
 
 另外，使用对象字面量语法时，如果留空其花括号，则可以定义为只包含默认属性和方法的对象，如下所示：var person = { };person.name = "tom";person.age=21;这个例子与本节前面的例子是等价的，只不过看起来似乎有点奇怪。
 
 以下是我另外找的补充：
 
 原文地址：http://www.w3cplus.com/javascript/create-an-object-methods.html
 
 对象是JavaScript的基本数据类型。在JavaScript中除了字符串、数字、true、false、null和undefined之外的值都是对象。所以，学习JavaScript不把对象学习明白要继续往下学习就非常的困难。从今天开始进入对象的学习中。
 
 概述
 
 在JavaScript中对象是一种基本的数据类型，在数据结构上是一种散列表，可以看作是属性的无序集合，除了原始值其他一切都是对象。可通过属性名访问这些值，而属性名可以是包含空字符在内的任意字符串。简单点说，一个对象就是一系列属性的集合，一个属性包含一个名字(key)和一个值(value)。
 
 理解什么是JavaScript对象，你可以这样来想。在JavaScript中，一个对象就是一个具有属性的特体。就拿你看到的一妹子，这妹子就是一个对象，她有自己的属性。比如妹子身高，年龄，姓名等。同样，在JavaScript中，也可以用属性来给对象定义它的特征。
 
 创建对象
 
 既然要学习对象，那得先要有一个对象，这样问题就来了，JavaScript中对象要怎么创建呢？接下来就来看看在JavaScript中如何创建对象。
 
 很多有关于JavaScript书在介绍对象创建的方法时，主要有：
 
 使用对象字面量创建对象(key-value)
 使用new创建对象
 使用Object.create()创建对象
 使用函数创建对象
 使用原型创建对象
 
 使用对象字面量创建对象
 
 对象字面量是创建对象最简单的一种形式，目的是在于简化创建包含大量属性的对象的过程。对象字面量由若干属性名(keys)和属性值(values)成对组成的映射表，key和value中间使用冒号(:)分隔，每对key/value之间使用逗号(,)分隔，整个映射表用花括号({})括起来。
 
 通过对象字面量创建对象的语法如下：
 
var obj = {
    property_1:   value_1,   // property_# 可能是一个标识符...
    2:            value_2,   // 或者是一个数字
    // ...,
    "property n": value_n    // 或是一个字符串
};
 
 这里obj是创建的对象的名称，每一个property_i是一个标识符(可以是一个名称、数字或字符串字面量),并且每个value_i是一个其值，并且将这个值赋予给property_i。来看一个具体实例：
 
var girl = {
    'name': '欣欣',
    'age' : 18,
    'height': 175,
    'weight': 45
}
 
 这个示例创建了一个名为girl的对象，对象有四个属性name、age、height和weight。这四个属性对应有一个属性值。
 
 使用对象字面量创建对象时，如果留空其花括号({})，则可以定义只包含默认属性和方法的对象。如：
 
var obj = {}
 
 使用这种方式创建的对象时，可以通过点(.)，也就是obj.key给对象obj创建对象属性，并且赋予对象的属性值。另外也可以通过方括号([])，也就是obj['key']给对象obj创建对象属性，并且赋予对象的属性值。如下面的示例：
 
var girl = {};
girl.name = '欣欣';
girl.age = 18;
girl['height'] = 175;
girl['weight'] = 45;
 
 此时在Chrome中打印girl对象时，输出的结果如下所示：
 
console.log(girl);
//Object {name: "欣欣", age: 18, height: 175, weight: 45}
 
 使用new创建对象
 
 使用new操作符后跟Object构造函数(有关于构造函数，后面再讲)也可以创建对象:
 
var obj = new Object(); // 和 obj = {}相同
 
 虽然初始状态下，obj是一个空对象，但在JavaScript中可以很方便地动态添加和使用成员，所以我们可以不断加入成员变量和方法。如：
 
var girl = new Object();
girl['name'] = '欣欣';
girl['age'] = 18;
girl['height'] = 175;
girl['weight'] = 45;
 
 使用Object.create()创建对象
 
 对象也可以用Object.create()方法创建。该方法非常有用，因为它允许你为创建的对象选择其原型对象，而不用定义一个构造函数。
 
 
 
Object.create()方法创建一个拥有指定原型和若干个指定属性的对象。
 
 
Object.create(proto, [ propertiesObject ])
 
 Object.create()方法创建一个对象，其接受两个参数，其中第一个参数是这个对象的原型对象proto；第二个是一个可选参数，用以对对象的属性做进一步描述。这个方法使用很简单：
 
var obj1 = Object.create({
    x: 1,
    y: 2
});    //对象obj1继承了属性x和y
var obj2 = Object.create(null);    //对象obj2没有原型
 
 
 
如果 proto 参数不是 null 或一个对象值，则抛出一个 TypeError 异常。
 
 
 有关于Object.create()方法更多的示例可以点击这里进行了解。
 
 使用函数创建对象
 
 在实际使用当中，字面量创建对象虽然很有用，但是它并不能满足我们的所有需求，我们希望能够和其他后台语言一样创建一个类，然后声明类的实例就能够多次使用，而不用每次使用的时候都要重新创建它。
 
 因为JavaScript没有类，一般都是使用函数来定义一个类似其他语言中的类格式，比如：
 
function Person() {
    this.name = "mary"; // 为这个类添加一个成员变量name，并为这个成员变量赋默认值
    this.age = 5;
    this.sayHello = function () {
        console.log(this.name + " : " + this.age);
    };
}
 
 定义好类之后，我们就可以像下面这样创建和使用对象：
 
var person1 = new Person();
person1.name = 'Tom';
person1.age = 20;
person1.sayHello(); // Tom : 20

var person2 = new Person();
person2.name = 'W3cplus';
person2.age = 5;
person2.sayHello(); // W3cplus : 5
 
 Person()函数不是用来被调用的，它是用来被new用的。
 
 通过原型创建对象
 
 这种方法比较前几种方法来说算是最为复杂，最为高级的方法。这里还涉及到封装的一些知识(有关于这些后续学习到了再记录)。这里简单看看如何通过原型创建对象。
 
 首先像函数方法创建对象一样，先定义一个函数：
 
function Person() {
    this.name = "W3cplus";
    this.age = 5;
    this.walk = function () {
        console.log("一个前端网站...");
    };
}
 
 然后在外部可以扩允成员：
 
//添加成员方法
Person.prototype.sayHello = function () {
    console.log("hello");
};
//也可以添加成员属性，
Person.prototype.height = 100;
 
 一方面，原型可以扩充原有类的功能(特别是添加有用方法)，也可以像下面这样写:
 
function Person() { }

Person.prototype.name = "W3cplus";
Person.prototype.age = 5;
Person.prototype.walk = function () {
    console.log("一个前端网站...");
};

Person.prototype.sayHello = function () {
    console.log("hello");
};
Person.prototype.height = 100;
 
 属性访问
 
 对象属性访问一般有两种方法，第一种是使用点(.)表示法，这也是最常用的一种方法，也是很多面向对象语言中通用的语法。第二种方法还可以使用中括号([])表示法来访问对象的属性。在使用中括号语法时，应该将要访问的属性以字符串的形式放在中括号中。如下：
 
person['name'];
person.name;
 
 从功能上来说，上面两种方法访问对象属性没有任何区别。但中括号语法的主要优点有两个：
 
 可能通过变量访问属性，如下：
 
var propertyName = 'name';
person[propertyName];
 
 另外一个优点是，如果属性名中包含了会导致语法错误的字符或者属性名使用的是关键字或保留字，可以使用中括号访问属性，如下：
 
person['first name'];
 
 一般情况之下，除非必须使用亦是来访问对象属性，否则建议使用点(.)的方法来访问对象属性。
 
 总结
 
 对象是JavaScript的基本数据类型，如果要更好的往下学习JavaScript相关的知识，很有必要先把对象整明白。这篇主要介绍了几种创建对象的方法。较为简单的是通过字面量({})和new Object()方法创建，但这两种方法创建的对象复用性较差；使用Object.create()创建对象时不需要定义一个构造函数就允许你在对象中选择其原型对象。除了这几种方法还可以使用函数和原型创建对象，而这两种方法相对来说可复用性强，只是使用较为复杂。