Java一些易错的基础知识

1. 数据类型转换之隐式转换
* A:案例演示
* a:int + int
* b:byte + int 
* B:Java中的默认转换规则
* 取值范围小的数据类型与取值范围大的数据类型进行运算,会先将小的数据类型提升为大的,再运算 

class Demo3_DataTypeConversion {					//Conversion转换
	public static void main(String[] args) {
		//数据类型转换之隐式转换
		/*int x = 3;
		byte b = 4;
		x = x + b;
		System.out.println(x);*/

		//数据类型转换之强制转换
		/*int x = 3;
		byte b = 4;

		b = (byte)(x + b);
		System.out.println(b);*/

		//00000000 00000000 00000000 10000010			130的二进制
		//10000010										-126补码
		//00000001										-1求反码
		//10000001										-126反码
		//11111110										-126原码
		byte b = (byte)(126 + 4);
		System.out.println(b);
		//00000000 00000000 00000001 00101100			300的二进制
		//00101100
		byte b2 = (byte)300;
		System.out.println(b2);
	}
}

2. 数据类型转换之强制转换
* A:强制转换问题
* int a = 10;
* byte b = 20; 
* b = a + b;
* B:强制转换的格式
* b = (byte)(a + b); 
* C:强制转换的注意事项
* 如果超出了被赋值的数据类型的取值范围得到的结果会与你期望的结果不同 
3. 面试题之变量相加和常量相加的区别
* A:案例演示
* 面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
* byte b1 = 3;
* byte b2 = 4;
* byte b3 = b1 + b2;
* 从两方面去回答这个题
* b1和b2是两个变量,变量里面存储的值都是变化的,所以在程序运行中JVM是无法判断里面具体的值
* byte类型的变量在进行运算的时候,会自动类型提升为int类型 
* byte b4 = 3 + 4;
* 3和4都是常量,java有常量优化机制,就是在编译的的时候直接把3和4的结果赋值给b4了 

class Test1_DataTypeConversion {
	public static void main(String[] args) {
		//面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
		byte b1 = 3;
		byte b2 = 4;
		//byte b3 = b1 + b2;
		/*
		从两方面
		1,byte与byte(或short,char)进行运算的时候会提升为int,两个int类型相加的结果也是int类型
		2,b1和b2是两个变量,变量存储的值是变化,在编译的时候无法判断里面具体的值,相加有可能会超出byte的取值范围
		*/
		//System.out.println(b3);
		//byte b4 = 3 + 4;			//java编译器有常量优化机制
		byte b4 = 7;
		System.out.println(b4);
	}
}	

4. 字符和字符串参与运算
* A:案例演示
* System.out.println('a');
* System.out.println('a'+1);

* 通过看结果知道'a'的值是多少,由此引出ASCII码表
* B:ASCII码表的概述
* 记住三个值：
* '0'  48
* 'A'  65
* 'a'  97
* C:案例演示
* System.out.println("hello"+'a'+1);
* System.out.println('a'+1+"hello");
* D:+在有字符串参与中被称为字符串连接符
* System.out.println("5+5="+5+5);
* System.out.println(5+5+"=5+5");

class Demo4_DataTypeConversion {
	public static void main(String[] args) {
		//System.out.println('a' + 1);			//98,因为有ASCII码表,a字符对应的是int类型的97
		//System.out.println((char)('a' + 1));


		System.out.println("hello"+'a'+1);		//任何数据类型用+与字符串相连接都会产生新的字符串
		System.out.println('a'+1+"hello");


		System.out.println(" 5 + 5 = " + (5 + 5));
	}
}

5. char数据类型
* A:char c = 97; 0到65535
* B:Java语言中的字符char可以存储一个中文汉字吗?为什么呢?
* 可以。因为Java语言采用的是Unicode编码。Unicode编码中的每个字符占用两个字节。中文也是占的两个字节
* 所以，Java中的字符可以存储一个中文汉字

6. 算术运算符++和--的练习
* A:案例演示
* 请分别计算出a,b,c的值?
* 
int a = 10;
int b = 10;
int c = 10;

a = b++;
c = --a;
b = ++a;
a = c--;

* B:案例演示
* 请分别计算出x,y的值?

int x = 4;
int y = (x++)+(++x)+(x*10);
* C:面试题
* byte b = 10;
* b++;
* b = b + 1;
* 问哪句会报错,为什么 

class Test1_Operator {
	public static void main(String[] args) {
		//第一题
		/*int a = 10;
		int b = 10;
		int c = 10;
	
		a = b++;					//a = 10 ,b = 11
		c = --a;					//a = 9, c = 9			
		b = ++a;					//a = 10, b = 10	
		a = c--;					//a = 9, c = 8			
		
		System.out.println("a = " + a + ",b = " + b + ",c = " + c);*/


		//第二题
		/*int x = 4;
		//		4	+	6+	60
		int y = (x++)+(++x)+(x*10);


		System.out.println("x = " + x + ",y = " +  y);*/


		//第三题问哪句会报错,为什么 
		byte b = 10;
		//b++;					//b = (byte)(b + 1)
		b = b + 1;				//当byte与int进行混合运算的时候,会提升为int类型,两个int相加的结果还是int,赋值给byte会损失精度
		System.out.println("b = " + b);
		
	}
}

7. 赋值运算符的面试题
* A:案例演示
* 面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
* short s=1;s = s+1;
* short s=1;s+=1;

class Test1_Operator {
	public static void main(String[] args) {
		// 面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
		//short s=1;s = s+1;			//当short与int进行运算的时候,会提升为int类型,两个int类型相加的结果也是int类型
		short s=1;s+=1;					//s = (short)(s + 1);


		System.out.println(s);
	}
}

8. 逻辑运算符&&和&的区别
* A:案例演示
* &&和&的区别?
* a:最终结果一样。
* b:&&具有短路效果。左边是false，右边不执行。
* &是无论左边是false还是true,右边都会执行

class Demo2_Operator {
	/*
	&&与&的区别
	* a:最终结果一样。
	* b:&&具有短路效果。左边是false，右边不执行。


	||与|的区别
	a:最终的结果是一样
	b:||具有短路效果,左边为true,右边不执行
	*/
	public static void main(String[] args) {
		/*int a = 10;
		int b = 20;
		int c = 30;
		System.out.println(a < b && b < c);				//true && true = true
		System.out.println(a < b && b > c);				//true && false = false
		System.out.println(a > b && b < c);				//false && true = false
		System.out.println(a > b && b > c);				//false && false = false*/


		int x = 3;
		int y = 4;
		//System.out.println((++x == 3) & (++y == 4));	//false & false = false
		//System.out.println("x = " + x);					//x = 4
		//System.out.println("y = " + y);					//y = 5
		System.out.println("---------------------------");
		System.out.println((++x == 3) && (++y == 4));	//false & false = false
		System.out.println("x = " + x);					//x = 4
		System.out.println("y = " + y);					//y = 4
	}
}

9. 位异或运算符的特点及面试题
* A:案例演示
* 位异或运算符的特点
* ^的特点：一个数据对另一个数据位异或两次，该数本身不变。

class Demo2_Operator {
	public static void main(String[] args) {
		/*
		* 位异或运算符的特点
		* ^的特点：一个数据对另一个数据位异或两次，该数本身不变。
		*/
		//System.out.println(5 ^ 10 ^ 10);
		//System.out.println(5 ^ 10 ^ 5);

		/*
		* 请自己实现两个整数变量的交换(不需要定义第三方变量)
		* 注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。
		*/
		int x = 10;
		int y = 5;

		//需要第三方变量,开发推荐用这种
		/*int temp;
		temp = x;
		x = y;
		y = temp;*/

		//不需要定义第三方变量,有弊端,有可能会超出int的取值范围
		/*x = x + y;				//10 + 5 = 15
		y = x - y;				//15 - 5 = 10
		x = x - y;				//15 - 10 = 5*/

		//不需要第三方变量,通过^来做
		x = x ^ y;				// 10 ^ 5 
		y = x ^ y;				// 10 ^ 5 ^ 5	y = 10
		x = x ^ y;				// 10 ^ 5 ^ 10  x = 5

		System.out.println("x = " + x + ",y = " + y);
	}
}

10. 成员变量和局部变量的区别
* A:在类中的位置不同
* 成员变量：在类中方法外
* 局部变量：在方法定义中或者方法声明上
* B:在内存中的位置不同
* 成员变量：在堆内存(成员变量属于对象,对象进堆内存)
* 局部变量：在栈内存(局部变量属于方法,方法进栈内存)
* C:生命周期不同
* 成员变量：随着对象的创建而存在，随着对象的消失而消失
* 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
* D:初始化值不同
* 成员变量：有默认初始化值
* 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
* 注意事项：
* 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
* 基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char
* 引用数据类型变量包括哪些:数组,类,接口,枚举
11. 创建一个对象的步骤
方法区、堆内存、栈
* Student s = new Student();
* 1,Student.class加载进内存
* 2,声明一个Student类型引用s
* 3,在堆内存创建对象,
* 4,给对象中属性默认初始化值
* 5,属性进行显示初始化
* 6,构造方法进栈,对对象中的属性赋值,构造方法弹栈
* 7,将对象的地址值赋值给s