Java_内部类

Posted pfzhang18

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java_内部类相关的知识,希望对你有一定的参考价值。

在Java中内部类主要分为四种:静态内部类、成员内部类、方法内部类、匿名内部类。

非静态内部类包括:成员内部类、方法内部类、匿名内部类。

1.成员内部类

成员内部类内部不允许存在任何static变量或方法,正如成员方法中不能有任何静态属性 (成员方法与对象相关、静态属性与类有关)。

class Outer 
    private String name = "test";
    public static int age = 20;
    public int num = 9;
    class Inner  
        // public static int num =10; // 在成员内部类不能存在静态属性
        public int num = 10;
        public void fun() 
            System.out.println(name); // 在成员内部类可以访问外部类的非静态属性
            System.out.println(age); // 以及静态属性
            System.out.println(num); // 10,有限访问内部属性
            System.out.println(this.num); // 10, 还是指内部类对象
            System.out.println(Outer.this.num); // 9,指的是外部类对象的属性
        
    

public class Test 
    public static void main(String [] args) 
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner(); // 成员内部类是依附外部类的,只有创建了外部类才能创建内部类。
        inner.fun();
    

2.静态内部类

使用static修饰的内部类我们称之为静态内部类。

静态内部类和非静态内部类之间存在一个最大的区别:非静态内部类在编译完成之后会隐含的保存着一个引用,该引用是指向创建它的外围类,但是静态类没有。

没有这个引用就意味着:

  1.静态内部类的创建不需要依赖外部类可以直接创建。

  2.静态内部类不可以使用任何外部类的非static类(包括属性和方法),但可以存在自己的成员变量。

class Outer 
    public String name = "test";
    private static int age =20;
    public void method() 
        System.out.println("Call Outer method");
    
    public static void method2() 
        System.out.println("Call Outer method2");
    
    static class Inner 
        private String name = "hello";
        public static int num = 10;
        public void fun() 
            System.out.println(name); // 可以访问外部的非静态属性
            // System.out.println(Outer.this.name); // 不能访问外部类的非静态属性
            System.out.println(age);  // 可以访问外部类的静态属性
            System.out.println(num);  // 可以在静态内部类中,定义静态属性
            // method(); // 不能访问非静态的方法
            method2(); // 可以访问外部类静态的方法
        
    


public class Test 
    public static void main(String [] args) 
        Outer.Inner in = new Outer.Inner(); // 不依赖外部类,可以直接创建内部类的实例
        in.fun();
    

3.方法内部类

定义在方法里的类被称为方法内部类。

1.方法内部类不允许使用访问权限修饰符(public、private、protected)。

2. 方法内部类对外部完全隐藏,除了创建这个类的方法可以访问它以外,其他地方均不能访问 (换句话说其他方法或者类都不知道有这个类的存在)。

3. 方法内部类如果想要使用方法形参,该形参必须使用final声明(JDK8形参变为隐式final声明)。

class Outer
    public int num = 5;
    public static int age = 10;
    public void dispaly(final int temp)  // JDK8形参变为隐式final声明

        class Inner  // 方法内部类即嵌套在方法里面, 不能使用修饰符public protected private
            // public static int age = 10; // 不能定义静态属性
            // public static void method2()  // 不能定义静态方法
            //     System.out.println(" ");
            // 
            public void method() 
                System.out.println(num); // 可以使用外部类的非静态属性 & 方法
                System.out.println(age); // 可以使用外部的静态属性 & 方法
                System.out.println("Call method");
                // temp++; // 不能改变final类型的值
                System.out.println(temp); // 但是可以调用
            
        

        // 方法内部类在方法里面创建
        new Inner().method();
    

public class Test 
    public static void main(String[] args) 
        Outer outer = new Outer();
        outer.dispaly(3);
    

4.匿名内部类

匿名内部类是一个没有名字的方法内部类,因此特点与方法内部类完全一致,除此之外,还有自己的特点:
1.匿名内部类必须继承一个抽象类或者实现一个接口。
2.匿名内部类没有类名,因此没有构造方法。

package Inner;

// 声明一个接口
interface MyInterface 
    void test();     // 接口中方法没有方法体
    default void test2()  // 可以有默认方法
        System.out.println("***hello***");
    


// 声明一个抽象类
abstract class Person 
    void play() 

    void play2() 
        System.out.println("***play****");
    


class Outer
    private int num = 5;
    private static int age = 10;
    public void dispaly(int temp) 
        // 匿名内部类,匿名的实现了 MyInterface 接口
        // 隐藏的class声明
        MyInterface myInterface = new MyInterface() 
            public void test() 
                System.out.println(num); // 可以访问外部类的非静态属性 & 方法
                System.out.println(age); // 可以访问外部类的静态属性 & 方法
                System.out.println("匿名实现MyInterface接口");
                // temp++; // 同方法内部类
                System.out.println(temp);
            
        ;
        myInterface.test();
        myInterface.test2();

        MyInterface myInterface2 = () ->   // 使用lambda表达式实现
            System.out.println("----------");
            System.out.println("匿名实现MyInterface接口");
        ;
        myInterface2.test();
        myInterface2.test2();
    

    public void display2(int temp) 
        Person person = new Person() 
            void play() 
                System.out.println("匿名实现抽象类Person");
            
        ;
        person.play();
        person.play2();
        // 抽象类不能使用lambda表达式方式实现
    


public class Test 
    public static void main(String[] args) 
        Outer out = new Outer();
        out.dispaly(3);
        out.display2(4);
    

静态内部类和非静态内部类的区别总结:

再看内部类的定义:

可以将一个类的定义放在另一个类的内部,这就叫内部类。 -java编程思想

嵌套类:

如果不需要内部类对象与其外部类对象之间存在联系,则可以将内部类声明为static。这通常称为嵌套类。

注意:普通的内部类对象隐式的保留着一个引用,指向创建它的外围对象。

内部类的作用:

1.内部类使得多重继承的解决方案更加完整。虽然接口解决可部分问题,但是内部类有效的实现了多重继承。

也就是说:内部类允许继承多个非接口类型(类或者抽象类)。 

2.每个内部类都能独立的继承自一个(接口的)实现,所以无论外围类是否已经继承了某个(接口)的实现,对应内部类都没有影响。

3.内部类可以有多个实例,每个实例有自己的状态信息,与外围类相互独立。

4.单个外围类中,可以让多个内部类以不同的方式实现统一接口,或者继承同一个类。

5.内部类没有令人迷惑的is-a的关系,是独立的实体。

 

以上是关于Java_内部类的主要内容,如果未能解决你的问题,请参考以下文章

Java_内部类

Java面向对象(17)_内部类

JAVA_内部类

JAVA_内部类

阶段1 语言基础+高级_1-3-Java语言高级_02-继承与多态_第7节 内部类_8_成员内部类的定义

Java_接口回调与匿名内部类