一、static关键字
1、概念
关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。
2、定义和使用格式
类变量
当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。
类变量 ：使用 static关键字修饰的成员变量
定义格式
static 数据类型 变量名；
举例：
static int numberID；
比如说，基础班新班开班，学员报到。现在想为每一位新来报到的同学编学号（sid），从第一名同学开始，sid为1，以此类推。学号必须是唯一的，连续的，并且与班级的人数相符，这样以便知道，
要分配给下一名新同学的学号是多少。这样我们就需要一个变量，与单独的每一个学生对象无关，而是与整个班级同学数量有关。
package day08.demo03;
/*
如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。多个对象共享同一份数据。
*/
public class Demo01StaticField {
public static void main(String[] args) {
Student two = new Student("黄蓉", 16);
two.room = "101教室";
System.out.println("姓名：" + two.getName()
+ "，年龄：" + two.getAge() + "，教室：" + two.room
+ "，学号：" + two.getId());
Student one = new Student("郭靖", 19);
System.out.println("姓名：" + one.getName()
+ "，年龄：" + one.getAge() + "，教室：" + one.room
+ "，学号：" + one.getId());
}
}
运行结果
"D:\Program Files\Java\jdk-13.0.2\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=52801:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath C:\OneDrive\java\src\out\production\OneDrive day08.demo03.Demo01StaticField 姓名：黄蓉，年龄：16，教室：101教室，学号：1 姓名：郭靖，年龄：19，教室：101教室，学号：2 Process finished with exit code 0
二、静态方法
当 static 修饰成员方法时，该方法称为类方法 。静态方法在声明中有 static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。
类方法 ：使用 static关键字修饰的成员方法，习惯称为静态方法。
定义格式：
修饰符 static 返回值类型 方法名 (参数列表){
// 执行语句
}
举例：在Student类中定义静态方法
public static void showNum() {
System.out.println("num:" + numberOfStudent);
}
静态方法调用的注意事项：
- 静态方法可以直接访问类变量和静态方法。
- 静态方法 不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
- 静态方法中，不能使用 this关键字
- 小贴士：静态方法只能访问静态成员。
调用格式
被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。
格式
// 访问类变量 类名.类变量名； // 调用静态方法 类名.静态方法名(参数)；
调用演示，代码如下：
public class StuDemo2 {
public static void main(String[] args) {
// 访问类变量
System.out.println(Student.numberOfStudent);
// 调用静态方法
Student.showNum();
}
}
示例代码
MyClass
package day08.demo03;
public class MyClass {
int num; // 成员变量
static int numStatic; // 静态变量
// 成员方法
public void method() {
System.out.println("这是一个成员方法。");
// 成员方法可以访问成员变量
System.out.println(num);
// 成员方法可以访问静态变量
System.out.println(numStatic);
}
// 静态方法
public static void methodStatic() {
System.out.println("这是一个静态方法。");
// 静态方法可以访问静态变量
System.out.println(numStatic);
// 静态不能直接访问非静态【重点】
// System.out.println(num); // 错误写法！
// 静态方法中不能使用this关键字。
// System.out.println(this); // 错误写法！
}
}
Student
package day08.demo03;
public class Student {
private int id; // 学号
private String name; // 姓名
private int age; // 年龄
static String room; // 所在教室
private static int idCounter = 0; // 学号计数器，每当new了一个新对象的时候，计数器++
public Student() {
this.id = ++idCounter;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
this.id = ++idCounter;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
测试
package day08.demo03;
/*
一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。
如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。
无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。
静态变量：类名称.静态变量
静态方法：类名称.静态方法()
注意事项：
1. 静态不能直接访问非静态。
原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容。
“先人不知道后人，但是后人知道先人。”
2. 静态方法当中不能用this。
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。
*/
public class Demo02StaticMethod {
public static void main(String[] args) {
MyClass obj = new MyClass(); // 首先创建对象
// 然后才能使用没有static关键字的内容
obj.method();
// 对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用。
obj.methodStatic(); // 正确，不推荐，这种写法在编译之后也会被javac翻译成为“类名称.静态方法名”
MyClass.methodStatic(); // 正确，推荐
// 对于本来当中的静态方法，可以省略类名称
myMethod();
Demo02StaticMethod.myMethod(); // 完全等效
}
public static void myMethod() {
System.out.println("自己的方法！");
}
}
运行结果
"D:\Program Files\Java\jdk-13.0.2\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=53087:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath C:\OneDrive\java\src\out\production\OneDrive day08.demo03.Demo02StaticMethod 这是一个成员方法。 0 0 这是一个静态方法。 0 这是一个静态方法。 0 自己的方法！ 自己的方法！ Process finished with exit code 0
三、静态原理图解
代码
package day08.demo03;
public class Demo03StaticStudent {
public static void main(String[] args) {
// 首先设置一下教室，这是静态的东西，应该通过类名称进行调用
Student.room = "101教室";
Student one = new Student("郭靖", 20);
System.out.println("one的姓名：" + one.getName());
System.out.println("one的年龄：" + one.getAge());
System.out.println("one的教室：" + Student.room);
System.out.println("============");
Student two = new Student("黄蓉", 18);
System.out.println("two的姓名：" + two.getName());
System.out.println("two的年龄：" + two.getAge());
System.out.println("two的教室：" + Student.room);
}
}
运行结果
"D:\Program Files\Java\jdk-13.0.2\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=53256:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath C:\OneDrive\java\src\out\production\OneDrive day08.demo03.Demo03StaticStudent one的姓名：郭靖 one的年龄：20 one的教室：101教室 ============ two的姓名：黄蓉 two的年龄：18 two的教室：101教室 Process finished with exit code 0
原理图解
静态代码块
package day08.demo03;
/*
静态代码块的格式是：
public class 类名称 {
static {
// 静态代码块的内容
}
}
特点：当第一次用到本类时，静态代码块执行唯一的一次。
静态内容总是优先于非静态，所以静态代码块比构造方法先执行。
静态代码块的典型用途：
用来一次性地对静态成员变量进行赋值。
*/
public class Demo04Static {
public static void main(String[] args) {
Person one = new Person();
Person two = new Person();
}
}
运行结果
"D:\Program Files\Java\jdk-13.0.2\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=55398:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath C:\OneDrive\java\src\out\production\OneDrive day08.demo03.Demo04Static 静态代码块执行！ 构造方法执行！ 构造方法执行！ Process finished with exit code 0
四、Arrays类
1、概述
java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单
2、操作数组的方法
package day08.demo04;
import java.util.Arrays;
/*
java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。
public static String toString(数组)：将参数数组变成字符串（按照默认格式：[元素1, 元素2, 元素3...]）
public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序。
备注：
1. 如果是数值，sort默认按照升序从小到大
2. 如果是字符串，sort默认按照字母升序
3. 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。（今后学习）
*/
public class Demo01Arrays {
public static void main(String[] args) {
int[] intArray = {10, 20, 30};
// 将int[]数组按照默认格式变成字符串
String intStr = Arrays.toString(intArray);
System.out.println(intStr); // [10, 20, 30]
int[] array1 = {2, 1, 3, 10, 6};
Arrays.sort(array1);
System.out.println(Arrays.toString(array1)); // [1, 2, 3, 6, 10]
String[] array2 = {"bbb", "aaa", "ccc"};
Arrays.sort(array2);
System.out.println(Arrays.toString(array2)); // [aaa, bbb, ccc]
}
}
运行结果
"D:\Program Files\Java\jdk-13.0.2\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=55468:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath C:\OneDrive\java\src\out\production\OneDrive day08.demo04.Demo01Arrays [10, 20, 30] [1, 2, 3, 6, 10] [aaa, bbb, ccc] Process finished with exit code 0
3、练习
请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。
package day08.demo04;
import java.util.Arrays;
/*
题目：
请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。
*/
public class Demo02ArraysPractise {
public static void main(String[] args) {
String str = "asv76agfqwdfvasdfvjh";
// 如何进行升序排列：sort
// 必须是一个数组，才能用Arrays.sort方法
// String --> 数组，用toCharArray
char[] chars = str.toCharArray();
Arrays.sort(chars); // 对字符数组进行升序排列
// 需要倒序遍历
for (int i = chars.length - 1; i >= 0; i--) {
System.out.println(chars[i]);
}
}
}
运行结果
"D:\Program Files\Java\jdk-13.0.2\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=55512:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath C:\OneDrive\java\src\out\production\OneDrive day08.demo04.Demo02ArraysPractise w v v v s s q j h g f f f d d a a a 7 6 Process finished with exit code 0
五、Math类
1、概述
java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单
2、基本运算的方法
package day08.demo04;
/*
java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。
public static double abs(double num)：获取绝对值。有多种重载。
public static double ceil(double num)：向上取整。
public static double floor(double num)：向下取整。
public static long round(double num)：四舍五入。
Math.PI代表近似的圆周率常量（double）。
*/
public class Demo03Math {
public static void main(String[] args) {
// 获取绝对值
System.out.println(Math.abs(3.14)); // 3.14
System.out.println(Math.abs(0)); // 0
System.out.println(Math.abs(-2.5)); // 2.5
System.out.println("================");
// 向上取整
System.out.println(Math.ceil(3.9)); // 4.0
System.out.println(Math.ceil(3.1)); // 4.0
System.out.println(Math.ceil(3.0)); // 3.0
System.out.println("================");
// 向下取整，抹零
System.out.println(Math.floor(30.1)); // 30.0
System.out.println(Math.floor(30.9)); // 30.0
System.out.println(Math.floor(31.0)); // 31.0
System.out.println("================");
System.out.println(Math.round(20.4)); // 20
System.out.println(Math.round(10.5)); // 11
}
}
运行结果
"D:\Program Files\Java\jdk-13.0.2\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=55607:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath C:\OneDrive\java\src\out\production\OneDrive day08.demo04.Demo03Math 3.14 0 2.5 ================ 4.0 4.0 3.0 ================ 30.0 30.0 31.0 ================ 20 11 Process finished with exit code 0
3、练习
计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？
package day08.demo04;
/*
题目：
计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？
分析：
1. 既然已经确定了范围，for循环
2. 起点位置-10.8应该转换成为-10，两种办法：
2.1 可以使用Math.ceil方法，向上（向正方向）取整
2.2 强转成为int，自动舍弃所有小数位
3. 每一个数字都是整数，所以步进表达式应该是num++，这样每次都是+1的。
4. 如何拿到绝对值：Math.abs方法。
5. 一旦发现了一个数字，需要让计数器++进行统计。
备注：如果使用Math.ceil方法，-10.8可以变成-10.0。注意double也是可以进行++的。
*/
public class Demo04MathPractise {
public static void main(String[] args) {
int count = 0; // 符合要求的数量
double min = -10.8;
double max = 5.9;
// 这样处理，变量i就是区间之内所有的整数
for (int i = (int) min; i < max; i++) {
int abs = Math.abs(i); // 绝对值
if (abs > 6 || abs < 2.1) {
System.out.println(i);
count++;
}
}
System.out.println("总共有：" + count); // 9
}
}
运行结果
package day08.demo04;
/*
题目：
计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？
分析：
1. 既然已经确定了范围，for循环
2. 起点位置-10.8应该转换成为-10，两种办法：
2.1 可以使用Math.ceil方法，向上（向正方向）取整
2.2 强转成为int，自动舍弃所有小数位
3. 每一个数字都是整数，所以步进表达式应该是num++，这样每次都是+1的。
4. 如何拿到绝对值：Math.abs方法。
5. 一旦发现了一个数字，需要让计数器++进行统计。
备注：如果使用Math.ceil方法，-10.8可以变成-10.0。注意double也是可以进行++的。
*/
public class Demo04MathPractise {
public static void main(String[] args) {
int count = 0; // 符合要求的数量
double min = -10.8;
double max = 5.9;
// 这样处理，变量i就是区间之内所有的整数
for (int i = (int) min; i < max; i++) {
int abs = Math.abs(i); // 绝对值
if (abs > 6 || abs < 2.1) {
System.out.println(i);
count++;
}
}
System.out.println("总共有：" + count); // 9
}
}