目录
1.控制流（if else swich break；） 循环（while for）
三：第六章 继承 重写 接口 this和super关键字 抽象类和抽象方法 接口 多态 static和final关键字
可点击目录直接跳转到指定章节
一：3到4章知识点总结
1.控制流（if else swich break；） 循环（while for）
注：此部分不会单独考察，会结合其他知识点，复习请见作业实验四分支结构与循环结构
2.类型转换
隐式类型转换（自动转换）：
隐式类型转换是指在编译时由编译器自动完成的类型转换。它发生在两种数据类型之间，其中一 种数据类型的范围更大，而另一种数据类型的范围更小。
例如：
int num1 = 10;
double num2 = num1; // int类型转换为double类型，发生了隐式类型转换
在这个例子中，int类型的`num1`被隐式转换为double类型的`num2`。这是因为double类型的范围更大，可以容纳int类型的值。
强制类型转换：
显式类型转换是指通过强制使用强制类型转换操作符（`(type)`）来执行的类型转换。它发生在两种数据类型之间，其中一种数据类型的范围较大，而另一种数据类型的范围较小。
例如：
double num1 = 3.14;
int num2 = (int) num1; // double类型转换为int类型，发生了显式类型转换
在这个例子中，double类型的`num1`被显式转换为int类型的`num2`。由于int类型的范围较小，因此需要使用强制类型转换操作符将其转换为int类型。
八进制 十六进制输出：
在Java中，可以使用整型变量表示八进制和十六进制的数值，并将其输出为相应的形式。下面是关于八进制和十六进制输出的详细说明和示例代码：
八进制输出：
八进制数使用前缀`0`表示。可以使用`Integer.toOctalString()`方法将整数转换为八进制字符串。
示例代码：
int octalNum = 83; // 十进制数值83
String octalString = Integer.toOctalString(octalNum);
System.out.println("八进制数：" + octalString); // 输出：123
十六进制输出：
十六进制数使用前缀`0x`表示。可以使用`Integer.toHexString()`方法将整数转换为十六进制字符串。
示例代码：
int hexNum = 171; // 十进制数值171
String hexString = Integer.toHexString(hexNum);
System.out.println("十六进制数：" + hexString); // 输出：ab
需要注意的是，输出的八进制和十六进制字符串都是以字符串形式呈现的，而不是直接作为数值进行计算、
还可以进行格式化输出：
System.out.printf("%x\n",x);//按16进制输出
System.out.printf("%o\n",x);//按8进制输出二：第5章面对对象基础：
1.类和对象：
类用class关键字定义
对象用类名 对象名 =new 类名（参数）；的方法来实例化对象
调用非静态（前缀没有static）方法和非静态成员变量需要先实例化对象，用对象名.方法名（成员变量）来进行调用。
代码演示：
// 类的定义
class Car {
// 成员变量
String brand;
String color;
// 成员方法
void startEngine() {
System.out.println("发动引擎");
}
}
// 对象的实例化
Car myCar = new Car();
2.封装：
使用private关键字对于一些成员方法和成员变量进行访问权限控制，并设立对应的get和set方法用于修改和调用
代码演示：
class Employee {
private String name; // 私有成员变量
private int age;
// 公共方法用于访问私有成员变量
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) {
this.age = age;
} else {
System.out.println("年龄不能为负数");
}
}
}
// 创建对象并使用封装的方法访问成员变量
Employee emp = new Employee();
emp.setName("John");
emp.setAge(25);
System.out.println("姓名：" + emp.getName());
System.out.println("年龄：" + emp.getAge());
在上述示例中，我们创建了一个名为Employee的类，并在类中定义了私有成员变量name和age。通过公共的访问方法（getter和setter），我们可以控制对私有成员变量的访问，并确保数据的有效性。
3.构造方法（Constructor）：
构造方法是一种特殊的方法，用于创建和初始化对象。它在实例化类时自动调用，并负责执行一些初始设置或操作。
示例代码：
class Person {
private String name;
private int age;
// 构造方法
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 成员方法
public void displayInfo() {
System.out.println("姓名：" + name);
System.out.println("年龄：" + age);
}
}
// 创建对象时调用构造方法进行初始化
Person person = new Person("Alice", 30);
person.displayInfo();
在上述示例中，我们在类中定义了一个构造方法Person(String name, int age)，它接受两个参数并用于初始化成员变量name和age。在创建对象时，构造方法会被自动调用，并使用提供的参数进行对象的初始化
注意构造方法和构造方法的区别：
1.成员方法格式：
返回值类型 //(例如void，boolean，int等)// 方法名//（自己随便取一个）//（参数）{
方法体
}
2.构造方法：
类名 （参数）{
方法体
}
三：第六章 继承 重写 接口 this和super关键字 抽象类和抽象方法 接口 多态 static和final关键字
1. 继承：
继承是面向对象编程中的一种机制，通过它，一个类可以继承另一个类的属性和方法。被继承的类称为父类或超类，继承这些属性和方法的类称为子类。子类可以使用父类的成员变量和方法，并可以扩展或重写它们。
class Animal {
void eat() {
System.out.println("动物吃食物");
}
}
class Dog extends Animal {
void bark() {
System.out.println("狗在叫");
}
}
// 创建子类对象并调用继承的方法
Dog dog = new Dog();
dog.eat(); // 继承自父类
dog.bark(); // 子类自己的方法
在上述示例中，`Animal`类作为父类，`Dog`类继承了`Animal`类。`Dog`类可以访问`Animal`类的方法`eat()`，并且还可以定义自己的方法`bark()`。
2. 重写：
重写是指子类重新定义父类中已存在的方法，以便在子类中实现。重写方法必须具有相同的名称、参数列表和返回类型。
重写方法使用`@Override`注解来标识。注意单词拼写不要在这种地方扣分
class Animal {
void eat() {
System.out.println("动物吃食物");
}
}
class Dog extends Animal {
@Override
void eat() {
System.out.println("狗吃骨头");
}
}
// 创建子类对象并调用重写的方法
Dog dog = new Dog();
dog.eat(); // 重写的方法
在上述示例中，`Dog`类重写了父类`Animal`的方法`eat()`，并重新定义了狗吃骨头的行为。
3. 接口（Interface）：
接口是一种定义了一组抽象方法和常量的类型，它没有实现的方法体。类可以实现（implement）一个或多个接口，并实现接口中定义的所有方法。接口提供了一种规范，以确保实现类具有特定的行为。
示例代码：
interface Drawable {
void draw();
}
class Circle implements Drawable {
@Override
public void draw() {
System.out.println("画一个圆形");
}
}
// 创建实现类对象并调用接口方法
Circle circle = new Circle();
circle.draw(); // 实现接口的方法
在上述示例中，`Drawable`接口定义了一个抽象方法`draw()`，`Circle`类实现了该接口并提供了具体的实现。
注意：
1.接口是用interface 接口名的形式构成，没有class关键字的事情，不要乱加东西
2.接口里面的成员方法是抽象方法，书写时可省略abstract关键字
3.其他类可以通过implements关键字获取接口，例如class A implements B
4.接口里面的成员变量是常量，默认前缀为final static （可省略）。例如 final static int a=0；
5.接口中的抽象方法必须全部被实现
4. this 和 super 关键字：
this`关键字引用当前对象，在方法内部使用它可以访问当前对象的成员变量和方法。
`super`关键字引用父类对象，在子类中使用它可以调用父类的成员变量和方法。
示例代码：
class Animal {
String name;
void eat() {
System.out.println("动物吃食物");
}
}
class Dog extends Animal {
void display() {
String name = "Dog";
System.out.println(this.name); // 当前对象的name
System.out.println(super.name); // 父类的name
super.eat(); // 调用父类的方法
}
}
// 创建子类对象并调用方法
Dog dog = new Dog();
dog.name = "Tom";
dog.display();
在上述示例中，`Dog`类中的`display()`方法使用了`this`关键字来访问当前对象的`name`成员变量，使用`super`关键字来访问父类的`name`成员变量，并调用父类的`eat()`方法。
注意：
1.调用方法时默认调用父类的方法
2.使用this关键字首先调用本类有参方法，子类没有该方法的话，去调用父类有参方法
3.super关键字去调用父类有参，没有就报错喽，遭老罪了那就
5. 抽象类和抽象方法：
抽象类是不能被实例化的类，它用于定义一个或多个抽象方法。抽象方法是没有具体实现的方法，必须由子类进行重写实现。如果一个类包含抽象方法，那么它必须声明为抽象类。
示例代码：
abstract class Shape {
abstract void draw(); // 抽象方法
}
class Circle extends Shape {
@Override
void draw() {
System.out.println("画一个圆形");
}
}
// 创建子类对象并调用抽象方法
Circle circle = new Circle();
circle.draw(); // 实现抽象方法
在上述示例中，`Shape`类是一个抽象类，其中定义了一个抽象方法`draw()`。`Circle`类继承了`Shape`类，并实现了抽象方法`draw()`。
6. 多态：
在多态中，父类的引用变量可以引用子类的对象，从而实现对不同子类对象的统一操作。
示例代码：
class Animal {
void sound() {
System.out.println("动物发出声音");
}
}
class Dog extends Animal {
@Override
void sound() {
System.out.println("狗在叫");
}
}
class Cat extends Animal {
@Override
void sound() {
System.out.println("猫在喵喵叫");
}
}
// 创建父类引用变量并调用子类的方法
Animal animal1 = new Dog();
Animal animal2 = new Cat();
animal1.sound(); // 多态调用，输出：狗在叫
animal2.sound(); // 多态调用，输出：猫在喵喵叫
在上述示例中，`Animal`类是父类，`Dog`和`Cat`类是子类。通过父类的引用变量分别指向不同的子类对象，可以实现对不同子类对象的方法调用。
7. static 和 final 关键字：
- `static`关键字用于声明静态成员变量和静态方法。静态成员变量属于类级别，所有对象共享同一份数据；静态方法不依赖于对象的实例，可以直接通过类名调用。
- `final`关键字用于声明常量、禁止方法重写和类继承。被`final`修饰的变量无法再次赋值，被`final`修饰的方法无法被子类重写，被`final`修饰的类无法被继承。
示例代码：
class MathUtil {
static final double PI = 3.14159; // 常量
static int add(int a, int b) {
return a + b;
}
}
public class Main {
public static void main(String[] args) {
System.out.println(MathUtil.PI); // 静态成员变量访问
int sum = MathUtil.add(5, 3); // 静态方法调用
System.out.println(sum);
}
}
在上述示例中，`MathUtil`类包含一个静态成员变量`PI`和一个静态方法`add()`。通过类名直接访问静态成员变量和调用静态方法。
关于static的几点注意：（重点）
在使用`static`关键字时，有一些注意事项需要记住：
1. 静态成员属于类级别：使用`static`关键字声明的成员变量和方法属于类级别，而不是实例级别。这意味着所有的对象实例共享同一个静态成员，而不是为每个对象实例创建一个数据。
2. 静态成员可以直接通过类名访问：由于静态成员属于类，而不是对象实例，所以可以直接使用类名访问静态成员，而无需创建对象实例。
3. 静态方法不能访问非静态成员：静态方法只能访问静态成员，如果需要在静态方法中访问非静态成员，可以通过创建对象实例来间接访问。
4. 静态方法中不能使用this关键字：由于静态方法属于类级别，而不是实例级别，因此无法使用`this`关键字引用当前对象。`this`关键字只能在实例方法中使用。
5. 静态块的初始化：使用静态块可以在类加载时进行静态成员的初始化操作。静态块使用`static`关键字和花括号包裹，当类被加载时，静态块中的代码会被执行一次。
6. 静态方法的重写和覆盖：静态方法不能被子类重写，因为静态方法属于类级别，而不是实例级别。子类可以定义一个与父类中的静态方法同名的方法，但并不是重写，而是隐藏了父类的静态方法。
四：数组与集合类：
1.数组：
数组这一块只有排序比较重要一点，其他的都是些语法问题。
数组是一种数据结构，用于存储一组相同类型的元素。在Java中，数组是固定长度的，一旦创建后，其长度就不能再改变。以下是对数组的详细讲解：
声明数组：
在声明数组时，需要指定数组的类型和长度。语法格式如下：
```
<数据类型>[] <数组名称> = new <数据类型>[长度];
```
int[] numbers = new int[5]; // 声明一个长度为5的int类型数组
String[] names = new String[3]; // 声明一个长度为3的String类型数组
double[] scores = new double[10]; // 声明一个长度为10的double类型数组
```
初始化数组：
数组可以通过两种方式进行初始化：静态初始化和动态初始化。
- 静态初始化：在声明数组的同时为数组元素赋值。
示例：
int[] numbers = {1, 2, 3, 4, 5}; // 静态初始化int类型数组
String[] names = {"Alice", "Bob", "Charlie"}; // 静态初始化String类型数组
- 动态初始化：先声明数组，然后使用循环或逐个赋值的方式为数组元素赋值。
示例：
int[] numbers = new int[5]; // 动态初始化int类型数组
for (int i = 0; i < numbers.length; i++) {
numbers[i] = i + 1;
}
String[] names = new String[3]; // 动态初始化String类型数组
names[0] = "Alice";
names[1] = "Bob";
names[2] = "Charlie";
访问数组元素：
数组元素的访问使用索引（下标）来指定。数组索引从0开始，最大索引为数组长度减1。
示例：
int[] numbers = {1, 2, 3, 4, 5};
System.out.println(numbers[0]); // 输出第一个元素，结果为1
System.out.println(numbers[2]); // 输出第三个元素，结果为3
String[] names = new String[3];
names[0]
数组排序：
Arrays.sort() 方法可以对任意类型的数组进行排序，包括基本数据类型和引用类型。排序是按照元素的自然顺序进行的，对于数字类型，是按照升序排序，对于字符串类型，是按照字典顺序排序。
示例：
int[] numbers = {5, 2, 8, 1, 4};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers)); // 输出 [1, 2, 4, 5, 8]
String[] names = {"Alice", "Bob", "Charlie"};
Arrays.sort(names);
System.out.println(Arrays.toString(names)); // 输出 ["Alice", "Bob", "Charlie"]
注意 ：
需要导包，需要导包！不要在这种地方疑惑为什么代码报错，看看是不是没导包！
2.Arrlist讲解：
ArrayList 是 Java 中常用的动态数组（可变长度数组）实现，它位于 `java.util` 包中。ArrayList 提供了一系列方法来操作数组，使其具有动态扩展和缩减的能力。以下是对 ArrayList 的详细讲解以及使用时的注意事项：
1. 声明和实例化 ArrayList：
在使用 ArrayList 之前，需要先进行声明和实例化。语法格式如下：
ArrayList<元素类型> arrayList = new ArrayList<>();
```
示例：
ArrayList<Integer> numbers = new ArrayList<>(); // 声明一个整数类型的 ArrayList
ArrayList<String> names = new ArrayList<>(); // 声明一个字符串类型的 ArrayList
2. 添加和访问元素：
ArrayList<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
System.out.println(names.get(0)); // 输出第一个元素，结果为 "Alice"
System.out.println(names.get(2)); // 输出第三个元素，结果为 "Charlie"
3. 删除元素：
使用 `remove()` 方法可以根据索引或元素值来删除 ArrayList 中的元素。
示例：
ArrayList<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
names.remove(1); // 删除索引为1的元素，即 "Bob"
names.remove("Alice"); // 删除元素值为 "Alice" 的元素
4. 遍历 ArrayList：
- 使用普通的 for 循环和 `size()` 方法来遍历 ArrayList。
- 使用增强的 for 循环来遍历 ArrayList。
- 使用迭代器（Iterator）遍历 ArrayList。
示例：
ArrayList<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
// 使用普通的 for 循环遍历
for (int i = 0; i < names.size(); i++) {
System.out.println(names.get(i));
}
// 使用增强的 for 循环遍历
for (String name : names) {
System.out.println(name);
}
// 使用迭代器遍历
Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
String name = iterator.next();
System.out.println(name);
}
注意事项：
- ArrayList 只能存储引用类型，不能存储基本数据类型。如果需要存储基本数据类型，可以使用其对应的包装类（例如 `Integer`、`Double`）。
。
3.Set类常用接口HashSet：
HashSet 是 Java 中的一种集合（Collection）类型，它实现了 Set 接口。HashSet 基于哈希表实现，它不保证元素的顺序，并且不允许包含重复元素。以下是对 HashSet 的详细讲解：
基本操作：
- 添加元素：使用 `add()` 方法向 HashSet 中添加元素。
- 删除元素：使用 `remove()` 方法根据元素值删除 HashSet 中的元素。
- 判断是否包含元素：使用 `contains()` 方法判断 HashSet 是否包含某个元素。
示例：
HashSet<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Orange");
System.out.println(set.contains("Apple")); // 输出 true
System.out.println(set.contains("Grapes")); // 输出 false
set.remove("Banana");
System.out.println(set); // 输出 [Apple, Orange]
迭代遍历：
- 使用增强的 for 循环遍历 HashSet 中的元素。
- 使用迭代器（Iterator）遍历 HashSet 中的元素。
示例：
HashSet<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Orange");
// 使用增强的 for 循环遍历
for (String fruit : set) {
System.out.println(fruit);
}
// 使用迭代器遍历
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
String fruit = iterator.next();
System.out.println(fruit);
}
4.set接口实现交集并集差集运算：
在 Java 中，集合的差集、交集和并集可以使用 Set 接口的实现类来实现。下面是对这些运算的详细讲解：
1. 差集（Difference）：
差集是指两个集合中不相同的元素组成的集合。在 Java 中，可以使用 Set 接口的 `removeAll()` 方法来实现差集运算。
示例：
Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
Set<Integer> set2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));
Set<Integer> difference = new HashSet<>(set1);
difference.removeAll(set2);
System.out.println(difference); // 输出 [1, 2, 3]
2. 交集（Intersection）：
交集是指两个集合中共有的元素组成的集合。在 Java 中，可以使用 Set 接口的 `retainAll()` 方法来实现交集运算。
示例：
Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
Set<Integer> set2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));
Set<Integer> intersection = new HashSet<>(set1);
intersection.retainAll(set2);
System.out.println(intersection); // 输出 [4, 5]
3. 并集（Union）：
并集是指两个集合中所有元素的集合，不包含重复的元素。在 Java 中，可以使用 Set 接口的 `addAll()` 方法来实现并集运算。
示例：
Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
Set<Integer> set2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));
Set<Integer> union = new HashSet<>(set1);
union.addAll(set2);
System.out.println(union); // 输出 [1, 2, 3, 4, 5, 6, 7, 8]
注意事项：
- 运算结果的集合类型和原集合的类型保持一致，可以使用 Set 接口的实现类（如 HashSet）来存储运算结果。
5.HashMap基本操作：
1.什么是 HashMap
HashMap 是 Map 接口的实现类，它存储的内容是键值对(key-value)映射，其中 key、value 都可以为 null。
- HashMap 是无序的，即被存入到 HashMap 中的元素，在遍历 HashMap 时，其输出是无序的。
2.创建 HashMap 集合
使用以下代码即可创建一个 HashMap 集合。
public static void main(String[] args) {
// 创建 HashMap 集合,key 存储字符串类型，value 存储整数类型
Map<String, Integer> hashMap = new HashMap<>();
}
3.HashMap 集合常用方法
常用方法示例：
public static void main(String[] args) {
// 创建 HashMap 集合,key存储字符串类型，value存储整数类型
Map<String, Integer> hashMap = new HashMap<>();
// 添加元素
hashMap.put("李四",28);
hashMap.put("张三",26);
hashMap.put("王五",26);
// 根据 key 获取 value 值
Integer zs = hashMap.get("张三");
System.out.println(zs);
// 获取所有 key 值
Set<String> strings = hashMap.keySet();
System.out.println(strings);
// 获取所有 value 值
Collection<Integer> values = hashMap.values();
System.out.println(values);
// 根据 key 去除元素
Integer ww = hashMap.remove("王五");
System.out.println(ww);
// 根据 key-value 去除元素
boolean boole = hashMap.remove("李四", 28);
System.out.println(boole);
System.out.print(hashMap);
}
执行结果：
26
[李四, 张三, 王五]
[28, 26, 26]
26
true
{张三=26}
4.遍历 HashMap 集合 （较为重要）
public static void main(String[] args) {
// 创建 HashMap 集合,key 存储字符串类型，value 存储整数类型
Map<String, Integer> map = new HashMap<>();
// 添加元素
map.put("李四",28);
map.put("张三",26);
map.put("王五",26);
//第一种：通过 keySet 遍历，普遍使用
for (String key : map.keySet()) {
System.out.println("key= "+ key + " and value= " + map.get(key));
System.out.println(----------);
}
//第二种:通过 entrySet 和迭代器遍历
Iterator<Map.Entry<String, Integer>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, Integer> entry = it.next();
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
System.out.println(----------);
}
//第三种：通过 entrySet 和增强 for 循环遍历，推荐，尤其是容量大时
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
System.out.println(----------);
}
}
执行结果 ：
key= 李四 and value= 28
key= 张三 and value= 26
key= 王五 and value= 26
----------
key= 李四 and value= 28
key= 张三 and value= 26
key= 王五 and value= 26
----------
key= 李四 and value= 28
key= 张三 and value= 26
key= 王五 and value= 26
标题五：Sting类：
public class StringDemo {
public static void main(String[] args) {
// 创建字符串对象
String str1 = "Hello";
String str2 = new String("World");
// 获取字符串长度
int length1 = str1.length();
int length2 = str2.length();
System.out.println("Length of str1: " + length1);
System.out.println("Length of str2: " + length2);
// 字符串拼接
String concatStr = str1.concat(str2);
System.out.println("Concatenated string: " + concatStr);
// 字符串比较
boolean isEqual = str1.equals(str2);
System.out.println("Are str1 and str2 equal? " + isEqual);
// 字符串截取
String substring = str1.substring(1, 3);
System.out.println("Substring of str1: " + substring);
// 字符串查找
int indexOf = str1.indexOf("l");
System.out.println("Index of 'l' in str1: " + indexOf);
// 字符串替换
String replacedStr = str1.replace("l", "L");
System.out.println("Replaced string: " + replacedStr);
// 字符串转换为字符数组
char[] charArray = str1.toCharArray();
System.out.print("Character array: ");
for (char c : charArray) {
System.out.print(c + " ");
}
}
}
输出结果：
Length of str1: 5
Length of str2: 5
Concatenated string: HelloWorld
Are str1 and str2 equal? false
Substring of str1: ell
Index of 'l' in str1: 2
Replaced string: HeLLo
Character array: H e l l o
在这个示例中，我们使用了 String 类的各种方法来展示其常见用法。首先，通过 length() 方法获取字符串的长度。然后，使用 concat() 方法将两个字符串进行拼接。使用 equals() 方法比较两个字符串是否相等。使用 substring() 方法截取子字符串。通过 indexOf() 方法查找指定字符在字符串中的索引位置。使用 replace() 方法替换字符串中的字符。最后，通过 toCharArray() 方法将字符串转换为字符数组，并使用循环遍历输出字符数组的内容。
其他方法总结：
标题六：日期类
1.Date类：构造方法
1.Date 类有如下两个构造方法。
-
Date()：此种形式表示分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒），使用该构造方法创建的对象可以获取本地的当前时间。
-
Date(long date)：此种形式表示从 GMT 时间（格林尼治时间）1970 年 1 月 1 日 0 时 0 分 0 秒开始经过参数 date 指定的毫秒数。
这两个构造方法的使用示例如下：
Date date1 = new Date(); // 调用无参数构造函数
System.out.println(date1.toString()); // 输出：Wed May 18 21:24:40 CST 2016
Date date2 = new Date(60000); // 调用含有一个long类型参数的构造函数
System.out.println(date2); // 输出：Thu Jan 0108:01:00 CST 1970Date 类的无参数构造方法获取的是系统当前的时间，显示的顺序为星期、月、日、小时、分、秒、年。
Date 类带 long 类型参数的构造方法获取的是距离 GMT 指定毫秒数的时间，60000 毫秒是一分钟，而 GMT（格林尼治标准时间）与 CST（中央标准时间）相差 8 小时，也就是说 1970 年 1 月 1 日 00:00:00 GMT 与 1970 年 1 月 1 日 08:00:00 CST 表示的是同一时间。 因此距离 1970 年 1 月 1 日 00:00:00 CST 一分钟的时间为 1970 年 1 月 1 日 00:01:00 CST，即使用 Date 对象表示为 Thu Jan 01 08:01:00 CST 1970。
2.Date常用方法 :
2.SimpleDateFormat类
实例化：
// 空参构造器，采用默认格式
SimpleDateFormat sdf = new SimpleDateFormat();
// 带参指定格式的构造器
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
参数中对应字符意义如下：
y：年
M：月
d：日
h：时
m：分
s：秒EE：周几
格式化 ：
格式化指的是将储存日期的类转化为字符串
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MMM-dd hh:mm:ss");// 3*M
String format1 = sdf2.format(date);
System.out.println(format1); // 2020-六月-24 12:16:05
记录的日期的形式，这里主要指Date类转化为String类。
格式化主要靠调用format(Date date)方法，该方法按format指定的格式将Date对象转化为一个String对象，并返回这个String对象的引用。
Date date = new Date(); // 新建一个util.Date对象
System.out.println(date); // Wed Jun 24 11:48:10 CST 2020
String format = sdf.format(date); // 格式化：按默认的格式
System.out.println(format); // 20-6-24 上午11:48
String format1 = sdf1.format(date); // 格式化，按给定的格式
System.out.println(format1); // 2020-06-24 12:09:58
值得一提的是，MMM将以中文形式输出月份：
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MMM-dd hh:mm:ss");// 3*M
String format1 = sdf2.format(date);
System.out.println(format1); // 2020-六月-24 12:16:05
解析
解析是格式化的逆过程，指的是将表示日期的字符串转化为记载日期的类，这里指的是util.Date类。
解析主要依靠parse(String source)方法，返回一个Date对象的引用，同时会抛ParseException异常
// 空参构造器默认的格式是："20-6-24 上午11:48"，我们则必须使用与其相同的格式的字符串来表示日期
String str = "2020-6-22 下午1:21"; // 采取其默认格式化时的格式
Date date1 = sdf.parse(str); // 解析，获取一个Date类对象的引用
System.out.println(date1); // Mon Jun 22 13:21:00 CST 2020
3.综合应用 ：
import java.util.Date;
import java.text.SimpleDateFormat;
public class DateDemo {
public static void main(String[] args) {
// 创建当前日期对象
Date currentDate = new Date();
// 获取日期和时间信息
int year = currentDate.getYear() + 1900;
int month = currentDate.getMonth() + 1;
int day = currentDate.getDate();
int hours = currentDate.getHours();
int minutes = currentDate.getMinutes();
int seconds = currentDate.getSeconds();
// 格式化日期对象
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String formattedDate = dateFormat.format(currentDate);
// 输出日期信息
System.out.println("Year: " + year);
System.out.println("Month: " + month);
System.out.println("Day: " + day);
System.out.println("Hours: " + hours);
System.out.println("Minutes: " + minutes);
System.out.println("Seconds: " + seconds);
System.out.println("Formatted Date: " + formattedDate);
}
}
输出结果可能如下所示：
Year: 2023
Month: 6
Day: 2
Hours: 14
Minutes: 30
Seconds: 15
Formatted Date: 2023-06-02 14:30:15
在这个示例中，我们创建了一个当前日期对象 `currentDate`，然后使用各种方法获取日期和时间的信息，包括年、月、日、小时、分钟、秒。我们还使用 `SimpleDateFormat` 类将 `Date` 对象格式化为指定的日期字符串。
标题七：Integer类
Integer类在对象中包装了一个基本类型的int值。Integer类对象包含一个int类型的字段，此外，该类提供了多个方法，能在int类型和String类型之间相互转换，还提供了处理int类型时非常有用的其他的一些常量和方法
1.Integer类的构造方法
- Integer（int value）：构造一个新分配的Integer对象，它表示指定的int值。
- Integer（String s）：构造一个新分配的Integer对象，它表示String参数所指示的int值。
例如，以下代码分别使用以上两个构造方法来获取 Integer 对象：
Integer integer1=new Integer(100); //以 int 型变量作为参数创建 Integer 对象
Integer integer2=new Integer("100"); //以 String 型变量作为参数创建 Integer 对象2. Integer类常用方法
在实际的编码过程中，经常将字符串转换为int类型的数值，或者将int类型的数值转换为对应的字符串，一下代码演示如何实现这两种功能：
十分常用且好用*********
String str="456";
int num=Integer.parseInt(str); //将字符串转换为int类型的数值
int i=789;
String s=Integer.toString(i); //将int类型的数值转换为字符串标题八：文件操作
欢迎移步这个链接进步学习文件操作
非常感谢看到这里的读者们，感谢这段时间的支持，和你们自身的努力。最后祝愿大家逢考必过取得圆满成绩，下学期再见。拜拜喽
4
290
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
