Java基础知识易错点总结

# 1.char 只能有且仅有一个字符 没有也不行('','  ',仅有' '可以)
System.out.println('');# 报错
System.out.println('  ');# 报错
System.out.println('AB');# 报错

System.out.println(12+23+"中国"); # 输出 35中国
System.out.println("中国"+12+23); # 输出 中国1223

byte:	1个字节    -128~127
short:  2个字节
 int:	4个字节    -2^63~2^63-1(-21亿~21亿)
long:   8个字符
float:	4个字节
double:	8个字节
char:	0-65535 
boolean: true,false

表示的数据范围大小关系为: 
byte < short(char) < int < long < float < double
boolean 仅有 true,false 不和它基本类型做比较

六种常量类型: 字符串常量 整型常量 浮点型常量 字节常量 布尔常量 空常量

byte short char 在做运算时会先提升为int后再运算,其中boolean不能发生数据类型转换

精度损失(3.5(double)->3(int)) 数据溢出(3.5(double)->3.5(float))

float j;
{
    j=8F;
}
System.out.println(j);
这样表示是可以的 相当于向其它函数传递实参(而不是形参),并在其函数体内进行修改函数值;

# 一次定义俩个变量的方法
long a_long = 6000000000L,b_long = 6000000000L;

# 此处的60亿会自动转为int型 编译时会报错 超出整型int范围
System.out.println(6000000000);

int a = 10;
# 5 在 byte(-128~127范围内) 编译器优化 允许这样的赋值
byte b1 = 5;
# byte b2 = b1 + (byte)a;
# 这样写是错误的 因为 byte、short、char 在做加法运算的时候byte类型数据会自动转化为int类型
# 那么仅强转a为byte类型是不够的.
# 需要如下的正确写法:
byte b2 = (byte)(b1 + a);

# 结果为-128,这种现象称之为回环,到byte所能表示的最大值之后回环到-128开始
byte b3 = (byte)128;
System.out.println(b3);

# 10=10+1; ++、-- 只能操作变量 不能操作常量
System.out.println(10++);

# 三元表达式不能独立存在
# 也就是不能光秃秃的写三元表达式(必须 要么打印输出 要么赋值给变量使用)
System.out.println(false ? 3 : 5.21);

# 此处这样写,编译是会报错的 因为int c;c=100;这是俩句,因而这里的花括号不能省略
if(a>18)
	int c=100;

public static void main(String [] args){
boolean flag = false;
if(flag = true){
	System.out.println("执行语句1");
}
System.out.println("执行语句2");
}
# 本题在小括号中不是判断语句，是一个赋值语句。赋值的结果也是一个布尔类型的，所以语法正确。
# 在小括号中的意思是将true赋值给一个变量flag，那么结果肯定是true，所以会执行语句1和语句2。

# switch(变量/常量/表达式){}
# 且括号中最终的数据类型为 byte short int char JDK1.5之后支持枚举类型 JDK1.7后支持字符串


# 这样是会报错的,因为switch()中case后的只能为常量 比如"case 1:" "case 'a':"等 不能为变量
int a = 5;
switch(5){case a: System.out.println("我是5;")}

# 也是会报错的括号内不能为double
switch(3.14){}

# default的位置不影响正常的条件判断
# 依然会输出1
switch (1) {
	default:
		System.out.println("default");
		break;
	case 1:
		System.out.println("1");
		break;
}
# 同理 下面这个例子依然会输出default
switch (2) {
	default:
		System.out.println("default");
		break;
	case 1:
		System.out.println("1");
		break;
}

# while循环一般用于不明确循环次数的循环,而if循环则用于指定循环次数的循环

while(true) {
	System.out.println("HELLO_WORLD!!!");
    # 一般在没有跳出语句的while死循环后继续写代码,编译器会报错,因而可以通过如下方式绕过编译器报错
	# while语句中 可以通过此种方式绕过编译器报错
	if (3 > 4){
		break;
	}
}
System.out.println("Hello_Java!!!");

# break语句跳出指定循环的经典案例,在要跳出的循环前写lo:,然后再写break lo;
int a = -1;
Scanner sc = new Scanner(System.in);
lo:while(true){
	System.out.println("请输入您要查看的星期数:");
	System.out.println("(如无需继续查看,请输入0退出程序)");
	a = sc.nextInt();
	switch(a){
		case 1:
			System.out.println("星期一我们去跑步");
			break;
		case 2:
			System.out.println("星期二我们去游泳");
			break;
		case 3:
			System.out.println("星期三我们去慢走");
			break;
		case 4:
			System.out.println("星期四我们去动感单车");
			break;
		case 5:
			System.out.println("星期五我们去拳击");
			break;
		case 6:
			System.out.println("星期六我们去爬山");
			break;
		case 7:
			System.out.println("星期日我们去好好吃一顿");
			break;
		case 0:
			System.out.println("感谢您的使用");
			break lo;
		default:
			System.out.println("您输入的星期数有误!!!");
			break;
	}
}

# 生成 [min,max] 范围内的随机整数的公式为
Random random = new Random();
int a = random.nextInt(max-min+1) + min;
# 举个栗子 取[0,1]的随机整数
int a = random.nextInt(1-0+1) + 0;

# 方法在内存中都是在栈中,而new出来的对象都是在内存中的堆空间的
# 引用数据类型 就是引用的 对象的在堆空间中的地址
# 执行程序时 首先将main方法在内存中写入方法区并且压入栈中(存方法和局部变量),然后在根据方法区中的语句 遇到方法压栈 遇到new出来的对象 将该对象写入堆(存对象中的成员变量和成员方法)

有关下面数组的定义，格式正确的是（ ）

A:

int[] arr = new int[3];
B:

int[] arr = new int[3]{11,22,33};
C:

int[] arr = {11,22,33};
D:

long[] arr = new int[] {33,22,11};
 

我的答案：A,B,C
正确答案：A,C
答案解析： 
数组在定义的过程中，中括号可以放在数组名称的前面，也可以放在数组名称的后面，在初始化数组的过程中，不能既给出长度，又给出具有的值。

A选项：该选项正确，这是正确的数组动态初始化，中括号可以写在数组名称的前面或者后面

B选项：该选项错误，数组初始化过程中，要么给出长度，要么给出具体数据值。

C选项：该选项正确，这是正确的数组静态初始化，中括号可以写在数组名称的前面或者后面

D选项：该选项错误，这是错误的数组静态初始化，等号前面的数据类型，必须和等号后面的数据类型一致

# 【编号：603】 有一个很有名的数学逻辑题叫做不死神兔问题。有一对兔子，从出生后第3个月起每个月都生一对兔子，
# 小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
# 第3个月起 第三个月也生兔子

# 解析: 典型的斐波拉切数列,当前下标的值等于前俩下标的值之和
public class Test10 {
    public static void main(String[] args) {
        int[] a = new int[]{-2};
        int count = 0;
        /** 该月具备生产能力的兔子的个数 */

        for (int month  = 0; month < 20; month++) {
            count = a.length;
            for(int i = 0;i < a.length;i ++){
                a[i]+=1;
                if (a[i]>0){
                    int[] temp = new int[a.length+1];
                    for(int j = 0;j < a.length;j ++){
                        temp[j] = a[j];
                    }
                    temp[a.length] = -2;
                    a = temp;
                }
            }
            System.out.println("第"+(month+1)+"个月兔子的对数为:" + a.length + "\t该月新生兔子为:" + (a.length-count));
        }
    }
}
}

# 当方法的返回值类型为void时,
# 是可以使用return 的 但是 只能单独使用  
# return后不能带有任何返回值;
# return 此时仅有结束当前方法的功能;

# while case循环中也可使用return语句
while(true)
switch(1){
	case 1:
		return;
}

同一个类中,多个方法的方法名相同,参数不同,则称为方法重载
(满足以下相关元素,且不满足以下不想关元素的则为重载)
有关的因素:
	1.方法名必须相同:
	2.参数必须不同:
		2.1	参数个数不同					method(int a), method(int a,int b)
		2.2 参数的类型不同					method(int a), method(String s)
		2.3 多个不同类型的参数顺序不同		method(int a,String s), method(String s,int a)
无关的元素：
	1.与参数的名称无关:	method(int a,int b), method(int c,int d)  不算方法重载
	2.int method(int a,int b), double method(int c,int d)   不算方法重载

# 方法参数传递为基本数据类型时: 传入方法中的 是具体的数值,因为基本数据类型的变量记录的就是具体值;
# 方法参数传递为引用数据类型时: 传入方法中的 是变量对应的地址值,因为引用数据类型的变量里存的是它对应的地址值;

# 此处编译器不会报错 因为只要方法返回值类型 表示的数据范围大于 方法体中返回值的数据范围(兼容) 即可
public static double a() {
	return 3;
}

# 冒泡 升序 排序算法
for (int i = 0; i < arr.length -1; i++) {
	for (int j = 0; j < arr.length -1 -i; j++) {
		if (arr[j] > arr[j+1]){
			arr[j] = arr[j] ^ arr[j+1];
			arr[j+1] = arr[j] ^ arr[j+1];
			arr[j] = arr[j] ^ arr[j+1];
		}
	}
}

# IDEA断点调试的过程中,面对复杂的判断条件语句的时候,可以拖动左键选中代码后,右击选中的代码 在弹出框中选择Add Watchs 可以看到当前复杂条件语句的结果

# &、|、^、~ 与 或 异或 非 一假即假、一真即真、相同为false不同为true、取反

# <<效率比*高很多 比如根据一个数组的长度定义另一个数组: 
int[] a = new int[]{11,22,33}; int[] b = new int[a.length<<1];
# 此处 a.length<<1 等同于 a.length*2

# 引用数据类型	因为null是引用数据类型的默认值,null可以给任意引用数据类型变量赋值

# iter单行输入 是 IDEA遍历List数组的快捷键

# Collections.shuffle() 快速打乱integerList内元素的顺序
Collections.shuffle(integerList);

# 升序快排
Arrays.sort(arr);

# Java中Arrays.parallelSort和Arrays.sort性能对比: Arrays.parallelSort是JDK8新增的并行排序算法,Arrays.sort是串行排序算法;这俩都是 升序 算法
# 他们所对应的降序算法使用方法
Arrays.parallelSort(arr,Collections.reverseOrder());
Arrays.sort(arr,Collections.reverseOrder());

# 类是对象的模板,对象是类的实例.

# 交换俩个值有 异或法 加减法

# 异或法
int a = 1,b = 2;
a = a ^ b;
b = a ^ b;
a = a ^ b;
# a = 2,b = 1
System.out.println("a = " + a + ",b = " + b);

# 加减法
int a = 1,b = 2;
a = a + b;
b = a - b;
a = a - b;
# a = 2,b = 1
System.out.println("a = " + a + ",b = " + b);