java笔记--内部类

内部类：

将一个类定义在另一个类的里面，对里面那个类就成为内部类（内置类、嵌套类）。

内部类访问特点：

1 内部类可以直接访问外部类中的成员
2 外部类要访问内部类，必须建立内部类的对象

用法

一般用于类的设计

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

class Outer{
    private int num=3;
    class Inner{//使用内部类可以直接访问num  
        void show(){
            System.out.print("show。。。。"+num);
        }
    }
    public void method(){//通过创建方法去创建对象，访问内部类
        Inner in = new Inner();
        in.show();
    }
}
public class InnerDemo {

    public static void main(String[] args) {
        Outer out=new Outer();
        out.method();
    }
}

运行：

image.png

常见的格式：

class Outer{
    private int num=3;
    private static int num1=4;
    class Inner{//使用内部类可以直接访问num  
        void show(){
            System.out.println("show。。。。"+num);
        }
    }
    static class Inner1{//使用内部类可以直接访问num  
        void show1(){
            //System.out.println("show1。。。。"+num);//在主函数调用这条语句会运行出错  静态类只能访问静态成员   所以需在num前加上static
            System.out.println("show1。。。。"+num1);//注意num和num1的区别
        }
        static void function(){//如果内部类中定义了静态成员，该内部类也必须是静态的
            System.out.println("function。。。。");
        }
    }
    public void method(){//通过创建方法去创建对象，访问内部类
        Inner in = new Inner();
        in.show();
    }
}
public class InnerDemo {

    public static void main(String[] args) {
        Outer.Inner in=new Outer().new Inner();//这种方式很少见，有些情况下内部类通常会被封装起来private
        in.show();
            
        //如果内部类是一个静态的，就相当于一个外部类
        Outer.Inner1 in1=new Outer.Inner1();
        in1.show1();
        
        //如果内部类是静态的，成员是静态的。
        Outer.Inner1.function();//直接调用
    }
}

运行：

image.png

内部类能直接访问外部类的成员。原因：

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

class Outer{
    int num=3;
    class Inner{
        int num=4;
        void show(){
            int num=5;
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(Inner.this.num);
            System.out.println(Outer.this.num);
        }
    }
    void method(){
        new Inner().show();
    }
}
public class InnerClass {

    public static void main(String[] args) {
        Outer out=new Outer();
        out.method();
    }
}

运行：

image.png

内部类也可以放在局部位置上。

//内部类在局部位置上只能访问局部中被final修饰的局部变量。
class Outer{
    int num=3;
    void method(){
        final int x = 9;//从内部类中访问局部变量需要在变量前加final
        class Inner{
            void show(){
                System.out.println("show..."+num);
                System.out.println("show..."+x);
            }
        }
        Inner in=new Inner();
        in.show();
    }
}

public class JuBuInner {

    public static void main(String[] args) {
        new Outer().method();
    }
}

运行：

image.png

匿名内部类：

匿名内部类，就是内部类的简写模式。

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

匿名内部类：其实就是一个匿名子类对象。

格式：new 父类or接口(){子类内容}

class Outer{
    int num=4;
//  class Inner extends Demo{
//      void show(){
//          System.out.print("show..."+num);
//      }
//  }
    public void method(){
        //new Inner().show();
        new Demo(){//匿名内部类
            void show(){
                System.out.println("show......"+num);
            }
        }.show();
    }
}
public class InnerClass {
    public static void main(String[] args) {
        new Outer().method();
    }
}

实现：

image.png

应用：

interface Inter{
    void show1();
    void show2();
}

class Outer{
    int num =4;
    /*
    class Inner implements Inter{
        public void show1(){}
        public void show2(){}
    }*/
    public void method(){
//      Inner in=new Inner();
//      in.show1();
//      in.show2();
        Inter in=new Inter(){
            public void show1(){
                System.out.println("show......"+num);
            }
            public void show2(){
                System.out.println("show......"+num);
            }
        };
        in.show1();
        in.show2();
    }
}
/*
常见的使用场景之一：
当函数参数是接口类型时，而且接口中的方法不超过三个。
可以用匿名内部类作为实际参数进行传递 
*/
public class YingYong {

    public static void main(String[] args) {
        new Outer().method();
        show(new Inter(){
           public void show1(){System.out.println("show......");}
            public void show2(){System.out.println("show......");}
        });
    }
    public static void show(Inter in){
        in.show1();
        in.show2();
    }
}

运行：

image.png

注意：

1 若在主函数中使用匿名内部类，因为主函数是静态的,只能调用静态的，所以想调用需用static修饰。
2 直接用例子解释：

class Outer{
    void method(){
        Object obj=new Object(){
            public void show(){
                System.out.print("show");
            }
        };
        obj.show();//因为匿名内部类这个子类对象被向上转型为了Object类型
                   //这样就不能再使用子类特有的方法了。
                   //所以在这里运行出错
    }
}
public class InnerDemo {

    public static void main(String[] args) {
        new Outer().method();
    }
}

运行出错。