JAVASE阶段一_模块2

模块二
任务一
摘要：1.面向对象的概念
2.类和对象
3.引用的定义
4.栈区

1.什么是面向对象：通俗的说就是你要造车，那你是一步一步的生产零件，进行组装，哪里少什么在管哪里。还是将汽车拆分为多个模块，搞定每个模块，根据模块来分类的进行组合。第一种可以理解为面向过程，第二种就是面向对象，将事务进行拆分。

下面是有关的定义：
• 万物皆对象。
• 面向对象指以属性和行为的观点去分析现实生活中的事物。
• 面向对象编程指先以面向对象的思想进行分析，然后使用面向对象的编程语言
进行表达的过程。
• 面向对象编程是软件产业化发展的需求。
• 理解面向对象的思想精髓(封装、继承、多态)，至少掌握一种编程语言。

2.类和对象的引用（重中之重）
• 对象主要指现实生活中客观存在的实体，在Java语言中对象体现为内存空
间中的一块存储区域。
• 类简单来就是“分类”
，是对具有相同特征和行为的多个对象共性的抽象描
述，在Java语言中体现为一种引用数据类型，里面包含了描述特征/属性
的成员变量以及描述行为的成员方法。
• 类是用于构建对象的模板，对象的数据结构由定义它的类来决定。
总结下来就是：类是把事务进行抽象出来，就好像把人抽取成为人类，对象就是类创造的具体事务。

3.类的定义格式
class 类名 {
类体;
}
注意：
通常情况下，当类名由多个单词组成时，要求每个单词首字母都要大写。
class Person {
}

成员变量的定义
• class 类名 {
数据类型 成员变量名 = 初始值;
}

• 注意：
当成员变量由多个单词组成时，通常要求从第二个单词起每个单词的首
字母大写 。

class Person {
String name;
}

对象的创建
• new 类名();
• 注意：
a.当一个类定义完毕后，可以使用new关键字来创建该类的对象，这个
过程叫做类的实例化。
b.创建对象的本质就是在内存空间的堆区申请一块存储区域， 用于存放
该对象独有特征信息。

new Person(); 引用的定义
• 基本概念
a.使用引用数据类型定义的变量叫做引用型变量，简称为"引用"
。
b.引用变量主要用于记录对象在堆区中的内存地址信息，便于下次访问。
• 语法格式
类名 引用变量名;
引用变量名.成员变量名;

Person p = new Person();
p.name = “张飞”;
System.out.println(p.name);

案例题目
• 编程实现Person类的定义和使用。

成员变量的初始值(如果没有赋值）

案例题目
• 编程实现Point类的定义，特征有：横纵坐标(整数)，要求在main方法中
声明Point类型的引用指向Point对象并打印特征，然后将横纵坐标修改为
3和5后再次打印。

4.成员方法（重中之重）成员方法的定义
• class 类名 {
返回值类型 成员方法名(形参列表) {
成员方法体;
}
}
• 当成员方法名由多个单词组成时，要求从第二个单词起每个单词的首字母大写。
class Person {
void show() {
System.out.println(“没事秀一下！”);
}
}

返回值类型的详解
• 返回值主要指从方法体内返回到方法体外的数据内容。
• 返回值类型主要指返回值的数据类型，可以是基本数据类型，也可以是
引用数据类型。
• 当返回的数据内容是66时，则返回值类型写 int 即可
• 在方法体中使用return关键字可以返回具体的数据内容并结束当前方法。

• 当返回的数据内容是66时，则方法体中写 return 66; 即可
• 当该方法不需要返回任何数据内容时，则返回值类型写void即可。形参列表的详解

• 形式参数主要用于将方法体外的数据内容带入到方法体内部。

• 形式参数列表主要指多个形式参数组成的列表，语法格式如下：
数据类型 形参变量名1, 数据类型 形参变量名2, …
• 当带入的数据内容是"hello"时，则形参列表写 String s 即可
• 当带入的数据内容是66和"hello"时，则形参列表写 int i, String s 即可
• 若该方法不需要带入任何数据内容时，则形参列表位置啥也不写即可。

方法体的详解：

• 成员方法体主要用于编写描述该方法功能的语句块。
• 成员方法可以实现代码的重用，简化代码。方法的调用
• 引用变量名.成员方法名(实参列表);
• 实际参数列表主要用于对形式参数列表进行初始化操作，因此参数的个
数、类型以及顺序都要完全一致。
• 实际参数可以传递直接量、变量、表达式、方法的调用等。
p.show();可变长参数
• 返回值类型 方法名(参数的类型… 参数名)
• 方法参数部分指定类型的参数个数是可以改变的，也就是0~n个 。
• 一个方法的形参列表中最多只能声明一个可变长形参，并且需要放到参
数列表的末尾。

方法的传参过程
• int max(int ia, int ib) { … … … } int a = 5; int b=6; int res = m.max(a,b);

1. 为main方法中的变量a、b、res分配空间并初始化。
2. 调用max方法，为max方法的形参变量ia、ib分配空间。
3. 将实参变量的数值赋值到形参变量的内存空间中。
4. max方法运行完毕后返回，形参变量空间释放。
5. main方法中的res变量得到max方法的返回值。
6. main方法结束后释放相关变量的内存空间。

参数传递的注意事项
• 基本数据类型的变量作为方法的参数传递时，形参变量数值的改变通常
不会影响到实参变量的数值，因为两个变量有各自独立的内存空间；
• 引用数据类型的变量作为方法的参数传递时，形参变量指向内容的改变
会影响到实参变量指向内容的数值，因为两个变量指向同一块内存空间
• 当引用数据类型的变量作为方法的参数传递时，若形参变量改变指向后
再改变指定的内容，则通常不会影响到实参变量指向内容的改变，因为
两个变量指向不同的内存空间。

内存结构之栈区（重点）
• 栈用于存放程序运行过程当中所有的局部变量。一个运行的Java程序从开
始到结束会有多次方法的调用。

• JVM会为每一个方法的调用在栈中分配一个对应的空间，这个空间称为该
方法的栈帧。一个栈帧对应一个正在调用中的方法，栈帧中存储了该方
法的参数、局部变量等数据。
• 当某一个方法调用完成后，其对应的栈帧将被清除。

传参的相关概念
• 参数分为形参和实参，定义方法时的参数叫形参，调用方法时传递的参
数叫实参。
• 调用方法时采用值传递把实参传递给形参，方法内部其实是在使用形参。
• 所谓值传递就是当参数是基本类型时，传递参数的值，比如传递i=10，
真实传参时，把10赋值给了形参。当参数是对象时，传递的是对象的值，
也就是把对象的地址赋值给形参。

任务1的总结：1.说了面向对象的概念（了解即可）
2.类的定义：成员变量和成员方法。
3.引用：将类进行实例化，在堆中开辟空间存储对象
4.成员方法：类的行为的描述。

任务2
1.构造方法
构造方法也是一个方法，不过它是用来创建和初始化对象的方法，格式为：
• class 类名 {
类名(形参列表) {
构造方法体;
}

}
• 构造方法名与类名完全相同并且没有返回值类型，连void都不许有。
class Person {
Person() { - Person类中的构造方法
}
}

同时，如果你没有写构造方法，那么编译器会自动加一个空参构造方法，它什么也不做，就是为了实现创建对象的功能：默认构造方法
• 当一个类中没有定义任何构造方法时，编译器会自动添加一个无参空构
造构造方法，叫做默认/缺省构造方法，如：Person(){}
• 若类中出现了构造方法，则编译器不再提供任何形式的构造方法。

2.方法重载
方法重载的概念
• 若方法名称相同，参数列表不同，这样的方法之间构成重载关系。

重载的体现形式：
• 方法重载的主要形式体现在：参数的个数不同、参数的类型不同、参数
的顺序不同，与返回值类型和形参变量名无关，但建议返回值类型最好
相同。
• 判断方法能否构成重载的核心：调用方法时能否加以区分。

重载的实际意义
• 方法重载的实际意义在于调用者只需要记住一个方法名就可以调用各种
不同的版本，来实现各种不同的功能。
• 如：java.io.PrintStream类中的println方法。

3.this关键字
this的基本概念
• 若在构造方法中出现了this关键字，则代表当前正在构造的对象。
• 若在成员方法中出现了this关键字，则代表当前正在调用的对象。
• this关键字本质上就是当前类类型的引用变量。工作原理
• 在构造方法中和成员方法中访问成员变量时，编译器会加上this.的前缀，
而this.相当于汉语中"我的"，当不同的对象调用同一个方法时，由于调用
方法的对象不同导致this关键字不同，从而this.方式访问的结果也就随之
不同。

使用方式
• 当局部变量名与成员变量名相同时，在方法体中会优先使用局部变量(就
近原则)，若希望使用成员变量，则需要在成员变量的前面加上this.的前
缀，明确要求该变量是成员变量（重中之重）。
• this关键字除了可以通过this.的方式调用成员变量和成员方法外，还可以
作为方法的返回值（重点）。
• 在构造方法的第一行可以使用this()的方式来调用本类中的其它构造方法
（了解）。

注意要点：
注意事项
• 引用类型变量用于存放对象的地址，可以给引用类型赋值为null，表示不
指向任何对象。
• 当某个引用类型变量为null时无法对对象实施访问（因为它没有指向任何
对象）。此时，如果通过引用访问成员变量或调用方法，会产生
NullPointerException 异常。

4.方法递归调用
递归通俗来说就是自己调用自己，将问题逐步缩小，在逐步返回。
比如求5的阶层：你可以先叫别人把4！结果给你，然后你再5*4！，别人可以让其他人求3！，以此类推，直到1！是1，在逐步返回得到5！的结果。

注意事项
• 使用递归必须有递归的规律以及退出条件。
• 使用递归必须使得问题简单化而不是复杂化。
• 若递归影响到程序的执行性能，则使用递推取代之。

案例题目
• 编程实现费式数列中第n项的数值并返回。
• 费式数列： 1 1 2 3 5 8 13 21 ……
案例题目
• 编程实现参数n的阶乘并返回，所谓阶乘就是从1累乘到n的结果。

5.封装（重中之重）
封装的概念 • 通常情况下可以在测试类给成员变量赋值一些合法但不合理的数值，无 论是编译阶段还是运行阶段都不会报错或者给出提示，此时与现实生活 不符。 • 为了避免上述错误的发生，就需要对成员变量进行密封包装处理，来隐 藏成员变量的细节以及保证成员变量数值的合理性，该机制就叫做封装。
封装的实现流程
• 私有化成员变量，使用private关键字修饰。
• 提供公有的get和set方法，并在方法体中进行合理值的判断。
• 在构造方法中调用set方法进行合理值的判断。

案例题目
• 提示用户输入班级的学生人数以及每个学生的信息，学生的信息有：学
号、姓名，最后分别打印出来。
• 提示：Student[] arr = new Student[num];

JavaBean的概念（了解• JavaBean是一种Java语言写成的可重用组件，其它Java 类可以通过反射机制发现和操作这些JavaBean 的属性。
• JavaBean本质上就是符合以下标准的Java类：
• 类是公共 有一个无参的公共的构造器
• 有属性，且有对应的get、set方法

6.总结和答疑
任务二讲了构造方法的知识点，还有封装的概念和递归，this关键字和方法的重载。

任务三要点：

1. static关键字
2. 继承
3. 访问控制
4. final关键
   5.总结和答疑

案例题目
• 编程实现People类的封装，特征有：姓名、年龄、国籍，要求提供打印
所有特征的方法。
• 编程实现PeopleTest类，main方法中使用有参方式构造两个对象并打印。

基本概念
• 使用static关键字修饰成员变量表示静态的含义，此时成员变量由对象层级提升为类层级，也就是整个类只有一份并被所有对象共享，该成员变量随着类的加载准备就绪，与是否创建对象无关。

• static关键字修饰的成员可以使用引用.的方式访问，但推荐类名.的方式。

使用方式
• 在非静态成员方法中既能访问非静态的成员又能访问静态的成员。
(成员：成员变量 + 成员方法， 静态成员被所有对象共享)

• 在静态成员方法中只能访问静态成员不能访问非静态成员。
(成员：成员变量 + 成员方法， 因为此时可能还没有创建对象，如果调用了别的非静态变量或者非静态的方法，无对象就是没有这些东西。)

• 在以后的开发中只有隶属于类层级并被所有对象共享的内容才可以使用
static关键字修饰。(不能滥用static关键字)

构造块和静态代码块（熟悉）
• 构造块：在类体中直接使用{}括起来的代码块。
• 每创建一个对象都会执行一次构造块。
使用构造块可以在对象创建时做一些初始化工作，因为构造方法可以有多个，所以使用构造块好一些。可以保证所有的对象创建之前都可以实现构造块的功能。
代码：

package package01;

public class BlockTest {
//当需要在执行构造方法之前做一些准备工作的时候，则将准备工作相关的代码写在构造块中即可，比如：对于成员变量进行的统一的初始化操作
{
System.out.println(“构造块！”);
}
//自定义构造方法
public BlockTest() {
System.out.println("=构造方法体=");
}

public static void main(String[] args) {
    BlockTest bt = new BlockTest();
    BlockTest bt2 = new BlockTest();
}

}
运行结果：

• 静态代码块：使用static关键字修饰的构造块。
• 静态代码块随着类加载时执行一次。

代码：
package package01;

public class BlockTest {
//当需要在执行构造方法之前做一些准备工作的时候，则将准备工作相关的代码写在构造块中即可，比如：对于成员变量进行的统一的初始化操作
{
System.out.println(“构造块！”);
}

//静态代码块，随着类的加载而执行，和对象是否创建无关，静态代码块只执行一次，先于构造块执行。
static{
    System.out.println("我是静态代码块");
}
//自定义构造方法
public BlockTest() {
    System.out.println("=====构造方法体=====");
}

public static void main(String[] args) {
    BlockTest bt = new BlockTest();
    BlockTest bt2 = new BlockTest();
}

}
运行截图：

使用静态代码块的原因：为类的加载做一些准备工作：比如数据库的加载驱动包等等。

扩展：
1.普通代码块：
类中方法的方法体
2.构造代码块：
构造块会在创建对象时被调用，每次创建时都会被调用，优先于类构造函数执行。
3.静态代码块：
用static{}包裹起来的代码片段，只会执行一次。静态代码块优先于构造块执行。
4.同步代码块：
使用synchronized（）{}包裹起来的代码块，在多线程环境下，对共享数据的读写操作是需要互斥进行的，否则会导致数据的不一致性。同步代码块需要写在方法中。

Main方法的参数传入，jvm调用main方法，所以javac 类名.java生成字节码文件以后，在java 类名 参数。代码如下：
package package01;

public class MainTest {
public static void main(String[] args) {
System.out.println(“主方法之中参数的个数：” + args.length);
System.out.print(“主方法之中参数的值：” );
for(String str : args) {
System.out.println(str);
}
}
}

设计模式之单例设计模式：
单例设计模式的概念
• 在某些特殊场合中，一个类对外提供且只提供一个对象时，这样的类叫
做单例类，而设计单例的流程和思想叫做单例设计模式。

单例设计模式的实现流程
• 私有化构造方法，使用private关键字修饰。
• 声明本类类型的引用指向本类类型的对象，并使用private static关键字共
同修饰。
• 提供公有的get方法负责将对象返回出去，并使用public static关键字共同
修饰。

单例设计模式的实现方式
• 单例设计模式的实现方式有两种：饿汉式 和 懒汉式，在以后的开发中推
荐饿汉式。（因为多线程的资源共享的原因，所以推荐饿汉式）
下面是参考代码：

package package01;

public class Singleton {
private Singleton() {

}
//private static Singleton singleton = new Singleton();   //饿汉式,推荐
private static Singleton singleton = null;   //懒汉式

public static Singleton getSingleton() {
    if(singleton == null) {
        singleton = new Singleton();
    }
    return  singleton;
}

}

package package01;

public class SingletonTest {
public static void main(String[] args) {
Singleton s1 = Singleton.getSingleton();
Singleton s2 = Singleton.getSingleton();
System.out.println(s1 == s2);
}
}

2.继承
生活里面继承这个词语大家并不陌生，是从长辈手中获得某些东西。Java里面也有这个现象。是为了避免重复的代码，比如People这个类有name和age属性，但是Work这个类也有name和age属性，所以Work可以继承People，一出来节省代码，避免代码重复。继承的关键字是extends.

注意要点：
• 子类不能继承父类的构造方法和私有方法，但私有成员变量可以被继承
只是不能直接访问。(解释：构造方法和类名相同，所以继承下来也没有用，私有方法作用域在本类里面，继承了也没有办法使用，所以不用继承了）
• 无论使用何种方式构造子类的对象时都会自动调用父类的无参构造方法，
来初始化从父类中继承的成员变量，相当于在构造方法的第一行增加代
码super()的效果。

继承的特点
• 使用继承必须满足逻辑关系：子类 is a 父类，也就是不能滥用继承。
• Java语言中只支持单继承不支持多继承，也就是说一个子类只能有一个父
类，但一个父类可以有多个子类。

直接继承的类称为直接子类，间接继承的称为间接继承。

方法重写的概念
• 从父类中继承下来的方法不满足子类的需求时，就需要在子类中重新写
一个和父类一样的方法来覆盖从父类中继承下来的版本，该方式就叫做
方法的重写（Override）。

方法重写的原则
• 要求方法名相同、参数列表相同以及返回值类型相同，从Java5开始允许
返回子类类型。
• 要求方法的访问权限不能变小，可以相同或者变大。
• 要求方法不能抛出更大的异常(异常机制)。（异常后面会讲）

Java开发的常用工具
• 文本编辑器（TE，Text Editor）
• 记事本、Notepad++、Edit Plus、UltraEdit、…
• 集成开发环境（IDE，Integrated Development Environment ）
• Jbuilder、NetBeans、Eclipse、MyEclipse、IDEA、

大家可以去下载Eclipse和IDEA官网上面。

下载和安装方式（IDEA的下载地址）
• 下载地址：https://www.jetbrains.com/
• 安装方式：一路点击下一步默认安装即可

又见构造块与静态代码块（笔试）
• 先执行父类的静态代码块，再执行子类的静态代码块。
• 执行父类的构造块，执行父类的构造方法体。
• 执行子类的构造块，执行子类的构造方法体。

3.访问控制权限范围：

注意事项
• public修饰的成员可以在任意位置使用。
• private修饰的成员只能在本类内部使用。
• 通常情况下，成员方法都使用public关键字修饰，成员变量都使用private
关键字修饰。

package语句的由来
• 定义类时需要指定类的名称，但如果仅仅将类名作为类的唯一标识，则
不可避免的出现命名冲突的问题。这会给组件复用以及团队间的合作成很大的麻烦！
• 在Java语言中，用包（package）的概念来解决命名冲突的问题。
包的定义
• 在定义一个类时，除了定义类的名称一般还要指定一个包名，格式如下：
package 包名;
package 包名1.包名2.包名3…包名n;
• 为了实现项目管理、解决命名冲突以及权限控制的效果。定义包的规范
• 如果各个公司或开发组织的程序员都随心所欲的命名包名的话，仍然不
能从根本上解决命名冲突的问题。因此，在指定包名的时候应该按照一
定的规范。
• org.apache.commons.lang.StringUtil
• 其中StringUtils是类名而org.apache.commons.lang是多层包名，其含义
如下：org.apache表示公司或组织的信息（是这个公司（或组织）域名的
反写）；common 表示项目的名称信息；lang 表示模块的名称信息。

包的导• 使用import关键字导入包。
• 使用import关键字导入静态成员，从Java5.0开始支持。（import static java.lang.System.out;导入java目录中lang目录中System类中的静态成员out 了解一下就好了）。

第四节：final关键字（重点）基本概念
final本意为"最终的、不可改变的"，可以修饰类、成员方法以及成员变量。

使用方式
• final关键字修饰类体现在该类不能被继承。

• 主要用于防止滥用继承，如：java.lang.String类等。
  • final关键字修饰成员方法体现在该方法不能被重写但可以被继承。
• 主要用于防止不经意间造成重写，如：java.text.Dateformat类中format方法等。
  • final关键字修饰成员变量体现在该变量必须初始化且不能改变。
• 主要用于防止不经意间造成改变，如：java.lang.Thread类中MAX_PRIORITY等。

常量的概念

• 在以后的开发中很少单独使用final关键字来修饰成员变量，通常使用
public static final关键字共同修饰成员变量来表达常量的含义，常量的命
名规范要求是所有字母都要大写，不同的单词之间采用下划线连。
• public static final double PI = 3.14;

初始化的方式：1.构造块里面赋值，public final int sum;｛sum = 11;｝
2.直接初始化 : public final int sum = 11;

总结和答疑

任务四：

1. 多态
2. 抽象类
3. 接口
4. 总结和答疑

1.多态

解释：多态的概念
• 多态主要指同一种事物表现出来的多种形态。
• 饮料：可乐、雪碧、红牛、脉动、…
• 宠物：猫、狗、鸟、小强、鱼、…
• 人：学生、教师、工人、保安、…
• 图形：矩形、圆形、梯形、三角形、…
语法格式：父类类型 变量名 = new 子类类型();
多态的特点：
• 当父类类型的引用指向子类类型的对象时，父类类型的引用可以直接调
用父类独有的方法。
• 当父类类型的引用指向子类类型的对象时，父类类型的引用不可以直接
调用子类独有的方法。
• 对于父子类都有的非静态方法来说，编译阶段调用父类版本，运行阶段
调用子类重写的版本（动态绑定）。
• 对于父子类都有的静态方法来说，编译和运行阶段都调用父类版本。

大家会不会想问有没有办法父类对象指向子类实例的时候，父类对象可以调用子类特有的方法呢？答案是有的。且看： 引用数据类型之间的转换。

• 引用数据类型之间的转换方式有两种：自动类型转换 和 强制类型转换。
• 自动类型转换主要指小类型向大类型的转换，也就是子类转为父类，也
叫做向上转型。
• 强制类型转换主要指大类型向小类型的转换，也就是父类转为子类，也
叫做向下转型或显式类型转换。

• 引用数据类型之间的转换必须发生在父子类之间，否则编译报错。
大家对于大类型和小类型是不是有一些模糊，其实可以这么想：子类 is 父类，子类是父类，但是不代表父类是子类。圆是图形，图形不一定是圆。或者生活里面，父亲是不是比儿子大？
当父类对象强制转换为子类类型时，可以实现调用子类特有的办法。不过注意：如果强转的对象指向的不是该类型，会报错。比如People,Work,Teacher。People是Work和Teacher的父类
People people = new Work();
Teacher teacher = (Teacher)people; //报错
所以大转小的时候需要先判断：instanceof关键字 用法：引用变量 instanceof 数据类型.如果引用变量是数据类型的本类类型或者是子类的类型，返回true，否则返回false
该关键字实际上是判断引用变量指向的堆区空间是不是该类型的对象或者是该子类的对象。

多态的意义：• 多态的实际意义在于屏蔽不同子类的差异性实现通用的编程带来不同的
效果。因为父类对象指向子类，可以提高代码的复用

2.抽象类
抽象方法的概念
• 抽象方法主要指不能具体实现的方法并且使用abstract关键字修饰，也就
是没有方法体。
• 具体格式如下：
访问权限 abstract 返回值类型 方法名(形参列表);
public abstract void cry();

抽象类的概念
• 抽象类主要指不能具体实例化的类并且使用abstract关键字修饰，也就是
不能创建对象。抽象类和抽象方法的关系
• 抽象类中可以有成员变量、构造方法、成员方法；
• 抽象类中可以没有抽象方法，也可以有抽象方法；
• 拥有抽象方法的类必须是抽象类，因此真正意义上的抽象类应该是具有抽象方法并且 使用abstract关键字修饰的类。
总结：抽象类和普通类的区别就是抽象类可以有抽象方法而且类有abstract修饰。
3.接口
接口是比抽象类还要抽象的东西。为什么要有接口？大家可以想想看：黄金是不是金属，黄金是不是货币的一种？都是吧，但是Java里面只允许单继承，不允许多继承。所以提出了接口，一个类可以实现多个接口。
接口的基本概念
• 接口就是一种比抽象类还抽象的类，体现在所有方法都为抽象方法。
• 定义类的关键字是class，而定义接口的关键字是interface。
• 如：金属接口 货币接口 黄金类

接口与类之间的关系

抽象类和接口的主要区别（笔试题）
• 定义抽象类的关键字是abstract class，而定义接口的关键字是interface。
• 继承抽象类的关键字是extends，而实现接口的关键字是implements。
• 继承抽象类支持单继承，而实现接口支持多实现。
• 抽象类中可以有构造方法，而接口中不可以有构造方法。
• 抽象类中可以有成员变量，而接口中只可以有常量。
• 抽象类中可以有成员方法，而接口中只可以有抽象方法。
• 抽象类中增加方法时子类可以不用重写，而接口中增加方法时实现类需
要重写（Java8以前的版本）。
• 从Java8开始增加新特性，接口中允许出现非抽象方法和静态方法，但非
抽象方法需要使用default关键字修饰。
• 从Java9开始增加新特性，接口中允许出现私有方法。

4.总结与答疑

任务五：特殊类

目录

1. 内部类
2. 枚举
3. 注解
4. 总结和答疑

1 内部类（熟悉）
内部类的基本概念
• 当一个类的定义出现在另外一个类的类体中时，那么这个类叫做内部类
（Inner），而这个内部类所在的类叫做外部类（Outer）。
• 类中的内容：成员变量、成员方法、构造方法、静态成员、构造块和静
态代码块、内部类。

实际作用
• 当一个类存在的价值仅仅是为某一个类单独服务时，那么就可以将这个
类定义为所服务类中的内部类，这样可以隐藏该类的实现细节并且可以
方便的访问外部类的私有成员而不再需要提供公有的get和set方法。

内部类的分类
• 普通内部类 - 直接将一个类的定义放在另外一个类的类体中。
• 静态内部类 - 使用static关键字修饰的内部类，隶属于类层级。
• 局部内部类 - 直接将一个类的定义放在方法体的内部时。
• 匿名内部类 - 就是指没有名字的内部类。

普通（成员）内部类的格式
• 访问修饰符 class 外部类的类名 {
访问修饰符 class 内部类的类名 {
内部类的类体;
}
}
普通内部类的使用方式
• 普通内部类和普通类一样可以定义成员变量、成员方法以及构造方法等。
• 普通内部类和普通类一样可以使用final或者abstract关键字修饰。
• 普通内部类还可以使用private或protected关键字进行修饰。
• 普通内部类需要使用外部类对象来创建对象。
• 如果内部类访问外部类中与本类内部同名的成员变量或方法时，需要使
用this关键字。

静态内部类的格式
• 访问修饰符 class 外部类的类名 {
访问修饰符 static class 内部类的类名 {
内部类的类体;
}
} 静态内部类的使用方式
• 静态内部类不能直接访问外部类的非静态成员。
• 静态内部类可以直接创建对象。
• 如果静态内部类访问外部类中与本类内同名的成员变量或方法时，需要
使用类名.的方式访问。局部（方法）内部类的格式
• 访问修饰符 class 外部类的类名 {
访问修饰符 返回值类型 成员方法名（形参列表） class 内部类的类名 {
内部类的类体;
}
}
} 局部内部类的使用方式
• 局部内部类只能在该方法的内部可以使用。
• 局部内部类可以在方法体内部直接创建对象。
• 局部内部类不能使用访问控制符和static关键字修饰符。
• 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内
部类和局部变量的声明周期不同所致。回调模式的概念
• 回调模式是指——如果一个方法的参数是接口类型，则在调用该方法时，
需要创建并传递一个实现此接口类型的对象；而该方法在运行时会调用
到参数对象中所实现的方法（接口中定义的）。开发经验分享
• 当接口/类类型的引用作为方法的形参时，实参的传递方式有两种：
• 自定义类实现接口/继承类并重写方法，然后创建该类对象作为实参传递；
• 使用上述匿名内部类的语法格式得到接口/类类型的引用即可；匿名内部类的语法格式（重点）
• 接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };第二节：枚举（熟悉）枚举的基本概念
• 一年中的所有季节：春季、夏季、秋季、冬季。
• 所有的性别：男、女。
• 键盘上的所有方向按键：向上、向下、向左、向右。
• 在日常生活中这些事物的取值只有明确的几个固定值，此时描述这些事
物的所有值都可以一一列举出来，而这个列举出来的类型就叫做枚举类
型。

枚举的定义
• 使用public static final表示的常量描述较为繁琐，使用enum关键字来定
义枚举类型取代常量，枚举类型是从Java5开始增加的一种引用数据类型。
• 枚举值就是当前类的类型，也就是指向本类的对象，默认使用public
static final关键字共同修饰，因此采用枚举类型.的方式调用。
• 枚举类可以自定义构造方法，但是构造方法的修饰符必须是private，默
认也是私有的。
Enum类的概念和方法
• 所有的枚举类都继承自java.lang.Enum类，常用方法如下：
static T[] values() 返回当前枚举类中的所有对象
String toString() 返回当前枚举类对象的名称
int ordinal() 获取枚举对象在枚举类中的索引位置
static T valueOf(String str) 将参数指定的字符串名转为当前枚举类的对象
int compareTo​(E o) 比较两个枚举对象在定义时的顺序
枚举类实现接口的方式
• 枚举类实现接口后需要重写抽象方法，而重写方法的方式有两种：重写
一个，或者每个对象都重写。
第三节：注解（重点）
注解的基本概念
• 注解（Annotation）又叫标注，是从Java5开始增加的一种引用数据类型。
• 注解本质上就是代码中的特殊标记，通过这些标记可以在编译、类加载、
以及运行时执行指定的处理。
注解的语法格式
• 访问修饰符 @interface 注解名称 {
注解成员;
}
• 自定义注解自动继承java.lang.annotation.Annotation接口。
• 通过@注解名称的方式可以修饰包、类、 成员方法、成员变量、构造方
法、参数、局部变量的声明等。
注解的使用方式
• 注解体中只有成员变量没有成员方法，而注解的成员变量以“无形参的方
法”形式来声明，其方法名定义了该成员变量的名字，其返回值定义了该
成员变量的类型。
• 如果注解只有一个参数成员，建议使用参数名为value，而类型只能是八
种基本数据类型、String类型、Class类型、enum类型及Annotation类型。
元注解的概念
• 元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但
是它能够应用到其它的注解上面。
• 元注解主要有 @Retention、@Documented、@Target、@Inherited、
@Repeatable。
元注解@Retention
• @Retention 应用到一个注解上用于说明该注解的的生命周期，取值如下：
• RetentionPolicy.SOURCE 注解只在源码阶段保留，在编译器进行编译时
它将被丢弃忽视。
• RetentionPolicy.CLASS 注解只被保留到编译进行的时候，它并不会被加
载到 JVM 中，默认方式。
• RetentionPolicy.RUNTIME 注解可以保留到程序运行的时候，它会被加载
进入到 JVM 中，所以在程序运行时可以获取到它们。
元注解@Documented
• 使用javadoc工具可以从程序源代码中抽取类、方法、成员等注释形成一
个和源代码配套的API帮助文档，而该工具抽取时默认不包括注解内容。
• @Documented用于指定被该注解将被javadoc工具提取成文档。
• 定义为@Documented的注解必须设置Retention值为RUNTIME。

元注解@Inherited
• @Inherited并不是说注解本身可以继承，而是说如果一个超类被该注解标
记过的注解进行注解时，如果子类没有被任何注解应用时，则子类就继
承超类的注解。
元注解@Repeatable
• @Repeatable表示自然可重复的含义，从Java8开始增加的新特性。
• 从Java8开始对元注解@Target的参数类型ElementType枚举值增加了两个：
• 其中ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明
语句中，如：泛型。
• 其中ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。
常见的预制注解
• 预制注解就是Java语言自身提供的注解，具体如下：
@author 标明开发该类模块的作者，多个作者之间使用,分割
@version 标明该类模块的版本
@see 参考转向，也就是相关主题
@since 从哪个版本开始增加的
@param 对方法中某参数的说明，如果没有参数就不能写
@return 对方法返回值的说明，如果方法的返回值类型是void就
不能写
@exception 对方法可能抛出的异常进行说明。