Java 基础语法

技术思考者

已于 2023-08-27 22:14:51 修改

阅读量223

点赞数 1

分类专栏： Java 文章标签： java 开发语言

于 2023-08-04 22:09:29 首次发布

本文链接：https://blog.csdn.net/m0_56925275/article/details/132113016

版权

Java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

Java 命名规范

项目名、包名全部小写。
类名命名首字母大写（大驼峰：首字母大写，若有多个单词组成，其余单词首字母也大写）。
```
例：DemoJavaClassName
```
方法名、参数名、成员变量、局部变量（小驼峰：若有多个单词组成，第一个单词首字母小写，其余单词首字母大写）
```
例：demoJavaMethodName
```
常量命名全部大写，单词间用下划线隔开，力求语义表达清楚，不要嫌名字长。
```
例：public static final String JAVA_CONSTANT = "javaConstant";
```
所有命名规则必须遵守以下规范：
- 名称只能由字母、数字、下划线_、$符号组成。
- 不能以数字开头。
- 名称不能使用 Java 中的关键字。
- 坚决不允许出现中文及拼音命名。
- 避免使用单个字符或者数字作为命名，除非是计数器或者临时变量。

Java 注释

Java 注释的作用

对代码进行说明和解释的文本。

Java 共有三种注释

单行注释

以双斜线（//）开头，从开头到行末的所有内容都会被注释掉。

// 这是一个单行注释
int age = 18; // 这是一个变量的声明

多行注释

以斜线加星号（/）开头，以星号加斜线（/）结尾。可以跨越多行。

/*
这是一个多行注释
它可以跨越多行
*/
int age = 18; // 这是一个变量的声明

文档注释

以斜线加星号加两个星号（/**）开头，以星号加斜线（*/）结尾。用于生成文档，可以被工具提取并生成 API 文档。

/**
 * 这是一个文档注释
 * 它可以被工具提取并生成 API 文档
 */
public class MyClass {
    // 类的内容
}

注释在代码中起到了重要的作用，它可以帮助他人理解代码的含义、用途和实现方式。良好的注释可以提高代码的可读性和可维护性。在编写代码时，建议养成良好的注释习惯。

注意事项

在编译过程中，注释会被编译器忽略，不会被包含在最终的可执行文件中，它只存在于源码中，对代码进行解释说明。

Java 关键字

关键字

关键字	含义
abstract	表明类或者成员方法具有抽象属性
assert	断言，用来进行程序调试
boolean	基本数据类型之一，声明布尔类型的关键字
break	提前跳出一个块
byte	基本数据类型之一，字节类型
case	用在switch语句之中，表示其中的一个分支
catch	用在异常处理中，用来捕捉异常
char	基本数据类型之一，字符类型
class	声明一个类
const	保留关键字，没有具体含义
continue	回到一个块的开始处
default	默认，例如，用在switch语句中，表明一个默认的分支。Java8 中也作用于声明接口函数的默认实现
do	用在do-while循环结构中
double	基本数据类型之一，双精度浮点数类型
else	用在条件语句中，表明当条件不成立时的分支
enum	枚举
extends	表明一个类型是另一个类型的子类型。对于类，可以是另一个类或者抽象类；对于接口，可以是另一个接口
final	用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量
finally	用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float	基本数据类型之一，单精度浮点数类型
for	一种循环结构的引导词
goto	保留关键字，没有具体含义
if	条件语句的引导词
implements	表明一个类实现了给定的接口
import	表明要访问指定的类或包
instanceof	用来测试一个对象是否是指定类型的实例对象
int	基本数据类型之一，整数类型
interface	接口
long	基本数据类型之一，长整数类型
native	用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new	用来创建新实例对象
package	包
private	一种访问控制方式：私用模式
protected	一种访问控制方式：保护模式
public	一种访问控制方式：共用模式
return	从成员方法中返回数据
short	基本数据类型之一,短整数类型
static	表明具有静态属性
strictfp	用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范
super	表明当前对象的父类型的引用或者父类型的构造方法
switch	分支语句结构的引导词
synchronized	表明一段代码需要同步执行
this	指向当前实例对象的引用
throw	抛出一个异常
throws	声明在当前定义的成员方法中所有需要抛出的异常
transient	声明不用序列化的成员域
try	尝试一个可能抛出异常的程序块
void	声明当前成员方法没有返回值
volatile	表明两个或者多个变量必须同步地发生变化
while	用在循环结构中

分组

按用途划分为如下几组：

用于数据类型的关键字有：boolean、byte、char、 double、 float、int、long、new、short、void、instanceof。
用于语句的关键字有：break、case、 catch、 continue、 default 、do、 else、 for、 if、return、switch、try、 while、 finally、 throw、this、 super。
用于修饰的关键字有：abstract、final、native、private、 protected、public、static、synchronized、transient、 volatile。
用于方法、类、接口、包和异常的关键字有：class、 extends、 implements、interface、 package、import、throws。

还有些关键字，如：future、 generic、 operator、 outer、rest、var等都是Java保留的没有意义的关键字。

另外，Java还有3个保留字：goto、const、null。它们不是关键字，而是文字。包含 Java 定义的值。和关键字一样，它们也不可以作为标识符使用。

Java 关键字的特点

都是小写。
都是完整的单词。

数据类型

Java中的数据类型分为两大类，基本数据类型和引用数据类型。

基本数据类型

基本数据类型只有8种，可按照如下分类
① 整数类型：long、int、short、byte
② 浮点类型：float、double
③ 字符类型：char
④ 布尔类型：boolean

No.	数据类型	大小/位	可表示数据范围	默认值
1	byte（字节型）	8	-128~127	0
2	short（短整型）	16	-32768~32767	0
3	int（整型）	32	-2147483648~2147483647	0
4	long（长整型）	64	-9223372036854775808~9223372036854775807	0
5	float（单精度）	32	-3.4E38~3.4E38	0.0
6	double（双精度）	64	-1.7E308~1.7E308	0.0
7	char（字符）	16	0~255	‘\u0000’或’ ’
8	boolean（布尔）	-	true或false	false

数据类型转换

自动转换

小类型转成大类型

在这里插入图片描述

强制转换

大类型转成小类型

int a = 30;

byte b = (byte)a；

byte b =(byte)(a + b);

public static void main(String[] args) {
    byte b1 = 10;
    // b1 = b1 + 20;//编译错误：做运算时，Java会自动将"短整型(byte，short，char)"自动提升为int，所以结果至少是int
    b1 += 20;//相当于：b1 = (byte)(b1 + 20);
    b1 = (byte) (20 + b1);//OK的
    // b1 = (byte) b1 + 20;//编译错误
}

引用数据类型

引用数据类型非常多，大致包括：

类、接口类型、数组类型、枚举类型、注解类型、字符串型

例如，String 类型就是引用类型。引用数据类型默认值是null

简单来说，所有的非基本数据类型都是引用数据类型。

两种数据类型区别

存储位置

基本变量类型

在方法中定义的非全局基本数据类型变量的具体内容是存储在栈中的。

引用变量类型

只要是引用数据类型变量，其具体内容都是存放在堆中的，而栈中存放的是其具体内容所在内存的地址。
ps:通过变量地址可以找到变量的具体内容，就如同通过房间号可以找到房间一般。

传递方式

基本变量类型

在方法中定义的非全局基本数据类型变量，调用方法时作为参数是按数值传递的

引用变量类型

引用数据类型变量，调用方法时作为参数是按引用传递的，传递的是引用的副本

详情参见：https://www.cnblogs.com/maskwolf/p/9972982.html

包装类

概念

包装类是指将基本数据类型封装成对象的类。在 Java 中，为了使基本数据类型具有面向对象的特性，提供了对应的包装类。每种基本数据类型都有对应的包装类。

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolen	Boolen

装箱和拆箱

装箱

可以使用 Integer 类的构造方法

// 参数传递一个 int 类型的参数
Integer i1 = new Integer(10);

// 参数传递一个字符串类型的整数
Integer i2 = new Integer("20");// 注意：传递的字符串类型的整数

可以使用 Integer 类中的静态方法

// 参数传递一个 int 类型的参数
Integer i1 = Integer.valueOf(10);

// 参数传递一个字符串类型的整数
Integer i2 = Integer.valueOf("20");

拆箱

把包装类中基本数据的数据取出来,把包装类转换为基本数据类型。

Integer integer1 = new Integer(10);
int i1 = integer1.intValue();

Double aDouble = new Double("20.1");
double d1 = aDouble.doubleValue();

自动装箱和自动拆箱

在 JDK1.5之后，装箱和拆箱可以自动进行，不用我们调用方法。

// int 类型数据自动转换为 Integer 类型，就相当于 Integer in = new Integer(10);
Integer in = 10;

// Integer 类型数据自动转换为 int 类型，就相当于 int i = in.intValue();
int i = in;

基本类型与字符串转换

基本类型数据转字符串

// 基本类型 + ""
String s1 = 10 + "";

// 使用包装类中的静态方法 toString
String s2 = Integer.toString(10);

// 可以使用 String 类中的静态方法 valueOf
String s3 = String.valueOf(10);

字符串转基本类型数据

每个包装类型都定义了一个 parseXXX 方法，可以把字符换基本类型转化为基本数据类型。参数必须传递基本数据类型的字符串。

// 参数传递字符串类型的整数
int i = Integer.parseInt("10");
// 参数传递字符串类型的小数
double v = Double.parseDouble("2.1");

注意：除了 Character 类，其它类都有 parseXXX 方法。把字符串类型转化为 char 类型的数据：char c = “hello”.charAt(0);

常见的转义字符

常见的转义字符包括：

\n：换行符
\r：回车符
\t：制表符
\：反斜杠
"：双引号
'：单引号
\b：退格符
\f：换页符
\uXXXX：Unicode字符（其中XXXX为四位十六进制数）

这些转义字符可以在字符串中使用，用于表示特殊字符或者进行字符串的格式化。例如，使用\n可以在字符串中实现换行效果。

运算符

算术运算符

加法：+
减法：-
乘法：*
除法：/
取余：%
自增：++
自减：–

int a = 10;
int b = 5;

int sum = a + b;  // 加法运算
int difference = a - b;  // 减法运算
int product = a * b;  // 乘法运算
int quotient = a / b;  // 除法运算
int remainder = a % b;  // 取余运算

System.out.println("Sum: " + sum);
System.out.println("Difference: " + difference);
System.out.println("Product: " + product);
System.out.println("Quotient: " + quotient);
System.out.println("Remainder: " + remainder);

int c = 5;
int d = c++;  // 先赋值再自增
int e = ++c;  // 先自增再赋值

System.out.println("d: " + d);  // 输出：5
System.out.println("e: " + e);  // 输出：7

赋值运算符

简单赋值：=
加法赋值：+=
减法赋值：-=
乘法赋值：*=
除法赋值：/=
取余赋值：%=
位运算赋值：&=、|=、^=、>>=、<<=、>>>=

int a = 10;
int b;

b = a;  // 简单赋值运算
System.out.println("b: " + b);  // 输出：10

b += 5;  // 复合赋值运算，等价于 b = b + 5
System.out.println("b: " + b);  // 输出：15

b -= 3;  // 复合赋值运算，等价于 b = b - 3
System.out.println("b: " + b);  // 输出：12

关系运算符

相等：==
不等：!=
大于：>
小于：<
大于等于：>=
小于等于：<=

int a = 10;
int b = 5;

boolean isEqual = (a == b);  // 相等运算
boolean isNotEqual = (a != b);  // 不等运算
boolean isGreater = (a > b);  // 大于运算
boolean isLess = (a < b);  // 小于运算
boolean isGreaterOrEqual = (a >= b);  // 大于等于运算
boolean isLessOrEqual = (a <= b);  // 小于等于运算

System.out.println("isEqual: " + isEqual);  // 输出：false
System.out.println("isNotEqual: " + isNotEqual);  // 输出：true
System.out.println("isGreater: " + isGreater);  // 输出：true
System.out.println("isLess: " + isLess);  // 输出：false
System.out.println("isGreaterOrEqual: " + isGreaterOrEqual);  // 输出：true
System.out.println("isLessOrEqual: " + isLessOrEqual);  // 输出：false

逻辑运算符

逻辑与：&&
逻辑或：||
逻辑非：!

boolean a = true;
boolean b = false;

boolean result1 = (a && b);  // 与运算
boolean result2 = (a || b);  // 或运算
boolean result3 = !a;  // 非运算

System.out.println("result1: " + result1);  // 输出：false
System.out.println("result2: " + result2);  // 输出：true
System.out.println("result3: " + result3);  // 输出：false

位运算符

按位与：&
按位或：|
按位异或：^
按位取反：~
左移：<<
右移：>>
无符号右移：>>>

int a = 5;
int b = 3;

int result1 = a & b;  // 按位与运算
int result2 = a | b;  // 按位或运算
int result3 = a ^ b;  // 按位异或运算
int result4 = ~a;  // 按位取反运算
int result5 = a << 1;  // 左移运算
int result6 = a >> 1;  // 右移运算
int result7 = a >>> 1;  // 无符号右移运算

System.out.println("result1: " + result1);  // 输出：1
System.out.println("result2: " + result2);  // 输出：7
System.out.println("result3: " + result3);  // 输出：6
System.out.println("result4: " + result4);  // 输出：-6
System.out.println("result5: " + result5);  // 输出：10
System.out.println("result6: " + result6);  // 输出：2
System.out.println("result7: " + result7);  // 输出：2

三元运算符

建议仅在结果语句非常短并且比 if / else 等效项的简洁性显着提高而又不牺牲可读性的情况下使用它。

public static void main(String[] args) {
    int a = 10;
    int b = 20;

    // 要两个数中的最大值, 做一个判断
    int max = a > b ? a : b；	// 可以嵌套--int max = a > b ? (a > c ? a : c) ：(b > c ? b : c);
    System.out.println("max = " + max);
}

流程控制语句

选择结构

在 Java 中，选择结构主要有 if 语句、switch 语句和三元运算符。

if语句

if 语句用于根据条件的真假执行不同的代码块。

语法如下：

if (条件) {
    // 条件为真时执行的代码
} else {
    // 条件为假时执行的代码
}

示例：

int num = 10;
if (num > 0) {
    System.out.println("num是正数");
} else {
    System.out.println("num是负数或零");
}

switch语句

switch 语句用于根据表达式的值选择不同的执行路径。

语法如下：

switch (表达式) {
    case 值1:
        // 当表达式的值等于值1时执行的代码
        break;
    case 值2:
        // 当表达式的值等于值2时执行的代码
        break;
    ...
    default:
        // 当表达式的值与之前的所有值都不匹配时执行的代码
        break;
}

示例：

int day = 2;
switch (day) {
    case 1:
        System.out.println("星期一");
        break;
    case 2:
        System.out.println("星期二");
        break;
    ...
    default:
        System.out.println("无效的星期");
        break;
}

三元运算符

三元运算符用于根据条件的真假返回不同的值。

语法如下：

表达式1 ? 表达式2 : 表达式3

如果表达式1的值为真，则返回表达式2的值；否则返回表达式3的值。
示例：

int num = 10;
String result = (num > 0) ? "正数" : "负数或零";
System.out.println(result);

这些选择结构可以根据条件的不同执行不同的代码，帮助程序根据需要做出相应的决策。

循环结构

在 Java 中，我们可以使用循环结构来重复执行一段代码。常见的循环结构有 for、while 和 do-while。

for 循环

for 循环是一种最常用的循环结构，它可以根据条件重复执行一段代码。for 循环由三部分组成：初始化表达式、循环条件和迭代表达式。语法如下：

for (初始化表达式; 循环条件; 迭代表达式) {
    // 循环体
}

示例，打印出从1到10的数字：

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

while 循环

while 循环在循环开始之前先判断条件是否满足，如果条件满足，则执行循环体，然后再次判断条件。如果条件不满足，则跳出循环。语法如下：

while (循环条件) {
    // 循环体
}

示例，打印出从1到10的数字：

int i = 1;
while (i <= 10) {
    System.out.println(i);
    i++;
}

do-while 循环

do-while 循环先执行一次循环体，然后再判断条件是否满足。如果条件满足，则继续执行循环体，否则跳出循环。

语法如下：

do {
    // 循环体
} while (循环条件);

示例，打印出从1到10的数字：

int i = 1;
do {
    System.out.println(i);
    i++;
} while (i <= 10);

这些循环结构可以根据具体的需求选择使用。需要注意的是，在使用循环时要确保循环条件最终会变为 false，否则可能会导致无限循环。

API

API概述

API（Application Programming Interface）是一组定义了软件组件之间的交互方式的接口和规范。在软件开发中，API允许不同的软件组件（例如库、框架、操作系统、服务等）之间进行通信和互操作，通过提供固定的方法和规则，使得开发者可以更方便地使用已经实现好的功能而不必了解内部实现细节。可以理解为是“一组类库”，这些类是由我们程序员在编写自己的程序时使用的。我们的程序：Java 基础语法 + 系统类库（String 类，Scanner 类，Random 类 . . . ） + 我们自己的类（Student 类，Phone 类）。

API定义了一套协议，规定了可以使用的方法、参数、返回值以及方法之间的调用顺序。它像是一扇门，允许开发者通过特定的接口来访问和使用某个软件组件的功能。开发者只需要了解API的规范和使用方法，而不需要了解内部实现，从而降低了开发复杂度。

API的作用可以总结为以下几点：

封装复杂性：API将底层复杂的操作和实现细节进行封装，提供了更简洁和易于使用的接口，使得开发者能够更方便地使用功能而无需关心底层实现。
提高代码复用性：通过使用API，开发者可以重复使用已经实现好的功能模块，避免重复编写相同的代码，提高代码的复用性和开发效率。
促进团队协作：API提供了一种标准化的交互方式，使得不同开发者或团队之间可以更好地协作和集成各自的模块，加快开发速度。
降低开发风险：API经过严格的设计和测试，提供了稳定和可靠的功能，减少了开发过程中的错误和风险。

Java API是Java开发中的一组标准库，提供了丰富的功能和类供开发者使用。Java API包括了集合框架、IO处理、多线程、网络编程、GUI开发等功能模块的接口和类。通过使用Java API，开发者可以利用已经实现好的功能，快速开发出各种类型的Java应用程序。

常用类

String 类

String类不可变

String的构造方法

String s = “Hello”;

String类的特点

public static void main(String[] args) {
    // 当我们使用字符串的“字面常量”赋值时，相同的“字面常量”会返回相同的地址
    String s1 = "Hello";
    String s2 = "Hello";
    System.out.println(s1 == s2);// true

    // 当我们通过new关键字，创建String对象，是在“堆”中产生空间，每个对象的地址是“不同的”
    String s4 = new String("Hello");
    String s5 = new String("Hello");
    System.out.println(s4 == s5);// false
}

字符串的比较_equals

比较两个字符串的地址用"==“, 比较两个字符串的内容用"equals”.

public static void main(String[] args) {
    String s1 = "Hello";
    String s2 = new String("Hello");
    String s3 = new String("hello");

    System.out.println(s1 == s2);// 判断的是地址：false
    System.out.println(s1.equals(s2));// 判断的是内容：true
    System.out.println(s2.equals(s3));// false[区分大小写]
    System.out.println(s2.equalsIgnoreCase(s3));// equalsIgnoreCase 不区分大小写
}

1. equals：方法对于字符串来说是比较内容的, 而对于非字符串来说是比较, 其指向的对象是否相同的。
2. ==：比较符也是比较指向的对象是否相同的, 也就是对象在内存中的首地址。

总结：如果是基本类型比较, 那么只能用 == 来比较, 不能用 equals；如果是基本类型的包装类型, 那么用 equals。

常用方法

String concat(String str)	// 将指定字符串连接到此字符串的结尾。把两个字符串连接到一起  
boolean contains(String s)	// 判断字符串中是否包含指定的字符串；包含返回true，不包含返回false。
boolean endsWith(String suffix)	// 判断字符串是否以指定的字符串结尾；是返回true，不是返回false。
boolean startsWith(String prefix)	// 判断字符串是否以指定的字符串开头；是返回true，不是返回false。
int indexOf(String str)	// 从前往后在字符串中查找另外一个字符串，找到了返回字符串对应的索引，找不到返回-1。
int lastIndexOf(int ch)	// 从后往前在字符串中查找另外一个字符串，找到了返回字符串对应的索引，找不到返回-1。
String replace(String target, String replacement)// 把大的字符串中所有的目标字符串，替换为新的字符串。
String substring(int beginIndex)// 从开始索引beginIndex截取字符串到字符串的末尾。
String substring(int beginIndex, int endIndex)	// 从开始索引beginIndex到结束索引endIndex截取字符串；包含头，不包含尾。
char[] toCharArray()	// 将此字符串转换为一个新的字符数组。
byte[] getBytes()// 查询系统默认的编码把字符串转换为字节数组。
String toLowerCase()	// 把字符串中所有的英文字符转换为小写 "ABC123你好"==>"abc123你好"。
String toUpperCase()	// 把字符串中所有的英文字符转换为大写 "abc123你好"==>"ABC123你好"。
String trim()	// 去掉字符串两端的空格。
String[] split(String regex)	// 根据自定的字符串对字符串进行切割。

StringBuilder类

StringBuilder类可变主要用于字符串拼接。

Random 类

public static void main(String[] args) {
    Random r = new Random();
    int i = r.nextInt();// 生成一个随机的整数
    int i1 = r.nextInt(10);// 0-9的随机数
    int i2 = r.nextInt(10) + 1;// 1-10的随机数
    int i3 = r.nextInt(30 - 7 + 1) + 7;// 7-30的随机数
    int i4 = r.nextInt(30) + 9;// 9-30的随机数
    int i5 = r.nextInt(15 + 6 + 3 - 4) + 7;// 7-26的随机数
    // 自创公式：nextInt(x) + y;// y-(x+y-1)之间的随机数
    int i = r.nextInt(3) - 1;// -1 - 1的随机数
    boolean b = r.nextBoolean();// 生成一个随机的布尔值
    double d = r.nextDouble();// 生成一个随机的小数
}

Object 类

在Java中，所有的类都直接或间接地继承自 java.lang.Object 类。Object类是Java中的根类，它提供了一些通用的方法和功能，可以在任何类中使用。

以下是一些Object类的常用方法：

equals(Object obj)：用于比较两个对象是否相等。默认情况下，它比较的是对象的引用地址，但可以在类中重写该方法以进行自定义的比较。
hashCode()：返回对象的哈希码值。该方法通常与 equals() 方法一起使用，用于实现哈希表等数据结构。
toString()：返回对象的字符串表示。默认情况下，该方法返回的是对象的类名和哈希码值，但可以在类中重写该方法以返回自定义的字符串表示。
getClass()：返回对象的运行时类。返回的是一个Class对象，可以通过它获取类的名称、父类、接口等信息。
finalize()：在对象被垃圾回收之前调用。可以在子类中重写该方法以实现资源释放等清理操作。
clone()：创建并返回当前对象的副本。需要注意的是，该方法是浅拷贝，即只复制对象本身，而不复制其引用的对象。

下面是一个示例代码，演示了Object类的使用：

public class Person {
    private String name;
    private int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 重写equals()方法
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }

    // 重写hashCode()方法
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    // 重写toString()方法
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("Alice", 25);
        Person person2 = new Person("Bob", 30);

        // 使用equals()方法比较对象
        System.out.println(person1.equals(person2));  // false

        // 使用hashCode()方法获取对象的哈希码值
        System.out.println(person1.hashCode());  // 不同的哈希码值

        // 使用toString()方法获取对象的字符串表示
        System.out.println(person1.toString());  // Person{name='Alice', age=25}
    }
}

除了上述方法，Object类还提供了 wait()、notify()、notifyAll() 等用于线程同步的方法。

需要注意的是，Object类中的这些方法都是使用关键字 native 修饰的，意味着它们的实现是由底层语言（如C或C++）实现的，而不是纯Java代码。这些方法为Java提供了一些基础的功能，使得所有类都可以使用它们。

Math类

Math类是Java中的一个数学工具类，提供了一系列静态方法来执行各种数学运算，例如求绝对值、取整、幂运算、三角函数等。

下面是一些Math类常用方法的介绍和示例代码：

abs()：返回一个数的绝对值。

int num = -10;
int absNum = Math.abs(num); // absNum = 10

ceil()：返回大于或等于参数的最小整数。

double num = 3.14;
double ceilNum = Math.ceil(num); // ceilNum = 4.0

floor()：返回小于或等于参数的最大整数。

double num = 3.14;
double floorNum = Math.floor(num); // floorNum = 3.0

round()：返回最接近参数的整数。

double num = 3.5;
long roundNum = Math.round(num); // roundNum = 4

pow()：返回一个数的指定次幂。

double base = 2;
double exponent = 3;
double result = Math.pow(base, exponent); // result = 8.0

sqrt()：返回一个数的平方根。

double num = 16;
double sqrtNum = Math.sqrt(num); // sqrtNum = 4.0

max()：返回两个数中较大的那个数。

int num1 = 10;
int num2 = 20;
int maxNum = Math.max(num1, num2); // maxNum = 20

min()：返回两个数中较小的那个数。

int num1 = 10;
int num2 = 20;
int minNum = Math.min(num1, num2); // minNum = 10

random()：返回一个大于等于0.0且小于1.0的随机数。

double randomNum = Math.random(); // 随机生成一个0.0到1.0之间的数

这些只是Math类提供的一些常用方法，还有其他方法可以用于三角函数、对数函数等数学运算。可以根据具体需求查看Java官方文档获取更多详细信息。

Date 类

Date类是Java中用于表示日期和时间的类。它位于 java.util 包中，可以用于获取和操作日期和时间的信息。

以下是Date类的一些常用方法和示例代码：

构造方法

Date()：创建一个表示当前日期和时间的Date对象。
Date(long date)：根据给定的毫秒数创建一个Date对象。

示例代码：

// 使用无参构造方法创建一个表示当前日期和时间的Date对象
Date currentDate = new Date();
System.out.println(currentDate);

// 使用指定毫秒数创建一个Date对象
long millis = 161234567890L;
Date date = new Date(millis);
System.out.println(date);

获取日期和时间信息的方法

getTime()：返回自1970年1月1日00:00:00 GMT以来的毫秒数。
getYear()：返回从1900年开始的年份。
getMonth()：返回月份，范围为0-11，0表示一月。
getDate()：返回一个月中的日期。
getHours()：返回小时数，范围为0-23。
getMinutes()：返回分钟数，范围为0-59。
getSeconds()：返回秒数，范围为0-59。

示例代码：

Date date = new Date();

System.out.println("毫秒数：" + date.getTime());
System.out.println("年份：" + (date.getYear() + 1900));
System.out.println("月份：" + date.getMonth());
System.out.println("日期：" + date.getDate());
System.out.println("小时：" + date.getHours());
System.out.println("分钟：" + date.getMinutes());
System.out.println("秒数：" + date.getSeconds());

修改日期和时间的方法

setTime(long time)：设置Date对象表示的时间。
setYear(int year)：设置年份。
setMonth(int month)：设置月份。
setDate(int date)：设置日期。
setHours(int hours)：设置小时数。
setMinutes(int minutes)：设置分钟数。
setSeconds(int seconds)：设置秒数。

示例代码：

Date date = new Date();

// 修改时间为2022年3月1日10:30:45
date.setYear(122); // 2022年
date.setMonth(2); // 3月
date.setDate(1); // 1日
date.setHours(10); // 10点
date.setMinutes(30); // 30分
date.setSeconds(45); // 45秒

System.out.println(date);

请注意，Date类中的大部分方法已经过时，推荐使用java.time包中的新日期和时间API（Java 8及更高版本）来处理日期和时间操作。

DateFormat 类

在Java中，DateFormat类用于格式化和解析日期和时间。它是一个抽象类，用于处理不同地区和语言的日期和时间格式。DateFormat类提供了一组方法，可以将日期和时间对象格式化为字符串，并将字符串解析为日期和时间对象。

以下是DateFormat类的一些常用方法：

format(Date date)：将给定的Date对象格式化为字符串。
parse(String source)：将给定的字符串解析为Date对象。
setLenient(boolean lenient)：设置是否宽容解析日期和时间。如果为 true，表示允许解析非严格格式的日期和时间；如果为 false，表示只解析严格格式的日期和时间。
setTimeZone(TimeZone zone)：设置时区。

示例代码：

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateFormatExample {
    public static void main(String[] args) {
        // 创建一个SimpleDateFormat对象，指定日期和时间的格式
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        // 将日期和时间对象格式化为字符串
        Date currentDate = new Date();
        String formattedDate = dateFormat.format(currentDate);
        System.out.println("Formatted Date: " + formattedDate);

        // 将字符串解析为日期和时间对象
        String dateString = "2022-01-01 12:00:00";
        try {
            Date parsedDate = dateFormat.parse(dateString);
            System.out.println("Parsed Date: " + parsedDate);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

在上述示例中，我们首先创建了一个SimpleDateFormat对象，指定了日期和时间的格式为"yyyy-MM-dd HH:mm:ss"。然后，我们使用format()方法将当前的Date对象格式化为字符串，并打印出来。接下来，我们将一个字符串解析为Date对象，并打印出来。

请注意，SimpleDateFormat是DateFormat的一个具体实现类，它提供了日期和时间格式化和解析的功能。在使用SimpleDateFormat时，需要注意线程安全性，如果在多线程环境下使用，推荐使用ThreadLocal来保证线程安全。

Calendar 类

Calendar类是Java中用于处理日期和时间的抽象类。它提供了一组方法来进行日期和时间的计算、格式化和解析等操作。Calendar类是一个抽象类，不能直接实例化，需要通过其子类的实例来使用。

示例代码：

import java.util.Calendar;

public class CalendarExample {
    public static void main(String[] args) {
        // 获取当前时间的Calendar实例
        Calendar calendar = Calendar.getInstance();

        // 获取年份
        int year = calendar.get(Calendar.YEAR);

        // 获取月份，注意月份是从0开始的，所以需要加1
        int month = calendar.get(Calendar.MONTH) + 1;

        // 获取日期
        int day = calendar.get(Calendar.DAY_OF_MONTH);

        // 获取小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY);

        // 获取分钟
        int minute = calendar.get(Calendar.MINUTE);

        // 获取秒
        int second = calendar.get(Calendar.SECOND);

        // 获取星期，注意星期是从1开始的，1代表星期日，2代表星期一，以此类推
        int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);

        // 输出当前时间信息
        System.out.println("当前时间：" + year + "-" + month + "-" + day + " " + hour + ":" + minute + ":" + second);
        System.out.println("当前星期：" + dayOfWeek);
    }
}

在上面的示例中，我们首先通过Calendar.getInstance()方法获取当前时间的Calendar实例。然后使用Calendar的get方法来获取年份、月份、日期、小时、分钟、秒和星期等信息。需要注意的是，月份是从0开始的，所以获取月份时需要加1。星期是从1开始的，1代表星期日，2代表星期一，以此类推。

通过这些方法，我们可以方便地获取日期和时间的各个部分，并进行相应的操作和处理。Calendar类还提供了其他一些方法，如设置日期和时间、日期和时间的计算、日期和时间的比较等，可以根据具体需求进行使用。

Arrays 类

Java中的Arrays类是一个实用工具类，提供了许多用于操作数组的静态方法。它包含了对数组进行排序、搜索、比较和填充等常见操作的方法。

示例代码：

sort()：对数组进行排序。

int[] arr = {5, 3, 1, 4, 2};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));  // 输出：[1, 2, 3, 4, 5]

binarySearch()：使用二分查找算法在已排序的数组中查找指定元素。

int[] arr = {1, 2, 3, 4, 5};
int index = Arrays.binarySearch(arr, 3);
System.out.println(index);  // 输出：2

equals()：比较两个数组是否相等。

int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
boolean isEqual = Arrays.equals(arr1, arr2);
System.out.println(isEqual);  // 输出：true

fill()：将指定的值填充到数组中的每个元素。

int[] arr = new int[5];
Arrays.fill(arr, 0);
System.out.println(Arrays.toString(arr));  // 输出：[0, 0, 0, 0, 0]

copyOf()：复制指定的数组，可以指定新数组的长度。

int[] arr = {1, 2, 3};
int[] newArr = Arrays.copyOf(arr, 5);
System.out.println(Arrays.toString(newArr));  // 输出：[1, 2, 3, 0, 0]

toString()：将数组转换为字符串。

int[] arr = {1, 2, 3};
String arrStr = Arrays.toString(arr);
System.out.println(arrStr);  // 输出：[1, 2, 3]

这些只是Arrays类的一部分方法，还有其他一些方法可以根据需要使用。使用Arrays类可以更方便地操作和处理数组。

System 类

System类是Java语言中的一个核心类，提供了与系统相关的方法和字段。它包含了一些常用的静态方法，可以用于处理输入输出、访问系统属性、执行垃圾回收等操作。

示例代码：

currentTimeMillis()：返回当前时间的毫秒数。

long currentTime = System.currentTimeMillis();
System.out.println("当前时间的毫秒数：" + currentTime);

arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将一个数组中的指定元素复制到另一个数组中。

int[] srcArray = {1, 2, 3, 4, 5};
int[] destArray = new int[5];
System.arraycopy(srcArray, 0, destArray, 0, srcArray.length);
System.out.println("复制后的数组：" + Arrays.toString(destArray));

getProperty(String key)：获取指定属性的值。

String javaVersion = System.getProperty("java.version");
System.out.println("Java版本：" + javaVersion);

getenv(String name)：获取指定环境变量的值。

String path = System.getenv("PATH");
System.out.println("系统环境变量PATH的值：" + path);

gc()：运行垃圾回收器。

System.gc();
System.out.println("垃圾回收器已执行");

这些是System类的一些常用方法，其他方法可以根据具体需求进行使用。

技术思考者

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
Java 基础语法

此篇文章介绍了Java基础语法的重要概念和用法。内容包括命名规范、注释、关键字、数据类型、包装类、运算符、流程控制语句及常用类等方面。可以帮助初学者或有一定编程经验的人从这篇博客中获得有价值的知识和技巧。
复制链接

扫一扫