怎么在建设银行网站更新身份证做个电商平台要多少钱

• JavaSE进阶
• 数据库
• 前端技术
• web开发
• 框架技术
• 项目1
• 微服务技术
• 项目2
• 项目3

面向对象三大特征：

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(参数,....);

方法的体现：

1. 重载
   • 在本类中发生
   • 方法名相同
   • 方法的参数列表不同（类型不同、数量不同、顺序不同）
   • 和返回值没有任何关系
2. 重写
   • 发生在父子类(继承)中
   • 子类中的方法和父类的方法一模一样

方法重写：

1. 什么是方法重写
2. 方法重写解决什么问题
3. 方法重写怎么实现
4. 方法重写有什么注意细节

this关键字的使用：

//访问本类中的成员变量
this.成员变量名=数据值;//访问本类中的成员方法
this.成员方法();//访问本类中的构造方法（要求：只能使用某个构造方法，去调用本类中另一个构造方法）
public ClassName(){}
public ClassName(String name){this(); //调用无参构造方法
}

学习套路：

1. 这个技术是什么？
2. 这个技术可以解决什么问题？ （重点）
3. 这个技术怎么使用？ （重点）
4. 这个技术在使用中的注意细节

回顾上午内容：

• 继承

  • 继承是什么

    让一个类继承另一个类
    关键字：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 父类{//重写方法@Overridepublic void show(String name){//重新编写方法体业务代码}
    }
    

  • 方法重写的注意细节

    1、针对父类中私有方法不能重写
    2、必须和父类中的方法一模一样
    

JVM内存划分：

1. 栈 //方法运行在栈内存中
2. 堆 //对象存储于堆内存中
3. 方法区 //存放加载的.class文件 //方法区有由N多个不同功能的小区域组成
4. 寄存器
5. 本地方法区

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

回顾上次课程内容：

1. 继承

   //什么是继承？
   让一个类继承另一个类就是继承。使用关键字：extends进行继承//继承解决程序中什么问题？（核心）
   1. 继承可以建立类与类之间的关系
   2. 继承可以提高程序中代码的复用性（子类在继承父类后，就可以直接使用父类中的非私有成员）    //继承怎么使用？（核心）
   public class 父类{}
   public class 子类 extends 父类{}//继承在使用中的注意事项
   1、继承只能单一继承(不支持多继承)，允许多层次继承
   2、不能继承父类中私有的成员
   3、继承中成员的访问原则：就近原则（子类有中，就使用子类自己的，子类中没有，去父类中找）
   4、子类对象在初始化时，需要先初始化父类对象（只有父类初始化完成，子类才可以访问父类中的成员）问题：子类怎么做到在创建对象时，先把父类初始化？答案：子类的构造方法中，默认第一行都有隐藏代码super()//调用父类无参构造方法
   

2. 方法重写

   //什么是方法重写？
   子类中存在和父类中一模一样的方法，称为：方法重写//方法重写解决程序中什么问题？
   当父类中的方法，不能满足子类的需求，子类可以重写父类中的方法//方法重写怎么使用？
   public class 父类{public void method(String name){}
   }
   public class 子类 extends 父类{@Override //和父类一模一样的方法public void method(String name){}
   }    //方法重写在使用中的注意事项
   1. 不能对父类中的私有方法进行重写
   2. 子类中的方法必须和父类中的方法一模一样    
   

3. 抽象类

   什么是抽象类？//抽象类解决程序中什么问题？
   1. 当某个不希望被创建对象，可以使用abstract修饰为抽象类（仅仅只是做为父类使用）
   2. 当某些方法无法书写具体的方法体代码时，把这些方法修饰为抽象方法，书写在抽象类中    //抽象类怎么使用？
   public abstract class 抽象类名{}//抽象类在使用中的注意事项
   1、抽象类不能实例化（不能创建对象）
   2、抽象类比普通类多了一个抽象方法（普通类可以书写的内容，都可以书写在抽象类中）抽象类中可以书写构造方法（目的：为了保障子类对象创建成功） 
   3、抽象类中的所有抽象方法，在子类中都要重写（另一种：子类也做为抽象类）    
   

4. 模板设计模式

   //模板设计模式解决程序中什么问题？
   当程序中有固定的执行流程了，但流程中的某个或某些点，在不确定时，就可以使用模板设计模式//模板设计模式的使用
   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内存划分:

1. 栈
2. 堆
3. 方法区
   • 是由N多个不同功能的小区域组成的
     • 静态区域：存放静态内容
     • 非静态区域：存放非静态内容
     • 字符串常量池：存放字符串常量
4. 寄存器
5. 本地方法区

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     //访问范围 ：没有限制    

权限修饰符在使用中的注意细节

//方法重写时：保障子类中重写访问的访问权限必须 >= 父类中方法的权限

在开发中经常会使用或开发：工具类

• 工具类的特点：
  1. 不能被继承
  2. 不能让其他类创建对象
  3. 提供静态方法

//final保障 ：工具类不能被继承
public final class 工具类{//不能让其他类创建对象private 工具类(){}//给外部提供：静态方法public static 返回值 静态方法(...){}
}

问题：在一个类中可以书写哪些内容？

public class 类{//成员变量：静态、非静态//成员方法：静态、非静态、抽象//构造方法//代码块}

代码块：

{}

代码块划分：

• 静态代码块 //开发中使用最多
  • 书写位置：在类中方法外（和成员变量、成员方法属于同一级）
    • 在构造代码块上添加：static
  • 特点：随着类的加载，执行1次静态代码块（类只会被加载1次）
  • 作用：用于对静态成员数据进行初始化
• 构造代码块
  • 书写位置：在类中方法外（和成员变量、成员方法属于同一级）
  • 特点：在每个构造方法执行前，都会先执行构造代码块
  • 作用：当类中多个构造方法中有共性内容时，可能抽取到构造代码块
• 局部代码块
  • 书写位置：写在方法体中
  • 特点：在方法执行时，才会调用
  • 作用：用于作用域

接口

接口的作用：制定规则

制定规则的两种方案：

1. 定义类，类中书写抽象方法（不建议使用。 类只能单一继承）
2. 定义接口， 接口中书写抽象方法（接口好处：可以多实现）

接口的定义：

public interface  接口名{//抽象方法
}

接口的特点：

1. 接口不能实例化（不能创建对象）
2. 接口中没有构造方法（接口只能通过子类来实现对象创建）
3. 接口可以多实现（ 一个类可以实现多个接口[解决类只能单一继承的问题] ）

按照接口中定义的规则开发子类： 编写接口实现类

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 {//问题：为什么接口可以多继承？//答案：接口中仅仅只是定义功能（没有功能的实现，子类要自己实现功能）
}

接口和抽象类的相同之处：

1. 接口和抽象类， 都不能实例化（不能创建对象）
2. 接口和抽象类，都具有抽象方法
3. 接口和抽象类，都是做为父类型存在的

抽象类和接口的区别：

1. 抽象类：除了抽象方法外，还具有成员变量、构造方法、非抽象方法
2. 接口：除了抽象方法外，只有常量 （JDK8：默认方法、静态方法）（JDK9：私有方法）

回顾上午内容：

1. 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. 非静态方法中可以访问：静态方法、静态变量
   

2. final关键字

   //final是什么？
   final是java语言中的修饰符关键字。用来修饰：类、方法、变量//final可以解决程序中什么问题？
   final修饰的类：不能被继承
   final修饰的方法： 不能被重写
   final修饰的变量： 初始化值后不能改变其值（常量）//final的使用
   public final class 类名{//变量final String name="初始化值";//方法public final void method(){}
   }
   

3. 权限修饰符号

   //权限修饰符解决什么问题？
   限制程序中访问权限//权限修饰符
   private 、默认（什么都不写）、protected 、 public private  ： 仅限本类中使用  
   默认（什么都不写） ： 同一个包下的任意类
   protected  ： 同一个包下的任意类 、 不同包下的子类
   public    ： 没有限制 
   

4. 接口

   //接口的作用：
   制定规则 //接口的定义（语法）
   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{//重写所有抽象方法}

5. 代码块

   代码块：局部代码块、构造代码块、静态代码块构造代码块作用：当类中构造方法里面有共性内容时，可以抽出到构造代码块中每次构造方法执行前，都会先执行构造代码块静态代码块：
   static{//特点：静态代码块是随着类的加载执行（执行1次）//作用：初始化数据（数据必须在创建对象之前就初始化完成）
   }    
   

   工具类的书写规则：

6. 工具类，修饰为final（不让继承）

7. 工具类的构造方法，设置为private（不让其他类创建对象）

8. 工具类中提供：静态方法（通过类名访问）

static关键字

• 解决程序中什么问题？

  静态变量：共享数据
  静态方法：工具类中方法的编写
  

• 怎么使用

  public class 类{static 类型 变量名;public static 返回值类型 方法名(参数, ..){}
  }类名.静态变量名=100;
  类名.静态方法名();
  

• 细节：

  1. 静态内容是随着类的加载，存放在方法区的静态区域下（仅有一份）【早于对象创建】
  2. 静态方法中不能使用this关键字
  3. 静态方法只能访问静态内容（静态变量、静态方法）

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进制：22进制： 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;

多态在使用时的注意细节

1. 多态中：父类和子类拥有一模一样的成员变量时：
   • 编译时：以父类型中的成员变量为主
   • 运行时：使用父类中的成员变量
2. 多态中：父类和子类拥有一模一样的成员方法时：
   • 编译时：以父类中的成员方法为主（检查父类中有没有这个成员方法，没有：报错）
   • 运行时：以子类中的成员方法为主（调用子类对象中重写后的成员方法）

多态转型

• 向上转型（自动类型提升）

  //基础班： int a =10;   long  num = a;  //多态：
  父类型  父引用 = new 子类(); //子类型变为：父类型 （弊端：父引用不能使用子类特有成员）
  

• 向下转型（强制类型转换）

  //解决的问题： 父引用不能使用子类中特有成员//基础班： long a =100L;    int b = (int) a;//多态的向下转型：
  子类 对象 = (子类) 父引用;
  

  • 注意细节：

    • 向下转型时容易发生：java.lang.ClassCastException（类型转换异常）

      解决方案：instanceof

      if( 父引用对象  instanceof 子类型 ){子类型 对象 = (子类型)父引用对象;对象.特有成员
      }
      

多态代码的书写：

1. 创建对象

   //父类型  父引用 = new 子类()
   Father f = new Son();
   

2. 作为参数

   public void method( Father f )
   {f.方法()
   }
   

3. 作为返回值

   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()
    • 作用： 把对象转换为字符串

比较两个字符串是否相同 ：

//方案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.DateFormatDataeFormat是一个抽象类，无法实例化。使用子类：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. 在枚举中除了可以书写：固定选项值外，还可以书写：成员变量、私有构造方法、成员方法