`
lysvanilla
  • 浏览: 80500 次
  • 性别: Icon_minigender_1
  • 来自: 湖南
社区版块
存档分类
最新评论

Java SE 学习笔记01 代码

java 
阅读更多

 Java中的基本数据类型

 

Java代码 复制代码 收藏代码
  1. /**
  2. * Java基本数据类型
  3. */
  4. package org.sean.module01;
  5. /**
  6. * @author 不落的太阳(Sean Yang)
  7. */
  8. public class BasicType {
  9. /**
  10. * 基本类型的自动提升
  11. *
  12. * 自动提升的规则如下:
  13. *
  14. * 如果两个操作数中有一个是double类型，则系统先将另一个操作数转换为double类型，然后运算，否则
  15. * 如果两个操作数中有一个是float类型，则系统先将另一个操作数转换为float类型，然后运算，否则
  16. * 如果两个操作数中有一个是long类型，则系统先将另一个操作数转换为long类型，然后运算，否则
  17. * 所有的操作数都被转换为int类型进行运算(低于int类型的会自动提升)
  18. *
  19. * 如果采用"+=","*="等缩略形式的运算符，则系统会强制将运算结果转换为目标变量类型。
  20. *
  21. */
  22. public static void typeAutoUppgrade() {
  23. char c = 'a';
  24. byte b = 44;
  25. short s = 1023;
  26. int i = 40000;
  27. long l = 1234L;
  28. float f = 35.6F;
  29. double d = 3.13D;
  30. double result = (b * f) + (f * l) + (i / c) - (d * s);
  31. System.out.println("自动类型提升的测试结果为" + result);
  32. @SuppressWarnings("unused")
  33. boolean flag = false;
  34. }
  35. /**
  36. * 基本类型的自动转换
  37. *
  38. * 自动类型转换的规则:
  39. *
  40. * 两种类型是兼容类型；目标类型的范围要比源类型的范围大
  41. */
  42. public static void autoChange() {
  43. char c = 'c';
  44. byte b = 44;
  45. short s = b;
  46. int i1 = s;
  47. int i2 = c;
  48. long l = i1;
  49. float f = l;
  50. double d = f;
  51. System.out.print("c=" + c + "\t");
  52. System.out.print("b=" + b + "\t");
  53. System.out.print("s=" + s + "\t");
  54. System.out.print("i1=" + i1 + "\t");
  55. System.out.print("i2=" + i2 + "\t");
  56. System.out.print("l=" + l + "\t");
  57. System.out.print("f=" + f + "\t");
  58. System.out.print("d=" + d + "\t");
  59. System.out.println();
  60. /**
  61. * 当float转换为double时，会出现不相等的情况
  62. *
  63. * 原因：float是32位的，double是64位的，在进行类型转换的时候，操作数都是以二进制的形式进行的，
  64. * 而浮点型无法用二进制精确表示，所以在类型转换时出现不相等的情况
  65. */
  66. float f2 = 1.7F;
  67. double d2 = f2;
  68. System.out.println("f2=" + f2 + "\t" + "d2=" + d2);
  69. float f3 = (float) d2;
  70. System.out.println("f3=" + f3);
  71. }
  72. /**
  73. * 基本类型的强制类型转换
  74. *
  75. * 强制类型转换的规则:
  76. *
  77. * 当两种类型不兼容或者，目标类型比源类型的范围小，就要进行强制类型转换
  78. *
  79. * 转化时会发生"截断取模"的现象
  80. */
  81. public static void forceChange() {
  82. double d = 123.45D;
  83. float f = (float) d;
  84. long l = (long) d;
  85. int i = (int) d;
  86. short s = (short) d;
  87. byte b = (byte) d;
  88. System.out.print("d=" + d + "\t");
  89. System.out.print("f=" + f + "\t");
  90. System.out.print("l=" + l + "\t");
  91. System.out.print("i=" + i + "\t");
  92. System.out.print("s=" + s + "\t");
  93. System.out.print("b=" + b + "\t");
  94. /**
  95. * 首先对d2进行截断操作，值变为567，然后对128进行取模，得到结果
  96. */
  97. double d2 = 567.8D;
  98. b = (byte) d2;
  99. System.out.println(b);
  100. }
  101. public static void main(String[] args) {
  102. BasicType.typeAutoUppgrade();
  103. BasicType.autoChange();
  104. BasicType.forceChange();
  105. }
  106. } 
/**
 * Java基本数据类型
 */
package org.sean.module01;

/**
 * @author 不落的太阳(Sean Yang)
 */
public class BasicType {

	/**
	 * 基本类型的自动提升
	 * 
	 * 自动提升的规则如下:
	 * 
	 * 如果两个操作数中有一个是double类型，则系统先将另一个操作数转换为double类型，然后运算，否则
	 * 如果两个操作数中有一个是float类型，则系统先将另一个操作数转换为float类型，然后运算，否则
	 * 如果两个操作数中有一个是long类型，则系统先将另一个操作数转换为long类型，然后运算，否则
	 * 所有的操作数都被转换为int类型进行运算(低于int类型的会自动提升)
	 * 
	 * 如果采用"+=","*="等缩略形式的运算符，则系统会强制将运算结果转换为目标变量类型。
	 * 
	 */
	public static void typeAutoUppgrade() {
		char c = 'a';
		byte b = 44;
		short s = 1023;
		int i = 40000;
		long l = 1234L;
		float f = 35.6F;
		double d = 3.13D;

		double result = (b * f) + (f * l) + (i / c) - (d * s);
		System.out.println("自动类型提升的测试结果为" + result);
		@SuppressWarnings("unused")
		boolean flag = false;
	}

	/**
	 * 基本类型的自动转换
	 * 
	 * 自动类型转换的规则:
	 * 
	 * 两种类型是兼容类型；目标类型的范围要比源类型的范围大
	 */
	public static void autoChange() {
		char c = 'c';
		byte b = 44;
		short s = b;
		int i1 = s;
		int i2 = c;
		long l = i1;
		float f = l;
		double d = f;
		System.out.print("c=" + c + "\t");
		System.out.print("b=" + b + "\t");
		System.out.print("s=" + s + "\t");
		System.out.print("i1=" + i1 + "\t");
		System.out.print("i2=" + i2 + "\t");
		System.out.print("l=" + l + "\t");
		System.out.print("f=" + f + "\t");
		System.out.print("d=" + d + "\t");
		System.out.println();

		/**
		 * 当float转换为double时，会出现不相等的情况
		 * 
		 * 原因：float是32位的，double是64位的，在进行类型转换的时候，操作数都是以二进制的形式进行的，
		 * 而浮点型无法用二进制精确表示，所以在类型转换时出现不相等的情况
		 */
		float f2 = 1.7F;
		double d2 = f2;
		System.out.println("f2=" + f2 + "\t" + "d2=" + d2);
		float f3 = (float) d2;
		System.out.println("f3=" + f3);
	}

	/**
	 * 基本类型的强制类型转换
	 * 
	 * 强制类型转换的规则:
	 * 
	 * 当两种类型不兼容或者，目标类型比源类型的范围小，就要进行强制类型转换
	 * 
	 * 转化时会发生"截断取模"的现象
	 */
	public static void forceChange() {
		double d = 123.45D;
		float f = (float) d;
		long l = (long) d;
		int i = (int) d;
		short s = (short) d;
		byte b = (byte) d;

		System.out.print("d=" + d + "\t");
		System.out.print("f=" + f + "\t");
		System.out.print("l=" + l + "\t");
		System.out.print("i=" + i + "\t");
		System.out.print("s=" + s + "\t");
		System.out.print("b=" + b + "\t");

		/**
		 * 首先对d2进行截断操作，值变为567，然后对128进行取模，得到结果
		 */
		double d2 = 567.8D;
		b = (byte) d2;
		System.out.println(b);
	}

	public static void main(String[] args) {
		BasicType.typeAutoUppgrade();
		BasicType.autoChange();
		BasicType.forceChange();
	}
}

 

Java中的运算符

Java代码 复制代码 收藏代码
  1. /**
  2. * Java中的运算符
  3. */
  4. package org.sean.module01;
  5. /**
  6. * @author 不落的太阳(Sean Yang)
  7. */
  8. public class Operator {
  9. /**
  10. * 算数运算符: +, -, *, /, %
  11. *
  12. * @param a
  13. * 左操作数
  14. * @param b
  15. * 右操作数
  16. */
  17. public static void ArithmeticOperator(int a, int b) {
  18. int result = a + b;
  19. System.out.println("a+b=" + result);
  20. /**
  21. * 当 * 号两边的数据类型为char,byte,short时，其均会转换为int进行运算 除此以外运算结果取决于两个操作数中范围较宽的类型
  22. *
  23. * 当乘法运算产生的结果发生数据溢出时，不会抛出ArithmeticException，只会出现精度丢失的情况
  24. */
  25. int mutiplyResult = a * b;
  26. System.out.println("a*b=" + mutiplyResult);
  27. /**
  28. * 对于除法运算，当 / 号两边数据类型为整型时，结果为整型(不管其能否被除尽)
  29. *
  30. * 当 / 号两边数据有一个是浮点型，结果为浮点型
  31. *
  32. * 如果左操作数为整型，当 / 号的右操作数为0时，会抛出ArithmeticException
  33. *
  34. * 如果左操作数为浮点型，当 / 号的右操作数为0时，不会抛出异常
  35. *
  36. * 常见结果有三种：Infinity; -Infinity; NaN
  37. *
  38. * Infinity ---> 2.0/0 -Infinity ---> -2.0/0 NaN ---> 0.0/0; 0.0/0.0; 0/0.0
  39. */
  40. int divideResult = a / b;
  41. System.out.println("a/b=" + divideResult);
  42. /**
  43. * 判断是否为NaN
  44. */
  45. System.out.println("0.0/0.0 is NaN:" + Double.isNaN(0.0/0.0));
  46. /**
  47. * 对于取模运算:实质是用左操作数连续减去右操作数，直到相减的结果小于右操作数，此时结果即为余数
  48. *
  49. * 当取模运算中有负数作为操作数的时候，取模运算结果的符号取决于左操作数的符号
  50. *
  51. * 如果左操作数为整型，当 % 符号的右操作数为0时，会抛出ArithmeticException
  52. *
  53. * 如果左操作数为浮点型，当 % 符号右操作数为0时，不会抛出异常，
  54. *
  55. * NaN ：2.0%0; -2.0%0; 0.0%0; 0%0; 0%0.0
  56. */
  57. int modResult = a % b;
  58. System.out.println("a%b=" + modResult);
  59. }
  60. /**
  61. * 比较运算符: ==, !=, <, <=, >, >=,
  62. *
  63. * @param a
  64. * 左操作数
  65. * @param b
  66. * 右操作数
  67. */
  68. public static void compareOperator(int a, int b) {
  69. System.out.println("a==b " + (a == b));
  70. System.out.println("a!=b " + (a != b));
  71. System.out.println("a>b " + (a > b));
  72. System.out.println("a>=b " + (a >= b));
  73. System.out.println("a<b " + (a < b));
  74. System.out.println("a<=b " + (a <= b));
  75. }
  76. /**
  77. * 位运算: &, |, ^, ~, >>, >>>, <<
  78. *
  79. * @param a
  80. * 左操作数
  81. * @param b
  82. * 右操作数
  83. */
  84. public static void bitOperator(int a, int b) {
  85. /**
  86. * 按位与，两个操作数都为1时，结果为1，否则为0
  87. */
  88. int c = a & b;
  89. System.out.println("按位与后：" + c);
  90. /**
  91. * 按位或，两个操作数都为0时，结果为0，否则为1
  92. */
  93. c = a | b;
  94. System.out.println("按位或后：" + c);
  95. /**
  96. * 按位异或，两个操作数相同时结果为0，不同时结果为1
  97. */
  98. c = a ^ b;
  99. System.out.println("按位异或后：" + c);
  100. /**
  101. * 按位非，如果操作数为0，则变成1，如果为1，则变成0
  102. */
  103. c = ~a;
  104. System.out.println("按位非后：" + c);
  105. /**
  106. * 左移 (<<) 低位补零，高位舍弃，其实质相当于乘以2的n次方
  107. */
  108. c = a << b;
  109. System.out.println("左移后：" + c);
  110. /**
  111. * 右移 (>>) 如果值为正:高位补零，低位舍弃，如果值为负，高位补1，低位舍弃，其实质相当于除以2的n次方
  112. */
  113. c = a >> b;
  114. System.out.println("右移后：" + c);
  115. /**
  116. * 无符号右移 (>>>) 不论正负与否，高位补零，低位舍弃
  117. */
  118. c = a >>> b;
  119. System.out.println("无符号右移后：" + c);
  120. }
  121. /**
  122. * 逻辑运算符: &, |, ^, !, &&, ||,
  123. *
  124. * @param b1,b2,b3
  125. * 参与逻辑运算的boolean表达式
  126. */
  127. public static void booleanOperator(boolean b1, boolean b2, boolean b3) {
  128. /**
  129. * 短路与运算:如果第一个表达式结果为false，那么整个表达式的结果就是false，后面的表达式不再运算
  130. */
  131. if (b1 && b2 && b3) {
  132. System.out.println("变量b1, b2, b3都为true");
  133. } else {
  134. System.out.println("变量b1, b2, b3至少有一个是false");
  135. }
  136. /**
  137. * 短路或运算:如果第一个表达式结果为true，那么整个表达式的结果就是true，后面的表达式不再运算
  138. */
  139. if (b1 || b2 || b3) {
  140. System.out.println("变量b1, b2, b3至少有一个true");
  141. } else {
  142. System.out.println("变量b1, b2, b3都是false");
  143. }
  144. /**
  145. * 异或运算:操作数相同为false，不同为true
  146. */
  147. if (b1 ^ b2) {
  148. System.out.println("b1, b2的值不同");
  149. } else {
  150. System.out.println("b1, b2的值相同");
  151. }
  152. }
  153. /**
  154. * 其他运算符
  155. *
  156. * @param i
  157. * 参与运算的变量
  158. */
  159. public static void otherOperator(int i) {
  160. System.out.println(i++);
  161. System.out.println(++i);
  162. int x = (i > 0) ? i : -i;
  163. System.out.println(x);
  164. }
  165. public static void main(String[] args) {
  166. int a = 7;
  167. int b = 5;
  168. Operator.ArithmeticOperator(a, b);
  169. Operator.compareOperator(a, b);
  170. Operator.bitOperator(a, b);
  171. boolean b1 = true;
  172. boolean b2 = false;
  173. boolean b3 = true;
  174. Operator.booleanOperator(b1, b2, b3);
  175. Operator.otherOperator(7);
  176. }
  177. } 
/**
 * Java中的运算符
 */
package org.sean.module01;

/**
 * @author 不落的太阳(Sean Yang)
 */
public class Operator {

	/**
	 * 算数运算符: +, -, *, /, %
	 * 
	 * @param a
	 *            左操作数
	 * @param b
	 *            右操作数
	 */
	public static void ArithmeticOperator(int a, int b) {
		int result = a + b;
		System.out.println("a+b=" + result);

		/**
		 * 当 * 号两边的数据类型为char,byte,short时，其均会转换为int进行运算 除此以外运算结果取决于两个操作数中范围较宽的类型
		 * 
		 * 当乘法运算产生的结果发生数据溢出时，不会抛出ArithmeticException，只会出现精度丢失的情况
		 */
		int mutiplyResult = a * b;
		System.out.println("a*b=" + mutiplyResult);

		/**
		 * 对于除法运算，当 / 号两边数据类型为整型时，结果为整型(不管其能否被除尽)
		 * 
		 * 当 / 号两边数据有一个是浮点型，结果为浮点型
		 * 
		 * 如果左操作数为整型，当 / 号的右操作数为0时，会抛出ArithmeticException
		 * 
		 * 如果左操作数为浮点型，当 / 号的右操作数为0时，不会抛出异常
		 * 
		 * 常见结果有三种：Infinity; -Infinity; NaN
		 * 
		 * Infinity ---> 2.0/0 -Infinity ---> -2.0/0 NaN ---> 0.0/0; 0.0/0.0; 0/0.0
		 */
		int divideResult = a / b;
		System.out.println("a/b=" + divideResult);

		/**
		 * 判断是否为NaN
		 */
		System.out.println("0.0/0.0 is NaN:" + Double.isNaN(0.0/0.0));
		
		/**
		 * 对于取模运算:实质是用左操作数连续减去右操作数，直到相减的结果小于右操作数，此时结果即为余数
		 * 
		 * 当取模运算中有负数作为操作数的时候，取模运算结果的符号取决于左操作数的符号
		 * 
		 * 如果左操作数为整型，当 % 符号的右操作数为0时，会抛出ArithmeticException
		 * 
		 * 如果左操作数为浮点型，当 % 符号右操作数为0时，不会抛出异常，
		 * 
		 * NaN ：2.0%0; -2.0%0; 0.0%0; 0%0; 0%0.0
		 */		
		int modResult = a % b;
		System.out.println("a%b=" + modResult);

	}

	/**
	 * 比较运算符: ==, !=, <, <=, >, >=,
	 * 
	 * @param a
	 *            左操作数
	 * @param b
	 *            右操作数
	 */
	public static void compareOperator(int a, int b) {
		System.out.println("a==b " + (a == b));
		System.out.println("a!=b " + (a != b));
		System.out.println("a>b " + (a > b));
		System.out.println("a>=b " + (a >= b));
		System.out.println("a<b " + (a < b));
		System.out.println("a<=b " + (a <= b));
	}

	/**
	 * 位运算: &, |, ^, ~, >>, >>>, <<
	 * 
	 * @param a
	 *            左操作数
	 * @param b
	 *            右操作数
	 */
	public static void bitOperator(int a, int b) {

		/**
		 * 按位与，两个操作数都为1时，结果为1，否则为0
		 */
		int c = a & b;
		System.out.println("按位与后：" + c);

		/**
		 * 按位或，两个操作数都为0时，结果为0，否则为1
		 */
		c = a | b;
		System.out.println("按位或后：" + c);

		/**
		 * 按位异或，两个操作数相同时结果为0，不同时结果为1
		 */
		c = a ^ b;
		System.out.println("按位异或后：" + c);

		/**
		 * 按位非，如果操作数为0，则变成1，如果为1，则变成0
		 */
		c = ~a;
		System.out.println("按位非后：" + c);

		/**
		 * 左移 (<<) 低位补零，高位舍弃，其实质相当于乘以2的n次方
		 */
		c = a << b;
		System.out.println("左移后：" + c);

		/**
		 * 右移 (>>) 如果值为正:高位补零，低位舍弃，如果值为负，高位补1，低位舍弃，其实质相当于除以2的n次方
		 */
		c = a >> b;
		System.out.println("右移后：" + c);

		/**
		 * 无符号右移 (>>>) 不论正负与否，高位补零，低位舍弃
		 */
		c = a >>> b;
		System.out.println("无符号右移后：" + c);
	}

	/**
	 * 逻辑运算符: &, |, ^, !, &&, ||,
	 * 
	 * @param b1,b2,b3
	 *            参与逻辑运算的boolean表达式
	 */
	public static void booleanOperator(boolean b1, boolean b2, boolean b3) {
		/**
		 * 短路与运算:如果第一个表达式结果为false，那么整个表达式的结果就是false，后面的表达式不再运算
		 */
		if (b1 && b2 && b3) {
			System.out.println("变量b1, b2, b3都为true");
		} else {
			System.out.println("变量b1, b2, b3至少有一个是false");
		}

		/**
		 * 短路或运算:如果第一个表达式结果为true，那么整个表达式的结果就是true，后面的表达式不再运算
		 */
		if (b1 || b2 || b3) {
			System.out.println("变量b1, b2, b3至少有一个true");
		} else {
			System.out.println("变量b1, b2, b3都是false");
		}

		/**
		 * 异或运算:操作数相同为false，不同为true
		 */
		if (b1 ^ b2) {
			System.out.println("b1, b2的值不同");
		} else {
			System.out.println("b1, b2的值相同");
		}
	}

	/**
	 * 其他运算符
	 * 
	 * @param i
	 *            参与运算的变量
	 */
	public static void otherOperator(int i) {
		System.out.println(i++);
		System.out.println(++i);

		int x = (i > 0) ? i : -i;
		System.out.println(x);
	}

	public static void main(String[] args) {
		int a = 7;
		int b = 5;
		Operator.ArithmeticOperator(a, b);
		Operator.compareOperator(a, b);
		Operator.bitOperator(a, b);
		boolean b1 = true;
		boolean b2 = false;
		boolean b3 = true;
		Operator.booleanOperator(b1, b2, b3);
		Operator.otherOperator(7);

	}
}

 

 

Java中的流程控制

Java代码 复制代码 收藏代码
  1. /**
  2. * Java中的流程控制
  3. */
  4. package org.sean.module01;
  5. /**
  6. * @author 不落的太阳(Sean Yang)
  7. */
  8. public class FlowControl {
  9. // 目标值
  10. public static final int TARGET_NUMBER = 10;
  11. public FlowControl() {
  12. System.out.println("constructor called");
  13. }
  14. /**
  15. * 通过if语句和递归方法使n的值逐渐变为TARGET_NUMBER;
  16. *
  17. * @param n
  18. */
  19. public void ifStatement(int n) {
  20. System.out.print(n + " ");
  21. if (n == TARGET_NUMBER) {
  22. System.out.println();
  23. } else if (n > TARGET_NUMBER) {
  24. ifStatement(--n);
  25. } else if (n < TARGET_NUMBER) {
  26. ifStatement(++n);
  27. }
  28. }
  29. /**
  30. * 通过for循环将n的值逐渐变为TARGET_NUMBER
  31. *
  32. * @param n
  33. */
  34. public void forStatement(int n) {
  35. for (; n > TARGET_NUMBER; n--) {
  36. System.out.print(n + " ");
  37. }
  38. for (; n < TARGET_NUMBER; n++) {
  39. System.out.print(n + " ");
  40. }
  41. System.out.println(n);
  42. }
  43. /**
  44. * 通过while循环将n的值逐渐变为TARGET_NUMBER
  45. *
  46. * @param n
  47. */
  48. public void whileStatement(int n) {
  49. while (n < TARGET_NUMBER) {
  50. System.out.print(n++ + " ");
  51. }
  52. while (n > TARGET_NUMBER) {
  53. System.out.println(n-- + " ");
  54. }
  55. System.out.println(n);
  56. }
  57. /**
  58. * 通过do...while循环将n的值逐渐变为TARGET_NUMBER
  59. *
  60. * @param n
  61. */
  62. public void doWhileStatement(int n) {
  63. if (n > TARGET_NUMBER) {
  64. do {
  65. System.out.print(n-- + " ");
  66. } while (n > TARGET_NUMBER);
  67. } else if (n < TARGET_NUMBER) {
  68. do {
  69. System.out.print(n++ + " ");
  70. } while (n < TARGET_NUMBER);
  71. }
  72. System.out.println(n);
  73. }
  74. /**
  75. * switch结构
  76. *
  77. * @param n
  78. */
  79. public void switchStatement(int n) {
  80. switch (n) {
  81. case 10:
  82. System.out.println("n=10");
  83. break;
  84. case 9:
  85. System.out.println("n=9");
  86. break;
  87. case 8:
  88. System.out.println("n=8");
  89. break;
  90. default:
  91. System.out.println("n!=8 and n!=9 and n!=10");
  92. break;
  93. }
  94. }
  95. public static void main(String[] args) {
  96. FlowControl control = new FlowControl();
  97. control.ifStatement(6);
  98. control.forStatement(16);
  99. control.whileStatement(6);
  100. control.doWhileStatement(16);
  101. control.switchStatement(8);
  102. }
  103. } 
/**
 * Java中的流程控制
 */
package org.sean.module01;

/**
 * @author 不落的太阳(Sean Yang)
 */
public class FlowControl {

	// 目标值
	public static final int TARGET_NUMBER = 10;

	public FlowControl() {
		System.out.println("constructor called");
	}

	/**
	 * 通过if语句和递归方法使n的值逐渐变为TARGET_NUMBER;
	 * 
	 * @param n
	 */
	public void ifStatement(int n) {
		System.out.print(n + " ");
		if (n == TARGET_NUMBER) {
			System.out.println();
		} else if (n > TARGET_NUMBER) {
			ifStatement(--n);
		} else if (n < TARGET_NUMBER) {
			ifStatement(++n);
		}
	}

	/**
	 * 通过for循环将n的值逐渐变为TARGET_NUMBER
	 * 
	 * @param n
	 */
	public void forStatement(int n) {
		for (; n > TARGET_NUMBER; n--) {
			System.out.print(n + " ");
		}
		for (; n < TARGET_NUMBER; n++) {
			System.out.print(n + " ");
		}
		System.out.println(n);
	}

	/**
	 * 通过while循环将n的值逐渐变为TARGET_NUMBER
	 * 
	 * @param n
	 */
	public void whileStatement(int n) {
		while (n < TARGET_NUMBER) {
			System.out.print(n++ + " ");
		}
		while (n > TARGET_NUMBER) {
			System.out.println(n-- + " ");
		}
		System.out.println(n);
	}

	/**
	 * 通过do...while循环将n的值逐渐变为TARGET_NUMBER
	 * 
	 * @param n
	 */
	public void doWhileStatement(int n) {
		if (n > TARGET_NUMBER) {
			do {
				System.out.print(n-- + " ");
			} while (n > TARGET_NUMBER);
		} else if (n < TARGET_NUMBER) {
			do {
				System.out.print(n++ + " ");
			} while (n < TARGET_NUMBER);
		}
		System.out.println(n);
	}

	/**
	 * switch结构
	 * 
	 * @param n
	 */
	public void switchStatement(int n) {

		switch (n) {
		case 10:
			System.out.println("n=10");
			break;
		case 9:
			System.out.println("n=9");
			break;
		case 8:
			System.out.println("n=8");
			break;
		default:
			System.out.println("n!=8 and n!=9 and n!=10");
			break;
		}
	}

	public static void main(String[] args) {
		FlowControl control = new FlowControl();
		control.ifStatement(6);
		control.forStatement(16);
		control.whileStatement(6);
		control.doWhileStatement(16);
		control.switchStatement(8);
	}

}

 

最后带给大家一个比较全面的打印各种形状的代码，貌似有时笔试面试会问到

 

Java代码 复制代码 收藏代码
  1. /**
  2. * 打印各种图形
  3. */
  4. package org.sean.module01;
  5. import java.util.Scanner;
  6. /**
  7. * @author 不落的太阳(Sean Yang)
  8. */
  9. public class PrintTriangle {
  10. public static void shape1(int k) {
  11. for (int i = 0; i < k; i++) {
  12. for (int j = 0; j <= i; j++) {
  13. System.out.print("*");
  14. }
  15. System.out.println();
  16. }
  17. }
  18. public static void shape2(int k) {
  19. for (int i = 0; i < k; i++) {
  20. for (int j = k; j > i; j--) {
  21. System.out.print("*");
  22. }
  23. System.out.println();
  24. }
  25. }
  26. /**
  27. * 打印等腰三角形
  28. *
  29. * @param i
  30. * 三角形的行数
  31. */
  32. public static void shape3(int n) {
  33. for (int i = 1; i <= n; i++) {
  34. for (int j = n - i; j >= 0; j--) {
  35. System.out.print(" ");
  36. }
  37. for (int k = 1; k <= (2 * i - 1); k++) {
  38. System.out.print("*");
  39. }
  40. System.out.println("");
  41. }
  42. }
  43. /**
  44. * 打印实心菱形
  45. *
  46. * @param i
  47. * 菱形的行数
  48. */
  49. public static void shape4(int n) {
  50. for (int i = 0; i < n; i++) {
  51. for (int k = n - i; k > 0; k--) {
  52. System.out.print(" ");
  53. }
  54. for (int j = 1; j <= (2 * i + 1); j++) {
  55. System.out.print("*");
  56. }
  57. System.out.println();
  58. }
  59. for (int i = n - 1; i > 0; i--) {
  60. for (int k = 0; k <= n - i; k++) {
  61. System.out.print(" ");
  62. }
  63. for (int k = (2 * i); k > 1; k--) {
  64. System.out.print("*");
  65. }
  66. System.out.println();
  67. }
  68. }
  69. /**
  70. * 打印空心菱形
  71. *
  72. * @param n
  73. * 菱形行数
  74. */
  75. public static void shape5(int n) {
  76. for (int i = 0; i < n; i++) {
  77. for (int k = n - i; k > 0; k--) {
  78. System.out.print(" ");
  79. }
  80. System.out.print("*");
  81. for (int j = 1; j <= (2 * i - 1); j++) {
  82. System.out.print(" ");
  83. }
  84. if (i > 0) {
  85. System.out.print("*");
  86. }
  87. System.out.println();
  88. }
  89. for (int i = n - 1; i > 0; i--) {
  90. for (int k = 0; k <= n - i; k++) {
  91. System.out.print(" ");
  92. }
  93. System.out.print("*");
  94. for (int k = ((2 * i) - 1); k > 2; k--) {
  95. System.out.print(" ");
  96. }
  97. if (i > 1) {
  98. System.out.print("*");
  99. }
  100. System.out.println();
  101. }
  102. }
  103. public strictfp static void main(String[] args) {
  104. Scanner scanner = new Scanner(System.in);
  105. int i = scanner.nextInt();
  106. PrintTriangle.shape1(i);
  107. System.out.println();
  108. PrintTriangle.shape2(i);
  109. System.out.println();
  110. PrintTriangle.shape3(i);
  111. System.out.println();
  112. PrintTriangle.shape4(i);
  113. System.out.println();
  114. PrintTriangle.shape5(i);
  115. }
  116. }
分享到：
| Java SE 学习笔记01
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    JAVA SE学习笔记

    **JAVA SE学习笔记** 在Java SE（标准版）的学习中，我们主要关注的是Java编程语言的基础和核心特性，包括但不限于语法、数据类型、控制结构、类与对象、接口、异常处理、多线程、集合框架、输入/输出(I/O)系统、...

    Java JDK 7学习笔记源代码

    《java jdk 7学习笔记》针对java se 7新功能全面改版，无论是章节架构或范例程序代码，都做了重新编写与全面翻新。并详细介绍了jvm、jre、java se api、jdk与ide之间的对照关系。必要时从java se api的源代码分析，...

    Java JDK7学习笔记-光盘

    《Java JDK7学习笔记》针对java se 7新功能全面改版，无论是章节架构或范例程序代码，都做了重新编写与全面翻新。并详细介绍了jvm、jre、java se api、jdk与ide之间的对照关系。必要时从java se api的源代码分析，...

    精品JAVA SE 学习笔记

    【Java SE学习笔记详解】 Java SE（Standard Edition）是Java平台的核心部分，它为开发桌面应用、服务器端应用以及中间件提供了基础。本笔记主要基于MLDN（Microsoft Learning Dynamic Network）李兴华老师的2009年...

    Java学习资料 java se JAVA基础学习笔记和演示案例代码项目

    "Java学习资料"这个压缩包显然包含了一些关于Java SE（标准版）的基础学习资源，包括笔记和实际的演示案例代码项目。Java SE是Java的核心部分，主要用于桌面应用和服务器端开发。 在Java的学习过程中，笔记通常会...

    java se个人学习笔记

    这份"java se个人学习笔记"显然是一份对Java SE基础知识的详细记录，由一位初学者整理，旨在帮助其他初学者理解这个强大的编程语言。笔记中可能涵盖了以下几个关键知识点： 1. **基础语法**：Java的基本数据类型、...

    Java+JDK+7学习笔记_林信良编著.pdf

    《Java JDK7学习笔记》针对java se 7新功能全面改版，无论是章节架构或范例程序代码，都做了重新编写与全面翻新。并详细介绍了jvm、jre、java se api、jdk与ide之间的对照关系。必要时从java se api的源代码分析，...

    非常详细javaSE学习笔记.rar

    Java SE（标准版）是Java开发平台的核心部分，它提供了编写、运行和部署桌面应用程序所需的类库和工具。这份“非常详细JavaSE学习...无论你是初学者还是有经验的开发者，这份详尽的Java SE学习笔记都是一个宝贵的资源。

    java se 1.8完整笔记，附大纲、代码、配图

    java SE 1.8笔记大纲 java SE 1.8是 Java 编程语言的标准版，本笔记涵盖了Java SE 1.8的所有知识点，从基本数据类型到...本笔记涵盖了 Java SE 1.8 的所有知识点，是一个非常完整和系统的 Java 编程语言学习资源。

    黑马java se视频笔记

    计算机基础知识是学习计算机科学和技术的基础，它...总结来说，了解计算机基础知识对于深入学习Java SE或其他计算机编程语言是十分必要的。它不仅为我们打下坚实的理论基础，还能帮助我们更好地理解和使用计算机技术。

    韩顺平编写的java学习笔记(全)

    ### 韩顺平编写的Java学习笔记概览 #### Java平台分类与运行机制 - **J2SE（Java 2 Platform, Standard Edition）**: 标准版Java开发平台，适用于桌面应用程序开发。 - **J2EE（Java 2 Platform, Enterprise ...

    JAVA SE 归档笔记

    【JAVA SE 归档笔记】是一份由多位IT行业高手共同编撰的珍贵资料，旨在为初学者提供学习指引，并作为经验丰富的开发者们的参考手册。这份笔记深入浅出地涵盖了JAVA SE（Java Standard Edition）的核心知识点，对于...

    Java学习笔记

    ●本书是作者多年来教学实践经验的总结，汇集了学员在学习课程或认证考试中遇到的概念、操作、应用等问题及解决方案, ●针对Java SE 8新功能全面改版，无论是章节架构或范例程序代码，都做了重新编写与全面翻新, ●...

    java学习笔记JDK6.0课件和代码

    这个压缩包中包含的"java学习笔记JDK6课件和课本代码"是学习JDK 6.0的重要参考资料，可以帮助你深入理解Java编程的核心概念和实践技巧。 1. **Java基础**：Java是一种面向对象的编程语言，它的基础包括类、对象、...

    java笔记本源代码

    此源代码使用Java SE（标准版）环境，可能涉及到Java的基础语法、类、对象、接口、异常处理、数据类型等。 2. **Swing库**：Java Swing库是用于构建GUI应用程序的组件集合。这个项目可能使用了JFrame、JButton、...

    JAVA-SE学习笔记

    这些基本概念构成了Java SE编程的基础，理解并掌握它们对于编写高效、可靠的Java代码至关重要。通过这些知识，开发者可以创建复杂的数据结构，实现灵活的设计模式，并构建出具有强大功能的应用程序。

    张龙 java se课程笔记

    1. **Java环境搭建**：首先，学习Java SE需要安装Java Development Kit (JDK)，设置好环境变量`JAVA_HOME`、`PATH`和`CLASSPATH`，以便于编译和运行Java程序。 2. **Java语法基础**：Java是一种面向对象的语言，其...

Magicbox
Global site tag (gtag.js) - Google Analytics