java基础——内部类

内部类(Inner Class)
内部类是Java 语言中的一种特殊的语法，简单的来说，就是在 一个类的内部再声明一个类，这些声明在类内部的类就被称作内部类。

在实际声明时，内部类可以 声明在类的内部、类的方法内部，也可以声明在类的构造方法内部。

内部类声明的语法格式和一般类的声明一样，只是 内部类声明时可以使用static修饰符进行修饰。
对于内部类的相关使用，本部分不做深入的介绍，只是进行简单的说明，辅助建立内部类的概念，能够进行一些基本的使用。
下面是一个简单的内部类的示例代码：
/**
* 内部类基本使用示例代码
*/
public class OutClass {
        int i = 0;
        public class InnerClass{
                public void test(){
                        i++;
                }
        }
}
在该示例代码中，类InnerClass 声明在了类OutClass 的内部，所以InnerClass 被称为内部类，而OutClass 则被称为InnerClass 的外部类。

该代码编译以后，将生成两个class 文件，一个是OutClass.class， 另外一个是OutClass$InnerClass.class。

这里需要说明的是，内部类也被编译成一个独立的类文件，类文件的名称为：外部类类名$内部类类名.class。
在内部类中，可以很方便的访问外部类的属性i，而外部类不能直接引用内部类中的属性和方法，语法中提供了一套专门的格式来访问内部类中的 属性和方法，这些语法这里就不作介绍了。
内部类是Java 语言诞生以后新增的一个语法，设计该语法的初衷主要有两个：
①：隐藏内部类的实现
也就是将只有被外部类使用的功能隐藏在内部类的内部，其它类访问这个内部类时的语法会比较复杂，从而在一定程度了避免了其它类对于内部类的访问。
②：内部类可以访问外部类的所有属性和方法，避免了参数传递
在内部类中，可以访问外部类中的所有属性和方法，private 访问控制符修饰的属性和方法也可以被内部类访问，这样将方便内部类的编写，避免了参数传递，也减少了外部类需要向其它类开放的属性和方法的数量。当然，内部类除了带来一系列的好处以外，还带来了一系列的不足，主要的不足有如下几点：
①：增加了语法的复杂度
在一个类的内部声明一个类，使Java 语言的复杂度增加了很多，也在一定程度上损害了Java 语言的编程风格，同时使阅读代码的难度大幅度的增加。
②：使整个项目的结构变得复杂
内部类通过增加每个类的复杂度，使得项目的结构变得更加复杂，而且没有原来的结构那么清晰。
当前内部类的语法在以下编程技术中的应用比较多：
①：图形用户界面编程中的事件处理
②：Java 语言API 中部分功能类的实现
综合以上说明，在实际的开发过程中，如果不是十分必要，不建议编写内部类，对于内部类实现的功能可以使用类和类之间的调用进行实现，这样可以保留Java 语言清晰的编程风格。
最后需要特别说明的是：在Java 语法中，一个源代码内部可以编写多个类，例如：
/**
* 一个类内部声明多个类
*/
public class TwoClassInOneFile {
        int n = 0;
        public void method(){}
}
class AnotherClass {
        char c;
        public void t(){}
}
这样的源代码，在编译时，将生成两个独立的class 的文件：TwoClassInOneFile.class 和AnotherClass.class，这样的结构不是内部类。在实际项目中，不推荐进行这样的编码，主要原因是不方便类源代码的查找，而推荐每个源文件内部只声明一个类的形式。 
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
内部类的访问规则：
①： 内部类可以直接访问外部类中的成员，包括私有。
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this
②：外部类要访问内部类，必须建立内部类对象。

访问格式：
①：当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。
格式：
 外部类名.内部类名  变量名 = 外部类对象.内部类对象;
 Outer.Inner in = new Outer().new Inner();

②：当内部类在成员位置上，就可以被成员修饰符所修饰。比如，private：将内部类在外部类中进行封装。
static:内部类就具备static的特性。
当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。 在外部其他类中，
如何直接访问static内部类的非静态成员呢？
new Outer.Inner().function();

在外部其他类中，如何直接访问static内部类的静态成员呢？
Outer.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的。当外部类中的静态方法访问内部类时，内部类也必须是static的。

 

当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事务在使用外部事物的内容。

class Body{
         private class XinZang {

         }

         public void show(){
                  new XinZang().
         }
 }

 

 

*/
class Outer{
        private static  int x = 3;

        static class Inner{//静态内部类
                  static void function(){
                             System.out.println("innner :"+x);
                  }
         }

         static class Inner2{
                  void show() {
                           System.out.println("inner2 show");
                  }
          }

         public static void method(){
                  //Inner.function();
                  new Inner2().show();
          }

}

class  InnerClassDemo2{
        public static void main(String[] args) {
                  Outer.method();
                  //Outer.Inner.function();
                  //new Outer.Inner().function();
                  //直接访问内部类中的成员。
                  //  Outer.Inner in = new Outer().new Inner();
                  //  in.function();
         }
}

------------------------------------------------------------------------------------------------------------------------------------------------------------------- 

内部类定义在局部时：
①：不可以被成员修饰符修饰
②：可以直接访问外部类中的成员，因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。

class Outer{
         int x = 3;

         void method(final int a){
                  final int y = 4;
                  class Inner{//定义局部变量中的内部类
                           void function(){
                                    System.out.println(y);
                           }
                  }
                  new Inner().function();
         }
}

class  InnerClassDemo3{
        public static void main(String[] args) {
                  Outer out = new Outer();
                  out.method(7);
                  out.method(8);
        }

}

 
------------------------------------------------------------------------------------------------------------------------------------------------------------------ 
匿名内部类:
①：匿名内部类其实就是内部类的简写格式。
②：定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。
③：匿名内部类的格式：  new 父类或者接口(){定义子类的内容}
④：其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以理解为带内容的对象。
⑤：匿名内部类中定义的方法最好不要超过3个。
abstract class AbsDemo{
        abstract void show();
}

class Outer{
         int x = 3;

 /*
         class Inner extends AbsDemo{
                  int num = 90;
                   void show(){
                           System.out.println("show :"+num);
                  }
                  void abc(){
                           System.out.println("hehe");
                  }
         }
 */

         public void function(){
                //AbsDemo a = new Inner();
                //  Inner in = new Inner();
                 //  in.show();
                //  in.abc();
 

          AbsDemo d = new AbsDemo(){
                   int num = 9;
                   void show(){
                            System.out.println("num==="+num);
                   }
                   void abc(){
                            System.out.println("haha");
                   }
           };

          d.show();
          //d.abc();//编译失败;

       }
}

 

class InnerClassDemo4 {
         public static void main(String[] args){
                  new Outer().function();
         }
}