【java基础】内部类、局部内部类、匿名内部类、静态内部类

ゞ浴缸里的玫瑰 2023-09-24 21:42 106阅读 0赞

# 内部类 #

内部类就是定义在另一个类中的类。我们使用内部类的原因主要有以下两点

*  内部类可以对同一个包中的其他类隐藏
 *  内部类方法可以访问定义这个类的作用域中的数据，包括原本私有的数据

public class A {
        
        
        class B {
        
        }
    }

我们使用内部类可以访问外部类的所有属性，语法就是 外部类.this.xx

public class A {
        
    
        private String name;
    
        public void show() {
        
        }
    
        public class B {
        
            public void test() {
        
                System.out.println(A.this.name);
                A.this.show();
            }
        }
    
    }

对于内部类里面的方法和属性可以和外部类重复，访问内部属性使用this，访问外部使用 outerClass.this。

public class A {
        
    
        private String name = "123";
    
        public class B {
        
            private String name = "456";
            public void t1() {
        
                System.out.println(A.this.name);
                System.out.println(this.name);
            }
        }
    }

如果内部类和外部类的变量和方法没有冲突，我们可以直接使用名称进行访问，编译器会先寻找内部类，然后寻找外部类

public class A {
        
    
        public void show() {
        
        }
        public class B {
        
            private String name = "456";
            public void t1() {
        
                show();
                System.out.println(name);
            }
        }
    }

关于内部类有一些注意事项如下  
**内部类中声明的所有静态字段都必须是final,并初始化为一个编译时常量。如果这个字段不是一个常量，就可能不唯一。**

**对于内部类，不能够有static方法。**

**对于内部类，我们可以设置为private，这样这个内部类就只有定义它的这个类可以使用了**

**内部类总是有一个隐式引用，指向创建它的外部对象。外围类的引用在构造器中设置，这是编译器自动帮我们完成的**

# 局部内部类 #

定义在方法中的就是一个局部内部类

public static void main(String[] args) {
        
            class Cat {
        
                public String name;
    
                public Cat(String name) {
        
                    this.name = name;
                }
            }
            Cat cat = new Cat("汤姆");
            System.out.println(cat.name);
        }

声明局部类时不能有访问说明符。局部类的作用域被限定在声明这个局部类的块中。

局部内部类不支持static修饰符

局部类有一个很大的优势，即对外部世界完全隐藏，只有在这个方法中才知道这个类的存在

**对于局部类，它也可以访问外部变量，规则和lambda是一样的，只能访问事实最终变量，也就是变量不能改变**

# 匿名内部类 #

匿名内部类就是没有名称的类，一般我们在只使用一次这个类时就可以用到匿名内部类

public static void main(String[] args) {
        
            Integer[] nums = {
        3, 2, 1, 4};
            Comparator<Integer> comparator = new Comparator<Integer>() {
        
                @Override
                public int compare(Integer o1, Integer o2) {
        
                    return o1 - o2;
                }
            };
            Arrays.sort(nums, comparator);
        }

在上面的代码中，Arrays.sort需要一个接口，我们就需要传入一个实现该接口的类。由于实现该接口的类我们只使用一次，于是就可将其定义为匿名内部类。

匿名内部类的语法如下

new SuperClass(construction parameter){
    	// 如果有抽象方法必须实现
    	// 其他操作
    }
    
    // 下面就是一个例子
    new Comparator<Integer>() {
    	@Override
    	public int compare(Integer o1, Integer o2) {
    		return o1 - o2;
    	}
    };

匿名内部类我们将其看作new关键字后面那个类型的子类就行了  
**需要注意的是匿名内部类不能有构造器，其他和局部内部类一样的**

# 静态内部类 #

有时候，使用内部类只是为了把一个类隐藏在另外一个类的内部，并不需要内部类有外围类对象的一个引用。为此，可以将内部类声明为static,这样就不会生成那个引用。

public class StaticClass {
        
    
        static class Dog{
        
            
        }
    }

一个静态内部类除了没有外部类的this之外，还可以有静态方法和字段，其他就和普通内部类一样了

public class StaticClass {
        
    
        static class Dog {
        
            static String name = "jack";
    
            public static void t1() {
        
            }
        }
    }

**有一点需要提醒，在接口中的声明的内部类自动是static和public**