在线午夜精品自拍小视频_无码av无码专区线_亚洲无码精品人妻_人人澡欧美一区

子函數(shù)：

馬克- to-win：馬克 java社區(qū)：防盜版實名手機尾號： 73203。
馬克-to-win：我把去頤和園路線寫在紅紙上，去北海的方法寫在黃紙上，我要讓你去頤和園兩次，去北海三次的話，只需讓按紅紙做兩次，按黃紙做三次，這里誰是子涵數(shù)？
例1：
public class Test14 {
    public static void main(String[] args) {
        printqijin();
        printyangwen();
        printqijin();
    }
    static void printqijin() {
        int i = 0;
        while (i < 2) {
            System.out.println("齊井");
            i++;
        }
    }
    static void printyangwen() {
        System.out.println("揚");
    }
}
結果：
齊井
齊井
揚
齊井
齊井

馬 克-to-win：程序就是人要告訴計算機干什么的一堆指令。計算機拿到這堆指令，開始干活。從main左括號開始，運行到右括號就結束。像if, main,int這些字，計算機都很好理解，但是一遇到子函數(shù)計算機就傻了，因為他不認識這些字，它就開始整個程序找這個子函數(shù)體，找到后就調(diào)用，如有實 參，就把實參值傳給形參。調(diào)用完就回到主函數(shù)中剛才調(diào)用的那一句的下一句。如有return，子函數(shù)中return值會給函數(shù)名對應的等號左邊的值，子函 數(shù)當即終止，即執(zhí)行子函數(shù)右大括號。在上個例子中，void表示沒有返回值。

例2：
給定整數(shù)返回平方
public class Test15 {
    public static void main(String[] args) {
        int a;
        int d;
        a = fff(2);
        System.out.println(a);
        d = fff(3);
        System.out.println(d);
    }
    static int fff(int b) {
        int c;
        c = b * b;
        return c;
    }
}
結果：
4
9

例3：
public class Test16 {
    public static void main(String[] args) {
        String a;
        String b;
        a = zhazhi("蘋果");
        b = zhazhi("桃");
        System.out.println(a);
        System.out.println(b);
    }

    static String zhazhi(String k) {
        String l;
        l = k + "汁";
        return l;
    }
}
結果：
蘋果汁
桃汁

作業(yè)1： 做一個子函數(shù)返回比自己大1的數(shù)。

public class Test17 {
    public static void main(String[] args) {
        int a;
        int b;
        a = hhh(5);
        b = hhh(4);
        System.out.println(a);
        System.out.println(b);
    }

    static int hhh(int c) {
        int d;
        d = c + 1;
        return d;
    }
}
結果：
6
5


小結：實參有兩種：馬克-to-win：（1）普通值比如int（2）數(shù)組類型，當是數(shù)組類型時（比如實參是a[],虛參是c[]），虛參指向?qū)崊⒌牡刂?，如c指向a。
調(diào)用：是指發(fā)現(xiàn)不認識函數(shù)名找到函數(shù)體，開始執(zhí)行函數(shù)體，這個過程叫調(diào)用，其實調(diào)用本質(zhì)就是用函數(shù)體替代掉函數(shù)名那句話而已。這樣主函數(shù)就會非常清晰。




作業(yè)2： 翻倍打印，復制數(shù)組

public class Test19 {
    public static void main(String[] args) {
        int a[] = { 7, 4, 3, 2, 5 };
        fanbei(a);
        dayin(a);
    }
   
    static void fanbei(int[] b) {
        int i = 0;
        while (i < b.length) {
            b[i] = b[i] * 2;
            i++;
        }
    }

    static void dayin(int[] c) {
        int j = 0;
        while (j < c.length) {
            System.out.println(c[j]);
            j++;
        }
    }
}
結果：
14
8
6
4
10



作業(yè)3： 求數(shù)組的長度

public class Test20 {
    public static void main(String[] args) {
        int a[] = { 3, 2, 1, 7 };
        int b;
        b = hh(a);
        System.out.println(b);
    }

    static int hh(int[] c) {
        int d;
        d = c.length;
        return d;
    }
}
結果：
4


作業(yè)4： 求數(shù)組中最大數(shù)
public class Test21 {
    public static void main(String[] args) {
        int a[] = { 5, 8, 7, 4 };
        int b;
        b = kk(a);
        System.out.println(b);
    }

    static int kk(int[] c) {
        int d = c[0];
        int i = 0;
        while (i < c.length) {
            {
                if (c[i] > d)
                    d = c[i];
            }
            i++;
        }
        System.out.println(d);
        return d;
    }
}
結果：
8
8



作業(yè)5：求數(shù)組中最小數(shù)
public class Test23 {
    public static void main(String[] args) {
        int a[] = { 3, 5, 2, 7 };
        int i = 0;
        int c = a[0];
        while (i < a.length) {
            if (a[i] < c) {
                c = a[i];
            }
            i++;
        }
        System.out.println(c);
    }
}
結果：
2

作業(yè)6：求數(shù)組中第一個數(shù)。
public class Test24 {
    public static void main(String[] args) {
        int a[] = { 3, 2, 1, 7 };
        int b;
        b = hhh(a);
        System.out.println(b);
    }

    static int hhh(int[] c) {
        int d;
        d = c[0];
        return d;
    }
}
結果：
3






作業(yè)7：找大數(shù)位置
public class Test26 {
    public static void main(String[] args) {
        int a[] = { 4, 7, 8, 6 };
        int b;
        b = findbigweizhi(a);
        System.out.println(b);
    }

    static int findbigweizhi(int[] c) {
        int i = 0;
        int d = c[0];
        int p = 0;
        while (i < c.length) {
            if (c[i] > d) {
                d = c[i];
                p = i;
            }
            i++;
        }
        System.out.println(d);
        System.out.println(p);
        return p;
    }
}
結果:
8
2
2



作業(yè)8：找大數(shù)
public class Test29 {
    public static void main(String[] args) {
        int a = 8;
        int b = 7;
        int c = 9;
        int k = zhaodashu(a, b, c);
        System.out.println(k);
    }

    static int zhaodashu(int x, int y, int z) {
        int big;
        big = x;
        if (y > big) {
            big = y;
        }
        if (z > big) {
            big = z;
        }
        return big;
    }
}
結果：
9



作業(yè)9：馬克-to-win：給定一個整數(shù)，數(shù)組和一個整數(shù)值，用子函數(shù)判斷，此數(shù)組中是否包含此整數(shù)值？如果不包含返回-1，如果包含返回位置。比如：如果第一個值就等于它就返回0。

public class Test30 {
    public static void main(String[] args) {
        int a[] = { 5, 6, 7, 3, 9 };
        int m = 7;
        int b;
        b = zhaoweizhi(a, m);
        System.out.println(b);
    }

    static int zhaoweizhi(int[] c, int m) {
        int i = 0;
        while (i < c.length) {
            if (c[i] == m) {
                return i;
            }
            i++;
        }
        return -1;
    }
}
結果：
2






馬 克-to-win：例：排序，替換大數(shù)。第一步找出最小的數(shù)3給m。第二步開始循環(huán)做a.length次，這里就是4。舉例這里做4次，找出最大的數(shù)放在 另一個數(shù)組b中。b={8，0，0，0}。同時a中剛才最大的數(shù)變成最小的那個數(shù)m等于3，a就變成a={5,3,3,6}，第二次循環(huán)做同樣的事。b= {8,6,0，0}，a變成{5,3，3，3}，第三次循環(huán)做同樣的事。b={8,6,5，0}，a變成{3,3，3，3}，第四次循環(huán)做同樣的事。b= {8,6,5，3}，a變成{3,3，3，3}

public class Test32 {
    public static void main(String[] args) {
        int a[] = { 5, 8, 3, 6 };
        int b[] = { 0, 0, 0, 0 };
        int m = 3;
        int big;
        big = tihuan(a, m);
        b[0] = big;
        big = tihuan(a, m);
        b[1] = big;
        big = tihuan(a, m);
        b[2] = big;
        big = tihuan(a, m);
        b[3] = big;
        System.out.println("完了");
        int i = 0;
        while (i < 4)
        {
            System.out.println(b[i]);
            i++;
        }
    }

    static int tihuan(int[] a, int m) {
        int i = 0;
        int big = a[0];
        int p = 0;
        while (i < a.length) {
            if (a[i] > big) {
                big = a[i];
                p = i;
            }
            i++;
        }
        System.out.println(big);
        System.out.println(p);
        a[p] = m;
        return big;
    }
}
結果:
8
1
6
3
5
0
3
0
完了
8
6
5
3



作業(yè)10：用固定最小數(shù)替換數(shù)組內(nèi)大數(shù)，大數(shù)依次放在另一個數(shù)組里。
public class Test31 {
    public static void main(String[] args) {
        int a[] = { 7, 8, 4, 6 };
        int b[] = { 0, 0, 0, 0 };
        int m = 4;//數(shù)組內(nèi)最小值是4
        int i = 0;
        int big;
        while (i < 4) {
            big = tihuan(a, m);
            b[i] = big;
            i++;
        }
        System.out.println("wanle ");
        i = 0;
        while (i < 4)
        {
            System.out.println(b[i]);
            i++;
        }
    }

    static int tihuan(int[] a, int m) {
        int i = 0;
        int big = a[0];
        int p = 0;
        while (i < a.length) {
            if (a[i] > big) {
                big = a[i];
                p = i;
            }
            i++;
        }
        System.out.println(big);
        System.out.println(p);
        a[p] = m;
        return big;
    }
}
結果：
8
1
7
0
6
3
4
0
wanle
8
7
6
4