引用数据类型和基本数据类型的一些区别

首先先举几个引用数据类型的例子：
　　String                StringBuffer                类(包括自己定义的一些类和包中有的类)                        integer                等
下面的是基本数据类型
       Int                        double                char                        Boolean                        等



表面上可以看出两个区别(单从类的角度来看)：
引用数据类型必须要实例化之后才可以使用，(String        和        integer除外)
注：String是一个很特殊的引用数据类型
        Inteter是在在使用的过程中会自动的装箱和拆箱
例如：StringBuffer  sb  =  new  StringBuffer();
引用数据类型或多或少的会有一些属性和方法
例如：类里面包含的就是属性和方法，比如StringBuffer里面就有append()方法                还有charAt()方法
深入点看：
引用数据类型是指针的指向，基本数据类型则在内存中直接得到
1.下面一个列子是一个值传递的过程
例如：
        下面是一个类的方法

1.                         public void changeNumber(int a,int b)
   
2.                         {
   
3.                                 int temp=a;
   
4.                                 a=b;
   
5.                                 b=temp;
   
6.                                 System.out.println("交换后的两数 a="+a+"  b="+b);
   
7.                          }
   
8. 
   
9.                         //在main方法中
   
10.                         public static void main(String[] args)
    
11.                         {
    
12.                                 //实例化的一个过程
    
13.                                 Exam9 ex=new Exam9();
    
14.                
    
15.                                 int a=10;
    
16.                                 int b=5;
    
17.                                 System.out.println("交换前的两数 a="+a+"  b="+b);
    
18.                                 //调用交换的方法
    
19.                                 ex.changeNumber(a, b);
    
20.                                System.out.println("方法调用后的两数 a="+a+"  b="+b);
    
21.                           }

复制代码

运行的结果是：
　　交换前的两数 a=10  b=5
　　交换后的两数 a=5  b=10
　　方法调用后的两数 a=10  b=5

　　这个是许多人都会犯的错误，包括我也犯了这个错误
　　就是：方法调用后的两数 a=5  b=10

　　解释：a变量和b变量在内存中的值已经有了，并且值是固定的
基本数据类型的传递是一个值传递的过程

                2.下面的一个例子是一个引用类型的传递

                        里面有一个user类：里面有一个属性：String name = “tom”;

1. 　　public void changeName(User user,String name)
   
2.                         {
   
3.                         user.name=name;
   
4.                         }
   
5. 
   
6. 　                　User user=new User();
   
7.                           System.out.println("更改前的用户姓名："+user.name);
   
8.                         //调用更改名字的方法
   
9.                         ex.changeName(user, "jack");
   
10.                
    
11.                      System.out.println("更改后的用户姓名："+user.name);

复制代码

　　结果是：更改前的用户姓名：tom
更改后的用户姓名：jack
这个是个引用的数据类型，




引用数据类型就是一个指针的一个指向。

这个例子也是一个引用数据类型的例子

1. public void change(StringBuffer bufferA,StringBuffer bufferB,StringBuffer bufferC)
   
2.         {
   
3.                 bufferA=new StringBuffer("AA");
   
4.                 bufferB.append("B");
   
5.                 bufferC=bufferA;
   
6.                 bufferC.append("C");
   
7.                
   
8.                 System.out.println("方法中：");
   
9.                 System.out.println(bufferA);
   
10.                 System.out.println(bufferB);
    
11.                 System.out.println(bufferC);
    
12.         }
    
13. 
    
14.         /**
    
15.          * @param args
    
16.          */
    
17.         public static void main(String[] args)
    
18.         {
    
19.                 StringBuffer bufferA=new StringBuffer("A");
    
20.                 StringBuffer bufferB=new StringBuffer("B");
    
21.                 StringBuffer bufferC=new StringBuffer("C");
    
22.                
    
23.                 Exam10 ex=new Exam10();
    
24.                
    
25.                 ex.change(bufferA, bufferB, bufferC);
    
26.                
    
27.                 System.out.println("方法外");
    
28.                 System.out.println(bufferA);
    
29.                 System.out.println(bufferB);
    
30.                 System.out.println(bufferC);
    
31.         }

复制代码

1. 
   

复制代码

运行的结果：
方法中的值大家都会的：
方法中：
AAC
BB
AAC
方法外
A
BB
C
关键是方法外面的System.out.println(bufferA);
这个比较难理解：
因为在方法体内部，有实例化了一个A对象，所以在方法里面的bufferA指向的是方法里面的A对象。和外面的没有联系。所以外面的还是指向原来的A对象，所以结果是A。

值得学习ing!