目录：
- Java中的关键字
- static关键字
- final关键字
- Java中的权限修饰符
- 代码块
- 构造代码块
- 静态代码块
- 接口
- 接口的介绍
- 接口的定义和特点
- 接口的成员特点
- 接口的案例
- 接口中成员方法的特点
- 枚举
- 随堂小记
- 继承
- 方法重写
- 抽象类
- 模板设计模式
- static
- final
- 权限修饰符
- 接口
- 回顾上午内容：
- static关键字
- final关键字
- 权限修饰符号
- 接口
- 代码块
- 选择语句：
- 枚举
1.Java中的关键字
static关键字
-
static关键字 :
-
静态的意思 , 可以修饰变量 , 也可以修饰方法 , 被static修饰的成员 , 我们叫做静态成员
-
-
static特点 :
-
静态成员被所类的所有对象共享
-
随着类的加载而加载 , 优先于对象存在
-
可以通过对象调用 , 也可以通过类名调用 , 建议使用类名
-
public class Student {
String name;
int age;
static String school;
public void show() {
System.out.println(name + "---" + age + "---" + school);
}
}
/*
static关键字的特点 :
1 静态成员被该类的所有对象的进行共享
2 静态成员可以通过类名调用 , 也可以通过对象进行调用 , 推荐使用类名
3 静态成员随着类的加载而加载 , 优先于对象存在
*/
public class StudentTest {
public static void main(String[] args) {
Student.school = "传智专修学院";
Student s = new Student();
s.name = "张三";
s.age = 23;
s.show();
Student s2 = new Student();
s2.show();
}
}- static内存图解
-
static关键字的注意事项
-
静态方法中只能调用静态成员
-
非静态方法中可以调用任何成员
-
静态方法中不能存在this关键字
-
final关键字
-
final关键字 : 翻译中文代表最终的意思 , 是java的一个关键字 也是一个修饰符 , 可以修饰类 , 可以修饰方法 , 也可以修饰变量
-
final关键字修饰的特点
-
final修饰的类 : 不能被继承 , 没有子类(太监类)
-
fina修饰的方法 : 不能被重写
-
final修饰的变量
-
基本数据类型 : 值不能改变
-
引用数据类型 : 地址不可发生改变 , 对象的属性可改变
-
注意 :
-
被final修饰的变量 , 我们叫做自定义常量 , 命名规范 : 每个字母需要大写 , 多个单词之间用下划线分割
-
final修饰成员变量需要注意初始化时机的问题 , 1) 直接赋值 , 2) 在构造方法执行完毕前赋值
-
-
-
package com.itheima.final_demo;
/*
final的特点
final修饰的类 , 不能被继承, 也就是没有子类
final修饰的方法 , 不能被重写
final修饰的变量
基本数据类型 : 值不可以发生改变
引用数据类型 : 地址不可发生改变 , 对象的内容可以发生改变
注意 :
1 被final修饰的变量 , 我们叫做自定义常量 , 命名规范 : 每个字母需要大写 , 多个单词之间用下划线分割
2 final修饰成员变量需要注意初始化时机的问题
1) 直接赋值
2) 在构造方法执行完毕前赋值
*/
public class FinalDemo1 {
public static void main(String[] args) {
// final修饰的基本数据类型变量 , 值不能被修改
// final int num = 10;
// num = 20;
// System.out.println(num);
final int[] arr = {1, 2, 3, 4, 5};
// final修饰的引用数据类型 , 地址不可改发生改变
// arr = new int[3];
// final修饰的引用数据类型 , 对象中的内容可以发生改变
arr[0] = 100;
}
}
// final修饰的类 , 不能被继承, 也就是没有子类
//final class Person {
//
//}
class Person {
// final修饰的方法 , 不能被重写
public final void eat() {
}
}
class Student extends Person {
// final修饰成员变量需要注意初始化时机的问题
// 要么直接赋值 , 要么在构造方法执行完毕前赋值
// final int num = 10;
final int num;
public Student() {
num = 100;
}
// @Override
// public void eat() {
// super.eat();
// }
}Java中的权限修饰符
- public -- protected -- 默认的 -- private
package com.itheima.permissions_demo1;
/*
public -- protected -- 默认的 -- private
*/
public class Fu {
public void method1() {
}
protected void method2() {
}
void method3() {
}
private void method4() {
}
// 同一个包中同一个类
public void show(){
method1();
method2();
method3();
method4();
}
}
===================================================
package com.itheima.permissions_demo1;
public class Test {
// 同一个包中 , 无关类
public void show(){
Fu f = new Fu();
f.method1();
f.method2();
f.method3();
// f.method4();
}
}
====================================================
package com.itheima.permissions_demo1;
public class Zi extends Fu {
// 用一个包中 , 有子类父关系
public void show(){
method1();
method2();
method3();
// method4();
}
}
package com.itheima.permissions_demo2;
import com.itheima.permissions_demo1.Fu;
public class Test {
// 不同包中 , 无关类
public void show(){
Fu f = new Fu();
f.method1();
// f.method2();
// f.method3();
// f.method4();
}
}
======================================
package com.itheima.permissions_demo2;
import com.itheima.permissions_demo1.Fu;
public class Zi extends Fu {
// 不同包中 , 有子类父关系
public void show(){
method1();
method2();
// method3();
// method4();
}
}
2.代码块
构造代码块
-
构造方法块 : 用一对大括号表示, 定义在类中方法外
-
执行时机 : 每次构造方法执行前, 都会执行构造代码块
-
作用 : 抽取构造方法中共性内容
package com.itheima.code_block;
/*
构造代码块
*/
public class Student {
final int NUM;
{
NUM = 10;
System.out.println("构造代码块...");
}
public Student() {
System.out.println("空参构造...");
}
public Student(int a) {
System.out.println("有参构造...");
}
}
class StudentTest {
public static void main(String[] args) {
Student s = new Student();
Student s2 = new Student(10);
}
}
静态代码块
-
静态代码块 : 在一对大括号前加上static关键字 , 定义在类中方法外
-
执行时机 : 随着类的加载而加载 , 只加载一次
-
作用 : 一般用于给静态成员初始化
package com.itheima.code_block.static_demo;
/*
静态代码块 :
1 定义的位置 : 在一对大括号前加上static , 定义在类中方法外
2 执行时机 ; 随着类的加载而执行, 只加载一次
3 可以给类中的静态成员进行初始化数据
*/
public class Test {
public static void main(String[] args) {
new Student();
new Student(10);
}
}class Student {
static {
System.out.println("静态代码块");
}
public Student() {
System.out.println("空参构造");
}
public Student(int a) {
System.out.println("有参构造");
}
}### 2.3 局部代码块
- 成员代码块 : 用一对大括号表 , 可以定义在任何的局部位置 , 方法中居多
- 执行时机 : 正常执行(从上往下依次执行)
- 控制变量的局部变量的声明周期
```java
package com.itheima.code_block.local_demo;
/*
局部代码块 :
1 位置 : 可以定义任何的局部的位置 , 方法中居多
2 执行时机 : 正常执行(从上往下依次执行)
3 作用 : 控制变量的生命周期 , 变量在使用完毕, 及时释放内存
*/
public class Test {
public static void main(String[] args) {
int num1 = 10;
System.out.println(num1);
// 局部代码块
{
int num2 = 20;
System.out.println(num1);
System.out.println(num2);
}
System.out.println(num1);
// System.out.println(num2);// 作用域不够 , 报错
}
}
3.接口
接口的介绍
-
接口 : 如果一个类中都是抽象方法 , 那么这个类应该是定义规则的类 , 我们应该把此类定义成接口,接口是一种引用数据类型
-
作用 :
-
用于定义规则
-
程序的扩展性
-
接口的定义和特点
-
定义接口的关键字使用interface
-
public interface 接口名{ ... }
-
-
类与接口之间的关系是实现关系 , 用关键字implements进行连接
-
public class 类名 implements 接口名 { ... }
-
-
接口不能实例化
-
接口的子类我们叫做实现类
-
要么重写接口中所有的抽象方法
-
要么实现类是一个抽象类
-
-
注意 : 类与接口的关系是实现关系 , 一个类可以实现多个接口,调用逗号分隔 , 还可以继承一个类的同时 , 实现多个接口
package com.itheima.interface_demo;
public interface Inter {
public abstract void show();
public abstract void method();
}
interface Inter2 {
}package com.itheima.interface_demo;
public class InterImpl extends Object implements Inter ,Inter2{
@Override
public void show() {
}
@Override
public void method() {
}
}package com.itheima.interface_demo;
/*
1 定义接口的关键字使用interface
public interface 接口名{ ... }
2 类与接口的关系是实现关系 , 使用implements进行连接
public class 类名 implements 接口名{ ... }
3 接口不能实例化(不能创建对象)
4 接口的子类,我们叫做实现类
要么重写接口中所有的抽象方法
要么这个实现类是一个抽象类
注意 : 类与接口的关系是实现关系 , 一个类可以实现多个接口
还可以继承一个类的同时 , 实现多个接口
*/
public class InterfaceDemo1 {
public static void main(String[] args) {
// 接口不能实例化(不能创建对象)
// Inter inter = new Inter();
}
}接口的成员特点
-
成员变量 : 都是常量 , 默认修饰符 public static final
-
构造方法 : 没有构造方法
-
成员方法 : 只能是抽象方法 , 默认修饰符public abstract
-
关于JDK8和JDK9版本对接口增加了一些方法新特性
-
package com.itheima.interface_demo;
public interface Inter {
// 是一个常量 , 默认修饰符 public static final
public static final int num = 10;
// 不存在构造方法
// public Inter(){}
public abstract void show();
public abstract void method();
}
interface Inter2 {
}public class InterfaceDemo1 {
public static void main(String[] args) {
// 接口不能实例化(不能创建对象)
// Inter inter = new Inter();
// 成员变量被static修饰
System.out.println(Inter.num);
// 是一个常量 , 只能赋值一次
// Inter.num = 20;
}
}接口的案例
package com.itheima.interface_demo.interface_test;
public interface player {
public abstract void play();
public abstract void pause();
public abstract void stop();
}
package com.itheima.interface_demo.interface_test;
public class MP3 implements player {
@Override
public void play() {
System.out.println("MP3开始播放音乐");
}
@Override
public void pause() {
System.out.println("MP3开始暂停");
}
@Override
public void stop() {
System.out.println("MP3开始关闭音乐");
}
}package com.itheima.interface_demo.interface_test;
public class MP4 implements player {
@Override
public void play() {
System.out.println("MP4播放音乐");
}
@Override
public void pause() {
System.out.println("MP4暂停音乐");
}
@Override
public void stop() {
System.out.println("MP4关闭音乐");
}
}
package com.itheima.interface_demo.interface_test;
/*
需求 :
1 创建一个播放接口 player
2 定义三个抽象方法 , 播放(play),暂停(pause),停止(stop)
3 定义MP3类,MAP4类,手机类,实现接口,重写抽象方法
*/
public class PlayerTest {
public static void main(String[] args) {
MP3 mp3 = new MP3();
mp3.play();
mp3.pause();
mp3.stop();
System.out.println("=============");
MP4 mp4 = new MP4();
mp4.play();
mp4.pause();
mp4.stop();
}
}
接口中成员方法的特点
-
DK8版本之前 : 只能是抽象方法
-
JDK8版本 :
-
默认方法
-
JDK8可以在接口中定义非抽象方法(带有方法体的方法) , 需要使用default进行修饰 , 其实就是默认方法
-
作用 : 解决接口升级的问题
-
格式 : public default 返回值类型 方法名(参数) { ... }
-
注意事项 :
-
默认方法不是抽象方法 , 可以继承 , 也可以重写 , 重写需要去掉default关键字
-
public 可以省略 , default不能省略
-
如果实现类实现了多个接口 , 有相同的方法声明 , 那么实现类必须重写该方法
-
-
-
静态方法
-
JDK8可以在接口中定义静态方法 , 也是有方法体的方法
-
作用 : 方便调用此功能
-
格式 : public static 返回值类型 方法名(参数){ ... }
-
注意事项
-
静态方法只能通过接口名调用 , 不能通过实现类名字和对象调用
-
public可以省略 , static不能省略
-
-
-
-
JDK9版本 :
-
私有方法
-
JDK9中新增私有方法
-
作用 : 抽取默认方法中共性内容
-
格式 : private 返回值类型 方法名(参数){ ... }
-
注意 : 要想抽取静态方法中的共性内容 , 需要对私有方法加上关键字static
-
-
4.枚举
-
枚举 : 当一个变量有几种固定可能的取值时，就可以将它定义为枚举类型
-
作用 : 更贴切 , 加见名之意
-
定义 : public enum 枚举名{ ... }
-
使用 : 通过枚举类型名直接引用枚举项即可，例如Sex.BOY、Sex.GIRL 注意 : 每个枚举项都相当于枚举的对象
-
案例代码
package com.itheima.enum_demo;
public enum Sex {
// 每一个枚举项都是枚举的对象
GIRL("女孩"), BOY("男孩"), YAO;
// 成员变量
private String name;
// 空参构造方法
private Sex() {
}
// 有参构造方法
private Sex(String name) {
this.name = name;
}
// 成员方法
public String getName() {
return name;
}
}
class Test {
public static void main(String[] args) {
System.out.println(Sex.GIRL.getName());
System.out.println(Sex.BOY.getName());
System.out.println(Sex.YAO.getName());
}
}-
枚举的本质 :
-
枚举其实本质上是一个类，每一个枚举项是本枚举类类型的一个对象。我们可以使用JDK提供的反编译命令，将枚举的字节码进行反编译查看
-
枚举本质上就是最终类
-
枚举项，就是枚举类的对象，而且是静态的常量。
-
有私有的构造方法
-
静态代码块
-
继承了lang包下的Enum
-
-
-
组成部分 :
-
构造器，成员方法，成员变量等 , 但是定义的成分一定要在枚举项之后，而且最后一个枚举项必须要有分号结束。
-
5. 随堂小记
继承
//什么是继承？
让一个类继承另一个类就是继承。使用关键字：extends进行继承
//继承解决程序中什么问题？（核心）
1. 继承可以建立类与类之间的关系
2. 继承可以提高程序中代码的复用性（子类在继承父类后，就可以直接使用父类中的非私有成员）
//继承怎么使用？（核心）
public class 父类{
}
public class 子类 extends 父类{
}
//继承在使用中的注意事项
1、继承只能单一继承(不支持多继承)，允许多层次继承
2、不能继承父类中私有的成员
3、继承中成员的访问原则：就近原则（子类有中，就使用子类自己的，子类中没有，去父类中找）
4、子类对象在初始化时，需要先初始化父类对象（只有父类初始化完成，子类才可以访问父类中的成员）
问题：子类怎么做到在创建对象时，先把父类初始化？
答案：子类的构造方法中，默认第一行都有隐藏代码super()//调用父类无参构造方法方法重写
//什么是方法重写？
子类中存在和父类中一模一样的方法，称为：方法重写
//方法重写解决程序中什么问题？
当父类中的方法，不能满足子类的需求，子类可以重写父类中的方法
//方法重写怎么使用？
public class 父类{
public void method(String name){
}
}
public class 子类 extends 父类{
@Override //和父类一模一样的方法
public void method(String name){
}
}
//方法重写在使用中的注意事项
1. 不能对父类中的私有方法进行重写
2. 子类中的方法必须和父类中的方法一模一样 抽象类
什么是抽象类？
//抽象类解决程序中什么问题？
1. 当某个不希望被创建对象，可以使用abstract修饰为抽象类（仅仅只是做为父类使用）
2. 当某些方法无法书写具体的方法体代码时，把这些方法修饰为抽象方法，书写在抽象类中
//抽象类怎么使用？
public abstract class 抽象类名{
}
//抽象类在使用中的注意事项
1、抽象类不能实例化（不能创建对象）
2、抽象类比普通类多了一个抽象方法（普通类可以书写的内容，都可以书写在抽象类中）
抽象类中可以书写构造方法（目的：为了保障子类对象创建成功）
3、抽象类中的所有抽象方法，在子类中都要重写（另一种：子类也做为抽象类） 模板设计模式
//模板设计模式解决程序中什么问题？
当程序中有固定的执行流程了，但流程中的某个或某些点，在不确定时，就可以使用模板设计模式
//模板设计模式的使用
public abstract class 模板设计模式的抽象类{
public void 固定执行流程的方法(){
//1、固定流程格式
//2、固定流程格式
//3、不确定（定义为抽象方法）
//4、不确定（定义为抽象方法）
//5、固定流程格式
//6、不确定（定义为抽象方法）
}
public abstract 返回值类型 抽象方法();//3、不确定（定义为抽象方法）
public abstract 返回值类型 抽象方法();//4、不确定（定义为抽象方法）
public abstract 返回值类型 抽象方法();//6、不确定（定义为抽象方法）
} static
什么是static？
static是java语言中的修饰符关键字
用来修饰：成员变量、成员方法static解决程序中的什么问题？
当程序中的某个数据需要共享时使用static修饰static怎么使用？
public class Student{
//成员变量
private String name;
private static String city;//静态成员变量
//静态成员方法
public static void method(){
}
}
//通过类名访问静态内容（静态的私有成员变量不能访问）static在使用中的注意细节
1、静态内容是随着类的加载就存在了（早于对象创建）
2、静态内容通常是使用： 类名.成员变量 类名.成员方法()
3、静态方法中只能访问静态成员（静态变量、静态方法）
4、静态方法中不能使用this关键字
5、非静态方法中可以直接访问：静态成员JVM内存划分:
-
栈
-
堆
-
方法区
-
是由N多个不同功能的小区域组成的
-
静态区域：存放静态内容
-
非静态区域：存放非静态内容
-
字符串常量池：存放字符串常量
-
-
-
寄存器
-
本地方法区
final
final是什么？
final是java语言中的修饰符关键字
用来修饰：类、变量、方法
final关键字的含义：最终的、不可改变的 final解决程序中什么问题？
1、当某个变量不允许修改数据值时，可以使用final修饰变量
2、当某个方法不允许被子类重写时，可以使用final修饰方法
3、当某个类不允许被继承时，可以使用final修饰类。 举例：String类final怎么使用？
public final class 类名{
private final int COUNT=100;
public final void method(){
}
}final在使用中的注意细节
final和abstract不能共存使用权限修饰符
权限修饰符是什么？
权限修饰符是java语言中的关键字，用于修饰：类、变量、方法
权限修饰符：private 、public 、protected、默认(什么都不写)权限修饰符号解决什么问题？
限制程序中的访问权限（类的访问权限、变量的访问权限、方法的访问权限）权限修饰符怎么使用？
//类（权限：公开的 [没有限制]）
public class 类{
//成员变量（私有权限：本类中使用）
private String name;
//默认权限（权限：当前包下的任意类）
void show(){
}
//protected（权限：子类）
protected void method(){
}
}
从小到大排序：
1. private //访问范围： 仅现本类中访问
2. 默认 //访问范围： 只能在同一个包下的类
3. protected //访问范围： 同一个包下的任意类 或 不同包下的子类
4. public //访问范围 ：没有限制权限修饰符在使用中的注意细节？
//方法重写时：保障子类中重写访问的访问权限必须 >= 父类中方法的权限在开发中经常会使用或开发：工具类
-
工具类的特点：
-
不能被继承
-
不能让其他类创建对象
-
提供静态方法
-
//final保障 ：工具类不能被继承
public final class 工具类{
//不能让其他类创建对象
private 工具类(){}
//给外部提供：静态方法
public static 返回值 静态方法(...){
}
}问题：在一个类中可以书写哪些内容？
public class 类{
//成员变量：静态、非静态
//成员方法：静态、非静态、抽象
//构造方法
//代码块
}代码块：
{
}代码块划分：
-
静态代码块 //开发中使用最多
-
书写位置：在类中方法外（和成员变量、成员方法属于同一级）
-
在构造代码块上添加：static
-
-
特点：随着类的加载，执行1次静态代码块（类只会被加载1次）
-
作用：用于对静态成员数据进行初始化
-
-
构造代码块
-
书写位置：在类中方法外（和成员变量、成员方法属于同一级）
-
特点：在每个构造方法执行前，都会先执行构造代码块
-
作用：当类中多个构造方法中有共性内容时，可能抽取到构造代码块
-
-
局部代码块
-
书写位置：写在方法体中
-
特点：在方法执行时，才会调用
-
作用：用于作用域
-
接口
接口的作用：制定规则
制定规则的两种方案：
-
定义类，类中书写抽象方法（不建议使用。 类只能单一继承）
-
定义接口， 接口中书写抽象方法（接口好处：可以多实现）
接口的定义：
public interface 接口名{
//抽象方法
}
接口的特点：
-
接口不能实例化（不能创建对象）
-
接口中没有构造方法（接口只能通过子类来实现对象创建）
-
接口可以多实现（ 一个类可以实现多个接口[解决类只能单一继承的问题] ）
按照接口中定义的规则开发子类： 编写接口实现类
public class 接口实现类 implements 接口{
//重写接口中所有的抽象方法
} 接口的多实现：
public class 接口实现类 implements 接口1 , 接口2 , 接口3 {
//重写所实现接口中所有的抽象方法
} 在接口可以书写的内容：
public interface 接口名{
//抽象方法
//静态常量
public static final int NUMBER = 10;
}思考：静态常量在程序中做什么呢？
问题：生活中有没有一些数据是固定的，且值比较单一？
示例：性别（固定、且仅有2个值）
public interface Gender{
public static final String BOY = "男";
public static final String GIRL = "女";
}
//程序中需要给性别赋值
String sex = Gender.BOY;
String sex = Gender.GIRL;接口中的方法的升级：
-
随着JDK版本的升级
-
在jdk1.8版本中新增：默认方法、静态方法 //有方法体代码
-
在jdk1.9版本中新增：私有方法 //有方法体代码
-
类和接口的概念：
类和类之间的关系： 继承 （只能单一继承）
public 子类 extends 父类{
}
类和接口之间的关系：实现
public 子类 implements 接口{
}
接口和接口之间的关系：继承 （允许多继承）
public 接口1 extends 接口2 {
//问题：为什么接口可以多继承？
//答案：接口中仅仅只是定义功能（没有功能的实现，子类要自己实现功能）
}
接口和抽象类的相同之处：
-
接口和抽象类， 都不能实例化（不能创建对象）
-
接口和抽象类，都具有抽象方法
-
接口和抽象类，都是做为父类型存在的
抽象类和接口的区别：
-
抽象类：除了抽象方法外，还具有成员变量、构造方法、非抽象方法
-
接口：除了抽象方法外，只有常量 （JDK8：默认方法、静态方法）（JDK9：私有方法）
回顾上午内容：
static关键字
//static是什么？
static是java语言中的修饰符关键字。用来修饰：变量、方法
//static解决程序中的什么问题？
static可以让数据进行共享（多个对象可以使用同一个数据）
//static的使用
public class 类{
//静态成员变量
public static int count;
//静态成员方法
public static void method(){
}
}
通过类名访问：静态成员
类名.count = 100;
类名.method();
//static在使用中的细节
1. static修饰的内容是随着类的加载而存在的（早于对象的创建）
2. static修饰的内容是存储在方法区的静态区别下（仅此一份）
3. static修饰的静态方法中，只能访问静态成员
4. static修饰的静态方法中，不能使用this关键字
5. 非静态方法中可以访问：静态方法、静态变量final关键字
//final是什么？
final是java语言中的修饰符关键字。用来修饰：类、方法、变量
//final可以解决程序中什么问题？
final修饰的类：不能被继承
final修饰的方法： 不能被重写
final修饰的变量： 初始化值后不能改变其值（常量）
//final的使用
public final class 类名{
//变量
final String name="初始化值";
//方法
public final void method(){
}
}权限修饰符号
//权限修饰符解决什么问题？
限制程序中访问权限
//权限修饰符
private 、默认（什么都不写）、protected 、 public
private ： 仅限本类中使用
默认（什么都不写） ： 同一个包下的任意类
protected ： 同一个包下的任意类 、 不同包下的子类
public ： 没有限制 接口
//接口的作用：
制定规则
//接口的定义（语法）
public interface 接口名{
//抽象方法
public abstract boolean login(String name, String password);
}
//接口的实现（语法）
public class 接口实现类 implements 接口名{
//重写：抽象方法
public boolean login(String name , String password){
......
return boolean类型的值;
}
}
//接口的特点：
1、接口不能实例化（不能创建对象）
2、接口中没有构造方法
3、接口可以多实现（解决类只能单一继承的问题）
实现类 可以在继承一个父类的情况下，还可以实现多个接口
public class 子类 extends 父类 implements 接口A , 接口B{
//重写所有抽象方法
}代码块
代码块：局部代码块、构造代码块、静态代码块
构造代码块作用：当类中构造方法里面有共性内容时，可以抽出到构造代码块中
每次构造方法执行前，都会先执行构造代码块
静态代码块：
static{
//特点：静态代码块是随着类的加载执行（执行1次）
//作用：初始化数据（数据必须在创建对象之前就初始化完成）
} 选择语句：
switch( 常量表达式 ){ //只能使用：byte、short、int、char、String、枚举
case 常量值1:
语句1;
break;
...
}枚举
//什么是枚举
在java语言中，枚举是一种数据类型。枚举用来表示：固定且仅有几种取值范围的数据
例：性别
public interface Gender{
public static final String BOY="男";
public static final String GIRL="女";
}
public class Student{
private String name;
private String sex;
public Student(String name , String sex){
this.name = name;
this.sex = sex;
}
}
Student stu = new Student("熊大", Gender.BOY);
Student stu = new Student("熊二", "男女");//不会报错
解决方案： 枚举类型
//枚举解决程序中的什么问题？
当程序中有数据是固定且只有几种取值范围时，使用枚举类型强制设置值的范围（赋值数据有保障）
//枚举怎么使用？
public enum Gender{
BOY , GIRL;
}
public class Student{
private String name;
//使用枚举类型
private Gender gender;
public Student(String name , Gender gender){
this.name = name;
this.gender = gender;
}
}
Student stu = new Student("熊二", "男女");//报错。原因：性别类型必须是Gender枚举
Student stu = new Student("熊二", Gender.BOY);//正确（保障数据的合法有效性）
//枚举在使用中的注意细节
1. 枚举本质是一个类
2. 在枚举中除了可以书写：固定选项值外，还可以书写：成员变量、私有构造方法、成员方法
