java-猜数字游戏（★☆☆☆☆）

最新推荐文章于 2024-04-01 18:55:17 发布

_陈玄

最新推荐文章于 2024-04-01 18:55:17 发布

阅读量3k

点赞数

分类专栏：笔记文章标签： java

本文链接：https://blog.csdn.net/qq_44406889/article/details/123241439

版权

笔记专栏收录该内容

36 篇文章 2 订阅

订阅专栏

题目：一个类A，类中有一个实例变量v，从键盘接收一个正整数作为实例变量v的初始值，再定义一个类B，接收一个数值，对A类中的实例变量v进行猜测，如果当前数大于v，则提示“猜大了",如果当前数小于v，则提示“猜小了”，否则提示“猜测成功”。

首先对题目进行分析，共有三个类，一个A类，一个B类，一个test运行测试类

A类：变量v，v的get和set方法，无参构造方法和有参构造方法完成变量v的初始化操作

B类：与A产生关联想办法获取到A中变量v的值，构造方法，猜测的方法

那么怎么让B与A产生关联并得到在A中的变量的值呢？

可以考虑继承或者在类B中获取到一个指向A类变量的引用。

先考虑第二种情况，在B类中有一个指向A类对象的引用，从而通过引用获取到v的值以便于进行对比

那么此时的B类型：A类型的引用，引用的get和set方法，有参的构造和无参的构造方法，猜数的方法

测试类中创建A和B对象，在创建A对象的时候，通过参数传递的形式，利用构造方法，完成对变量v的初始化操作，在创建B对象的时候，通过参数传递的形式，利用构造方法，完成对实例引用类型变量赋值的过程，使其内部的一个引用指向A类对象所在的内存单元，从键盘接收一个数据，将这个数据传递到B类的内部，然后在其内部，利用引用和猜测的方法，进行对比，不同的情况有不同的输出或者返回值，如果是返回值，那么在测试类中接收当前返回值进行控制台的输出即可。

如下代码：

A类：
package data;
public class A {
    private int v;
    
    public void setV(int v){
        this.v=v;
    }
    
    public int getV(){
        return v;
    }
    
    public A(){
        
    }
    
    public A(int v){
        this.v=v;
    }
}
类B：
package data;

public class B {
    //A类型的引用
    private A a;
    //引用的get和set方法
    public A getA() {
        return a;
    }

    public void setA(A a) {
        this.a = a;
    }

    public B(){

    }
    public B(A a){
        this.a=a;
    }

    public String guess(int v){
        int data=a.getV();
        if (v>data) return "大了";
        else if (v<data)return "小了";
        else return "猜测成功";
    }
}
测试类：A类中默认值我们通过参数进行传递的，v变量的初始值设置为了18.
package data;

import java.util.Scanner;

public class test {
    public static void main(String[] args) {
        A a=new A(18);
        B b=new B(a);
        while (true) {
            System.out.print("请猜测数值：");
            Scanner in = new Scanner(System.in);
            int v = in.nextInt();
            System.out.println(b.guess(v));
        }
    }
}
输出结果：
请猜测数值：6
小了
请猜测数值：16
小了
请猜测数值：18
猜测成功
请猜测数值：
…………………………
如上，实现了这个功能，但是根据输出结果，可以看出来程序虽然猜测成功了，但是程序依旧在运行，因为在测试类中，猜测这个功能呆在永真的循环框架里，会永久执行，直到手动的进行结束。这种情况在处理上可能会相对的复杂，所以也可以在B类中不进行返回值的返回，而是直接的完成在控制台的输出，在测试类的主方法中只需要进行对象的创建和方法的调用即可。

如下：修改B类中的guess方法
    public void guess(int v){
        int data=a.getV();
        if (v>data) System.out.println("大了");
        else if (v<data) System.out.println("小了");
        else{
            System.out.println("猜测成功"); 
            System.exit(0);  //虚拟机结束运行
        }
    }
修改test测试类中的代码：
package data;

import java.util.Scanner;

public class test {
    public static void main(String[] args) {
        A a=new A(18);
        B b=new B(a);
        while (true) {
            System.out.print("请猜测数值：");
            Scanner in = new Scanner(System.in);
            int v = in.nextInt();
            b.guess(v);   //只调用方法，不需要进行返回值的接收
        }
    }
}
如下输出结果，可以看出来，在成功之后，程序不是无限执行，而是结束了运行。
请猜测数值：6
小了
请猜测数值：16
小了
请猜测数值：18
猜测成功

Process finished with exit code 0

再考虑一下第一种方法，就是通过继承来实现操作。通过super()方法来继承父类的特征,并在子类中形成一个父类型的模块,在这个模块中,我们可以访问到父类的变量,利用这种方法,就可以实现以上的操作。

在这种方法下，B类：变量，有参和无参的构造方法，变量的get和set方法，猜测数据的方法

测试类：接收两个输入数据（A对象的默认值、猜测值），只创建一个子类型对象，然后利用super（）方法的特性，传入参数，进而利用其中一个参数对其父类特征模块的v变量进行初始化，利用另一个参数进行对比。

如下所示：

A类：
package day16;

import java.util.Scanner;

public class A {
    private int v;
    public A(){

    }
    public A(int v){
        this.v=v;
    }

    public int getV() {
        return v;
    }

    public void setV(int v) {
        this.v = v;
    }
}
B类：
package day16;

public class B extends A{
    private int v;
    public B(){

    }
    public B(int v,int scanner){
        super(v);
        this.v=scanner;
    }

    @Override
    public int getV() {
        return v;
    }

    @Override
    public void setV(int v) {
        this.v = v;
    }

    //主要代码
    public void guess(int v){
        int data=super.getV();
        if (v>data) System.out.println("大了");
        else if (v<data) System.out.println("小了");
        else{
            System.out.println("猜测成功");
            System.exit(0);  //虚拟机结束运行
        }
    }
}
测试类
package day16;

import java.util.Scanner;

public class test {
    public static void main(String[] args) {
        System.out.print("输入A类中的值:");
        Scanner x=new Scanner(System.in);
        int inA =x.nextInt();
        System.out.print("输入B类中的值:");
        int inB=x.nextInt();
        B b =new B(inA,inB);
        b.guess(inB);
    }
}
运行：
输入A类中的值:18
输入B类中的值:25
大了
输入B类中的值:30
大了
输入B类中的值:15
小了
输入B类中的值:18
猜测成功

Process finished with exit code 0
可以发现运行依旧正常。