二、Java基础语法

二、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$ $\approx 2e9$	$4$
整数	long	$-2^{63}$ ~ $2^{63}-1$ $\approx 9e19$	$8$
浮点数	float	$-3.401298e-38$~$3.402823e+38$	$4$
浮点数	double	$-4.9000000e-324$~$1.797693e+308$	8
字符	char	$0$~$65535$	$2$
布尔	boolean	$true,false$	$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+=b等于a=a+b$
-=	$a-=b等于a=a-b$
/=	$a/=b等于a=a/b$
*=	$a\ast =b等于a=a\ast b$
%=	$a\%=b等于a=a\%b$
++	$a++等于a+=1$
–	$a--等于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$ $判断a和b是否相等相等为true不相等为false$
!=	$a==b$ $判断a和b是否不相等不相等为true相等为false$
>	$a>b$ $判断a是否大于b大于为true不大于为false$
<	$a<b$ $判断a是否小于b小于为true不小于为false$
>=	$a>=b$ $判断a是否大于等于b大于等于为true小于为false$
<=	$a<=b$ $判断a是否小于等于b小于等于为true大于为false$

• **关系运算符的结果都为 boolean 类型 要么是 $true$ 要么是 $false$ **

• 不要把 $==$ 写成 $=$

11 . 逻辑运算符

符号	说明
$\&\&$	$并且的意思两边都为真才为真$
$\&$	$按位与两边都为1才是1$
$
$	$
^	$逻辑异或不同为true相同为false$
$!$	$取反0遍11遍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$	$\ast /$
$4$	$+-$
$5$	$>><<>>>$
$6$	$<<=>>=$
$7$	$==!=$
$8$	$\&$
$9$	^
$10$	$
$11$	$\&\&$
$12$	$
$13$	$?:$
$14$	$=+=-=\ast =/=$

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的值也会跟着修改