Java学习笔记

最新推荐文章于 2025-03-24 10:23:16 发布

原创最新推荐文章于 2025-03-24 10:23:16 发布 · 置顶 · 298 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

笔记专栏收录该内容

16 篇文章

订阅专栏

图片显示可能会异常，这主要是我的图片都是基于本地文件夹，更完整的内容存储在Hexo Blog：印

Java笔记

关键字是java内置的
标识符是用户定义的，不得以数字开头
命名规范：
- 类名称用大驼峰，所有单词首字母大写
- 变量名用小驼峰，首单词首字母小写其它单词首字母大写
双引号" "引起的是字符串常量，整数常量，有小数点的默认是浮点数，精度默认double，字符由单引号' '引用不能连着否则为空，亦不可以有多个字符 ，布尔常量true & false，空常量null不可以直接打印
数据类型分为基本数据类型 （整数型：byte、short、int、long；浮点型：float，double；字符型：char；布尔型：Boolean）和引用数据类型 （字符串、数组、类、接口、Lambda）
数据范围与字节数不一定相关，例如float的数据范围比long更广泛，但是float是4字节，long是8字节，注意float不可能准确

整数默认int，否则需要加后缀；浮点数默认是double，否则需要加后缀
创建变量：数据类型变量名称，创建多个变量不得重名，byte和short右侧的数据值必须在左侧类型的范围内
变量必须赋值以后才可以使用，变量的使用取决于其作用域，超出作用域是不可使用的，这里还需要注意先声明赋值即初始化 再使用

数据类型转换

数据类型不一样时会发生数据类型转换

自动转换

即隐式转换，数据范围由小到大long num1 = 100左边是long右边是int，double num2 = 3.14F，float num3 = 34L记住数据范围与字节数不一定相关

强制转换

不符合自动转换规则时使用，int num = 100L(error)。使用时的格式：范围小的类型范围小的变量名 = (范围小的类型) 原本范围大的数据，int num = (int) 100L注意这里的数据范围指的是类型的范围而不是实际的范围（100显然没有超出L的范围）

强制转换不推荐使用 有可能会导致精度损失或者数据溢出
byte/short/char这三种类型都可以发生数学运算，会先提升为int然后再计算，例如byte+byte超过了int可以将返回值提升为int即：int = byte+byte
布尔类型不能发生数据类型转换，即不可以认为是1和0

编码

Unicode码(万国码)>ASCII码表

运算符和表达式

进行特定操作 的符号，表达式是用运算符连起来的式子 ，一旦运算当中有不同类型的数据，结果取范围大 的类型。

+：对于数值来说就是加法，对于字符就是升级为int后的加法，对于字符串就是字符串连接，任何数据类型和字符串连接时都会显示为字符串str+20+30 = str2030改变优先级str+(20+30)=str50
自增--和自减++: 基本含义是变量增加或减少1。单独使用时 ：++num和numm++无区别；混合使用时 ：A:++num时变量立刻+1，并使用该结果。B:num++时先使用变量，再+1(注意print时也是这样！！！)
赋值运算=,+=,-=,/=,*=
比较运算注意< = 和 > = 和 ! = 和==即等号在右侧，返回值时Boolean ，多次比较不可以连着写2<3<4(error)需要逻辑运算符拆分
逻辑符号：&& || !，与或非，有一种用法：短路 如果根据左侧就可完成判断就可以不执行右边，例如&&左边false和||左边true时右边就可跳过，返回值均为Boolean
三元运算符：需要三个数据才可以操作的运算符数据类型变量名称 = 条件判断？表达式A : 表达式B注意在这里的条件判断不能是3 > 4 ? 1 : 2因为3>4不是条件判断而是false，三元的结果必须使用即左侧必须有结果

方法

定义格式：（入门）

public static void 方法名() {
    方法体
}

注意方法定义的先后顺序无要求，方法不能产生嵌套关系 ，方法定义后不会执行需要调用，方法调用方法：

方法名();

JShell

cmd > JShell ，使用类似于python脚本 ，轻量情况下使用。

jshell> int a = 10
a ==> 10
jshell> a*a
$2 ==> 100
jshell>/exit
退出

编译器的简两点优化

byte num1 = 10 //这里的10是int，左边的num1是byte，不符合自动转换，但也没有强制转换，但是语句执行不会报错

对于byte/short/char三种类型来说，如果右侧值没有超过范围，那么javac会自动补上(char)强制转换，如果超过了，报错。

byte/short/char发生运算自动提升为int类型！！！

short a = 5;
short b = 8;

//short result = a+b;
//(Error)short + short => int + int => int

short result = 5 + 8;//编译器不会报错

变量赋值时如果右侧全是常量，那么javac会优先将多个常量计算即

short result = 5 + 8;
short result = 13;
//等价

编译器常量优化

流程控制

顺序结构

顺序执行

判断结构

//if结构
if(关系表达式) {
	语句体;
}

//if-else结构
if(关系表达式) {
	语句体;
}else if(关系表达式) {
	语句体;
}else {
	语句体;
}

选择结构
```
switch(表达式) {
    case 常量1: 语句体1;
        break;
    case 常量2: 语句体2;
        break;
    default: 语句体n+1;
        break;
}
```
无break会穿透，一直向下执行直到break或者结束，即case是起点，break或者结束是终点，switch的括号中只能是下列数据类型：

1.基本数据类型：byte/short/char/int

2.引用数据类型：String字符串、enum枚举

循环结构

初始化表达式：只执行一次

//for循环
for(初始化表达式,条件判断,步进语句) {
    循环体;
}
//while循环
while(boolean表达式) {
    循环体;
    步进语句;
}
//步进语句在循环体内

//do-while循环
//与while类似，但先执行一次循环体，结尾一定要有分号应为while()是个语句
do() {
} while();

break语句跳出整个循环，continue语句跳出单次循环继续开始余下的循环，注意死循环后的语句不可执行，error。

IntelliJ IDEA

结构：
项目project->模块module->包package

快捷键：

按住ctrl+鼠标点击方法 快速查看
Alt+4 显示输出窗口

方法

方法的格式

方法就是若干语句的集合，有参数和返回值

修饰符 返回值类型 方法名称(参数类型 参数名称) {
    方法体;
    return 返回值;
}

参数有多个用逗号分隔，return 停止方法，亦可返回值到调用处，注意类型的一致性

方法的三种调用

单独调用

调用方法不做其它操作
```
sum(a,b)
```
打印调用

调用后print
```
System.out.println(sum(a,b))
```
赋值调用
```
int num = sum(a,b)
```
方法的调用过程，找到方法的定义，执行方法语句，返回值到调用处，void的return后面不可有值，可以省略return，可以有多个return，但是保证只有一个可以被执行

方法的重载

对于功能类似但是参数不同的方法来说可以使用重载(Overload)，即方法名称相同，但是参数列表不相同

package com.itcast.day04.demo04;
/*对于功能类似但是参数不同的方法来说可以使用重载(Overload)
* 方法名称相同，但是参数列表不相同
* */
public class Demo1MethodOverload {
    public static void main(String[] args) {
        int a=10,b=20,c=30,d=40;
        System.out.println(sum(a,b));
        System.out.println(sum(a,b,c));
    }
    
    public static int sum(int a,int b) {
        return a + b;
    }
    
    public static int sum(int a,int b,int c) {
        return a + b + c;
    }
}

注意事项：

参数个数不同
参数类型不同
参数的多类型顺序不同
与参数名称无关，即参数列表只有参数名称不同是错误的
与方法的返回值无关，即方法列表相同，但是返回值类型相同，也是错误的
与修饰符无关，即与static、public等无关，也与返回类型无关，即只看名称及其参数列表

数组

package com.itcast.day05.demo01;
/*数组是一种容器，可以存放多个数值，
* 特点：
* 1.数组是一种引用类型
* 2.数组的多个数据类型统一
* 3.数组的长度在程序运行期间不能改变
*
* 数组的初始化，创建数组并赋值
* 1.动态初始化(指定长度)
* 2.静态初始化(指定内容)
*
* 动态初始化的格式
* 数据类型[] 数组名称 = new 数据类型[数组长度];
* 左右数据类型一致，数组长度是一个int数字*/
public class Demo01Arry {
    public static void main(String[] args) {
        //动态初始化
        int[] arryA = new int[300];
    }
}

package com.itcast.day05.demo01;
//静态数组在创建时不指定长度，但是指定内容,由此获得长度
/*基本格式
* 数据类型[] 数组名称 = new 数据类型[] {元素1,元素2,....}*/
public class Demo02Arry {
    public static void main(String[] args) {
        int[] arryA = new int[] {5,15,25};
    }
}

package com.itcast.day05.demo01;
/*初始化可以拆分来写*/
public class Demo03Arry {
    public static void main(String[] args) {
        int[] arryC;
        arryC = new int[] {1,2,3};
        int[] arryD;
        //arryD = {1,2,3};error
    }
}

package com.itcast.day05.demo01;
//直接打印数组名称获得的是内存地址的哈希值
public class Demo04ArryUse {
    public static void main(String[] args) {
        int[] arry = {10,20};
        System.out.println(arry);//[I@5f184fc6 第一个符号I是表明int,[表明是数组,后面的是十六进制地址
        System.out.println(arry[0]);//索引由0开始

        /*如果是动态初始化
        * 会默认赋值
        * 整型：0
        * 浮点型：0.0
        * 字符型：'\u0000'(十六进制，不是空格)
        * 布尔类型：false
        * 引用类型：null
        */
        
        /*静态初始化也有默认值过程，但是很快就通过{}赋值
        * */
        int[] arryD = new int[3];
        arryD[1] = 123;
        System.out.println(arryD);
        System.out.println(arryD[0]);
        System.out.println(arryD[1]);
        System.out.println(arryD[2]);
        System.out.println("============");
    }
}

//数组赋值，将int[]视为整体理解
int[] arryA = arryB;

Java的内存划分

划分为5个部分

栈(Stack)：存放的都是方法中的局部变量。
- 局部变量：方法的参数，或者方法{}的变量
- 作用域：一旦超出作用域，立刻从栈内存中消失
方法一定在栈运行
堆(Heap)：凡是new 出来的东西都在堆中。
- 堆内存中的内容都有一个十六进制 的地址
- 堆内存的数据都有默认值：规则
  - 整型：0
  - 浮点型：0.0
  - 字符型：’\u0000’(十六进制，不是空格)
  - 布尔类型：false
  - 引用类型：null
方法区(Method Area)：存储.class 的相关信息，包含方法的信息
本地方法栈(Native Method Stack)：与操作系统相关
寄存器(pc Register)：与CPU相关

一个数组的内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ib4d6qE3-1598282525172)(./Java笔记/一个数组的内存图.png)]

两个数组的内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xwcMScBt-1598282525175)(Java笔记/两个数组的内存图.png)]

两个引用指向一个数组的内存图

int[] arryA = arryB; 没有new 说明没有开辟新堆内存

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EtDj5YwN-1598282525176)(./Java笔记/两个引用指向一个数组的内存图.png)]

借助数组返回多个结果

对于一个方法，如果希望返回多个数据值，可以返回一个数组类型。数组作为参数，传入的是地址，返回的也是地址。

面向对象编程

package com.itcast.day06.demo01;

import java.util.Arrays;

/*面向过程实现一个功能时，每一个步骤都需要亲历亲为的处理
* 面向对象，实现一个功能时不关心具体的步骤，而是找一个具有该功能的对象*/
public class Demo01PrintArray {
    public static void main(String[] args) {
        //面向过程
        int[] array = {10,20,30,40,50};
        System.out.print("[");
        for(int i=0;i<array.length;i++) {
            if(i== array.length-1) {
                System.out.println(array[i]+"]");
            }else {
                System.out.print(array[i]+",");
            }
        }
        System.out.println("=================");
        //面向对象
        System.out.println(Arrays.toString(array));
    }
}

面向对象的三大特征

封装
继承
多态

类的定义

属性（是什么）+行为（能做什么）= 成员变量+成员方法

package com.itcast.day06.demo01;

/*成员变量定义在类当中方法外
* 成员方法不写static(在本例)*/

public class Student {
    //成员变量
    String name;//名字
    int ages;//年龄

    public void eat() {
        System.out.println("吃饭饭！！！");
    }
    public void sleep() {
        System.out.println("睡觉觉！！！");
    }
    public void study() {
        System.out.println("学习习！！！");
    }
}

封装性

package com.itcast.day06.demo03;
/*方法就是一种封装
* 关键字private也是一种封装
* main并不关心getMax方法的实现，只关心它的功能，这些功能封装在getMax中
* 对外是透明的，不可见*/
public class Demo02Metod {
    public static void main(String[] args) {
        int[] array = {14, 1, 90, 23, 85, 739, 1, 851};
        int max = getMax(array);
        System.out.println(max);
    }

    public static int getMax(int[] array) {
        int max = array[0];
        for(int i = 0;i < array.length;i++) {
            if(array[i] > max) {
                max = array[i];
            }
        }
        return max;
    }
}

构造方法

package com.itcast.day06.demo03;

/*构造方法是专门用来创建对象的方法，我们在使用关键字new时其实就是在调用构造方法
* 格式：
* public 类名称(参数类型 参数名称) {
*   方法体;
* }
* 构造方法和类名称完全一样
* 不写返回类型，包括void，不return返回值，注意首字母也大写（一般方法不大写）
* 如果没有编写，编译器自行构建默认方法
* 编写构造方法后，默认方法不添加
* 构造方法可以重载*/

import java.sql.SQLOutput;

public class Person {
    public static void main(String[] args) {
        Person person = new Person(100);
        person.setName("lsj");
        System.out.println(person.getName());
    }
    String name;
    public Person() {
        System.out.println("方法调用了");
    }
    public Person(int num) {
        System.out.println(num);
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
}

常用的API

1.60的JDK API有官方的简体中文版

以scanner为例

package com.itcast.day06.demo04;

import java.util.Scanner;

/*引用类型使用的基本步骤
* 1.导包
* import 包路径.类名称
* 只有java.lang包下的内容不需要导包
* 2.创建
* 类名称 对象名 = new 类名称();
* 3.使用
* 对象名.方法名()
* 获取一个键盘输入的int数字：int num = sc.nextInt();
* 获取一个键盘输入的String字符：String str = sc.next();*/

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);//从键盘输入
        String str = sc.next();
        System.out.println(str);
        int num = sc.nextInt();
        System.out.println(num);
    }
}

以求最值为例

package com.itcast.day06.demo04;

import java.util.Scanner;

public class ScannerMax {
    public static void main(String[] args) {
        Scanner console = new Scanner(System.in);
        System.out.println("请输入第一个数字：");
        int num1 = console.nextInt();
        System.out.println("请输入第二个数字：");
        int num2 = console.nextInt();
        System.out.println("请输入第三个数字：");
        int num3 = console.nextInt();

        int temp = num1 > num2 ? num1 : num2;
        int max = temp > num3 ? temp : num3;
        System.out.println("最大值是："+max);
    }
}

匿名对象的说明

package com.itcast.day06.demo04;

import com.itcast.day06.demo03.Person;

/*只有右侧的对象没有类名称：new类名称
* 匿名对象一个只能使用一次*/
public class Demo01Anonymos {
    public static void main(String[] args) {
        new Person().getName();
    }
}

匿名对象作为参数和返回值

package com.itcast.day06.demo04;
/*匿名对象可以用于传参
* 匿名对象也可以作为返回值*/
import java.util.Scanner;

public class Demo02Anonymous {
    public static void main(String[] args) {
        int num = new Scanner(System.in).nextInt();
        System.out.println(num);
    }
}

Random概述及使用

package com.itcast.day06.demo05;

import java.util.Random;

/*创建
* Random r = new Random()
* 使用
* int num = r.nextInt()如果括号为空在int范围内有负有正
* int num = r.nextInt(10),左闭右开区间在0-9*/
public class RandomDemo {
    public static void main(String[] args) {
        Random r = new Random();
        int num = r.nextInt();
        System.out.println(num);

        for(int i = 0;i<10;i++) {
            System.out.println(r.nextInt(10));
        }
    }
}

对象数组

package com.itcast.day06.demo05;

import com.itcast.day06.demo03.Person;

public class DemoArrayObject {
    public static void main(String[] args) {
        //首先创建一个长度为3的数组，里面用来存放Person对象
        Person[] array = new Person[3];
        Person one = new Person();
        Person two = new Person();
        Person three = new Person();

        array[0] = one;
        array[1] = two;
        array[2] = three;

    }
}

ArrayList集合

package com.itcast.day06.demo05;

/*数组的长度不可改变
* 集合的长度可以改变
* <E>尖括号表示泛型E表示具体的泛型
* 泛型是在集合中所有的元素都是统一的某个类型
* 泛型只能是引用类型*/

/*注意事项：
* 对于ArrayList集合来说，直接打印获得的不是地址而是内容
* 如果内容1为空，则得到[]*/

import java.util.ArrayList;

public class Demo01ArrayList {
    public static void main(String[] args) {
        //jdk1.7以后下式右侧尖括号内可以不写类型，因为与左侧相同ArrayList<>
        ArrayList<String> list = new ArrayList<String>();
        System.out.println(list);//[]

        //向集合中添加数据
        list.add("张飞");
        list.add("刘备");
        list.add("关羽");
        list.add("诸葛亮");
        System.out.println(list);
    }
}

ArrayList的常用方法

package com.itcast.day06.demo05;

/*ArrayList常用的方法有:
* public boolean add(E,e)：向集合中添加元素，参数的类型和泛型一致
* public E get(int index)：从集合中获取索引值对应的元素，返回值为该元素
* public E remove(int index)：从集合中删除索引对应的元素
* public int size()：获取集合的元素个数*/

import java.util.ArrayList;

public class DemoArrayListMethod {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);

        //添加元素
        boolean state = list.add("刘燕");//对于一些集合可能添加不成功，但是ArrayList一定可以
        System.out.println("添加状态："+state);
        System.out.println(list);
        list.add("张飞1");
        list.add("张飞2");
        list.add("张飞3");
        list.add("张飞4");
        list.add("张飞5");
        list.add("张飞6");
        list.add("张飞7");
        System.out.println("========================");
        System.out.println(list);

        //获取元素
        String name = list.get(2);
        System.out.println(name);

        //删除元素
        list.remove(2);
        System.out.println(list.get(2));

        //获取尺寸
        int size = list.size();
        System.out.println(size);
    }
}

ArrayList的泛型只能是引用类型在处理基本类型时：

package com.itcast.day06.demo05;

/*如果希望集合ArrayList当中存储基本数据类型，必须使用基本类型对应的包装类
* 基本类型 包装类
* byte Byte
* short Short
* int Integer 【】
* long Long
* float Float
* double Double
* char Character 【】
* boolean Boolean*/

/*从JDK1.5+开始支持自动装箱和拆箱
* 自动装箱：基本类型-->包装类型
* 自动拆箱：包装类型-->基本类型*/

import java.util.ArrayList;

public class DemoArrayListBasic {
    public static void main(String[] args) {
        //泛型E只能是引用类型，不能是基本类型
        ArrayList<String> listA = new ArrayList<>();
        //Error，这主要是因为集合保存的都是地址值
        //ArrayList<int> listB = new ArrayList<int>();
        //可以使用包装类
        ArrayList<Integer> listB = new ArrayList<>();
        listB.add(100);

        //* 自动装箱：基本类型-->包装类型
        //* 自动拆箱：包装类型-->基本类型
        //可以发现num是int而不是Integer
        int num = listB.get(0);
        System.out.println(num);

    }
}

存储自定义对象

public class student {

}
ArrayList<student> list = new ArrayList<>();
Student stu = list.get(0);

字符串

字符串的构造

package com.itcast.day06.demo06;
/*程序中凡是带有""都是字符串
* 字符串的特点：
* 字符串的内容不可变
* 所以字符串可以共享使用节省内存
* 效果上相当于char[]字符数组，但是底层原理时byte[]字节数组*/

/*String字符串的构造
* public String()创建一个空白字符串，不含任何内容
* public String(char[] array)根据字符数组内容创建字符串
* public String(byte[] array)同上
* String str = "你好"虽然没new但也是字符串*/
public class Demo01String {
    public static void main(String[] args) {
        String str1 = new String();
        System.out.println(str1);

        char[] charArray = {'A','B','C'};
        String str2 = new String(charArray);
        System.out.println(str2);

        byte[] byteArray = {97,98,99};
        String str3 = new String(byteArray);
        System.out.println(str3);

        String str4 = "abcd";
        System.out.println(str4);
    }
}

字符串的常量池

package com.itcast.day06.demo06;
/*字符串常量池，程序中只有写上双引号""内的字符串在字符串常量池中
* 对于基本类型：==进行的是数值比较
* 对于引用类型：==进行的是地址值比较
* */
public class Demo02String {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";

        char[] charArry = {'a','b','c'};
        String str3 = new String(charArry);//new后不在常量池

        System.out.println(str1==str2);//true
        System.out.println(str1==str3);//false
        System.out.println(str2==str3);//false
    }
}

字符串常量池的内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aExB8XPp-1598282525178)(Java笔记/字符串常量池的内存图.png)]

字符串的一些方法

内容比较方法:equals

package com.itcast.day06.demo06;
/*内容比较而不是==的的地址比较*/
/*
* equals具有对称性
* 常量+变量对比建议写法，字符常量.equals()
*/
public class Demo03StringEquals {
    public static void main(String[] args) {
        String str1 = "Hello";
        char[] charArray = {'H','e','l','l','o'};
        String str2 = new String(charArray);

        System.out.println(str1.equals(str2));
        System.out.println("Hello".equals(str2));
        
        "hello".equalsIgnoreCase(str1);//忽视大小写
    }
}

获取的相关方法

package com.itcast.day06.demo06;

/*public int length()：获取字符串中含有的字符个数即长度
* public String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串
* public char charAt(int index)：获取指定索引位置的单个字符from 0
* public int indexOf(String str)：查找参数字符串在本字符串中首次出现的位置，如果没有返回-1
* */

public class demo4StringGets {
    public static void main(String[] args) {
        int length = "afsbggzrsfdsffadsfasd".length();
        System.out.println(length);

        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);//字符串是常量str1和str2原封不动，新创建了str3
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);

        char ch = "Hello World".charAt(1);
        System.out.println(ch);

        String original = "Hello World Hello World";
        int index = original.indexOf("llo");
        System.out.println(index);
        System.out.println(original.indexOf("bye"));
    }
}

截取的相关方法

package com.itcast.day06.demo06;

/*截取方法
* public String subString(int index)：截取index开始的字符串至结尾并返回新的字符串
* public String subString(int begin,int end)：截取index的左闭右开区间字符串返回一个新的字符串
* */

public class Demo05SubString {
    public static void main(String[] args) {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5);
        System.out.println(str1);//字符串不变
        System.out.println(str2);

        String str3 = str1.substring(4,7);
        System.out.println(str3);

        // 注意一种混淆，即str只是存储的地址值，地址值是可变的
        // 地址可变导致指向的字符串改变，但是原有地址的字符串是没变的
        // 具体如下：
        String strA = "Hello";
        System.out.println(strA);
        strA = "Java";
        System.out.println(strA);
    }
}

字符串的转换方法

package com.itcast.day06.demo06;

/*public char[] toCharArray()：将当前字符串拆分成字符数组返回值
* public byte[] getBytes()：获得当前字符串底层字节数组
* public String replace(CharSequence oldString,CharSequence newString)
* 将所有老的字符串替换成新的字符串返回替换后的新字符串*/

public class
Demo06StringCovert {
    public static void main(String[] args) {
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]);
        System.out.println(chars.length);

        byte[] bytes = "abc".getBytes();
        for(int i = 0;i < bytes.length;i++) {
            System.out.println(bytes[i]);
        }

        String str1 = "How do you do?";
        String str2 = str1.replace("o","*");//注意这里的是""是字符串虽然只有一个
        System.out.println(str2);
    }
}

字符串的分割方法

package com.itcast.day06.demo06;

/* 字符串的分割方法
* public String[] split(String regex)
* regex是一个正则表达式，如果按照句点"."分割需要写为"\\."*/

public class Demo07StringSplit {
    public static void main(String[] args) {
        String str1 = "aaa,bbb,ccc";
        String[] array1 = str1.split(",");
        for(int i = 0;i<array1.length;i++) {
            System.out.println(array1[i]);
        }
    }
}

static静态关键字

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m4011jAi-1598282525179)(Java笔记/static关键字分析图.png)]

修饰成员变量

package com.itcast.day06.demo07;

/*如果一个成员变量使用了static关键字，那么这个变量不属于对象自己，而是属于所在的类，多个对象共享这一份数据*/

public class Demo01Static {
    public static void main(String[] args) {
        Student one = new Student("张飞",19);
        one.room = "101教室";//只对one赋值
        System.out.println("姓名："+one.getName()+"年龄："+one.getAge()+"教室："+one.room+ "学号：" +one.getId());
        Student two = new Student("关羽",20);
        System.out.println("姓名："+two.getName()+"年龄："+two.getAge()+"教室："+two.room+"学号："+two.getId());
    }
}

//类定义

package com.itcast.day06.demo07;

public class Student {
    private int id;
    private String name;
    private int age;
    static String room;
    private static int idCounter = 0;//new就++

    public Student() {
        idCounter++;
    }

    public int getId() {
        return id;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCounter;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

修饰成员方法

package com.itcast.day06.demo07;

/*一旦使用static修饰了成员方法那么就是静态方法，静态方法不属于对象而是属于类
* 如果没有static关键字，那么需要先创建对象才能使用它
* 无论是成员变量还是成员方法，如果是静态的，建议用类调用而不是对象
* 注意
* 1.静态不能直接访问非静态
* 原因：内存中现有静态内容，后有非静态内容，故而不可以
* 2.静态方法中不能用this
* 原因：因为this代表当前对象，而静态方法和变量与对象无关*/

public class Demo02StaticMethods {
    public static void main(String[] args) {
        //先创建对象才能使用没有static的方法
        MyClass obj = new MyClass();
        obj.method();

        //可以创建对象调用静态方法，也可以直接用类调用
        obj.methodStatic();//不推荐，也会被翻译为下一行
        MyClass.methodStatic();//推荐

        //对于本类自己的静态方法，可以省略类名称
        myMethod();
    }
    public static void myMethod() {
        System.out.println("自己的方法！");
    }
}

//Class定义

package com.itcast.day06.demo07;

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);Error静态方法不可以访问静态变量
    }
}

静态static内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dO2b45qQ-1598282525180)(Java笔记/静态static内存图.png)]

静态代码块

package com.itcast.day06.demo07;

/*静态代码块
* public class 名称 {
*   static {
*   }
* }
* 特点：当第一次用到本类时，静态代码块执行唯一的一次*/

public class Person {
    static {
        System.out.println("静态代码块执行！");
    }
    public Person() {
        System.out.println("构造方法执行！！！");
    }
}

package com.itcast.day06.demo07;

/*静态内容总是优先执行，且执行一次*/

public class DemoStaticBlock {
    public static void main(String[] args) {
        Person one = new Person();
        Person two = new Person();
    }
}

静态代码块执行！
构造方法执行！！！
构造方法执行！！！

数组工具类

package com.itcast.day06.demo08;

/*java.util.Arrays是一个与数组相关的工具类，里面提供了大量的静态方法
*
* public static String toString(数组)：将参数数组变成字符串（默认格式）
* public static void sort(数组)：按照由小到大排序
* 注意：
* 如果是数值，sort按默认升序由小到大
* 如果是字符串，sort按照字母升序
* 如果是自定义类型，需要由Comparable和Comparator接口的支持*/

import java.util.Arrays;

public class DemoArrays {
    public static void main(String[] args) {
        int[] intArray = {10, 20, 30};
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr);

        int[] array1 = {21,34,14,5,21};
        Arrays.sort(array1);//返回的是void无返回值不返回新数组，对原数组操作
        System.out.println(Arrays.toString(array1));

        String[] array2 = {"bbb","aaa","ccc"};
    }
}

数学工具类Math

package com.itcast.day06.demo09;

/*常用方法
* public static double abs(num)：获取绝对值
* public static double ceil(num)：向上取整
* public static double flor(num)：向下取整
* public static long round(num)：四舍五入
* */

public class DemoMath {
    public static void main(String[] args) {
        System.out.println(Math.abs(-Math.PI));
        System.out.println(Math.ceil(21.5));
        System.out.println(Math.floor(21.5));
        System.out.println(Math.round(21.5));
    }
}