Fundamental.Unit06

达内

知识体系

方法

• 方法用于封装一段特定的逻辑功能，如执行计算或者操作
• 方法可以程序中反复调用，大量减少代码量，便于代码维护
• 方法定义的五要素：
  public static void sum(int i, int j){
//方法体
}
  修饰词 + 放回值 + 方法名 + 参数列表 + 方法体
• 注意方法参数和返回值，调用方法是传入参数，return语句返回值
• 方法调用时候：返回值 + 方法名 + 参数列表

经典案例

猜字母游戏

1. 设计数据结构

package day01;
public class GuessLettersGame {
    public static void main(String[] args) {
        //表示玩家猜测的次数
        int count =0;
        //表示用户猜测的数据
        char[] input = null;
        //表示猜测的字符串
        char[] chs = null;
        //用于保存判断的结果，result[0]表示猜对的字母个数（字符对位置也对），result[1]表示字符对位置不对的个数
        //如果用两个int型，则方法在返回值上面不好处理，好的数据结构可以带来好的算法
        int[] result = new int[2];
    }
}

1. 设计程序结构

package day01;
public class GuessLettersGame {
    public static void main(String[] args) {
        //表示玩家猜测的次数
        int count =0;
        //表示用户猜测的数据
        char[] input = null;
        //表示猜测的字符串
        char[] chs = null;
        //用于保存判断的结果，result[0]表示猜对的字母个数（字符对位置也对），result[1]表示字符对位置不对的个数
        //如果用两个int型，则方法在返回值上面不好处理，好的数据结构可以带来好的算法
        int[] result = new int[2];
    }
    /**
     * 随机生成需要猜测的字母序列
     * @return 随机生成的字符数组
     */
    public static char[] generate(){
        char[] chs = new char[5];
        return chs;
    }
    /**
     * 比较用户输入的字符数组和随机生成的字符数组
     * @param chs 随机生成的字符数组
     * @param input 用户输入的字符数组
     * @return 比较结果，对的个数
     */
    public static int[] check(char[] chs, char[] input){
        int[] result = new int[2];
        return result;
    }
}

1. 实现字母生成方法

`   /**
     * 随机生成需要猜测的字母序列
     * @return 随机生成的字符数组
     */
public static char[] generate(){
        char[] chs = new char[5];
        char[] letters = {'A','B','C','D','E','F','G',
                          'H','I','J','K','L','M','N',
                          'O','P','Q','R','S','T',
                          'U','V','W','X','Y','Z'};
        boolean[] flags = new boolean[letters.length];
        for(int i=0; i<chs.length; i++){
            int index;
            do{
                index = (int)(Math.random() * (letters.length));
            }while(flags[index]); //用来判断生成的字符是否重复
            flags[index] = true;
        }
        return chs;
    }

1. 实现字母检测方法

/**
     * 比较用户输入的字符数组和随机生成的字符数组
     * @param chs 随机生成的字符数组
     * @param input 用户输入的字符数组
     * @return 比较结果，对的个数
     */
    public static int[] check(char[] chs, char[] input){
        int[] result = new int[2];
        for(int i=0; i<input.length; i++){
            for(int j=0; j< chs.length; j++){
                if(input[i] == chs[j]){
                    result[1]++;
                    if(i == j){
                        result[0]++;
                    }
                    break;
                }
            }
        }
        return result;
    }

1. 实现主方法

package day01;
import java.util.Arrays;
import java.util.Scanner;
public class GuessLettersGame {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //表示玩家猜测的次数
        int count =0;
        //表示用户猜测的数据
        char[] input = null;
        //表示猜测的字符串
        char[] chs = null;
        //用于保存判断的结果，result[0]表示猜对的字母个数（字符对位置也对），result[1]表示字符对位置不对的个数
        //如果用两个int型，则方法在返回值上面不好处理，好的数据结构可以带来好的算法
        int[] result = new int[2];
        //先看到5个字符，好测试
        chs = generate();
        System.out.println(Arrays.toString(chs));
        System.out.println("游戏开始，请输入你猜的五个字符序列：exit退出");
        while(true){
            String inputStr = scan.next().trim().toUpperCase();
            if("EXIT".equals(inputStr)){
                System.out.println("谢谢你的尝试，下次再来");
                break;
            }
            input = inputStr.toCharArray();
            result = check(chs,input);
            if(result[0] == chs.length){ //全对的情况下
                int score = 100 * chs.length -count *10;
                System.out.println("你全猜对了，得分是：" + score);
            }else{
                count++;
                System.out.println("你猜对了：" + result[1] + "个字符，其中有" + result[0] + "个字符的位置正确（你的猜测字数是：" + count +"）。" );
            }
        }
        scan.close();
    }
    /**
     * 随机生成需要猜测的字母序列
     * @return 随机生成的字符数组
     */
    public static char[] generate(){
        char[] chs = new char[5];
        char[] letters = {'A','B','C','D','E','F','G',
                          'H','I','J','K','L','M','N',
                          'O','P','Q','R','S','T',
                          'U','V','W','X','Y','Z'};
        boolean[] flags = new boolean[letters.length];
        for(int i=0; i<chs.length; i++){
            int index;
            do{
                index = (int)(Math.random() * (letters.length));
            }while(flags[index]); //用来判断生成的字符是否重复
            chs[i] = letters[index];
            flags[index] = true;
        }
        return chs;
    }
    /**
     * 比较用户输入的字符数组和随机生成的字符数组
     * @param chs 随机生成的字符数组
     * @param input 用户输入的字符数组
     * @return 比较结果，对的个数
     */
    public static int[] check(char[] chs, char[] input){
        int[] result = new int[2];
        for(int i=0; i<input.length; i++){
            for(int j=0; j< chs.length; j++){
                if(input[i] == chs[j]){
                    result[1]++;
                    if(i == j){
                        result[0]++;
                    }
                    break;
                }
            }
        }
        return result;
    }
}

课后作业

随机生成数组

封装一个方法generateArray()，实现生成指定长度的int数组，元素都是随机值
开始没有调用方法：

package day01;
import java.util.Arrays;
import java.util.Scanner;
public class GenerateArray {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("输入生成数组长度");
        int index = scan.nextInt();
        System.out.println("输入数组元素最大值：");
        int max = scan.nextInt();
        int[] arr = new int[index];
        for(int i=0; i<arr.length; i++){
            arr[i] = (int)(Math.random() * max + 1);    
        }
        System.out.println(Arrays.toString(arr));
    }
}

调用方法之后：

package day01;
import java.util.Arrays;
import java.util.Scanner;
public class GenerateArray {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("输入生成数组长度");
        int index = scan.nextInt();
        System.out.println("输入数组元素最大值：");
        int max = scan.nextInt();
        int[] arr = generateArray(index,max);
        System.out.println(Arrays.toString(arr));
    }
    /**
     * 生成指定长度的数组，里面元素范围也是指定
     * @param index 指定长度
     * @param max 指定范围
     * @return 产生的数组
     */
    public static int[] generateArray(int index, int max){
        int[] arr = new int[index];
        for(int i=0; i<arr.length; i++){
            arr[i] = (int)(Math.random() * max + 1);    
        }
        return arr;
    }
}

在猜字母游戏中实现游戏等级（3，5，7，9）

这个时候在写程序时候，考虑程序的扩展性

package day01;
import java.util.Arrays;
import java.util.Scanner;
public class GuessLettersGamePlus {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //表示玩家猜测的次数
        int count =0;
        //表示用户猜测的数据
        char[] input = null;
        //表示猜测的字符串
        char[] chs = null;
        //用于保存判断的结果，result[0]表示猜对的字母个数（字符对位置也对），result[1]表示字符对位置不对的个数
        //如果用两个int型，则方法在返回值上面不好处理，好的数据结构可以带来好的算法
        int[] result = new int[2];
        //接受等级g
        System.out.println("请输入游戏等级（3，5，7，9）：");
        int g = scan.nextInt();
        //先看到5个字符，好测试
        chs = generate(g);
        System.out.println(Arrays.toString(chs));
        System.out.println("游戏开始，请输入你猜的五个字符序列：exit退出");
        while(true){
            String inputStr = scan.next().trim().toUpperCase();
            if("EXIT".equals(inputStr)){
                System.out.println("谢谢你的尝试，下次再来");
                break;
            }
            input = inputStr.toCharArray();
            result = check(chs,input);
            if(result[0] == chs.length){ //全对的情况下
                int score = 100 * chs.length -count *10;
                System.out.println("你全猜对了，得分是：" + score);
            }else{
                count++;
                System.out.println("你猜对了：" + result[1] + "个字符，其中有" + result[0] + "个字符的位置正确（你的猜测字数是：" + count +"）。" );
            }
        }
        scan.close();
    }
    /**
     * 随机生成需要猜测的字母序列
     * @return 随机生成的字符数组
     */
    public static char[] generate(int g){
        char[] chs = new char[g];
        char[] letters = {'A','B','C','D','E','F','G',
                          'H','I','J','K','L','M','N',
                          'O','P','Q','R','S','T',
                          'U','V','W','X','Y','Z'};
        boolean[] flags = new boolean[letters.length];
        for(int i=0; i<chs.length; i++){
            int index;
            do{
                index = (int)(Math.random() * (letters.length));
            }while(flags[index]); //用来判断生成的字符是否重复
            chs[i] = letters[index];
            flags[index] = true;
        }
        return chs;
    }
    /**
     * 比较用户输入的字符数组和随机生成的字符数组
     * @param chs 随机生成的字符数组
     * @param input 用户输入的字符数组
     * @return 比较结果，对的个数
     */
    public static int[] check(char[] chs, char[] input){
        int[] result = new int[2];
        for(int i=0; i<input.length; i++){
            for(int j=0; j< chs.length; j++){
                if(input[i] == chs[j]){
                    result[1]++;
                    if(i == j){
                        result[0]++;
                    }
                    break;
                }
            }
        }
        return result;
    }
}