前言:
如果你很想搞明白面向对象是什么，面向过程是什么，或者说二者之间的区别是什么，那么就花费一点时间来研读一下这篇博客，你一定会有很大的收获的！
一、面向对象与面向过程的区别
面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了；面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
可以拿生活中的实例来理解面向过程与面向对象，例如五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用不同的方法来实现。
如果是面向对象的设计思想来解决问题。面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。
可以明显地看出，面向对象是以功能来划分问题，而不是步骤。同样是绘制棋局，这样的行为在面向过程的设计中分散在了多个步骤中，很可能出现不同的绘制版本，因为通常设计人员会考虑到实际情况进行各种各样的简化。而面向对象的设计中，绘图只可能在棋盘对象中出现，从而保证了绘图的统一。
上述的内容是从网上查到的，觉得这个例子非常的生动形象，我就写了下来，现在就应该理解了他俩的区别了吧，其实就是两句话，面向对象就是高度实物抽象化、面向过程就是自顶向下的编程！
二、面向对象的特点
 在了解其特点之前，咱们先谈谈对象，对象就是现实世界存在的任何事务都可以称之为对象，有着自己独特的个性

属性用来描述具体某个对象的特征。比如小志身高180M，体重70KG，这里身高、体重都是属性。

面向对象的思想就是把一切都看成对象，而对象一般都由属性+方法组成！
属性属于对象静态的一面，用来形容对象的一些特性，方法属于对象动态的一面，咱们举一个例子，小明会跑，会说话，跑、说话这些行为就是对象的方法！所以为动态的一面， 我们把属性和方法称为这个对象的成员！
类：具有同种属性的对象称为类，是个抽象的概念。比如“人”就是一类，期中有一些人名，比如小明、小红、小玲等等这些都是对象，类就相当于一个模具，他定义了它所包含的全体对象的公共特征和功能，对象就是类的一个实例化，小明就是人的一个实例化！我们在做程序的时候，经常要将一个变量实例化，就是这个原理！我们一般在做程序的时候一般都不用类名的，比如我们在叫小明的时候，不会喊“人，你干嘛呢！”而是说的是“小明，你在干嘛呢！”
面向对象有三大特性，分别是封装性、继承性和多态性，这里小编不给予太多的解释，因为在后边的博客会专门总结的！
三、面向过程与面向对象的优缺点
很多资料上全都是一群很难理解的理论知识，整的小编头都大了，后来发现了一个比较好的文章，写的真是太棒了，通俗易懂，想要不明白都难!
用面向过程的方法写出来的程序是一份蛋炒饭，而用面向对象写出来的程序是一份盖浇饭。所谓盖浇饭，北京叫盖饭，东北叫烩饭，广东叫碟头饭，就是在一碗白米饭上面浇上一份盖菜，你喜欢什么菜，你就浇上什么菜。我觉得这个比喻还是比较贴切的。
蛋炒饭制作的细节，我不太清楚，因为我没当过厨师，也不会做饭，但最后的一道工序肯定是把米饭和鸡蛋混在一起炒匀。盖浇饭呢，则是把米饭和盖菜分别做好，你如果要一份红烧肉盖饭呢，就给你浇一份红烧肉；如果要一份青椒土豆盖浇饭，就给浇一份青椒土豆丝。
蛋炒饭的好处就是入味均匀，吃起来香。如果恰巧你不爱吃鸡蛋，只爱吃青菜的话，那么唯一的办法就是全部倒掉，重新做一份青菜炒饭了。盖浇饭就没这么多麻烦，你只需要把上面的盖菜拨掉，更换一份盖菜就可以了。盖浇饭的缺点是入味不均，可能没有蛋炒饭那么香。
到底是蛋炒饭好还是盖浇饭好呢？其实这类问题都很难回答，非要比个上下高低的话，就必须设定一个场景，否则只能说是各有所长。如果大家都不是美食家，没那么多讲究，那么从饭馆角度来讲的话，做盖浇饭显然比蛋炒饭更有优势，他可以组合出来任意多的组合，而且不会浪费。
盖浇饭的好处就是"菜"“饭"分离，从而提高了制作盖浇饭的灵活性。饭不满意就换饭，菜不满意换菜。用软件工程的专业术语就是"可维护性"比较好，“饭” 和"菜"的耦合度比较低。蛋炒饭将"蛋”“饭"搅和在一起，想换"蛋”"饭"中任何一种都很困难，耦合度很高，以至于"可维护性"比较差。软件工程追求的目标之一就是可维护性，可维护性主要表现在3个方面：可理解性、可测试性和可修改性。面向对象的好处之一就是显著的改善了软件系统的可维护性。

　　
看了这篇文章，简单的总结一下!
面向过程

优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、                                                                                                                      Linux/Unix等一般采用面向过程开发，性能是最重要的因素。

缺点：没有面向对象易维护、易复用、易扩展

面向对象

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统                         更加灵活、更加易于维护

缺点：性能比面向过程低

javascript 数组以及对象的深拷贝（复制数组或复制对象）的方法
前言
在js中，数组和对象的复制如果使用=号来进行复制，那只是浅拷贝。如下图演示：


如上，arr的修改，会影响arr2的值，这显然在绝大多数情况下，并不是我们所需要的结果。

因此，数组以及对象的深拷贝就是javascript的一个基本功了。

评论中有很多人说我误导大家。说这些都是浅拷贝。我不做过深的阐述，本文中涉及到的都是比较浅显的内容。诸位请根据自己的需要以及情况自行判断和理解。

数组的深拷贝
条条大道通罗马，实现数组的深拷贝，是有好几种方法的。举例如下：
for 循环实现数组的深拷贝
for循环是非常好用的。如果不知道高级方法，通过for循环能够完成我们大多数的需求。
var arr = [1,2,3,4,5]
var arr2 = copyArr(arr)
function copyArr(arr) {
	let res = []
	for (let i = 0; i < arr.length; i++) {
	 res.push(arr[i])
	}
	return res
}

如上，通过对数组的for循环，即可实现对数组的深拷贝了。
slice 方法实现数组的深拷贝
这个代码实现非常简单。原理也比较好理解，他是将原数组中抽离部分出来形成一个新数组。我们只要设置为抽离全部，即可完成数组的深拷贝。代码如下：
var arr = [1,2,3,4,5]
var arr2 = arr.slice(0)
arr[2] = 5
console.log(arr)
console.log(arr2)

运行结果如下：


更多 slice 内容请访问 w3school JavaScript slice 方法

concat 方法实现数组的深拷贝
这个代码也非常简单，原理更加粗暴。它是用于连接多个数组组成一个新的数组的方法。那么，我们只要连接它自己，即可完成数组的深拷贝。代码如下：
var arr = [1,2,3,4,5]
var arr2 = arr.concat()
arr[2] = 5
console.log(arr)
console.log(arr2)

运行结果如下：


更多 concat 内容请访问 w3school JavaScript concat 方法

2017年10月31日补充：ES6扩展运算符实现数组的深拷贝
OK，以上之前讲的方法全部过时了，用下面的方法实现数组的深拷贝是最简单的。
var arr = [1,2,3,4,5]
var [ ...arr2 ] = arr
arr[2] = 5
console.log(arr)
console.log(arr2)

运行结果如下：

对象的深拷贝
对象的深拷贝相比数组也没有困难许多，列举两个方法。
万能的for循环实现对象的深拷贝
在很多时候，for循环能够解决大问题。
var obj = {
  name: 'FungLeo',
  sex: 'man',
  old: '18'
}
var obj2 = copyObj(obj)
function copyObj(obj) {
  let res = {}
  for (var key in obj) {
    res[key] = obj[key]
  }
  return res
}

转换成json再转换成对象实现对象的深拷贝
上面的代码实在是比较长，所以，用一个更暴力的方法吧！代码如下：
var obj = {
  name: 'FungLeo',
  sex: 'man',
  old: '18'
}
var obj2 = JSON.parse(JSON.stringify(obj))

这个原理没什么好解释的，实在是够简单粗暴的啦！
2017年10月31日补充： 扩展运算符实现对象的深拷贝
var obj = {
  name: 'FungLeo',
  sex: 'man',
  old: '18'
}
var { ...obj2 } = obj
obj.old = '22'
console.log(obj)
console.log(obj2)

运行结果如下：

小结
数组和对象的深拷贝是js中最常见的应用。理解各种方法是必须的。希望对大家有所帮助。

本文中并没有对异常进行处理，主要在讲原理。更多的数组以及对象的操作方法，可以参考lodash的源码，查看它的源码可以让你的js基础变得非常牢固。我也在学习中。

2017年10月31日补充，使用es6提供的扩展运算符的方法实现深拷贝，简单，高效。并且，对象的深拷贝不会像使用 JSON 方法深拷贝一样，丢失函数等信息，只能用来深拷贝 JSON 数据格式的对象。推荐大家使用。

补充一个数组去重的方法
function dedupe(array) {
  return [...new Set(array)]
}
var arr = [1,2,2,3,3,4,4,5,5]
console.log(dedupe(arr))

运行结果如下：

2021年03月29日 补充
这里说的深拷贝，都是指一维的数组和对象的深拷贝。鉴于评论中多人指出，这些是浅拷贝，我本来不想回应，但是提出这个观点的人很多，因此我在这边回应一下。
浅拷贝的概念不重复了，上文中已经说明。文章中的多种方法，均不是浅拷贝，只是是否支持多维数据而已。而在绝大多数场景下，文中的方法是适用的。
想要简便的支持多维数据的深拷贝，可以直接适用 JSON 方式。或适用 lodash 工具实现。
版权申明：本文由FungLeo原创，允许转载，但转载必须附注首发链接。谢谢。

public class TestA {
	private Integer a;
	public Integer getA() {
		return a;
	}
	public void setA(Integer a) {
		this.a = a;
	}
}
public class Test {
	public static void main(String[] args) {
		TestA a = new TestA();
		a.setA(1);
		TestA aa = a;
		a.setA(3);
		System.out.println(aa==a);
		System.out.println(aa.getA());
	}
}

输出结果是true和3，这理解起来很简单，java中对象直接"="赋值其实就是将引用传给对方，让他也指向同一个内存地址。

所以如果a改变了里面属性的值，那这个地址存储的内容就变了，当aa去拿的时候就是变了之后的，因为两个指向依然同一个地址，

所以aa==a是true的。

但如果这么来：
  TestA a = new TestA();
		a.setA(1);
		TestA aa = a;
  a = new TestA();
		a.setA(3);
		System.out.println(aa==a);
		System.out.println(aa.getA());

那输出就是false和1了，因为a又重新new了一个对象，他引用的地址已经变了，就和aa一点关系都没有了！
以上我们都知道，但对于包装类却看似不一样：
public class Test {
	public static void main(String[] args) {
		Integer b = new Integer(5);
		Integer c = b;
		System.out.println(b==c);
		b = b+1;
		System.out.println(b);
		System.out.println(c);
		System.out.println(b==c);
	}
}

以上的运行结果是：

true

6

5

false

这似乎和我们之前的例子不一样了。c和b都指向同一个地址，所以第一次bc是true的，但当b加1之后，c并没有跟着b加1，

bc变成了false，说明两个指向的地址已经不是同一个了。

一开始对这个可能无法理解，我们先看看下面的例子：
public class Test {
	public static void main(String[] args) {
		int x = 1;
		int y = x;
		x = x+1;
		System.out.println(y==x);
	}
}

输出是false，这个我们很容易知道，一开始x和y都是1，当x加1之后，x是2，y还是1，所以yx是false的，数值型的变量在判断时是直接比较他们的值的。
再回忆一下java的装箱和拆箱：

所谓装箱，就是把基本类型用它们相对应的引用类型包起来，使它们可以具有对象的特质，如我们可以把int型包装成Integer类的对象，或者把double包装成Double，等等。

所谓拆箱，就是跟装箱的方向相反，将Integer及Double这样的引用类型的对象重新简化为值类型的数据。

JDK1.5之后可自动进行装箱和拆箱的操作，例子如下：
int i=10;
Integer j=Integer.valueOf(i); //手动装箱操作
int k=j.intValue();//手动拆箱操作

int i1=10
Integer j1=i1;//自动装箱操作
int k1=j1;//自动拆箱操作

通过上面的讲解应该就知道原因了：
	Integer b = new Integer(5);
	Integer c = b;
	System.out.println(b==c);//现在两个指向同一个地址，是true的
	b = b+1;//b是包装类，得拆箱成数值型，然后加1，变成数值6，然后把数值6再装箱变成包装类赋给b，等同于b=Integer.valueOf(b.intValue()+1);
	//Integer.valueOf()会生成一个新的包装类对象(因为valueOf()方法的源码里写着，return的是new Integer()，源码见下)
	System.out.println(b==c);//现在两个指向不同的地址，是false的

终于真相大白了，上面的问题告一段落，我自以为对包装类很懂了，但再看看下面的题目：
    Integer b = 128;
	Integer c = 128;
	System.out.println(b==c);

输出是false，这很好理解，128是数值型的，再赋值给包装类变量时先要装箱，上面的等同于：
     	Integer b = Integer.valueOf(128);
		Integer c = Integer.valueOf(128);
		System.out.println(b==c);

这样很明显可以看成是false的，是两个不同的对象。

再看看这个：
     	Integer b = 100;
		Integer c = 100;
		System.out.println(b==c);

输出居然是true。小学生表示已经崩溃，是不是对java已经无爱了。但是我可不会就这样放弃，到底是什么原因呢？

查看Integer的valueOf方法的源码如下：
public static Integer valueOf(int i) {
final int offset = 128;
if (i >= -128 && i <= 127) { // must cache 
    return IntegerCache.cache[i + offset];
}
    return new Integer(i);
}

于是明白了，在【-128，127】之间的数字，valueOf()返回的是缓存中的对象，所以两次调用返回的是同一个对象。

也就是说Integer(100)这样的对象已经有了一个了，自动装箱之前就不去new了，直接使用缓存里的，所以是同一个对象，指向的是同一个引用地址。

以上代码等同于:
     	Integer b = Integer.valueOf(100);
		Integer c = Integer.valueOf(100);
		System.out.println(b==c);

所以输出是true。

接下来下面这个也很明白了吧：
    Integer a = new Integer(100);  
    Integer b = 100;  
    System.out.println(a == b);

输出的是false，因为a是自己new的对象，不是通过valueOf获取的，没有放进缓存里，所以b在valueOf时还是会new一个

以上代码等同于：
    Integer a = new Integer(100);  
  	Integer b = Integer.valueOf(100);  
    System.out.println(a == b);

这样就看的出来是false了。

总之以上的现象只会在拆装箱，或者你自己手动调用valueOf方法时才会出现！

var obj = {}；
1、toString（推荐）
Object.prototype.toString.call(obj) === '[object Object]'

2、constructor
obj.constructor === Object

3、instanceof      需要注意的是由于数组也是对象，因此用 arr instanceof Object 也为true。
obj instanceof Object

4、typeof
typeof obj === Object

// 根据typeof判断对象也不太准确
表达式	                      返回值
typeof undefined	       'undefined'
typeof null	               'object'
typeof true	               'boolean'
typeof 123	               'number'
typeof "abc"	           'string'
typeof function() {}	   'function'
typeof {}	               'object'
typeof []	               'object'

5、$.isPlainObject()

判断指定参数是否是一个纯粹的对象（所谓"纯粹的对象"，就是该对象是通过"{}"或"new Object"创建的。）
$.isPlainObject(obj)