二、Java基础语法

Guohy.

已于 2023-02-08 15:36:20 修改

阅读量434

点赞数

CC 4.0 BY-SA版权

文章标签： java jvm 开发语言

于 2023-02-06 15:43:09 首次发布

本文链接：https://blog.youkuaiyun.com/aaaghyaa/article/details/128902929

二、Java基础语法

1 . 注释

注释只是给程序的说明性文字不会参与编译

单行注释

public class main{
    public static void main(String[] args){
        // System.out.println("Hello World!");
        System.out.println("Hello World!");
    }
}

运行结果 :

Hello World!

单行注释 // 双斜杠后面的内容会被注释

多行注释

public class main{
    public static void main(String[] args){
        /*
        System.out.println("Hello World!");
        System.out.println("Hello World!");
        */
        System.out.println("Hello World!");
    }
}

运行结果 :

Hello World!

*多行注释以 / 开头 */ 结尾中间的内容会被注释 **

文档注释

在程序中采用特定的注释格式进行注释，然后通过JDK提供的工具javadoc来解析，生成一套以网页文件形式体现的程序说明文档。

文档注释，一般用于注释类或方法。

暂时用不上待补充

2 . 关键字

关键字就是被Java赋予特定含义的单词

关键字的特点

关键字的字母全部小写
常用的代码编辑器对于关键字有特殊的高亮显示

Java中的部分关键字

assert		const		long		public		final		continue		goto		static		while		strictfp
abstract	default		int			extends		class		boolean			break		throws		volatile	......

3 . 字面量

告诉程序员 : 数据在程序中的书格式

字面量类型

类型	关键字	说明	举例	默认值	内存大小
整数类型	int	不带小数点的数字	123 456	0	4byte
小数类型/浮点数类型	float double	带小数点的数字	123.456	0.0	8byte
字符类型	char	单个字符使用单引号括起来	‘a’ ‘0’	‘\0’	2byte
字符串类型	String	一串字符使用双引号括起来	“Hello”	null	/
布尔类型	boolean	只有值真或假	真true 假false	false	1byte \|\| 4byte
空类型	/	一个特殊的值空值	值为 null	/	/

4 . 数据类型

数据类型分为基本数据类型和引用数据类型

基本数据类型

数据类型	关键字	取值范围	内存占用
整数	byte	$2^7$ ~ $2^7-1$	$1$
整数	short	$2^{15}$ ~ $2^{15}-1$	$2$
整数	int	$2^{31}$ ~ $2^{31}-1$ $≈2e9\approx 2e9$	$4$
整数	long	$2^{63}$ ~ $2^{63}-1$ $≈9e19\approx 9e19$	$8$
浮点数	float	$- 3.401298 e - 38$ ~ $3.402823 e + 38$	$4$
浮点数	double	$- 4.9000000 e - 324$ ~ $1.797693 e + 308$	8
字符	char	$0$ ~ $65535$	$2$
布尔	boolean	$t r u e, f a l se$	$1$

在定义long类型时需要在数字后面添加 ‘L’ 或者 ‘l’

在定义float类型时需要在数字后面添加 ‘F’ 或者 ‘f’

取值范围大小关系

double > float > long > int > short > byte

5 . 变量

在程序运行过程中其值有可能发生变换的量 (数据)

变量命名规则

名字中只能包含字母数字下划线’_’ 美元符’$’
数字不能开头
变量名不能重复定义
不能与Java的关键字相重复
区分大小写

使用方法

[数据类型 | 字面量类型] [变量名] = [值];

定义变量

public class main{
    public static void main(String[] args){
        //定义了一个整数类型的变量 值为10
        int a=10;
        
        //定义了一个浮点数的变量 未赋值
        double b;
        
        //定义了三个char类型的变量
        char c1='a',c2,c3;
        
        //定义了一个long类型的变量
        long d=12345L;
        
        //定义了一个float类型的变量
        float e=3.1415f;
    }
}

输出打印

public class main{
    public static void main(String[] args){
        int a=10;
        System.out.println(a);
        // 输出结果为 10
    }
}

参与计算

public class main{
    public static void main(String[] args){
        int a=10,b=20;
        System.out.println(a+b);
        // 输出结果为 30
    }
}

修改数值

public class main{
    public static void main(String[] args){
		int a=10;
        System.out.println(a);
        // 输出结果为 10
        
        a=30;
        // 把变量 a 的值修改为30
        
        System.out.println(a);
        // 输出结果为 30
    }
}

6 . 算数运算符

运算符和表达式

运算符
- 对字面量或者变量进行操作的符号

符号	作用
+	加
-	减
*	乘
/	除
%	取余
=	$赋值 a = b 把 a 的值给 b$
+=	$a=a+ba+=b\ \ 等于\ \ a=a+b$
-=	$a=a−ba-=b\ \ 等于\ \ a=a-b$
/=	$a=a/ba/=b\ \ 等于\ \ a=a/b$
*=	$a=a∗ba=b\ \ 等于\ \ a=ab$
%=	$a=a%ba\%=b\ \ 等于\ \ a=a\%b$
++	$\ 等于\ a+=1$
–	$\ 等于\ a-=1$

表达式
- 用运算符把字面量或者变量连接起来符合Java语法的式子

int a=10;
int b=20;

// '+' 就是运算符
// a+b 是表达式
int c=a+b;

7 . 隐式转换和强制转换

隐式转换

取值范围小的和取值范围大的进行运算小的会先提升为大的再进行运算

public class main{
    public static void main(String[] args){
		int a=10;
        double b=20;
        //此时输出 a+b 的值为 30.0 double类型的 在计算 a+b 时  会自动把 a 提升为double类型
        System.out.println(a+b);
    }
}

内存占用不满 4byte 类型的会自动转化为 int 来进行计算

public class main{
    public static void main(String[] args){
        byte a=100,b=200;
        
        //此时输出结果为 200  但是 byte 类型的最大值为127
        System.out.println(a+b);
    }
}

强制转换

强制转换是把占用内存大的类型转换为占用内存小的类型
强制转换之后可能会出现精度丢失的问题

书写格式

(数据类型)变量名
    
double a=12.3;

// 此时输出的为 12 丢失了小数部分
System.out.println((int)a);

精度丢失

public class main{
    public static void main(String[] args){
        int a=4987;
        byte b=(byte)a;
        
        //此时输出的 b 结果为123 就是出现了精度丢失
        System.out.println(b);
    }
}
/*

数字在内存中都是使用二进制进行存储的
int 占用4byte 32位
4987  的二进制为  1001101111011

byte 占用1byte 8个字节
a强制转换为byte之后只会保留后八位二进制 01111011

0 1 1 1 1 0 1 1
第一位为符号位 0表示正数  1表示负数
后七位为数据位 1111011转为十进制位123

所以 b 的值为123

*/

8 . 字符串的 ‘+’ 操作

当 ‘+’ 操作中出现字符串时这个 ‘+’ 就不是算数运算符了而是字符串连接符号
‘+’ 会将前后的数据进行拼接产生一个新的字符串

public class main{
    public static void main(String[] args){
        int a=123;
        
        // 输出结果为 123456 因为出现了字符串
        System.out.println(a+"456");
    }
}

public class main{
    public static void main(String[] args){
        int a=123;
        int b=10;
        
        
        // 输出结果为 133456 
        // 刚开始算 a+b 因为没出现字符串 所以计算的是值相加 结果为 133
        // 再拿 a+b 的结果 133 去与 "456" 相加  因为 "456" 是字符串 所以结果是 133456
        System.out.println(a+b+"456");
    }
}

9 . 字符的 ‘+’ 操作

字符在计算机中是以ASCII码的形式存放的
字符的 + 操作就是ASCII码值的相加

public class main{
    public static void main(String[] args){
        char a='A';
        
        //输出的值为 65 字符 'A' 的ASCII码值就为65
        System.out.println((int)a);
    }
}

10 . 关系运算符

符号	说明
==	$a == b$ $相等为\ true \ 不相等为\ false$
!=	$a == b$ $不相等为\ true \ 相等为\ false$
>	$a > b$ $大于为\ true \ 不大于为\ false$
<	$a < b$ $小于为\ true \ 不小于为\ false$
>=	$a >= b$ $大于等于为\ true \ 小于为\ false$
<=	$a <= b$ $小于等于为\ true \ 大于为\ false$

**关系运算符的结果都为 boolean 类型要么是 $t r u e$ 要么是 $f a l se$ **
不要把 $==$ 写成 $=$

11 . 逻辑运算符

符号	说明
$&&\&\&$	$两边都为真才为真并且的意思\ \ 两边都为真才为真$
$&\&$	$两边都为1才是1按位与\ \ 两边都为1才是1$
$
$	$
^	$相同为false逻辑异或\ \ 不同为true\ \ 相同为false$
$!$	$0遍11遍0取反\ \ 0遍1 1遍0$

12 . 三元运算符

# 基础语法
[表达式] ? (A语句) : (B语句);

# 如果表达式的值为 true 则执行 A语句 否则执行 B语句

// 求两个数的最大值
/*

int a=10,b=20;
int max= a>b?a:b;

*/

// 三元运算符的嵌套使用 求三个数的最大值
/*

int a=10,b=20,c=30;
int max= a>b?a>c?a:c:b>c?b:c; 

*/

13 . 运算符的优先级

优先级	运算符
$1$	$\ \ () \ \ \{ \}$
$2$	$−−!\ \ ++\ \ --$
$3$	$*\ \ /\ \ %$
$4$	$−+\ \ -$
$5$	$>>>>>\ \ <<\ \ >>>$
$6$	$>=<\ \ <=\ \ >\ \ >=$
$7$	$!===\ \ !=$
$8$	$&\&$
$9$	^
$10$	$
$11$	$&&\&\&$
$12$	$
$13$	$? :$
$14$	$=\ \ +=\ \ -=\ \ *=\ \ /=\ \ %=\ \ & \=$

14 . 源码、反码、补码

**源码 : 数字的二进制位第一位为符号位符号位为 0 表示正数 1为负数 **

正数在内存中的存储

# 正数的源码 = 反码 = 补码
# 13的源码
# 13的二进制位 1101
# 源码为 00001101

负数在内存中的存储

# 负数的源码 = 符号位为1 其他位与正数的源码一样
# 负数的反码 = 负数的源码除了符号位按位取反 1变0 0变1
# 负数的补码 = 负数的源码+1

# -13 的源码为 10001101  //第一位符号位位1 表示负数
# -13 的反码为 11110010  //除了符号位按位取反
# -13 的补码为 11110011  //反码+1

15 . 分支语句

if

// 使用方法

// 单个if  如果表达式的值为 true 则执行语句 A
/*
if(表达式){
	// 语句 A
}
*/

// if - else 
// 如果表达式的值为 true 则执行 语句A 否则执行 语句B
/*
if(表达式){
	// 语句 A
}else{
	// 语句 B
}
*/

// if -else 的嵌套
// 如果 表达式1 的值为 true 则执行 语句A 否则再判断表达式2 的值 如果表达式2为 true 则执行 语句B 否则执行语句C
/*
if(表达式1){
	// 语句 A
}else if(表达式2){
	// 语句 B
}else{
	// 语句 C
}

*/

swith

// 使用方法

// 先计算表达式的值 如果表达式的值等于 值1 就执行 语句A ,如果表达式的值等于 值2 就执行语句B 如果都不匹配 则执行default里面的语句
// 值1 2 3等只能是常量
/*
switch(表达式){
	case 值1 :
		语句 A;
		break;
	case 值2 :
		语句 B;
		break;
	case 值3 :
		语句 C;
		break;
	case 值4 :
		语句 D;
		break;
	default :
		语句 E;
		break;
}
*/

16 . 循环语句

while循环与 do-while循环

// 使用方法

// 如果表达式的值为true 则一直执行语句A 否则跳出循环
/*
while(表达式){
	语句A;
}
*/

// do-while 循环
// 先执行一次语句 A,再判断表达式的值 如果表达式为 true 则继续执行语句A 否则跳出循环
/*
do{
	语句A;
}while(表达式);
*/

for 循环

// 使用方法
// 初始化语句只会执行一次 再判断表达式 表达式为true则执行语句A 执行完之后再执行语句B 再判断表达式的值是否为true 如果为true 则继续语句A
/*
for([初始化语句];[表达式];[语句B]){
	语句A;
}
*/

// 输出数字 1-100
/*
for(int i=1;i<=100;i++){
	System.out.println(i);
}
*/

continue 与 break

continue : 结束当前循环开始下一次循环

// 输出数字 1-10 ,遇到7的倍数则不输出
/*
for(int i=1;i<=10;i++){
	if(i%7==0){
		// 遇到 7 的倍数就结束此次循环 开启下一次循环
		continue;
	}
	System.out.println(i);
}
// 运行结果 :
1 2 3 4 5 6 8 9 10
*/

break : 退出循环

// 输出数字 1-100 遇到 7 的倍数则退出循环
/*
for(int i=1;i<=100;i++){
	if(i%7==0){
		// 直接退出循环
		break;
	}
	System.out.println(i);
}
// 运行结果 :
1 2 3 4 5 6
*/

17 . 数组

**数组就是能够存储一些相同元素的集合 **

数组的定义与初始化

//静态初始化
//(数据类型)[] 数组名 = new (数据类型)[]{值1,值2,值3};

//定义了一个int类型的数组 存储了五个整数
int[] array = new int[]{1,2,3,4,5};


//动态初始化
//(数据类型)[] 数组名 = new (数据类型)[数组大小];

//定义了一个长度为10的int类型数组
int[] val=new int[10];

数组的元素访问与修改

// 数组的元素可以通过下标来进行访问
// 下标从 0 开始 下标的取值范围为 0 ~ 数组长度-1
// 格式 
// 数组名[下标]
int[] array = new int[]{1,2,3,4,5};

//输出下标 2
System.out.println(array[2]);

//修改array数组中下标 3 的值为 100
array[3]=100;

//遍历数组 array.length为数组的长度
for(int i=0;i<array.length;i++){
    System.out.println(array[i]);
}

数组在内存中的存储

Java new 出来的内存都存储在堆空间中
数组名存储的仅仅只是堆空间中的地址值

int[] a=new int[]{1,2,3};
int[] b=a;
System.out.println(a[2]);
//输出的值为 3

b[2]=5;
System.out.println(a[2]);
//输出的值为 5

int[] b=a 只是把变量 a中存储的地址值赋值给 b ,此时变量 b 指向的的与a是同一块内存修改b的值 a的值也会跟着修改

在这里插入图片描述

二、Java基础语法

二、Java基础语法

1 . 注释

单行注释

多行注释

文档注释

2 . 关键字

关键字的特点

Java中的部分关键字

3 . 字面量

字面量类型

4 . 数据类型

基本数据类型

5 . 变量

变量命名规则

使用方法

定义变量

输出打印

参与计算

修改数值

6 . 算数运算符

运算符和表达式

7 . 隐式转换和强制转换

隐式转换

强制转换

8 . 字符串的 ‘+’ 操作

9 . 字符的 ‘+’ 操作

10 . 关系运算符

11 . 逻辑运算符

12 . 三元运算符

13 . 运算符的优先级

14 . 源码、反码、补码

正数在内存中的存储

负数在内存中的存储

15 . 分支语句

if

swith

16 . 循环语句

while循环 与 do-while循环

for 循环

continue 与 break

17 . 数组

数组的定义与初始化

数组的元素访问与修改

数组在内存中的存储

while循环与 do-while循环