内部类

来源：互联网发布：在淘宝上如何申请退款编辑：程序博客网时间：2024/04/27 17:30

优点：业务逻辑相关性封装在一个类中，内部类隐藏在外部类中。减少了类文件在编译后的字节码的大小。
缺点：逻辑不够清晰

内部类可为静态，可用protected和private修饰。（而外部类不可以：顶级类只能使用public和default）。
JAVA文件中没有publie class 可以类名和文件不同名

内部类分四种：
（成员式）静态内部类、成员内部类
（局部式）局部内部类、匿名内部类
*********************************************
成员内部类

四个访问权限修饰符都可以修饰成员内部类。

内部类和外部类在编译时是不同的两个类，内部类对外部类没有任何依赖。
内部类是一种编译时语法‌‎，在编译时生成各自的字节码文件，内部类和外部类没有关系。
内部类中可以访问外部类的私有成员。
内部类是作为外部类的一个成员存在，与外部类的属性、方法并列。
内部类和外部类的实例变量可以共存。
在内部类中访问实例变量：this.属性
在内部类访问外部类的实例变量：外部类名.this.属性。
在外部类的外部访问内部类，使用out.inner.

成员内部类的特点：

1．内部类作为外部类的成员，可以访问外部类的私有成员或属性。（即使将外部类声明为private，但是对于处于其内部的内部类还是可见的。）

2．用内部类定义在外部类中的不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。

注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。
（泛型也是便已是概念，反射中的public ....修饰符）

对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。

3．成员内部类不能含有静态成员。

建立内部类对象时应注意：
在外部类的内部可以直接使用inner s=new inner();（因为外部类知道inner是哪个类，所以可以生成对象。）
而在外部类的外部，要生成（new）一个内部类对象，需要首先建立一个外部类对象（外部类可用），然后在生成一个内部类对象。内部类的类名是外部类类名.内部类类名。

例：
public class Test{
   public static void main(String[] args){
   Outer o=new Outer();
Outer.Inner in=o.new Inner();
Outer.Inner in=(new Outer).new Inner();
}
}

class Outer{
   private int a；
   class Inner{
   private int b;
   public Inner(){
   this.b=Outer.this.a；
   }
   }
   ……
}

静态内部类

（注意：前三种内部类与变量类似，所以可以对照参考变量）
静态内部类定义在类中，任何方法外，用static class定义。
静态内部类只能访问外部类的静态成员。

静态内部类和成员内部类的区别
创建（new）一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。
静态内部类的对象可以直接生成：
Outer.Inner in=new Outer.Inner()；
而不需要通过生成外部类对象来生成。静态内部类成为了一个和外部类平等的类。静态内部类不可定义为private。
例：
public class Test{
   public static void main(String[] args){
Outer.Inner in=new Outer.Inner()；
}
}

class Outer{
   private static int a
   static class Inner{
   private int b;
   public Inner(){
   this.b=Outer.this.a;
   }
   }
   ……
}

注意：当类与接口（或者是接口与接口）发生方法命名冲突的时候，此时必须使用内部类来实现。用接口不能完全地实现多继承，用接口配合内部类才能实现真正的多继承。

例子：

对于两个类，拥有相同的方法：
class abstruct People
{
  run();
}
interface Machine{
   run();
}
此时有一个robot类：
class Robot extends People implement Machine.
此时run()不可直接实现。

interface Machine
{
   void run();
}
class Person
{
   void run(){
   System.out.println("run");
   }
}
class Robot extends Person
{
   private class MachineHeart implements Machine
   {
   public void run(){System.out.println("heart run");}
   }
   public void run(){System.out.println("Robot run");}
   Machine getMachine(){return new MachineHeart();}
}
class Test
{
   public static void main(String[] args)
   {
   Robot robot=new Robot();
   Machine m=robot.getMachine();
   m.run();
   robot.run();
   }
}

*
局部内部类

局部内部类是定义在方法中的内部类。
局部内部类不能够加权限修饰符，其范围为定义它的代码块。

注意：局部内部类不仅可以访问外部类私有实例变量，还可以访问外部类的局部常量（也就是局部变量必须为final的）

(引用自：http://xm-king.javaeye.com
Thinking In Java里面的说法（唯一正确的说法）：如果定义一个匿名内部类，并且希望它使用一个在其外部定的对象，那么编译器会要求其参数引用是final 的。
Java代码
public class Tester {
   public static void main(String[] args) {
   A a = new A();
   C c = new C();
   c.shoutc(a.shout(5));
   }
}
///////////////////////////////////////////////////////
class A {
   public void shouta() {
   System.out.println("Hello A");
   }

   public A shout(final int arg) {
   class B extends A {
   public void shouta() {
   System.out.println("Hello B" + arg);
   }
   }
   return new B();
   }
}
////////////////////////////////////////////////////////
class C {
   void shoutc(A a) {
   a.shouta();
   }
}

   第5行c.shoutc(a.shout(5))，在a.shout(5)得到返回值后，a的shout()方法栈被清空了，即arg不存在了，而 c.shoutc()却又调用了a.shouta()去执行System.out.println("Hello B" + arg)。
   再来看Java虚拟机是怎么实现这个诡异的访问的：有人认为这种访问之所以能完成，是因为arg是final的，由于变量的生命周期，事实是这样的吗？方法栈都不存在了，变量即使存在，怎么可能还被访问到？试想下：一个方法能访问另一个方法的定义的final局部变量吗(不通过返回值)？
   研究一下这个诡异的访问执行的原理，用反射探测一下局部内部类。编译器会探测局部内部类中是否有直接使用外部定义变量的情况，如果有访问就会定义一个同类型的变量，然后在构造方法中用外部变量给自己定义的变量赋值，而后局部内部类所使用的变量都是自己定义的变量，所以就可以访问了。见下：
Java代码
class A$1$B {
   A$1$B(A, int);
   private final int var$arg;
   private final A this$0;
}
   A$1$B类型的对象会使用自定义的var$arg变量，而不是shout()方法中的final int arg变量，当然就可以访问了。
   那么为什么外部变量要是final的呢？即使外部变量不是final，编译器也可以如此处理：自己定义一个同类型的变量，然后在构造方法中赋值就行了。原因就是为了让我们能够挺合逻辑的直接使用外部变量，而且看起来是在始终使用　外部的arg变量(而不是赋值以后的自己的字段)。
   考虑出现这种情况：在局部内部类中使用外部变量arg，如果编译器允许arg不是final的，那么就可以对这个变量作变值操作（例如 arg++），根据前面的分析，变值操作改变的是var$arg，而外部的变量arg并没有变，仍然是5(var$arg才是6)。因此为了避免这样如此不合逻辑的事情发生：你用了外部变量，又改变了变量的值，但那个变量却没有变化，自然的arg就被强行规定必须是final所修饰的，以确保让两个值永远一样，或所指向的对象永远一样（后者可能更重要)。
   将函数的参数引用设为final，主要是考虑到局部变量的生命周期与局部内部类的对象的生命周期的不一致性!往深层次说，就是为了解决参数的不一致性问题。即因为从编程人员的角度来看他们是同一个东西，如果编程人员在程序设计的时候在内部类中改掉参数的值，但是外部调用的时候又发现值其实没有被改掉，这就让人非常的难以理解和接受，为了避免这种尴尬的问题存在，所以编译器设计人员把内部类能够使用的参数设定为必须是final来规避这种莫名其妙错误的存在。
   举个例子来说可能会更清楚一些，对于局部变量int i=3;方法中代码修改的是这个真正的变量i,而内部为对象修改的是i的复制品copy_i，这样这两个i就会发生值的不一致性，（这一点正是这个实现技术的缺陷),所以干脆就不允许这个int i=3;局部变量发生值的改变!由于不允许改int i的值,所以这两个int i的值就始终保持值的一致了,这才是final的这个规定的由来! 是一种不得不如此的无奈之举!
   简单的来说，因为生命周期的原因，内部类需要复制局部变量为内部类的一个属性变量，因为复制，所以要将修饰符设为final。
)
局部内部类的特点：不能直接访问局部内部类（保证局部内部类对外是不可见的）,只有在方法中才能访问其局部内部类。
局部内部类的作用

通过内部类和接口达到一个强制的弱耦合，用局部内部类来实现接口，并在方法中返回接口类型，使局部内部类不可见，屏蔽实现类的可见性。

局部内部类写法
public class TestLocalInnerClass{
   public static void main(String[] args){
   Outer o=new Outer();
   final int a=9;
   o.print(a);
   }
}

class Outer{
   private int index=100;
   public void print(final int a){
   final int b=10;
   System.out.println(a);
   class Inner{
   public void print(){
   System.out.println(index);
   System.out.println(a);
   System.out.println(b);
   }
   }
   Inner i=new Inner();
   i.print();
   }
}

**************************************
匿名内部类

匿名内部类是一种特殊的局部内部类，可通过匿名类隐式的实现接口。

匿名内部类的特点：
1，一个类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的事先或是覆盖。
2，只是为了获得一个对象实例，不许要知道其实际类型。
3，类名没有意义，也就是不需要使用到。

注：一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类，没有类名，根据多态，我们使用其父类名。

匿名内部类的特点
1) 因其为局部内部类，那么局部内部类的所有限制都对其生效。
2) 匿名内部类是唯一一种无构造方法类。
3)大部分匿名内部类是用于接口回调用的。
4)匿名内部类在编译的时候由系统自动起名Out$1.class。
5)一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。
6)因匿名内部类无构造方法，所以其使用范围非常的有限。

匿名内部类和局部内部类的区别
需要返回多个对象时，使用局部内部类，局部内部类的应用相对较多。匿名内部类中不写构造方法。

匿名内部类的写法：
interface A{
   void ia();
}
class B{
   public A bc(){
   return new A{
   void ia(){
   System.out.println(“ia”)
   }
   };
   }
}
使用匿名内部类：
public class Test{
public static void main(String[] args){
B b=new B();
A a=b.bc();
a.ia();
}
}