JAVA学习笔记—JAVA SE（二）面向对象编程

二、面向对象编程

1. 类和对象

1.1 面向对象编程

面向对象编程的概念

• 万物皆对象。

• 面向对象指以属性和行为的观点去分析现实生活中的事物。

• 面向对象编程指先以面向对象的思想进行分析，然后使用面向对象的编程语言进行表达的过程。

• 面向对象编程是软件产业化发展的需求。

• 理解面向对象的思想精髓(封装、继承、多态)，至少掌握一种编程语言。

1.2 类和对象及引用

类和对象的概念

• 对象主要指现实生活中客观存在的实体，在Java语言中对象体现为内存空间中的一块存储区域。

• 类简单来就是“分类”，是对具有相同特征和行为的多个对象共性的抽象描述，在Java语言中体现为一种引用数据类型，里面包含了描述特征/属性的成员变量以及描述行为的成员方法。

• 类是用于构建对象的模板，对象的数据结构由定义它的类来决定。

类的定义

• class 类名 {

类体;

}

• 注意：

通常情况下，当类名由多个单词组成时，要求每个单词首字母都要大写。

成员变量的定义

• class 类名 {

数据类型 成员变量名 = 初始值;

}

• 注意：

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

对象的创建

• new 类名();

• 注意：

a.当一个类定义完毕后，可以使用new关键字来创建该类的对象，这个过程叫做类的实例化。

b.创建对象的本质就是在内存空间的堆区申请一块存储区域， 用于存放该对象独有特征信息。

引用的定义

• 基本概念

a.使用引用数据类型定义的变量叫做引用型变量，简称为"引用"。

b.引用变量主要用于记录对象在堆区中的内存地址信息，便于下次访问。

• 语法格式

类名 引用变量名;

引用变量名.成员变量名;

成员变量的初始值

• 对象创建后，其成员变量可以按照默认的方式初始化，具体规则如下：

1.2.2 成员方法

成员方法的定义

• class 类名 {

​ 返回值类型 成员方法名(形参列表) {

​ 成员方法体;

​ }

}

• 当成员方法名由多个单词组成时，要求从第二个单词起每个单词的首字母大写。

返回值类型的详解

• 返回值主要指从方法体内返回到方法体外的数据内容。

• 返回值类型主要指返回值的数据类型，可以是基本数据类型，也可以是引用数据类型。

• 当返回的数据内容是66时，则返回值类型写 int 即可

• 在方法体中使用return关键字可以返回具体的数据内容并结束当前方法。

• 当返回的数据内容是66时，则方法体中写 return 66; 即可

• 当该方法不需要返回任何数据内容时，则返回值类型写void即可。

形参列表的详解

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

• 形式参数列表主要指多个形式参数组成的列表，语法格式如下：

​ 数据类型 形参变量名1, 数据类型 形参变量名2, …

• 当带入的数据内容是"hello"时，则形参列表写 String s 即可

• 当带入的数据内容是66和"hello"时，则形参列表写 int i, String s 即可

• 若该方法不需要带入任何数据内容时，则形参列表位置啥也不写即可。

方法体的详解

• 成员方法体主要用于编写描述该方法功能的语句块。

• 成员方法可以实现代码的重用，简化代码。

方法的调用

• 引用变量名.成员方法名(实参列表);

• 实际参数列表主要用于对形式参数列表进行初始化操作，因此参数的个

数、类型以及顺序都要完全一致。

• 实际参数可以传递直接量、变量、表达式、方法的调用等。

​ 程序的执行流程和内存分析

可变长参数

• 返回值类型 方法名(参数的类型… 参数名)

• 方法参数部分指定类型的参数个数是可以改变的，也就是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赋值给了形参。当参数是对象时，传递的是对象的值，也就是把对象的地址赋值给形参。

2. 方法和封装

2.1 构造方法

构造方法的概念

• class 类名 {

​ 类名(形参列表) {

​ 构造方法体;

​ }

}

• 构造方法名与类名完全相同并且没有返回值类型，连void都不许有。

默认构造方法

• 当一个类中没有定义任何构造方法时，编译器会自动添加一个无参空构造构造方法，叫做默认/缺省构造方法，如：Person(){}

• 若类中出现了构造方法，则编译器不再提供任何形式的构造方法。

构造方法的作用

• 使用new关键字创建对象时会自动调用构造方法实现成员变量初始化工作。

2.2 方法和重载

方法重载的概念

• 若方法名称相同，参数列表不同，这样的方法之间构成重载关系(Overload)。

重载的体现形式

• 方法重载的主要形式体现在：参数的个数不同、参数的类型不同、参数的顺序不同，与返回值类型和形参变量名无关，但建议返回值类型最好相同。

• 判断方法能否构成重载的核心：调用方法时能否加以区分。

重载的实际意义

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

• 如：java.io.PrintStream类中的println方法。

2.3 this关键字

this的基本概念

• 若在构造方法中出现了this关键字，则代表当前正在构造的对象。

• 若在成员方法中出现了this关键字，则代表当前正在调用的对象。

• this关键字本质上就是当前类类型的引用变量。

工作原理

• 在构造方法中和成员方法中访问成员变量时，编译器会加上this.的前缀，而this.相当于汉语中"我的"，当不同的对象调用同一个方法时，由于调用方法的对象不同导致this关键字不同，从而this.方式访问的结果也就随之不同。

使用方式

• 当局部变量名与成员变量名相同时，在方法体中会优先使用局部变量(就近原则)，若希望使用成员变量，则需要在成员变量的前面加上this.的前缀，明确要求该变量是成员变量。

• this关键字除了可以通过this.的方式调用成员变量和成员方法外，还可以作为方法的返回值。

	// 自定义成员方法实现Person类型对象的获取并返回的行为
	Person getPerson() {
		// 返回当前调用对象本身  Person tp = new Person();  return tp;
		return this;
	} 
	
		// 调用成员方法获取对象
		Person p4 = p1.getPerson();
		System.out.println("p4 = " + p4);

• 在构造方法的第一行可以使用this()的方式来调用本类中的其它构造方法。

注意事项

• 引用类型变量用于存放对象的地址，可以给引用类型赋值为null，表示不指向任何对象。

• 当某个引用类型变量为null时无法对对象实施访问（因为它没有指向任何对象）。此时，如果通过引用访问成员变量或调用方法，会产生NullPointerException 异常。

2.4 方法递归调用

递归的基本概念

• 递归本质就是指在方法体的内部直接或间接调用当前方法自身的形式。

注意事项

• 使用递归必须有递归的规律以及退出条件。

• 使用递归必须使得问题简单化而不是复杂化。

• 若递归影响到程序的执行性能，则使用递推取代之。

案例题目

• 编程实现参数n的阶乘并返回，所谓阶乘就是从1累乘到n的结果。

public class JieChengTest {
	
	// 自定义成员方法实现将参数n的阶乘计算出来并返回
	// 1! = 1;     2! = 1*2;   3! = 1*2*3;   ...   n! = 1*2*3*...*n;
	int show(int n) { // int n=5; int n = 4; int n = 3; int n = 2;  int n = 1;
		// 递推的方式 
		/*
		int num = 1;
		for(int i = 1; i <= n; i++) {
			num *= i;
		}
		return num;
		*/
		/*
		    5! = 5 * 4 * 3 * 2 * 1;
			4! = 4 * 3 * 2 * 1;
			3! = 3 * 2 * 1;
			2! = 2 * 1;
			1! = 1;
			
			5! = 5 * 4!;
			4! = 4 * 3!;
			3! = 3 * 2!;
			2! = 2 * 1!;
			1! = 1;
			
			n! = n * (n-1)!;
		  
		*/
		// 递归的方式
		// 当n的数值为1时，则阶乘的结果就是1
		/*
		if(1 == n) {
			return 1;
		}
		*/
		if(1 == n) return 1;
		// 否则阶乘的结果就是 n*(n-1)!
		return n*show(n-1);
	}
	
	public static void main(String[] args) {
		
		// 1.声明JieChengTest类型的引用指向该类型的对象
		JieChengTest jct = new JieChengTest();
		// 2.调用方法进行计算并打印
		int res = jct.show(5);
		System.out.println("最终的计算结果是：" + res); // 120
	}
}

2.5 封装

2.5.1 封装的概念

• 通常情况下可以在测试类给成员变量赋值一些合法但不合理的数值，无论是编译阶段还是运行阶段都不会报错或者给出提示，此时与现实生活不符。

• 为了避免上述错误的发生，就需要对成员变量进行密封包装处理，来隐藏成员变量的细节以及保证成员变量数值的合理性，该机制就叫做封装。

封装的实现流程

• 私有化成员变量，使用private关键字修饰。

• 提供公有的get和set方法，并在方法体中进行合理值的判断。

• 在构造方法中调用set方法进行合理值的判断

案例题目

• 提示用户输入班级的学生人数以及每个学生的信息，学生的信息有：学号、姓名，最后分别打印出来。

• 提示：Student[] arr = new Student[num];

public class Student {
	
	// 1.私有化成员变量，使用private关键字修饰
	// private关键字修饰表示私有的含义，也就是该成员变量只能在当前类的内部使用
	private int id;       // 用于描述学号的成员变量
	private String name;  // 用于描述姓名的成员变量 
	
	// 3.在公有的构造方法中调用set方法进行合理值的判断
	public Student() {}
	public Student(int id, String name) {
		//this.id = id;
		//this.name = name;
		setId(id);
		setName(name);
	}
	
	// 2.提供公有的get和set方法，并在方法体中进行合理值的判断
	// 使用public关键字修饰表示公有的含义，也就是该方法可以在任意位置使用
	public int getId() {
		return id;
	}
	public void setId(int id) {
		if(id > 0) {
			this.id = id;
		} else {
			System.out.println("学号不合理哦！！！");
		}
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	// 自定义成员方法实现特征的打印
	// 什么修饰符都没有叫做默认的访问权限，级别介于private和public之间
	public void show() {
		//System.out.println("我是" + name + "，我的学号是" + id);
		System.out.println("我是" + getName() + "，我的学号是" + getId());
	}
}

import java.util.Scanner; 
 
public class StudentTest2 {
	
	public static void main(String[] args) {
		
		// 1.提示用户输入学生的人数并使用变量记录
		System.out.println("请输入学生的人数：");
		Scanner sc = new Scanner(System.in);
		int num = sc.nextInt();
		
		// 2.根据学生的人数准备对应的一维数组
		// int[] arr = new int[3];  - 表示声明一个长度为3元素类型为int类型的一维数组
		// 数组中的每个元素都是int类型，也就是说数组中的每个元素都可以看做是一个int类型的变量，使用整数数据进行初始化 arr[0] = 10;
		// 下面的代码是声明一个长度为num元素类型为Student类型的一维数组
		// 数组中的每个元素都是Student类型，也就是说数组中的每个元素都可以看做Student类型的变量，arr[0] = new Student();
		Student[] arr = new Student[num];
		
		
		// 3.提示用户输入每个学生的信息(学号 姓名)并记录到一维数组中
		for(int i = 0; i < num; i++) {
			System.out.println("请输入第" + (i+1) + "个学生的信息(学号 姓名)：");
			arr[i] = new Student(sc.nextInt(), sc.next());
		}
		
		System.out.println("-----------------------------------------------");
		// 4.打印所有学生信息
		System.out.println("该班级的所有学生信息有：");
		for(int i = 0; i < num; i++) {
			//System.out.println(arr[i]);
			arr[i].show();
		}
	}
}

2.5.2 JavaBean的概念

• JavaBean是一种Java语言写成的可重用组件，其它Java 类可以通过反射机制发现和操作这些JavaBean 的属性。

• JavaBean本质上就是符合以下标准的Java类：

​ 类是公共的

​ 有一个无参的公共的构造器

​ 有属性，且有对应的get、set方法

3. static关键字和继承

3.1 static关键字

基本概念

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

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

使用方式

• 在非静态成员方法中既能访问非静态的成员又能访问静态的成员。

(成员：成员变量 + 成员方法， 静态成员被所有对象共享)

• 在静态成员方法中只能访问静态成员不能访问非静态成员。

(成员：成员变量 + 成员方法， 因为此时可能还没有创建对象)

• 在以后的开发中只有隶属于类层级并被所有对象共享的内容才可以使用

static关键字修饰。(不能滥用static关键字)

案例题目

• 编程实现People类的封装，特征有：姓名、年龄、国籍，要求提供打印所有特征的方法。

• 编程实现PeopleTest类，main方法中使用有参方式构造两个对象并打印。

public class People {
	
	// 1.私有化成员变量，使用private关键字修饰
	private String name;
	private int age;
	//private String country; // 隶属于对象层级，也就是每个对象都拥有独立的一份
	//public static String country; // 隶属于类层级，也就是整个类只有一份并且被所有对象共享
	private static String country;
	
	// 3.在构造方法中调用set方法进行合理值的判断
	public People() {}
	public People(String name, int age/*, String country*/) {
		setName(name);
		setAge(age);
		//setCountry(country);
	}
	
	// 2.提供公有的get和set方法，并在方法体中进行合理值的判断
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age > 0 && age < 150) {
			this.age = age;
		} else {
			System.out.println("年龄不合理哦！！！");
		}
	}
	public static String getCountry() {
		return country;
	}
	public static void setCountry(String country) {
		//this.country = country;
		People.country = country;
	}
	
	public void show() {
		System.out.println("我是" + getName() + "，今年" + getAge() + "岁了，来自" + getCountry());
	}
}

public static void main(String[] args) {
	
	// 3.验证static关键字修饰的静态成员(类成员)是否与创建对象无关  类名.的方式 => 无关
	//System.out.println("获取到的国籍信息是：" + People.country); // null
	System.out.println("获取到的国籍信息是：" + People.getCountry()); // null
	
	// 1.使用有参方式构造两个People类型的对象并打印特征
	People p1 = new People("zhangfei", 30/*, "China"*/);
	p1.show(); // zhangfei 30 China
	
	People p2 = new People("guanyu", 35/*, "China"*/);
	p2.show(); // guanyu 35 China

	System.out.println("--------------------------------------------");
	// 2.验证static关键字修饰的静态成员(类成员) 是否被所有对象共享  => 共享
	//p1.country = "蜀国";
	p1.setCountry("蜀国");
	//System.out.println("第一个对象的国籍是：" + p1.country); // 蜀国
	//System.out.println("第二个对象的国籍是：" + p2.country); // 蜀国
	System.out.println("第一个对象的国籍是：" + p1.getCountry()); // 蜀国
	System.out.println("第二个对象的国籍是：" + p2.getCountry()); // 蜀国
	
	People p3 = new People();
	//System.out.println("第三个对象的国籍是：" + p3.country); // 蜀国
	System.out.println("第三个对象的国籍是：" + p3.getCountry()); // 蜀国
}

3.1.1 构造块和静态代码块

• 构造块：在类体中直接使用{}括起来的代码块。

• 每创建一个对象都会执行一次构造块。

• 静态代码块：使用static关键字修饰的构造块。

• 静态代码块随着类加载时执行一次。

执行顺序

• 先执行父类的静态代码块，再执行子类的静态代码块。

• 执行父类的构造块，执行父类的构造方法体。

• 执行子类的构造块，执行子类的构造方法体。

3.1.2 单例设计模式

单例设计模式的概念

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

单例设计模式的实现流程

• 私有化构造方法，使用private关键字修饰。

• 声明本类类型的引用指向本类类型的对象，并使用private static关键字共同修饰。

• 提供公有的get方法负责将对象返回出去，并使用public static关键字共同修饰。

单例设计模式的实现方式

• 单例设计模式的实现方式有两种：饿汉式 和 懒汉式，在以后的开发中推荐饿汉式。

案例题目

• 编程实现Singleton类的封装。

• 编程实现SingletonTest类对Singleton类进行测试，要求main方法中能得到且只能得到该类的一个对象。

public class Singleton {
	
	// 2.声明本类类型的引用指向本类类型的对象，使用private static关键字共同修饰
	//private static Singleton sin = new Singleton();  // 饿汉式
	private static Singleton sin = null;               // 懒汉式
	
	// 1.私有化构造方法，使用private关键字修饰
	private Singleton() {}
	
	// 3.提供公有的get方法负责将对象返回出去，使用public static关键字共同修饰
	public static Singleton getInstance() {
		//return sin;
		if(null == sin) {
			sin = new Singleton();
		}
		return sin;
	}
}

public class SingletonTest {
	
	public static void main(String[] args) {
		
		// 1.声明Singleton类型的引用指向该类型的对象
		//Singleton s1 = new Singleton();
		//Singleton s2 = new Singleton();
		//System.out.println(s1 == s2); // 比较变量s1的数值是否与变量s2的数值相等  false
		//Singleton.sin = null;  可以使得引用变量无效
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		System.out.println(s1 == s2); // true
	}
}

3.2 继承

继承的概念

• 当多个类之间有相同的特征和行为时，可以将相同的内容提取出来组成一个公共类，让多个类吸收公共类中已有特征和行为而在多个类型只需要编写自己独有特征和行为的机制，叫做继承。

• 在Java语言中使用extends(扩展)关键字来表示继承关系。

• 如：

public class Worker extends Person{} - 表示Worker类继承自Person类

其中Person类叫做超类、父类、基类。

其中Worker类叫做派生类、子类、孩子类。

• 使用继承提高了代码的复用性，可维护性及扩展性，是多态的前提条件。

继承的特点

• 子类不能继承父类的构造方法和私有方法，但私有成员变量可以被继承只是不能直接访问。

• 无论使用何种方式构造子类的对象时都会自动调用父类的无参构造方法，来初始化从父类中继承的成员变量，相当于在构造方法的第一行增加代码super()的效果。

• 使用继承必须满足逻辑关系：子类 is a 父类，也就是不能滥用继承。

• Java语言中只支持单继承不支持多继承，也就是说一个子类只能有一个父类，但一个父类可以有多个子类。

案例

public class Person {
	
	// 1.私有化成员变量，使用private关键字修饰
	private String name;
	private int age;
	//private boolean gender; // 性别
	
	// 3.在构造方法中调用set方法进行合理值的判断
	public Person() {
		System.out.println("Person()");
	}
	public Person(String name, int age) {
		System.out.println("Person(String, int)");
		setName(name);
		setAge(age);
	}
	
	// 2.提供公有的get和set方法并在方法体中进行合理值的判断
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age > 0 && age < 150) {
			this.age = age;
		} else {
			System.out.println("年龄不合理哦！！！");
		}
	}
	
	// 自定义成员方法实现特征的打印
	public void show() {
		System.out.println("我是" + getName() + "，今年" + getAge() + "岁了！");
	}
	// 自定义成员方法描述吃饭的行为
	public void eat(String food) {
		System.out.println(food + "真好吃！");
	}
	// 自定义成员方法描述娱乐的行为
	public void play(String game) {
		System.out.println(game + "真好玩！");
	}
}

public class Worker extends Person {
	
	private int salary;
	
	public Worker() {
		super(); // 表示调用父类的无参构造方法，若没有加则编译器自动添加
		System.out.println("Worker()");
	}
	public Worker(String name, int age, int salary) {
		super(name, age); // 表示调用父类的有参构造方法
		System.out.println("Worker(String, int, int)");
		//setName(name);
		//setAge(age);
		setSalary(salary);
	}
	
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		if(salary >= 2200) {
			this.salary = salary;
		} else {
			System.out.println("薪水不合理哦！！！");
		}
	}
	
	// 自定义成员方法描述工作的行为
	public void work() {
		System.out.println("今天的砖头有点烫手...");
	}
	// 自定义show方法覆盖从父类中继承的版本
	@Override  // 标注/注解，用于说明下面的方法是对父类方法的重写，若没有构成重写则编译报错
	public void show() {
		super.show(); // 表示调用父类的show方法
		System.out.println("我的薪水是：" + getSalary());
	}
}

public class WorkerTest {
	
	public static void main(String[] args) {
		
		// 1.使用无参方式构造Worker类型的对象并打印特征
		Worker w1 = new Worker();
		// 当子类重写show方法后，则下面调用的是重写以后的版本
		w1.show(); // null  0
		
		System.out.println("----------------------------------");
		// 2.使用有参方式构造Worker类型的对象并打印特征
		Worker w2 = new Worker("zhangfei", 30, 3000);
		w2.show(); // zhangfei ...
		// 调用成员方法测试
		w2.eat("豆芽");
		w2.play("王者荣耀");
		w2.work();
	}
}

3.2.1 方法重写

方法重写的概念

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

方法重写的原则

• 要求方法名相同、参数列表相同以及返回值类型相同，从Java5开始允许返回子类类型。

• 要求方法的访问权限不能变小，可以相同或者变大。

• 要求方法不能抛出更大的异常(异常机制)。

3.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开始支持。

3.4 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;

4. 多态和特殊类

4.1 多态

多态的概念

• 多态主要指同一种事物表现出来的多种形态。

多态的语法格式

• 父类类型 引用变量名 = new 子类类型();

• 如：

Shape sr = new Rect();

sr.show();

多态的特点

• 当父类类型的引用指向子类类型的对象时，父类类型的引用可以直接调用父类独有的方法。

• 当父类类型的引用指向子类类型的对象时，父类类型的引用不可以直接调用子类独有的方法。

• 对于父子类都有的非静态方法来说，编译阶段调用父类版本，运行阶段调用子类重写的版本（动态绑定）。

• 对于父子类都有的静态方法来说，编译和运行阶段都调用父类版本。

引用数据类型之间的转换

• 引用数据类型之间的转换方式有两种：自动类型转换 和 强制类型转换。

• 自动类型转换主要指小类型向大类型的转换，也就是子类转为父类，也叫做向上转型。

• 强制类型转换主要指大类型向小类型的转换，也就是父类转为子类，也叫做向下转型或显式类型转换。

• 引用数据类型之间的转换必须发生在父子类之间，否则编译报错。

• 若强转的目标类型并不是该引用真正指向的数据类型时则编译通过，运

行阶段发生类型转换异常。

• 为了避免上述错误的发生，应该在强转之前进行判断，格式如下：

if(引用变量 instanceof 数据类型)

判断引用变量指向的对象是否为后面的数据类型

多态的实际意义

• 多态的实际意义在于屏蔽不同子类的差异性实现通用的编程带来不同的效果。

案例题目

• 编程实现Shape类的封装，特征有：横纵坐标，要求提供打印所有特征的方法。

• 编程实现Rect类的封装并继承自Shape类，特征有：长度和宽度。

• 编程实现ShapeRectTest类，在main方法中分别创建Shape和Rect类型对象并打印特征。

public class Shape {
    private int x;
    private int y;

    public Shape() {
    }

    public Shape(int x, int y) {
        setX(x);
        setY(y);
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public void show() {
        System.out.println("横坐标：" + getX() + "，纵坐标：" + getY());
    }

    // 自定义静态方法
    public static void test() {
        System.out.println("Shape类中的静态方法！");
    }
}

public class Rect extends Shape {
    private int len;
    private int wid;

    public Rect() {
    }

    public Rect(int x, int y, int len, int wid) {
        super(x, y);
        setLen(len);
        setWid(wid);
    }

    public int getLen() {
        return len;
    }

    public void setLen(int len) {
        if(len > 0) {
            this.len = len;
        } else {
            System.out.println("长度不合理哦！！！");
        }
    }

    public int getWid() {
        return wid;
    }

    public void setWid(int wid) {
        if (wid > 0) {
            this.wid = wid;
        } else {
            System.out.println("宽度不合理哦！！！");
        }
    }

    @Override
    public void show() {
        super.show();
        System.out.println("长度是：" + getLen() + "，宽度是：" + getWid());
    }

    // 自定义静态方法
    //@Override Error: 历史原因、不是真正意义上的重写
    public static void test() {
        System.out.println("---Rect类中的静态方法！");
    }
}

public class ShapeRectTest {

    public static void main(String[] args) {

        // 1.声明Shape类型的引用指向Shape类型的对象并打印特征
        Shape s1 = new Shape(1, 2);
        // 当Rect类中没有重写show方法时，下面调用Shape类中的show方法
        // 当Rect类中重写show方法后，下面调用Shape类中的show方法
        s1.show(); // 1 2

        // 使用ctrl+d快捷键可以复制当前行
        System.out.println("------------------------------------");
        // 2.声明Rect类型的引用指向Rect类型的对象并打印特征
        Rect r1 = new Rect(3, 4, 5, 6);
        // 当Rect类中没有重写show方法时，下面调用Shape类中的show方法
        // 当Rect类中重写show方法后，下面调用Rect类中的show方法
        r1.show(); // 3 4 5 6

        // 使用alt+shift+上下方向键  可以移动代码
        System.out.println("------------------------------------");
        // 3.声明Shape类型的引用指向Rect类型的对象并打印特征
        // 相当于从Rect类型到Shape类型的转换  也就是子类到父类的转换   小到大的转换  自动类型转换
        Shape sr = new Rect(7, 8, 9, 10);
        // 当Rect类中没有重写show方法时，下面调用Shape类中的show方法
        // 当Rect类中重写show方法后，下面的代码在编译阶段调用Shape类的方法，在运行阶段调用Rect类中的show方法
        sr.show(); // 7 8 9 10

        System.out.println("------------------------------------");
        // 4.测试Shape类型的引用能否直接调用父类和子类独有的方法呢？？？
        int ia = sr.getX();
        System.out.println("获取到的横坐标是：" + ia); // 7
        //sr.getLen();  error  Shape类中找不到getLen方法，也就是还在Shape类中查找

        // 调用静态方法
        sr.test(); // 提示：不建议使用引用.的方式访问
        Shape.test(); // 推荐使用类名.的方式访问

        System.out.println("------------------------------------");
        // 5.使用父类类型的引用调用子类独有方法的方式
        // 相当于从Shape类型到Rect类型的转换，也就是父类到子类的转换  大到小的转换   强制类型转换
        int ib = ((Rect) sr).getLen();
        System.out.println("获取到的长度是：" + ib); // 9

        // 希望将Shape类型转换为String类型  强制类型转换要求必须拥有父子类关系
        //String str1 = (String)sr;  Error
        // 希望将Shape类型强制转换为Circle类型，下面没有报错
        //Circle c1 = (Circle)sr; // 编译ok，但运行阶段发生  ClassCastException类型转换异常

        // 在强制类型转换之前应该使用instanceof进行类型的判断
        // 判断sr指向堆区内存中的对象是否为Circle类型，若是则返回true，否则返回false
        if(sr instanceof Circle) {
            System.out.println("可以放心地转换了！");
            Circle c1 = (Circle)sr;
        } else {
            System.out.println("强转有风险，操作需谨慎！");
        }
    }
}

4.2 抽象类

抽象方法的概念

• 抽象方法主要指不能具体实现的方法并且使用abstract关键字修饰，也就是没有方法体。

• 具体格式如下：

访问权限 abstract 返回值类型 方法名(形参列表);

public abstract void cry();

抽象类的概念

• 抽象类主要指不能具体实例化的类并且使用abstract关键字修饰，也就是不能创建对象。

抽象类和抽象方法的关系

• 抽象类中可以有成员变量、构造方法、成员方法；

• 抽象类中可以没有抽象方法，也可以有抽象方法；

• 拥有抽象方法的类必须是抽象类，因此真正意义上的抽象类应该是具有抽象方法并且使用abstract关键字修饰的类。

抽象类的实际意义

• 抽象类的实际意义不在于创建对象而在于被继承。

• 当一个类继承抽象类后必须重写抽象方法，否则该类也变成抽象类，也就是抽象类对子类具有强制性和规范性，因此叫做模板设计模式。

• 在以后的开发中推荐使用多态的格式，此时父类类型引用直接调用的所有方法一定是父类中拥有的方法，若以后更换子类时，只需要将new关键字后面的子类类型修改而其它地方无需改变就可以立即生效，从而提高了代码的可维护性和可扩展型。

• 该方式的缺点就是：父类引用不能直接调用子类独有的方法，若调用则需要强制类型转换。

抽象类的应用

• 银行有 定期账户和活期账户。继承自 账户类。账户类中：

• public class Account {

​ private double money;

​ public double getLixi(){}

}

public /*final*/ abstract class Account {
    private int money;

    public Account() {
    }

    public Account(int money) {
        setMoney(money);
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        if (money >= 0) {
            this.money = money;
        } else {
            System.out.println("金额不合理哦！！！");
        }
    }

    // 自定义抽象方法实现计算利息并返回的功能描述
    public abstract double getLixi();
    // private 和 abstract 关键字不能共同修饰一个方法
    //private abstract double getLixi();
    // final 和 abstract 关键字不能共同修饰一个方法
    //public final abstract double getLixi();
    // static 和 abstract 关键字不能共同修饰一个方法
    //public static abstract double getLixi();
}

public class FixedAccount extends Account {
    public FixedAccount() {
    }

    public FixedAccount(int i) {
        super(i); // 表示调用父类的有参构造方法
    }

    @Override
    public double getLixi() {
        // 利息 = 本金 * 利率 * 时间
        return getMoney() * 0.03 * 1;
    }

    public static void main(String[] args) {

        // 1.声明Account类型的引用指向子类类型的对象，形成了多态
        //Account acc = new FixedAccount(1000);
        Account acc = new FixedAccount();
        acc.setMoney(1000);
        double res = acc.getLixi();
        System.out.println("计算的利息是：" + res); // 30.0
    }
}

4.3 接口

接口的基本概念

• 接口就是一种比抽象类还抽象的类，体现在所有方法都为抽象方法。

• 定义类的关键字是class，而定义接口的关键字是interface。

• 如：

金属接口 货币接口 黄金类

类和接口之间的关系

抽象类和接口的主要区别

• 定义抽象类的关键字是abstract class，而定义接口的关键字是interface。

• 继承抽象类的关键字是extends，而实现接口的关键字是implements。

• 继承抽象类支持单继承，而实现接口支持多实现。

• 抽象类中可以有构造方法，而接口中不可以有构造方法。

• 抽象类中可以有成员变量，而接口中只可以有常量。

• 抽象类中可以有成员方法，而接口中只可以有抽象方法。

• 抽象类中增加方法时子类可以不用重写，而接口中增加方法时实现类需要重写（Java8以前的版本）。

• 从Java8开始增加新特性，接口中允许出现非抽象方法和静态方法，但非抽象方法需要使用default关键字修饰。

• 从Java9开始增加新特性，接口中允许出现私有方法。

练习题目

• 编程实现Runner接口，提供一个描述奔跑行为的抽象方法。

• 编程实现Hunter接口继承Runner接口，并提供一个描述捕猎行为的抽象方法。

• 编程实现Man类实现Hunter接口并重写抽象方法，在main方法中使用多态方式测试。

public interface Runner {
    // 自定义抽象方法描述奔跑的行为
    public abstract void run();
}

// 接口只能继承接口，不能继承类
public interface Hunter extends Runner {
    // 自定义成员方法描述捕猎的行为
    public abstract void hunt();

    // 将两个默认方法中重复的代码可以提取出来打包成一个方法在下面的两个方法中分别调用即可
    private void show() {
        System.out.println("在以后的开发中尽量减少重复的代码，也就是减少代码的冗余！");
    }
    // 增加一个抽象方法
    //public abstract void show1();
    // 增加非抽象方法
    public default void show1() {
        show();
        //System.out.println("在以后的开发中尽量减少重复的代码，也就是减少代码的冗余！");
        System.out.println("show1方法中：这里仅仅是接口中的默认功能，实现类可以自由选择是否重写！");
    }

    // 增加非抽象方法
    public default void show2() {
        show();
        //System.out.println("在以后的开发中尽量减少重复的代码，也就是减少代码的冗余！");
        System.out.println("show2方法中：这里仅仅是接口中的默认功能，实现类可以自由选择是否重写！");
    }

    // 增加静态方法 隶属于类层级，也就是接口层级
    public static void test() {
        System.out.println("这里是静态方法，可以直接通过接口名.的方式调用，省略对象的创建");
    }
}

public class Man implements Hunter {
    @Override
    public void hunt() {
        System.out.println("正在追赶一直小白兔...");
    }

    @Override
    public void run() {
        System.out.println("正在被一直大熊追赶，玩命奔跑中...");
    }

    @Override
    public void show1() {
        System.out.println("为了给你几分薄面，我决定重写一下！");
    }

    public static void main(String[] args) {

        // 1.声明接口类型的引用指向实现类的对象，形成了多态
        Runner runner = new Man();
        runner.run();

        Hunter hunter = new Man();
        hunter.hunt();

        System.out.println("-----------------------------------------");
        // 2.可以使用接口名称.的方式调用接口中的静态方法
        Hunter.test();
    }
}

5. 特殊类

5.1 内部类

内部类的基本概念

• 当一个类的定义出现在另外一个类的类体中时，那么这个类叫做内部类（Inner），而这个内部类所在的类叫做外部类（Outer）。

• 类中的内容：成员变量、成员方法、构造方法、静态成员、构造块和静态代码块、内部类。

实际作用

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

内部类的分类

• 普通内部类 - 直接将一个类的定义放在另外一个类的类体中。

• 静态内部类 - 使用static关键字修饰的内部类，隶属于类层级。

• 局部内部类 - 直接将一个类的定义放在方法体的内部时。

• 匿名内部类 - 就是指没有名字的内部类。

普通（成员）内部类的格式

• 访问修饰符 class 外部类的类名 {

​ 访问修饰符 class 内部类的类名 {

​ 内部类的类体;

​ }

}

普通内部类的使用方式

• 普通内部类和普通类一样可以定义成员变量、成员方法以及构造方法等。

• 普通内部类和普通类一样可以使用final或者abstract关键字修饰。

• 普通内部类还可以使用private或protected关键字进行修饰。

• 普通内部类需要使用外部类对象来创建对象。

• 如果内部类访问外部类中与本类内部同名的成员变量或方法时，需要使用this关键字。

静态内部类的格式

• 访问修饰符 class 外部类的类名 {

​ 访问修饰符 static class 内部类的类名 {

​ 内部类的类体;

​ }

}

静态内部类的使用方式

• 静态内部类不能直接访问外部类的非静态成员。

• 静态内部类可以直接创建对象。

• 如果静态内部类访问外部类中与本类内同名的成员变量或方法时，需要使用类名.的方式访问

练习

public class StaticOuter {
    private int cnt = 1;        // 隶属于对象层级
    private static int snt = 2; // 隶属于类层级

    public /*static*/ void show() {
        System.out.println("外部类的show方法就是这里！");
    }

    /**
     * 定义静态内部类   有static关键字修饰隶属于类层级
     */
    public static class StaticInner {
        private int ia = 3;
        private static int snt = 4;

        public StaticInner() {
            System.out.println("静态内部类的构造方法哦！");
        }

        public void show() {
            System.out.println("ia = " + ia); // 3
            System.out.println("外部类中的snt = " + snt); // 2
            //System.out.println("外部类的cnt = " + cnt); // Error:静态上下文中不能访问非静态的成员，因此此时可能还没有创建对象
        }

        public void show2(int snt) {  // 就近原则
            System.out.println("snt = " + snt); // 5
            System.out.println("内部类中的成员snt = " + StaticInner.snt); // 4
            System.out.println("外部类中的成员snt = " + StaticOuter.snt); // 2
            //StaticOuter.show();
            new StaticOuter().show();
        }
    }
}

public class StaticOuterTest {

    public static void main(String[] args) {

        // 1.声明StaticInner类型的引用指向该类型的对象
        StaticOuter.StaticInner si = new StaticOuter.StaticInner();
        // 2.调用show方法进行测试
        si.show();

        System.out.println("---------------------------------------------");
        si.show2(5);
    }
}

局部（方法）内部类的格式

• 访问修饰符 class 外部类的类名 {

​ 访问修饰符 返回值类型 成员方法名（形参列表） {

​ class 内部类的类名 {

​ 内部类的类体;

​ }

​ }

}

局部内部类的使用方式

• 局部内部类只能在该方法的内部可以使用。

• 局部内部类可以在方法体内部直接创建对象。

• 局部内部类不能使用访问控制符和static关键字修饰符。

• 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致

回调模式的概念

• 回调模式是指——如果一个方法的参数是接口类型，则在调用该方法时，需要创建并传递一个实现此接口类型的对象；而该方法在运行时会调用到参数对象中所实现的方法（接口中定义的）。

• 当接口/类类型的引用作为方法的形参时，实参的传递方式有两种：

• 自定义类实现接口/继承类并重写方法，然后创建该类对象作为实参传递；

• 使用上述匿名内部类的语法格式得到接口/类类型的引用即可；

匿名内部类的语法格式

• 接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };

案例

public interface AnonymousInterface {
    // 自定义抽象方法
    public abstract void show();
}

public class AnonymousInterfaceImpl implements AnonymousInterface {
    @Override
    public void show() {
        System.out.println("这里是接口的实现类！");
    }
}

public class AnonymousInterfaceTest {

    // 假设已有下面的方法，请问如何调用下面的方法？
    // AnonymousInterface ai = new AnonymousInterfaceImpl();
    // 接口类型的引用指向实现类型的对象，形成了多态
    public static void test(AnonymousInterface ai) {
        // 编译阶段调用父类版本，运行调用实现类重写的版本
        ai.show();
    }

    public static void main(String[] args) {

        //AnonymousInterfaceTest.test(new AnonymousInterface()); // Error:接口不能实例化
        AnonymousInterfaceTest.test(new AnonymousInterfaceImpl());

        System.out.println("---------------------------------------------------------------");
        // 使用匿名内部类的语法格式来得到接口类型的引用，格式为：接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };
        AnonymousInterface ait = new AnonymousInterface() {
            @Override
            public void show() {
                System.out.println("匿名内部类就是这么玩的，虽然你很抽象！");
            }
        };

        // 从Java8开始提出新特性lamda表达式可以简化上述代码，格式为：(参数列表) -> {方法体}
        AnonymousInterface ait2 = () -> System.out.println("lamda表达式原来是如此简单！");
        AnonymousInterfaceTest.test(ait2);
    }
}

5.2 枚举

枚举的基本概念

• 在日常生活中这些事物的取值只有明确的几个固定值，此时描述这些事物的所有值都可以一一列举出来，而这个列举出来的类型就叫做枚举类型。

枚举的定义

• 使用public static final表示的常量描述较为繁琐，使用enum关键字来定义枚举类型取代常量，枚举类型是从Java5开始增加的一种引用数据类型。

• 枚举值就是当前类的类型，也就是指向本类的对象，默认使用public static final关键字共同修饰，因此采用枚举类型.的方式调用。

• 枚举类可以自定义构造方法，但是构造方法的修饰符必须是private，默认也是私有的。

Enum类的概念和方法

• 所有的枚举类都继承自java.lang.Enum类，常用方法如下：

枚举类实现接口的方式

• 枚举类实现接口后需要重写抽象方法，而重写方法的方式有两种：重写一个，或者每个对象都重写。

案例

public enum DirectionEnum implements DirectionInterface {
    // 2.声明本类类型的引用指向本类类型的对象
    // 匿名内部类的语法格式：接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };
    // public static final Direction UP = new Direction("向上") { 方法的重写 };
    UP("向上") {
        @Override
        public void show() {
            System.out.println("贪吃蛇向上移动了一下！");
        }
    }, DOWN("向下") {
        @Override
        public void show() {
            System.out.println("贪吃蛇向下移动了一下！");
        }
    }, LEFT("向左") {
        @Override
        public void show() {
            System.out.println("左移了一下！");
        }
    }, RIGHT("向右") {
        @Override
        public void show() {
            System.out.println("右移了一下！");
        }
    };

    private final String desc; // 用于描述方向字符串的成员变量

    // 通过构造方法实现成员变量的初始化，更加灵活
    // 1.私有化构造方法，此时该构造方法只能在本类的内部使用
    private DirectionEnum(String desc) { this.desc = desc; }

    // 通过公有的get方法可以在本类的外部访问该类成员变量的数值
    public String getDesc() {
        return desc;
    }

    // 整个枚举类型只重写一次，所有对象调用同一个
    /*@Override
    public void show() {
        System.out.println("现在可以实现接口中抽象方法的重写了！");
    }*/
}

public class DirectionEnumTest {

    public static void main(String[] args) {

        // 1.获取DirectionEnum类型中所有的枚举对象
        DirectionEnum[] arr = DirectionEnum.values();
        // 2.打印每个枚举对象在枚举类型中的名称和索引位置
        for (int i = 0; i < arr.length; i++) {
            System.out.println("获取到的枚举对象名称是：" + arr[i].toString());
            System.out.println("获取到的枚举对象对应的索引位置是：" + arr[i].ordinal()); // 和数组一样下标从0开始
        }

        System.out.println("---------------------------------------------------------------");
        // 3.根据参数指定的字符串得到枚举类型的对象，也就是将字符串转换为对象
        //DirectionEnum de = DirectionEnum.valueOf("向下"); // 编译ok，运行发生IllegalArgumentException非法参数异常
        DirectionEnum de = DirectionEnum.valueOf("DOWN");
        //DirectionEnum de = DirectionEnum.valueOf("UP LEFT"); // 要求字符串名称必须在枚举对象中存在
        //System.out.println("转换出来的枚举对象名称是：" + de.toString());
        System.out.println("转换出来的枚举对象名称是：" + de); // 当打印引用变量时，会自动调用toString方法

        System.out.println("---------------------------------------------------------------");
        // 4.使用获取到的枚举对象与枚举类中已有的对象比较先后顺序
        for(int i = 0; i < arr.length; i++) {
            // 当调用对象在参数对象之后时，获取到的比较结果为 正数
            // 当调用对象在参数对象相同位置时，则获取到的比较结果为 零
            // 当调用对象在参数对象之前时，则获取到的比较结果为 负数
            System.out.println("调用对象与数组中对象比较的先后顺序结果是：" + de.compareTo(arr[i]));
        }

        System.out.println("---------------------------------------------------------------");
        // 5.使用数组中每个DirectionEnum对象都去调用show方法测试
        for (int i = 0; i < arr.length; i++) {
            arr[i].show();
        }
    }
}

public class DirectionTest {

    public static void main(String[] args) {

        /*// 1.声明Direction类型的引用指向该类型的对象并打印特征
        Direction d1 = new Direction("向上");
        System.out.println("获取到的字符串是：" + d1.getDesc()); // 向上

        Direction d2 = new Direction("向下");
        System.out.println("获取到的字符串是：" + d2.getDesc()); // 向下

        Direction d3 = new Direction("向左");
        System.out.println("获取到的字符串是：" + d3.getDesc()); // 向左

        Direction d4 = new Direction("向右");
        System.out.println("获取到的字符串是：" + d4.getDesc()); // 向右

        System.out.println("-------------------------------------");
        Direction d5 = new Direction("向前");
        System.out.println("获取到的字符串是：" + d5.getDesc()); // 向前*/

        //Direction.UP = 2; Error:类型不匹配
        //Direction d2 = null;
        //Direction.UP = d2; Error: final关键字修饰
        Direction d1 = Direction.UP;
        System.out.println("获取到的方向是：" + d1.getDesc()); // 向上

        System.out.println("-------------------------------------");
        // 使用一下Java5开始的枚举类型
        DirectionEnum de = DirectionEnum.DOWN;
        System.out.println("获取到的方向是：" + de.getDesc()); // 向下
    }
}

public class DirectionUseTest {

    // 自定义静态方法实现根据参数指定的字符串内容来打印具体的方向信息
    public static void test1(String str) {
        switch (str) {
            case "向上":
                System.out.println("抬头望明月！"); break;
            case "向下":
                System.out.println("低头思故乡！"); break;
            case "向左":
                System.out.println("左牵黄"); break;
            case "向右":
                System.out.println("右擎苍"); break;
            default:
                System.out.println("没有这样的方向哦！");
        }
    }

    // 自定义静态方法实现根据参数指定的枚举类型来打印具体的方向信息
    public static void test2(DirectionEnum de) {
        switch (de) {
            case UP:
                System.out.println("抬头望明月！"); break;
            case DOWN:
                System.out.println("低头思故乡！"); break;
            case LEFT:
                System.out.println("左牵黄"); break;
            case RIGHT:
                System.out.println("右擎苍"); break;
            default:
                System.out.println("没有这样的方法哦！");
        }
    }

    public static void main(String[] args) {

        DirectionUseTest.test1(Direction.UP.getDesc());
        DirectionUseTest.test1("今天是个好日子！");

        System.out.println("--------------------------------------------");
        DirectionUseTest.test2(DirectionEnum.DOWN);
        //DirectionUseTest.test2("今天是个好日子！"); Error:类型不匹配，减少了出错的可能性
    }
}

5.3 注释

注解的基本概念

• 注解（Annotation）又叫标注，是从Java5开始增加的一种引用数据类型。

• 注解本质上就是代码中的特殊标记，通过这些标记可以在编译、类加载、以及运行时执行指定的处理。

注解的语法格式

• 访问修饰符 @interface 注解名称 {

​ 注解成员;

}

• 自定义注解自动继承java.lang.annotation.Annotation接口。

• 通过@注解名称的方式可以修饰包、类、 成员方法、成员变量、构造方法、参数、局部变量的声明等。

注解的使用方式

• 注解体中只有成员变量没有成员方法，而注解的成员变量以“无形参的方法”形式来声明，其方法名定义了该成员变量的名字，其返回值定义了该成员变量的类型。

• 如果注解只有一个参数成员，建议使用参数名为value，而类型只能是八种基本数据类型、String类型、Class类型、enum类型及Annotation类型。

例

public @interface MyAnnotation {
    //public Direction value(); // 声明一个String类型的成员变量，名字为value   类型有要求
    public String value() default "123"; // 声明一个String类型的成员变量，名字为value
    public String value2();
}

元注解的概念

• 元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其它的注解上面。

• 元注解主要有 @Retention、@Documented、@Target、@Inherited、 @Repeatable。

元注解@Retention

• @Retention 应用到一个注解上用于说明该注解的的生命周期，取值如下：

• RetentionPolicy.SOURCE 注解只在源码阶段保留，在编译器进行编译时它将被丢弃忽视。

• RetentionPolicy.CLASS 注解只被保留到编译进行的时候，它并不会被加载到 JVM 中，默认方式。

• RetentionPolicy.RUNTIME 注解可以保留到程序运行的时候，它会被加载进入到 JVM 中，所以在程序运行时可以获取到它们。

元注解@Documented

• 使用javadoc工具可以从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档，而该工具抽取时默认不包括注解内容。

• @Documented用于指定被该注解将被javadoc工具提取成文档。

• 定义为@Documented的注解必须设置Retention值为RUNTIME。

元注解@Target

• @Target用于指定被修饰的注解能用于哪些元素的修饰，取值如下：

元注解@Inherited

• @Inherited并不是说注解本身可以继承，而是说如果一个超类被该注解标记过的注解进行注解时，如果子类没有被任何注解应用时，则子类就继承超类的注解。

元注解@Repeatable

• @Repeatable表示自然可重复的含义，从Java8开始增加的新特性。

• 从Java8开始对元注解@Target的参数类型ElementType枚举值增加了两个：

• 其中ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中，如：泛型。

• 其中ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。

常见的预制注解

• 常用的预制注解如下：

@Override 限定重写父类方法, 该注解只能用于方法

@Deprecated 用于表示所修饰的元素(类, 方法等)已过时

@SuppressWarnings 抑制编译器警告