java内部类复习

                                                             java内部类复习

内部类在笔试也是高频出现的考点，下面是对于内部类的知识点总结：

1.内部类的分类：

   成员式内部类    局部式内部类 

   成员式内部类又可以分为：成员内部类  静态成员内部类

   局部式内部类又可以分为：局部内部类  匿名内部类

  当我们看到该类的定义实在一个类内定义且不是在方法中定义的，那么它一定是一个成员式内部类。对于成员式的内部类就可以将其看作一个类的属性，相当于一个类的属性。对于静态成员内部类就相当于一个静态属性变量。

  当该类实在一个方法体内定义的类时，可以很肯定的说它是一个局部内部类了，

 成员式内部类的特性比较：

    成员式内部类的比较就是在比较成员内部类和静态成员内部类，将从四点去比较二者的差别。

     a.定义时能否用作用域符修饰即public、protected、private修饰

     b.能否像外部类一样定义自己的属性及访问内部类的属性的语法格式

     c.实例化的语法格式

     d.访问外部类属性的权限和数据类型

 成员内部类：

     a条件满足，即可以用作用符来修饰

     b条件满足，可以定义自己的属性,但不可以定义静态属性变量，只能定义非静态属性变量和静态常量。访问的语法格式为：外部类对象名.内部类对象名.属性名

     c实例化内部类对象的语法格式为：外部类名.内部类名 对象名 = 外部类对象名.new 内部类名()

     d.可以访问外部类的私有属性，数据类型没有要求

  静态成员内部类：

     a条件满足，可以用作用符来修饰

     b条件满足，可以定义自己的静态属性和非静态属性。访问的格式为：外部类名.内部类名.内部静态属性，这种方式不能访问内部类的非静态属性。

     c.实例化静态成员内部类的语法格式：内部类名 对象名 = new 外部类名.内部类名();

     d.只能访问外部类的静态属性变量或静态属性常量，访问的语法为 外部类名.内部类名.属性名

    下面是测试的代码：

     

public class TestInner {
private int a = 0;

//定义成员内部类
public class Inn1{

public int a1 = 3;
//public static int b = 3;
public static final int b = 2;
public int  say() {
System.out.print("正在访问外部类的变量a..."+a);
return 0;
}

}
public static void main(String[] args) {
Inn1 inn1 = new TestInner().new Inn1();
System.out.println("正在访问内部类的say()方法。。。"+new TestInner().new Inn1().say());
System.out.println("正在访问内部类的成员变量。。。"+new TestInner().new Inn1().a1);
System.out.println("正在访问内部类的静态常量。。。"+inn1.b);
}

}

上面是成员内部类的测试代码。下面是静态成员内部类的代码：

     

public class Test_Static_Inner {
public static final int a = 11;
public int b = 111;

public static class Inner01{
public int a1 = 12;
public static int a2 = 13;
public int say(){
System.out.println("正在访
c203
问外部类的静态属性a。。"+a);
//			System.out.println("正在访问外部类的非静态属性b.."+b);
return a;
}
public static Inner01 say1(){
System.out.println("正在访问外部类的静态属性a。。"+a);
//			System.out.println("正在访问外部类的非静态属性b.."+b);
Inner01 inner01 = new Inner01();
return inner01;
}
}
public static void main(String[] args) {
Inner01 inner01 =new Test_Static_Inner.Inner01();
System.out.println("正在访问静态内部类的静态属性a2。。"+Test_Static_Inner.Inner01.a2);
System.out.println("正在访问静态内部类的静态方法say1。。。"+inner01.say1());
System.out.println("如何访问静态内部类的非静态属性。。。"+Test_Static_Inner.Inner01.say1().say());
//		System.out.println("正在访问内部类的非静态属性。。"+ Test_Static_Inner.new Inner01().a1);
//		System.out.println("正在访问内部类的非静态属性。。"+new Test_Static_Inner().new Inner01().a1);
//		System.out.println("正在访问静态内部类的方法。。"+new Test_Static_Inner().new Inner01().say());
}
}

（在对于静态成员内部类的测试我注释的代码，读者可以取消，发现那是编译都不能通过的）

在对于成员内部类、静态成员内部类的测试后，我们发现的是静态成员内部类与成员内部类的比较体现的特性更多的类似于静态成员变量。尤其是在静态成员变量实例化一个对象时，与外部类访问该静态内部类的成员。静态变量是属于整个类的属性，静态成员内部类也体现着这种性质。
下面继续来复习局部式内部类：

 局部式内部类分为  局部内部类   匿名内部类

    局部内部类和匿名内部类的特性比较：

   a.能否使用作用域符修饰

   b.访问局部变量的数据类型要求

   c. 能否定义static类型变量

   d.编译后能否生成独立的.class文件

局部内部类：

   a.允许使用作用域符来修饰

   b.只能访问final修饰的局部变量

   c.不能定义static类型的变量

   d.编译后能生成单独的.class文件

public class TestClazz {

public Inner say(){
/**
* 局部内部类
*/
class Inner2 implements Inner{
public Inner2() {
System.out.println("局部内部类的构造方法");
}
public void sayHello(){
System.out.println("内部类的方法执行--Hello!");
}
}
//inner2对象的生命周期：say内部
//如何在say方法结束后依然可以使用inner2对象
Inner inner2 = new Inner2();
inner2.sayHello();
return inner2;
}
public static void main(String[] args) {
TestClazz outer2 = new TestClazz();
Inner inner = outer2.say();
outer2.say();
System.out.println("----------------------");
inner.sayHello();
}

}匿名内部类的特性：
     a允许使用作用域符修饰匿名内部类

     b只能访问final修饰的变量

     c不能定义static修饰的变量

     d只能实例化一次变量。

   测试代码如下：

   public class TestMethodInnerClazz {

private int a = 6;
public Inner say(){
final int temp = 45;
/**
* 匿名内部类****************
* 只能创建一个对象 Swing监听 线程
* 可以访问final修饰的局部变量和外部类的全局变量
*/
Inner inner3 = new Inner(){
@Override
public void sayHello() {
System.out.println("Hello" + temp + "," + a);
}
};
return inner3;
}
public static void main(String[] args) {
Outer3 outer3 = new Outer3();
Inner inter = outer3.say();
System.out.println("----------------------");
inter.sayHello();
}
}
通过测试代码，可以看到二者的在代码的实现上差别还是很大的，还是较好区分两个局部式内部类的。
内部类是一个难点，也是一个重点，匿名内部类应用较为多。