2-1 关键字与保留字

  • 关键字(keyword)



  • 保留字(reserved word)

2-2 标识符(Identifier)





案例

  1. 	class Test{
  2. 		public static void main(String[] args) {
  3. 			System.out.println("Hello World!");
  4. 		}
  5. 	}
  7. 	class _9Hello{
  8. 	}
  10. 	class Public{
  11. 	}
  13. 	class publicstatic{
  14. 	}
  16. 	class PublicStatic{
  18. 	}
  20. 	class XinXi{
  21. 		String xingMing;
  22. 	}

2-3 变量









案例

  1. 	/**
  2. 	变量的声明和使用
  3. 	1.定义：在一定范围内取值不断变化的量。
  4. 	2.格式：数据类型 变量名 = 初始化值
  5. 	3.注意点：
  6. 	①先声明，后使用
  7. 	②变量的作用域即为其声明所在的{}内。
  8. 	*/
  9. 	  public class VariableTest {
  10. 	      public static void main(String[] args) {
  11. 	          int number1;
  12. 	          number1 = 10;
  14. 	          int number2;
  15. 	          number2 = 20;
  17. 	          int number3;
  18. 	        number3 = number1 + number2;
  19. 	        System.out.println("Number3 = " + number3);
  21. 	        int number4 = 50;
  22. 	        int number5 = number4 - number3;
  23. 	        System.out.println("Number5 = " + number5);
  24. 	     }
  25. 	 }







数据类型案例

  1. 	/**
  2. 	1.角度一：按照数据类型来分
  3. 	①基本数据类型：整型：byte / short / int / long
  4. 	浮点型：float / double
  5. 	字符型：char
  6. 	布尔型：boolean
  7. 	②引用数据类型：类 / 接口 / 数组
  8. 	注意：String 属于引用数据类型
  10. 	2.(了解)角度二：按照在类中声明的位置的不同来分：成员变量   vs  局部变量
  11. 	 */
  13. 	class VariableTest1{
  14. 		public static void main(String[] args) {
  15. 			//1.整型：byte (1字节:-128~127) / short (2字节) / int (4字节) / long(8字节)
  16. 			//通常，我们将一个整型变量定义为int。
  17. 			//如果定义log型变量，必须后缀为：l或L
  18. 			byte b1 = 3;
  20. 			//b1 = 128;
  22. 			int i1 = 23152;
  23. 			//i1 = 234254363575325243635;
  25. 			long l1 = 1243252323545L;
  27. 			System.out.println(b1);
  28. 			System.out.println(i1);
  30. 			//2.浮点型：float (4字节)/ double (8字节)
  31. 			//①从存储数据的表数范围上讲：float的范围比long要大。
  32. 			//②如果定义float型变量，必须后缀为:f或F
  33. 			//③通常，我们将一个浮点型变量定义为double.
  34. 			double d1 = 12.3;
  35. 			float f1 = 12.3f;
  36. 			f1 = 12.5F;
  37. 			System.out.println(f1);//12.5
  39. 			//3.字符型：char (2字节)
  40. 			//①通常情况下，声明一个字符，使用一对''
  41. 			//②char的不同表示方式：1.声明一个字符 2.声明转义字符 3.使用Unicode码（了解）
  42. 			char c1 = 'a';
  43. 			char c2 = '中';
  44. 			char c3 = 'ネ';
  45. 			char c4 = '4';
  47. 			//char c5 = 43;//编译可以通过的
  49. 			char c6 = '\n';
  50. 			char c7 = '\t';
  52. 			System.out.println("Hello" + c7 + "world");
  54. 			char c8 = '\u0023';
  56. 			//4.布尔型：boolean
  57. 			//只能保存true 或 false. 不能取值为null.
  58. 			//常常在条件判断、循环中，使用boolean型变量
  60. 			boolean isMarried = true;
  62. 			if(isMarried){
  63. 				System.out.println("你不能参加单身party了！");
  64. 			}else{
  65. 				System.out.println("可以多谈谈女朋友");
  66. 			}
  68. 		}
  69. 	}





基本数据类型转换案例

  1. 	/**
  2. 	基本数据类型变量间的运算规则
  4. 	适用范围：除了boolean之外，其他7种基本数据类型都适用
  6. 	1.自动类型提升：容量小的数据类型和容量大的数据类型的变量做运算，运算的结果为容量大的数据类型。
  7. 	byte 、short 、char --> int --> long -->  float --> double
  8. 	特别地，byte、short、char三者之间做运算，结果为int型。
  10. 	2.强制类型转换：自动类型提升的逆过程。见<VariableTest3.java>
  12. 	说明：此时的容量的大小指的是存储数据范围的大小，而非内存存储空间的大小。
  13. 	*/
  15. 	class VariableTest2{
  16. 		public static void main(String[] args) {
  18. 			int num1 = 10;
  19. 			short s1 = 10;
  20. 			int num2 = num1 + s1;
  22. 			boolean b1 = true;
  23. 			//b1 + num1;
  25. 			long l1 = 123L;
  26. 			float f1 = 12.2f;
  27. 			float f2 = l1 + f1;
  29. 			//long l2 = l1 + f1;//编译不通过
  31. 			System.out.println(f2);
  33. 			double d1 = num1 + s1;
  34. 			System.out.println(d1);//20.0
  36. 			//********************************
  37. 			//字符char的运算
  38. 			char c1 = 'A';
  39. 			int num3 = 0;
  40. 			int num4 = c1 + num3;
  41. 			System.out.println(num4);//65
  43. 			//********************************
  44. 			//特别的情况：
  45. 			byte by1 = 10;
  46. 			short ss1 = 10;
  47. 			//short ss2 = by1 + ss1;//编译不通过
  48. 			int i1 = by1 + ss1;
  50. 			short ss2 = 10;
  51. 			//short ss3 = ss1 + ss2;//编译不通过
  53. 			byte by2 = 10;
  54. 			//byte by3 = by1 + by2;//编译不通过
  56. 			char c2 = 'a';
  58. 			//short ss4 = by1 + c2;//编译不通过
  60. 			//********************************
  61. 			//整型的常量，默认为int型。
  62. 			int n1 = 10;
  63. 			int n2 = n1 + 2;
  65. 			//浮点型的常量，默认为double型
  66. 			//float ff = n1 + 12.3;//编译不通过
  68. 			//**********************************
  69. 			long ll1 = 1234;//可以理解为自动类型提升
  70. 			System.out.println(ll1);
  72. 			long ll2 = 1234235234233L;
  73. 			System.out.println(ll2);
  75. 			//float ff1 = 12.3;//12.3默认为double,此时编译不通过
  77. 		}
  78. 	}

强制类型转换案例

  1. 	/**
  2. 	强制类型转换：
  3. 	1.自动类型提升的逆过程。
  4. 	2.容量大的数据类型的变量如果想转换为容量小的数据类型的变量,就需要使用强制类型符进行转换。
  5. 	3.强制类型转换符：()
  7. 	注意点：强转过程中，有可能出现精度损失的情况。
  8. 	*/
  10. 	class VariableTest3 {
  11. 		public static void main(String[] args) {
  13. 			int num1 = 12;
  14. 			short s1 = (short)num1;
  16. 			System.out.println(s1);
  18. 			//强转过程中，有可能出现精度损失的情况。
  19. 			//举例一：
  20. 			double d1 = 12.6;
  21. 			int num2 = (int)d1;
  22. 			System.out.println(num2);
  24. 			//举例二：
  25. 			int num3 = 128;
  26. 			byte b1 = (byte)num3;
  27. 			System.out.println(b1);//-128
  29. 		}
  30. 	}

String案例

  1. 	/**
  2. 	String类与基本数据类型(8种)变量之间的运算
  4. 	1.String类属于引用数据类型的变量
  5. 	2.String类型的变量值使用一对""括起来表示。
  6. 	3.String类与基本数据类型(8种)变量之间只能做连接运算：+
  7. 	4.String类与基本数据类型(8种)变量做运算的结果为:String类型
  8. 	*/
  9. 	class StringTest {
  10. 		public static void main(String[] args) {
  12. 			String s1 = "Hello World!";
  14. 			System.out.println(s1);
  15. 			System.out.println("s1");
  16. 			//System.out.println(s2);//编译不通过
  18. 			int num1 = 10;
  19. 			String s3 = s1 + num1;
  20. 			s3 = s3 + true;
  21. 			System.out.println(s3);
  23. 			//练习1：
  24. 			int n = 1;
  25. 			char c = 'a';
  26. 			String str = "beijing";
  28. 			System.out.println(n + c + str);//98beijing
  29. 			System.out.println(n + (c + str));//1abeijing
  30. 			System.out.println(str + n + c);//beijing1a
  32. 			//练习2：
  33. 			//*	*
  34. 			System.out.println("*	*");
  35. 			System.out.println("*" + "\t" + "*");
  36. 			System.out.println('*' + "\t" + "*");
  37. 			System.out.println('*' + '\t' + "*");//51*
  38. 			System.out.println('*' + '\t' + '*');//93
  40. 			char c1 = 'a';
  41. 			char c2 = 97;
  42. 			System.out.println(c2);
  44. 			//************************
  45. 			int i = 10;
  46. 			//String str1 = i;//编译不通过
  47. 			String str2 = i + "";
  49. 			System.out.println(str2);//"10"
  51. 			//int j = str2;//编译不通过
  53. 			//int j = (int)str2;//编译不通过
  55. 			//了解：使用包装类才能使得String---->int
  56. 			int j = Integer.parseInt(str2);
  57. 			System.out.println(j);
  59. 		}
  60. 	}

练习1

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

练习2

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







进制案例

  1. 	/*
  2. 	对于整数，有四种表示方式：
  3. 	二进制：0,1 ，满2进1.以0b或0B开头。
  4. 	十进制：0-9 ，满10进1.
  5. 	八进制：0-7 ，满8进1. 以数字0开头表示。
  6. 	十六进制：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。
  7. 		如：0x21AF +1= 0X21B0
  9. 	*/
  10. 	class  BinarySystemTest{
  11. 		public static void main(String[] args) {
  12. 			int num1 = 0b1010;//二进制
  14. 			int num2 = 0754;//八进制
  16. 			int num3 = 0x12AB;//十六进制
  18. 			System.out.println(num1);
  19. 			System.out.println(num2);
  20. 			System.out.println(num3);
  21. 		}
  22. 	}















练习

  1. 	将以下十进制数转换为十六进制和二进制
  2. 	123     		256    				87    			62
  4. 	7b/1111011   	100/100000000		57/1010111		3e/111110
  5. 	将以下十六进制数转换为十进制和二进制
  6. 	0x123    		 0x25F    			0x38    	0x62
  7. 	291/100100011	 607/1001011111		56/111000		98/1100010

2-4 运算符





算术运算符案例

  1. 	/**
  2. 	算术运算符的使用：
  3. 	+  -  +  -  *  /  %  (前)++  (后)++  (前)--  (后)--   +
  4. 	*/
  5. 	class AriTest {
  6. 		public static void main(String[] args) {
  8. 			// 除： /
  9. 			int num1 = 10;
  10. 			num1 = 12;
  11. 			int num2 = 5;
  12. 			int num3 = num1 / num2 * num2;
  13. 			System.out.println(num3);
  15. 			double d1 = num1 / num2;
  16. 			System.out.println(d1);//2.0
  17. 			double d2 = (double)num1 / num2;
  18. 			System.out.println(d2);//2.4
  19. 			System.out.println(num1 / num2);
  21. 			// 取余：% : 余数的符号与被模数的符号相同
  22. 			int n1 = 12;
  23. 			int m1 = 5;
  24. 			System.out.println(n1 % m1);//2
  26. 			int n2 = -12;
  27. 			int m2 = 5;
  28. 			System.out.println(n2 % m2);//-2
  30. 			int n3 = 12;
  31. 			int m3 = -5;
  32. 			System.out.println(n3 % m3);//2
  34. 			int n4 = -12;
  35. 			int m4 = -5;
  36. 			System.out.println(n4 % m4);//-2
  38. 			//(前)++ :先自增1，然后再运算
  39. 			//(后)++ :先运算，后自增1
  41. 			int a1 = 10;
  42. 			int b1 = ++a1;
  43. 			System.out.println("a1 = " + a1 + ",b1 = " + b1);//a1:11 b1:11
  45. 			int a2 = 10;
  46. 			int b2 = a2++;
  47. 			System.out.println("a2 = " + a2 + ",b2 = " + b2);//a2:11 b2:10
  49. 			//(前)-- :先自减1，然后再运算
  50. 			//(后)-- :先运算，后自减1
  52. 			int a3 = 10;
  53. 			int b3 = --a3;
  54. 			System.out.println("a3 = " + a3 + ",b3 = " + b3);//
  56. 			int a4 = 10;
  57. 			int b4 = a4--;
  58. 			System.out.println("a4 = " + a4 + ",b4 = " + b4);//
  60. 			short s1 = 10;
  61. 			//s1 = s1 - 1;//编译不通过
  62. 			//s1 = (short)(s1 - 1);//9
  64. 			//或者
  65. 			//自增1，或自减1,不会改变其数据类型。
  66. 			s1--;
  67. 			System.out.println(s1);
  68. 		}
  69. 	}

练习

  1. 	public class TestSign{
  2. 	        public static void main(String[] args){
  3. 	                int i1 = 10;int i2 = 20;
  4. 	                int i = i1++;
  5. 	                System.out.print(“i=”+i);
  6. 	                System.out.println(“i1=”+i1);
  7. 	                i = ++i1;
  8. 	                System.out.print(“i=”+i);
  9. 	                System.out.println(“i1=”+i1);
  10. 	                i = i2--;
  11. 	                System.out.print(“i=”+i);
  12. 	                System.out.println(“i2=”+i2);
  13. 	                i = --i2;
  14. 	                System.out.print(“i=”+i);
  15. 	                System.out.println(“i2=”+i2);
  16. 	         }
  17. 	}
  19. 	输出：
  20. 	i=10	i1=11
  21. 	i=12	i1=12
  22. 	i=20	i2=19
  23. 	i=18	i2=18





赋值运算符案例

  1. 	/**
  2. 	2.赋值运算符： =  +=  -=  *=  /=  %=
  3. 	*/
  5. 	class SetValueTest {
  6. 		public static void main(String[] args) {
  8. 			int i = 10;
  9. 			int num1,num2;//int num1;int num2;
  10. 			num1 = num2 = 1;//连续赋值
  12. 			System.out.println("num1 = " + num1 + ",num2 = " + num2);
  14. 			// +=:
  15. 			int num = 10;
  16. 			num += 2;//与num = num + 2"相似"
  17. 			System.out.println("num = " + num);
  19. 			num *= 3;// num = num * 3
  20. 			System.out.println("num = " + num);
  22. 			//举例1：运算完以后，不会改变变量的数据类型。
  23. 			short s = 10;
  24. 			s += 3;// s = (short)(s + 3).
  25. 			System.out.println("s = " + s);
  27. 			//举例2：
  28. 			int j = 1;
  29. 			j *= 0.1;
  30. 			System.out.println(j);//0
  31. 			j++;
  32. 			System.out.println(j);//1
  34. 			//真正开发中，如果我们希望一个变量自增1.我们如何写？
  35. 			//方式一： i = i + 1;  方式二：i += 1;  方式三： i++;(推荐)
  37. 			//真正开发中，如果我们希望一个变量自增2.我们如何写？
  38. 			//方式一： i = i + 2;  方式二：i += 2; (推荐)
  40. 			//算术运算符再举例：
  41. 			int n = 10;
  42. 			int m = (n++) + (++n); //10 + 12
  43. 			System.out.println("m = " + m);//22
  45. 			//(m++)++;
  47. 		}
  48. 	}



比较运算符案例

  1. 	/**
  2. 	3.比较运算符： == !=  >  < >=  <=  instanceof
  4. 	结论：1.比较运算符的结果都是boolean类型
  5. 	2.区别 ==  与 =
  6. 	*/
  8. 	class CompareTest{
  9. 		public static void main(String[] args) {
  10. 			int i = 10;
  11. 			int j = 5;
  12. 			System.out.println(i == j);
  13. 			System.out.println(i = j);//不报错
  15. 			System.out.println(4 == 3);
  16. 			//System.out.println(4 = 3);//报错
  18. 			boolean b1 = false;
  19. 			//区分好==和=的区别。
  20. 			if(b1 = true)
  21. 				System.out.println("结果为真");
  22. 			else
  23. 				System.out.println("结果为假");
  25. 		}
  26. 	}



案例

  1. 	/**
  2. 	4.逻辑运算符：   &  &&  |  ||  !  ^
  4. 	结论：1.运算符操作的是boolean型变量，运算的结果也为boolean类型
  5. 	*/
  7. 	class LogicTest{
  8. 		public static void main(String[] args) {
  9. 			boolean b1 = true;
  10. 			boolean b2 = false;
  11. 			System.out.println("b1 && b2 ：" + (b1 && b2) );
  12. 			System.out.println("b1 & b2 ：" + (b1 & b2) );
  13. 			System.out.println("b1 | b2 ：" + (b1 | b2) );
  14. 			System.out.println("b1 || b2 ：" + (b1 || b2) );
  15. 			System.out.println("b1 ^ b2 ：" + (b1 ^ b2) );
  16. 			System.out.println("!b1  ：" + !b1 );
  18. 			//&  与 && : 两个符号判断以后的结果是相同的。
  19. 			//相同点：如果符号左边的值为true,两个运算符都要执行符号右边的运算。
  20. 			//不同点：如果符号左边的值为false,&:仍然要执行符号右边的运算。&&：不在执行符号右边的运算
  21. 			//开发中：习惯于使用：&&
  23. 			boolean isFlag1 = false;
  24. 			int num1 = 10;
  25. 			if(isFlag1 & (num1++ > 0)){
  26. 				System.out.println("小明很帅");
  27. 			}else{
  28. 				System.out.println("德玛很美");
  29. 			}
  31. 			System.out.println("num1 = " + num1);
  33. 			boolean isFlag2 = false;
  34. 			int num2 = 10;
  35. 			if(isFlag2 && (num2++ > 0)){
  36. 				System.out.println("小明很帅");
  37. 			}else{
  38. 				System.out.println("德玛很美");
  39. 			}
  41. 			System.out.println("num2 = " + num2);
  43. 			// |  与 ||：两个符号判断以后的结果是相同的。
  44. 			//相同点：如果符号左边的值为false,两个运算符都要执行符号右边的运算。
  45. 			//不同点：如果符号左边的值为true,&:仍然要执行符号右边的运算。&&：不在执行符号右边的运算
  46. 			//开发中：习惯于使用：||
  47. 			boolean isFlag3 = true;
  48. 			int num3 = 10;
  49. 			if(isFlag3 | (num3++ > 0)){
  50. 				System.out.println("李栋很帅");
  51. 			}else{
  52. 				System.out.println("李栋很美");
  53. 			}
  55. 			System.out.println("num3 = " + num3);
  57. 			boolean isFlag4 = true;
  58. 			int num4 = 10;
  59. 			if(isFlag4 || (num4++ > 0)){
  60. 				System.out.println("李栋很帅");
  61. 			}else{
  62. 				System.out.println("李栋很美");
  63. 			}
  65. 			System.out.println("num4 = " + num4);
  66. 		}
  67. 	}

练习

  1. 1题
  2. int x = 1;
  3. int y=1;
  5. if(x++==2 & ++y==2){
  6. 	x =7;
  7. }
  8. System.out.println("x="+x+",y="+y);
  9. 						2		2
  11. 2题
  12. int x = 1,y = 1;
  14. if(x++==2 && ++y==2){
  15. 	x =7;
  16. }
  17. System.out.println("x="+x+",y="+y);
  18. 						2		1
  20. 3题
  21. int x = 1,y = 1;
  23. if(x++==1 | ++y==1){
  24. 	x =7;
  25. }
  26. System.out.println("x="+x+",y="+y);
  27. 						7		2
  29. 4题
  30. int x = 1,y = 1;
  32. if(x++==1 || ++y==1){
  33. 	x =7;
  34. }
  35. System.out.println("x="+x+",y="+y);
  36. 						7		1
  38. 5题
  39. 1．  class  Test4  {
  40. 2.        public static void main (String []  args)  {
  41. 3．           boolean x=true;
  42. 4．           boolean y=false;
  43. 5．           short z=42;
  44. 6．	    //if(y = true)
  45. 7.              if((z++==42)&&(y=true))z++;
  46. 8.              if((x=false) || (++z==45))  z++;
  47. 9．
  48. 10.            System. out.println(“z=”+z);
  49. 11.            }
  50. 12.   }
  51. 结果为：z= 46





案例

  1. 	/**
  2. 	5.位元素符： <<   >> >>>  &  | ^  ~
  4. 	结论：1.操作的都是数值型变量
  5. 	2.  << : 在一定范围内，每左移一位，相当于数值 * 2 ：过犹不及
  6. 	>> : 在一定范围内，每右移一位，相当于数值 / 2
  7. 	>>>:右移以后，最高位拿0补。
  8. 	*/
  10. 	class BitTest {
  11. 		public static void main(String[] args) {
  12. 			System.out.println("15 << 2 : " + (15 << 2));
  13. 			System.out.println("-15 << 2 : " + (-15 << 2));
  14. 			System.out.println("15 << 28 : " + (15 << 28));
  16. 			System.out.println("15 >> 2 : " + (15 >> 2));
  17. 			System.out.println("-15 >> 2 : " + (-15 >> 2));
  18. 			System.out.println("-15 >> 2 : " + (-15 >>> 2));
  20. 			//练习1：
  21. 			int m = 10;
  22. 			int n = 5;
  24. 			System.out.println("m = " + m + ",n = " + n);
  26. 			//交换m和n的数值
  27. 			//方式一：更通用。
  28. 			//int temp = m;
  29. 			//       m = n;
  30. 			//       n = temp;
  32. 			//方式二：好处：不需要额外定义临时变量。 缺点：①有可能运算时溢出。②适用数据类型有限制
  33. 			//m = m + n;// 15 = 10 + 5
  34. 			//n = m - n;// n = 15 - 5;
  35. 			//m = m - n;// m = 15 - 10;
  37. 			//方式三：好处：相较于方式二，不会溢出。 缺点：适用数据类型有限制
  38. 			m = m ^ n;  //(m ^ n) ^ n => m
  39. 			n = m ^ n;
  40. 			m = m ^ n;
  42. 			System.out.println("m = " + m + ",n = " + n);
  44. 			//练习2：手动实现60的二进制到十六进制的转换。
  45. 			int num = 60;
  47. 			String binary = Integer.toBinaryString(num);
  48. 			System.out.println(binary);
  49. 			String hex = Integer.toHexString(num);
  50. 			System.out.println(hex);
  52. 			System.out.println();
  54. 			int temp1 = num & 15;
  55. 			String s1 = (temp1 >= 10)? (char)(temp1 - 10 + 'a') + "" : temp1 + "";
  56. 			//System.out.println(s1);
  58. 			num = num >> 4;
  59. 			int temp2 = num & 15;
  60. 			String s2 = (temp2 >= 10)? (char)(temp2 - 10 + 'a') + "" : temp2 + "";
  62. 			//....
  64. 			System.out.println(s2 + s1);
  66. 			/*
  67. 			String s = "abc";
  68. 			s += "cde";//s = s + "cde";
  69. 			System.out.println(s);
  71. 			//abcdefg  ---> abfedcg
  72. 			*/
  73. 		}
  74. 	}

案例

  1. 	/*
  2. 	6.三元运算符：   (条件表达式)? 表达式1 : 表达式2;
  4. 	说明：1.条件表达式的结果为boolean.
  5. 		  2.根据boolean类型的值，决定执行表达式1 (true) 还是表达式2 (false).
  6. 		  3.表达式1 与 表达式2 要保持一致！
  7. 		  4.三元运算符可以相互嵌套
  9. 		  5.三元运算符一定可以转换为使用if-else实现。反之，不成立。
  10. 			如果既可以使用三元运算符，又可以使用if-else,建议使用三元运算符。因为：简单，执行效率高。
  12. 	*/
  13. 	class SanYuanFu {
  14. 		public static void main(String[] args) {
  16. 			//获取两个整数的较大值
  17. 			int m = 10,n = 10;
  18. 			int max = (m > n)? m : n;
  19. 			System.out.println("较大值为：" + max);
  21. 			//三元运算符可以相互嵌套
  22. 			String s = (m > n)? "m大" : (m == n)? "m和n相等" : "n大";
  23. 			System.out.println(s);
  25. 			//表达式1 与 表达式2 要保持一致！不一定要相同
  26. 			double temp = (m > n)? 4 : 1.2;
  27. 			System.out.println(temp);
  29. 			//获取三个整数的最大值
  30. 			int num1 = 23,num2 = 44,num3 = 2;
  31. 			//int max1 = (num1 > num2)? num1 : num2;
  32. 			//int max2 = (max1 > num3)? max1 : num3;
  33. 			//方式二：
  34. 			int max2 = (((num1 > num2)? num1 : num2) > num3)? ((num1 > num2)? num1 : num2) : num3;
  35. 			System.out.println(max2);
  37. 			//使用if-else获取两个整数的较大值
  38. 			int n1 = 10,n2 = 4;
  39. 			if(n1 > n2){
  40. 				System.out.println(n1);
  41. 			}else{
  42. 				System.out.println(n2);
  43. 			}
  45. 		}
  46. 	}

第2章 Java基本语法(上): 变量与运算符的更多相关文章

  1. Java基础语法01——变量与运算符

    本文是对Java基础语法的第一部分的学习,包括注释:标识符的命名规则与规范:变量的数据类型分类以及转换:以及六种运算符(算术.赋值.比较.逻辑.三元和位运算符).

  2. java面向对象编程——第二章 java基础语法

    第二章 java基础语法 1. java关键字 abstract boolean break byte case catch char class const continue default do ...

  3. 第一章 –– Java基础语法

    第一章 –– Java基础语法 span::selection, .CodeMirror-line > span > span::selection { background: #d7d4 ...

  4. JAVA学习（三）：Java基础语法（变量、常量、数据类型、运算符与数据类型转换）

    Java基础语法(变量.常量.数据类型.运算符与数据类型转换) 1.变量 Java中.用户能够通过指定数据类型和标识符来声明变量.其基本的语法为: DataType identifier; 或 Dat ...

  5. Java基础语法(2)-变量

    title: Java基础语法(2)-变量 blog: CSDN data: Java学习路线及视频 1.什么是变量? 变量的概念 内存中的一个存储区域 该区域的数据可以在同一类型范围内不断变化 变量 ...

  6. (第三章)Java内存模型(上)

    一.java内存模型的基础 1.1 并发编程模型的两个关键问题 在并发编程中,需要处理两个关键问题:线程之间如何通信及线程之间如何同步(这里的线程是指并发执行的活动实体).通信是指线程之间以何种机制来 ...

  7. 第二章 Java 基本语法1

    2.1关键字 1.定义:被Java语言赋予了特殊含义,用做专门用途的字符串(单词). 2.特点:关键字中所有字母都是小写字母. 3.分类: 用于定义数据类型的关键字:byte.short.int.lo ...

  8. 第2章 Java基本语法(下): 流程控制--项目（记账本）

    2-5 程序流程控制 2-5-1 顺序结构 2-5-2 分支语句1:if-else结构 案例 class IfTest1{ public static void main(String[] args) ...

  9. Java基本语法和变量

    1基本语法 1.1 标识符.关键字 在程序中用于定义名称的都为标识符,如文件名称.类名称.方法名称或变量名称等. 在Java中标识符的定义格式由字母.数字._(下划线),$所组成,不能以数字开头, 不 ...

随机推荐

  1. Cordova结合Vue学习Camera

    简单聊两句 学习Vue+Cordova打包编译App,首先你要安装Cordova与vue,在这里本人就不说明了,自行看文档与搜索相关资料. Cordova中文官网地址 Vue中文官网地址 第一步:首先 ...

  2. shiro框架

    Shiro Shiro简介 SpringMVC整合Shiro,Shiro是一个强大易用的Java安全框架,提供了认证.授权.加密和会话管理等功能. Authentication:身份认证/登录,验证用 ...

  3. 《SQL 基础教程》第四章:数据更新

    数据更新包括了表存在的情况下数据的添加,数据的删除和数据的更新,主要是下面三个语句: INSERT 语句 DELETE 语句 UPDATE 语句 在本章的最后,讲了关于「事务」的相关知识,用于对作出的 ...

  4. linux iso 下载地址

    Centos 5.3  下载地址: http://www.karan.org/mock/5.3/CentOS-5.3-i386-bin-1to6.torrent http://www.karan.or ...

  5. java8中的时间处理

    java8中关于时间的处理整理 package com.xb.utils; import java.time.*; import java.time.format.DateTimeFormatter; ...

  6. java对redis的基本操作,ZZ

    java对redis的基本操作 http://www.cnblogs.com/edisonfeng/p/3571870.html

  7. 普元eos、soa、esb

    http://www.primeton.com/support/video.php http://www.primeton.com/products/bps/overview.php http://w ...

  8. Set集合中的treeSet问题：cannot be cast to java.lang.Comparable；

    使用TreeSet保存自定义对象时, 必须让定义对象的类实现Comparable接口,并重写compareTo()方法 否则报 实体类User:cannot be cast to java.lang. ...

  9. windows service 2008 R2 安装net4.6环境失败，windows service 2008 R2 升级sp1问题

    一.错误 1.因为我的程序是以vs2017开发的,在windows service 2008 R2  IIS部署项目文件报出错误,因此要安装net4.6的环境. 2.windows service 2 ...

  10. python 实现杨辉三角（依旧遗留问题）

    1 #! usr/bin/env python3 #-*- coding :utf-8 -*- print('杨辉三角的generator') def triangles(): N=[1] while ...