java 内部类的学习总结

内部类
参考文档：https://www.runoob.com/w3cnote/java-inner-class-intro.html

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

1.成员内部类

//1.成员内部类地位和类的成员等同 
//2.成员内部类可以访问外部类的任意成员方法。 
//3.如果外部类需要访问内部类，则需要先创建内部类对象。直接创建。 
//4.其他类获取成员内部类对象为 new People().new Man(); 
//5.成员内部类的访问修饰符可以控制他的访问权限。这一点和类的成员是一致的。
成员内部类为什么不可以声明静态属性或方法?
三点说明：
static类型的属性和方法，在类加载的时候就会存在于内存中。
要想使用某个类的static属性和方法，那么这个类必须要加载到虚拟机- 中。
非静态内部类并不随外部类一起加载，只有在实例化外部类之后才会加载。
 结论：
非静态内部类不能有静态成员！
成员内部类必须先实例化外部类对象然后再实例化成员内部类；

定义类
package java_basic.stuInnerClass;
import org.junit.Test;
public class People {
    private  String name="小明";
    public int age=29;
    @Test
    public void method01() {
        System.out.println( new Man().showMessage());
        System.out.println(new People().age);//29
        System.out.println(People.this.age);//29
    }
    public People(){}
    //成员内部类
    //这个修饰符，用途类成员的用法非常一致。
    //搞不清访问修饰符，你需要参考：https://blog.csdn.net/qq_40331861/article/details/106949169
   public class Man{
        public int age =28;
        public String showMessage(){
            return "hello world"+"  name="+name;
        }
        public int getAge(){
            return age;
        }
    }
}
访问成员内部类
package java_basic.other;//注意这个包名 和People如果不在同一包里，就需要注意People中内部类前的访问修饰符了。
import java_basic.stuInnerClass.People;
public class Main extends People {
    public void method01() {
       People.Man man = new People().new Man();//其他类获取成员内部类的方式
    }
}

2.局部内部类

参考文档：https://www.cnblogs.com/SQP51312/p/6108848.html

定义在方法中的内部类。

1、局部内部类不能被public、private、static修饰；

2、在外部类中不能创建内部类的实例；

3、创建局部内部类的实例只能在包含他的方法中；

4、内部类访问包含他的方法中的变量必须有final修饰，版本升级就不需要了；

5、外部类不能访问局部内部类，只能在方法体中访问局部内部类，且访问必须在内部类定义之后。

假如现在有这样的一个需求：

要通过方法method()，获取某个类OBJ的重写后的对象。而这个需求只在这个地方（OBJ的某个方法）用。

可以用局部内部类来实现。

package java_basic.stuInnerClass;
import org.junit.Test;
//局部内部类
public class People01 {
    @Test
    public void method() {
        showMessage().getNumber();

    }
    private String name = "小明";
//该方法要求返回一个OBJ对象，业务需要该对象被重写。由于改重写对象只会在此处用，因此可以使用局部内部类。
//更加简便地是使用匿名内部类
    public  OBJ showMessage(){
         int num = 10;
         //
        class inner extends OBJ{
            //String name = "小军";//局部内部类的属性如果和外部类同名，则会隐藏外部属性。
            //static String abc="";//报错
            int score  = 100;
            public void getNumber(){
                String name = "小军1";//
                int mark = 23;
                //局部内部类可以直接访问外部类的属性，即便是private
                // 局部内部类的属性如果和外部类同名，则会隐藏外部属性。
                System.out.println(name);//小军1
                //解决办法
                System.out.println(People01.this.name);//小明
                System.out.println(num);//版本更新，访问已经可以不用final修饰的外部方法了。
                System.out.println(score);
                System.out.println(mark);

            }
        }
        return new inner();
    }
    public class OBJ{
        public void getNumber(){
            System.out.println("number is 20");
        }
    }
}

3.静态内部类

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

public class Test {
    public static void main(String[] args)  {
        Outter.Inner inner = new Outter.Inner();
    }
}
 
class Outter {
    public Outter() {
         
    }
     
    static class Inner {
        public Inner() {
             
        }
    }
}

4.匿名内部类

//匿名内部类的测试
public class People02 {
    @Test
    public void method() {
        subject.showMessage();//how are you.  //xxx
        animal.method();//method
        fruit.getNumber();//fruit geNumber
        fruit.toString();
    }


    //1.获取Subject类的匿名子类
    Subject subject = new Subject(){
        //里面的内容和子类集成一样的协防，可以重写父类方法，也可以不重写;
        @Override
        public void showMessage() {
            super.showMessage();
            method();
        }
        public void method(){//非重写方法外部无法访问，仅提供内部使用
            System.out.println("xxx");
        }
    };

    //2.获取接口的匿名实现
    Animal animal = new Animal() {
        @Override
        public void showMessage() {
            System.out.println("ShowMessae");
        }

        @Override
        public void method() {
            System.out.println("method");

        }

    };
    //3.当接口中只有一个方法时，可以通过lambda表达式简写
    //为了限制该接口只有一个自定义抽象方法，可以在该接口上加@FunctionalInterface
    //参考文档https://blog.csdn.net/qq_27610859/article/details/88861988
    Fruit fruit = () -> {
        System.out.println("fruit geNumber");
    };


}
//接口
interface Animal{
    void showMessage();//接口中的属性的默认是public static final 、方法是public abstract
    void method();
}

@FunctionalInterface
interface Fruit  {

    void getNumber();
    int hashCode();//Object 中的抽象方法可以再次出现 此处仅作为测试 并不知道其作用
    String toString();//Object 中的抽象方法可以再次出现 此处仅作为测试 并不知道其作用
    //String getName();//由于注解的缘故 在加一个自定义抽象方法，会报错。
}

//普通类
class Subject{
    public void showMessage(){
        System.out.println("how are you.");
    }
}

5,进一步有匿名内部类的知识（lambda缩写），结合函数是几口Function<T,R>的相关知识，

我们可以实现想js中那样的回调函数。

import java.util.function.Function;
public  class People03 {
    //回掉函数
    public static <T,R> void CallBack(Function<T,R> fnt,T t){
        fnt.apply(t);
    }
    @Test
    public void method() {
      //调用回掉函数
        People03.CallBack((Function<Integer, Object>) o ->(o*10),23);
    }
}

Function<T,R> 是有系统提供的，当然自己也可以编写，非常简单。只要注意里面有一个抽象方法apply().

People03.CallBack((Function<Integer, Object>) o ->(o*10),23); 调用时(Function<Integer, Object>) o ->(o*10)为产生一个Function<Integer, Object>对象，o ->(o*10)就是他的实现。o 是实现方法的传入形参。

回掉函数的实际调用在回调函数的的内部，即fnt.apply(t); t 为接收实参。

函数式接口的相关只是不了解的可以查一下。

参考文档：https://www.cnblogs.com/rever/p/9725173.html

这样做的好处：体味一下函数式编程以及实现，以及回调的一些思想。