记得看内部类的视频时，听到老师将内部类一般都是被私有修饰的，我当时很是不解，被私有修饰别人怎么调用啊？后来看到了集合的迭代器这里，终于明白，原来私有内部类有这样的应用：对象存到集合里，怎么样取出是一个问题。所以就定义了内部类，因为内部类可以更加简单得操作集合中的数据。然后集合又提供了iterator和listIterator方法，就可以轻松获取到该内部类的实例。
看起来好像有点傻哈，还请大家不要笑话~~，也不知道这样有没有想错，大神帮忙指点一下啊，别让我想歪了~~{:2_33:}
下面是一些伪代码，可以参考一下，

1. class IteratorTest
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 ArrayList al = new ArrayList();
   
6.                 al.add("zhangsan");
   
7.                 al.add("lisi");
   
8.                 ....
   
9.                 //调用集合中的方法，就返回了被private修饰的内部类对象
   
10.                 Iterator it = al.iterator();
    
11.         }
    
12. }
    
13. class ArrayList
    
14. {        
    
15.         //为了更加方便得操作集合中的元素，所以将迭代器定义在了集合内部
    
16.         private class Itr implements Iterator
    
17.         {
    
18.                 //这里面是操作集合中元素的方法hasNext(),next(),remove()...
    
19.         }
    
20.         public Iterator iterator()
    
21.         {
    
22.                 return new Itr();
    
23.         }
    
24. 
    
25. }
    
26. interface Iterator
    
27. {
    
28.         public boolean hasNext();
    
29.         public Object next();
    
30.         public void remove();
    
31. }

复制代码

1. /*
   
2. ：内部类
   
3. * 1.相当于说，我们可以在类的内部再定义类。外面的类：外部类。里面定义的类：内部类
   
4. * 2.内部类的分类：成员内部类（声明在类内部且方法外的）  vs 局部内部类(声明在类的方法里)
   
5. * 3.成员内部类：
   
6. *                 3.1是外部类的一个成员：①可以有修饰符（4个）②static final ③可以调用外部类的属性、方法
   
7. *                        
   
8. *                 3.2具体类的特点：①abstract ②还可以在其内部定义属性、方法、构造器
   
9. *
   
10. * 4.局部内部类：
    
11. *
    
12. * 5.关于内部类，大家掌握三点：
    
13. *   ①如何创建成员内部类的对象
    
14. *   ②如何区分调用外部类、内部类的变量(尤其是变量重名时)
    
15. *   ③局部内部类的使用
    
16. *
    
17. */
    
18. public class TestInnerClass {
    
19.         public static void main(String[] args) {
    
20.                 //创建静态内部类的对象：可以直接通过外部类调用静态内部类的构造器
    
21.                 Person.Dog d = new Person.Dog();//Person.new Dog();
    
22.                 //Person.Bird b = new Person.Bird();
    
23.                 //创建非静态的内部类的对象：必须先创建外部类的对象，通过外部类的对象调用内部类的构造器
    
24.                 Person p = new Person();
    
25.                 Person.Bird b = p.new Bird();//new p.Bird();
    
26.                 b.info();
    
27.                 b.setName("杜鹃");
    
28.         }
    
29. }
    
30. 
    
31. class Person{
    
32.         String name = "韩梅梅";
    
33.         int age;
    
34.         //成员内部类(非static的)
    
35.         class Bird{
    
36.                 String name = "黄鹂";
    
37.                 int id;
    
38.                
    
39.                 public Bird(){
    
40.                        
    
41.                 }
    
42.                 public void setName(String name){
    
43.                         System.out.println(name);//杜鹃
    
44.                         System.out.println(this.name);//黄鹂
    
45.                         System.out.println(Person.this.name);//韩梅梅
    
46.                 }
    
47.                 public void info(){
    
48.                         show();
    
49.                 }
    
50.         }
    
51.         //成员内部类(静态内部类)
    
52.         static class Dog{
    
53.                
    
54.         }
    
55.        
    
56.         public void show(){
    
57.                 System.out.println("我是show()方法");
    
58.         }
    
59.        
    
60.         public void method1(){
    
61.                 class A{
    
62.                        
    
63.                 }
    
64.         }
    
65. }

复制代码

1. /*
   
2. * 关于局部内部类的使用
   
3. */
   
4. public class TestInnerClass1 {
   
5.        
   
6. }
   
7. 
   
8. class OuterClass{
   
9.         //局部内部类
   
10.         //如下的使用方式较少
    
11.         public void method1(){
    
12.                
    
13.                 class InnnerClass{
    
14.                        
    
15.                 }
    
16.         }
    
17.         //常常使用一个方法，使其返回值为某个类或接口的对象。而这个类或接口在方法内部创建
    
18.         //使用方式一
    
19.         public Comparable getComparable(){
    
20.                 //1.创建一个实现Comparable接口的类:局部内部类
    
21.                 class MyComparable implements Comparable{
    
22. 
    
23.                         @Override
    
24.                         public int compareTo(java.lang.Object o) {
    
25.                                 return 0;
    
26.                         }
    
27.                        
    
28.                 }
    
29.                 //2.返回一个实现类的对象
    
30.                 return new MyComparable();
    
31.         }
    
32.         //使用方式二
    
33.         public Comparable getComparable1(){
    
34.                 //返回一个实现Comparable接口的匿名内部类的对象
    
35.                 return new Comparable(){
    
36. 
    
37.                         @Override
    
38.                         public int compareTo(java.lang.Object o) {
    
39.                                 // TODO Auto-generated method stub
    
40.                                 return 0;
    
41.                         }
    
42.                        
    
43.                 };
    
44.         }
    
45. }
    

复制代码