1.基本类型：Underfined ,Null, Boolean,Number,String
2.引用类型： Object，Array，Date，Function
首先了解一个概念：栈内存与堆内存---这是两种不同的内存分配方法
一般代码逻辑，简单变量，结构体都是放在栈中；而对象，以及被装箱的数据放在堆中


栈内存中存放地址指向堆内存中的对象
基本类型就是保存在栈内存中的简单数据段，而引用类型指的是那些保存在堆内存中的对象
基本类型在内存中分别占有固定大小的空间，他们的值保存在栈空间中，我们通过按值访问
引用类型：值的大小不固定，栈内存中存放地址指向堆内存中的对象，是按引用访问的。栈内存中存放的只是该对象的访问地址
3.在堆内存中为这个值分配空间。由于这种值的大小不固定，因此不能把他们保存在栈内存中。但内存地址大小是固定的，因此可以将内存地址保存在栈内存中。这样，当查询引用类型的变量时，先从栈中读取内存地址，然后再通过地址找到堆中的值。对于这种，我们把它叫做按引用访问。
当我们看到一个变量类型是已知的，就分配在栈里面，比如INT，Double等，其它未知的类型，比如自定义类型，因为系统不知道需要多大，所以程序自己申请，这样就分配在堆里面。基本类型大小固定，引用类型大小不固定，分开存放使得程序运行占有内存最小。
4.基本类型在当前执行环境结束时销毁，而引用类型不会随执行环境结束而销毁，只有当所有引用它的变量不存在是这个对象才被垃圾回收机制回收。


基本类型有一下几个特点：
1.基本类型的值是不可变的
任何方法都无法改变一个基本类型的值，比如一个字符串：


var name  = 'hello';

name.toUpperCase();  //输出HELLO

console.log(name);   //输出 hello


会发现原始的name并未发生改变，而是调用了toUpperCase()方法后返回的是一个新的字符串
再来个例子：
var person = 'Mary';

person.age = 22;

person.method = function(){};

console.log(person.age); //underfined

console.log(person.method);//underfined


通过上面代码可知，我们不能给基本类型添加属性与方法，再次说明基本类型是不可变的


2.基本类型的比较是值的比较
只有他们的值相等的时候他们才相等
var a =1;

var b = true;

console.log(a==b);  //true


有这个疑问，这就得了解一下类型转换和 == 运算符的知识了，也就是说在用==比较两个不同类型的变量是会进行一些类型转换，像上面的比较先会把true转换为1，再和数字1笔记，结果就是true了。这是当比较两个值的类型不同的时候的时候==运算符会进行类型转换，但是当两个值的类型相同的时候，即使是 == 也相当于 ===。
3.基本类型的变量是存放在栈区的（栈区指内存里的栈内存）


引用类型：除了基本类型就是引用类型，也就是说对象。对象是属性与方法的集合
也就是说引用类型可以拥有属性与方法，属性又可以包含基本类型与引用类型。来看看引用类型的一些基本特性：
1.引用类型的值是可变的
我们可以为引用类型添加属性与方法，也可以删除其属性与方法。如：
var person = {}; //创建一个对象 ---引用类型

person.name = 'Mary';

person.age = 22;

person.sayName = function() {console.log(person.name);}

person.sayName(); //'Mary'

delete person.name;  //删除person对象的name属性

person.sayName();  //underfined




上面代码说明来引用类型可以拥有方法与属性，并且可以动态改变


2.引用类型的值是同时保存在栈内存和堆内存中的对象
    js与其它语言不同，其不允许直接访问内存中的地址，也就是说不能直接操作对象的内存空间，那我们操作啥呢实际上，是操作对象的引用，所以引用类型的值是按引用访问的。

准确的说，引用类型的存储需要内存的栈区和堆区（堆区是指内存里的堆内存）共同完成，栈区内存保存变量标识符和指向堆内存中该对象的指针，也就是说该对象在堆内存的地址。
假如有以下几个对象：
这三个对象在内存中保存的情况如下图：
var person1 = {name: 'Mary'};
var person2 = {name: 'xioaming'};
var person3 = {name: 'xiaohua'};





3.引用类型的比较是引用的比较
 
var person1 = '{}';
var person2 = '{}';
console.log(person1 == person2);  //true


上面讲基本类型的比较的时候提出里当两个比较值的类型相同的时候，相当于用 === ，所以输出是true；
这里比较的是两个对象，为啥就不相等了呢：
var person1 = {};
var person2 = {};
console.log(person1 ==person2);  //false




⚠️别忘了，引用类型是按引用访问的，换句话说，就是比较两个对象的堆内存的地址是否相同，那很明显，person1 和 person2在堆内存中地址是不同的


所以这两个是完全不同的对象，所以返回false；


3.简单赋值
从一个变量向另一个变量赋值基本类型时，会在该变量上创建一个新值，然后再把该值复制到为新变量分配的位置上：
var a =10;
var b =a;
a ++;
console.log(a); //11
console.log(b); //10


此时，a中保存的值为10，当使用a来初始化b时，b中保存的值也为10，但b中的10与a中的是安全独立的，该值只是a中的值的一个副本，此后，这两个变量可以参加任何操作而相互不受影响。


也就是说，基本类型在赋值操作后，两个变量是相互不受影响的。
4.对象引用
从一个变量向另一个变量赋值引用类型的值时，同样也会将存储在变量中的对象的值复制一份放到新变量分配的空间中，前面讲引用类型的时候提到过，
保存在变量中的是对象在堆内存中的地址，所以，与简单赋值不同，这个值的副本实际上是一个指针，而这个指针指向存储在堆内存的一个对象，那么赋值操作后，两个变量都保存了同一个对象地址，则两个变量指向了同一个对象。因此，改变其中任何一个变量，都会相互影响：
var a ={};
var b = a;
a.name = 'Mary';
console.log(a.name); //'Mary'
console.log(b.name);//'Mary'

b.age = 22;
console.log(b.age); //22
console.log(a.age); //22
console,.log(a==b);  //true




引用类型的赋值其实是对象保存在栈区地址指针的赋值，因此两个变量指向同一个对象，任何操作都会相互影响。

引用类型：类class，对象object，数组type []，字符串 string，委托delegate，接口interface

值类型：整数int，浮点数float double，布尔bool，字符char，结构struct，枚举enum

1、什么是引用类型
 
引用类型（reference type）指向一个对象，不是原始值，指向对象的变量是引用变量。

在java里面除去基本数据类型的其它类型都是引用数据类型，自己定义的class类都是引用类型，可以像基本类型一样使用。

示例如下：

public class MyDate {
    private int day = 8;
    private int month = 8;
    private int year = 2008;
    private MyDate(int day, int month, int year){...}
    public void print(){...}
}
public class TestMyDate {
    public static void main(String args[]) {
        //这个today变量就是一个引用类型的变量
        MyDate today = new MyDate(23, 7, 2008);
    }
}
 
2、引用类型的赋值
 
在java编程语言中，用类的一个类型声明的变量被指定为引用类型，这是因为它正在引用一个非原始类型，这对赋值具有重要的意义。如下代码：

int x = 7;
int y = x;
String s = "Hello";
String t = s;

四个变量被创建：两个原始类型 int 和两个引用类型String。x的值是7，而这个值被复制到y；x和y是两个独立的变量且其中任何一个的进一步的变化都不对另外一个构成影响。至于变量s和t，只有一个String对象存在，它包含了文本"Hello"，s和t均引用这个单一个对象。

java中的引用类型概念

如果将变量t重新定义为t="World"；则新的对象World被创建，而t引用这个对象。      

 java中的引用类型概念
 
3、按值传递和按引用传递的区别
 
1）按值传递

指的是在方法调用时，传递的参数是按值的拷贝传递。示例如下：
 
public class TempTest {
private void test1(int a) {
// 做点事情
a++;
}
 
 
  
public static void main(String args[]) {
TempTest t = new TempTest();
int a = 3;
t.test1(a);//这里传递的参数a就是按值传递。
System.out.printIn(“main方法中的a===” + a);
}
}
 
按值传递的重要特点：传递的是值的拷贝，也就是说传递后就互不相关了。第9行的a和第2行的a是两个变量，当改变第2行的a的值，第9行a的值是不变的，所以打印结果是3。
 
main 方法中的a 为 3 
 test1 方法中的a 为 4
 
我们把第9行的a称之为实参，第2行的a称之为形参；对于基本数据类型，形参数据的改变，不影响实参的数据。
 
2）按引用传递
 
指的是在方法调用时，传递的参数是按引用进行传递，其实传递的是引用的地址，也就是变量所对应的内存空间的地址。
 
示例如下：
public class TempTest {
private void test1(A a) {
a.age = 20;
System.out.printIn(“test1方法中的age=”+a.age);
}
public static void main(String args[]) {
TempTest t = new TempTest();
A a = new A();
a.age = 10;
t.test1(a);// 这里传递的参数a就是按引用传递
System.out.printIn(“main方法中的age=”+a.age);
}
}
classA {
public int age = 0;
} 
 
运行结果如下：test1方法中的age = 20 main方法中的age = 20
 
按引用传递的重要特点：
 
传递的是值的引用，也就是说传递前和传递后都指向同一个引用（也就是同一个内存空间）。
 
要想正确理解按引用传递的过程，就必须学会理解内存分配的过程，内存分配示意图可以辅助我们去理解这个过程。
 
用上面的例子来进行分析：
 
（1）、运行开始，运行第8行，创建了一个A的实例，内存分配示意图如下：
 
main方法中的a 
 
java中的引用类型概念
 
（2）、运行第9行，修改了A实例里面的age的值，内存分配示意图如下： 
 
main方法中的a 
 
java中的引用类型概念
 
（3）、运行第10行，是把main方法中的变量a所引用的内存空间地址，按引用传递给test1方法中的a变量。请注意：这两个a变量是完全不同的，不要被名称相同所蒙蔽，但它们指向了同一个A实例。内存分配示意图如下：
 
java中的引用类型概念
 
（4）、运行第3行，为test1方法中的变量a指向A实例的age进行赋值，完成后形成新的内存示意图如下：
 
java中的引用类型概念 
 此时A实例的age值的变化是由test1方法引起的。
 
（5）、运行第4行，根据此时的内存示意图，输出test1方法中的age=20
 
（6）、运行第11行，根据此时的内存示意图，输出main方法中的age=20
 
3）对上述例子的改变
 
理解了上面的例子，可能有人会问，那么能不能让按照引用传递的值，相互不影响呢？就是test1方法里面的修改不影响到main方法里面的呢？
 
方法是在test1方法里面新new一个实例就可以了。改变成下面的例子，其中第3行为新加的：
public class TempTest {
private void test1(A a) {
a = new A();// 新加的一行
a.age = 20;
System.out.printIn(“test1方法中的age=”+a.age);
}
public static void main(String args[]) {
TempTest t = new TempTest();
A a = new A();
a.age = 10;
t.test1(a);// 这里传递的参数a就是按引用传递
System.out.printIn(“main方法中的age=”+a.age);
}
}
classA {
public int age = 0;
} 
 
运行结果为：test1方法中的age=20 main方法中的age=10
 
实现了按引用传递的值传递前与传递后互不影响，还是使用内存示意图来理解一下：
 
（1）、运行开始，运行第9行，创建了一个A实例，内存分配示意图如下：
 
java中的引用类型概念
 
（2）、运行第10行，是修改A实例里面的age的值，运行后内存分配示意图如下：
 
java中的引用类型概念
 
（3）、运行第11行，是把mian方法中的变量a所引用的内存地址，按引用传递给test1方法中的a变量。请注意：这两个a变量是完全不同的，不要被名称相同所蒙蔽。
 
java中的引用类型概念
 
（4）、运行第3行，为test1方法中的变量a重新生成了新的A实例，完成后形成的新的内存示意图如下：
 
java中的引用类型概念
 
（5）、运行第4行，为test1方法中的变量a指向的新的A实例的age进行赋值，完成后形成新的内存示意图如下：
 
java中的引用类型概念
 
注意：这个时候test1方法中的变量a的age被改变，而main方法中的a变量是没有改变的。
 
（6）、运行第5行，根据此时的内存示意图，输出test1方法中的age=20
 
（7）、运行第12行，根据此时的内存示意图，输出main方法中的age=10
 
说明：
 
（1）、“在Java里面参数传递都是按值传递”这句话的意思是：按值传递是传递的值的拷贝，按引用传递其实传递的是引用的地址值，所以统称按值传递。
 
（2）、在Java里面只有基本类型和按照下面这种定义方式的String是按值传递，其它的都是按引用传递。就是直接使用双引号定义的字符串方式：String str = “Java快车”;
 
http://blog.sina.com.cn/s/blog_7fb1495b01012sfn.html

两者的区别可以主要从以下三个方面说起：1：内存空间   2：对值的操作   3：变量的复制    
    《javascript高级程序设计》中对于二者的定义是：基本类型值指的是简单的数据段，而引用类型值指那些可能由多个值构成的对象。
    基本数据类型包括  number string boolean undefined  null 

    引用类型包括:array  object function

1:内存空间
    我们将js的内存分为栈内存和堆内存；基本类型存放于栈内存中，包括变量以及变量的值。
例如：
var name = 'jozo';
var city = 'guangzhou';
var age = 22;



引用类型是大小不固定的数据，但是他们的地址大小是固定的，所以把地址存在栈中而值存在堆中。
var person1 = {name:'jozo'};
var person2 = {name:'xiaom'};
var person3 = {name:'xiaoq'};


2：对值的操作
基本类型值：按值访问，操作的是他们实际保存的值


 引用类型值：按引用访问，当查询时，我们需要先从栈中读取内存地址，然后再找到保存在堆内存中的值。对于引用类型的值，我们可以为其添加属性和方法，也可以改变和删除其属性的方法。
 
3：变量的复制


      基本类型变量的复制：从一个变量向另一个复制时，会在栈中创建一个新值，然后把值复制到为新变量分配的位置上。


 



     引用类型变量的复制：复制的是存储在栈中的指针，将指针复制到栈中为新变量分配的空间中，而这个指针副本和原指针指向存储在堆中的同一个对象，复制操作结束后，两个变量实际上将引用同一个对象，因此改变其中一个，将影响另一个。