【JavaSE】内部类讲解(二)

简介: 【JavaSE】内部类讲解

四、静态内部类

被 static 修饰的内部成员类称为静态内部类

class Out{
    //静态内部类
    static class Inner{
    }
}

(1)静态内部类的成员变量和方法的构建

跟实例内部类类似,静态内部类也可以创建成员变量和方法,唯一不同的是,静态内部类可以创建静态的方法静态的成员变量!!

静态内部类中的静态成员变量可以不被 final 修饰

class Out{
    //静态内部类
    static class Inner{
        public int data1 = 1;
        private int data2 = 2;
        public static int data3 = 3;
        public void Inner(){
            System.out.println("静态内部类的构造方法");
        }
        public void func1(){
            System.out.println("静态内部类的普通方法");
        }
        public static void func2(){
            System.out.println("静态内部类的静态方法");
        }
    }
}

(2)静态内部类在实外创建

由于静态内部类是静态的,不依赖与外部类实例化对象,所以实例化就不需要创建外部类对象!!

外部类.内部类 变量名 = new 外部类.内部类;
class Out{
    //静态内部类
    static class Inner{
        public void Inner(){
            System.out.println("静态内部类的构造方法");
        }
        public void func1(){
            System.out.println("静态内部类的普通方法");
        }
        public static void func2(){
            System.out.println("静态内部类的静态方法");
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Out.Inner inner = new Out.Inner();
        inner.func1();
    }
}

注意:在外部类中,实例化静态内部类也是直接用类名实例化!

(3)在静态内部类中访问外部类成员变量

注意:在静态内部类中不能直接方法外部类中非静态的成员变量

class Out{
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;
    //静态内部类
    static class Inner{
        public int data4 = 4;
        private int data5 = 5;
        public static int data6 = 6;
        public void Inner(){
            System.out.println("静态内部类的构造方法");
        }
        public void func1(){
            System.out.println("静态内部类的普通方法");
            System.out.println("外部类中静态成员变量 data3:"+data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
        }
    }
}

 ① 在静态内部类中访问外部类非静态的成员变量

   因为静态内部类是静态的,不依赖于外部类对象,所以我们要想在静态内部类中访问,就要构建一个外部类对象。

class Out{
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;
    //静态内部类
    static class Inner{
        public void Inner(){
            System.out.println("静态内部类的构造方法");
        }
        public void func1(){
            Out out = new Out();
            System.out.println("外部类非静态成员变量 data1:"+out.data1);
            System.out.println("外部类非静态成员变量 data2:"+out.data2);
        }
    }
}

(4)总结


五、局部内部类

局部内部类是在方法内部定义的内部类

public class Demo3 {
    public void Func(){
        /**
         * 局部内部类
         * 不能被 public static 修饰
         */
        class Inner{
        }
    }
    public static void main(String[] args) {
    }
}

注意:


     ① 局部内部类只能在所定义的方法体内部使用


     ② 不能被public、static等修饰符修饰


     ③ 因为局部内部类局限性很大,所以平时很少用  

六、匿名内部类        

       匿名类是一个没有类名的特殊内部类,也叫匿名内部类,适合于只使用一次的类。创建匿名内部类是须继承一个已有的父类或则实现一个接口。

new 父类名/接口名(){
    //类体
};

(1)静态内部类在实外创建

       因为匿名内部类既是一个类的定义,同时它本身也是一个对象,在类外创建是可以使用该继承的父类名或实现的接口名接收!

父类名/接口名 变量名 = new 父类名/接口名(){
    //类体
};

① 继承父类实现内部类

匿名内部类继承的父类可以是 普通类 也可以是 抽象类!

class B{
    public void func2(){
    };
}
abstract class C{
    abstract void func3();
}
public class Demo1 {
    public static void main(String[] args) {
       B b = new B(){
         public void func2(){
             System.out.println("继承普通类的匿名内部类"); 
         };
       };
        C c = new C() {
            @Override
            void func3() {
                System.out.println("继承抽象的匿名内部类");
            }
        };
        b.func2();
        c.func3();
    }
}

② 实现接口创建内部类

interface A{
    public abstract void func1();
}
public class Demo1 {
    public static void main(String[] args) {
        A a = new A() {
            @Override
            public void func1() {
                System.out.println("实现接口的匿名内部类");
            }
        };
        a.func1();
    }
}

      这里创建内部类的过程类似于,一个类实现了A接口,这不过这个类是没有名字的。

(2)匿名内部类的成员变量和方法的构建

      匿名内部类由于本身没有名字,所以就不存在构造方法,同时也不能包含静态的成员!!但是普通的成员直接可以创建

A a = new A() {
            public int data1 = 1;
            @Override
            public void func1() {
                System.out.println("实现接口的匿名内部类");
            }
            public void func2(){
                System.out.println("匿名内部类的普通方法");
            }
        };

注意:匿名内部类中可以有许多方法,但是在类外只能调用重写的方法!!


简而言之就是,与 继承的父类 或 实现的接口中方法 同名的,匿名内部类才能调用

(3)匿名内部类访问外部类的成员变量和局部变量

 在匿名内部类中,可以直接访问外部类的静态成员变量和局部变量!


 非静态成员变量需要构建外部类实例才能访问

interface A{
    void func();
}
public class Out {
    public static int data1 = 1;
    public int data2 = 2;
    private int data3 = 3;
    public static void main(String[] args) {
        String name ="威威";
        A a = new A() {
           @Override
           public void func() {
               System.out.println(name);
               System.out.println(data1);
               Out out = new Out();
               System.out.println(out.data2);
               System.out.println(out.data3);
           }
       };
       a.func();
    }
}

注意:外部其他类不能访问匿名内部类,因为匿名内部类实际上就是一个局部变量!!

(4)总结

以上就是内部类的讲解,有错误的地方希望大家能批评指正,别忘了点赞👍+收藏⭐️哦

相关文章
【JavaSE】详解final关键字
【JavaSE】详解final关键字
|
Java 编译器
【JAVASE】继承 中
【JAVASE】继承
|
Java 编译器
【JavaSE】抽象类
【JavaSE】抽象类
【JavaSE】抽象类
|
Java 程序员 编译器
【JavaSE】一起学继承
【JavaSE】一起学继承
【JavaSE】内部类
【JavaSE】内部类
|
Java 程序员
【JAVASE】继承 上
【JAVASE】继承
|
Java 定位技术 Android开发
Java的内部类和匿名类 , 您了解过吗?
Java的内部类和匿名类 , 您了解过吗?