Java基础8——深入理解java的内部类

最新推荐文章于 2020-07-02 21:22:07 发布

置顶电子狗到程序猿

最新推荐文章于 2020-07-02 21:22:07 发布

阅读量119

点赞数 1

分类专栏： Java 基础内部类

本文链接：https://blog.csdn.net/weixin_43192732/article/details/85339621

版权

Java 同时被 3 个专栏收录

50 篇文章 0 订阅

订阅专栏

基础

44 篇文章 0 订阅

订阅专栏

内部类

1 篇文章 0 订阅

订阅专栏

深入理解内部类

内部类基础

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

问题：为什么要使用内部类？
在《Think in java》中有这样一句话：使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。
可以利用内部类提供的、可以继承多个具体的或者抽象的类的能力来解决这些程序设计问题。可以这样说，接口只是解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。

1. 成员内部类

成员内部类是最普通的内部类，其定义位于另一个类的内部且在方法外，作为类及类的成员而存在。

作为类，可声明为abstract的，即可以被其他的内部类所继承。
作为类的成员，其可声明为final、static（静态内部类）和abstract的，且与外部类不同的是，内部类可以使用四种访问修饰符进行修饰。

class Circle {
    double radius = 0;
     
    public Circle(double radius) {
        this.radius = radius;
    }
     
    class Draw {     //内部类
        public void drawSahpe() {
            System.out.println("drawshape");
        }
    }
}

这样看起来，类Draw像是类Circle的一个成员，Circle称为外部类。成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。

class Circle {
    private double radius = 0;
    public static int count =1;
    public Circle(double radius) {
        this.radius = radius;
    }
     
    class Draw {     //内部类
        public void drawSahpe() {
            System.out.println(radius);  //外部类的private成员
            System.out.println(count);   //外部类的静态成员
        }
    }
}

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

外部类.this.成员变量
外部类.this.成员方法

虽然成员内部类可以无条件地访问外部类的成员，而外部类想访问成员内部类的成员却不是这么随心所欲了。在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问：

class Circle {
    private double radius = 0;
 
    public Circle(double radius) {
        this.radius = radius;
        getDrawInstance().drawSahpe();   //必须先创建成员内部类的对象，再进行访问
    }
     
    private Draw getDrawInstance() {
        return new Draw();
    }
     
    class Draw {     //内部类
        public void drawSahpe() {
            System.out.println(radius);  //外部类的private成员
        }
    }
}

成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。创建成员内部类对象的一般方式如下：

public class Test {
    public static void main(String[] args)  {
        //第一种方式：
        Outter outter = new Outter();
        Outter.Inner inner = outter.new Inner();  //必须通过Outter对象来创建
         
        //第二种方式：
        Outter.Inner inner1 = outter.getInnerInstance();
        
        //若对于静态内部类创建对象：
        Outter.Inner inner2 = new Outter.Inner1();//不需要创建Outter的对象，直接创建内部类的对象
    }
}
 
class Outter {
    private Inner inner = null;
    public Outter() {
         
    }
     
    public Inner getInnerInstance() {
        if(inner == null)
            inner = new Inner();
        return inner;
    }
      
    class Inner {
        public Inner() {
             
        }
    }
    static class Inner1(){
    	public Inner() {
    	      
        }
    }
}

2. 局部内部类

局部内部类是定义在一个方法内或一个作用域（如if条件判断代码块）中的类，其和成员内部类的区别在于局部内部类的访问仅限于该方法内或该作用域中。
注意点：

局部内部类可以访问当前代码块的常量以及其外部类的所有成员。
局部内部类非外部类的成员，故外部类无法访问该内部类。
局部内部类可以看做一个局部变量，不能有public、protected、private 和static修饰。

class People{
    public People() {
         
    }
}
 
class Man{
    public Man(){
         
    }
     
    public People getWoman(){
        class Woman extends People{   //局部内部类
            int age =0;
        }
        return new Woman();
    }
}

3. 匿名内部类

基本结构：

new 父类构造器（参数列表）|实现接口（）  
    {  
     //匿名内部类的类体部分  
    }

匿名内部类指没有名字的内部类，故其只能使用一次，通常用来简化代码编写，如Android中为控件添加监听事件。

scan_bt.setOnClickListener(new OnClickListener() {
             
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                 
            }
        });
         
history_bt.setOnClickListener(new OnClickListener() {
             
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                 
            }
        });

使用匿名内部类能够在实现父类或者接口中的方法情况下同时产生一个相应的对象，但是前提是这个父类或者接口必须先存在才能这样使用。当然像下面这种写法也是可以的，跟上面使用匿名内部类达到效果相同。

private void setListener()
{
    scan_bt.setOnClickListener(new Listener1());        
    history_bt.setOnClickListener(new Listener2());
}
 
class Listener1 implements View.OnClickListener{
    @Override
    public void onClick(View v) {
    // TODO Auto-generated method stub
             
    }
}
 
class Listener2 implements View.OnClickListener{
    @Override
    public void onClick(View v) {
    // TODO Auto-generated method stub
             
    }
}

注意点：

匿名内部类必须继承一个父类或实现一个接口，进而对继承方法进行实现或重写（匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法）。
匿名内部类是唯一一种没有构造器的类，其在编译时由系统自动起名为「外部类名序号.class 」如「Outter1.class」。
匿名内部类一定是在new的后面，仅用于创建该匿名内部类的一个实例。
匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。

最常用的情况就是在多线程的实现上，因为要实现多线程必须继承 Thread类或是继承Runnable接口。

public class 匿名内部类 {

}
interface D{  //接口D
    void run ();
}
abstract class E{ //抽象类E
    E (){

    }
    abstract void work();//抽象方法
}
class A {

        @Test
        public void test (int k) {
            //利用接口写出一个实现该接口的类的实例。
            //有且仅有一个实例，这个类无法重用。
            new Runnable() {
                @Override
                public void run() {
//                    k = 1;报错，当外部方法中的局部变量在内部类使用中必须改为final类型。
                    //因为方外部法中即使改变了这个变量也不会反映到内部类中。
                    //所以对于内部类来讲这只是一个常量。
                    System.out.println(100);
                    System.out.println(k);
                }
            };
            new D(){
                //实现接口的匿名类
                int i =1;
                @Override
                public void run() {
                    System.out.println("run");
                    System.out.println(i);
                    System.out.println(k);
                }
            }.run();
            new E(){
                //继承抽象类的匿名类
                int i = 1;
                void run (int j) {
                    j = 1;
                }

                @Override
                void work() {

                }
            };
        }

}
--------------------- 
作者：How 2 Play Life 
来源：CSDN 
原文：https://blog.csdn.net/a724888/article/details/80087616 
版权声明：本文为博主原创文章，转载请附上博文链接！

为什么局部内部类和匿名内部类只能访问局部final变量？

public class Test1 {
    public static void main(String[] args)  {
         
    }
     
    public void test(final int b) {
        final int a = 10;//若去掉a,b前面任意一个final编译都出现错误
        new Thread(){
            public void run() {
                System.out.println(a);
                System.out.println(b);
            };
        }.start();
    }
} // 这段代码会被编译成两个class文件：Test.class和Test1.class。

在这里插入图片描述
分析原因：
当test方法执行完毕之后，变量a的生命周期就结束了，而此时Thread对象的生命周期很可能还没有结束，那么在Thread的run方法中继续访问变量a就变成不可能了，但是又要实现这样的效果，怎么办呢？Java采用了拷贝的手段来解决这个问题。将这段代码的字节码反编译可以得到下面的内容：
在这里插入图片描述
这条指令表示将操作数10压栈，表示使用的是一个本地局部变量。这个过程是在编译期间由编译器默认进行，如果这个变量的值在编译期间可以确定，则编译器默认会在匿名内部类（局部内部类）的常量池中添加一个内容相等的字面量或直接将相应的字节码嵌入到执行字节码中。这样一来，匿名内部类使用的变量是另一个局部变量，只不过值和方法中局部变量的值相等，因此和方法中的局部变量完全独立开。

public class Test2 {
    public static void main(String[] args)  {
         
    }
     
    public void test(final int a) {
        new Thread(){
            public void run() {
                System.out.println(a);
            };
        }.start();
    }
}

这里是将变量test方法中的形参a以参数的形式传进来对匿名内部类中的拷贝（变量a的拷贝）进行赋值初始化。
以局部内部类为例：

public class OuterClass {
    public void display(final String name,String age){
        class InnerClass{
            void display(){
                System.out.println(name);
            }
        }
    }
}
--------------------- 
作者：How 2 Play Life 
来源：CSDN 
原文：https://blog.csdn.net/a724888/article/details/80087616 
版权声明：本文为博主原创文章，转载请附上博文链接！

从上面代码中看好像name参数应该是被内部类直接调用？其实不然，在java编译之后实际的操作如下：

public class OuterClass$InnerClass {
    public InnerClass(String name,String age){
        this.InnerClass$name = name;
        this.InnerClass$age = age;
    }


    public void display(){
        System.out.println(this.InnerClass$name + "----" + this.InnerClass$age );
    }
}
--------------------- 
作者：How 2 Play Life 
来源：CSDN 
原文：https://blog.csdn.net/a724888/article/details/80087616 
版权声明：本文为博主原创文章，转载请附上博文链接！

所以从上面代码来看，内部类并不是直接调用方法传递的参数，而是利用自身的构造器对传入的参数进行备份，自己内部方法调用的实际上时自己的属性而不是外部方法传递进来的参数。

也就说如果局部变量的值在编译期间就可以确定，则直接在匿名内部里面创建一个拷贝（如Test1）。如果局部变量的值无法在编译期间确定，则通过构造器传参的方式来对拷贝进行初始化赋值。(如Test2)

简单理解就是，拷贝引用，为了避免引用值发生改变，例如被外部类的方法修改等，而导致内部类得到的值不一致，于是用final来让该引用不可改变。

4. 静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。

public class Test {
    public static void main(String[] args)  {
        Outter.Inner inner = new Outter.Inner();//不需要创建Outter的对象，直接创建内部类的对象
    }
}
 
class Outter {
    public Outter() {
         
    }
     
    static class Inner {
        public Inner() {
             
        }
    }
}

内部类初始化

我们一般都是利用构造器来完成某个实例的初始化工作的，但是==匿名内部类是没有构造器的！那怎么来初始化匿名内部类呢？使用构造代码块！==利用构造代码块能够达到为匿名内部类创建一个构造器的效果。

public class OutClass {
    public InnerClass getInnerClass(final int age,final String name){
        return new InnerClass() {
            int age_ ;
            String name_;
            //构造代码块完成初始化工作
            {
                if(0 < age && age < 200){
                    age_ = age;
                    name_ = name;
                }
            }
            public String getName() {
                return name_;
            }

            public int getAge() {
                return age_;
            }
        };
    }
--------------------- 
作者：How 2 Play Life 
来源：CSDN 
原文：https://blog.csdn.net/a724888/article/details/80087616 
版权声明：本文为博主原创文章，转载请附上博文链接！

电子狗到程序猿

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础8——深入理解java的内部类

深入理解内部类内部类基础在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。广泛意义上的内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。问题：为什么要使用内部类？在《Think in java》中有这样一句话：使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现...
复制链接

扫一扫