内部类笔记

内部类##

一个类或者接口定义在另外一个类或者接口的内部

public class A1{//外部类 
  class B1{}//内部类 
  interface C1{}//内部接口 
}

将一个类定义置入另一个类定义中，这就叫作“内部类”

• 内部类之外的类称为外部类
• 内部类的名称必须区别于它所在的外部类，和其它类之间没有要求

//内部类的全名叫做[外部类名称$内部类名称] 
public class A1 {
    public class A1{} //语法报错 
    class B1{} //语法正确，默认编译的结果名称为A1$B1.class 
}
class B1{}

• 内部类可以访问其外部类的所有变量和方法

public class A1 {//外部类的范围限定词只能是public或者默认package 
    private String name; public class B1 { //内部类的范围限定词可以是4种
        public void pp() { 
            System.out.println(name); //可以直接访问外部类的成员 
            System.out.println(A1.this.name);//这里的
            A1.this用于表示A1类对象 A1.this.name="ffff"; //System.out.println(this.name);报错的原因是this用于指代当前类的对象，当前类 B1中并没有属性name
            pp(); //可以直接访问外部类的成员 
            A1.this.pp(); 
        } 
    }
    private void pp(){}
}

外部类不能直接访问内部类的实现细节，可以通过创建内部类对象的方式直接访问，不受限定词的影响

public class A1 {
    private String name;
    public class B1 {
        private int age=99;
        public void ff() {
            System.out.println(name); System.out.println(A1.this.name); A1.this.name="ffff";
        }
        private void dd(){} 
    }
    private void pp(){ 
        B1 b=new B1(); //如果需要在外部类中访问内部类的实现细节则需要构建内部类对象，然后 通过内部类对象进行访问 
        b.ff();
        System.out.println(b.age); //注意：可以直接访问内部类中的私有属性 b.dd();//私有方法仍旧可以直接调用 
    } 
}

• 内部类比外部类多了private/protected/static三个修饰符，这三个修饰符不能用在外部类上
• 非静态内部类不能拥有静态成员，静态内部类则没有这个限制

public class A{ 
    protected class B1 { 
        private int age = 99;
        { }//允许包含非静态代码块
        private static String password="123456";//非静态内部类中不能包含静态属性 
        static{ }//非静态内部类中不允许包含静态代码块 
        public B1() {//允许定义构造器和析构器方法 
        }
        public static void hh(){} //非静态内部类中不允许包含静态方法 
    }
}

内部类的作用

• 内部类提供更好的封装
• 内部类可以直接访问外部类的私有成员，外部类不能直接访问内部类的成员
• 匿名内部类适合用于创建仅仅使用一次使用的类

内部类相关的设计

• 分析事物时发现该事物描述还有事物，而且这个事物还在访问被描述事物的内容 例如牛和牛腿
• 如果一个事物离开另外一个事物后则没有任何意义，这种情况下建议使用内部类，不允许其他类访问
• 内部类能直接访问外部类中成员，是因为内部类持有了外部类的引用，即外部类名.this

###内部类分类

在 Java 中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。广泛意义上的内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。

内部类实际拥有外部类的一个引用，在构造函数中将外部类的引用传递进来。

非静态内部类

public class A1{
    protected class B1{}//静态内部类是protected static class B1{} }

在创建非静态内部类对象时，一定要先创建起相应的外部类对象

public class A1 {
    public static void main(String[] args) {
        B1 b = new B1(); 
        B1.C1 cc = b.new C1(); //内部类的写法为[外部类名.内部类名]，否则需要import com.yan.B1.C1;则可以直接使用C1类。至于C1类是否可见取决于C1类的范围限定词 
        System.out.println(cc); 
    }
}
class B1 {
    public class C1 {
    }
}

• 在任何非静态内部类中，都不能有静态数据、静态方法或者又一个静态内部类

//语法错误 
public class A1{ 
    public class B1{
        public static String name="ooo";//语法错误,除非B1类是静态内部类 static class B1{}
        static{}//语法错误
        public static void pp(){}//语法错误 
        public static class C1{}//语法错误 
    } 
}

• 注意内部类的可见性范围限制
• 访问方法：直接访问外部类中内部类中的成员

class B1 {
    private String pwd; 
    private void dd(){} 
    protected class C1 { 
        private String name; private void pp(){           System.out.println(pwd);//内部类可以直接访问外部类中的私有成员
    //另外的写法 B1.this.pwd 
     dd();
  //另外的写法 B1.this.dd();
      }
    }
    public void ee(){ //如果需要访问内部类中的成员，则必须首先创建内部类对象 
        C1 cc=new C1(); //通过构建的内部类对象则可以访问内部类中的私有成员 
        cc.name="abc";
        cc.pp(); 
    } 
}