Java基础部分学习笔记

写在前面：

1.这是我的java基础部分的学习笔记。
2.因为之前了解过java所以一般的我都是挑重要的的记下笔记 。
3.整个笔记流程不是非常明了，只用来记录自己学习过程。
4.如果笔记有幸被别人浏览到，有错误希望您及时提醒我，不要误导别人，谢谢。

java历史

1.1995 年 sun公司研发 1.0版本 1996年1.1版本是正式版
2.2004年5版本大更新
3.2009年Oracle收购sun 2007发布java7
4.14年 java8版本 大更新

存储

5.位：0或1
6.字节：8位是1字节 数据存储最小单位
7.1byte=8 bit
8.1KB=1024Byte 1MB=1024KB … 1ZB=1024EB

命令

9.MS-DOS
10.CMD（命令提示符）
切换盘d: e: …
cd 子目录 进入硬盘子目录（可以使用tab快速补全）
cd …返回上个目录 最多到硬盘目录
cd 子目录1\子目录2\子目录3 直接进入多级文件夹
cd \直接返回硬盘 (根目录）
dir 显示列表 DIR是文件夹
cls(clear screen) 清除屏幕
exit 退出

JAVA

11.运行虚拟环境-JVM（win lin mac）
12.JRE：java运行时环境 包含JVM和核心库
13.JDK:java开发工具包
14.JDK>JRE+开发工具>JVM+运行环境

开发步骤（简单）

15.编写源程序
16.编译
17.运行
18.javac 编译器
19.java 解释器
20 新建
21.javac.程序名.java -生成class文件
22.java.程序名 -输出结果

代码解释

23.第一行 public class 后面定义一个类的名称
24.第二行 固定写法public static void main 代表main方法 代表程序执行起点)
25.固定写法输出System.out.println

关键字

26.完全小写字母 有特殊颜色 public class等

标识符

27. 英文字母 0-9 ￥ _
    28.数字不能开头
    29.不能关键字
    30.规范 首字母大写（大驼峰） 变量 首字母小写后面首字母大写（小驼峰）

以上为简单的梳理，以下开始系统的整理

常量

31.整数
32.浮点数
33.字符常量 ‘A’‘a’有且仅有一个字母
34.布尔常量 true false
35.空常量 null 不能直接打印输出
36.字符串 内容可以为空

基本数据类型

37.整数型 byte short int long
38.浮点型 float double
39.字符型 char
40.布尔型 boolean

41.字符串是引用类型不是基本类型
42.浮点型是一个近似值
43.浮点数默认double 使用float 加后缀F
44.整数默认int long+后缀L

变量（variable）

注意：
45.名称不可重复
46.字母L F不要丢掉
47.byte short 不要超出范围
48.先赋值在使用
49.不能超过作用域范围（从定义变量开始到大括号结束）

数据类型转换

50.数据类型不一样会发生数据类型转换
51.自动类型转换（隐式） 自动完成 规则：数据范围从小到大 int–long
52.强制类型转换 （显式）不自动完成 格式：范围下的类型 范围小的变量=（范围小的类型） 原本范围大的数据 int num = (int)100L
53.注意事项
1.强制类型一般不推荐使用有可能精度损失 数据溢出
2.byte/short/char再进行运算的时候 会提升成int 在运算
3.boolean不能发生数据类型转换
54.ASCII码表
55.Unicode码表 万国码 从128开始包含更多字符
56.48-‘0’ 65-‘A’ 97-‘a’

运算符

57.算术运算符 + - * / %（取模） ++ - -
58.+有多种用法 加法 char类型 先提升成int在运算 字符串+表示拼接
59.自增运算符
混合使用时 ++num 立刻自加1 num++先使用num值在+1
–道理相同
常量不可++ –

流程控制语句

60.选择结构 if if…else if…else if… else
61.循环结构 for while do…while
62.break 打断循环
63.continue 跳过此次循环

IDEA

1. 项目结构  porject（项目）-module（模块）-package（包）

快捷键

方法

65.若干语句的集合

调用

66.单独调用 ：名称（参数）
打印调用 :system.out.println(方法名称（参数）;
赋值调用 :数据类型 变量=方法名称（参数）；

重载（overload）

67.名称相同 参数列表不同

数组

68.动态初始化
69.静态初始化

java内存

数组内存图

类与对象

71.面向过程
72.面向对象：偷懒 找一个JDK提供的类

73.类： 抽象的 类是对象的模板
74.对象：具体的 对象是类具体的实例

类的定义

75.定义方法不用static

对象创建

76.类名称 对象名 = new 类名称（）;

对象使用

77.对象名.成员变量 对象名.成员方法();

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

面向对象三大特征：封装，继承，多态

封装：将细节信息隐藏起来
78.方法就是封装
79.关键字private(siyouhua)也是封装

private

boolean getter用 is 不是get

this

81.this.成员变量名 重名情况下区分

构造方法

标准类Java Bean

API（应用程序编程接口）

82.API(Application Programming Interface)，应用程序编程接口。Java API是一本程序员的 字典 ，是JDK中提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查询API的方式，来学习Java提供的类，并得知如何使用它们。

Scanner类

83.一个可以解析基本类型和字符串的简单文本扫描器。 例如，以下代码使用户能够从 System.in 中读取一个数：
84.import 包名.类名; 数据类型 变量名 = new 数据类型(参数列表); 变量名.方法名();
85.Scanner sc = new Scanner(System.in); 表示从键盘录入的
86.获取输入的int数字 int num = sc.nextInt();
87.获取字符串 String Str = sc.next();

匿名对象
88.创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。虽然是创对象的简化写法，但是应用场景非常有限。
89.：一个匿名对象，只能使用一次。

Random类

90.此类的实例用于生成伪随机数。

ArrayList类

91.是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储的元素。 ArrayList 中可不断添加元素，其大小也自动增长。
92. ，表示一种指定的数据类型，叫做泛型。 E ，取自Element（元素）的首字母。在出现 E 的地方，我们使用一种引用数据类型将其替换即可，表示我们将存储哪种引用类型的元素。

93.常用方法
public boolean add(E e) ：将指定的元素添加到此集合的尾部。
public E remove(int index) ：移除此集合中指定位置上的元素。
public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
public int size() ：返回此集合中的元素数。遍历集合时，控制索引范围

如何存储基本数据类型

94.ArrayList对象不能存储基本类型，只能存储引用类型的数据。类似 不能写，但是存储基本数据类型对应的包装类型是可以的。所以，想要存储基本类型数据， <> 中的数据类型，必须转换后才能编写。

字符串

95.java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如 “abc” ）都可以被看作是实现此类的实例。
96.特点：
1.字符串不变：字符串的值在创建后不能被更改。
2.因为String对象是不可变的，所以它们可以被共享。
3.“abc” 等效于 char[] data={ 'a' , 'b' , 'c' } 。
97.创建字符串：

 // 无参构造
    String str = new String（）；
    // 通过字符数组构造
    char chars[] = {'a', 'b', 'c'};
    String str2 = new String(chars);
    // 通过字节数组构造
    byte bytes[] = { 97, 98, 99 };
    String str3 = new String(bytes);
     // 直接创建
        Stringstr = " ";

字符串常量池

98.程序当中写上双引号，就在字符串常量池中
99.

常用方法
100.public boolean equals (Object anObject) ：将此字符串与指定对象进行比较（任何对象都能用object接收）

101.public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小写。

102.public int length () ：返回此字符串的长度。
public String concat (String str) ：将指定的字符串连接到该字符串的末 尾。
public char charAt (int index) ：返回指定索引处的 char值。
public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。

public String substring (int beginIndex) ：返回一个子字符串，从beginIndex 开始截取字符串到字符串结尾。
public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含 endIndex。

103.public char[] toCharArray () ：将此字符串转换为新的字符数组。
public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使用replacement字符串替换。

104.public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。

static

修饰变量
105.当 static 修饰成员方法时，该方法称为类方法 。静态方法在声明中有 static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。
106.类方法：使用 static关键字修饰的成员方法，习惯称为静态方法。
修饰方法
106.静态方法可以直接访问类变量和静态方法。
静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
静态方法中，不能使用this关键字。

静态代码块

107.定义在成员位置，使用static修饰的代码块{ }。
位置：类中方法外。
执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。
格式：

public class ClassName{
static {
// 执行语句
}
}

108.静态代码块笔构造方法先执行，静态代码块只执行唯一一次 用来一次性对静态成员变量进行赋值

Arrays类（包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。）

109.public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。
110.public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。

Math类（类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，）

public static double abs(double a) ：//返回 double 值的绝对值。
public static double ceil(double a) ：//向上取整
public static double floor(double a) ：//向下取整
public static double round(double a) ：//四舍五入

    MATH.PI  圆周率

继承（就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。）

112.多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。
113.多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类。
114.好处：
1. 提高代码的复用性。
2. 类与类之间产生了关系，是多态的前提。
115.格式：通过 extends 关键字，可以声明一个子类继承另外一个父类

class 父类 {
...
}
class 子类 extends 父类 {
...
}

继承后的特点——成员变量
116.如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。
117.如果子类父类中出现重名的成员变量，这时的访问是有影响的。
118.子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰父类成员变量，类似于之前学过的 this 。

class Fu {
// Fu中的成员变量。
int num = 5;
}
class Zi extends Fu {
// Zi中的成员变量
int num = 6;
public void show() {
//访问父类中的num
System.out.println("Fu num=" + super.num);
//访问子类中的num
System.out.println("Zi num=" + this.num);
}
}

演示结果：
Fu num = 5
Zi num = 6
119.Fu 类中的成员变量是非私有的，子类中可以直接访问。若Fu 类中的成员变量私有了，子类是不能直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员变量呢？对！可以在父类中提供公共的getXxx方法和setXxx方法。

继承后的特点——成员方法
120.如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。

class Fu{
public void show(){
System.out.println("Fu类中的show方法执行");
}
}
class Zi extends Fu{
public void show2(){
System.out.println("Zi类中的show2方法执行");
}
}
public class ExtendsDemo04{
public static void main(String[] args) {
Zi z = new Zi();

//子类中没有show方法，但是可以找到父类方法去执行

成员方法重名——重写(Override)
121.如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (Override)。
122.子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。
123.子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强。比如新的手机增加来电显示头像的功能，代码如下：

class Phone {
public void sendMessage(){
System.out.println("发短信");
}
public void call(){
System.out.println("打电话");
}
public void showNum(){
System.out.println("来电显示号码");
}
}

//智能手机类

class NewPhone extends Phone {
//重写父类的来电显示号码功能，并增加自己的显示姓名和图片功能
public void showNum(){
//调用父类已经存在的功能使用super
super.showNum();
//增加自己特有显示姓名和图片功能
System.out.println("显示来电姓名");
System.out.println("显示头像");
}
}
public class ExtendsDemo06 {
public static void main(String[] args) {
// 创建子类对象
NewPhone np = new NewPhone()；
// 调用父类继承而来的方法
np.call();
// 调用子类重写的方法
np.showNum();
}
}

1. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
2. 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。

继承后的特点——构造方法
125.注意：

1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
2. 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。代码如下：

class Fu {
private int n;
Fu(){
System.out.println("Fu()");
}
}
class Zi extends Fu {
Zi(){
// super（），调用父类构造方法
super();
System.out.println("Zi（）");
}
}
public class ExtendsDemo07{
public static void main (String args[]){
Zi zi = new Zi();
}
}

输出结果：
Fu（）
Zi（）

super和this

126.super ：代表父类的存储空间标识(可以理解为父亲的引用)。
127.this ：代表当前对象的引用(谁调用就代表谁)。
128.子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

继承的特点

129. Java只支持单继承，不支持多继承
     //一个类只能有一个父类，不可以有多个父类。

class C extends A{} //ok
class C extends A，B... //error

130.Java支持多层继承(继承体系)。

class A{}
class B extends A{}
class C extends B{}

131.顶层父类是Object类。所有的类默认继承Object，作为父类。子类和父类是一种相对的概念。

## 抽象类

132.父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。
133.抽象方法 ： 没有方法体的方法。
134.抽象类：包含抽象方法的类。

抽象方法
135.使用 abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。
修饰符 abstract 返回值类型 方法名 (参数列表)；

public abstract void run()；

抽象类

```java
abstract class 类名字 {
}

public abstract class Animal {
public abstract void run()；
}

注意

1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
   理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
   理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
   理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象
   类。
   理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

接口

136.接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）。
137.定义：接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。
138.引用数据类型：数组，类，接口。
139.接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。
140.格式：

public interface 接口名称 {
// 抽象方法
// 默认方法
// 静态方法
// 私有方法
}

141.方法
1.抽象方法：使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。

public interface InterFaceName {
public abstract void method();
}

2.默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。
静态方法：使用 static 修饰，供接口直接调用。

public interface InterFaceName {
public default void method() {
// 执行语句
}
public static void method2() {
// 执行语句
}
}

3.私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。

public interface InterFaceName {
private void method() {
// 执行语句
}
}

实现
142.类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements 关键字。
143.非抽象子类实现接口：

1. 必须重写接口中所有抽象方法。
2. 继承了接口的默认方法，即可以直接调用，也可以重写。

class 类名 implements 接口名 {
// 重写接口中抽象方法【必须】
// 重写接口中默认方法【可选】
}

144.方法使用
1.抽象方法的使用 抽象必须全部实现。
2.默认方法的使用，可以继承，可以重写，二选一，但是只能通过实现类的对象来调用。
3.静态方法的使用，静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用
4.私有方法的使用，私有方法：只有默认方法可以调用，私有静态方法：默认方法和静态方法可以调用
145.如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法去调用。从设计的角度讲，私有的方法是对默认方法和静态方法的辅助。同学们在已学技术的基础上，可以自行测试。

接口的多实现

146.之前学过，在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
// 重写接口中抽象方法【必须】
// 重写接口中默认方法【不重名时可选】
}

147.多实现方法
1.抽象方法，接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。
2.默认方法，接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。
3.静态方法，接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

优先级
148.当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。

接口多继承
149.一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用 extends 关键字，子接口继承父接口的方法。如果父接口中的默认方法有重名的，那么子接口需要重写一次。
150.子接口重写默认方法时，default关键字可以保留。
子类重写默认方法时，default关键字不可以保留。
其他成员特点
1.接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static fifinal修饰。
2.接口中，没有构造方法，不能创建对象。
3.接口中，没有静态代码块。

多态（是指同一行为，具有多个不同表现形式。）

151.多态是继封装、继承之后，面向对象的第三大特性。
152.多态体现的格式：
父类类型 变量名 = new 子类对象；
变量名.方法名() 父类类型：指子类对象继承的父类类型，或者实现的父接口类型。
153.当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。
定义父类：

public abstract class Animal {
public abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
}

定义子类：

class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
}

定义测试类

public class Test {
public static void main(String[] args) {
// 多态形式，创建对象
Animal a1 = new Cat();
// 调用的是 Cat 的 eat
a1.eat();
// 多态形式，创建对象
Animal a2 = new Dog();
// 调用的是 Dog 的 eat
a2.eat();
}
}

多态的好处
154.实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。

引用类型转换
155.向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。当父类引用指向一个子类对象时，便是向上转型。
父类类型 变量名 = new 子类类型();
如：Animal a = new Cat();
156.向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。
子类类型 变量名 = (子类类型) 父类变量名;
如:Cat c =(Cat) a;

转型的异常
157.为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，
变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。

if (a instanceof Cat){
Cat c = (Cat)a;
c.catchMouse(); // 调用的是 Cat 的 catchMouse
} else if (a instanceof Dog){
Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse

fifinal

158.不可改变。可以用于修饰类、方法和变量。
159.类：被修饰的类，不能被继承。
方法：被修饰的方法，不能被重写。
变量：被修饰的变量，不能被重新赋值。
160.修饰类

final class 类名 {
}
修饰方法
修饰符 final 返回值类型 方法名(参数列表){
//方法体
}

修饰变量
1. 局部变量——基本类型
基本类型的局部变量，被fifinal修饰后，只能赋值一次，不能再更改。

public class FinalDemo1 {
public static void main(String[] args) {
// 声明变量，使用final修饰
final int a;
// 第一次赋值
a = 10;
// 第二次赋值
a = 20; // 报错,不可重新赋值
// 声明变量，直接赋值，使用final修饰
final int b = 10;
// 第二次赋值
b = 20; // 报错,不可重新赋值
}
}

2. 局部变量——引用类型
引用类型的局部变量，被fifinal修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改

public class FinalDemo2 {
public static void main(String[] args) {
// 创建 User 对象
final User u = new User();
// 创建 另一个 User对象
u = new User(); // 报错，指向了新的对象，地址值改变。
// 调用setName方法
u.setName("张三"); // 可以修改
}
}

3. 成员变量
成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：
显示初始化；

public class User {
final String USERNAME = "张三";
private int age;
}

构造方法初始化。

public class User {
final String USERNAME ;
private int age;
public User(String username, int age) {
this.USERNAME = username;
this.age = age;
}
}

161.被fifinal修饰的常量名称，一般都有书写规范，所有字母都大写。

权限修饰符

162.在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，
public：公共的。
protected：受保护的
default：默认的
private：私有的
163.不同权限的访问能力

164.public具有最大权限。private则是最小权限，编写代码时，如果没有特殊的考虑，建议这样使用权限：
成员变量使用 private ，隐藏细节。
构造方法使用 public ，方便创建对象。
成员方法使用 public ，方便调用方法。
165.不加权限修饰符，其访问能力与default修饰符相同

内部类
166.将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。
167.成员内部类 ：定义在类中方法外的类。

class 外部类 {
class 内部类{
}
}

访问特点
168.内部类可以直接访问外部类的成员，包括私有成员。外部类要访问内部类的成员，必须要建立内部类的对象。
创建内部类对象格式：外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；

// 创建外部类对象
Person p = new Person();
// 创建内部类对象
Heart heart = p.new Heart();

169.内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号 。比如Person$Heart.class

匿名内部类【重点】

170.是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，有以下步骤：

1. 定义子类
2. 重写接口中的方法
3. 创建子类对象
4. 调用重写后的方法
   171.前提：匿名内部类必须继承一个父类或者实现一个父接口。
   172.格式：

new 父类名或者接口名(){
// 方法重写
@Override
public void method() {
// 执行语句
}
};

173.使用方式：
定义接口：

public abstract class FlyAble{
public abstract void fly();
}

创建匿名内部类，并调用

public class InnerDemo {
public static void main(String[] args) {
/*
1.等号右边:是匿名内部类，定义并创建该接口的子类对象
2.等号左边:是多态赋值,接口类型引用指向子类对象
*/
FlyAble f = new FlyAble(){
public void fly() {
System.out.println("我飞了~~~");
}
};
//调用 fly方法,执行重写后的方法
f.fly();
}
}

引用类型用法总结

174.class作为成员变量：
类作为成员变量时，对它进行赋值的操作，实际上，是赋给它该类的一个对象。
175.interface作为成员变量：
接口作为成员变量时，对它进行赋值的操作，实际上，是赋给它该接口的一个子类对象。
176.interface作为方法参数和返回值类型
接口作为参数时，传递它的子类对象。
接口作为返回值类型时，返回它的子类对象。

**

完

本文地址：https://blog.csdn.net/Ulrica_Amaris/article/details/107684539