Java内部类

发布时间:2024年01月17日

?目录

一、内部类

1.1内部类定义

1.2内部类格式

1.3 内部类访问特点

1.4内部类分类?

?二、成员内部类

2.1成员内部类定义位置

2.2外界创建成员内部类格式 ?

?三、局部内部类

3.1局部内部类定义位置

3.2 局部内部类访问特点

四、匿名内部类?

4.1匿名内部类存在前提

?4.2匿名内部类的格式

?4.3匿名内部类的本质

4.4匿名内部类在开发中的使用(应用)

五、嵌套内部类(静态内部类)

六、内部类的好处


一、内部类

1.1内部类定义

在一个类中定义一个类。举例:在一个类A的内部定义一个类B,类B就被称为内部类

1.2内部类格式

/*
	格式:
    class 外部类名{
    	修饰符 class 内部类名{
    	
    	}
    }
*/

class Outer {
    public class Inner {
        
    }
}

1.3 内部类访问特点

  • 内部类可以直接访问外部类的成员,包括私有

  • 外部类要访问内部类的成员,必须创建对象

 */
public class Outer {
    private int num = 10;
    public class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    public void method() {
        Inner i = new Inner();   //外部类访问内部类,创建对象

        i.show();
    }
}

1.4内部类分类?

成员内部类、局部内部类、(特殊的局部内部类)匿名内部类、静态内部类?

?二、成员内部类

2.1成员内部类定义位置

在类中方法,跟成员变量是一个位置

2.2外界创建成员内部类格式 ?

  • 格式:外部类名.内部类名 对象名 = 外部类对象.内部类对象;

  • 举例:Outer.Inner oi = new Outer().new Inner();

注意: 当内部类不被public修饰被私有化private,这种格式就会失效,报错。我们最好的方法就是在外部类里面创建一个方法,并在方法中创建内部类对象,调用内部类的方法,然后在测试类里直接创建外部类对象并调用方法。(直接看代码!)

class Outer {
    private int num = 10;
    private class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    public void method() {
        Inner i = new Inner();
        i.show();
    }
}
public class InnerDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

?成员内部类的推荐使用方案:将一个类,设计为内部类的目的,大多数都是不想让外界去访问,所以内部类的定义应该私有化,私有化之后,再提供一个可以让外界调用的方法,方法内部创建内部类对象并调用。

?三、局部内部类

3.1局部内部类定义位置

在一个类的成员方法中。或者说,定义在一个成员方法的中的类就是局部内部类。

3.2 局部内部类访问特点

  • 局部内部类,外界是无法直接使用,需要在方法内部创建对象并使用

  • 该类可以直接访问外部类的成员,也可以访问方法内的局部变量

?代码展示:

class Outer {
    private int num = 10;
    public void method() {
        int num2 = 20;
        class Inner {
            public void show() {
                System.out.println(num);
                System.out.println(num2);
            }
        }
        Inner i = new Inner();
        i.show();
    }
}
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

注意:?局部内部类如果要去访问局部变量,那么局部变量必须声明为final类型

四、匿名内部类?

4.1匿名内部类存在前提

存在一个类或者接口,这里的类可以是具体类也可以是抽象类

?4.2匿名内部类的格式

格式:new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }

?4.3匿名内部类的本质

一个继承了该类或者实现了该接口的子类匿名对象

匿名内部类直接调用方法:

?代码展示:

nterface Inter{
    void method();
}

class Test{
    public static void main(String[] args){
        new Inter(){
            @Override
            public void method(){
                System.out.println("我是匿名内部类");
            }
        }.method();	// 直接调用方法
    }
}

?匿名内部类的细节:

如果想要多次调用内部类的方法可以直接复制粘贴

?但是如果次数过多,就不方便了!这边可以通过多态的形式来直接调用!

Inter i = new Inter(){
  @Override
    public void method(){
        
    }
}

4.4匿名内部类在开发中的使用(应用)

interface Jumpping {
    void jump();
}
class Cat implements Jumpping {
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}
class Dog implements Jumpping {
    @Override
    public void jump() {
        System.out.println("狗可以跳高了");
    }
}
class JumppingOperator {
    public void method(Jumpping j) { //new Cat();   new Dog();
        j.jump();
    }
}
class JumppingDemo {
    public static void main(String[] args) {
        //需求:创建接口操作类的对象,调用method方法
        JumppingOperator jo = new JumppingOperator();
        Jumpping j = new Cat();
        jo.method(j);

        Jumpping j2 = new Dog();
        jo.method(j2);
        System.out.println("--------");

        // 匿名内部类的简化
        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("猫可以跳高了");
            }
        });
		// 匿名内部类的简化
        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("狗可以跳高了");
            }
        });
    }
}

五、嵌套内部类(静态内部类)

静态内部类和成员内部类相比多了一个static修饰符。它与类的静态成员变量一般,是不依赖于外部类的。同时静态内部类也有它的特殊性。因为外部类加载时只会加载静态域,所以静态内部类不能使用外部类的非静态变量与方法。同时可以知道成员内部类里面是不能含静态属性或方法的。?

格式:?

class U {
    static class I {
        
    }
}

对象创建:静态内部类对象的创建一般是外部类.内部类 类名 = new 外部类.内部类();?

 生成静态内部类对象的方式为:
 OuterClass.InnerClass inner = new OuterClass.InnerClass();

class StaticInner {
    private static int a = 4;

    // 静态内部类
    public static class Inner {
        public void test() {
// 静态内部类可以访问外部类的静态成员
// 并且它只能访问静态的
            System.out.println(a);
        }
    }
}

public class StaticInnerClassTest {
    public static void main(String[] args) {
        StaticInner.Inner inner = new StaticInner.Inner();
        inner.test();
    }
}

注意:嵌套类和普通的内部类还有一个区别:普通内部类不能有?static?数据和?static?属性,也不能包含嵌套类,但嵌套类可以。而嵌套类不能声明为?private?,一般声明为?public,方便调用。?

由于学习原因静态内部类没有过多的介绍,感兴趣的朋友可以去学习一下,然后让我再去学习一哈!

六、内部类的好处

1. 内部类可以有多个实例,每个实例都有自己的状态信息,并且与其外围类对象那个的信息相互独立;
2. 在单个外围类中,可以让多个内部类以不同的方式实现同一个接口,或继承同一个类;
3. 方便将存在一定逻辑关系的类组织在一起,又可以对外界隐藏
4. 方便编写事件驱动程序;
5. 方便编写线程代码。?

文章来源:https://blog.csdn.net/qq_56751933/article/details/135642172
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。