java内部类——非静态内部类

目录

内部类

内部类的作用

内部类相关的设计

内部类分类

非静态内部类

---

内部类

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

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三个修饰符，这三个修饰符不能用在外部类上
• 非静态内部类不能拥有静态成员

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{}
}

 非静态内部类的特点：

• 和其他类一样，它只是定义在外部类中的另一个完整的类结构

可以继承自己的想要继承的父类，实现自己想要实现的父接口们，和外部类的父类和父接口无关

可以在非静态内部类中声明属性、方法、构造器等结构，但是不允许声明静态成员，但是可以 继承父类的静态成员，而且可以声明静态常量。

可以使用abstract修饰，因此它也可以被其他类继承

可以使用final修饰，表示不能被继承

编译后有自己的独立的字节码文件，只不过在内部类名前面冠以外部类名和$符号。

• 和外部类不同的是，它可以允许四种权限修饰符：public，protected，缺省，private

外部类只允许public或缺省的

• 还可以在非静态内部类中使用外部类的所有成员，哪怕是私有的
• 在外部类的静态成员中不可以使用非静态内部类哦

就如同静态方法中不能访问本类的非静态成员变量和非静态方法一样

• 在外部类的外面必须通过外部类的对象才能创建非静态内部类的对象

因此在非静态内部类的方法中有两个this对象，一个是外部类的this对象，一个是内部类的 this对象

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

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="yan";//语法错误,除非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();
    }
}

 外部类.内部类 in=new 外部类().new 内部类();

public class A1 {
    public static void main(String[] args) {
        B1 b = new B1();
        B1.C1 cc=b.new C1();//内部类是否可以访问到，取决于内部类上的范围限定词
    }
}
class B1 {
    class C1{}
}

 in.内部类方法();

public class A1 {
    public static void main(String[] args) {
        B1 b = new B1();
        B1.C1 cc=b.new C1();
        cc.pp(); //是否可以访问pp方法取决于pp方法的范围限定词
    }
}
class B1 {
    class C1{
        public void pp(){}
    }
}

 注意内部类的可见性范围限制

class B1 {
    private class C1{//注意这个C1类只能在B1类中进行使用，其它位置不可见
        public void pp(){}
    }
}

 问题：

public class A1 {
    public A1(){
        System.out.println("aaaaa");
    }
    public static void main(String[] args) {
        new A1();//创建外部类对象和内部类无关，创建外部类对象并不会自动创建内部类对象
    }
    class C1 {
        public C1() {
            System.out.println("dddd");
        }
    }
}