Java 学习笔记

Posted 2022-03-10 Spring-_-Bear

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java 学习笔记相关的知识，希望对你有一定的参考价值。

一、内容介绍

内容介绍
学习前的话
就业方向
开发场景
应用领域
内容梳理

二、Java概述

程序举例
Java故事
Java特性
Sublime
Jdk介绍

JVM 是一个虚拟的计算机，具有指令集并使用不同存储区域。负责执行指令，管理数据、内存、寄存器，包含在 JDK 中
JDK = JRE + Java 开发工具（java、javac、javap、javadoc ······）
JRE = JVM + Java 核心类库

我的电脑
Jdk安装
环境变量配置
Win7安装Jdk
Mac安装Jdk
快速入门
运行机制
开发细节
学习方法
转义字符
易犯错误
注释介绍
多行注释
文档注释
代码规范
DOS原理
路径详解
DOS指令1
DOS指令2
DOS指令3
本章作业1
本章作业2
内容梳理

三、变量

变量原理
变量概念
变量入门
变量细节
加号使用
数据类型
整型使用

类型	字节数	范围
byte	1	-128 - 127
short	2	-32768 - 32767
int	4	-2³¹ - 2³¹-1
long	8	-2⁶³ - 2⁶³-1

整型细节
浮点数使用

类型	字节数	范围
float	4	-3.403E38 - 3.403E38
double	8	-1.798E308 - 1.798E308

浮点数组成：符号位 + 指数位 + 尾数位
Java 浮点类型默认为 double 类型，定义 float 类型时需要在末尾加上 F 或 f

浮点数细节1
浮点数细节2
Java文档
字符型使用

类型	字节数	范围
char	2	ISO 单一字符集

字符型细节
字符型本质
常用编码

类型	字符占用字节数	汉字占用字节数
ASCII	1
Unicode	2	2
UTF - 8	1	3
GBK	1	2

布尔类型

类型	字节数	范围
boolean	1	true or false

自动类型转换基础

char -> int -> long -> float -> double
byte -> short -> int -> long -> float -> double

自动类型转换基础细节1

(byte，short) 和 char 之间不会自动类型转换
byte、char、short 在进行运算时，当作 int 处理

自动类型转换基础细节2
强制类型转换基础
强制类型转换细节

char 类型可以保存 int 类型的常量值，但不能保存 int 型的变量值，需要强转

类型转换练习
String和基本类型转换
String转基本类型细节
本章作业1
本章作业2
本章小结

四、运算符

算术运算符介绍
算术运算符使用

int i = 1;
i = i++;
// output：1
System.out.println(i);

int i = 1;
i = ++i;
// output：2
System.out.println(i);

算术运算符练习1
算术运算符练习2
算术运算符练习3
算术运算符练习4
关系运算符介绍
关系运算符使用
逻辑运算符介绍
短路与逻辑与
短路或逻辑或
逻辑非逻辑异或
逻辑运算符练习
赋值运算符介绍
赋值运算符细节
三元运算符介绍

Object object = true ? new Integer(1) : new Double(2.0);
// 三元运算符需要看作一个整体，故输出 1.0；if - else 分支结构则输出 1
System.out.println(object);

三元运算符细节
三元运算符练习
运算符优先级

运算顺序	操作符
	. () ; ,
R -> L	++ – ~ !
L -> R	* / %
L -> R	+ -
L -> R	<< >> >>>
L -> R	< > <= >= instanceof
L -> R	== !=
L -> R	&
L -> R	^
L -> R	\|
L -> R	&&
L -> R	\|\|
L -> R	? :
R -> L	= *= /= %=
R -> L	+= -= <<= >>=
R -> L	>>>= &= ^= \|=

标识符规则
标识符练习
标识符规范
关键字保留字

strictfp：strict float point (精确浮点) - strictfp关键字可应用于类、接口、方法。使用 strictfp 关键字声明一个方法时，该方法中所有的 float 和 double 表达式都严格遵守 FP-strict 的限制，符合 IEEE-754 规范
volatile 是 jvm 提供的轻量级同步机制。作用是: 1. 保证可见性 2. 禁止指令重排 3. 不保证原子性

键盘输入
四种进制介绍
2进制转10进制
8进制转10进制
16进制转10进制
10进制转2进制
10进制转8进制
10进制转16进制
2进制转8进制
2进制转16进制
8进制转2进制
16进制转2进制
位运算思考题
原码、反码和补码
位运算详解1
位运算详解2

算术右移：>> ：低位丢弃，符号位不变，高位补符号位
算术左移：<< ：符号位不变，低位补0
无符号右移：>> ：低位丢弃，高位补 0

本章作业
内容梳理

五、程序控制结构

顺序控制
单分支使用
单分支流程图
双分支使用
双分支流程图
双分支练习题
多分支使用
多分支练习1
多分支练习2
嵌套分支
嵌套分支课后练习
switch基本语法
switch流程图
switch快速入门
switch细节

switch 的 case 后跟常量或常量表达式，switch 中的表达式只能是以下类型中的一种：byte、short、char、int、enum、String

switch课堂练习1
switch课堂练习2
switch和if选择
for基本语法
for执行流程
for细节
for编程思想1
for编程思想2
while基本语法
while执行流程
while课堂练习
do-while语法
do-while执行流程
do-while练习1
do-while练习2
多重循环执行流程
多重循环练习1
多重循环练习2
空心金字塔
break需求
break执行流程
break快速入门
break细节
break课堂练习1
break课堂练习2
continue执行流程
continue快速入门
continue细节
return使用说明
本章作业1
本章作业2
本章作业3
本章作业4
本章作业5
本章作业6
内容梳理
听懂和会做

六、数组、排序和查找

数组必要性
数组快速入门

数组是引用类型，创建数组时使用了 new 关键字

数组使用1
数组使用2
数组使用3

数组静态初始化

int[] array = 2,54,3,23;

数组注意事项

创建数组后，若没有赋值，则有默认值

int[] a = new int[3];
// output: [0, 0, 0]
System.out.println(Arrays.toString(a));

数组练习1
数组练习2
数组赋值机制1

基本数据类型赋值，赋值的是具体的数据
引用类型赋值，传递的是数组的地址

数组赋值机制2
数组拷贝
数组翻转1
数组翻转2
数组扩容1
数组扩容2
数组缩减
排序介绍

内部排序：将需要处理的所有数据都加载到内部存储器中进行排序（交换式排序法、选择式排序法和插入式排序法）
外部排序：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序（合并排序法和直接合并排序法）

冒泡排序思路
冒泡排序实现
查找
二维数组入门
二维数组内存布局
二维数组使用1
二维数组使用2

Java 中二维数组每行的元素个数可以不一致

int[][] array = new int[3][];
array[0] = new int[3];
array[1] = new int[2];
array[2] = new int[6];

二维数组使用3
二维数组练习1
杨辉三角
二维数组细节
二维数组练习2
本章作业1
本章作业2
本章作业3
本章作业4
本章作业5
内容梳理
专业和编程

七、面向对象编程(基础部分)

类与对象引出
类与对象概述
面向对象快速入门
对象内存布局
属性概念
属性注意细节
创建对象访问属性
对象分配机制
对象创建过程

栈：一般存放基本数据类型（局部变量）
堆：存放对象（数组）
方法区：常量池（字符串）、类加载信息

对象机制练习
方法快速入门1
方法快速入门2
方法调用机制
方法的妙用
方法的定义
方法的使用细节1
方法的使用细节2
方法的使用细节3
方法练习题1
方法传参机制1
方法传参机制2
方法传参机制3
克隆对象
递归解决什么问题
递归执行机制1
递归执行机制2
递归执行机制3
递归执行机制4
递归斐波那契
猴子吃桃
老鼠出迷宫1
老鼠出迷宫2
老鼠出迷宫3
老鼠出迷宫4
汉诺塔
八皇后
重载介绍
重载快速入门
重载使用细节

方法重载方法签名必须不同，返回值不是方法签名的一部分

重载课堂练习1
重载课堂练习2
重载课堂练习3
可变参数使用
可变参数细节

可变参数的实参可以是 0 个或是多个，其本质就是数组
形参列表中可以同时有普通形参和可变参数，但必须保证可变参数是形参列表的最后一个参数
一个方法的形参列表只能出现一个可变参数

可变参数练习
作用域基本使用

类的属性有默认值，局部变量没有默认值

作用域使用细节1
作用域使用细节2
构造器基本介绍
构造器快速入门
构造器使用细节1

构造器完成对象的初始化，并不是创建对象；调用构造器时堆中已经分配了对象的空间，构造器只是负责对对象进行初始化

构造器使用细节2
构造器课堂练习
对象创建流程详解

加载类信息，生成 .class 对象
在堆中为对象分配空间
完成对象的默认初始化
构造器完成对象的初始化

引出this
this入门

JVM 会给每个对象分配 this，代表当前对象；哪个对象调用，this 指向它

this本质
this小结
this使用细节

this 不能在类定义的外部使用，只能在类定义的方法中使用

this课堂练习
本章作业1
本章作业2
本章作业3
本章作业4
本章作业5
本章作业6
本章作业7
本章作业8
本章作业9
本章作业10
本章作业11
内容梳理

八、面向对象编程(中级部分)

IDEA介绍
IDEA下载安装
IDEA使用1
IDEA使用2
IDEA使用3
IDEA快捷键1

自动补全 alt + /
查看类结构：ctrl + H

IDEA快捷键2
IDEA快捷键3
IDEA模板
包基本介绍
包原理
包快速入门
包命名
常用的包
包的使用细节
访问修饰符规则

修饰符只能用来修饰类或类的成员

访问修饰符细节
封装介绍
封装步骤
封装快速入门
封装与构造器
封装课堂练习
为什么需要继承
继承原理图
继承快速入门
继承使用细节1

子类继承了父类所有的方法和属性，但父类的私有属性不能在子类中直接访问

继承使用细节2

当创建子类的对象时，无论使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类中使用 super 去显式调用父类的构造器完成父类的初始化工作，否则编译不会通过

继承使用细节3

super() 和 this() 都只能放在构造器的第一行，因此这两个方法不能同时存在一个构造器中

继承使用细节4

Object 类的所有方法

继承使用细节5
继承本质详解

继承课堂练习1
继承课堂练习2
继承课堂练习3
super基本语法

super 代表父类的引用，用于访问父类的属性、方法、构造器
使用 super 不能访问父类的 private 成员

super使用细节1
super使用细节2
super使用细节3

区别点	this	super
方法	访问本类属性，没有则依次查找父类	直接依次查找父类属性
属性	访问本类方法，没有则依次查找父类	直接依次查找父类方法
构造器	行首调用本类其它构造器	行首调用父类指定构造器
特殊	表示当前对象	表示子类中访问父类的对象

方法重写介绍
方法重写细节

子类重写父类的方法时，返回类型可以是父类返回类型的子类
子类不能缩小父类方法的访问权限

重写课堂练习1
重写课堂练习2
养宠物引出多态
方法的多态

重载与重写也体现了多态

对象的多态
多态快速入门
向上转型
向下转型
属性重写问题
多态课堂练习1
多态课堂练习2
动态绑定机制

当调用对象方法的时候，该方法会和该对象的内存地址 / 运行类型动态绑定
当调用对象属性时，不存在动态绑定，在哪儿声明在哪使用

多态数组1
多态数组2
多态参数
运算符

	作用
==	判断基本类型时判断值是否相等；判断引用类型时判断是否引用到同一个对象
equals()	只能判断引用类型是否引用到同一个对象，子类往往重写

查看Jdk源码
子类重写equals
equals课堂练习1
equals课堂练习2
equals课堂练习3
hashCode

   /**
    * Returns a hash code value for the object. This method is
    * supported for the benefit of hash tables such as those provided by
    * @link java.util.HashMap.
    * <p>
    * The general contract of @code hashCode is:
    * <ul>
    * <li>Whenever it is invoked on the same object more than once during
    *     an execution of a Java application, the @code hashCode method
    *     must consistently return the same integer, provided no information
    *     used in @code equals comparisons on the object is modified.
    *     This integer need not remain consistent from one execution of an
    *     application to another execution of the same application.
    * <li>If two objects are equal according to the @code equals(Object)
    *     method, then calling the @code hashCode method on each of
    *     the two objects must produce the same integer result.
    * <li>It is <em>not</em> required that if two objects are unequal
    *     according to the @link java.lang.Object#equals(java.lang.Object)
    *     method, then calling the @code hashCode method on each of the
    *     two objects must produce distinct integer results.  However, the
    *     programmer should be aware that producing distinct integer results
    *     for unequal objects may improve the performance of hash tables.
    * </ul>
    * <p>
    * As much as is reasonably practical, the hashCode method defined by
    * class @code Object does return distinct integers for distinct
    * objects. (This is typically implemented by converting the internal
    * address of the object into an integer, but this implementation
    * technique is not required by the
    * Java&trade; programming language.)
    *
    * @return  a hash code value for this object.
    * @see     java.lang.Object#equals(java.lang.Object)
    * @see     java.lang.System#identityHashCode
    */
   public native int hashCode();

toString

   /**
    * Returns a string representation of the object. In general, the
    * @code toString method returns a string that
    * "textually represents" this object. The result should
    * be a concise but informative representation that is easy for a
    * person to read.
    * It is recommended that all subclasses override this method.
    * <p>
    * The @code toString method for class @code Object
    * returns a string consisting of the name of the class of which the
    * object is an instance, the at-sign character `@code @', and
    * the unsigned hexadecimal representation of the hash code of the
    * object. In other words, this method returns a string equal to the
    * value of:
    * <blockquote>
    * <pre>
    * getClass().getName() + '@' + Integer.toHexString(hashCode())
    * </pre></blockquote>
    *
    * @return  a string representation of the object.
    */
   public String toString() 
       return getClass().getName() + "@" + Integer.toHexString(hashCode());

finalize

   /**
    * Called by the garbage collector on an object when garbage collection
    * determines that there are no more references to the object.
    * A subclass overrides the @code finalize method to dispose of
    * system resources or to perform other cleanup.
    * <p>
    * The general contract of @code finalize is that it is invoked
    * if and when the Java&trade; virtual
    * machine has determined that there is no longer any
    * means by which this object can be accessed by any thread that has
    * not yet died, except as a result of an action taken by the
    * finalization of some other object or class which is ready to be
    * finalized. The @code finalize method may take any action, including
    * making this object available again to other threads; the usual purpose
    * of @code finalize, however, is to perform cleanup actions before
    * the object is irrevocably discarded. For example, the finalize method
    * for an object that represents an input/output connection might perform
    * explicit I/O transactions to break the connection before the object is
    * permanently discarded.
    * <p>
    * The @code finalize method of class @code Object performs no
    * special action; it simply returns normally. Subclasses of
    * @code Object may override this definition.
    * <p>
    * The Java programming language does not guarantee which thread will
    * invoke the @code finalize method for any given object. It is
    * guaranteed, however, that the thread that invokes finalize will not
    * be holding any user-visible synchronization locks when finalize is
    * invoked. If an uncaught exception is thrown by the finalize method,
    * the exception is ignored and finalization of that object terminates.
    * <p>
    * After the @code finalize method has been invoked for an object, no
    * further action is taken until the Java virtual machine has again
    * determined that there is no longer any means by which this object can
    * be accessed by any thread that has not yet died, including possible
    * actions by other objects or classes which are ready to be finalized,
    * at which point the object may be discarded.
    * <p>
    * The @code finalize method is never invoked more than once by a Java
    * virtual machine for any given object.
    * <p>
    * Any exception thrown by the @code finalize method causes
    * the finalization of this object to be halted, but is otherwise
    * ignored.
    *
    * @throws Throwable the @code Exception raised by this method
    * @see java.lang.ref.WeakReference
    * @see java.lang.ref.PhantomReference
    * @jls 12.6 Finalization of Class Instances
    */
   protected void finalize() throws Throwable

断点调试介绍
断点调试案例1
断点调试案例2
断点调试案例3
断点调试案例4
断点调试案例5
断点调试案例6
零钱通介绍
零钱通菜单
零钱通明细
零钱通收益
零钱通消费
零钱通退出确认
零钱通金额校验
零钱通OPP版
本章作业1
本章作业2
本章作业3
本章作业4
本章作业5
本章作业6
本章作业7
本章作业8
本章作业9
本章作业10
本章作业11
本章作业12
本章作业13
本章作业14
本章作业15
本章作业16
本章作业17
内容梳理
不要让堕性毁了你

九、房屋出租系统

房屋出租需求
房屋出租设计
房屋出租工具类
房屋出租House类
房屋出租主菜单
房屋出租列表
房屋出租添加
房屋出租删除
房屋出租退出
房屋出租查找
房屋出租修改
第一阶段结束语

十、面向对象编程(高级部分)

类变量引出
类变量快速入门
类变量内存剖析

JDK 8 以前类变量放在方法区的静态域中，JDK 8 以后放在堆的对应类的 class 对象尾部

类变量定义访问

类变量也即静态变量

类变量使用细节
类方法快速入门

类方法也即静态方法

类方法最佳实践

当方法中不设计到与任何对象相关的成员时，则可以将方法设计为静态方法以提高运行效率

类方法注意事项

静态方法只能访问静态成员；非静态方法，可以访问静态和非静态成员

类成员课堂练习
main语法说明
main特别说明
main动态传值
代码块快速入门

代码块可以理解为只有方法体的方法，它没有方法名、返回值、参数，不能通过对象或类显式调用，只有在加载类或是创建对象时隐式调用
代码块的修饰符只能是 static，方法体中的语句可以是任何正确逻辑语句
类代码块的调用顺序优先于构造器

代码块使用细节1

类加载时机：创建该类的对象时；创建子类的对象时父类也会加载；使用类的静态成员时
如果只是调用类的静态成员，普通代码块并不会执行

代码块使用细节2

普通代码块可以看作是构造器的一种补充机制，所以在调用类的静态成员但没有创建类的对象时，构造器并未被调用，因而类的普通代码块不会被执行

代码块使用细节3

创建类的对象时，执行顺序

静态代码块与静态成员优先级一致，按定义先后顺序依次执行
普通代码块与普通成员优先级一致，按定义先后顺序依次执行
调用构造器

理解：构造器的开头隐含了 super() 和调用普通代码块

class Temp 
   public Temp() 
       super();

代码块使用细节4

代码执行顺序

父类的静态代码块和静态属性按定义顺序依次执行
子类的静态代码块和静态属性按定义顺序依次执行
父类的普通代码块与普通属性按定义顺序依次执行
父类的构造器
子类的普通代码块与普通属性按定义顺序依次执行
子类的构造器

静态代码块、静态方法只能调用静态成员；普通方法和普通代码块可以调用任何成员

代码块课堂练习
单例模式饿汉式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格以及解决问题的思考方式。设计模式好比经典的棋谱，不同的棋局采用不同的棋谱，免去再次思考和摸索的过程
类的单例设计模式：采取一定的方法在整个软件系统中，某个类有且仅有一个对象实例，并且该类只提供一个取得该对象的方法
单例模式的实现：构造器私有化；在类的内部创建对象；向外部提供一个静态的公共方法取得该对象

// 单例设计模式饿汉式
class GirlFriend 
   private GirlFriend() 
   
   private static final GirlFriend girlFriend = new GirlFriend();
   public static GirlFriend getGirlFriend() 
       return girlFriend;

单例模式懒汉式

// 单例设计模式懒汉式
class GirlFriend 
   private GirlFriend() 
   
   private static GirlFriend girlFriend;
   public static GirlFriend getGirlFriend() 
       if (girlFriend == null) 
           girlFriend = new GirlFriend();
       
       return girlFriend;

饿汉式与懒汉式的区别：创建时机不同 - 饿汉式在类加载是就创建了对象而懒汉式在使用到对象时才创建
饿汉式不存在线程安全问题，懒汉式存在线程安全问题
java.lang.Runtime 类就是经典的单例模式

public class Runtime 
   private static Runtime currentRuntime = new Runtime();

   /**
    * Returns the runtime object associated with the current Java application.
    * Most of the methods of class <code>Runtime</code> are instance
    * methods and must be invoked with respect to the current runtime object.
    *
    * @return  the <code>Runtime</code> object associated with the current
    *          Java application.
    */
   public static Runtime getRuntime() 
       return currentRuntime;
   

   /** Don't let anyone else instantiate this class */
   private Runtime()

final基本使用

final 的使用场景：不希望某个类被继承；不希望父类的方法被子类重写；不希望类的成员值被修改；不希望局部变量的值被修改

final使用细节1

final 修饰的属性必须初始化，此后不能更改，初始化可在三个地方进行：定义时初始化；构造器中初始化；代码块中初始化
如果 final 修饰的属性同时是 static 的，那么只能在两个地方初始化：定义时初始化；静态代码块中初始化
如果非 final 类中含有 final 修饰的方法，则该方法可以被继承不能被重写

final使用细节2

final 往往和 static 搭配使用，效率更高，因为底层编译器做了优化处理，不会导致类的加载

class GirlFriend 
   public static final int AGE = 2;
   // 当使用到 GirlFriend.AGE 时，此静态代码块不会执行即此类未加载
   static 
       System.out.println("I am your only girlfriend");

八大包装类都是 final 类型的

final课堂练习
抽象类引出

当父类的某些方法需要被声明，但又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类
有抽象方法的类一定是抽象类，抽象类不一定有抽象方法
抽象方法没有方法体即

抽象类细节1

abstract 只可以修饰类和方法

抽象类细节2

抽象类的本质也是类，可以有任何普通类有的属性
如果一个类继承自抽象类，则必须实现父类的所有抽象方法，除非它也是一个抽象类
抽象方法不能使用 private、final、static 来修饰，因为这些修饰符与重写相违背

抽象类课堂练习
抽象模板模式
接口快速入门
接口基本介绍

JDK 7 及之前的版本，所有的方法都没有方法体及抽象方法
JDK 8 及之后的版本，接口类中可以有静态方法、默认方法即接口中的方法可以有具体实现

interface Study
   default public void english() 
       System.out.println("Study english");
   
   public static void math() 
       System.out.println("Study math");

接口应用场景
接口使用细节1

抽象类实现接口可以不用实现方法；接口继承接口时可以不用实现方法

接口使用细节2

接口中的属性能且仅能是 public static final 修饰符

接口课堂练习
接口VS继承

继承的价值：解决代码的复用性与可维护性
接口的价值：设计规范方法，一定程度上实现代码解耦即接口规范性 + 多态

接口多态特性
接口多态传递
接口课堂练习
四种内部类

匿名内部类、局部内部类、成员内部类、静态内部类

局部内部类1

局部内部类定义在外部类的局部位置，比如方法或代码块中，并且有类名，有以下几个特点

可以直接访问外部类的所有成员，包含私有的
不可以添加访问修饰符，可以添加 final
局部内部类可以理解为方法的局部变量

class Outer 
   private String name = "Spring-_-Bear";
   public void m1() 
       class Inner 
           private void test() 
               // 直接调用外部类的私有成员
               System.out.println(name);
           
       
       // 调用局部内部类的方法
       new Inner().test();

局部内部类2

如果外部类和局部内部类的成员重名时，默认遵循就近原则。如果想访问外部类的成员，可以使用外部类名.this.成员的方式去访问

class Outer 
   private String name = "Spring-_-Bear";
   public void m1() 
       class Inner 
           private String name = "springbear";
           private void test() 
               // 调用局部内部类的成员
               System.out.println(name);
               // 调用外部类的成员
               System.out.println(Outer.this.name);
           
       
       // 调用局部内部类的方法
       new Inner().test();

匿名内部类本质

匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名，同时还是一个对象

/**
* 基于接口的匿名内部类
* 
* @author Spring-_-Bear
* @date 2021-12-12 08:50
*/
public class C02 
   public static void main(String[] args) 
       // 方式1
       I03 i03 = new I03() 
           @Override
           public void cry() 
               System.out.println("呜呜呜~~~");
           
       ;
       i03.cry();
       // 匿名内部类的类名：I03
       System.out.println(i03.getClass());
   
   
   // 方式2
   new I03() 
           @Override
           public void cry() 
               System.out.println("呜呜呜~~~");
           
   .cry();


interface I03
   void cry();

匿名内部类使用
匿名内部类细节

匿名内部类本身既是一个类的定义，同时它本身也是一个对象，因而从语法层面看，它既有类定义类的特征也有创建对象的特征
只能定义在方法或代码块中，匿名内部类的地位就好比一个没有名字的局部变量

匿名内部类实践

经典使用场景：将匿名内部类直接当作实参传递，简洁高效

成员内部类1

成员内部类可以理解为类的成员

成员
以上是关于Java 学习笔记的主要内容，如果未能解决你的问题，请参考以下文章

机器学习笔记3

Java小项目零钱通

建筑建模学习笔记2——3DMax房屋框架建模

DeepLearning深度学习课程笔记

吴恩达机器学习课程笔记：多元梯度下降法

java-零钱通（项目）