java随堂小记
java随堂小记
- static
- final
- 权限修饰符
- 接口
- 多态
- JavaSE进阶
- 数据库
- 前端技术
- web开发
- 框架技术
- 项目1
- 微服务技术
- 项目2
- 项目3
面向对象三大特征：
- 封装
- 继承
- 多态
学习技巧：
问题1：什么是继承
继承发生前提：当多个类中有相同的属性和行为时，把这些相同的属性和行为，抽取出来封装一个独立的类中
在Java中使用继承(extends)，来继承这些封装了公共属性和行为的类（父类）
继承：有父类、有子类
结论：让一个类(子类、派生类)继承另一个类(父类、超类、基类)
问题2：继承解决程序中的什么问题？
1、程序中代码的复用性（重复的代码抽取出来，封装到父类中，子类继承后就可以直接使用）
2、建立类和类之间的关系
问题3：继承怎么使用？ //写代码
public class 父类{
//共性成员
}
public class 子类 extends 父类{
//子类可以使用父类中定义的内容
}
问题4：继承在使用中有使用注意细节
1、Java只能单一继承(不能多继承)，允许多层次继承
2、在子类继承父类后，就直接可以父类中非私有的成员（成员变量、成员方法）
3、在继承中，访问成员变量或成员方法的原则：就近原则（先在子类中查找，子类没有再去父类中查找）
super.父类中的成员变量
super.父类中的成员方法
4、当父子类中存在一模一样的成员方法时，这种情况称为：方法重写
5、在继承中，要先初始化父类对象（ 通过子类构造方法中的super()来调用父类的无参构造 ）
//调用父类有参构造方法： super(参数,....);
方法的体现：
- 重载
- 在本类中发生
- 方法名相同
- 方法的参数列表不同（类型不同、数量不同、顺序不同）
- 和返回值没有任何关系
- 重写
- 发生在父子类(继承)中
- 子类中的方法和父类的方法一模一样
方法重写：
- 什么是方法重写
- 方法重写解决什么问题
- 方法重写怎么实现
- 方法重写有什么注意细节
this关键字的使用：
//访问本类中的成员变量
this.成员变量名=数据值;
//访问本类中的成员方法
this.成员方法();
//访问本类中的构造方法（要求：只能使用某个构造方法，去调用本类中另一个构造方法）
public ClassName(){
}
public ClassName(String name){
this(); //调用无参构造方法
}
学习套路：
- 这个技术是什么？
- 这个技术可以解决什么问题？ （重点）
- 这个技术怎么使用？ （重点）
- 这个技术在使用中的注意细节
回顾上午内容：
-
继承
-
继承是什么
让一个类继承另一个类 关键字：extends -
继承可以解决什么问题
1、建立类与类之间的关系：父子关系 2、可以解决程序中代码的复用性（子类可以直接使用父类中的非私有成员） -
继承怎么使用
public class 父类{ //成员 } public class 子类 extends 父类{ //子类可以直接使用父类中的非私有成员 } -
继承在使用中的注意细节
1、Java语言只支持单一继承(不能多继承) ， 允许多层次继承 2、子类不能继承父类中的私有成员 3、当子类和父类中存在相同的成员时，访问原则：就近原则 super.成员变量 super.成员方法() super() super(参数, ...) 4、子类对象在实例化完成之前，必须先初始化父类对象（只有父类初始化完成后子类才可以访问父类成员） //子类构造方法在执行时，有隐藏代码：super() //默认调用父类中的无参构造方法
-
-
方法重写
-
什么是方法重写
当父子类中存在一模一样的非私有成员方法时，就可以称为：子类重写父类的方法（方法重写） -
方法重写可以解决什么问题
当父类中的方法，子类在调用时无法满足子类的要求，就可以在子类中重写父类的方法 目的： 1. 为后面学习多态准备 2. 不愿意在起一个方法名 -
方法重写怎么使用
public class 父类{ public void show(String name){ .... } } public class 子类 extends 父类{ //重写方法 @Override public void show(String name){ //重新编写方法体业务代码 } } -
方法重写的注意细节
1、针对父类中私有方法不能重写 2、必须和父类中的方法一模一样
-
JVM内存划分：
- 栈 //方法运行在栈内存中
- 堆 //对象存储于堆内存中
- 方法区 //存放加载的.class文件 //方法区有由N多个不同功能的小区域组成
- 寄存器
- 本地方法区
this：当前类对象引用
this.成员方法()
this.成员变量 = 数据值
this() //本类无参构造方法
this("字符串")//本类带有String类型参数的构造方法
super：父类对象引用
super.成员方法()
super.成员变量 = 数据值
super() //父类无参构造方法
super("字符串")//父类带有String类型参数的构造方法
//父类：动物类
public abstract class Animal{
//抽象方法：必须使用关键字abstract修饰
//抽象方法：必须书写在抽象类中
public abstract void eat();//在java语言中没有方法体的方法，称为：抽象方法
}
普通类:
public class 类名{
//成员变量
private String name;
//成员方法
public void setName(String name){
this.name = name;
}
//构造方法
public 类名{
}
}
抽象类：
public class 类名{
//成员变量
private String name;
//成员方法
public void setName(String name){
this.name = name;
}
//构造方法
public 类名{
}
//抽象方法
public abstract void 抽象方法();
}
- 抽象类，不能实例化（不能创建对象）
- 疑问：既然不能创建对象了，为什么还要有构造方法？
- 抽象类通常是用于父类，创建子类对象时，需要先初始化父类（抽象方法中构造方法的作用就是用于父类初始化使用）
- 疑问：既然不能创建对象了，为什么还要有构造方法？
- 抽象类中的抽象方法，必须由子类重写
什么是设计模式？
- 设计模式，就是一种解决方案（解决开发中某个问题的方案）
设计模式解决什么问题？
- 在开发中一些常见问题，可以使用设计模式解决
模板设计模式：
- 模板：就一个固定的格式
- 模板设计：把确定的内容，提前准备好，把不确定的内容，定义为抽象方法（由子类重写）
创建对象：
Student stu = new Student(); //有名字的对象
//对象名： stu
匿名对象：
- 没有名字的对象
new Student(); //创建的对象没有名字
new Student("张三",23);
回顾上次课程内容：
-
继承
//什么是继承？ 让一个类继承另一个类就是继承。使用关键字：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多个不同功能的小区域组成的
- 静态区域：存放静态内容
- 非静态区域：存放非静态内容
- 字符串常量池：存放字符串常量
- 是由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次） //作用：初始化数据（数据必须在创建对象之前就初始化完成） }工具类的书写规则：
-
工具类，修饰为final（不让继承）
-
工具类的构造方法，设置为private（不让其他类创建对象）
-
工具类中提供：静态方法（通过类名访问）
static关键字
-
解决程序中什么问题？
静态变量：共享数据 静态方法：工具类中方法的编写 -
怎么使用
public class 类{ static 类型 变量名; public static 返回值类型 方法名(参数, ..){ } } 类名.静态变量名=100; 类名.静态方法名(); -
细节：
- 静态内容是随着类的加载，存放在方法区的静态区域下（仅有一份）【早于对象创建】
- 静态方法中不能使用this关键字
- 静态方法只能访问静态内容（静态变量、静态方法）
final关键字
- final修饰的类， 不能继承
- final修饰的方法， 不能被重写
- final修饰的变量， 初始化值后不能修改其值（变为常量）
代码块：
static{
//在对象创建之前，初始化数据
}
接口：
-
接口的作用：制定规则
-
接口的使用
-
接口定义（制定规则）
public interfce 接口名{ //常量 public static final String 常量名 = 值; //抽象方法(制定规则) public abstract 返回值类型 方法名(参数, ...); } -
接口实现（按照规则实现代码）
public 接口实现类 implements 接口名{ //重写接口中的抽象方法 }
-
问题：在继承时，子类可能把父类的构造方法继承了吗？
答案：不可以。
枚举：
-
解决什么问题？
当程序中的某个数据有固定在一定范围的取值时，为保障程序中数据的有效性，可以使用：枚举 -
使用方式：
public enum 枚举名{ 固定选项值1,固定选项值2,...; } 枚举名.选项值; public enum Sex{ BOY,GIRL; } public class Student{ private Sex sex; } Student stu = new Student( Sex.BOY )
多态
什么是多态？
多态：多种形态
多种形态：
同一个对象，在不同时刻表现出来的不同形态
Cat extends Animal
第一种形态： Cat c1 = new Cat(); //c1是只猫
第二种形态： Animal c2 = new Cat(); //c2是个动物
举例：
数字2
10进制：2
2进制： 00000010
多态解决程序中的什么问题？
1、提高代码的复用性
2、提高代码的扩展性
public interface Player{
public void play();
public void stop();
}
public MP3 implements Player{
public void play(){
System.out.println("mp3播放")
}
public void stop(){
System.out.println("mp3停止")
}
}
public MP4 implements Player{
public void play(){
System.out.println("mp4播放")
}
public void stop(){
System.out.println("mp4停止")
}
}
public static void main(String[] args){
MP3 mp3 = new MP3();
method( mp3 )
MP4 mp4 = new MP4();
method( mp4 )
}
//多态的体现： Player p = new MP3 / MP4 ();
public static void method( Player p )// Player p = new MP4()
{
p.play();
p.stop();
}
//集合： ArrayList类 implements List接口 、 LinkedList类 implements List接口
List list = new LinkedList();
多态的使用
//多态的代码体现格式：
父类型 对象 = new 子类(); //大类型包含小类型 int a=10; long b = a;
多态在使用时的注意细节
- 多态中：父类和子类拥有一模一样的成员变量时：
- 编译时：以父类型中的成员变量为主
- 运行时：使用父类中的成员变量
- 多态中：父类和子类拥有一模一样的成员方法时：
- 编译时：以父类中的成员方法为主（检查父类中有没有这个成员方法，没有：报错）
- 运行时：以子类中的成员方法为主（调用子类对象中重写后的成员方法）
多态转型
-
向上转型（自动类型提升）
//基础班： int a =10; long num = a; //多态： 父类型 父引用 = new 子类(); //子类型变为：父类型 （弊端：父引用不能使用子类特有成员） -
向下转型（强制类型转换）
//解决的问题： 父引用不能使用子类中特有成员 //基础班： long a =100L; int b = (int) a; //多态的向下转型： 子类 对象 = (子类) 父引用;-
注意细节：
-
向下转型时容易发生：java.lang.ClassCastException（类型转换异常）
解决方案：instanceof
if( 父引用对象 instanceof 子类型 ){ 子类型 对象 = (子类型)父引用对象; 对象.特有成员 }
-
-
多态代码的书写：
-
创建对象
//父类型 父引用 = new 子类() Father f = new Son(); -
作为参数
public void method( Father f ) { f.方法() } -
作为返回值
public Animal getInstance() { //返回：子类对象 return new Cat(); }
内部类：
public class HelloWorld{
//成员变量
//成员方法
//在一个类中，定义了另外一个类（内部类[成员内部类]）
class Hello{
}
}
问题：如何访问某个类中的成员变量or成员方法？
答案：创建类的对象，通过"对象名.成员"的方式访问
匿名内部类：
-
解决程序中什么问题？
简化程序中代码的书写 -
怎么使用？
//语法格式： new 类名/接口(){ //重写方法 } //示例： public class Father{ public String sayHello(String name){ return "早上好, "+ name; } } //此时：程序的需求发生改变，要求sayHello方法的返回值为"你好,名字" public class Son extends Father{ //重写sayHello方法 public String sayHello(String name){ return "你好, "+name; } } //以下代码使用匿名内部的方式（其实本质就是一个子类对象） new Father(){ //把父类中的方法重写 public String sayHello(String name){ return "晚上好,"+name; } }
工具类：为解决某些特定问题，特意编写的公共类（程序员都可以使用）
- JDK(java开发工具包) = JRE + 核心类库
- 核心类库： jdk提供一些现成的功能，这些功能封装在不同的类中
- JDK就提供了一些工具类：Math、Arrays
- Arrays工具类：针对数组，提供了一系列现成的功能（例：排序）
回顾上午内容：
-
多态
//多态可以解决程序中什么问题？ 1、提高程序中代码的复用性 2、提高程序中代码的扩展性 //多态怎么使用？ //1、创建一个对象 父类型 父引入 = new 子类(); //2、作为参数 public void method(父类型 父引用){ 父引用.成员方法() } //3、作为返回值 public 父类型 getInstance(){ return 子类对象; } //多态在使用中的细节 父子类中有相同的成员变量时：编译和运行都以父类型中的成员变量为主 父子类中有相同的成员方法时：编译时检查父类型中的成员方法是否存在 运行时以子类对象中的重写的方法为主 //多态的转型 向上转型： 父类型 父引入 = new 子类(); //弊端：父引用不能访问子类对象中特有成员 向下转型： 子类 对象 = (子类) 父引用; //向下转换后，可以访问子类对象中特有成员 在向下转型时容易发生：ClassCastException 异常 使用：instanceof 避免 ClassCastException异常发生 if(父引用 instanceof 子类类型){ 子类 对象 =(子类) 父引用; } -
匿名内部类
//匿名内部类解决什么问题？ 简化程序中的代码 //匿名内部类的使用 父类型 父引用 = new 父类/接口(){ //重写父类型中的方法 }; //作为参数 public void show( Flyable fly ); show( new Flyalbe(){ //重写方法 } ); //作为返回值 public Flyable getInstance(){ return new Flyable(){ //重写方法 }; }
在Java继承体系中，有一个顶层父类：Object（鼻祖类）
- 在java语言中，程序员自定义的类或者jdk中存在的类，直接或间接都要继承Object
- 继承了Object类后，就可以使用Object提供的相关方法：
- boolean equals(Object obj)
- boolean： 方法的返回值类型
- Object： 方法传递参数的类型
- 作用：比较两个对象是否相同（比较两个对象的地址值是否相同）
- String toString()
- 作用： 把对象转换为字符串
- boolean equals(Object obj)
比较两个字符串是否相同 ：
//方案1： String类中的equals方法
boolean result = 字符串1.equals(字符串2);
//方案2：Objects工具类中的equals方法
boolean result = Objects.equals(字符串1 , 字符串2);
区别：Objects工具类中的equals方法 可以避免NullPointerException异常的发生
日期类型的数据：
public class Emp
{
//姓名
private String name;//String表示字符串
//年龄
private int age;//int表示整数
//生日
private Date birthday;//Date表示日期
}
Date类：
-
归属包：java.util
-
作用：表示日期时间（精确到毫秒）
-
使用：
-
构造方法（创建对象）
public Date() public Date(long time) -
常用方法
-
DateFormat类
//DateFormat类是什么
DateFormat类是java语言提供的日期格式化类
//DateFormat类解决什么问题
对日期进行格式化操作：Date类型 -> String类型 => String format(Date)
对日期进行解析操作：String类型 -> Date类型 => Date parse(String )
//DateFormat类怎么使用
java.text.DateFormat
DataeFormat是一个抽象类，无法实例化。使用子类：SimpleDateFormat
DateFormat df = new SimpleDateFormat("日期模板");
//日期模板：就是使用一些特定的字符，来表示某个日期。例：yyyy表示全年 MM表示月 dd表示日
DateFormat df = new SimpleDateFormat("yyyy/MM/dd");
DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String format(Date date) //将Date类型的数据，按照日期模板，转换为字符串
Date parse(String s) //将日期格式的字符串数据，按照日期模板，转换为Date对象
Calendar类：日历类（存储的有日期、时间、日历信息）
- 代替java.util.Date类中的过期方法
//Calendar类的使用： 构造方法、 常用方法
//Calendar类是一个抽象类，无法创建对象。 子类：GregorianCalendar
//在Calendar类中，提供了一个静态方法，该静态方法可以实现：Calendar对象的实例化（底层还是使用GregorianCalendar子类）
//获取Calendar类对象
Calendar c = Calendar.getInstance();
Calendar对象中存储的内容：
java.util.GregorianCalendar[
time=1667208388632,
areFieldsSet=true,
areAllFieldsSet=true,
lenient=true,
zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",
offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null],
firstDayOfWeek=1,
minimalDaysInFirstWeek=1,ERA=1,
YEAR=2022,
MONTH=9, //月份：0~11
WEEK_OF_YEAR=45,
WEEK_OF_MONTH=6,
DAY_OF_MONTH=31,
DAY_OF_YEAR=304,
DAY_OF_WEEK=2,DAY_OF_WEEK_IN_MONTH=5,AM_PM=1,
HOUR=5,
HOUR_OF_DAY=17,
MINUTE=26,
SECOND=28,
MILLISECOND=632,
ZONE_OFFSET=28800000,DST_OFFSET=0]
获取Calendar对象中存储的数据：
//API方法： public int get(int 字段名) //字段名：YEAR MONTH DAY_OF_MONTH
在Calendar类中有一些静态常量： YEAR MONTH DAY_OF_MONTH
Calenar.YEAR Calendar.MONTH
//获取日历对象中的年
Calendar c = Calendar.getInstance();
int year = c.get( Calenar.YEAR )
给日历对象设置具体的：年月日时分秒…
//获取日历对象中的年
Calendar c = Calendar.getInstance(); //日历对象是基于当前系统日期时间获取的
//修改日历对象中的信息 public void set(int 字段 , int 数值)
c.set( Calendar.YEAR , 2000 );
//修改日历对象中的年月日
c.set( 2000, 9, 31 );
给日历对象中的信息，增加或减少
public void add(int 字段 ， int 数值) //数值是负数是减少 ， 数据是正数表示增加
选择语句：
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. 在枚举中除了可以书写：固定选项值外，还可以书写：成员变量、私有构造方法、成员方法