Day-03 java的基本语法

D_Ddr

已于 2023-08-01 21:12:22 修改

阅读量132

点赞数

文章标签： java 笔记学习

于 2023-07-18 20:45:46 首次发布

本文链接：https://blog.csdn.net/D_Ddr/article/details/131795417

版权

一、运算符

1.1 算术运算符

运算符	运算	示例	结果
+	加	1 + 1	2
-	减	3 - 2	1
*	乘	3 * 2	6
/	除	4 / 2	2
%	取模（求余数）	5 % 2	1

1.2 自增自减运算符

++和–：

当该运算符放在操作数前面，则先减1或加1，操作数再参加运算

当该运算符放在操作数后面，则操作数先参加运算，再减1或加1

public class Demo01 {
    public static void main(String[] args){
        int a = 2;
        int x = a + a++;
        System.out.println(x); //4
        System.out.println(a); //3

        int b = 2;
        int y = b + ++b;
        System.out.println(y); //5
        System.out.println(b); //3
    }
}

1.3 赋值运算符

运算符	运算	示例	结果
=	赋值	a=3	a = 3
+=	加等于	a = 3, a += 2	a = 5
-=	减等于	a = 3, a -= 2	a = 1
*=	乘等于	a = 3, a *= 2	a = 6
/=	除等于	a = 4, a /= 2	a = 2
%=	模等于	a = 5, a %= 2	a = 1

1.4 比较运算符

运算符	运算	示例	结果
==	赋值	4==3	false
!=	加等于	3!=2	true
<	小于	3<2	false
>	大于	3>2	true
<=	小于等于	4<=2	false
>=	大于等于	5>=2	true

1.5 逻辑运算符

运算符	运算	示例	结果
&	与	true & false	false
\|	或	true \| false	true
^	异或	true ^ true	false
!	非	!false	true
&&	短路与	false && true	false
\|\|	短路或	true \| false	true

异或可以简单理解为不一样即为true，一样即为false

与”&“、短路与“&&”在使用上的差别为：当短路与左边为false时，不再对右边进行运算，而与则会继续；同理，或“|”与短路或“||”也是一样

1.6 位运算符

运算符	运算
&	按位与
\|	按位或
~	按位非
^	按位异或
<<	左位移
>>	右位移
>>>	无符号右位移

public class Demo02 {
    public static void main(String [] args){
        //  8：0000 0000 0000 0000 0000 0000 0000 1000
        // -8：1000 0000 0000 0000 0000 0000 0000 1000
        //  5：0000 0000 0000 0000 0000 0000 0000 0101
        System.out.println(8 & 5); // 按位与 结果为0
        System.out.println(8 | 5); // 按位或 结果为13
        /*
            取非后相当于反码，需要再转化为原码，5取反转化为源码后结果为-6
            注意取反后符号位不会再变化
        */
        System.out.println(~5); // 非 结果为-6
        System.out.println(8 ^ 5); //按位异或 结果为13
        System.out.println(8 << 2); // 左位移2位 结果为32
        System.out.println(8 >> 3); // 右位移3位 结果为1
        System.out.println(-8 >>> 3); // 无符号右位移3位 结果为536870911
    }
}

二、条件语句结构

2.1 选择语句

1. if条件语句

if(条件语句) {

 	代码块;
}

2. if…else语句

if(条件语句) {
	执行语句1;
} else {
	执行语句2;
}

3. if…else if…else语句

if(条件语句1) {
	执行语句1;
} else if (条件语句2) {
	执行语句2;
}...
else{
	执行语句n+1;
}

public class Demo03 {
    public static void main(String[] args) {
        //运行程序过程中，需要向程序中输入一些数据，借助Scanner类型操作
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入分数（上限100）：");
        int grade = sc.nextInt();
        if (grade < 60) {
            System.out.print("成绩不及格！");
        } else if (grade < 70) {
            System.out.print("成绩为中！");
        } else if (grade<80) {
            System.out.print("成绩为良！");
        } else if (grade<100) {
            System.out.print("成绩为优！");
        } else {
            System.out.print("成绩不合法！");
        }
    }
}

2.2 三元运算符

判断条件 ? 表达式1 : 表达式2

public class Demo04 {
    public static void main(String [] args) {
        int x = 0, y = 1;
        int max;
        if(x > y) {
            max = x;
        } else {
            max = y;
        }
        System.out.println(max); //1
    }
}

public class Demo05 {
    public static void main(String [] args) {
        int x = 0, y = 1;
        int max = x > y ? x : y;
        System.out.println(max); //1
    }
}

2.3 switch 条件语句

switch(条件语句) {
	case1:
		执行语句1；
		break;
	case2:
		执行语句2；
		break;
	case3:
		执行语句3；
		break;
	default:
		执行语句4；
		break;
}

import java.util.Scanner;
public class Demo06 {
    public static void main(String [] args) {
        Scanner sc = new Scanner(System.in);
        int level = sc.nextInt();
        switch(level) {
            case 0:
                System.out.println("档位0，风扇静止");
                break;
            case 1:
                System.out.println("档位1，风扇转速500r/min");
                break;
            case 2:
                System.out.println("档位2，风扇转速1000r/min");
                break;
            case 3:
                System.out.println("档位3，风扇转速1500r/min");
                break;
            default:
                System.out.println("档位不存在");
                break;
        }
        System.out.println("OVER");
    }
}

switch语法中的特殊情况

1. break缺失

会造成case穿透，执行多余的代码
如果能总结好规律，也可以提高效率

2. default缺失

能缺失，没有了默认的情况

3. default书写在其他位置

不影响运行，可读性变差
一般书写在最后面

三、循环结构语句

3.1 while循环语句

while(条件语句){
	执行语句;
}

public class Demo07 {
    public static void main(String [] args){
        int x = 0;
        while(x < 4) {
            System.out.println("x = " + x);
            x++;
        }
    }
}

while循环特殊情况

1. 一次都不执行

循环第一轮判断，条件是false，循环直接结束

2. 无限循环

循环条件恒为true

3.2 do…while循环语句

do {
	执行语句;
} while(条件语句)；

public class Demo08 {
    public static void main(String [] args){
        int x = 0;
        do {
            System.out.println("x = " + x);
            x++;
        } while(x < 4);
    }
}

注意：do…while与while循环语句的区别在于do…while语句会无条件执行一次

3.3 for循环语句

for(初始化表达式；循环条件；操作表达式){
	执行语句;
}

public class Demo09 {
    public static void main(String [] args) {
        int i, j = 0;
        for(i = 1; i < 5; i++) {
            j++;
        }
        System.out.println(j); //4
    }
}

3.4 循环嵌套

指在循环体中再定义一个循环结构

public class Demo10 {
    public static void main(String[] args) {
        int i, j;
        for (i = 1; i < 6; i++) {
            for(j = 0; j < i; j++) {
                System.out.print('*');
            }
            System.out.print('\n');
        }
    }
}

四、跳转语句

4.1 break语句

常出现于循环语句，用于跳出循环体，执行循环体外的语句

4.2 continue语句

在循环语句中，终止本次循环，执行下次循环

五、方法

修饰符 返回值类型 方法名 (参数类型 参数名1，参数类型 参数名2， ...) {
	执行语句；
	...
	return 返回值；
}

public class Demo11 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println(getMax(sc.nextInt(), sc.nextInt()));
    }
    public static int getMax(int a, int b){
        int c;
        return c = a > b ? a : b;
    }
}

5.1 方法结构

1. 修饰符

public

公开的，java中的关键字，目前默认使用public
static

静态的，java中的关键字，目前默认使用static

后续会接触更多的修饰符

2. 返回值

void

返回值为空，今天会接触其他的返回值类型

其余返回值大体类似

5.2 形参和实参

形参

形参数定义在方法声明中小括号中的变量

只需要变量的声明，不用赋值
这些参数告知方法的调用者：此方法运行需要这些数据【是必须的】

实参

在方法中实际参与运行的数据
- 具体的数据
- 相当于给声明的形参赋值

5.3 方法重载

同一个作用域内具有相同方法名，但参数不同的方法

public class Demo12 {
    public static void main(String[] args) {
        System.out.println(getMax(2,5));
        System.out.println(getMax(2,9,5));
    }
    public static int getMax(int a, int b) {
        int c;
        return c = a > b ? a : b;
    }
    public static int getMax(int a, int b, int c) {
        int max = a > b ? a : b;
        max = max > c ? max : c;
        return max;
    }
}

六、数组

数组类型 [] 数组名;
数组类型 [] 数组名 = new 数组类型[长度];

int[] X;
int[] y = new int[10];

6.1 数组默认初始值

数据类型	默认初始值
byte、short、int、long	0
float、double	0.0
char	空字符，即’\u0000’
boolean	false
引用数据类型	null，表示变量不引用任意对象

6.2 数组常见操作

1. 遍历

public class Demo13 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4};
        for(int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " "); //1 2 3 4 
        }
    }
}

2. 排序

public class Demo14 {
    public static void main(String[] args) {
        int[] arr1 = { 8, 7, 3, 5, 6, 1, 4 };
        System.out.println("冒泡排序前：");
        printArray(arr1); //8 7 3 5 6 1 4
        bubbleSort(arr1);
        System.out.println("冒泡排序后：");
        printArray(arr1); //1 3 4 5 6 7 8
    }
    public static void printArray(int[] a) { //打印数组
        for(int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println('\n');
    }
    public static void bubbleSort(int[] a) { //冒泡排序
        for(int i = 0; i < a.length - 1; i++) {
            for(int j = 0; j < a.length - i - 1; j++) {
                if(a[j] > a[j + 1]) { //比较相邻元素
                 int temp = a[j];
                 a[j] = a[j + 1];
                 a[j + 1] = temp;
                }
            }
        }
    }
}

6.4 二维数组

数据类型[][] 数组名 = new int[行的个数] [列的个数];
数据类型[][] 数组名 = new int[行的个数] [];
数据类型[] [] 数组名 = {{第0行初始值}，{第1行初始值},...，{第n行初始值}}

int[][] arr1 = new int[1][2];
int[][] arr2 = new int[3];
int[][] arr3 = { { 1 ,2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } };

6.5 数组扩容

1. 概述

数组创建的时候需要指定长度，长度不能更改
如果数组中已经存满了数据，还有更多的数据需要存入，数组需要扩容
扩容的思路：
- 创建更大的新数组
- 把原来数组中的数据依次复制到新的数组

2. 扩容方式

手动扩容

使用循环挨个遍历数据，复制数据到新数组

public class Demo15 {
	public static void main(String[] args) {
		String[] nameWei = {"许褚","典韦","夏侯惇","夏侯渊","曹爽"};
		String[] nameShu = {"赵云","马超","关羽","张飞","黄忠"};
		
		// 创建更大的数组,存入原来数组中的数据和新加入的数据
		String[] names = new String[nameWei.length + nameShu.length];
		
		// 迁移数据
		// 把nameWei中的数据迁移到新的数组
		for (int i = 0; i < nameWei.length; i++) {
			names[i] = nameWei[i];
		}
		
		for (int i = 0; i < names.length; i++) {
			System.out.println(names[i]);
		}
		
		// 把nameShu中的数据迁移到新的数组
		for (int i = 0; i < nameShu.length; i++) {
			names[nameWei.length + i] = nameShu[i];
		}
		
		System.out.println("-----------------------");
		
		for (int i = 0; i < names.length; i++) {
			System.out.println(names[i]);
		}
	}
}

System.arraycopy方法

把源数据数组中的数据复制到目标数组

public class Demo16 {
	public static void main(String[] args) {
		/**
		 * 	public static void arraycopy(Object src,
                             int srcPos,
                             Object dest,
                             int destPos,
                             int length)
			 	src - 源数组。
				srcPos - 源数组中的起始位置。
				dest - 目标数组。
				destPos - 目标数据中的起始位置。
				length - 要复制的数组元素的数量。 
		 */
		// 源数据数组
		String[] nameWei = {"许褚","典韦","夏侯惇","夏侯渊","曹爽"};
		String[] nameShu = {"赵云","马超","关羽","张飞","黄忠"};
		
		// 创建新数组:目标数组
		// 创建更大的数组,存入原来数组中的数据和新加入的数据
		String[] names = new String[nameWei.length + nameShu.length];
		
		// 使用系统提供的方法复制数据
		System.arraycopy(nameWei, 0, names, 0, nameWei.length);
		System.arraycopy(nameShu, 0, names, nameWei.length, nameShu.length);		
		
		for (int i = 0; i < names.length; i++) {
			System.out.println(names[i]);
		}
	}
}

Arrays.copyOf方法

创建指定长度的数组，把源数据数组中的内容复制到新的数组

import java.util.Arrays;
public class Demo17 {
	public static void main(String[] args) {
		// 源数据数组
		String[] nameWei = {"许褚","典韦","夏侯惇","夏侯渊","曹爽"};
		String[] nameShu = {"赵云","马超","关羽","张飞","黄忠"};
		
		// 把数组转换成为字符串
		System.out.println(Arrays.toString(nameWei));
		
		/**
		 *	创建一个新的数组，长度是20
		 *		把nameWei中的数据复制到新的数组
		 *		剩余的空间可以接纳更多的数据
		 */
		String[] newArray = Arrays.copyOf(nameWei, 5);
		for (int i = 0; i < newArray.length; i++) {
			System.out.println(newArray[i]);
		}
		// 把数组转换成为字符串,包含原数组中所有的内容
		String str = Arrays.toString(newArray);
		System.out.println(str);
	}	
}