Java学习文档

类名首字母必须大写
声明变量类型变量名(标识符)
程序员自定义的名字都叫做标识符
由字母、数字、_ 、$ 组成
不能以数字开头
标识符不能是关键字
标识符起名要见名知意
标识符尽量使用驼峰命名法
包名全部小写，常量名全部大写
赋值
首次赋值-变量初始化
未初始化的变量不可被调用
指定类型的变量只能赋值对应类型的值
变量可以多次赋值，但是不能重新声明
三目运算符: A > B ? C : D
double b = 12; 其实是赋值了12.0
二进制 （ 0b 开头 + 二进制数值主体）
a = 0b10011 = 19
八进制 （ 0 开头 + 八进制数值主体）
a = 0111 = 73
十六进制 （ 0x 开头+十六进制数值主体）
a = 0x111;
声明两个变量，将两个变量的值进行交换

		//中间变量
		int e = 12;
		int f = 34;
		int temp = e;
		e = f;
		f = temp;

java中浮点型默认类型是double,要将double转为float

		//带f后缀可为float赋值
		float ff = 12.2f;

算术运算符

		// + - * % /
		int a = 12, b = 23, i;
		int c = a + b;
		int d = a - b;
		int e = a * b;
		int f = a / b;
		int h = a % b;

一元运算符

 		//一元运算
		int a = 12;
		a++;//把a的值自加1, a = 13；
		++a;//把a的值自加1, a = 14;
		a--;//把a的值自减1, a = 13;
		--a;//把a的值自减1, a = 12;

判断运算符

		//判断运算符 > < <= >= == !=
		boolean bool;
		bool = 12 > 23;//false
		bool = 12 < 23;//true
		bool = 12 <= 23;//true
		bool = 12 >= 23;//false
		bool = 12 == 23;//false
		bool = 12 != 23;//true

逻辑运算符 　&& 　　 || 　　　!
&& 　的优先级高于　 ||
&& 　前后表达式都为true，整个表达式结果才为true
|| 　前后表达式有一个为true，整个表达式就为true
! 　非(翻转结果)[一元运算]
短路现象
A　&&　B 　如果A的结果为false，整个表达式的结果就是false，B不会被运算
A　||　B 　如果A的结果为true，整个表达式的值就为true，B不会被执行
== 比较引用时，比较的是引用的地址
位运算(二进制运算)
&　 (按位与)前后两个数字都转为二进制，右侧对齐，上下比较，两者都为1则结果为1，有一个不为1则结果为0
| 　(按位或)两者有一个为1则结果为1，两者都不为1则结果为0
& 　和　| 　没有短路现象
^　 (按位异或) 两个相同为0，不同为1
>>　 (向右移) A >> B, A的二进制向右移B位
<< 　(向左移) A << B, A的二进制向左移B位,空出的位置补0
Ctrl + Shift + o快速导包
控制台输入输出

		//控制台输入
		Scanner sc = new Scanner(System.in);
		//控制台输出
		System.out.println("请输入数据");

分支判断

		//分支判断
		//1.if(){}
		int a = sc.nextInt();
		if(a % 2 == 0) {
   
			System.out.println("偶数");
		}else {
   
			System.out.println("奇数");
		}
		if(a > 0 && a < 10) {
   
			System.out.println("a的范围是1-9");
		}else if(a >= 10 && a < 20) {
   
			System.out.println("a的范围是10-19");
		}else if(a >= 20 && a < 30) {
   
			System.out.println("a的范围是20-29");
		}else {
   
			System.out.println("a的范围是30或30以上");
		}
		//2.switch(){}
		//匹配所有case项,如果都不符合才会执行default
		//匹配到某一个值,就是从该行开始运行，一直在运行到break或者代码块结束
		//case和default的书写顺序是可以打乱的
		//switch可以匹配什么类型？
		//整数(浮点型不可以, long类型也不可以), 字符, 布尔类型不可以, 字符串, 枚举
		a = 1;
		switch(a) {
   
		case 0 :
			System.out.println("a的值是0");
			break;
		case 1 :
			System.out.println("a的值是1");
			break;
		case 2 :
			System.out.println("a的值是2");
			break;
		default:
			System.out.println("a的值无法判断");
			break;
		}

while循环

//while循环
		int i = 0;
		while(i < 20) {
   
			System.out.println(i);
			i++;
		}

随机数

		double d = Math.random();

do while循环

		int i = 0;
		do {
   
			System.out.println("--" + i);
			i++;
		} while(i < 20);

for循环

		//for循环
		//第一个表达式只会执行一次，剩下两个表达式循环执行
		//第二个表达式只能为判断表达式
		//三个语句可以全部为空，但是不可以没有
		for(i = 0; i < 10; i += 2) {
   
			if(i == 0 || i == 8) System.out.println("************");
			else System.out.println("* *");
		}
		for(;;) {
   
			
		}

控制语句:
break结束循环
continue 结束本次循环，立即开启新的循环
数组

		//数组
		//声明
		int[] arr;
		//开辟空间
		arr = new int[10];
		//声明并赋值
		arr = new int[] {
   1, 2, 3, 4, 5};
		//直接赋值 必须声明并直接赋值
		int[] arr1 = {
   1, 2, 3};
		//数组 java中数组的类型是不可变的
		//数组的属性 数组.length
		System.out.println(arr.length);
		//依次获取该数组的累加值，最大值和最小值
		System.out.println(Arrays.toString(arr));
		int sum = arr[0], max = arr[0], min = arr[0];
// //累加值初始为arr[0],最大值和最小值都设置为数组的第一个值
		for(int i = 1; i < arr.length; i++) {
   
			sum += arr[i];//每次循环将数组的值加到sum中
			max = max > arr[i] ? max : arr[i];
			//max与每一个数组值比较，若小于当前数组值，则改变max
			min = min < arr[i] ? min : arr[i];
			//min与每一个数组值比较，若大于当前数组值，则改变min
		}
		System.out.println(sum);
		System.out.println(max);
		System.out.println(min);
		//数组排序
		//冒泡排序
		int temp;
		//j是确定好的元素的个数
		for(int j = 0; j < arr.length - 1; j++) {
   
			for(int i = 0; i <= arr.length - j - 1; i++) {
   
				if(arr[i] > arr[i+1]){
   
					//前面的元素大,交换位置
					temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
				}
			}
		}