Java编程思想笔记(七) —— 内部类

刚刚看到论坛推荐，阿里的校招没想到8月底就开始了，等春招再去试试，现在还是太嫩了点。

 

将一个类的定义放到另一个类定义的内部——内部类。用java写Android的朋友经常用的Listener的东西，里面就是内部类。而且，不要单纯地以为就java才能开发Android。

 

1)简单的内部类

内部类的功能看似隐藏了代码，其实不然。

 

public class Ticket {
    class Destination{
        private String content;
        Destination(String s){
            content = s;
        }
        String showContent(){
            return content;
        }
    }
    
    public void show(String dest){
        Destination d = new Destination(dest);
        System.out.println(d.showContent());
    }
    public static void main(String[] args) {
        Ticket t = new Ticket();
        t.show("BeiJing");
    }
}

一个简单的内部类，就是一个普通类嵌套在内部。

 

 

 

    public Destination getDestination(){
        return new Destination("ShangHai");
    }
    public static void main(String[] args) {
        Ticket t = new Ticket();
        Ticket.Destination dest = t.getDestination();
        Destination d = t.new Destination("GuangZhou");
        t.show("BeiJing");
    }

如果从静态方法中创建内部类对象，如果是直接new的话要用上面的写法，而用了返回值为对象的方法的需要指明对象的类型。

 

 

2)链接到外部类

内部类拥有其外围类(enclosing class，enclosing是封闭的意思，书上翻译成外围类对象)的所有元素的访问权。直接用书上的例子。

 

public class Sequence {
    private Object[] item;
    private int next = 0;
    public Sequence(int size){
        item = new Object[size];
    }
    public void add(Object x){
        if(next<item.length){
            item[next++]=x;
        }
    }
    
    private class SimpleItertor implements MyIterator{
        private int index = 0;
        /*public boolean end() {
            if(next == item.length){
                return true ;
            }
            return false;
        }代码冗余 其实可以写的更简洁
        */
        
        public boolean end() {
            return index == item.length;
        }
        public Object current() {
            return item[index];
        }

        public void next() {
            if(index<item.length){
                index ++;
            }
        }
    }
    
    public MyIterator iterator(){
        return new SimpleItertor();
    }
    
    public static void main(String[] args) {
        Sequence s = new Sequence(10);
        for(int i = 0; i < 10 ; i++){
            s.add(i);
        }
        MyIterator i = s.iterator();
        while(!i.end()){
            System.out.println(i.current());
            i.next();
        }
    }
}

为什么把这个例子写进来呢，一个是这个类似我们经常使用容器的Iterator，其实也应用了设计模式——迭代器模式。还有内部类中用了外围类的私有成员进行操作。

 

 

3)使用.this和.new

 

public class Outer {
    class Inner{
        Outer getOuter(){
            return Outer.this;
        }
    }
}

如果是单纯的this的话，this指向的是Outer.Inner，如果返回Outer对象，还是需要Outer.this。

 

 

.new的话在第一个知识点的时候提到了。需要

 

 Destination d = t.new Destination("GuangZhou");

内部类对象会偷偷地连接到外部类对象，所以在创建外部类对象之前是不能创建内部类的，当时如果为静态内部类（嵌套类）就不需要外部类对象的引用。

 

 

 

 

public class Outer {
     static class Inner{
    }
     public static void main(String[] args) {
        Inner i = new Inner();
    }
}

4)内部类用处——向上转型

 

更高深的隐藏代码。其实书上再举例子。不过回头再看发现已经用过一次了。

 

private class SimpleItertor implements MyIterator{}
public MyIterator iterator(){ return new SimpleItertor(); }

 

 

其实我们在代码已经隐藏了这个实现类的实现细节，属性为私有，返回的时候是将SimpleIterator向上转型为通用的接口。

 

5)方法和作用域中的内部类。

 

public class Outer {
    public void get(){
        class Inner{
        }
    }
}

方法内部，称为局部内部类。

 

作用域方面，如果内部类声明在if条件语句下作用域中，那超出这个域也是不可用的。

 

6)匿名内部类

 

public class Outer {
    public Sequence get() {
        return new Sequence(1) {}; 
      }
}

虽然返回Sequence对象，但是却是你可以在花括号里面定义自己的东西。这对于外面来说就是匿名的。

 

如果匿名内部类使用其外部定义对象,参数要有final。

 

class Inner{}
 
public class Outer {
    public Inner get(final String s){
        return new Inner(){
           String type = s;
        };
    }
}

Cannot refer to a non-final variable s inside an inner class defined in a different method.不能把内部类里面非final变量s放进一个不同的方法中定义。

 

 

7)嵌套类

上面提到的静态内部类。和静态方法的特点类似。创建嵌套类对象不需要外部类对象引用，不能从嵌套类对象访问非静态外围类对象（静态方法的是不能在静态方法中使用非静态方法）。

 

8)为什么需要内部类

这东西设计来干啥，要知道其实语言是人设计的，特性也是自己设计的，没用的是不会专门设计出来的。

内部类实现接口和外围类实现接口是不同的，每个内部类都能继承接口，外围类继承了谁并不会对内部类造成影响。在使用GUI的时候，更能感受到内部类的价值。

 

9)闭包和回调

闭包，closure，指的是可调用对象记录一些信息，信息来自创建他的作用域。其实内部类就是。

 

10)内部类标识符

在没有使用IDE之前的那段时间，纯粹在dos窗口编译的时候，经常会去看编译后的文件是什么样子的。有时会看到Outer$Inner.class文件的存在，其实这就是编译器编译的结果，外围类加上$再加上内部类的名字。

 

 

接口和内部类这两章真的很复杂很深奥，内部类这里还有一个控制框架是我没写出来的。C++没有这些东西，接口和内部类的结合可以解决C++多重继承的问题。写的还不多，接触到这两者还比较少，以后接触到再来看就知道价值所在了。