Object

虾仁不眨眼£

于 2024-09-12 08:52:55 发布

阅读量337

点赞数 3

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_68940487/article/details/142163206

版权

1.1 概述

定义在内部的类，就是内部类。可以定义在类的内部，也可以定义在方法的内部。
根据定义的位置不同，可以分为：
- 成员内部类：
  - 普通成员内部类
  - 私有成员内部类
  - 静态成员内部类
- 局部内部类
- 匿名内部类

1.2 普通成员内部类

定义在成员位置的类，就叫成员内部类

格式：

class 内部类类名{
    内部类成员;
}

示例：

public class Demo {
    class Animal {
        String name = "lisa";

        public void info() {
            System.out.println(name);
        }
    }
}

说明：

内部类可以直接访问外部类的所有成员，包括私有成员
外部类访问内部类的成员，必须先创建内部类的对象：
```
内部类名 内部类对象名 = new 内部类名();
```

示例：

public class Demo {
    class Animal {
        String name = "lisa";

        public void info() {
            System.out.println(name);
        }
    }

    public void method() {
        Animal animal = new Animal();
        System.out.println(animal.name);
        animal.info();
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        Animal animal = demo.new Animal();
        animal.info();
    }
}

1.3 私有成员内部类

普通成员内部类前加private关键字
说明：
- 在外部类以外，不能直接访问外部类中的私有成员内部类。
- 可以在外部类中，定义一个访问私有内部类的公有方法，让外界可以调用公有方法，间接的访问外部类中的私有成员内部类。
- 示例：

public class Demo {
    private class Animal {
        String name = "lisa";

        public void info() {
            System.out.println(name);
        }
    }

    public Animal getAnimalClass() {
        return new Animal();
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        Animal animalClass = demo.getAnimalClass();
        animalClass.info();
    }
}

1.4 静态成员内部类

普通成员内部类前加static关键字
说明：
- 成员内部类是外部类的静态成员，所以可以通过外部类名.内部类名的方式直接访问，而不需要创建外部类的对象。
- 静态内部类中的非静态成员，需要将所在的内部类对象创建出来之后，才能被调用。
- 一个类是否需要创建对象，不取决于该类本身是否是静态，而取决于要访问的成员是否是静态。
- 静态成员内部类的对象创建格式：

外部类名.内部类名 内部类对象名 = new 外部类名.内部类名();

示例：

public class Demo {
    static class Animal {
        String name = "lisa";
        static int age = 3;

        public void info() {
            System.out.println(name);
        }
    }

    public void method() {
        Animal animal = new Animal();
        System.out.println(animal.name);
        System.out.println(Animal.age);
    }

    public static void main(String[] args) {
        Demo.Animal animal = new Demo.Animal();
        System.out.println(animal.name);
        System.out.println(Demo.Animal.age);
    }
}

1.5 局部内部类

定义在方法中的内部类
说明：
- 问题：属于方法中的局部变量，外界都没有办法访问到。
- 解决：在方法内部定义调用方式
- 示例：
```
public class Demo {
    public void method() {
        class Animal {
            public void eat() {
                System.out.println("动物都可以吃东西");
            }
        }
        new Animal().eat();
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.method();
    }
}
```
  1.6 匿名内部类
- 没有名字的内部类
- 本质：重写
- 示例：
```
public class Demo {
    public void method() {
        System.out.println("最开始定义的方法的输出");
    }

    public static void main(String[] args) {
        new Demo() {
            @Override
            public void method() {
                System.out.println("内部类中重新定义了输出");
            }
        }.method();
    }
}
```
  2. 包
- 包：用于分类存放类文件(.class)的文件夹，在out/production目录下存放.class
- 作用：
  - 分类存放类文件，管理查找比较方便
  - 在不同的包中，可以起相同的类名（可类名以根据包名区分）
- 命名：域名倒着写：com.xxxx.www（全球唯一）
- 包的声明：使用package的关键字，声明当前的类是属于指定的包的。
- 效果：
  - 编译的这个类，就会进入到一个指定的文件夹中。
  - 当前的类，名称也发生了变化，类名变成了【包名 + 类名】
- 简化：
  
  每次使用其他包的类的时候，都需要写很长一串全类名，所以非常麻烦，需要简化. 使用import语句进行简化，在类的声明上，写一个import语句，将这个类的全类名导入进来，在该类中，就可以直接使用这个类的简写形式了。
  
  注意事项：
  - 即使在一个包中，有好多类都要使用，也不建议使用import *，使用import到类名。
  - 如果在一个文件中，需要使用两个包中的同名类，那么不建议用import语句导包，否则无法区分使用的是哪个包中的类。