Java day05——常用类（Random、String）、静态（static）、类加载

常用类

软件包package

java.lang: 常用类,默认自动import

• System: java.lang.System
• Math: java.lang.Math
• String: java.lang.String

java.util: 工具类

• Scanner: java.util.Scanner
• Arrays: java.util.Arrays

java.io: 输入输出相关类
java.sql: 数据库相关
java.net: 网络相关
java.text: 格式化相关

常用类

Random

Random: 构造方法 new Random()

• int nextInt(): 产生一个随机整数
• int nextInt(int n): 产生一个0~n的随机数

		// 1.创建Random对象
        Random ran = new Random();
        // 2.使用方法
        int a = ran.nextInt();
        System.out.println(a);
        // 0~20之间随机数
        int b = ran.nextInt(20);
        System.out.println(b);
        // 产生一个随机boolean值
        boolean c = ran.nextBoolean();
        System.out.println(c);

比较Math.random() 和 Random 的使用

1. Math.random() -> 不需要对象,直接调用
   Random -> 需要对象
2. Math.random() -> 返回double, 范围固定0~1
   Random中的nextInt() -> 返回int, 范围可指定

String字符串

字符数组直接打印, 就是字符串 -> JVM转换的

   	   char[] arr = {'Y','N','H','C','M'};
       System.out.println(Arrays.toString(arr));//[Y, N, H, C, M]
       System.out.println(arr);// YNHCM

特点

1.直接赋值的字符串, 都存在字符串常量池中, 优化
2.字符串本身不可变
3.字符串不能用 == 来比较

// 构造方式的区别
      // 1.直接赋值
      // 2.new出来的
      String s1 = new String("hello");
      String s2 = new String("hello");
      // 判断s1和s2是否相等
      System.out.println(s1 == s2); // false,new出来的会开辟一个新的空间

      String s3 = "hello";
      String s4 = "hello";
      System.out.println(s3 == s4); // true
      System.out.println(s3 == s1); // false
      // 字符串字面量/直接量 的拼接, 出来的还是直接赋值
      String s5 = "he" + "llo";
      System.out.println(s4 == s5); // true
      String s6 = "he";
      // 变量和直接量的拼接, 产生一个新的对象
      String s7 = s6 + "llo";
      System.out.println(s4 == s7); // false

字符串常量池

构造方法举例

String s = “hello”;
String()

// 2.无参构造器 -> "" 空的字符串
       String s1 = new String();

String(String)

// 3.有参构造 1 -> hello
       String s2 = new String("hello");

String(char[])

// 4.有参构造 2 -> hello
       char[] chs = {'h','e','l','l','o'};
       String s3 = new String(chs);

String(char[], int offset, int count)

// 5.有参构造 3 -> ell
       String s4 = new String(chs, 1, 3);

String(byte[])

// 6.有参构造 4 -> bcde
       byte[] bs = {98, 99, 100, 101};
       String s5 = new String(bs);

String(byte[], int offset, int length)

// 7.有参构造 5 -> cde
        String s6 = new String(bs, 1, 3);

常用API

char charAt(int index)获得某一个字符串下标对应的字符
char[] toCharArray() 将字符串s, 转换成字符数组
boolean equals(String)字符串比较
String substring(int start, int end)截取字符串
String substring(int start) 截取字符串, 从指定位置截取到末尾
boolean startsWith(String)判断是否以xx开头
boolean startsWith(String, int offset) – 从offset位置开始, 是否以指定字符串打头
boolean endsWith(String)判断是否以xx结尾
int indexOf(char)
int indexOf(String)获得指定字符串出现的位置
int indexOf(char, int fromIndex)-- 从fromIndex开始往后, 第一次出现char的位置
int indexOf(String, int fromIndex)
int length()
boolean equalsIgnoreCase(String) – 忽略大小写
String trim() – 去掉字符串左右两边的空白字符
String concat – 将指定字符串连接到该字符串的末尾
String toUpperCase – 字符串全部大写
String toLowerCase – 字符串全部小写
boolean contains（） – 是否包含指定字符
replace（oldchar，newchar）-- 替换

System.arraycopy

数组扩容

		// 需求: 让arr变成 {1,2,3,4,5,6}
        int[] arr = {1,2,3,4,5};
        // 1.数组扩容
        int[] b = new int[arr.length+1];
        // 2.数组复制
        /*
            参数1: 要复制的数组 - 源数组
            参数2: 从要源数组的哪个位置开始复制
            参数3: 要复制到哪个数组中 - 目标数组
            参数4: 要从b数组的哪个位置开始存放值
            参数5: 要复制几个元素
         */
        System.arraycopy(arr, 0, b, 0, arr.length);
        // 3.再最后加一个6
        b[b.length - 1] = 6;
        // 4.将arr替换
        arr = b;
        System.out.println(Arrays.toString(arr));
        

long currentTimeMillis();当前时间

Arrays

String Arrays.toString(数组): 以[元素1, 元素2]格式打印数组
int[] Arrays.copyOf(int[] src, int newLength)
void sort(int[] arr): 按照升序排序, 只支持基本数据类型和String

Math

Math: java.lang
static double random(): 0.0~1.0
static double pow(double a, double b)
static int abs(int) : 求绝对值
double ceil(double) : 向上取整
double floor(double): 向下取整
double round(double): 四舍五入
double sqrt(double): 开方

静态static

有一些类的方法在使用时, 不需要创建对象

修饰成员变量

静态的成员变量
通常静态成员变量不会在构造方法中初始化

	// 通常是声明的同时初始化
    static int money;

1. 属于类的, 所有对象共用
2. 通过类名. 调用 例如 Child.money
3. 只有一个

普通的成员变量

• 属于对象
• 通过对象. 调用 例如 c1.name
• 有几个对象, 就有几个成员变量

修饰方法

静态方法

static void cry() {
 // 调用静态方法
 Child.cry();

修饰代码块

静态代码块 -> 给类初始化 - 类加载时执行的，作用: 用来执行消耗比较大的代码

 // 
    static {
        money = 1000;
        System.out.println("静态代码块被执行了");
    }

类加载

把类的信息从字节码文件中读取到内存的方法区中

静态成员变量的加载

xx.java -> xx.class -> 类加载 -> JVM方法区中
静态的成员变量是和类一起加载到方法区中的

结论: 当使用静态成员变量时, 对象不一定存在

类加载的时间

第一次使用类会加载, 并且只加载一次

使用类的三种情况

		 // 1.创建对象
        Child c = new Child();
        Child c1 = new Child("小明", 3);

        // 2.调用静态成员变量、静态方法
        Child.money ++;
        Child.cry();    
       

补充：
4.使用子类会加载父类

• 创建子类对象, 先加载父类, 再加载子类
• 调用子类的静态成员, 先加载父类, 再加载子类

5.类.class
6.Class.forName(String className): 手动加载
java.lang.String java.util.ArrayList

类加载执行的代码

1. 静态代码块
2. 静态成员变量

静态代码块，构造代码块，构造函数执行顺序

执行顺序优先级：静态块,main(),构造块,构造方法。

案例：运行下面代码的结果为

class A {
 public A() {
 	System.out.println("class A");
 }
 {
 	System.out.println("I'm A class");
 }
 static {
 	System.out.println("class A static");
 }
}
public class B extends A {
 public B() {
	 System.out.println("class B");
}
{
	 System.out.println("I'm B class");
}
 static {
 	System.out.println("class B static");
 }
 public static void main(String[] args) {
	 new B();
 }
}


class A static 
class B static 
I'm A class 
class A 
I'm B class
class B