JAVA学习 Day5(常⽤API与static关键字)

回顾

数组排序
面向对象:
类: class 类型 包含:成员变量.成员方法.构造方法
对象: 类的实例化个体
使用对象步骤:
1.定义类
2.创建对象 类型 变量名 = new 类型();
3.变量名.成员变量 变量名.成员方法()
对象成员变量初始化:
构造方法: 方法名和类名相同
没有返回值类型
没写构造方法, 默认添加无参构造方法
class Foo {
String name;
Foo(String name) {
this.name = name
}
}
this关键字: 当前对象
this(); --> 构造方法中占第一行
this.name; --> 调用成员变量
this.method1() --> 调用成员方法
方法的重载:
方法名一样
参数列表不同: 类型,个数,顺序
引用类型数组:
1.数组初始化: 只确定数组长度, 默认元素都是null
Foo[] arr = new Foo[3];
2.元素初始化
arr[0] = new Foo();
没有初始化, 就会出现 null.成员变量, 产生空指针异常
NullPointerException
ArrayIndexOutOfBoundsException
类中:
成员变量 -> field
成员方法 -> method

new Scanner(System.in)
nextLine()
next()
nextInt()
nextDouble()

1.API

JDK中提供的类 API -> 应用程序接口,工具-类
学习类:
就是学习 构造方法 -> 如何创建对象
成员变量 -> 基本可以忽略
成员方法 -> 功能
接触过的类:
System: java.lang.System
Scanner: java.util.Scanner
Math: java.lang.Math
String: java.lang.String
Arrays: java.util.Arrays
程序中,默认import的软件包就是 java.lang

软件包package:
java.lang: 常用类
java.util: 工具类
java.io: 输入输出相关类
java.sql: 数据库相关
java.net: 网络相关
java.text: 格式化相关

2.常用类[一]

1.Random: 构造方法 new Random()
int nextInt(): 产生一个随机整数
int nextInt(int n): 产生一个0~n的随机数
比较Math.random() 和 Random 的使用
1.Math.random() -> 不需要对象,直接调用
Random -> 需要对象
2.Math.random() -> 返回double, 范围固定0~1
Random中的nextInt() -> 返回int, 范围可指定

public class Demo01Random {
    public static void main(String[] args) {
        // 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);
    }
}

2.String - 字符串 -
字符数组直接打印, 就是字符串 -> JVM转换的
字符串特点:
1.直接赋值的字符串, 都存在字符串常量池中, 优化
2.字符串本身不可变
3.字符串不能用 == 来比较

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

public class Demo03StringConstructor {
    public static void main(String[] args) {
        // 1.简单写法
        String s = "hello";
        // 2.无参构造器 -> "" 空的字符串
        String s1 = new String();
        // 3.有参构造 1 -> hello
        String s2 = new String("hello");
        // 4.有参构造 2 -> hello
        char[] chs = {'h','e','l','l','o'};
        String s3 = new String(chs);
        // 5.有参构造 3 -> ell
        String s4 = new String(chs, 1, 3);
        // 6.有参构造 4 -> bcde
        byte[] bs = {98, 99, 100, 101};
        String s5 = new String(bs);
        // 7.有参构造 5 -> cde
        String s6 = new String(bs, 1, 3);
    }
}

package com.zzxx.api;

public class Demo04String {
    public static void main(String[] args) {
        // 构造方式的区别
        // 1.直接赋值
        // 2.new出来的
        String s1 = new String("hello");
        String s2 = new String("hello");
        // 判断s1和s2是否相等
        System.out.println(s1 == s2); // false

        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
    }
}

内存图：

2.常用API
char charAt(int index)
char[] toCharArray()
boolean equals(String)
String substring(int start, int end)
String substring(int start)
boolean startsWith(String)
– 从offset位置开始, 是否以指定字符串打头
boolean startsWith(String, int offset)
boolean endsWith(String)
int indexOf(char)
int indexOf(String)
– 从fromIndex开始往后, 第一次出现char的位置
int indexOf(char, int fromIndex)
int indexOf(String, int fromIndex)
int length()
boolean equalsIgnoreCase(String)
String trim()-- 去掉字符串左右两边的空白字符

public class Demo05StringAPI {
    public static void main(String[] args) {
        String s = "hello@qq.com";
        String s1 = new String("hello");
        // 1.获得某一个下标对应的字符
        char c = s.charAt(0);
        System.out.println("charAt: " + c);
        // 2.字符串比较不能用 s==s1  s1==s
        boolean b = s1.equals(s); // s.equals(s1)
        System.out.println("equals: " + b);
        // 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);
        // 6.判断是否以xx结尾 @qq.com
        boolean b2 = s.endsWith("@qq.com");
        System.out.println("endsWith: " + b2);
        // 7.获得字符串中指定字符第一次出现的位置, 没有字符, 返回-1
        int index = s.indexOf('@');
        System.out.println("indexOf: " + index);
        // 8.截取字符串, s本身没变
        String sub = s.substring(0, 5);
        System.out.println("substring: " + sub);
    }
}

public class Demo06StringAPI2 {
    public static void main(String[] args) {
        String s = " \t    hel   lo \n   ";
        // 1.截取字符串, 从指定位置截取到末尾
        String sub = s.substring(3);
        System.out.println("substring: " + sub);
        // 2.是否以指定字符串开始, 开始位置是offset
        boolean b = s.startsWith("lo", 3);
        System.out.println("startsWith: " + b);
        // 3.获得指定字符串出现的位置
        int index = s.indexOf("qq");
        System.out.println("index: " + index);
        // 4.从指定下标开始往后, 指定字符串第一次出现的位置
        int index1 = s.indexOf("qq", 3);
        System.out.println("index: " + index1);
        // 5.忽略大小写比较
        boolean t = s.equalsIgnoreCase("Hello");
        System.out.println("equals: " + t);

        // 例子: 用户自己输入邮箱地址, 获得对应的用户名

        String trim = s.trim();
        System.out.println(trim);

    }
}

其他方法：
concat
toUpperCase
toLowerCase
contains
replace
3.Scanner
Scanner console = new Scanner(System.in);

3.static 修饰词

有一些类的方法在使用时, 不需要创建对象
static: 静态的
1.修饰成员变量
属于类的, 所有对象共用
通过类名.调用
只有一个

2.修饰方法

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

xx.java -> xx.class -> 类加载 -> JVM方法区中
静态的成员变量是和类一起加载到方法区中的
结论: 当使用静态成员变量时, 对象不一定存在

类什么时候会加载?
第一次使用类会加载, 并且只加载一次
使用类的情况:
创建对象
调用类的静态成员变量
调用类的静态方法

public class Demo03StaticBlock {
    public static void main(String[] args) {
        // 使用类的三种情况
        // 1.创建对象
        Child c = new Child();
        Child c1 = new Child("小明", 3);

        // 2.调用静态成员变量
//        Child.money ++;

        // 3.调用静态方法
//        Child.cry();
    }
}

类加载会执行什么代码?
1.静态代码块
2.静态成员变量

/**
 * 静态的成员变量:
 *   1.属于类
 *   2.通过类名. 调用 例如 Child.money
 *   3.只有一个
 *
 * 普通成员变量:
 *   1.属于对象
 *   2.通过对象. 调用 例如 c1.name
 *   3.有几个对象, 就有几个成员变量
 *
 * 静态方法:
 *   1.属于类
 *   2.通过类. 调用 例如 Child.cry()
 *   3.在静态方法中, 不能直接使用普通成员变量和成员方法
 *   4.在普通方法中, 可以直接使用静态变量和静态方法
 */
public class Child {
    String name;
    int age;
    // 通常是声明的同时初始化
    static int money;
    // 静态代码块 -> 给类初始化 - 类加载时执行的
    static {
        money = 1000;
        System.out.println("静态代码块被执行了");
    }
    // 代码块: 调用构造器之前
    // 给对象初始化, 提取所有构造方法中重复的代码
    {
        money++;
        System.out.println("代码块");
    }
    Child () {
        System.out.println("无参构造器");
    }
    Child(String name, int age) {
        this.name = name;
        this.age = age;
        // 通常静态成员变量不会在构造方法中初始化
        // money = 100;
        System.out.println("有参构造器");
    }
    static void cry() {
        System.out.println(/*name +*/ "在放声哭!");
//        this.sleep();
    }
    void sleep() {
        cry();
        System.out.println(name + "在睡觉觉!");
        System.out.println("抱着" + money + "的零花钱");
    }
}

java.lang.Math:
double Math.random(): 返回0.0~1.0 之间的随机数
double Math.pow(double a, double b): 返回 a 的 b 次幂
java.util.Arrays:
String Arrays.toString(数组): 以[元素1, 元素2]格式打印数组

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

数组 [1,2,3,4,5], 添加一个 6
1.数组扩容: 创建新的数组
int[] arr = {1,2,3,4,5};
arr = new int[6]; // [1,2,3,4,5,0]
2.将原来的元素复制到新数组中

数组赋值:
void System.arraycopy(src, srcPos, dest, destPos, count)

练习

生成一套双色球号码
红球: 1~33 随机, 不能重复, 生成5个号
按照升序排序
蓝球: 1~16 随机, 1个 加到数组的最后

int[] red = new int[5];
扩容1位, 加蓝球

import java.util.Arrays;
import java.util.Random;

/*  生成一套双色球号码
          红球: 1~33 随机, 不能重复, 生成5个号
          按照升序排序
          蓝球: 1~16 随机, 1个 加到数组的最后

          int[] red = new int[5];
          扩容1位, 加蓝球*/
public class DoubleColorBall {
    public static void main(String[] args){
        Random r = new Random();
        int[] red = new int[5];
        int[] blue = new int[6];
        for(int i = 0; i < 5; i++){
            red[i] = r.nextInt(33) + 1;
        }
        //System.arraycopy方法
        System.arraycopy(red, 0, blue , 0, 5);
        blue[5] = r.nextInt(15) + 1;
        System.out.println(Arrays.toString(blue));
        //Arrays.copyOf方法
        red = Arrays.copyOf(red, red.length + 1);
        red[5] = r.nextInt(15) + 1;
        System.out.println(Arrays.toString(red));
    }
}