Java SE 学习笔记01 代码

 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. }