Java 部分类、API以及Static的使用

程序中，默认import的软件包是Java.lang。

常用的package有一下几个：

	Java.lang:	常用类
	Java.util:	工具类
	Java.io:	输入输出相关类
	Java.sql：	数据库相关
	Java.net:	网络相关类
	Java.text:	格式化相关类

1. Random类

import java.util.Random;

public class Demo01Random {
    public static void main(String[] args) {
        //1. 创建Random对象
        Random ran =new Random();
        //2. 使用方法
        int a = ran.nextInt();  //产生一个随机整数,范围是int的范围
        System.out.println(a);
        
        int b = ran.nextInt(20);//产生[0,20)之间的数
        System.out.println(b);
        
        boolean c = ran.nextBoolean();//产生boolean值
        System.out.println(c);
    }
}

Math.random()和Random的比较：
①

Math.random() 	->  不需要定义对象，可直接调用
Random			->	需要先定义一个对象

②

Math.random() 	->		返回double，范围固定为0-1
Random			->		返回Int，范围可直接指定

2. String类

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

字符串特点:
   1.直接赋值的字符串, 都存在字符串常量池中
   2.字符串本身不可变
   3.字符串不能用 “== ”来比较大小

构造方法：
String s = “hello”;
String()
String(String)
String(char[])
String(char[], int offset, int count)
String(byte[])
String(byte[], int offset, int length)

public class Demo03StringConstrutor {
    public static void main(String[] args) {

        //1.简单写法
        String s= "hello";

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

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

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

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

        //6.有参构造4->bcde     把字节转换为字符
        byte[] bs = {98,99,100,101};
        String s5 = new String(bs);
        System.out.println(s5);

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

import java.util.Arrays;

public class Demo05StringAPI {
    public static void main(String[] args) {
        String s= "+86 hello @qq.com";
        String s1 = new String("+86 Hello @qq.com");

        //1.获得某个对应下标的字符
        char c =s.charAt(0);
        System.out.println("charAt: "+c);

        //2.字符串比较不能用==
        boolean b= s1.equals(s);
        System.out.println("equals: "+b);
        //忽略大小写比较：
        boolean b_1 = s.equalsIgnoreCase(s1);
        System.out.println("equalsIgnoreCase: "+b_1);

        //3.将字符串s转换成字符数组
        char []chs = s.toCharArray();
        System.out.println("toCharArray: "+Arrays.toString(chs));

        //4.统计字符串字符个数、长度
        int length = s.length();
        System.out.println("length: "+length);

        //5.判断是否以XX开头 ：例如+86
        boolean b1 = s.startsWith("+86");
        System.out.println("startsWith: "+b1);
        //可以设置起始下标为3，从开始如果结果为+86,则输出true
        boolean b1_1 = s.startsWith("+86",3);
        System.out.println("startsWith: "+b1_1);

        //6.判断是否以XX结尾
        boolean b2 = s.endsWith("@qq.com");
        System.out.println("endWith: "+b2);

        //7.获得字符串中指定字符第一次出现的位置。     找不到时，返回-1
        int i = s.indexOf('@');
        System.out.println("indexOf: "+i);
        //获得指定字符串出现的位置
        int i_1 = s.indexOf("qq");
        System.out.println("indexOf: "+i_1);
        //从指定下标开始计算，后面指定字符串出现的位置
        int i_2 = s.indexOf("qq",3);
        System.out.println("indexOf: "+i_2);

        //8.截取字符串 其中填入起始位置和结束位置
        String sub = s.substring(0,6);
        System.out.println("substring: "+sub);
        //从第6位开始截取
        String sub1 = s.substring(6);
        System.out.println("substring: "+sub1);

        //去掉字符串 **两边** 的空白字符
        s.trim();
        /**
         * concat(String str)                       将指定的字符串连接到该字符串的末尾。
         * toUpperCase()                            将所有在此字符 String使用默认语言环境的规则大写。
         * toLowerCase()                            将所有在此字符 String使用默认语言环境的规则，以小写。
         * contains(CharSequence s)                 当且仅当此字符串包含指定的char值序列时才返回true。
         * replace(char oldChar, char newChar)      返回从替换所有出现的导致一个字符串 oldChar在此字符串 newChar 。
         */
    }
}

3. 常用API

API(Application Programing Interface),应用程序编程接口。Java API是程序员的“字典”，是JDK提供给我们使用的类的说明文档。这些类将底层的代码实现了封装，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。

4. Static

4.1 Static概述

关于static关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单属于某个对象的。也就是时候，既然属于类，就可以不依靠对象来调用。

4.2 定义

4.2.1 静态变量

当static修饰成员变量时，该变量称为静态变量(类变量)。该类的每个对象都共享同一个类变量的值。任何多谢都可以更改该变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

静态变量：使用static关键字修饰的成员变量。

定义格式：

static  数据类型 变量名;
举例：
static int numberID；

4.2.2 静态方法

当static修饰成员方法时，称该方法为静态方法。静态方法在声明中有static，建议使用类名调用，而不需要创建类的对象。调用的方法非常的简单。

静态方法：使用static关键字修饰的成员方法，习惯称为静态方法。

定义格式：

修饰符 static 返回值类型 方法名 （参数列表）{
	//执行语句
}

举例：
public static void showNum（）{
	System.out.println("num:"+numberOfStudent);
}

静态方法调用的注意事项：

①静态方法可以直接访问静态变量和静态方法。
②静态方法不能直接访问普通成员变量或者成员方法。反之，成员方法可以直接访问类变量或者静态方法。
③静态方法中，不能使用this关键字。

注意：静态方法只能访问静态成员

4.2.3 调用格式

被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。
格式：

//访问静态变量
类名.静态变量名
//调用静态方法
类名.静态方法名（参数）

4.2.4 静态代码块

静态代码块：定义在成员位置，使用static{}修饰代码块。

书写位置：位于类之中，方法外。
执行：随着类加载而执行且执行一次，优先于main方法和构造方法的执行。

格式

public class ClassName{
	static{
		//执行语句
		//可以给类初始化赋值
	}
}

4.3 Static 的运用代码

Child.java

package StaticClass1;

/**
 * 静态的成员变量：
 *      1.属于类
 *      2.通过类名 调用 例如Child.money
 *      3.只有一个
 *
 * 普通成员变量：
 *      1.属于对象的
 *      2.通过对象调用
 *      3.有几个对象，就有几个成员变量
 *
 * 静态方法：
 *      1.属于类
 *      2.通过类调用
 *      3.在静态方法中，不能直接使用成员变量
 *
 * 普遍方法：
 *      1.属于对象的
 *      2.通过对象调用
 */

public class Child {
    String name;
    int age;
    static int money = 100;

    //静态代码块->给类初始化---类加载时执行的
    static {
        money = 1000;
        System.out.println("静态代码块被执行了");
    }
    //代码块----调用构造器之前被调用
    //提取所有构造方法中，重复的代码
    {
        System.out.println("代码块被执行了");
    }

    Child(){

    }
    Child(String name,int age){
        this.name = name;
        this.age = age;
        //通常 静态成员变量 不会再构构造方法中初始化
        //money = 100;
    }

    static void cry(){
        System.out.println("哭");
    }

    void sleep(){
        System.out.println(name+"睡觉");
    }
}

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

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

类什么时候会加载?
第一次使用类会加载, 并且只加载一次

使用类的情况:
①创建对象
②调用类的静态成员变量
③调用类的静态方法

类加载会执行什么代码?
①静态代码块
②静态成员变量

5. Arrays类

5.1 概述

java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常的简单。

5.2 操作数组的方法

String Arrays.toString(数组): 以[元素1, 元素2]格式打印数组

int[] Arrays.copyOf(int[] src, int newLength)

void sort(int[] arr): 按照升序排序, 只支持基本数据类型和String

5.3 代码部分

import java.lang.reflect.Array;
import java.util.Arrays;

public class Demo09Array {
    public static void main(String[] args) {
        int [] arr = {1,2,3,4,5};
        //参数1：要复制的数组->源数组
        //参数2：要生成的新数组的长度
        //返回值：生成新的数组
        //这个方法的功能是给数组扩容，或者缩容
        arr = Arrays.copyOf(arr,arr.length+1);
        arr[arr.length-1]=6;
        System.out.println(Arrays.toString(arr));
    }
}

import java.util.Arrays;

public class Demo10ArraysSort {
    public static void main(String[] args) {
        //更加高效的排序
        int []a ={5,6,3,2,1,6};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

        //依照ASCII码表进行排序，若第一个字母相同，则对比第二个。
        String[]str = {"Jack","ash","Aok","asB","Tom"};
        Arrays.sort(str);
        System.out.println(Arrays.toString(str));
    }
}

6. System

6.1 简述

java.lang.System 类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有一下几种：

static void arraycopy(int[] src, int srcPos, int[] dest, int destPos, int length)
//将数组中指定的数据拷贝到另一个数组中。

long currentTimeMillis();
//获取当前系统时间与1970年01月01日00:00点之间的毫秒差值

6.2 代码部分

public class Demo05String {
    public static void main(String[] args) {
        //获得当前系统时间 - 毫秒
        long time = System.currentTimeMillis();
        String str = "";
        char a = 'a';
        for(int i=0;i<100;i++){
            //建议频繁的字符串拼接不要使用“+”
            str = str.concat(String.valueOf(a));
        }
        System.out.println(str);
        long time1 = System.currentTimeMillis();
        System.out.println(time1-time);
    }
}

import java.util.Arrays;

public class Demo01ArrayCopy {
    public static void main(String[] args) {
        // 需求: 让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));
    }
}