第2章 Java基本语法(上): 变量与运算符

2-1 关键字与保留字

• 关键字(keyword)
  
  
  
  

• 保留字(reserved word)
  
  

2-2 标识符(Identifier)

案例

	class Test{
		public static void main(String[] args) {
			System.out.println("Hello World!");
		}
	}

	class _9Hello{
	}

	class Public{
	}

	class publicstatic{
	}

	class PublicStatic{

	}

	class XinXi{
		String xingMing;
	}

2-3 变量

案例

	/**
	变量的声明和使用
	1.定义：在一定范围内取值不断变化的量。
	2.格式：数据类型 变量名 = 初始化值
	3.注意点：
	①先声明，后使用
	②变量的作用域即为其声明所在的{}内。
	*/
	  public class VariableTest {
	      public static void main(String[] args) {
	          int number1;
	          number1 = 10;

	          int number2;
	          number2 = 20;

	          int number3;
	        number3 = number1 + number2;
	        System.out.println("Number3 = " + number3);

	        int number4 = 50;
	        int number5 = number4 - number3;
	        System.out.println("Number5 = " + number5);
	     }
	 }

数据类型案例

	/**
	1.角度一：按照数据类型来分
	①基本数据类型：整型：byte / short / int / long
	浮点型：float / double
	字符型：char
	布尔型：boolean
	②引用数据类型：类 / 接口 / 数组
	注意：String 属于引用数据类型

	2.(了解)角度二：按照在类中声明的位置的不同来分：成员变量   vs  局部变量
	 */

	class VariableTest1{
		public static void main(String[] args) {
			//1.整型：byte (1字节:-128~127) / short (2字节) / int (4字节) / long(8字节)
			//通常，我们将一个整型变量定义为int。
			//如果定义log型变量，必须后缀为：l或L
			byte b1 = 3;

			//b1 = 128;

			int i1 = 23152;
			//i1 = 234254363575325243635;

			long l1 = 1243252323545L;

			System.out.println(b1);
			System.out.println(i1);

			//2.浮点型：float (4字节)/ double (8字节)
			//①从存储数据的表数范围上讲：float的范围比long要大。
			//②如果定义float型变量，必须后缀为:f或F
			//③通常，我们将一个浮点型变量定义为double.
			double d1 = 12.3;
			float f1 = 12.3f;
			f1 = 12.5F;
			System.out.println(f1);//12.5

			//3.字符型：char (2字节)
			//①通常情况下，声明一个字符，使用一对''
			//②char的不同表示方式：1.声明一个字符 2.声明转义字符 3.使用Unicode码（了解）
			char c1 = 'a';
			char c2 = '中';
			char c3 = 'ネ';
			char c4 = '4';

			//char c5 = 43;//编译可以通过的

			char c6 = '\n';
			char c7 = '\t';

			System.out.println("Hello" + c7 + "world");

			char c8 = '\u0023';

			//4.布尔型：boolean
			//只能保存true 或 false. 不能取值为null.
			//常常在条件判断、循环中，使用boolean型变量

			boolean isMarried = true;

			if(isMarried){
				System.out.println("你不能参加单身party了！");
			}else{
				System.out.println("可以多谈谈女朋友");
			}

		}
	}

基本数据类型转换案例

	/**
	基本数据类型变量间的运算规则

	适用范围：除了boolean之外，其他7种基本数据类型都适用

	1.自动类型提升：容量小的数据类型和容量大的数据类型的变量做运算，运算的结果为容量大的数据类型。
	byte 、short 、char --> int --> long -->  float --> double
	特别地，byte、short、char三者之间做运算，结果为int型。

	2.强制类型转换：自动类型提升的逆过程。见<VariableTest3.java>

	说明：此时的容量的大小指的是存储数据范围的大小，而非内存存储空间的大小。
	*/

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

			int num1 = 10;
			short s1 = 10;
			int num2 = num1 + s1;

			boolean b1 = true;
			//b1 + num1;

			long l1 = 123L;
			float f1 = 12.2f;
			float f2 = l1 + f1;

			//long l2 = l1 + f1;//编译不通过

			System.out.println(f2);

			double d1 = num1 + s1;
			System.out.println(d1);//20.0

			//********************************
			//字符char的运算
			char c1 = 'A';
			int num3 = 0;
			int num4 = c1 + num3;
			System.out.println(num4);//65

			//********************************
			//特别的情况：
			byte by1 = 10;
			short ss1 = 10;
			//short ss2 = by1 + ss1;//编译不通过
			int i1 = by1 + ss1;

			short ss2 = 10;
			//short ss3 = ss1 + ss2;//编译不通过

			byte by2 = 10;
			//byte by3 = by1 + by2;//编译不通过

			char c2 = 'a';

			//short ss4 = by1 + c2;//编译不通过

			//********************************
			//整型的常量，默认为int型。
			int n1 = 10;
			int n2 = n1 + 2;

			//浮点型的常量，默认为double型
			//float ff = n1 + 12.3;//编译不通过

			//**********************************
			long ll1 = 1234;//可以理解为自动类型提升
			System.out.println(ll1);

			long ll2 = 1234235234233L;
			System.out.println(ll2);

			//float ff1 = 12.3;//12.3默认为double,此时编译不通过

		}
	}

强制类型转换案例

	/**
	强制类型转换：
	1.自动类型提升的逆过程。
	2.容量大的数据类型的变量如果想转换为容量小的数据类型的变量,就需要使用强制类型符进行转换。
	3.强制类型转换符：()

	注意点：强转过程中，有可能出现精度损失的情况。
	*/

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

			int num1 = 12;
			short s1 = (short)num1;

			System.out.println(s1);

			//强转过程中，有可能出现精度损失的情况。
			//举例一：
			double d1 = 12.6;
			int num2 = (int)d1;
			System.out.println(num2);

			//举例二：
			int num3 = 128;
			byte b1 = (byte)num3;
			System.out.println(b1);//-128

		}
	}

String案例

	/**
	String类与基本数据类型(8种)变量之间的运算

	1.String类属于引用数据类型的变量
	2.String类型的变量值使用一对""括起来表示。
	3.String类与基本数据类型(8种)变量之间只能做连接运算：+
	4.String类与基本数据类型(8种)变量做运算的结果为:String类型
	*/
	class StringTest {
		public static void main(String[] args) {

			String s1 = "Hello World!";

			System.out.println(s1);
			System.out.println("s1");
			//System.out.println(s2);//编译不通过

			int num1 = 10;
			String s3 = s1 + num1;
			s3 = s3 + true;
			System.out.println(s3);

			//练习1：
			int n = 1;
			char c = 'a';
			String str = "beijing";

			System.out.println(n + c + str);//98beijing
			System.out.println(n + (c + str));//1abeijing
			System.out.println(str + n + c);//beijing1a

			//练习2：
			//*	*
			System.out.println("*	*");
			System.out.println("*" + "\t" + "*");
			System.out.println('*' + "\t" + "*");
			System.out.println('*' + '\t' + "*");//51*
			System.out.println('*' + '\t' + '*');//93

			char c1 = 'a';
			char c2 = 97;
			System.out.println(c2);

			//************************
			int i = 10;
			//String str1 = i;//编译不通过
			String str2 = i + "";

			System.out.println(str2);//"10"

			//int j = str2;//编译不通过

			//int j = (int)str2;//编译不通过

			//了解：使用包装类才能使得String---->int
			int j = Integer.parseInt(str2);
			System.out.println(j);

		}
	}

练习1

	String str1 = 4;        //判断对错：no
	String str2 = 3.5f + “”;             //判断str2对错：yes
	System.out.println(str2);        //输出：3.5
	System.out .println(3+4+“Hello!”);     //输出：7Hello!
	System.out.println(“Hello!”+3+4);      //输出：Hello!34
	System.out.println(‘a’+1+“Hello!”);    //输出：98Hello!
	System.out.println(“Hello”+‘a’+1);     //输出：Helloa1

练习2

	判断是否能通过编译
	1）short  s = 5;
	      s = s-2;                     //判断：no
	2） byte b = 3;
	       b = b + 4;                  //判断：no
	       b = (byte)(b+4);       	   //判断：yes
	3）char c = ‘a’;
	      int  i = 5;
	      float d = .314F;
	      double result = c+i+d;       //判断：yes
	4） byte b = 5;
	       short s = 3;
	       short t = s + b;            //判断：no

进制案例

	/*
	对于整数，有四种表示方式：
	二进制：0,1 ，满2进1.以0b或0B开头。
	十进制：0-9 ，满10进1.
	八进制：0-7 ，满8进1. 以数字0开头表示。
	十六进制：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。
		如：0x21AF +1= 0X21B0

	*/
	class  BinarySystemTest{
		public static void main(String[] args) {
			int num1 = 0b1010;//二进制

			int num2 = 0754;//八进制

			int num3 = 0x12AB;//十六进制

			System.out.println(num1);
			System.out.println(num2);
			System.out.println(num3);
		}
	}

练习

	将以下十进制数转换为十六进制和二进制
	123     		256    				87    			62

	7b/1111011   	100/100000000		57/1010111		3e/111110
	将以下十六进制数转换为十进制和二进制
	0x123    		 0x25F    			0x38    	0x62
	291/100100011	 607/1001011111		56/111000		98/1100010

2-4 运算符

算术运算符案例

	/**
	算术运算符的使用：
	+  -  +  -  *  /  %  (前)++  (后)++  (前)--  (后)--   +
	*/
	class AriTest {
		public static void main(String[] args) {

			// 除： /
			int num1 = 10;
			num1 = 12;
			int num2 = 5;
			int num3 = num1 / num2 * num2;
			System.out.println(num3);

			double d1 = num1 / num2;
			System.out.println(d1);//2.0
			double d2 = (double)num1 / num2;
			System.out.println(d2);//2.4
			System.out.println(num1 / num2);

			// 取余：% : 余数的符号与被模数的符号相同
			int n1 = 12;
			int m1 = 5;
			System.out.println(n1 % m1);//2

			int n2 = -12;
			int m2 = 5;
			System.out.println(n2 % m2);//-2

			int n3 = 12;
			int m3 = -5;
			System.out.println(n3 % m3);//2

			int n4 = -12;
			int m4 = -5;
			System.out.println(n4 % m4);//-2

			//(前)++ :先自增1，然后再运算
			//(后)++ :先运算，后自增1

			int a1 = 10;
			int b1 = ++a1;
			System.out.println("a1 = " + a1 + ",b1 = " + b1);//a1:11 b1:11

			int a2 = 10;
			int b2 = a2++;
			System.out.println("a2 = " + a2 + ",b2 = " + b2);//a2:11 b2:10

			//(前)-- :先自减1，然后再运算
			//(后)-- :先运算，后自减1

			int a3 = 10;
			int b3 = --a3;
			System.out.println("a3 = " + a3 + ",b3 = " + b3);//

			int a4 = 10;
			int b4 = a4--;
			System.out.println("a4 = " + a4 + ",b4 = " + b4);//

			short s1 = 10;
			//s1 = s1 - 1;//编译不通过
			//s1 = (short)(s1 - 1);//9

			//或者
			//自增1，或自减1,不会改变其数据类型。
			s1--;
			System.out.println(s1);
		}
	}

练习

	public class TestSign{
	        public static void main(String[] args){
	                int i1 = 10;int i2 = 20;
	                int i = i1++;
	                System.out.print(“i=”+i);
	                System.out.println(“i1=”+i1);
	                i = ++i1;
	                System.out.print(“i=”+i);
	                System.out.println(“i1=”+i1);
	                i = i2--;
	                System.out.print(“i=”+i);
	                System.out.println(“i2=”+i2);
	                i = --i2;
	                System.out.print(“i=”+i);
	                System.out.println(“i2=”+i2);
	         }
	}

	输出：
	i=10	i1=11
	i=12	i1=12
	i=20	i2=19
	i=18	i2=18

赋值运算符案例

	/**
	2.赋值运算符： =  +=  -=  *=  /=  %=
	*/

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

			int i = 10;
			int num1,num2;//int num1;int num2;
			num1 = num2 = 1;//连续赋值

			System.out.println("num1 = " + num1 + ",num2 = " + num2);

			// +=:
			int num = 10;
			num += 2;//与num = num + 2"相似"
			System.out.println("num = " + num);

			num *= 3;// num = num * 3
			System.out.println("num = " + num);

			//举例1：运算完以后，不会改变变量的数据类型。
			short s = 10;
			s += 3;// s = (short)(s + 3).
			System.out.println("s = " + s);

			//举例2：
			int j = 1;
			j *= 0.1;
			System.out.println(j);//0
			j++;
			System.out.println(j);//1

			//真正开发中，如果我们希望一个变量自增1.我们如何写？
			//方式一： i = i + 1;  方式二：i += 1;  方式三： i++;(推荐)

			//真正开发中，如果我们希望一个变量自增2.我们如何写？
			//方式一： i = i + 2;  方式二：i += 2; (推荐)

			//算术运算符再举例：
			int n = 10;
			int m = (n++) + (++n); //10 + 12
			System.out.println("m = " + m);//22

			//(m++)++;

		}
	}

比较运算符案例

	/**
	3.比较运算符： == !=  >  < >=  <=  instanceof

	结论：1.比较运算符的结果都是boolean类型
	2.区别 ==  与 =
	*/

	class CompareTest{
		public static void main(String[] args) {
			int i = 10;
			int j = 5;
			System.out.println(i == j);
			System.out.println(i = j);//不报错

			System.out.println(4 == 3);
			//System.out.println(4 = 3);//报错

			boolean b1 = false;
			//区分好==和=的区别。
			if(b1 = true)
				System.out.println("结果为真");
			else
				System.out.println("结果为假");

		}
	}

案例

	/**
	4.逻辑运算符：   &  &&  |  ||  !  ^

	结论：1.运算符操作的是boolean型变量，运算的结果也为boolean类型
	*/

	class LogicTest{
		public static void main(String[] args) {
			boolean b1 = true;
			boolean b2 = false;
			System.out.println("b1 && b2 ：" + (b1 && b2) );
			System.out.println("b1 & b2 ：" + (b1 & b2) );
			System.out.println("b1 | b2 ：" + (b1 | b2) );
			System.out.println("b1 || b2 ：" + (b1 || b2) );
			System.out.println("b1 ^ b2 ：" + (b1 ^ b2) );
			System.out.println("!b1  ：" + !b1 );

			//&  与 && : 两个符号判断以后的结果是相同的。
			//相同点：如果符号左边的值为true,两个运算符都要执行符号右边的运算。
			//不同点：如果符号左边的值为false,&:仍然要执行符号右边的运算。&&：不在执行符号右边的运算
			//开发中：习惯于使用：&&

			boolean isFlag1 = false;
			int num1 = 10;
			if(isFlag1 & (num1++ > 0)){
				System.out.println("小明很帅");
			}else{
				System.out.println("德玛很美");
			}

			System.out.println("num1 = " + num1);

			boolean isFlag2 = false;
			int num2 = 10;
			if(isFlag2 && (num2++ > 0)){
				System.out.println("小明很帅");
			}else{
				System.out.println("德玛很美");
			}

			System.out.println("num2 = " + num2);

			// |  与 ||：两个符号判断以后的结果是相同的。
			//相同点：如果符号左边的值为false,两个运算符都要执行符号右边的运算。
			//不同点：如果符号左边的值为true,&:仍然要执行符号右边的运算。&&：不在执行符号右边的运算
			//开发中：习惯于使用：||
			boolean isFlag3 = true;
			int num3 = 10;
			if(isFlag3 | (num3++ > 0)){
				System.out.println("李栋很帅");
			}else{
				System.out.println("李栋很美");
			}

			System.out.println("num3 = " + num3);

			boolean isFlag4 = true;
			int num4 = 10;
			if(isFlag4 || (num4++ > 0)){
				System.out.println("李栋很帅");
			}else{
				System.out.println("李栋很美");
			}

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

练习

1题
int x = 1;
int y=1;

if(x++==2 & ++y==2){
	x =7;
}
System.out.println("x="+x+",y="+y);
						2		2

2题
int x = 1,y = 1;

if(x++==2 && ++y==2){
	x =7;
}
System.out.println("x="+x+",y="+y);
						2		1

3题
int x = 1,y = 1;

if(x++==1 | ++y==1){
	x =7;
}
System.out.println("x="+x+",y="+y);
						7		2

4题
int x = 1,y = 1;

if(x++==1 || ++y==1){
	x =7;
}
System.out.println("x="+x+",y="+y);
						7		1

5题
1．  class  Test4  {
2.        public static void main (String []  args)  {
3．           boolean x=true;
4．           boolean y=false;
5．           short z=42;
6．	    //if(y = true)
7.              if((z++==42)&&(y=true))z++;
8.              if((x=false) || (++z==45))  z++;
9．
10.            System. out.println(“z=”+z);
11.            }
12.   }
结果为：z= 46

案例

	/**
	5.位元素符： <<   >> >>>  &  | ^  ~

	结论：1.操作的都是数值型变量
	2.  << : 在一定范围内，每左移一位，相当于数值 * 2 ：过犹不及
	>> : 在一定范围内，每右移一位，相当于数值 / 2
	>>>:右移以后，最高位拿0补。
	*/

	class BitTest {
		public static void main(String[] args) {
			System.out.println("15 << 2 : " + (15 << 2));
			System.out.println("-15 << 2 : " + (-15 << 2));
			System.out.println("15 << 28 : " + (15 << 28));

			System.out.println("15 >> 2 : " + (15 >> 2));
			System.out.println("-15 >> 2 : " + (-15 >> 2));
			System.out.println("-15 >> 2 : " + (-15 >>> 2));

			//练习1：
			int m = 10;
			int n = 5;

			System.out.println("m = " + m + ",n = " + n);

			//交换m和n的数值
			//方式一：更通用。
			//int temp = m;
			//       m = n;
			//       n = temp;

			//方式二：好处：不需要额外定义临时变量。 缺点：①有可能运算时溢出。②适用数据类型有限制
			//m = m + n;// 15 = 10 + 5
			//n = m - n;// n = 15 - 5;
			//m = m - n;// m = 15 - 10;

			//方式三：好处：相较于方式二，不会溢出。 缺点：适用数据类型有限制
			m = m ^ n;  //(m ^ n) ^ n => m
			n = m ^ n;
			m = m ^ n;

			System.out.println("m = " + m + ",n = " + n);

			//练习2：手动实现60的二进制到十六进制的转换。
			int num = 60;

			String binary = Integer.toBinaryString(num);
			System.out.println(binary);
			String hex = Integer.toHexString(num);
			System.out.println(hex);

			System.out.println();

			int temp1 = num & 15;
			String s1 = (temp1 >= 10)? (char)(temp1 - 10 + 'a') + "" : temp1 + "";
			//System.out.println(s1);

			num = num >> 4;
			int temp2 = num & 15;
			String s2 = (temp2 >= 10)? (char)(temp2 - 10 + 'a') + "" : temp2 + "";

			//....

			System.out.println(s2 + s1);

			/*
			String s = "abc";
			s += "cde";//s = s + "cde";
			System.out.println(s);

			//abcdefg  ---> abfedcg
			*/
		}
	}

案例

	/*
	6.三元运算符：   (条件表达式)? 表达式1 : 表达式2;

	说明：1.条件表达式的结果为boolean.
		  2.根据boolean类型的值，决定执行表达式1 (true) 还是表达式2 (false).
		  3.表达式1 与 表达式2 要保持一致！
		  4.三元运算符可以相互嵌套

		  5.三元运算符一定可以转换为使用if-else实现。反之，不成立。
			如果既可以使用三元运算符，又可以使用if-else,建议使用三元运算符。因为：简单，执行效率高。

	*/
	class SanYuanFu {
		public static void main(String[] args) {

			//获取两个整数的较大值
			int m = 10,n = 10;
			int max = (m > n)? m : n;
			System.out.println("较大值为：" + max);

			//三元运算符可以相互嵌套
			String s = (m > n)? "m大" : (m == n)? "m和n相等" : "n大";
			System.out.println(s);

			//表达式1 与 表达式2 要保持一致！不一定要相同
			double temp = (m > n)? 4 : 1.2;
			System.out.println(temp);

			//获取三个整数的最大值
			int num1 = 23,num2 = 44,num3 = 2;
			//int max1 = (num1 > num2)? num1 : num2;
			//int max2 = (max1 > num3)? max1 : num3;
			//方式二：
			int max2 = (((num1 > num2)? num1 : num2) > num3)? ((num1 > num2)? num1 : num2) : num3;
			System.out.println(max2);

			//使用if-else获取两个整数的较大值
			int n1 = 10,n2 = 4;
			if(n1 > n2){
				System.out.println(n1);
			}else{
				System.out.println(n2);
			}

		}
	}