07-java运算符总结-打印*号练习题

1. 1. 知识点总结
2. 数据类型转换
   1. 数据类型范围从小到大排序（byte < char < short < int < long < float < double），布尔类型Boolean不能参与类型转换；
   2. 自动类型转换，范围小的数据类型向范围大的数据类型转换时使用；
   3. 强制类型转换，范围大的数据类型向范围小的数据类型转换时使用。

 

1. 算数运算符
   1. 用来完成算数运算（如加减乘除计算等）
   2. ++，--运算符的使用
      1. ++，--前置（如++a），当参与运算时，变量a的值先自增1，然后用自增后的新值再参与运算；
      2. ++，--后置（如a++），当参与运算时，变量a先使用原有值参与运算符，变量a的值再自增1。

 

1. 赋值运算符
   1. 用来完成数据的赋值（如 int a = 100;）
   2. +=,-,*=,/=这样的赋值运算符包含了一个强制转换的操作，会将左右两边运算后的结果，强制类型转换后赋值给左边

int n = 10;

byte by = 20;

by += n; // 运算完毕后，by的值为byte类型30， 相当于代码 by = (byte)(by + n);

 

1. 比较运算符
   1. 用来比较数据的大小（如 3>4），比较运算符也称为条件运算符。
   2. 比较后的结果为布尔类型Boolean的值
   3. “==”两个等号代表比较是否相等，“=”一个等号代表赋值。

 

1. 逻辑运算符
   1. 逻辑与& 和逻辑短路与&&：代表着并且的意思，左右两边都要条件成立，结果才为true；
   2. 逻辑或| 和逻辑短路或||：代表着或者的意思，左边两边有一个条件成立，结果就为true；
   3. 逻辑非!：代表着相反的意思，原先是false，结果就为true；原先是ture，结果就为false；
   4. 逻辑异或^： 左右两边条件结果相同，结果就为false，左右两边条件结果不同，结果就为true；

 

1. 三元运算符
   1. 根据判断条件运算结果，执行不同的表达式值；条件为true，执行表达式1，否则，执行表达式2。

 

1.    *****
2.    *****
3.    *****
4.    *****
5.    *****
6.    10.  
7.       *
8.      *** 打印的是1+0个  
9.     *****
10.    *******
11.   *********
12. 9.
13.   *
14.   **
15.   ***
16.   ****
17.   *****
18.  
19. 11.
20.     *
21.    ***
22.   *****
23.  *******
24. *********
25.  *******
26.   *****
27.    ***
28.     *
29.     13.
30.    ###*###
31.    ##*#*##
32.    #*###*#
33.    *#####*
34.    #*###*#
35.    ##*#*##
36.    ###*###
37. 12. 
38.     A
39.    ABA
40.   ABCBA
41.  ABCDCBA
42. ABCDEDCBA
43.  ABCDCBA
44.   ABCBA
45.    ABA
46.     A
47. public class Demo1 {
48.    
49.    
50.    
51.     public static void main(String[] args) {
52.        
53.         Integer numInteger = new Integer("45");
54.         System.out.println(numInteger);
55.         /*
56.          *         *****
57.                    *****
58.                    *****
59.                    *****
60.                    *****
61.          */
62.         for(int i = 0;i < 5; i ++) {
63.             System.out.println("*****");
64.         }
65.         System.out.println("---------------------");
66.             //       *
67.             //      ***
68.             //     *****
69.             //    *******
70.             //  *********
71.         for (int i = 1; i <= 5; i++) {
72.             for (int j = 5 - i; j > 0; j--) {
73.                 System.out.print(" ");
74.             }
75.             for (int k = 1; k <= 2 * i - 1; k++) {
76.                 System.out.print("*");
77.             }
78.             System.out.println();
79.         }
80.         System.out.println("----------------------");
81. //        *
82. //        **
83. //        ***
84. //        ****
85. //        *****
86.         for(int i = 0; i <= 5; i++) {
87.             for (int j = 0; j < i; j++) {
88.                 System.out.print("*");
89.             }
90.             System.out.println();
91.         }
92.             //      *
93.             //      ***
94.             //     *****
95.             //    *******
96.             //  *********
97.             //    *******
98.             //     *****
99.             //      ***
100.             //       *
101.         System.out.println("--------------------------");
102.         for (int i = 1; i <= 5; i++) {
103.             for (int j = 5 - i; j > 0; j--) {
104.                 System.out.print(" ");
105.             }
106.             for (int k = 1; k <= 2 * i - 1; k++) {
107.                 System.out.print("*");
108.             }
109.             System.out.println();
110.         }
111.         for (int i = 1; i <= 4; i++) {
112.             for (int j = 1; j <= i; j++) {
113.                 System.out.print(" ");
114.             }
115.             for (int k = 0; k < 9 - 2 * i; k++) {
116.                 System.out.print("*");
117.             }
118.             System.out.println();
119.         }
120. //         ###*###
121. //         ##*#*##
122. //        #*###*#
123. //         *#####*
124. //         #*###*#
125. //         ##*#*##
126. //         ###*###
127.         System.out.println("--------------------------");
128.         for (int i = 1; i <= 4; i++) {
129.             for (int j = 1; j <= 7; j++) {
130.                 if (j == 3 + i  || j == 5 - i) {
131.                    System.out.print("*");                
132.                 } else {
133.                    System.out.print("#");
134.                 }
135.             }
136.             System.out.println();
137.         }
138.         for (int i = 1; i <= 3; i++) {
139.             for (int j = 1; j <= 7; j++) {
140.                 if (j == 7 - i ||  j == i + 1) {
141.                    System.out.print("*");
142.                 } else {
143.                    System.out.print("#");
144.                 }
145.             }
146.             System.out.println();
147.         }
148.         System.out.println("--------------------------");
149.         //       A
150.         //      ABA
151.         //     ABCBA
152.         //    ABCDCBA
153.         //  ABCDEDCBA
154.         //    ABCDCBA
155.         //     ABCBA
156.         //      ABA
157.         //       A
158.         for (int i = 1; i <= 5; i++) {
159.             for (int j = 5 - i; j > 0; j--) {
160.                 System.out.print(" ");
161.             }
162.             for (int j = 'A'; j < 'A' + i ; j++) {
163.                 System.out.print((char)j);
164.             }
165.             for (int k = 'A' + i - 2; k >= 'A'; k--) {
166.                 System.out.print((char)k);
167.             }
168.             System.out.println();
169.         }
170.         for (int i = 1; i <= 4; i++) {
171.             for (int j = 1; j <= i; j++) {
172.                 System.out.print(" ");
173.             }
174.             for (int k = 'A'; k <= 'A' + 4 - i; k++) {
175.                 System.out.print((char)k);
176.             }
177.             for (int l = 'A' + 3 - i; l >= 'A' ; l--) {
178.                 System.out.print((char)l);
179.             }
180.             System.out.println();
181.         }
182.     }

}