Java————内部类

大部分时候，类被定义为一个独立的程序单元。但是在某些情况下，也会把一个类定义在另一个类的内部，这种类就成为内部类。包含内部类的类叫作外部类（或宿主类）。内部类主要有以下几个作用：

• 内部类提供了更好的封装，可以把内部类藏在外部类之内，不允许同一个包中的其他类访问该类。假设现在需要创建Cow类，Cow类需要组合一个CowLeg对象，CowLeg类只有在Cow类中才有效，离开了Cow类之后就没有任何意义。在这种情况下，就可以把CowLeg定义成Cow的内部类，不允许其他类访问CowLeg。
• 内部类成员可以直接访问外部类的私有数据，因为内部类被当成其外部类的成员，同一个类的成员之间可以相互访问。但是外部类不能访问内部类的实现细节，比如内部类的成员变量。
• 匿名内部类适用于创建哪些仅需要使用一次的类。

 

内部类与外部类的语法大致相同，但是还存在以下一些区别：

• 内部类可以比外部类多使用三个修饰符：private、protected、static——外部类不可以使用这三个修饰符
• 非静态内部类不能拥有静态成员

 

非静态成员内部类

直接将一个类定义在外部类中，可以在类的任何位置。与类的成员变量、方法、构造器和初始化块地位相同。可以直接视为是外部类的一个成员。因为他是类的成员，所以可以使用private、static、protected修饰符。非静态成员内部类就是不使用static修饰符修饰的内部类。

package testInnerClass;

public class Cow {
    private double weight;
    public Cow(){}
    public Cow(double weight){
        this.weight = weight;
    }

    /**
     * 内部类
     */
    private class CowLeg{
        private String color;
        private double length;

        public CowLeg(){}
        public CowLeg(String color,double length){
            this.color = color;
            this.length = length;
        }

        public void setColor(String color){
            this.color = color;
        }
        public String getColor(){
            return this.color;
        }

        public void setLength(double length){
            this.length = length;
        }

        public double getLength(){
            return this.length;
        }

        public void showLegs(){
            System.out.println("这头牛重"+weight+"公斤");
            System.out.println("这头牛腿的颜色是"+color+"腿的长度是"+length+"厘米");
        }
    }

    public void showCow(){
        CowLeg cl = new CowLeg("黑色",80);//外部类想要访问内部类的私有变量，需要创建内部类的实例，通过实例来调用，不能直接调用
        cl.showLegs();
    }
}



/**
*测试类
*/

package testInnerClass;

public class testMain {
    public static void main(String[] args){
        Cow cow = new Cow(150);
        cow.showCow();
    }
}

通过这个例子可以看出，在成员内部类中，我们可以直接调用外部类的私有成员。这是因为在非静态内部类对象里，保存了一个它所寄生的外部类对象的引用。即当调用非静态内部类的实例方法时，必须有一个非静态内部类实例，非静态内部类实例必须寄生在外部类实例里。

即我们必须像操作外部类成员那样去操作内部类的对象。我们不能直接在测试类中创建CowLeg对象，只能在Cow类中创建CowLeg实例对象，然后在测试类中通过外部类对象来调用内部类对象。

 

当我们在非静态内部类的方法中调用变量时，会优先在该方法中去寻找改变量，如果未找到，则会去方法所属的内部类中去寻找；如果未找到，会去外部类中寻找。如果还未找到，才会报错。

如果外部类 和内部类中有同名变量的话，可以通过 this. 和 外部类.this. 的形式区分开来。

 

之前说内部类可以直接调用外部类的成员，那么外部类中可以直接调用内部类的成员么？答案是：不可以！

原因如下：

• 非静态内部类的成员只在非静态内部类的范围内是可知的，如果外部类想要调用内部类的成员，必须显示创建内部类的对象，通过内部类的对象进行调用。
• 非静态内部类是寄生在外部类对象中的，也就是说，有非静态内部类对象存在，则一定存在一个可以被他寄生的外部类对象。相反，如果有外部类对象的话，其中不一定存在寄生的非静态内部类对象。所以当外部类对象访问非静态内部类成员时，可能非静态内部类的对象根本不存在！

 

注意：非静态内部类里面是不可以有静态初始化块的，但可以包含普通初始化块。非静态内部类普通初始化块的作用与外部类初始化块的作用完全相同。

静态成员内部类

 

     如果使用static来修饰一个内部类，则这个内部类就属于外部类本身，而不属于外部类的某个对象。因此使用static修饰的内部类称为类内部类，也称为静态内部类。

     静态内部类可以包含静态成员，也可以包含非静态成员。根据静态成员不能访问非静态成员的规则，静态内部类不能访问外部类的实例成员，只能访问外部类的类成员。即是是静态内部类的实例方法也不能访问外部类的实例成员，只能访问外部类的静态成员。

如下图代码所示：

 

在静态内部类中访问外部类的静态私有成员会报错。

 

局部内部类

如果把一个类放在方法中定义，则这个类就是局部内部类，局部内部类仅在该方法中有效。由于局部内部类不能在外部类方法以外的地方使用，因此局部内部类也不能使用访问控制符合static修饰符。

如果需要使用局部内部类定义变量、创建实例或者派生子类，那么都只能在局部内部类所在的方法内进行。

局部内部类是一种非常鸡肋的语法，在实际开发中很少定义局部内部类，这是因为局部内部类的作用域实在太小了，只能在当前方法中使用。大部分时候，定义一个类之后，当然希望多次复用这个类，但局部内部类无法离开他所在的方法，因此在实际开发中很少使用局部内部类。

 

匿名内部类

匿名内部列审核创建那种只需要使用一次的类。创建匿名内部类的语法有点奇怪，创建匿名内部类时会立即创建一个该类的实例，这个类定义立即消失，匿名内部类不能重复使用。

定义格式如下：

new 实现接口()|父类构造器（实参列表）

{

       //匿名内部类的类体部分

}

从上面的定义可以看出，匿名内部类必须继承一个父类，或实现一个接口，但最多只能继承一个父类，或实现一个接口。

 

关于匿名内部类还有以下两条规则：

• 匿名内部类不能是抽象类。因为系统在创建匿名内部类时，会立即创建匿名内部类的对象。因此不允许将匿名内部类定义成抽象类。
• 匿名内部类不能定义构造器。由于匿名内部类没有类名，所以无法定义构造器，但匿名内部类可以定义初始化块，可以通过初始化块来完成构造器需要完成的事情。

最常用的创建匿名内部类的方式是需要创建某个接口类型的对象，如下程序所示：

package nimingClass;

interface  Product{
    public double getPrice();
    public String getName();
    }
public class NiMingClass {
  public void test(Product p){
      System.out.println("购买了一个"+p.getName()+"花掉了"+p.getPrice());
  }
  public static void main(String[] args){
      NiMingClass niMingClass = new NiMingClass();
      niMingClass.test(new Product(){
          public double getPrice(){
              return 567.8;
          }
          public String getName(){
              return "APG显卡";
          }
      });
  }
}

由于匿名内部类不能是抽象类，所以匿名内部类必须实现他的抽象父类或者接口里包含的全部抽象放法。