对Java的面对对象编程中对象和引用以及内部类的理解

最近利用下班的时候看了看的think in java感觉再看 和第一次看大不一样
接下来说一下java中对象和引用的关系，以及内部类的概念。
1、java中一切都是对象
 在java中是什么来操作者对象呢？答案是引用，这就好比c或者c++中的指针。
如果用拥有一个引用，那么此时你必须让其和一个对象关联在一起，否则这个引用并不会像你想象的那样任由你的控制，例如你创建了一个string的引用：

string s ;

而此时并未与任何对象关联，如果此时你去做一些操作，如调用string的一些方法，肯定是会出现问题，（一些基本类型除外，因为你在定义的时候，它们就会赋予初始值的），所以在使用钱必须和对象进行关联：

string s = new string();

或者

string s = “my name is ajun”；

像这样就可以了。
2、怎么和对象进行关联
在java中通常会通过new来创建一个对象，来和引用进行关联，如：

string s = new string("my name is ajun");

这样不仅创建了一个对象和引用s进行关联，同事也进行初始化，同时我们也可以创建属于自己的对象类型。
3、存储位置
（1）堆栈：一般存储引用和基本类型变量，堆栈主要是通过堆栈指针上下移动来对内存进行分配和释放。
基本类型变量并不适应于new进行创建，因为其所占的内存较小。
（2）堆：用于存储java对象，当程序执行new的时候，堆就会分配一个空间给这个对象，记住堆进行内存的分配和释放是比堆栈进行存储和释放内存消耗更多的时间，这就是基本类型变量要存在堆栈中了，因为基本类型变量是用的最频繁的，频繁的存储和释放内存，在消耗更多的时候，性能可想而知的。
4、内部类
（1）、内部类基础知识：
一般定义在java类内部的类成为内部类
内部类可以分为：定义在方法体外部的类、定义方法内部的类、静态内部类（只能定义在方法外部），匿名内部类
说明：
定义在方法外面的类：
类的成员变量（静态、非静态）可以访问，为了保证能够正确的引用的类的成员变量，所以必须先实例化外部类的对象，才可以实例化内部类的对象
访问权限可以任何，可以把它看成类的成员变量，这样理解就好多来了。
定义在方法体内的类;
类的成员变量（静态、非静态）可以访问，为了保证能够正确的引用的类的成员变量，所以必须先实例化外部类的对象，才可以实例化内部类的对象
访问权限不可以有，把他看成方法的局部变量就可以了。
静态内部类：
只能访问类的静态成员变量
访问权限任何
匿名内部类：
类的成员变量（静态、非静态）可以访问，为了保证能够正确的引用的类的成员变量，所以必须先实例化外部类的对象，才可以实例化内部类的对象
访问权限不可以有
（2）、内部类的作用
内部类可以很好的隐藏类，一般类不允许有private protect default访问权限。
内部类可以实现多重继承，弥补了java不能多继承的特点
（3）、例子

package com.ajun.test.innerclass.example; 
 
/** 
 * 水果内容 
 * @author administrator 
 * 
 */ 
public interface contents { 
   string value(); 
} 

package com.ajun.test.innerclass.example; 
 
/** 
 * 水果目的地 
 * @author administrator 
 * 
 */ 
public interface destination { 
 
  //目的地 
  string readlabel(); 
} 

package com.ajun.test.innerclass.example; 
 
public class goods { 
 
  private string des="is ruit!!"; 
   
  //方法外部 
  private class content implements contents{ 
    private string name = "apple "+des; 
    @override 
    public string value() { 
      return name; 
    } 
  } 
   
  //方法外部 
  private class gdestination implements destination{ 
    private string label ; 
    private gdestination(string label){ 
      this.label= label; 
    } 
    @override 
    public string readlabel() { 
      return label; 
    } 
  } 
   
   
  //匿名内部类 
  public destination getdestination(final string label){ 
    return new destination(){ 
      @override 
      public string readlabel() { 
        return label; 
      } 
    }; 
  } 
   
  public destination dest(string s){ 
    return new gdestination(s); 
  } 
   
  public contents content(){ 
    return new content(); 
  } 
   
  public destination dest2(string s){ 
    class gdestination implements destination{ 
        private string label; 
        private gdestination(string label){ 
          this.label= label; 
        } 
        @override 
        public string readlabel() { 
          return label; 
        } 
    } 
    return new gdestination(s); 
  } 
   
} 

package com.ajun.test.innerclass.example; 
 
public class test { 
 
  public static void main(string [] a){ 
    goods gs = new goods(); 
    contents c = gs.content(); 
    destination d = gs.dest("beijing"); 
    system.out.println(c.value()); 
    system.out.println(d.readlabel()); 
    destination d1 = gs.getdestination("shanghai"); 
    system.out.println(d1.readlabel()); 
    system.out.println(gs.dest2("tianjin").readlabel()); 
  } 
} 

其中content和gdestination得到了很好的隐藏，外面调用的时候，根本就不知道调用的是具体哪个类，使这个类拥有多继承的特性。

输出;

apple is ruit!! 
beijing 
shanghai 
tianjin