今天看到了毕老师视频for嵌套的地方了，除了毕老师讲的两种*形三角之外，又拓展了另外四种三角形的打印小程序。毕老师的视频中打印了：
*                               *****
**                              ****
***                             ***
****                            **
*****   和                    *                这两种三角。
第一个拓展是打印：
*****                              *
****                             **
  ***                            ***
   **                           ****
    *    和                   *****             这两种三角：
代码如下：

1. package test;
   
2. 
   
3. /**
   
4. * 打印如下图形：
   
5. *
   
6. *            *****
   
7. *            ****
   
8. *            ***
   
9. *            **
   
10. *            *
    
11. * @author jeremy
    
12. *
    
13. * 每一行打印*前，先打印x个空格，即可完成上述图形。
    
14. */
    
15. public class Triangle3 {
    
16. 
    
17.         public static void main(String[] args) {
    
18.                 for(int x = 0; x < 5; x ++) {
    
19.                        
    
20.                         for(int y = x; y < 5; y ++) {
    
21.                                
    
22.                                 System.out.print("*");
    
23.                                
    
24.                         }
    
25.                        
    
26.                         System.out.println();
    
27.                        
    
28.                         /*
    
29.                          * 这个for循环，在每次换行之后，打印x个数量的空格
    
30.                          */
    
31.                         for(int j = 0; j <= x; j ++) {
    
32.                                
    
33.                                 System.out.print(" ");
    
34.                                
    
35.                         }
    
36.                 }
    
37.         }
    
38. }

复制代码

1. package test;
   
2. 
   
3. /**
   
4. * 打印如下图形：
   
5. *            *
   
6. *           **
   
7. *          ***
   
8. *         ****
   
9. *        *****
   
10. * @author jeremy
    
11. *
    
12. *        只需要在Triangle2的基础上，每行先打印x个空格即可打印上述图形。
    
13. */
    
14. public class Triangle4 {
    
15.        
    
16.         public static void main(String[] args) {
    
17.                
    
18.                 for(int x = 0; x < 5; x ++) {
    
19.                        
    
20.                         /*
    
21.                          * 这个循环在每行打印*前，先打印x个空格
    
22.                          */
    
23.                         for(int j = 4; j > x; j --) {
    
24.                                 System.out.print(" ");
    
25.                         }
    
26.                        
    
27.                         for(int y = 0; y <= x; y ++) {
    
28.                                 System.out.print("*");
    
29.                         }
    
30.                        
    
31.                         System.out.println();
    
32.                 }
    
33.         }
    
34. }
    

复制代码

第二个拓展，是打印如下三角和其倒三角：
         *
        ***
       *****
      *******
代码如下：

1. package test;
   
2. 
   
3. /**
   
4. * 打印如下图形：
   
5. *           
   
6. *    *******
   
7. *     *****
   
8. *      ***
   
9. *       *
   
10. *
    
11. * @author jeremy
    
12. *
    
13. *        1）根据Triangle3，先将每行前的空格打印出来，第一步结果如下：
    
14. *     *******
    
15. *      *******
    
16. *       *******
    
17. *        *******
    
18. *
    
19. *  2）第二步工作只需要控制每一行的*数量即可，即找出init（初始行*的个数）和x（行数）之间的关系：
    
20. *                                                  每一行*的数量 = init - 2x   
    
21. *  即x每增加1，每一行的*数量减少2个
    
22. *  
    
23. *  3）在内循环控制判断条件，即可打印上述图形
    
24. */
    
25. 
    
26. public class Triangle5 {
    
27. 
    
28.         public static void main(String[] args) {
    
29.                
    
30.                 int init = 17;
    
31.                
    
32.                 //打印上述图形，初始行*的个数与整个图形行数的关系是 第一行*个数 / 2 + 1，例如第一行*个数（init） = 7的时候，有4行，以此类推
    
33.                 for(int x = 0; x < (init / 2 + 1); x ++) {
    
34.                        
    
35.                         //每一行*的数量 = init - 2x
    
36.                         for(int y = 0; y < (init - 2 * x); y ++) {     
    
37.                                 System.out.print("*");
    
38.                         }
    
39.                        
    
40.                         System.out.println();
    
41.                        
    
42.                         //这个循环在换行后先打印x个空格
    
43.                         for(int j = 0; j <= x; j ++) {
    
44.                                 System.out.print(" ");
    
45.                         }
    
46.                        
    
47.                 }
    
48.         }
    
49. }
    

复制代码

1. package test;
   
2. 
   
3. /**
   
4. * 打印如下图形：
   
5. *
   
6. *         *
   
7. *        ***
   
8. *       *****
   
9. *      *******
   
10. * @author jeremy
    
11. *
    
12. *        思路同Triangle5，只是打印空格的循环先于换行语句执行，以及需要根据整个三角的行数确定每行打印空格的个数。
    
13. */
    
14. 
    
15. public class Triangle6 {
    
16.        
    
17.         public static void main(String[] args) {
    
18.                
    
19.                 int base = 15;
    
20.                
    
21.                 //打印上述图形，初始行*的个数与整个图形行数的关系是 （最后一行*个数 / 2 + 1），例如最后一行*个数（base） = 7的时候，有4行，以此类推
    
22.                 for(int x = 0; x < (base / 2 + 1); x ++) {
    
23.                        
    
24.                         //每行空格的个数 = 最后一行*个数 / 2
    
25.                         for(int j = (base / 2); j > x; j --) {
    
26.                                 System.out.print(" ");
    
27.                         }
    
28.                        
    
29.                         //第（x + 1）行*的个数 = 最后一行*的个数（base） - 2 * (整个三角形的行数 - (x + 1))，这里貌似很麻烦，但是我想不到更好的方法了，希望大家指点
    
30.                         for(int y = 0; y < (base - 2 * ((base / 2 + 1) - (x + 1))); y ++) {
    
31.                                 System.out.print("*");
    
32.                         }
    
33.                        
    
34.                         System.out.println();
    
35.                 }
    
36.         }
    
37. }
    

复制代码

希望对大家有所帮助~一起努力！

打印一个菱形就差不多了    菱形前天刚刚做出来

菱形其实就是综合了这几种的图形，练练那个就足够了