下面是我刚刚用for嵌套循环写的圣诞树代码。代码太多，求优化。

1. class Tree{
   
2. public static void main(String[] args){
   
3. int le=10; //第一层
   
4. for(int i=0;i<le;i++){
   
5. for(int j=0;j<le-i-1;j++){
   
6. System.out.print(" ");
   
7. }
   
8. for(int j=0;j<=i;j++){
   
9. System.out.print("* ");
   
10. }
    
11. System.out.println();
    
12. }
    
13. int l=8; //第二层
    
14. for(int a=0;a<l;a++){
    
15. for(int s=0;s<l-a+1;s++){
    
16. System.out.print(" ");
    
17. }
    
18. for(int s=0;s<=a;s++){
    
19. System.out.print("* ");
    
20. }
    
21. System.out.println();
    
22. }
    
23. int q=6; //第三层
    
24. for(int w=0;w<q;w++){
    
25. for(int e=0;e<q-w+3;e++){
    
26. System.out.print(" ");
    
27. }
    
28. for(int e=0;e<=w;e++){
    
29. System.out.print("* ");
    
30. }
    
31. System.out.println();
    
32. }
    
33. for(int m=0;m<6;m++){ //底层
    
34. System.out.print(" ");
    
35. for(int n=0;n<5;n++){
    
36. System.out.print("*");
    
37. }
    
38. System.out.println();
    
39. }
    
40. }
    
41. }

复制代码

弄了老久，这样应该差不多了吧.。能封装的都尽量封装了，最主要的是数的大小可控制，树冠层数可以控制，只要改 num=10,level=3,chang=6;就行。

1. /*
   
2. 需求：简化打印树形的代码
   
3. */
   
4. import static java.lang.System.*;
   
5. class Tree
   
6. {
   
7.         private static int num=10,level=3,chang=6;        //控制打印树的大小与形状的变量
   
8.         public static void main(String[] args)
   
9.         {
   
10.                 for(int i=1;i<=level;i++)
    
11.                         san(i);
    
12.                 ju();
    
13.         }
    
14.         //打印三角形
    
15.         public static void san(int p)
    
16.         {
    
17.                 for(int i=0;i<num;i++)
    
18.                 {
    
19.                         myFor(num+2*p-i-3," ");//num+2*p-i-3为左边打印的空格数
    
20.                         myFor(i,"* ");
    
21.                         sop("\n");
    
22.                 }
    
23.                 num-=2;
    
24.         }
    
25.         //打印矩形
    
26.         public static void ju()
    
27.         {
    
28.                 for(int m=0;m<chang;m++)
    
29.                 {
    
30.                         myFor(chang," ");
    
31.                         myFor(chang,"*");
    
32.                         sop("\n");
    
33.                 }
    
34.         }
    
35.         //for循环
    
36.         public static void myFor(int x,Object y)
    
37.         {
    
38.                 for(int i=0;i<=x;i++)
    
39.                 {
    
40.                         sop(y);
    
41.                 }
    
42.         }
    
43.         //打印
    
44.         public static void sop(Object obj)
    
45.         {
    
46.                 out.print(obj);
    
47.         }
    
48. }

复制代码

1. 基本实现了能动态打印树，可根据自己想要的结果打印，但只能倒着打印。
   
2. 树干不太容易控制，但基本还能看。
   
3. 
   
4. <div class="blockcode"><blockquote>import java.util.ArrayList;
   
5. class Tree{
   
6.         private static ArrayList<Integer> al = new ArrayList<Integer>();
   
7.         /*
   
8.          * 用一个集合记录每次打印树尖的位置，主要是要用第一次打印的位置
   
9.          */
   
10.         public static void main(String[] args){
    
11.                 printTree(8);
    
12.                 printTree(6);
    
13.                 printGan(6);
    
14.         }
    
15.         public static void printTree(int e){
    
16.                 for(int i=0;i<e;i++){
    
17.                         if(al.size()==0){        //al.size()==0,表示是第一次打印树
    
18.                                 for(int j=0;j<e-i-1;j++){
    
19.                                         System.out.print(" ");
    
20.                                 }
    
21.                         }else{ //如果不是第一次打印，那么就根据第一次打印树的位置来判断这次需要多少空格
    
22.                                 int a = al.get(0)-e;
    
23.                                 for(int j=0;j<e-i-1+a;j++){
    
24.                                         System.out.print(" ");
    
25.                                 }
    
26.                         }
    
27.                         for(int j=0;j<=i;j++){
    
28.                                 System.out.print("* ");
    
29.                         }
    
30.                         System.out.println();
    
31.                 }
    
32.                 al.add(e);                //记录该次打印树尖的位置
    
33.         }
    
34.         public static void printGan(int k){
    
35.                 int j = al.get(0) - (k/2);
    
36.                 for(int m=0;m<k;m++){ //底层
    
37.                        
    
38.                         for(int i=0;i<j;i++){        //控制树干前面打印的空格数
    
39.                                 System.out.print(" ");
    
40.                         }
    
41.                        
    
42.                         for(int n=0;n<k;n++){
    
43.                                 System.out.print("*");
    
44.                         }
    
45.                         System.out.println();
    
46.                 }
    
47.         }
    
48. }

复制代码

咳咳，让专业的来，我点评一下，撸主这完全是C代码的风格，可能是收了某高校谭姓教授的书籍的印象，变量的命令各种a，b，c的这样取，这样在java里面是不科学的，光少的写法单纯使用了extract method的重构办法，虽然一定程度改善了代码，但是感觉还是有些欠妥~阳少的那几个if条件语句让我有一种淡淡的忧伤~~

我下面的这种是面向对象的常规思维~~

1. 
   
2. public class Tree {
   
3. 
   
4. public static void main(String[] args) {
   
5. 
   
6. Triangle triangle1 = new Triangle(10,-1);
   
7. Triangle triangle2 = new Triangle(8,1);
   
8. Triangle triangle3 = new Triangle(6,3);
   
9. Rectangle rectangle = new Rectangle(6,5);
   
10. 
    
11. triangle1.show();
    
12. triangle2.show();
    
13. triangle3.show();
    
14. rectangle.show();
    
15. }
    
16. }
    
17. 
    
18. class Triangle{
    
19. 
    
20. private int size;
    
21. private int len;//为了对齐的偏移量，应该有某种数学规律，但是我没有总结出来，就穿死数字进去吧
    
22. 
    
23. public Triangle(int size, int len) {
    
24. this.size = size;
    
25. this.len = len;
    
26. }
    
27. 
    
28. public void setLevel(int size) {
    
29. this.size = size;
    
30. }
    
31. 
    
32. public void show() {
    
33. 
    
34. for (int i = 0; i < this.size; i++) {
    
35. 
    
36. for (int j = 0; j < this.size - i + len; j++) {
    
37. System.out.print(" ");
    
38. }
    
39. for (int j = 0; j <= i; j++) {
    
40. System.out.print("* ");
    
41. }
    
42. System.out.println();
    
43. }
    
44. 
    
45. }
    
46. }
    
47. 
    
48. class Rectangle{
    
49. 
    
50. private int with;
    
51. private int height;
    
52. 
    
53. public Rectangle(int with, int height) {
    
54. this.with = with;
    
55. this.height = height;
    
56. }
    
57. 
    
58. public void show(){
    
59. 
    
60. for (int i = 0; i < height; i++) { // 底层
    
61. System.out.print(" ");
    
62. for (int j = 0; j < with; j++) {
    
63. System.out.print("*");
    
64. }
    
65. System.out.println();
    
66. }
    
67. }
    
68. 
    
69. }

复制代码

这里我插一句，我对于毕老师的关于抽取的System.out.println()方法的做法持保留态度，这样做的优点是可以少写几个字母，可是~~那是你以为~~~~

如果你使用的是eclipse系列的神器的话，手打 sys 然后Alt+/



你会发现我们也只要打三个字母，而且还不影响程序可读性~~

丘凤光 发表于 2013-4-9 01:08
弄了老久，这样应该差不多了吧.。能封装的都尽量封装了，最主要的是数的大小可控制，树冠层数可以控制，只 ...

谢谢哈，看起来，舒服多了。

黄小贝 发表于 2013-4-9 04:29
咳咳，让专业的来，我点评一下，撸主这完全是C代码的风格，可能是收了某高校谭姓教授的书籍的印象，变量的 ...

谢谢。还有，你起来的好早啊。

赵家阳 发表于 2013-4-9 04:27

思路很清晰， 谢了。

叼炸了........

给你奉上代码

1. public class ChristmasTree {
   
2. 
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 printTree(6,10,0);
   
6.                 printTree(8,10,2);
   
7.                 printTree(10,10,4);
   
8.                 printlRec(10,10);
   
9.         }
   
10.         public static void printTree(int rol,int offset,int Init)
    
11.         {
    
12.                 for(int i=0;i<rol;i++)
    
13.                 {
    
14.                         if(i<Init) continue;
    
15.                         for(int j=0;j<offset-i;j++)
    
16.                         {
    
17.                                 System.out.print(" ");
    
18.                         }
    
19.                         for(int j=0;j<=i;j++)
    
20.                         {
    
21.                                 System.out.print("* ");
    
22.                         }
    
23.                         System.out.println();
    
24.                 }
    
25.         }
    
26.         public static void printlRec(int rol,int offset)
    
27.         {
    
28.                 for(int i=0;i<rol/2;i++)
    
29.                 {
    
30.                         for(int j=0;j<rol/2*1.5;j++)
    
31.                         {
    
32.                                 System.out.print(' ');
    
33.                         }
    
34.                         for(int j=0;j<rol/2;j++)
    
35.                         {
    
36.                                 System.out.print("*");
    
37.                         }
    
38.                         System.out.println();
    
39.                 }
    
40.         }
    
41. }

复制代码

我就不给你注释解释了哈哈 ....

1. class Print
   
2. {
   
3.         public static void printTree(int rol,int offset,int Init)
   
4.         {
   
5.                 for(int i=0;i<rol;i++)
   
6.                 {
   
7.                         if(i<Init) continue;
   
8.                         for(int j=0;j<offset-i;j++)
   
9.                         {
   
10.                                 System.out.print(" ");
    
11.                         }
    
12.                         for(int j=0;j<=i;j++)
    
13.                         {
    
14.                                 System.out.print("* ");
    
15.                         }
    
16.                         System.out.println();
    
17.                 }
    
18.         }
    
19.         public static void printlRec(int rol,int offset)
    
20.         {
    
21.                 for(int i=0;i<rol/2;i++)
    
22.                 {
    
23.                         for(int j=0;j<rol/2*1.5;j++)
    
24.                         {
    
25.                                 System.out.print(' ');
    
26.                         }
    
27.                         for(int j=0;j<rol/2;j++)
    
28.                         {
    
29.                                 System.out.print("*");
    
30.                         }
    
31.                         System.out.println();
    
32.                 }
    
33.         }
    
34. }
    
35. public class ChristmasTree {
    
36. 
    
37.         public static void main(String[] args)
    
38.         {
    
39.                 Print print = new Print();
    
40.                 print.printTree(6,10,0);
    
41.                 print.printTree(8,10,2);
    
42.                 print.printTree(10,10,4);
    
43.                 print.printlRec(10,10);
    
44.         }
    
45. }

复制代码

为了避免有c语言风格....

1. package exercises;
   
2. 
   
3. public class MerryTest {
   
4.         public static void main(String[] args){
   
5.                 triangle(10,3,5);//给定三个条件，num:打印树形的长度，cas:打印次数，cols：树体长度
   
6.         }
   
7.         public static void triangle(int num,int cas,int cols){//
   
8.                 char spa=32;
   
9.                 char star=32;
   
10.                 int count=num;
    
11.                 for(int c=0;c<cas;c++,num-=2){//输出树体部分
    
12.                         for(int i=num,nums=count;i>0;){
    
13.                                 for(int s=0;s<nums;s++)
    
14.                                         System.out.print(spa);
    
15.                                 for(int j=num;j>=i;j--){
    
16.                                         System.out.print("*"+star);
    
17.                                         if(num==6&&j==1){
    
18.                                                 num=3;
    
19.                                                 cas++;
    
20.                                                 nums=8;//
    
21.                                                 star='*';
    
22.                                         }
    
23.                                 }
    
24.                                 System.out.println();
    
25.                                 if(cas<=3){//打印三个树形，就让这些变量不改动了。
    
26.                                         nums--;
    
27.                                         i--;
    
28.                                 }else cols--;
    
29.                                 if(cols<0)//跳出条件，不然会死循环
    
30.                                         return ;
    
31.                         }
    
32.                 }
    
33.         }
    
34. }//一个循环体解决，尽可能减少了循环次数。小题目就不考虑面向对向封装类了。里面涉及了较多的条件判断。有点麻烦
    

复制代码

似水像火 发表于 2013-4-9 10:33
给你奉上代码我就不给你注释解释了哈哈 ....

够屌。。。。。。:lol

赵家阳 发表于 2013-4-9 13:26
够屌。。。。。。

献丑了....

HM刘俊 发表于 2013-4-9 08:39
谢谢。还有，你起来的好早啊。

那时候还没有睡，我现在才起床~~~

黄小贝 发表于 2013-4-9 16:38
那时候还没有睡，我现在才起床~~~

你这作息时间真吊。传说中的通宵啊。