Java中的内部类

成员内部类

定义在一个类的内部。

1、内部类可以访问外部类所有的属性和方法，包括private成员。可以用private、protected、public修饰

@Data
@ToString
public class Outer {
    private double radius=0;
    private static String name="Circle";
    public Outer(double radius){
        this.radius=radius;
    }
    private void outerMethod(){
        System.out.println("outerMethod");
    }
    //内部类
     class Inner{
        public Inner(){

        }
        public void innerMethod(){
            System.out.println("innerMethod");
            //访问外部类的私有属性
            System.out.println("radius:"+radius);
            //访问外部类的静态属性
            System.out.println("name："+name);
            //访问外部类的私有方法
            outerMethod();
        }
    }
}

内部类的创建需要一个外部类对象，可以通过如下的方法创建

public class MainApp {
    public static void main(String[]args){
        Outer outer=new Outer(10);
        //创建成员内部类的方法
        Outer.Inner inner=outer.new Inner();
        inner.innerMethod();
    }
}

运行结果

innerMethod radius:10.0 name：Circle outerMethod

2、如果外部类访问内部类的属性和方法需要先创建一个内部类对象，然后通过这个内部类对象来访问。

public class Outer {
    private double radius=0;
    private static String name="Outer";
    private Inner inner;
    public Outer(double radius){
        this.radius=radius;
    }
    public void getInnerProperty(){
        System.out.println("getInnerProperty:"+getInnerInstance().innerName);
    }
    Inner getInnerInstance(){
        if (inner==null){
            return new Inner();
        }
        return inner;
    }
    //内部类
     class Inner{
        private String innerName="Inner";
        public Inner(){

        }
    }
}

public class MainApp {
    public static void main(String[]args){
        Outer outer=new Outer(10);
        //创建成员内部类的方法
        Outer.Inner inner=outer.new Inner();
        //外部类通过内部类实例访问内部类的属性
        outer.getInnerProperty();
    }
}

运行结果：

getInnerProperty:Inner

3、如果外部类和内部类有重名的属性和方法

当外部类和成员来拥有相同的属性和方法时，会发生隐藏现象，即默认情况下访问的时成员内部类的成员。

外部类和内部类拥有同名的属性："shape"和同名方法“hello”

public class Outer {
    private double radius=0;
    private String shape="Circle";
    public Outer(double radius){
        this.radius=radius;
    }

    private void hello(){
        System.out.println("Out say hello");
    }
    //内部类
     class Inner{
        private String shape="Rect";
        public Inner(){

        }
        private void hello(){
            System.out.println("Inner say hello");
        }
        public void visitTest(){
            hello();
            System.out.println("shape:"+shape);
        }
    }
}

public class MainApp {
    public static void main(String[]args){
        Outer outer=new Outer(10);
        //创建成员内部类的方法
        Outer.Inner inner=outer.new Inner();
        inner.visitTest();
    }
}

执行结果：

Inner say hello shape:Rect

如果要访问外部类同名的成员，要按照下面的方式访问

外部类.this.成员变量

外部类.this.成员方法

@Data
@ToString
public class Outer {
    private double radius=0;
    private String shape="Circle";
    public Outer(double radius){
        this.radius=radius;
    }
    private void hello(){
        System.out.println("Out say hello");
    }
    //内部类
     class Inner{
        private String shape="Rect";
        public Inner(){

        }
        private void hello(){
            System.out.println("Inner say hello");
        }
        public void visitTestV2(){
            Outer.this.hello();
            System.out.println("shape:"+Outer.this.getShape());
        }
    }
}

public class MainApp {
    public static void main(String[]args){
        Outer outer=new Outer(10);
        //创建成员内部类的方法
        Outer.Inner inner=outer.new Inner();
        inner.visitTestV2();
    }
}

执行结果：

Out say helloshape:Circle

局部内部类

局部内部类是定义在一个方法或者一个作用域内，它的访问权限仅在该方法内或作用域内。不可以用private、protected、public修饰。

package com.innerClass.part;

public class People {
    public People(){
    }
}

public class Man {
    public Man() {

    }

    public People getWoman() {
        class Women extends People {
            public int age = 10;
        }
        Women women=new Women();
        System.out.println("age:"+women.age);
        return new Women();
    }
}

public class MainApp {
    public static void main(String[]args){
        Man man=new Man();
        People people=man.getWoman();
    }
}

执行结果：

age:10

匿名内部类

• 匿名内部类是唯一没有构造器的类，因为没有构造器，大部分匿名内部类用于接口回调。

• 匿名内部类在编译的时候由系统自动起名为Outter$1.class。

• 一般来说，匿名内部类用于继承其他类或是实 现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。

  实现方法：

  方法一： 接口名 实例名 = new 接口名（）{ 实现接口中的所有抽象方法 }；（分号不能掉） 实例名.方法名（）； …

  方法二： new 接口名（）{ 实现接口中的所有抽象方法 }.方法名（）；（从后面开始直接调用方法）

    下面写一个例子：

package com.innerClass.anonymous;

import java.math.BigDecimal;

public interface Operation {
    BigDecimal compute(BigDecimal num1,BigDecimal num2);
}

public class InnerClass {
    /**
     * 加法
     * @param a
     * @param b
     * @return
     */
    public static BigDecimal add(BigDecimal a ,BigDecimal b){
        Operation operation=new Operation() {
            @Override
            public BigDecimal compute(BigDecimal num1, BigDecimal num2) {
                return num1.add(num2);
            }
        };
        BigDecimal sum=operation.compute(a,b);
        return sum;
    }

    /**
     * 减法
     * @param a
     * @param b
     * @return
     */
    public static BigDecimal substract(BigDecimal a,BigDecimal b){
        return new Operation(){
            @Override
            public BigDecimal compute(BigDecimal num1, BigDecimal num2) {
                return num1.subtract(num2);
            }
        }.compute(a,b);
    }
}

public class MainApp {
    public static void main(String [] args){
        BigDecimal a=BigDecimal.valueOf(100);
        BigDecimal b=BigDecimal.valueOf(50);
        System.out.println(InnerClass.add(a,b));
        System.out.println( InnerClass.substract(a,b));
    }
}

执行结果：

150
50

静态内部类

静态内部类也是定义在另一个类里面的类，只是在类前面加了一个static，并且它不能使用外部类的非static成员或者方法。

public class Outer {
    private String name="Outer";
    private static String shape="Circle";
    public Outer(){

    }
    static class Inner{//在此类中不能访问name
        public Inner(){
            System.out.println("shape:"+shape);
        }
    }
}

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

执行结果：

shape:Circle

至于这几种类型的应用场景后续再更新