Java学习（七）

Java内部类

在Java中，共存在四种内部类，分别为对象内部类、方法内部类、静态内部类和匿名内部类（*）。下面简述前三种内部类的使用方法。

对象内部类：顾名思义，就是在类中嵌套一个非静态类。内部类的成员与构造函数与普通类基本相同。this.variable表示当前类下的对象。这种类可以被外部类访问，也可以访问外部类，包括protected对象。

方法内部类：在类的方法中定义另外的一个类。内部类不可用private、protected、public和static修饰，只可以用final与abstract修饰。这表示这个类只可以在类的该函数中使用，不可作用于外部域。此外，内部类只可以访问被final修饰的局部变量，原因很好理解——局部变量在方法调用后会随时消失，因此一般的局部变量不可能被局部内部类引用。局部内部类可以调用其他的外部类。

静态类：静态类中用于存放静态对象和静态方法。表示当前类中的对象用类名.variable来表示，这与非静态类的this.variable具有明显的不同。静态类不能访问非static的对象与方法。

匿名内部类：匿名内部类需要使用父类或接口来新建一个匿名类。在Object对象中，其中有内置接口toString()。匿名内部类只能使用一次，每次使用完后需要重新建立。

package helloWorld;

public class InnerClass {
    private String name;
    private int age;
    public InnerClass(){}
    public InnerClass(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    //类对象内部类
    public class Inner extends InnerClassTemp
    {
        private String name;
        private int age;
        public Inner(){}
        public Inner(String name,int age)
        {
            super("SJTU");
            this.name=name;
            this.age=age;
        }
        public void print()
        {
            System.out.println("class Inner: "+name+": "+age+" "+super.school);
            
        }
    }
    
    //类方法内部类
    //===========

/*
* obj中定义了toString()这个接口
* public Object copy()
*/

public String copy()
{
final String name="Elizabeth";
class Inner2
{
public String print()
{
//System.out.println("class Inner2: "+name);
return name+"!";
}
}
Inner2 in2=new Inner2();
return in2.print();
}

//静态内部类
    public static class Inner3
    {
        //对象与方法均需要为static
        static String name;
        static int age;
        public Inner3(){}
        public Inner3(String name,int age)
        {
            //静态类中Inner3.name表示静态对象
            //非静态类中不能这样使用
            Inner3.name=name;
            Inner3.age=age;
        }
        
        public static void print()
        {
            System.out.println("class Inner3: "+name+": "+age);
        }
    }
    
    public void print()
    {
        System.out.println("class InnerClass: "+name+": "+age);
    }
    
    //匿名内部类
    //===============

public Object annoyCopy(String str)
{
return new Object(){
public String toString()
{
return "How do you do! "+str;
}
};
}

}

class InnerClassTemp
{
    protected String school;
    public InnerClassTemp(){}
    public InnerClassTemp(String school)
    {
        this.school=school;
    }
}

//类的实例化
        InnerClass ic=new InnerClass("Andy",24);
        ic.print();
        //类对象的内部类
        InnerClass.Inner ici1=ic.new Inner("Jane",23);
        ici1.print();
        //静态内部类
        //静态内部类可以不通过实例就创建类
        //这与非静态类有较大差别
        InnerClass.Inner3 ici3=new InnerClass.Inner3("Tom",27);
        ici3.print();

//匿名内部类
System.out.println(ic.annoyCopy("Sansa").toString());

结果为：
class InnerClass: Andy: 24
class Inner: Jane: 23 SJTU
Elizabeth!
class Inner3: Tom: 27
How do you do! Sansa

在Java中存在Boolean、Character、Byte、Short、Integer、Long、Float、Double类，还有bool、char、byte、short、int、、float、long、double八种数据类型。前面八种基本类被封装在Object类中，为引用类型。将数值赋给前八种类称为封装（Boxing），将前八种类的值传递给后八种数据类型称为拆包（Unboxing)。这些操作均由编译器compiler自动完成。下面以double与Double为例简述他们的区别：

1.Double是java定义的类，而double是预定义数据类型（8种中的一种）
2.Double是对double类型的封装，内置很多方法可以实现String到double的转换，以及获取各种double类型的属性值（MAX_VALUE、SIZE等等）。
基于上述两点，如果是在普通的定义一个浮点类型的数据，两者都可以，但是Double是类所以其对象是可以为NULL的，而double定义的不能为NULL。

package helloWorld;

public class AdvancedGrammar {
    enum Light{Red,Orange,Yello,Green,Blue,Purple};
    public AdvancedGrammar(){}
    public void Box()
    {
        Integer I1=new Integer(10);
        int i1=I1;
        Integer I2=11;
        int i2=I2;
        System.out.println(I1+" "+i1);
        System.out.println(I2+" "+i2);
        
        Object[] obj=new Object[]{1,"Nice"};//Object为引用类型
        System.out.println(obj[0]+" "+obj[1]);
        System.out.println((Integer)obj[0]+" "+(String)obj[1]);        
    }

}

AdvanceGrammar advg=new AdvanceGrammar();
advg.Box();
结果为：
10 10
11 11
1 Nice
1 Nice