java：内部类（实例内部类、静态内部类、方法内部类、匿名内部类）

最新推荐文章于 2024-10-10 18:02:30 发布

约翰兰博之西安分博

最新推荐文章于 2024-10-10 18:02:30 发布

阅读量143

点赞数

分类专栏： java知识相关文章标签： java 类编程语言

本文链接：https://blog.csdn.net/qq_21864095/article/details/113277586

版权

java知识相关专栏收录该内容

19 篇文章 0 订阅

订阅专栏

1、概念：

内部类，简言之就是类里面定义的类或者一个类的方法中定义的类。

java这块分为 实例内部类，静态内部类，匿名内部类，方法内部类（局部内部类）

2、实现：

1、实例内部类（成员内部类）：

class Circle{
    private  double radius;
    private static int count =1;
    public Circle(double radius) {
        this.radius = radius;
    }

    public void spael(){
    }

    class Draw{//实例内部类
        private double radius;
        public void drawShape(){
            System.out.println("draw map");
            System.out.println(radius);//外部类成员变量
            System.out.println(count);//外部类静态变量
            spael();//外部类成员方法
        }
    }
}

1、成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）

2、要建一个成员内部类对象，必须先建立一个外部类对象

创建成员内部类对象的一般形式为：外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()

3、当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

外部类.this.成员变量

外部类.this.成员方法

class Circle{
     double radius =20;
    private static int count =1;



    public Circle() { }//外部类的构造方法

    //1、外部类的有参构造 
    public Circle(double radius){
        this.radius =radius;
    }


    class Draw{//实例内部类
       double radius =500;

       public Draw(){}

       public Draw(double radius){
           this.radius = radius;
       }

        public void drawShape(){//内部类的drawShape方法
            System.out.println("内部类的 drawShape方法");
            System.out.println(Circle.this.radius);//外部类的this 所以是21。。成员内部类，含有外部类的this引用
            System.out.println(this.radius+"\n");//内部类的this 所以是5

            System.out.println("成员内部类调用外部类的方法");
            Circle.this.drawShape();//成员内部类调用外部类的实例方法 有外部类的this引用  值是21 21
        }
    }

    public void drawShape(){//外部类的drawShape方法
        System.out.println("外部类的 drawShape方法");
        System.out.println(Circle.this.radius);//外部类的  其实这和下面的一样
        System.out.println(this.radius+"\n");


    }
}

public class InnerClassTestDemo {
    public static void main(String[] args) {

        //成员内部类对象的创建，必须先创建一个外部类的对象 之后再new 内部类的对象。
        //可以理解为成员内部类是外部类的一个属性，所以必须先调用外部类的
        Circle circle = new Circle(21);
        Circle.Draw draw = circle.new Draw(5);

        System.out.println("外部类的radius"+draw.radius);//内部类的radius 500
        System.out.println("内部类的radius"+circle.radius+"\n");//外部类的radius 5

        draw.drawShape();//调用外部类的方法
        circle.drawShape();//直接调用外部类的方法
    }

}
结果：
外部类的radius5.0  //System.out语句 外部类对象调用
内部类的radius21.0 //system.out语句 内部类调用

内部类的 drawShape方法  // （A） draw.drawShape();调用内部类的方法
21.0 //有外部类的this引用  是 外部类的radius的值
5.0 //内部类的this 是 内部类的radius的值

成员内部类调用外部类的方法//(A)执行 即调用内部类的draw方法，里面调用了外部类的draw方法
外部类的 drawShape方法
21.0 //外部类的this引用 外部类的值
21.0

外部类的 drawShape方法 //main函数里面单纯的调用了外部类的方法
21.0 
21.0

4、外部类不能直接访问内部类的对象及方法，但可以通过new一个内部类对象调用

class Circle{
     double radius =20;
    private static int count =1;



    public Circle() { }//外部类的构造方法

    //1、外部类的有参构造  在初始化时候，new一个内部类对象getDrawInstance（）返回一个内部类引用，之后外部类调用内部类的方法
    public Circle(double radius){
        this.radius =radius;
        getDrwInstance().drawShape("OutClass: Circle" );
    }

    public Draw getDrwInstance(){
        return new Draw();
    }

    class Draw{//实例内部类
       double radius =500;

       public Draw(){}


        public void drawShape(String who){//内部类的drawShape方法
            System.out.println(who+"调用内部类的 drawShape方法");
        }
    }

    public void drawShape(){//外部类的drawShape方法
        System.out.println("外部类的 drawShape方法");

    }
}

public class InnerClassTestDemo {
    public static void main(String[] args) {

        Circle circle = new Circle(21);//在new外部类对象时候，已经new了一个内部类对象，所以外部类借此对象调用了内部类的方法
        Circle.Draw draw = circle.new Draw();
        draw.drawShape("InnerClass:draw");//new出来的内部类对象 自己调用了自己的方法 

    }

}

输出：
OutClass: Circle调用内部类的 drawShape方法
InnerClass:draw调用内部类的 drawShape方法

内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。比如上面的例子，如果成员内部类Inner用private修饰，则只能在外部类的内部访问，如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。这一点和外部类有一点不一样，外部类只能被public和包访问两种权限修饰。我个人是这么理解的，由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰。

2、静态内部类

静态内部类，在内部类的前面有static修饰。

class OuterClass{
    static int A = 10;
    public int B=20;

    public void noneStaticSpeak(){
        System.out.println("OuterClass noneStatic speak");
    }

    public static void staticSpeak(){
        System.out.println("OuterClass Static speak");

    }


    static class InnerClass{
        static int A =11;
        public int B =10;

        public void hello(){

            /*OuterClass.this.speak();外部类，没有给静态内部类提供this引用，所以静态内部类里面无法调用外部类的 非静态变量，非静态成员
            OuterClass.speak();
            OuterClass.B;
            */
            System.out.println(OuterClass.A);
            System.out.println(InnerClass.A);
            OuterClass.staticSpeak();

        }
    }
}

public class InnerClassTestDemo {
    public static void main(String[] args) {
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
        innerClass.hello();
    }
}

静态内部类，不能访问外部类的非静态变量和非静态方法，原因是外部类没有给静态内部类提供this引用，所以静态内部类里面外部类.this，就点不出来。

成员内部类和静态内部类的区别：

1、静态内部类没有外部类的引用，this，所以无法访问外部类的非静态变量和方法

成员内部类有外部类的this引用，所以开销比静态内部类大

2、对于成员内部类，必须先产生外部类的实例化对象，才能产生内部类的实例化对象。而静态内部类不用产生外部类的实例化对象即可产生内部类的实例化对象。

创建静态内部类对象的一般形式为：外部类类名.内部类类名 xxx = new 外部类类名.内部类类名()

　　创建成员内部类对象的一般形式为：外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()（也就是说得先new个外部类对象）

3、局部内部类（方法内部类）

局部内部类是定义在一个方法或者一个域内的，它和成员内部类的区别在于局部内部类的访问仅限于方法或者该作用域内

class People{
    public People(){}
}

class Mann{
    
    public Mann(){}

    public People getWoman(){
        class Womman extends People{
            public Womman(){}
        }
        return new Womman();
    }
    
}

注意，局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

4、匿名内部类（暂时没有用到这块的，可以参考一下俩链接）

Java的匿名内部类

java中的匿名内部类总结