内部类

概述

将一个类定义在另一个类里面类就称为内部类

访问特点：

1.内部类可以直接访问外部类中的成员，包括私有成员

2.外部类要访问内部类中成员必须要建立内部类的对象

内部类的设计：分析事物时，发现该事物中还有事物，而且这个事物还在访问被描述事物的内容，这时就是还有的事物定义成内部类来描述

修饰符

package com.monfolld;
class Outer1
{
    private int num=3;
    class Inner  //内部类可以直接访问外部类的成员
    {
       void show(){
           System.out.println("show run"+num);
       }
    } 
    public  void method(){
    Inner in=new Inner();
    in.show();
}
}
public class InnerClassDemo {
    public static void main(String[] args){
        Outer1 o=new Outer1();    
        o.method(); 
             //Outer1.Inner o=new Outer1().new Inner();   直接访问外部类中的内部类中的成员
             //    o.show();
    }
}

当内部类为静态时，如果要访问外部类中的成员变量，外部类中的成员变量必须也是静态的

package com.monfolld;
class Outer1
{
    private   static int num=3;    //静态变量
   static class Inner  //静态内部类可以直接访问外部类的静态成员
    {
       void show(){
           System.out.println("show run"+num);
       }
    }
    public  void method(){
    Inner in=new Inner();
    in.show();
}
}
public class InnerClassDemo {
    public static void main(String[] args){
        //如果内部类是静态的，相当于一个外部类
        Outer1.Inner in=new Outer1.Inner();   //静态内部类的创建对象格式
          in.show();
    }
}

如果内部类是静态的，成员是静态的

package com.monfolld;
class Outer1
{
    private   static int num=3;    //静态变量
   static class Inner  //静态内部类可以直接访问外部类的静态成员
    {
      static void show(){
           System.out.println("show run"+num);
       }
    }
    public  void method(){
    Inner in=new Inner();
    in.show();
}
}
public class InnerClassDemo {
    public static void main(String[] args){
        //如果内部类是静态的，成员是静态的格式
        Outer1.Inner.show();
    }
}

如果内部类中定义了静态成员，该内部类也必须是静态的

细节

为什么内部类能直接访问外部类的成员呢？

因为内部类持有了外部类的引用，    外部类名.this

package com.monfolld;
class Outer2{
    int num=3;
        class Inter
        {
            int num=4;
            void show(){
                int num=5;
                System.out.println("show..."+num);
                System.out.println("show..."+this.num);
                System.out.println("show..."+Outer2.this.num);
            }
        }
        void method(){
            new Inter().show();
        }
}
public class InterClassDemo2 {
    public static void main(String[] args){
        new Outer2().method();
    }
}

运行结果：

show...5
show...4
show...3

内部类可以存放在局部位置上，只能访问局部中被final修饰的局部变量

package com.monfolld;
class Outer3{
    int num=3;
    void method(){
        
       final int x=9;  //原本访问局部变量必须加final，但我用的java8，竟然不加final也能运行
        class Inner{
            void show(){
                System.out.println("show..."+x);
            }
        }
        Inner in=new Inner();
        in.show();
    }
}
public class InnerClassDemo3 {
    public static void main(String[] args){
        new  Outer3().method();
    }
}

匿名内部类

匿名内部类，就是内部类的简写格式.

前提：内部类必须继承或者实现一个外部类或者接口

匿名内部类，其实就是一个匿名子类对象 ，格式：new父类or接口（）{子类内容}

package com.monfolld;
abstract class Demo{
    abstract  void show();
}
class Outer4{
    int num=4;
public void method(){
    new Demo()
    {
        void  show(){
            System.out.println("show..."+num);
        }
    }.show();
}
}
public class InterClassDemo4 {
    public static void main(String[] args){
      Outer4 o=new Outer4();
      o.method();
    }
}

上面这段代码的内容等同于

package com.monfolld;
 abstract class   Demo{
    abstract void show();
}
class Outer4{
   int num=4;
    class Inner extends Demo{
        void show(){
            System.out.println("show..."+num);
        }
    }
    public void method() {
        new Inner().show();
    }
}
public class InterClassDemo4 {
    public static void main(String[] args){
        Outer4 o=new Outer4();
        o.method();
    }
}

通用场景之一，当函数的参数是接口类型时，而且接口中的方法不超过三个，可以用匿名内部类作为实际参数进行传参

注意：1.主函数不能访问内部类中非静态成员

2.匿名内部类这个子类对象被向上转型，就不能调用子类的特有方法了