48 ‘0’
65 ‘A’
97 ‘a’
注意事项
short/byte/char可以数学运算，例如”+”;运算时都会被提升为int类型，变量赋值时，如果右侧没有超过左侧范围，javac编译器将会自动补上(short)(byte)(char)，否则报错
boolean类型不能进行数据类型转换
&& || 具有短路效果：如果左边已经可以判断最终结果，那么右边的代码将不再执行，从而节省一定的性能
三元运算符：数据类型变量名 =条件判断？表达式A:表达式B，三元运算符的结果必须被使用

4.判断语句

注意事项：

switch后的小括号只能是：（基本数据类型）byte、short、int、char;（引用数据类型）String、enum

5.方法的重载（overload）

多个方法的名称相同（Java中严格区分大小写），但是参数列表不同

方法重载与下列因素相关：

参数个数不同
参数类型不同
参数的多类型顺序不同

方法重载与下列因素无关：

与参数的名称无关
与方法的返回值类型无关
和修饰词无关

6.数组

特点：

数组是一种引用数据类型
多个数据值的数据类型必须统一
数组的长度在程序运行期间不可改变

1. 动态初始化（直接指定数组的长度）

数据类型[] 数组名称 =new 数据类型[数组长度(int)];
也可以拆分为两个步骤
eg:

int[] array;
array=new int[10];

使用动态初始化数组时，会具有默认值
整型为0
浮点型为0.0
字符型为’\u0000’(\u代表unicode)
布尔型为false
引用类型为null

2.静态初始化（直接指定数组的内容）

标准格式：数据类型[] 数组名称 =new 数据类型[]{xx,xx,xx,xx…};
省略格式：数据类型[] 数据名称 ={xx,xx,xx,xx…};
静态初始化没有直接指定长度，但是仍然会自动推算出长度。
静态初始化标准格式可以拆分为两个步骤
eg:

int[] array;
array=new int[]{1,2,3};

静态初始化时也有默认值，但系统会自动替换为大括号中的具体值

注意事项：

只有带new的定义格式可以拆分为两个步骤
使用建议：不确定数组中具体内容是用动态初始化，已经确定内容的有静态初始化
直接打印数组名称，得到的是数组对应的，内存地址哈希值

- int[] array ={10,20,30};
System.out.println(array);
//[I@723279cf 得到数组对应的内存地址哈希值

3.数组常见问题

数组索引越界异常

int[] array ={1,2,3};
System.out.println(array[3]);
//Exception:ArrayIndexOutOfBoundsException

空指针异常

int[] array=null;
//所有引用类型变量，都可以赋值为一个null值，代表其中什么都没有
System.out.println(array[0]);
//Exception:NullPointerException

7.Java内存的划分

Java内存划分为5个部分
1.栈（Stack）：存放的都是方法中的局部变量，方法的运行一定要在栈当中运行。
局部变量：方法的参数，或者是方法内部{}的变量
作用域：一旦超出作用域，立刻从栈内存中消失。
2.堆（Heap）：凡是new出来的东西，都在堆当中。
堆内存里面的东西都有一个地址值：16进制
堆内存里的数据都有默认值，规则：

整型为0
浮点型为0.0
字符型为’\u0000’(\u代表unicode)
布尔型为false
引用类型为null

3.方法区（Method Area）：存储.class相关信息，包含方法的信息。
4.本地方法栈（Native Method Stack）：与操作系统相关。
5.寄存器（pc Register）：与CPU 相关。

8.类和对象

类：类是一组相关属性和行为的集合，可以看作是一类事物的模板，使用事务的属性特征和行为特征来描述该类事物。

属性：该事物的状态信息
行为：该事物能够做什么

对象：是一类事物的具体实现，对象是类的一个实例，必须具备该类事物的属性和行为

类是对一类事物的描述，是抽象的。对象是一类事物的实例，是具体的。类是对象的模板，对象是类的实体。

9.成员变量和局部变量的区别

定义位置不同： ⭐

局部变量在方法内部
成员变量在类中，方法外

作用范围不同: ⭐

局部变量作用于该方法
成员变量作用于整个类

默认值不同： ⭐

局部变量没有默认值，必须赋值使用
成员变量有默认值（规则同数组一样）

内存的位置不同

局部变量位于栈内存
成员变量位于堆内存

生命周期不同

局部变量随着方法进栈而诞生，随着方法出栈而消失
成员变量随着对象创建而诞生，随着对象被垃圾回收而消失

10.Java三大特性——封装

封装性在Java中的体现
方法就是一种封装
关键字private也是一种封装
封装就是将一些细节信息隐藏起来，对于外界不可看

private关键字的作用及使用
用private将需要保护的成员变量保护起来;private只能在本类之内随意访问，本类之外不可以直接访问。

this关键字的作用
当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量；如果需要访问本类当中的成员变量，需要使用格式：this.成员变量名。“通过谁调用的方法，谁就是this”。

构造方法
构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象的时候，其实就是在调用构造方法。

注意事项：

构造方法的名称必须和类名称完全一样
构造方法不需要返回值
如果没有编写任何构造方法，那么编译器会默认生成一个构造方法，没有参数、方法体什么事也不做
一旦编写的至少一个构造方法，那么编译器不会默认生成无参构造方法
构造方法可以重载

定义一个标准的类
一个标准的类，通常需要有以下四个组成部分——这样标准的类称作 Java Bean
所有的成员变量都要使用private关键字修饰
为每一个成员变量编写一对getter/setter方法
编写一个无参数的构造方法
编写一个全参数的构造方法

11.Sanner类

一个可以解析基本类型和字符串的简单文本扫描器。
引用类型的一般使用步骤：
1.导包
import 包路径.类名称；
使用java.lang包下的类不需要导包
2.创建
类名称对象名 = new 类名称（参数）；
3.使用
对象名.成员方法名（参数）

获取键盘上的一个int数字

int num = sc.nextInt();

获取键盘上输入发一个字符串

String str = sc.next();

匿名对象
只有右边的对象，没有左边的名字和赋值运算符：new 类名称();

匿名对象只能使用一次
如果确定一个对象只需要使用唯一一次，那么可以使用匿名对象
匿名对象作为方法的参数和返回值

12.Random类

Random r = new Random();
int num = r.nextInt();

Random r = new Random();
int num = r.nextInt(3);//左闭右开区间 [0, 3)

获取 [1, n] 的随机数

import java.util.Random;
import java.util.Scanner;

public class Demo03Random {
public static void main(String[] args) {
int num = new Scanner(System.in).nextInt();
for (int i = 0; i < 1000; i++) {
System.out.println(new Random().nextInt(num) + 1);
}
}
}

13.ArrayList类

数组长度不可以改变，但ArrayList集合的长度是可以随意变化的

ArrayList 代表泛型，表示装在集合中的元素的统一类型，泛型只能是引用类型，不能是基本类型
对于arraylist集合对象来说，直接打印得到的不是地址值，而是其中的内容。如果内容为空，得到的是空的中括号：[];
向集合中添加数据，需要使用add()方法

- ArrayList<String> list = new ArrayList<>();
list.add("hello");

ArrayList的常用方法

public boolean add(E e);向集合中添加元素，参数的类型和泛型一致
备注：对于ArrayList集合来说,add添加动作一定是成功的，所以返回值可用可不用，但对于其他集合来说，add添加动作不一定成功
public E get(int index);从集合中获取元素，参数是索引编号，返回值就是对应位置的元素
public E remove(int index);从集合中删除元素，参数是索引编号，返回值就是被删除的元素
public int size(); 获取集合的尺寸长度，返回值是集合中包含的元素个数

ArrayList存储基本数据类

如果希望向集合ArrayList中存储基本数据类型，必须使用基本类型对应的包装类

基本类型	包装类（引用类型，包装类都位于Java.lang包下）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

从JDK1.5+开始，支持自动装箱，自动拆箱
自动装箱：基本数据类型自动变成引用数据类型（包装类型）
自动拆箱：引用数据类型（包装类型）自动变成基本数据类型

14.String类

java.lang.String类代表字符串
Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现，程序中所有双引号字符串都是String类的对象（即使没有new）
字符串的特点：
1、字符串是常量；它们的值在创建之后不能更改。【重点】
2、正是因为字符串内容不可改变，所以字符串是可以共享使用的（节省内存）。
3、字符串效果上相当于char型字符数组，但底层原理是byte[]字节数组。
创建字符串的常见3+1种方式
三种构造方法
public String();创建一个空白字符串，不含有任何内容
public String(char[] array);根据字符数组的内容，来创建对应的字符串
public String(byte[] array);根据字节数组的内容，来创建对应的字符串
一种直接创建
String str =“Hello”;//右边直接双引号
注意：直接写上双引号，就是字符串对象。

字符串的常量池

字符串常量池：程序中双引号直接写上的字符串，就在池中；自己new出来的字符串不在池中。
池中保存字符串对象byte[]字节数组的地址
对于基本数据类型来说，==是进行数值的比较
对于引用数据类型来说，==是进行地址值的比较
从JDK1.7+开始，字符串常量池在堆内存中

字符串中的常用方法

1.字符串的内容比较

是对引用对象的地址值的比较，如果确实需要字符串的内容比较，可以使用两个办法:

public boolean equals(Object obj);参数可以是任何对象

注意事项：

任何对象都可以用Object接受：参数可以是任何对象，但只有参数是一个字符串并且内容相同才会返回true
equals具有对称性，a.equals(b)和b.equals(a)效果一样
如果比较两个一个常量一个变量，推荐把常量字符串写在前面，因为如果变量为空值在前面会出现空指针异常错误

public boolean equalsIgnoreCase(String str); 忽略大小写，进行内容比较

2.字符串的获取相关方法

public int length();获取字符串中含有的字符个数，拿到字符串长度
public String concat(String str);将当前字符串和参数字符串拼接返回新的字符串
public char charAt(int index); 获取指定索引位置的单个字符
public int indexOf(String str); 查找参数字符串在本字符串中首次出现的索引位置，如果没有返回-1

3.字符串的截取方法

public String substring (int index); 截取从参数位置一直到字符串末尾，返回新字符串
public String substring(int begin, int end);截取从begin开始到end结束中间的字符串，[begin,end)

4.字符串的转换相关方法

public char[] toCharArray();将当前字符串拆分成为字符数组作为返回值
public byte[] getBytes();获得当前字符串底层的字节数据
public String replace(CharSequence oldString ，CharSequence newString);将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串，CharSequence意思是可以接收字符串类型

5.字符串的分割方法

public String[] split(String regex);按照参数的规则，将字符串切割成为若干部分

String str1 ="aaa,bbb,ccc";
String[] strings = str1.split(",");
for (int i = 0; i < strings.length; i++) {
System.out.println(strings[i]);
}

注意事项：

split方法的参数其实是一个正则表达式
如果按照英文句点“.”进行切分，必须写“\\.”(两个反斜杠和英文句点)

eg：键盘输入一个字符串，并且统计各种字符出现的次数。种类有：大写字母、小写字母、数字、其他；

public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("Please input:");
String str=sc.next();
int Big=0;
int Small=0;
int num=0;
int oth=0;
char[] chars=str.toCharArray();
for (int i = 0; i < chars.length; i++) {
char c=chars[i];
if('A'<=c&&c<='Z'){
Big++;
}else if('a'<=c&&c<='z'){
Small++;
}else if('0'<=c&&c<='9'){
num++;
}else{
oth++;
}
}
System.out.println("大"+Big);
System.out.println("小"+Small);
System.out.println("数字"+num);
System.out.println("其他"+oth);
}

15.静态static关键字

static可以用来修饰成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。凡是本类的成员，都共享同一份。
一旦使用static修饰成员方法，那么这就成为了静态方法
静态方法不属于对象，而是属于类的
如果没有static关键字，必须先创建对象，然后通过对象才能使用它
对于静态方法来说，可以通过对象名进行调用，也可以通过类名称进行调用
无论是成员变量，还是成员方法，如果有了static，都推荐使用类名称进行调用
静态变量：类名称.静态变量
静态方法：类名称.静态方法（参数）

注意事项：

静态只能直接访问静态，静态不能直接访问非静态
原因：再内存中先有的静态内容，后有的非静态内容（“先人不知后人，而后人知先人已”）
2、静态方法中不能用this
原因：this表示当前对象的调用，static不需要创建对象

静态代码块

静态代码块的格式是：

public calss 类名称{
static{
//静态代码块的内容
}
}

特点：当第一次用到本类时，静态代码块执行唯一的一次。
静态内容总是优先于非静态
静态代码块比构造方法先执行
静态代码块的典型用途：
用来一次性地对静态变量进行赋值

16.数组工具类Arrays

java.util.Arrays是一个与数组相关的工具类，里面提供了大量的静态方法，用来实现数组常见的操作

public static String toString(数组);
将参数数组变成字符串(按照默认格式，[元素1,元素2,元素3…])
publci static void sort(数组);
按照默认升序对数组的元素进行升序排序

备注：

如果是数值，sort默认按照升序从小到大
如果是字符串，sort默认按照字母升序
如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持

17.数学工具类Math

java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作

public static double abs(double num); 获取绝对值，有多种重载
public static double ceil(double num);向上取整
public static double floor(double num);向下取整
public static long round(double num);四舍五入
Math.PI 近似圆周率（double）

18.Java三大特性——继承

继承是多态的前提，如果没有继承，就没有多态
继承主要解决的问题就是：共性抽取
父类（基类、超类）
子类（派生类）

继承关系中的特点：
子类可以“拥有”父类的“内容”
内存中：子类对象里面有一个完整的父类对象
子类还可以拥有自己的内容

继承的格式

在继承关系中，“子类就是一个父类”，就是说，子类可以当作父类看待，例如父类是员工，子类是讲师，那么“讲师就是一个员工”
定义父类的格式（一个普通的类定义）

public class 父类名称 {
//...
}

定义一个子类的格式

public class 子类名称 extends 父类名称{
//...
}

继承中成员变量的访问特点

在父子类的继承关系中，如果成员变量重名，则成员变量的访问有两种方式

直接通过子类对象访问成员变量：
优先用子类的，子类没有再找父类的
间接通过成员方法访问成员变量：
该成员方法属于谁，就优先用谁的成员变量，子类没有就向上找父类

子类方法中三种变量重名情况下的区分

局部变量：直接使用
本类的成员变量： this.变量名
父类的成员变量： super.变量名

在父子类继承关系中，创建子类对象，访问成员方法的规则：

创建的对象是谁，就先用谁，如果没有则向上找父类

继承中方法的覆盖重写（Override）

在继承关系中，方法的名称一样，参数列表也一样，此时就产生了方法的重写

特点：方法在覆写之后，子类对象调用该名称方法时会优先使用自己的该方法

重写（override）和重载（overload）

重写方法名称一样，参数列表一样
重载方法名称一样，参数列表不一样

注意事项：

必须保证父子类之间方法的名称相同，参数列表也相同。
@Override:写在重写方法前面，用来检测是不是有效的正确覆盖重写。（注解）
子类方法的返回值必须小于等于父类方法的返回值范围
java.lang.Object类是所有类的公共最高父类;java.lang.String就是Object的子类
子类方法的修饰符权限必须大于等于父类方法的修饰符权限
public>protected>(default)>private
(default)不是关键字default，而是留空，什么都不写
设计原则：对于已经投入使用的类，尽量不要进行修改。推荐定义一个新的类，来重复利用其中共性内容，并且添加改动新内容

继承关系中父子类构造方法的访问特点：

子类构造方法中，会有一个默认隐含的“super();”调用，所以一定是先调用的父类构造方法，后执行的子类构造方法
子类构造调可以通过super关键字来用父类重载构造
super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造
子类必须要调用父类的调用方法，不写则编译器默认调用super();

super关键字的三种用法：

在子类的成员方法中访问父类的成员变量
在子类的成员方法中访问父类的成员方法
在子类的构造方法中访问父类的构造方法

this关键字的三种用法：

在本类的成员方法中访问本类的成员变量
在本类的成员方法中访问本类的另一个成员方法
在本类的构造方法中访问本类的另一个构造方法
this(…)也必须是构造方法的第一个语句
B.super和this两种构造调用，不能同时使用

java继承的三个特点

Java语言是单继承的：一个类的直接父类只能有一个
Java语言可以多级继承：父类可以有父类；父类的父类也称为父类
java.lang.Object是所有类的父类
一个子类的直接父类是唯一的，但一个父类可以拥有很多个子类

抽象

抽象方法：就是加上abstract关键字，然后去掉大括号直接分号结束。
抽象类：抽象方法所在的类，必须是抽象类；抽象类定义也是加关键字abstract

public abstract class A {
public abstract void eat();
}

如何使用抽象类和抽象方法：

不能直接new抽象类对象
必须用一个子类来继承抽象父类
子类必须覆盖重写抽象类中所有的抽象方法。
覆盖重写（实现）：子类去掉抽象方法的abstract管关键字，然后补上方法体大括号
创建子类对象进行使用

注意事项：

抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的
子类的构造方法中，有默认的super();需要访问父类构造方法
抽象类中不一定包含抽象方法，但抽象方法所在的类一定是在抽象类中
这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊场景下有用途
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译器无法通过而报错，除非该子类也是抽象类

19.接口

接口就是多个类的公共规范
接口是一种引用数据类型，最重要的内容是其中的抽象方法
定义一个接口的格式：

public interface 接口名称{
//接口内容
}

换成了关键字interface之后，编译生成的字节码文件仍然是: .java–>.class
如果是java7,那么接口中可以包含的内容有：
1、常量
2、抽象方法
如果是java8，还可以额外包含有：
3、默认方法
4、静态方法
如果是java9,还可以额外包含有：
5、私有方法

接口定义抽象方法

格式：public abstract 返回值类型方法名称（参数列表）；
注意事项：
1、接口当中的抽象方法，修饰符必须是两个固定关键字：public abstract
2、这两个关键字修饰符可以省略
3、方法的三要素可随意定义

接口使用步骤：

1.接口不能直接使用，必须有一个实现类来实现该接口
格式：

public class 实现类名称 implements 接口名称{
//...
}

2.接口的实现类必须覆盖重写（实现）接口中的所有抽象方法
实现：去掉abstract关键字，加上方法体大括号
3.创建实现类的对象，进行使用

注意事项：
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类

默认方法

从java8开始，接口里允许定义默认方法
格式：

public default 返回值类型 方法名称（参数列表）{
方法体
}

备注:接口中的默认方法可以解决接口升级的问题
接口的默认方法可以通过实现类直接调用
接口的默认方法也可以被接口实现类进行覆盖重写

静态方法

从Java8开始，接口中允许定义静态方法
格式：

public static 返回值类型 方法名称（参数列表）{
//方法体
}

提示：就是将abstract或者default换成static即可，带上方法体。
注意：不能通过接口实现类的对象来调用接口中的静态方法
正确用法：通过接口名称直接调用其中的静态方法
格式：接口名称.静态方法名（参数）；

私有方法

问题描述：我们需要抽取出来一个公共方法，用来解决两个默认方法之间重复代码的问题
但是这个公共方法不应该让实现类使用，应该是私有化的

解决方案：
从java9开始，接口当中允许定义私有方法

普通私有方法，解决多个默认方法之间重复代码问题
格式:

private 返回值类型 方法名称（参数列表）{
方法体
}

静态私有方法，解决多个静态方法之间重复代码问题
格式：

private static 返回值类型 方法名称（参数列表）{
方法体
}

成员变量

接口中也可以定义“成员变量”，但是必须使用 public static final 三个关键字进行修饰

从效果上看，这其实就是接口的【常量】
格式:
public static final 数据类型常量名称=数据值；
备注：一旦使用final关键字进行修饰，这说明不可改变。
注意事项
1、接口中的常量，可以省略 public static final ,注意，不写也照样是这样
2、接口中的常量，必须进行赋值，不能不赋值
3、接口中常量的名称必须完全大写,多个单词加下划线

在Java 9+版本中，接口的内容可以有：
成员变量其实是常量，格式：
[public] [static] [final] 数据类型常量名称 = 数据值;
注意：
常量必须进行赋值，而且一旦赋值不能改变。
常量名称完全大写，用下划线进行分隔。

接口中最重要的就是抽象方法，格式：
[public] [abstract] 返回值类型方法名称(参数列表);
注意：实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。

从Java 8开始，接口里允许定义默认方法，格式：
[public] default 返回值类型方法名称(参数列表) { 方法体 }
注意：默认方法也可以被覆盖重写

从Java 8开始，接口里允许定义静态方法，格式：
[public] static 返回值类型方法名称(参数列表) { 方法体 }
注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法

从Java 9开始，接口里允许定义私有方法，格式：
普通私有方法：private 返回值类型方法名称(参数列表) { 方法体 }
静态私有方法：private static 返回值类型方法名称(参数列表) { 方法体 }
注意：private的方法只有接口自己才能调用，不能被实现类或别人使用。

使用接口的注意事项：

接口是没有静态代码块或者构造方法的
一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
格式：

public static MyInterfaceImpl implements MyInterfaceA ,MyInterfaceB(){
//覆盖重写所有抽象方法
}

如果实现类所实现的多个接口中存在重复的抽象方法，那么只需要覆盖重写一次即可
如果实现类没有覆盖重写所有接口中的所有抽象方法，那么实现类就必须是个抽象方法
如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法覆盖重写
一个类如果直接父类中的方法和接口中的默认方法产生了冲突，优先用父类中的方法

接口之间的多继承

类与类之间是单继承的
类与接口之间是多实现的
接口与接口之间是多继承的

注意事项：

多个父接口当中的抽象方法如果重复，没关系
多个父接口中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，【而且必须带着default关键字】

20.Java三大特性——多态

父类型引用指向子类型对象这种机制导致程序存在编译阶段绑定和运行阶段绑定两种不同的形态
extends继承和implements实现，是多态性的前提
实现同一接口的不同类型的对象，可被当作同一类型的对象对待
父类对象和从相同的父类派生出来的多个子类的对象，可被当作同一种类型对待
可向这些不同的类型对象发送同样的消息，由于多态性，这些不同类的对象响应同一消息时的行为可以有所差别
绑定：将一个方法调用表达式与方法体的代码结合起来
早绑定：“静态绑定”,在程序运行之前执行绑定
晚绑定：“动态绑定”或“运行期绑定”,是基于对象的类别，在程序运行时绑定；
对多态来说，编译时无法知道方法调用表达式所指向的实际对象类型，运行时才能确定，所以多态是动态绑定
对象的向上转型：父类名称对象名 =new 子类名称（）
含义：右侧创建一个子类对象，把它当作父类来看待使用
类似于：自动类型转换 double num =100;
注意事项：
向上转型一定是安全的，但转型之后无法调用子类特有的内容
对象的向下转型【还原】：子类名称对象名 =(子类名称)父类对象
含义：将父类对象，【还原】成为本来的子类对象
类似于：强制类型转换
int num =(int)10.0//可以
int num=(int)10.5//不可以，精度损失
如何知道一个父类引用的对象，本来是什么子类？
格式：对象 instanceof 类型
结果为一个Boolean值，判断前面的对象能不能当作后面类型的实例

21.final关键字

final代表最终、不可改变的
常见的四种用法：

可以用来修饰一个类
当前这个类不能有任何的子类
可以用来修饰一个方法
这个方法就是最终方法，不能覆盖重写

注意事项：对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

可以用来修饰一个局部变量
一旦使用final用来修饰局部变量，那么这个变量就不能进行更改，“一次赋值，终身不变”
对于基本类型来说，不可变说的是变量当中的数据不可变
对于引用类型来说，不可变说的是变量当中的地址不可变
可以用来修饰一个成员变量
由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认了
对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一
必须保证类中所有重载的构造方法，都最终会对final的成员变量进行赋值

22.权限修饰符

权限修饰符（从大到小）	public	protected	(default)	private
同一个类	YES	YES	YES	YES
同一个包(子类/非子类)	YES	YES	YES	NO
不同包子类	YES	YES	NO	NO
不同包非子类	YES	NO	NO	rNO

### 23.内部类分类： - 成员内部类 - 局部内部类（包含匿名内部类）

成员内部类

成员内部类定义格式：

修饰符 class 类名称{
修饰符 class 内部类名称{
//...
}
//...
}

访问特点

内部类可以直接访问外部类的成员，包括私有成员。
外部类要访问内部类的成员，必须要建立内部类的对象。

如何使用成员内部类：

间接方式：在外部类的方法中使用内部类；main只是调用外部类的方法
直接方式：外部类名称.内部类名称对象名 = new 外部类名称().new 内部类名称();

如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名

局部内部类

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类，只限当前方法使用

修饰符 class 外部类名称{
修饰符 返回值类型 外部类方法名称（）{
class 局部内部类{
/...
}
/...
}
}

定义一个类的时候，权限修饰符的规则：
外部类：public /(default)
成员内部类:public protected (default) private
局部内部类:什么都不能写

局部内部类如果想要访问所在方法的局部变量，那么这个局部变量必须是【有效final的】。从java8+开始，只要局部变量事实不变，那么final关键字可以省略

匿名内部类

如果接口的实现类（或父类的子类），只需要使用唯一的一次，那么这种情况下可以省略掉该类的定义，而改为使用匿名内部类

接口名称/父类名称 对象名 =new 接口名称（）{
//覆盖重写接口中所有抽象方法
};

对格式“new 接口名称（）{…};”进行解析： new代表创建对象的动作
接口名称就是匿名内部类需要实现的接口名称（要继承的父类）
{…}才是匿名内部类的内容

匿名内部类在【创建对象】的时候，只能使用唯一一次
如果希望多次创建对象，而且类的内容一样的话，就必须使用单独定义的类

匿名对象，在【调用方法】的时候，只能调用唯一一次
如果希望同一个对象调用多次方法，那么必须给对象起个名字

匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】

（匿名内部类和匿名对象不是一回事）

更多更完整的Java基础知识在这里👉Java学习笔记👈

点赞 1
收藏
分享
文章举报

yabayaoya 发布了7 篇原创文章 · 获赞 7 · 访问量 421 私信关注

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航

Java基础知识（一）（重载、数组 、Java内存的划分、类和对象、成员变量和局部变量的区别、封装、Sanner类、Random类、ArrayLis、String类、Math、接口、多态、权限修饰符）

文章目录

Java基础知识（一）

1.关于jre，jdk

2.基本数据类型

3.运算

4.判断语句

5.方法的重载（overload）

6.数组

1. 动态初始化（直接指定数组的长度）

2.静态初始化（直接指定数组的内容）

3.数组常见问题

7.Java内存的划分

8.类和对象

9.成员变量和局部变量的区别

10.Java三大特性——封装

11.Sanner类

12.Random类

13.ArrayList类

ArrayList的常用方法

ArrayList存储基本数据类

14.String类

字符串的常量池

字符串中的常用方法

1.字符串的内容比较

2.字符串的获取相关方法

3.字符串的截取方法

4.字符串的转换相关方法

5.字符串的分割方法

15.静态static关键字

静态代码块

16.数组工具类Arrays

17.数学工具类Math

18.Java三大特性——继承

继承的格式

继承中成员变量的访问特点

继承中方法的覆盖重写（Override）

java继承的三个特点

抽象

19.接口

接口定义抽象方法

接口使用步骤：

默认方法

静态方法

私有方法

成员变量

使用接口的注意事项：

接口之间的多继承

20.Java三大特性——多态

21.final关键字

22.权限修饰符

成员内部类

局部内部类

匿名内部类

Java基础知识（一）（重载、数组、Java内存的划分、类和对象、成员变量和局部变量的区别、封装、Sanner类、Random类、ArrayLis、String类、Math、接口、多态、权限修饰符）