private 为了保证数据的安全性

package review.InnerDemo;

class Computer{

private class Chip{

public void function(){

System.out.println(“芯片工作”);

}

}

public void show(){

Chip c = new Chip();

c.function();

}

}

public class demo3 {

public static void main(String[] args) {

Computer o = new Computer();

o.show();

//内部类加入了private权限修饰符之后，就不能被访问了

//Computer.Chip c = new Computer().new Chip();是错误的

}

}

芯片在电脑的里面，我们不希望芯片这个内部类被外界访问，所以用private修饰

这时我们只能在Computer类里面创建Chip类的对象，再由这个对象来调用成员变量或者成员方法。再像之前那样用外部类名.内部类名 对象名 = 外部类对象.内部类对象;的方法来创建内部类对象就不行了

那么有private修饰符，也有static修饰符

成员内部类加上一个static修饰符后变成静态内部类

格式为

class Outer{

static class Inner{

//静态内部类

}

}

static 为了让数据访问更方便

1. 被静态修饰的成员内部类只能访问外部类的静态成员

2. 静态内部类可以有静态成员，而非静态内部类则不能有静态成员（成员包括变量和方法）

3. 非静态的成员内部类，成员只能是非静态的。

4. 内部类被静态修饰后的方法有静态和非静态之分。他们的访问和不用静态是不一样的。

访问非静态方法：外部类名.内部类名 对象名 = new 外部类名.内部类名();

访问静态方法：上面创建的对象访问，或者外部类名.内部类名.方法名();

package review.InnerDemo;

class Computer1{

int num1 = 10;

static int num2 = 20;

public static class Chip1{

public static void show1(){ //内部类的静态方法

System.out.println(num2); //只能访问外部类的静态成员变量num2

System.out.println(“静态方法”);

}

public void show2(){ //内部类的非静态方法

System.out.println(“非静态方法”);

}

}

}

public class demo4 {

public static void main(String[] args) {

//访问非静态方法

Computer1.Chip1 c = new Computer1.Chip1();

c.show2();

System.out.println(“==========”);

//访问静态方法

c.show1();

System.out.println(“==========”);

//访问静态方法

Computer1.Chip1.show1();

}

}

结果为

局部内部类

1. 可以直接访问外部类的成员

2. 可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

局部内部类存在于方法中。

package review.InnerDemo;

class Outer3{

int num1 = 10;

public void show(){

int num2 = 20;

class Inner3{

int num3 = 30;

public void show2(){

System.out.println(num3);

System.out.println(num2);

System.out.println(num1);

}

}

//num2 = 40; 这里无法修改num2的值

//jdk1.8之后会自动在局部方法上的局部变量添加final

//System.out.println(num2);在这里打印的结果是num2 = 20

//创建内部类对象，通过对象调用成员变量

Inner3 i = new Inner3();

i.show2();

}

}

public class demo5 {

public static void main(String[] args) {

Outer3 o = new Outer3();

o.show();

}

}

结果为

局部内部类和成员内部类的区别

1. 局部内部类的作用范围在方法或者作用域之内

2. 局部内部类不能用public或private访问说明符进行声明

package review.InnerDemo;

class Outer3{

public void show(){

class Inner3{

public void show2(){

//这两种方式调用外部类的方法，结果是一样的

Outer3.this.test();

test();

}

}

Inner3 i = new Inner3();

i.show2();

}

public void test(){

System.out.println(“外部类方法”);

//要注意，不能在这里创建内部类的对象，超出局部内部类的作用范围

//Inner3 i = new Inner3();

}

}

public class demo5 {

public static void main(String[] args) {

Outer3 o = new Outer3();

o.show();

}

}

结果为

匿名内部类

就是内部类的简化写法。

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

格式：

new 抽象类名或者接口名() {

重写方法;

}

先来看看如果不适用匿名内部类，应该怎么写

public interface interDemo {

public abstract void show1();

public abstract void show2();

}

abstract class abstractDemo {

public abstract void test();

}

class Inter implements interDemo{

public void show1(){

System.out.println(“show1”);

}

public void show2(){

System.out.println(“show2”);

}

}

public class Ab extends abstractDemo{

public void test(){

System.out.println(“test”);

}

}

public class demo1 {

public void function(){

Inter i = new Inter();

i.show1();

i.show2();

Ab a = new Ab();

a.test();

}

public static void main(String[] args) {

demo1 d = new demo1();

d.function();

}

}

结果为

这样写无疑是比较麻烦的，现在再来看看，使用匿名内部类后怎么写

public interface interDemo {

public abstract void show1();

public abstract void show2();

}

abstract class abstractDemo {

public abstract void test();

}

package review.InnerDemo.anonymous;

public class demo1 {

public void function(){

interDemo i = new interDemo(){

public void show1(){

System.out.println(“show1”);

}

public void show2(){

System.out.println(“show2”);

}

};

i.show1();

i.show2();

abstractDemo a = new abstractDemo() {

@Override

public void test() {

System.out.println(“test”);

}

};

a.test();

}

public static void main(String[] args) {

demo1 d = new demo1();

d.function();

}

}

结果是

跟之前的结果一样，但代码简洁了许多

那么到具体的情景中，要怎么使用匿名内部类呢

首先定义一个接口，学生要学习，里面有两个抽象方法 读书read和背诵recite

public interface Study {

public abstract void read();

public abstract void recite();

}

package review.anonymous1;

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

我的面试宝典：一线互联网大厂Java核心面试题库

以下是我个人的一些做法，希望可以给各位提供一些帮助：

整理了很长一段时间，拿来复习面试刷题非常合适，其中包括了Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等，且还会持续的更新…可star一下！

283页的Java进阶核心pdf文档

Java部分：Java基础，集合，并发，多线程，JVM，设计模式

数据结构算法：Java算法，数据结构

开源框架部分：Spring，MyBatis，MVC，netty，tomcat

分布式部分：架构设计，Redis缓存，Zookeeper，kafka，RabbitMQ，负载均衡等

微服务部分：SpringBoot，SpringCloud，Dubbo，Docker

还有源码相关的阅读学习

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
，希望可以给各位提供一些帮助：**

整理了很长一段时间，拿来复习面试刷题非常合适，其中包括了Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等，且还会持续的更新…可star一下！

[外链图片转存中…(img-y1HszvJA-1713138250392)]

283页的Java进阶核心pdf文档

Java部分：Java基础，集合，并发，多线程，JVM，设计模式

数据结构算法：Java算法，数据结构

开源框架部分：Spring，MyBatis，MVC，netty，tomcat

分布式部分：架构设计，Redis缓存，Zookeeper，kafka，RabbitMQ，负载均衡等

微服务部分：SpringBoot，SpringCloud，Dubbo，Docker

[外链图片转存中…(img-j50kQVI3-1713138250393)]

还有源码相关的阅读学习

[外链图片转存中…(img-6241GAf8-1713138250393)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！