Java复习之知识点整理（一）

1.Dos常见命令

cls : 清屏

dir : 查看目录

. : 当前目录

cd :change dir 改变目录

.. ： 上级目录

tab : 制表符

c: d: e: f: 切换盘符

2.windows快捷键

win+r : 运行cmd

win + d ： 显示桌面

3.CMD常见快捷键

cmd + calc :计算器

cmd + mspaint : 画图

cmd + mkdir : 创建文件夹

cmd + del : 删除文件或者目录

cmd + echo xxxx > a.txt : 向a.txt中覆盖输入xxxx

cmd + echo xxxx >> a.txt : 向a.txt中追加输入xxxx

cmd + type a.txt : 输出a.txt中的文本内容

cmd + tree ： 显示目录结构的树形图

cmd + rmdir + /s /q ： 删除一个目录

cmd + del * ： 删除所有文件

cmd + copy a b : 将a复制到b

cmd + rename a b : 将a重命名为b

cmd + move a b : 将a移动到b

4.java中的关键字

class 类

interface 接口（指定规范）

byte 字节，计算机中最小的储存单位，-128~127 ， 1byte

short 短整型, 2byte

int 整形 4byte

long 长整型 8byte

float 单精度浮点 4byte

double 双精度浮点 8byte

char 字符型 2byte

boolean 布尔型 1byte

public 公开的

private 私有的

protected 受保护的

abstract 抽象的

final 最终的

static 静态的

synchrozined 同步

extends 继承

implements 实现

new 实例化

super 上级

instanceof 属于谁的实例

package 包

import 导入

native 本地的

5.计算机的中负数的储存形式

计算机中负数是通过补码的形式储存的，计算机不管多少位数值，如果全是1，则表示-1，理论上正数和负数相加应该为0，所以，负数的表示方法为：正数的每个位上的数字取反（1变0,0变1），但是如果这样就表示负数的话，会发现正数和负数相加为111111，每个位上的数字都是1，其数值表现为-1，所以，取反的基础上还要加上1

同理，负数的位取反，然后加1，则表示对应的正数

但是注意：byte表示的范围为256中组合，数值上规定为-128~127.也就是说，没有正的128，而-128表示为1000 0000 127表示为 0111 1111

6.java是强制类型的语言，变量的声明之前必须要指定类型

7.java中的引用类型有：

class 类

inerface 接口

[ ] 数组

8.隐式转换

隐式转换需要注意一点：所有的byte short,char 在计算（加减乘除等）的时候，都会自动隐式转换提升为int类型参与运算。所以， short s = 0 ; s = s + 2；这种写法是错的。因为等号右侧已经隐式变成了int,左侧还是short类型。但是 short s +=2; 就没问题，因为 += 运算已经强制转换了。

9.Java中的 与 或 亦或 & | ^

与& ： 按位相乘。表现为 只要有0就是0，全是1才是1；会向小数靠拢

或 | ： 按位相加。表现为 只要有1就是1 ， 全是0才是0；会向大数靠拢

异或^：按位数字相同位0，不同位1；会是数据分散

短路与 && ： 有假，结果便假。是逻辑运算，所以，左侧假，右侧不看

单与 & ： 有假，结果便假。但是因为其本质是位运算，所以符号两侧都会运算，都会看

短路或 || ： 有真，结果为真。是逻辑运算，所以，左侧真，右侧不看

单或 | ： 有真，结果便真。但是因为其本质是位运算，所以符号两侧都会运算，都会看

10.移位运算

左移 << X : 位向左移动X位。表现为数值扩大X倍（不超过最大表示范围）；

带符号右移 >> X： 所有位向右移动X位。前面空出来的位置自动补充符号位；表现为缩小X倍

不带符号右移 >>> X： 所有位向右移动X位。前面空出来的位置自动补充0；变现为缩小X倍，但是负数会变成正数；

飘 ~ ： 按位取反 0变1 ， 1变0 ；

注意，计算机中，全是0表示0,0位正数，全是1表示 - 1；首尾表示符号位

11.基础练习

class Day03 {
	public static void main(String[] args) {

		func9();

	}

	// 1.把浮点数的成绩换成优良中差，不及格,非法值.
	// 成绩: float score= 98.5f ;
	// 不及格 : [0,60) 0 <= x < 60
	// 差 : [60,70)
	// 中 ：[70,80)
	// 良 : [80,90)
	// 优 : [90,100]
	// if(){
	// switch(){
	// ....
	// }
	// }
	public static void func1() {
		float score = 98.5f;

		if (score < 0 || score > 100) {
			System.out.println("非法输入");
		} else if (score >= 0 && score <= 60) {
			System.out.println("不及格");
		} else {
			switch ((int) score / 10) {
			case 6: {
				System.out.println("差");
				break;
			}
			case 7: {
				System.out.println("中");
				break;
			}
			case 8: {
				System.out.println("良");
				break;
			}
			case 9:
			case 10: {
				System.out.println("优");
				break;
			}
			}
		}
	}

	// 2.找出1~1000之间的所有素数.
	// 素数: 除了1和本身之外，不能被任何数整除。有其他数整除，就不是质数
	public static void func2() {
		boolean isZhiShu = true;
		int j;

		for (int i = 2; i < 1000; i++) {
			isZhiShu = true;
			for (j = 2; j < i; j++) {
				if (i % j == 0) {
					isZhiShu = false;
					break;
				}
			}

			if (isZhiShu) {
				System.out.println(i + "是质数！");
			}
		}
	}

	// 3.大臣下棋，64 ， 每个格子放是2的n(n是格子的序号，1 ~ 64)次方个麦粒，64格子放满，需要多少麦粒?
	public static void func3() {
		int sum = 0;
		for (int n = 1; n <= 64; n++) {
			for (int j = 1; j < n; j++) {
				sum += Math.pow(2, j);
			}

		}
		System.out.println("共需要麦粒" + sum);
	}

	// 4.打印出9x9乘法表倒三角。
	public static void func4() {
		for (int i = 9; i >= 1; i--) {
			for (int j = 1; j <= i; j++) {
				System.out.print(i + " * " + j + " = " + i * j + "\t");
			}
			System.out.println("");
		}
	}

	// 5.打印空心三角形
	// *
	// * *
	// * *
	// * *
	// *********
	public static void func5() {
		int line = 10;
		for (int i = 1; i <= line; i++) {
			// System.out.print("0");
			for (int j = 1; j <= 2 * line - 1; j++) {
				if (i == line) {
					System.out.print("*");
				} else if (i + j == (line + 1) || j - i == (line - 1)) {
					System.out.print("*");
				} else {
					System.out.print(" ");
				}
			}
			System.out.println();
		}
	}

	// 6.百钱买白鸡。
	// 钱:100
	// 鸡:100
	//
	// 公鸡 : 5
	// 母鸡 : 3
	// 小鸡 : 1/3只
	public static void func6() {
		for (int i = 0; i <= 20; i++) {
			for (int j = 0; j <= 33; j++) {
				for (int k = 0; k <= 99; k += 3) {
					if (i + j + k == 100 && 5 * i + 3 * j + k / 3 == 100) {
						System.out.println("公鸡" + i + "母鸡" + j + "小鸡" + k);
					}
				}
			}
		}
	}

	// 7.冒泡排序
	// 10.冒泡排序
	public static void func7() {
		int[] nums = { 2, 3, 4, 6, 7, 9, 11, 15, 88 };

		for (int i = 0; i < nums.length - 1; i++) {
			for (int j = 0; j < nums.length - 1 - i; j++) {
				int temp;
				if (nums[j] < nums[j + 1]) {
					temp = nums[j];
					nums[j] = nums[j + 1];
					nums[j + 1] = temp;
				}
			}
		}

		for (int i : nums) {
			System.out.print(i + "  ");
		}
	}

	// 8.折半查找
	public static void func8(int search) {
		int[] nums = { 2, 3, 4, 6, 7, 9, 11, 15, 88 };

		int min = 0;
		int max = nums.length - 1;
		int mid = (max + min) / 2;

		boolean isHave = false;

		while (nums[mid] != search) {

			if (nums[mid] < search) {
				min = mid + 1;
			} else if (nums[mid] > search) {
				max = mid - 1;
			}

			mid = (min + max) / 2;

			if (min > max) {
				System.out.println("要查找的数值不存在");
				return;
			}
		}

		System.out.println("要查找的是第" + mid + "数值");

	}

	// 9.数组倒序
	public static void func9() {
		int[] nums = { 2, 3, 4, 6, 7, 9, 11, 15, 88 };

		int start = 0;
		int end = nums.length - 1;

		for (start = 0; start <= end; start++, end--) {
			int temp = nums[start];
			nums[start] = nums[end];
			nums[end] = temp;
		}

		for (int i : nums) {
			System.out.print(i);
		}
	}
}

全文完！