学习如何面向接口开发

面向接口开发流程
(1) 定义接口时，需要定义方法名，但无需实现。所有开发人员必须根据接口进行开发。继承是单继承，通过串联实现多继承。接口可以用于开发不同模块，实现多继承。不需要实现的方法只要限制方法名，无需编写方法体。

(2) 如果某些方法无法确定如何实现，Java提供了关键字"abstract"来定义抽象方法。有抽象方法的类就是抽象类，需用"abstract"修饰。抽象类不能被实例化，其中的方法也不能被调用。修改功能时，可以通过继承类并使用"super"引用父类代码来优化代码。

(3) 对于算法类或工具类，无需实例化，可将类标记为"static"，使其成为静态类。静态类无需实例化，可直接使用类名.方法来访问。静态类具有运算速度快、在内存中最先执行的特点。

(4) 根据面向对象的设计方法进行封装、继承和多态的考虑。

(5) 实际执行的每个方法中的代码仍然是面向过程的。

面向接口开发的模式来改写剪刀石头布
定义接口

public interface Joiner {
    //只定义方法，不需要实现
    public void choice();
    public void name_settings();
}

定义了一个抽象类Player，实现了Joiner接口。Player类有两个私有属性，name和choice_name，分别表示玩家的姓名和选择。接着定义了两个构造方法，一个是无参构造方法，另一个是带有name和choice_name参数的构造方法。接下来是一个抽象方法choice()，使用了@Override注解，表示该方法需要在子类中实现。然后是Joiner接口中的name_settings()方法的实现，用来初始化玩家的姓名。接着是name和choice_name属性的setter和getter方法。最后重写了toString()方法，用来打印Player对象的内容。

public abstract class Player implements Joiner{
    private String name;
    private int choice_name;
    //2、做无参和有参构造
    public Player() {
    }
    public Player(String name, int choice_name) {
        this.name = name;
        this.choice_name = choice_name;
    }
    //被abstract修饰的方法不需要实现
    @Override
    public abstract void choice();
    //抽象方法完成了name的初始化
    @Override
    public void name_settings() {
        this.setName("匿名用户");
    }
    //1、做setter和getter方法

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getChoice_name() {
        return choice_name;
    }

    public void setChoice_name(int choice_name) {
        this.choice_name = choice_name;
    }
    //3、重写类打印出内容的toString方法

    @Override
    public String toString() {
        return "Player{" +
                "name='" + name + '\'' +
                ", choice_name=" + choice_name +
                '}';
    }
}

import java.util.Scanner;

public class MyPlayer extends Player{

    @Override
    public void choice() {
        System.out.println("*****************");
        System.out.println("1-----剪刀");
        System.out.println("2-----石头");
        System.out.println("3-----布");
        System.out.println("*****************");
        System.out.println("请选择出拳名称代表数字:");
        Scanner scanner = new Scanner(System.in);
        //这里直接接收数字,考虑nextInt可能报错
        System.out.println("注意：必须输入内容,然后再回车，不能是空格加回车，否则程序执行不下去");
        try{
            int tmp=scanner.nextInt();
            this.setChoice_name(tmp);
        }catch(Exception e){
            this.setChoice_name((int)(Math.random()*3+1));
        }
    }
    //为了防止匿名用户，还需要重写name的命名方法

    @Override
    public void name_settings() {
        super.name_settings();
        System.out.println("请输入玩家名称:");
        Scanner scanner = new Scanner(System.in);
        //这个名称允许空格,但是空格后回车，如果接受是空的，空的没有意义
        //属次调用scanner.nextLine()一直接收屏幕输入，只输入一次
        //这里只有变量接收一次
        String line=scanner.nextLine();
        if (!line.trim().equals("")) {
            this.setName(line);
        }
    }
}

定义了一个名为MyPlayer的类，该类继承自前面提到的Player类。在MyPlayer类中，重写了Player类中的抽象方法choice()和name_settings()。在choice()方法中，首先输出了一个选择菜单，然后通过Scanner类接收用户输入的数字，并根据用户输入设置了玩家的选择。如果输入发生异常，则通过Math.random()方法随机生成一个1到3之间的数字作为选择。在name_settings()方法中，首先调用了父类的name_settings()方法，然后提示用户输入玩家名称，并通过Scanner类接收用户输入的名称，如果输入的名称不为空格，则设置为玩家的姓名。
MyPlayer类实现了Player类中定义的抽象方法，并提供了自定义的选择和命名逻辑。

/*
裁判类
 */
public  class Judge {
    //判断输赢的方法，方法需要两个角色，这个角色就是方法的参数
    public static  void judge_winner(MyPlayer player,MyComputer computer){
        //可以用减差来判断胜负
        int sub_player=player.getChoice_name()-computer.getChoice_name();
        //通过减值得到结果是 sub_player是1  0 2  -1 -2
        // 0 1   　考虑数组的角标，０值永远都是平局，０数组中的第一个元素，1就是数组中的赢
        //值是2   　对应数组中的输
        //-1 arrs[-1] 0 -1　-2  应用到电脑中没有问题
        String[] arrs= {"平局","赢","输"};
        try{
            System.out.println("玩家"+arrs[sub_player]);
        }catch(Exception e){
            //电脑应用Math.abs绝对值函数，
            System.out.println("电脑"+arrs[Math.abs(sub_player)]);
        }
        System.out.println("双方出牌情况");
        String[] player_choices={"剪刀","石头","布"};
        System.out.println("玩家出拳:"+player_choices[player.getChoice_name()-1]);
        System.out.println("电脑出拳："+player_choices[computer.getChoice_name()-1]);

    }
}

定义了一个名为MyComputer的类，该类同样继承自Player类。在MyComputer类中，重写了Player类中的choice()和name_settings()方法。在choice()方法中，通过Math.random()方法随机生成一个1到3之间的数字，并将其设置为电脑的选择。在name_settings()方法中，首先调用了父类的name_settings()方法，然后输出了一个供用户选择的电脑名称菜单，通过Scanner类接收用户输入的编号，并根据用户选择设置电脑的名称。
MyComputer类实现了Player类中定义的抽象方法，提供了自定义的选择和命名逻辑，同时保证了不会出现匿名用户。

import java.util.Scanner;

public class MyComputer extends Player {
    @Override
    public void choice() {
        //电脑随机1,2,3
        this.setChoice_name((int)(Math.random()*3+1));
    }
    //还有一个方法没有重写，参与用户一直是匿名用户
    //防止用户参与是匿名用户
    @Override
    public void name_settings() {
        super.name_settings();
        String[] computer_names={"蜡笔小新","葫芦娃"};
        System.out.println("****************");
        System.out.println("1----蜡笔小新");
        System.out.println("2----葫芦娃");
        System.out.println("****************");
        System.out.println("请选择对阵的英雄编号");
        Scanner scanner = new Scanner(System.in);
        System.out.println("注意：必须输入内容,然后再回车，不能是空格加回车，否则程序执行不下去");
        try{
            //把scanner的nextInt先接收一下
            int tmp=scanner.nextInt();
            this.setName(computer_names[tmp-1]);
        }catch(Exception e ) {

        }
    }
}

主类，调用其他类的方法

import java.util.Scanner;

public class MyMain {
    public static void main(String[] args) {
        MyComputer mycomputer=new MyComputer();
        MyPlayer myplayer=new MyPlayer();
        //按照游戏逻辑，调用类中的方法进行串联。
        //如果调用中的相关问题，那就是类中的方法有问题
        //可以显示一个菜单
        System.out.println("*************************");
        System.out.println("　游戏：剪刀石头布");
        System.out.println("************************");
        //输入回车后，游戏开始
        System.out.println("输入回车后，游戏开始");
        Scanner scanner = new Scanner(System.in);
        scanner.nextLine();
        System.out.println("游戏开始.......");
        //开始逻辑
        //定义玩家名称
        myplayer.name_settings();
        //选择电脑参与作战者
        mycomputer.name_settings();
        //调用player的出拳
        myplayer.choice();
        //调用电脑computer的出拳
        mycomputer.choice();
        //调用对应的裁判类，进行裁决。这里的裁决类是一个工具类，工具类不需要,类似于Math类
        Judge.judge_winner(myplayer,mycomputer);
    }
}