java 四大内部类-----转载

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java 四大内部类-----转载相关的知识，希望对你有一定的参考价值。

(成员)内部类-常用
技术分享
特点：可以把内部类当作是外部类的一个【成员】
  • 同外部类的成员一样，内部类可被private、protected等权限修饰符修饰
  • 同外部类的成员一样，private修饰的内部类仅对外部类是可见的【public Inner in=new Inner();】，对外部类以外的地方不可见
  • 同外部类的成员一样，内部类中也可以访问外部类的private成员（当然包括static成员）
  • 同外部类的成员不一样的是，成员内部类中不能定义静态变量(否则就要定义为静态内部类)，但是可以定义 static final 变量(即常量)
  • 同外部类的成员不一样的是，编译完成后，内部类会被编译成一个独立的类【Outer$Inner.class】，而不是Outer类的一个域
特殊使用场合：
通过使用内部类可以间接实现多继承，可以解决实现的多个接口之间，或继承的类与接口之间方法同名的冲突
例如 class Robot extends People implement Machine { }
而若 class People 和 interface Machine 都有一个同名的方法 run() 
此时若按以上结构是无法区分 Robot 中的 run() 到底是继承的还是实现的
此时的解决方式为：让 Robot 仅继承或仅实现，再在 Robot 中定义一个内部类仅实现或仅继承即可
外部类访问内部类的方式：
  • 1.1、在外部类及其[非静态]方法中可以直接访问内部类【 new Inner().内部类的成员】
  • 1.2、在外部类的[静态]方法中需要先创建外部类对象，才访问内部类【new Outer(). new Inner().内部类的成员】
  • 1.3、其他地方访问内部类也是【new Outer(). new Inner().内部类的成员】
内部类访问外部类的方式：
  • 2.1、外部类的成员变量如果和内部类的变量不同名，则内部类可直接用【变量名】访问外部类的成员变量
  • 2.2、若同名，则内部类可用【Outer.this.变量名】来访问外部类的实例变量(注意不是Outer.Inner.变量名)
  • 2.3、在内部类中直接用【变量名】或【this.变量名】访问的都是内部类自己的实例变量
// 外部类之外的其他类
class InnerClassDemo {
    public static void main(String[] args) {
        new Outer().new Inner().innerSpeak(); //1.3、其他地方访问内部类
    }
}
 
//外部类
class Outer {
    private static int age = 1;
    private String name = "外部类";
    private Inner ooo = new Inner(); //1.1、在外部类中可以直接访问内部类
 
    public void method() {
        new Inner().innerSpeak(); //1.1、在外部类的非静态方法中可以直接访问内部类
 
    }
 
    public static void method2() {
        new Outer().new Inner().innerSpeak();//1.2、在外部类的静态方法中访问内部类
 
    }
 
    //内部类
    class Inner {
        private String name = "普通内部类";
 
        void innerSpeak() {
            System.out.println(age++ + "..." + name); //2.1、不同名，可直接用变量名访问外部类的成员变量
        }
 
        void hello() {
            String name = "局部变量";
            System.out.println(Outer.this.name + "..." + this.name + "..." + name); //2.2、同名，可用Outer.this.变量名 访问    
        }
    }
 
}
技术分享
 
静态内部类-较麻烦
技术分享
特点：可以把静态内部类当作外部类的一个【静态成员】
  • 和静态成员一样，静态内部类用 static 定义，可以用 public,protected,private修饰
  • 和静态成员一样，静态内部类随着外部类的加载而产生，可以用外部类类名+静态成员名直接获得
  • 和静态方法不一样的是，静态内部类中可以定义静态的也可以定义非静态的成员
外部类访问内部类方式：
  • 1.1、外部类可以直接访问静态内部类【 new Inner().静态内部类的成员】
  • 1.2、外部类的[静态和非静态]成员都可以用【Outer.Inner.成员】访问内部类的[静态]成员
  • 1.3、外部类的[静态和非静态]成员都可以用【new Outer.Inner().成员】访问内部类的[非静态]成员
  • 1.4、其他地方访问内部类可用【new Outer.Inner().成员】，其中访问静态成员还可以用【Outer.Inner.成员】
内部类访问外部类方式：
  • 2.1、若内部类的[静态和非静态]成员和外部类的[静态]成员不同名，可以直接用【成员名】访问
  • 2.2、同名时，内部类的[静态和非静态]成员可以用【Outer.成员】访问外部类的[静态]成员
  • 2.3、内部类的[静态和非静态]成员可以用【new Outer().成员】访问外部类的[非静态]成员
// 外部类之外的其他类
class InnerClassDemo {
    public static void main(String[] args) {
        new Outer.Inner2().innerSpeak(); //1.4
        new Outer.Inner2().innerSpeak2(); //1.4
        Outer.Inner2.innerSpeak(); //1.4
    }
}
//外部类
 
class Outer {
    private static int age = 1;
    private String name = "外部类";
   private Inner2 ooo = new Inner2(); //1.1
 
    public void method() {
      new Inner2().innerSpeak();//1.1
      new Outer.Inner2().innerSpeak(); //1.1
      Outer.Inner2.innerSpeak();//1.2      
      new Outer.Inner2().innerSpeak2(); //1.3
    }
    //静态内部类
 
    static class Inner2 {
 
        private static String name = "静态内部类";
 
        static void innerSpeak() {
           System.out.println(age + "..." + Outer.age + "..." + name + "..." + new Outer().name);//2.1、2.2、2.3
        }
 
        void innerSpeak2() {
            System.out.println("静态内部类的非静态方法");
        }
    }
}
技术分享
 
匿名内部类-最简单
技术分享
典型使用场景：
  • 若一个类继承于某个类(不般是一个抽象类)，或是实现了某个接口，那么此类一般是需要重写或实现某些抽象方法的
  • 除此之外，若此类并不需要增加额外的成员，且我们不需要知道此类的实际类型(只是为了获得一个对象，且用完之后没有任何一个地方会再用到)，则适合使用匿名内部类
 注意：
  • 匿名内部类是唯一一种【无构造方法类】，匿名内部类中不能定义构造方法
  • 匿名内部类在编译的时候由系统自动起名Out$1.class
常用格式一（单一引用）：
        new Fu() {    //或接口
            void show(){} //子类【重写或隐藏】的父类的方法
        }.show();
常用格式二（多引用）：
        Fu f = new Fu() {
            void show1(){}
            void show2(){}
        };
        f.show1();
        f.show2();
常用格式三（参数传递）：
   obj.show(new InterfaceDemo(){ //函数参数是接口类型
        public void show1(){}   //接口中的方法通常不超过2个
        public void show2(){}
    });
技术分享
 
局部内部类-不常用
技术分享
特点：可以把局部内部类当作外部类方法中的一个局部变量
  • 与局部变量一样，局部内部类是在方法(当然可以是静态方法)中定义的
  • 与局部变量一样，局部内部类只能在其所在方法中使用，且不能被public、static等修饰
  • 与局部变量一样，只有定义局部内部类之后的代码，才可访问局部内部类(即先定义后使用)
  • 与局部变量一样，局部内部类可以访问外部类的任何成员
  • 与局部变量不一样的是，局部内部类中不可定义静态变量(不管外部方法是不是静态的)
  • 与局部变量不一样的是，局部内部类只能访问 final 修饰的局部变量(也即只能访问常量)
外部类不能访问局部内部类
内部类访问外部类的方式：
  • 1.1、局部内部类的变量若和外部类的成员变量不同名，则可直接用【变量名】访问外部类的成员
  • 1.2、若同名，则局部内部类可用【Outer.this.变量名】来访问外部类的成员
  • 1.3、在局部内部类中可以直接用【变量名】或【this.变量名】来访问内部类自己的成员
// 外部类之外的其他类
class InnerClassDemo {
    public static void main(String[] args) {
        new Outer().method(3);
    }
}
 
// 外部类
class Outer {
    private int s = 1;
    private static int o = 2;
    private static int oo = 3;
 
    public void method(final int k) {
        final int s = 100;
        final int oo = 200;
        int i = 300;
 
        //局部内部类
        class Inner {
            Inner(int k) {
                method();//我是外部类的方法
                System.out.println(o);//2
                System.out.println(oo);//200
                System.out.println(s);//100
                System.out.println(Outer.this.s);//1
                //System.out.println(i);//错误
            }
        }
        new Inner(k);
    }
 
    private void method() {
        System.out.println("我是外部类的方法");
    }
}
技术分享

以上是关于java 四大内部类-----转载的主要内容，如果未能解决你的问题，请参考以下文章

java内部类的四大作用

Android 开发必备知识点及面试题汇总（Android+Java+算法+性能优化+四大组件……）

java匿名内部类 (转载)

Java 静态内部类作用？

java内部类与匿名内部类作用分别是啥？

java四大特性详解