<Java>一切都是对象

引用操纵对象

1. 拥有一个引用，但是不一定需要有一个对象与他关联。（不一定有遥控的对象）
2. String s;---创建的是引用，并不是对象。（创建了一个遥控器，但是遥控器没有指向的对象）
3. 一种安全的创建方法：String s="i like java!"——创建一个引用的同时便进行初始化
4. 一旦创建了一个引用，就希望它能与一个新的对象关联——用new 关键字的意思是“给我一个新对象”
   1. String s=new String ("i love coffee!");
   2. 这里不仅创建了一个新的字符串，而且在括号内给出了初始化的内容。

      class Num
      {
          int num;
          Num(int h)
          {
              num=h;
          }
          void print()
          {
              System.out.println(num);
          }
      }
      public class temp {
          public static void main (String[]args)
          {
              int a=1;
              int b=2;
              System.out.println(a);
              System.out.println(b);
              b=a;        //a只不过把值传给了b
              b=4;
              System.out.println(a);
              System.out.println(b);
              Num n,m;
              n=new Num(1);
              m=new Num(2);
              n.print();
              m.print();
              m=n;        //n把存有的地址传给了m
              m.num=5;
              n.print();
              m.print();
          }
      }/* output:
      1
      2
      1
      4
      1
      2
      5
      5*/

1. 基本类型只不过是传递了她的存的东西--真正的数据而已。b=a只是把a的值给了b，改变b并不会改变a的值。

而引用类型也是传值--而引用类型在栈内本身存的东西是地址，所以m=n的时候，传递了n的地址给m，所以对m进行操作的时候，也会改变n在堆内的数据信息。

基本类型	数值型 byte short int long float double 字符型 char 布尔型 boolean	值直接保存在变量中 声明的时候直接分配了可以放值的空间。 分配的空间在内存栈上，并且值本身也存在内存栈空间上的。	int a=2; //栈空间 int b=a; //b的值和a一样。但是改变b的值不会改变a的值
引用类型	类 class 接口 interface 数组 array	变量中只保存对象的地址 声明的时候只是分配了引用的空间， 确定对象的时候才分配空间存放的对象。 引用空间在栈上，存着地址，真正的值在堆上。（栈--->堆）	String str=”hi”; str=”hello”; 不会改变对象的内容，而是直接改变了地址; MyDate today; //栈空间 today=new MyDate();//堆空间

基本类型

1. Java中基本类型所占的存储空间大小是确定的（不像C++ C那样）
2. 基本类型存在的意义 ：用 new在堆里面创建一个存放小的，简单的变量的对象，往往不是很有效。
3. 基本类型的变量不是引用，这个变量直接存放值，并放在堆栈里面。
4. 所有数值类型都有正负号
5. Boolean类型所占的存储空间大小没有明确指定，取字面值true或者false

基本类型	大小	最小值	最大值	包装器类型
boolean	-	-	-	Boolean
char	16-bit	Unicode 0	Unicode 2^16-1	Character
byte	8 bits	-128	+127	Byte
short	16 bits	-2^15	+2^15-1	Short
int	32 bits	-2^32	+2^32-1	Integer
long	64 bits	-2^64	+2^64-1	Long
float	32 bits	IEEE754	IEEE754	Float
double	64bits	IEEE754	IEEE754	Double
void	-	-	-	Void

1. 包装器类型都是一个完整的单词，并且首字母都有大写
2. 包装器类
   1. 基本类型具有包装器类
   2.  使得可以在堆中创建一个非基本对象，用来表示对应的基本类型
   3.  char c=’x’;  Character ch=new Character(c);
      1. 这一例子中，c为基本类型，为char型。而ch为非基本对象。
      2.  也可以 Character ch=new Character(‘x’);
   4. Java SE5的自动包装功能可以自动地讲基本类型转换为包装器类型
   5.  也可以反向转换
      1.  即从非基本对象转成基本类型
      2. char c=ch;

1. 高精度数字
   1. Java提供了两个类：BigInteger和BigDecimal。
   2. BigInteger和BigDecimal大体上属于包装器类，而他们都没有对应的基本类型
   3.  操作与基本类型所能执行的操作相似。
   4. 注意：必须以方法调用的方式取代运算符方式来实现！　　
      1. public BigInteger add(BigInteger val)　　
      2. public BigInteger subtract(BigInteger val)
      3. public BigInteger multiply(BigInteger val)
      4. public BigInteger divide(BigInteger val)
      5. public BigInteger[] divideAndRemainder(BigInteger val)
      6.  a.add(b)，而不是a+b
   5. BigInteger支持任意精度的整数
   6.  BigDecimal支持任何精度的定点数
2. 数组
   1.  创建了一个数组对象时，实际上是创建了一个引用数组。
   2. 每个引用都会自动被初始化为一个特定值，该特定值为null，以表示该引用还没有指向某个对象
      1. 注意这里说的是每个引用都用null作为初始化特定值，而不是基本数据类型。
   3.  如果试图使用一个还是null的引用，在运行时会报错（不像C++使用NULL那样）
   4. 可以创建用来存放基本数据类型的数组。初始化—讲这种数组所占的内存全部置零。

永远不需要销毁的对象

1. 作用域 scope
   1.  Java  free-form
   2. Java不允许较小的作用域的变量隐藏较大作用域的同名变量
   3. 对象的作用域
      1.  Java对象不具备和基本类型一样的生命周期
      2.  引用的作用域结束了，可是引用指向的对象仍然占着堆空间。
2.  Java的垃圾回收器：用来监视用new创建的所有对象。一旦对象不被需要，她就会自行消失。poof~
3. 解决了内存泄漏的问题  忘记释放内存（c++ c）