1 /*
  2     練習1：定義一個功能，獲取兩個整數中最大的數
  3     練習2：定義一個功能，判斷兩個數是否相等。
  4     練習3：定義一個功能，打印99乘法表
  5     練習4：定義一個功能，未簡化打印字符串的輸出語句
  6     每個練習之前都必須要先寫一個思路---兩個明確？
  7 
  8 */
  9 class  FunctionTest
 10 {
 11     /*
 12     練習1：定義一個功能，獲取兩個整數中最大的數
 13     思路：
 14     1，明確該功能的結果 。是一個整數。int
 15     2，明確未知內容，是兩個整數不確定，有兩個整形參數
 
 16     3，既然要獲取大的那個，可以通過比較來完成。if語句。
 17     4，通過return語句將較大的值返回。
 18 
 19     */
 20     public static int getMax(int a,int b) 
 21     {
 22         if (a>b)
 23         {
 24             return a;
 25         }
 26         else 
 27             return b;
 28         //return a>b?a:b;
 29     }
 30
 
 
 31 
 32     /*
 33     練習2：定義一個功能，判斷兩個數是否相等。
 34     思路：
 35     1，明確結果，Boolean
 36     2，未知的內容，兩個整數
 37     */
 38 
 39     public static boolean isEquals(int a,int b)
 40     {
 41         if (a>b)
 42         {
 43             return true;
 44         }
 45         else
 46             return false
 
;
 47         //return a>b?true:false;
 48         // return a>b;
 49     }
 50 
 51 
 52 
 53     /**
 54     練習3：定義一個功能，打印99乘法表
 55     思路：
 56     1，結果，沒有結果
 57     2，未知內容，沒有
 58     */
 59 
 60     public static void print99()
 61     {
 62         for (int x=1;x<=9 ;x++ )
 63         {
 64             for (int y=1;y<=a ;b++ )
 65             {
 66                 System.out.print(y+"y*x"+x+"*"+y*x"\t");
 67             }
 68             System.out.println();
 69 
 70         }
 71     }
 72 
 73 
 74     /*
 75     練習4：定義一個功能，未簡化打印字符串的輸出語句
 76     輸出語句每次書寫很麻煩。
 77     為了簡化，可以將該語句進行函數的封裝
 78     將要輸出的內容作為參數傳遞給函數即可
 79     好處：簡化了輸出語句的書寫
 80     思路：
 81     1，明確，
 82     */
 83 
 84     public static void sop(String str)
 85     {
 86         System.out.println(str);
 87     }
 88 
 89 
 90     /*
 91     通過定義主函數，讓該類運行，去驗證這個功能是否可用？
 92     */
 93     public static void main(String[] args)
 94     {
 95         int max = getMax(4,6);
 96         System.out.println("max="+max);
 97     }
 98 
 99 }/*
100     練習1：定義一個功能，獲取兩個整數中最大的數
101     練習2：定義一個功能，判斷兩個數是否相等。
102     練習3：定義一個功能，打印99乘法表
103     練習4：定義一個功能，未簡化打印字符串的輸出語句
104     每個練習之前都必須要先寫一個思路---兩個明確？
105 
106 */
107 class  FunctionTest
108 {
109     /*
110     練習1：定義一個功能，獲取兩個整數中最大的數
111     思路：
112     1，明確該功能的結果 。是一個整數。int
113     2，明確未知內容，是兩個整數不確定，有兩個整形參數
114     3，既然要獲取大的那個，可以通過比較來完成。if語句。
115     4，通過return語句將較大的值返回。
116 
117     */
118     public static int getMax(int a,int b) 
119     {
120         if (a>b)
121         {
122             return a;
123         }
124         else 
125             return b;
126         //return a>b?a:b;
127     }
128 
129 
130     /*
131     練習2：定義一個功能，判斷兩個數是否相等。
132     思路：
133     1，明確結果，Boolean
134     2，未知的內容，兩個整數
135     */
136 
137     public static boolean isEquals(int a,int b)
138     {
139         if (a>b)
140         {
141             return true;
142         }
143         else
144             return false;
145         //return a>b?true:false;
146         // return a>b;
147     }
148 
149 
150 
151     /**
152     練習3：定義一個功能，打印99乘法表
153     思路：
154     1，結果，沒有結果
155     2，未知內容，沒有
156     */
157 
158     public static void print99()
159     {
160         for (int x=1;x<=9 ;x++ )
161         {
162             for (int y=1;y<=a ;b++ )
163             {
164                 System.out.print(y+"y*x"+x+"*"+y*x"\t");
165             }
166             System.out.println();
167 
168         }
169     }
170 
171 
172     /*
173     練習4：定義一個功能，未簡化打印字符串的輸出語句
174     輸出語句每次書寫很麻煩。
175     為了簡化，可以將該語句進行函數的封裝
176     將要輸出的內容作為參數傳遞給函數即可
177     好處：簡化了輸出語句的書寫
178     思路：
179     1，明確，
180     */
181 
182     public static void sop(String str)
183     {
184         System.out.println(str);
185     }
186 
187 
188     /*
189     通過定義主函數，讓該類運行，去驗證這個功能是否可用？
190     */
191     public static void main(String[] args)
192     {
193         int max = getMax(4,6);
194         System.out.println("max="+max);
195     }
196 
197 }

java_函數的練習