05_方法、数组（一维）

 1 /*
 2     方法：完成特定功能的代码块。
 3     
 4     注意：在很多语言里面有函数的定义，而在Java中函数被称为方法。
 5 
 6     方法格式：
 7         修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
 8             方法体语句;
 9             return 返回值; 
10         }
11     详细解释：
12         修饰符：目前就用 public static。后面我们再详细的讲解其他的修饰符。
13         返回值类型：就是功能结果的数据类型。
14         方法名：符合命名规则即可。方便我们的调用。
15         参数：
16             实际参数：就是实际参与运算的。
17             形式参数；就是方法定义上的，用于接收实际参数的。
18         参数类型：就是参数的数据类型
19         参数名：就是变量名
20         方法体语句：就是完成功能的代码。
21         return：结束方法的。
22         返回值：就是功能的结果，由return带给调用者。
23         
24     要想写好一个方法，就必须明确两个东西：
25         A:返回值类型
26             结果的数据类型
27         B:参数列表
28             你要传递几个参数，以及每个参数的数据类型
29             
30     需求：求两个数据之和的案例
31     
32     方法的执行特点：
33         不调用，不执行。
34         
35     如何调用呢?(有明确返回值的调用)
36         A:单独调用,一般来说没有意义，所以不推荐。
37         B:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。
38         C:赋值调用,推荐方案。
39         
40 */
41 class FunctionDemo {
42     public static void main(String[] args) {
43         int x = 10;
44         int y = 20;
45         
46         //方式1：单独调用
47         //sum(x,y);
48     
49         //方式2：输出调用
50         //System.out.println(sum(x,y));
51         //System.out.println(30);
52     
53         //方式3：赋值调用
54         int result = sum(x,y);
55         //result在这里可以进行操作
56         System.out.println(result);
57     }
58     
59     /*
60         需求：求两个数据之和的案例
61         
62         两个明确：
63             返回值类型：int
64             参数列表：2个，都是int类型。
65     */
66     public static int sum(int a,int b) {
67             //如何实现呢?
68             //int c = a + b;
69             //return c;
70             
71             //c就是a+b,所以，我可以直接返回a+b
72             return a + b;
73     }
74     
75 }

 1 /*
 2     方法的注意事项：
 3         A:方法不调用不执行
 4         B:方法与方法是平级关系，不能嵌套定义
 5         C:方法定义的时候参数之间用逗号隔开
 6         D:方法调用的时候不用在传递数据类型
 7         E:如果方法有明确的返回值，一定要有return带回一个值
 8 */
 9 class FunctionDemo2 {
10     public static void main(String[] args) {
11         /*
12         错误的
13         public static int sum(int a,int b){
14             return a + b;
15         }
16         */
17         
18         //sum(10,20);
19         
20         //int x = 10;
21         //int y = 20;
22         //错误
23         //sum(int x,int y);
24     }
25     
26     public static int sum(int a,int b){
27         return a + b;
28     }
29 }

 1 /*
 2     需求：在控制台输出如下的形状
 3         *****
 4         *****
 5         *****
 6         *****
 7         
 8     void类型返回值的方法调用：
 9         单独调用
10         输出调用(错误)
11         赋值调用(错误)
12 */
13 class FunctionDemo3 {
14     public static void main(String[] args) {
15         //for循环嵌套输出图形
16         for(int x=0; x<4; x++) {
17             for(int y=0; y<5; y++) {
18                 System.out.print("*");
19             }
20             System.out.println();
21         }
22         System.out.println("--------------");
23         
24         //需求：我要在控制台输出一个6行7列的星形图形
25         for(int x=0; x<6; x++) {
26             for(int y=0; y<7; y++) {
27                 System.out.print("*");
28             }
29             System.out.println();
30         }
31         System.out.println("--------------");
32         
33         //如果需要继续改变，我们就应该考虑使用方法改进。
34         //单独调用
35         pringXing(3,4);
36         System.out.println("--------------");
37         pringXing(6,7);
38         System.out.println("--------------");
39         pringXing(8,9);
40         
41         //输出调用
42         //此处不允许使用 ‘空‘ 类型
43         //System.out.println(pringXing(3,4));
44         
45         //赋值调用
46         //非法的表达式开始
47         //void v = pringXing(3,4);
48     }
49     
50     /*
51         写一个什么样子的方法呢?写一个m行n列的代码
52         
53         两个明确：
54             返回值类型：这个时候没有明确的返回值，不写东西还不行，所以，这里记住是void
55             参数列表：int m,int n
56     */
57     public static void pringXing(int m,int n) {
58         for(int x=0; x<m; x++) {
59             for(int y=0; y<n; y++) {
60                 System.out.print("*");
61             }
62             System.out.println();
63         }
64     }
65 }

 1 /*
 2     需求：我要求数的和
 3     
 4     我们的需求不断的发生改变，我们就对应的提供了多个求和的方法。
 5     但是呢，他们的名字是不一样的。
 6     而我们又要求方法命名做到：见名知意。
 7     但是，很明显，现在没有做到。
 8     那么，肿么办呢?
 9     针对这种情况：方法的功能相同，参数列表不同的情况，为了见名知意，Java允许它们起一样的名字。
10     
11     其实，这种情况有一个专业名词：方法重载。
12     
13     方法重载：
14         在同一个类中，方法名相同，参数列表不同。与返回值类型无关。
15         
16         参数列表不同：
17             A:参数个数不同
18             B:参数类型不同
19 */
20 class FunctionDemo4 {
21     public static void main(String[] args) {
22         //jvm会根据不同的参数去调用不同的功能
23         System.out.println(sum(10,20));
24         System.out.println(sum(10,20,30));
25         System.out.println(sum(10,20,30,40));
26         
27         System.out.println(sum(10.5f,20f));
28     }
29     
30     //需求1:求两个数的和
31     public static int sum(int a,int b) {
32         System.out.println("int");
33         return a + b;
34     }
35     
36     //需求2:求三数的和
37     /*
38     public static int sum1(int a,int b,int c) {
39         return a + b + c;
40     }
41     */
42     
43     public static int sum(int a,int b,int c) {
44         return a + b + c;
45     }
46     
47     //需求3:求四个数的和
48     /*
49     public static int sum2(int a,int b,int c,int d) {
50         return a + b + c + d;
51     }
52     */
53     public static int sum(int a,int b,int c,int d) {
54         return a + b + c + d;
55     }
56     
57     public static float sum(float a,float b) {
58         System.out.println("float");
59         return a + b;
60     }
61 }

 1 /*
 2     键盘录入两个数据，返回两个数中的较大值
 3 */
 4 import java.util.Scanner;
 5 
 6 class FunctionTest {
 7     public static void main(String[] args) {
 8         //创建键盘录入对象
 9         Scanner sc = new Scanner(System.in);
10         
11         System.out.println("请输入第一个数据:");
12         int a = sc.nextInt();
13         
14         System.out.println("请输入第二个数据:");
15         int b = sc.nextInt();
16         
17         int result = getMax(a,b);
18         System.out.println("较大值是："+result);
19     }
20     
21     /*
22         需求：两个数中的较大值
23         两个明确：
24             返回值类型：int
25             参数列表：int a,int b            
26     */
27     public static int getMax(int a,int b) {
28         //if语句
29         /*
30         if(a > b) {
31             //System.out.println(a);
32             return a;
33         }else {
34             //System.out.println(b);
35             return b;
36         }
37         */
38         
39         //用三元改进
40         //int c = ((a > b)? a: b);
41         //return c;
42         
43         //由于c就是后面的式子
44         return ((a>b)? a : b);
45     }
46 }

 1 /*
 2     键盘录入两个数据，比较两个数是否相等
 3     
 4     分析：
 5         比较两个数是否相等结果是一个boolean类型。
 6 */
 7 import java.util.Scanner;
 8 
 9 class FunctionTest2 {
10     public static void main(String[] args) {
11         //创建键盘录入对象
12         Scanner sc = new Scanner(System.in);
13         
14         System.out.println("请输入第一个数据:");
15         int a = sc.nextInt();
16         
17         System.out.println("请输入第二个数据:");
18         int b = sc.nextInt();
19         
20         boolean flag = compare(a,b);
21         System.out.println(flag);
22     }
23     
24     /*
25         需求：比较两个数是否相等
26         两个明确：
27             返回值类型：boolean
28             参数列表：int a,int b
29     */
30     public static boolean compare(int a,int b) {
31         //if语句的格式2实现
32         /*
33         if(a == b) {
34             return true;
35         }else {
36             return false;
37         }
38         */
39         
40         //三元改进
41         //boolean flag = ((a==b)? true: false);
42         //return flag;
43         
44         //继续改进
45         //return ((a==b)? true: false);
46         
47         //最终版
48         return a == b;
49     }
50 }

/*
    键盘录入三个数据，返回三个数中的最大值
*/
import java.util.Scanner;

class FunctionTest3 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        
        System.out.println("请输入第一个数据:");
        int a = sc.nextInt();
        
        System.out.println("请输入第二个数据:");
        int b = sc.nextInt();
        
        System.out.println("请输入第三个数据:");
        int c = sc.nextInt();
        
        int max = getMax(a,b,c);
        System.out.println("三个数据中的最大值是："+max);
    }
    
    /*
        需求；返回三个数中的最大值
        
        两个明确：
            返回值类型：int
            参数列表：int a,int b,int c
    */
    public static int getMax(int a,int b,int c) {
        //if嵌套
        /*
        if(a > b) {
            if(a > c) {
                return a;
            }else {
                return c;
            }
        }else {
            if(b > c) {
                return b;
            }else {
                return c;
            }
        }
        */
        
        //用三元改
        /*
        if(a > b) {
            return (a>c? a: c);
        }else {
            return (b>c? b: c);
        }
        */
        
        //继续改进
        //return (a>b)? (a>c? a: c): (b>c? b: c);
        //不建议，写代码一定要注意阅读性强
        int temp = ((a>b)? a: b);
        int max = ((temp>c)? temp: c);
        return max;
    }
}

 1 /*
 2     键盘录入行数和列数，输出对应的星形
 3 */
 4 import java.util.Scanner;
 5 
 6 class FunctionTest4 {
 7     public static void main(String[] args) {
 8         //创建键盘录入对象
 9         Scanner sc = new Scanner(System.in);
10         
11         System.out.println("请输入行数：");
12         int m = sc.nextInt();
13         
14         System.out.println("请输入列数：");
15         int n = sc.nextInt();
16         
17         //void类型的方法调用
18         pringXing(m,n);
19     }
20     
21     /*
22         输出星形
23         
24         两个明确：
25             返回值类型：void
26             参数列表：int m,int n
27     */
28     public static void pringXing(int m,int n) {
29         for(int x=0; x<m; x++) {
30             for(int y=0; y<n; y++) {
31                 System.out.print("*");
32             }
33             System.out.println();
34         }
35     }
36 }

 1 /*
 2     键盘录入一个数据n(1<=n<=9)，输出对应的nn乘法表
 3 */
 4 import java.util.Scanner;
 5 
 6 class FunctionTest5 {
 7     public static void main(String[] args) {
 8         //创建对象
 9         Scanner sc = new Scanner(System.in);
10         
11         System.out.println("请输入n的值：(1~9)");
12         int n = sc.nextInt();
13         
14         //调用
15         printNN(n);
16     }
17     
18     /*
19         需求：输出对应的nn乘法表
20         两个明确：
21             返回值类型：void
22             参数列表：int n
23     */
24     public static void printNN(int n) {
25         for(int x=1; x<=n; x++) {
26             for(int y=1; y<=x; y++) {
27                 System.out.print(y+"*"+x+"="+y*x+"\t");
28             }
29             System.out.println();
30         }
31     }
32 }

 1 /*
 2     比较两个数据是否相等。参数类型分别为
 3         两个byte类型，两个short类型，两个int类型，两个long类型，
 4     并在main方法中进行测试
 5 */
 6 class FunctionTest6 {
 7     public static void main(String[] args) {
 8         //测试
 9         byte b1 = 3;
10         byte b2 = 4;
11         System.out.println("byte:"+compare(b1,b2));
12         
13         //测试
14         short s1 = 5;
15         short s2 = 5;
16         System.out.println("short:"+compare(s1,s2));
17         
18         //后面的两个自己测试
19     }
20     
21     //byte类型
22     public static boolean compare(byte a,byte b) {
23         System.out.println("byte");
24         return a == b;
25     }
26     
27     //short类型
28     public static boolean compare(short a,short b) {
29         System.out.println("short");
30         return a == b;
31     }
32     
33     //int类型
34     public static boolean compare(int a,int b) {
35         System.out.println("int");
36         return a == b;
37     }
38     
39     //long类型
40     public static boolean compare(long a,long b) {
41         System.out.println("long");
42         return a == b;
43     }
44 }