08练习题

曾经终败给现在 2024-04-01 12:17 69阅读 0赞

1、创建三个类

练习题：创建三个类，实现具体功能
    我的答案：
    package Project0101;
    public class Homework01 {
        public static void main(String[] args) {
            double[] a={1.0,2.0,3.0};
            A01 t1=new A01();
            System.out.println(t1.max(a));
            String[] b={"s","t","r"};//创建字符串数组
            A02 t2=new A02();
            System.out.println(t2.find(b,"r"));
            A03 t3=new A03();
            System.out.println(t3.updatePrice(160));
        }
    }
    //类A01，返回某个double数组的最大值
    class A01{
        public double max(double[] a){
            double max=a[0];
            for(int i=1;i<a.length;i++){
                if(max<a[i]){
                    max=a[i];
                }
            }
            return max;
        }
    }
    //类A02，实现查找某字符串数组中的查找，并返回索引，如果找不到，返回-1
    class A02{
        public int find(String[] b,String c){
            int i=0;
            for(i=0;i<b.length;i++){
                if(b[i].equals(c)){
                    return i;
                }
            }
                return -1;
        }
    }
    //类A03，实现更改某本书的价格，具体：如果价格>150，则更改为150，如果价格>100，更改为100，否则不变
    class A03{
        public int updatePrice(int d){
            return d>150?150:(d>100?100:d);
        }
    }*/
    /*输出：
    3.0
    2
    150
    */
    //评价，第一个类思虑不周，第二个类做得挺好的，第三个类没有使用构造器，偏离题意。

（1）类A01，返回某个double数组的最大值

//老师的答案：
    ackage Project0101;
    public class Homework01 {
        public static void main(String[] args) {
            A01 a01=new A01();
            double[] arr={1.0,2.0,3.0};
            Double res=a01.max(arr);//注意是Double
            if(res!=null){
                System.out.println("arr的最大值="+res);
            }else{
                System.out.println("arr的输入有误");
            }
        }
    }
    //缺少不满足条件的思考
    class A01{
        public Double max(double[] arr) {//Double类，所以其对象可以为null,而double是基本数据类型，不可以为null
            //先判断arr是否等于null,再判断是否>0，否则的话，出现null.length是错误的
            if (arr!=null&&arr.length > 0) {
                double max = arr[0];
                for (int i = 1; i < arr.length; i++) {
                    max = arr[i];
                }
                return max;
            }else {
                return null;
            }
        }
    }//输出：arr的最大值=3.0

（2）类A02，实现查找某字符串数组中的查找，并返回索引，如果找不到，返回-1

//老师的答案：
    package Project0101;
    public class Homework01 {
        public static void main(String[] args) {
            String[] strs={"s","t","r"};
            A02 a02=new A02();
            int index=a02.find("r",strs);
            System.out.println("查找的index="+index);
        }
    }
    class A02{
            public int find(String findStr,String[] strs){
                for(int i=0;i<strs.length;i++){
                    if(findStr.equals(strs[i])){
                        return i;
                    }
                }
                return -1;
            }
    }
    //输出：查找的index=2

（3）类A03，实现更改某本书的价格，具体：如果价格>150，则更改为150，如果价格>100，更改为100，否则不变

//老师的答案：
    package Project0101;
    public class Homework01 {
        public static void main(String[] args) {
            A03 t3=new A03("笑傲江湖",900);
            System.out.println("原价："+t3.price);
            t3.updatePrice();
            System.out.println("价格更新后："+t3.price);
        }
    }
    class A03{
            String name;
            double price;
            public A03(String name,double price){
                this.name=name;
                this.price=price;
            }
            //方法一：
            public void updatePrice(){
                //如果方法中没有price局部变量，this.price等价于price，可以不写this
                this.price=((this.price>150)?150:(this.price>100)?100:price);
            }
            //方法二：
            /*public void updatePrice(){
                if(price>150){
                    price=150;
                }else if(price>100){
                    price=100;
                }
            }*/
    }
    //输出：
    // 原价：110.0
    //价格更新后：100.0
    // 原价：90.0
    //价格更新后：90.0
    // 原价：900.0
    //价格更新后：150.0

2、创建三个类

//我的答案：
    package Project0101;
    public class Homework02 {
        public static void main(String[] args) {
            //调用第一个类
            int[] arr={1,2,3,4};
            A04 t1=new A04();
                System.out.println(t1.copyArr(arr));
            //调用第二个类
            Circle t2=new Circle(3.0);
            t2.cir();
            //调用第三个类
            Cale t3=new Cale(2,3);
            t3.and();
            t3.difference();
            Cale t4=new Cale(3,2);
            t4.multiply();
            t4.except();
        }
    }
    //类A04，实现数组的复制功能copyArr，输入旧数组，返回一个新数组，元素和旧数组一样
    class A04{
        public int[] copyArr(int[] arr){
            int[] newarr=new int[arr.length];
            int k=0;
            for(int i=0;i<arr.length;i++){
                newarr[k++]=arr[i];
            }
            return newarr;
        }
    }
    //问题：数组有多种类型，怎么确定返回类型？返回后的数组怎么打印出来？
    
    //定义一个圆类Circle，定义属性：半径，提供显示圆周长功能的方法
    class Circle{
        double radius;
        public Circle(double radius){
            this.radius=radius;
        }
        public void cir(){
            double cir=2*3.14*radius;
            System.out.println("圆周长="+cir);
        }
    }//问题：∏怎么表示
    
    //编程创建一个Cale计算类，在其中定义2个变量表示两个操作数，
    // 定义四个方法实现求和、差、乘、商（要求除数为0的话，要提示）并创建两个对象，分别测试
    class Cale{
        int a;
        int b;
        public Cale(int a,int b){
            this.a=a;
            this.b=b;
        }
        public void and(){
            System.out.println("a+b="+(a+b));
        }
        public void difference(){
            System.out.println("a-b="+(a-b));
        }
        public void multiply(){
            System.out.println("a*b="+(a*b));
        }
        public void except(){//写错了，除数应该是b
            if(a!=0) {
                System.out.println("a/b=" + (a / b));
            }else{
                System.out.println("除数不能为0");
            }
        }
    }
    /*输出：
    [I@27d6c5e0
    圆周长=18.84
    a+b=5
    a-b=-1
    a*b=6
    a/b=1*/

（1）类A04，实现数组的复制功能copyArr，输入旧数组，返回一个新数组，元素和旧数组一样

//老师的答案：
    package Project0101;
    public class Homework02 {
        public static void main(String[] args) {
            int[] oldArr={10,20,30};
            A04 a04=new A04();
            int[] newArr=a04.copyArr(oldArr);//重点：如何打印返回的数组？
            System.out.println("返回的newArr元素情况");
            for(int i=0;i< oldArr.length;i++){
                System.out.println(newArr[i]+"\t");
            }
        }
    }
    class A04{
        public int[] copyArr(int[] oldArr){
            int[] newArr=new int[oldArr.length];
            for(int i=0;i<oldArr.length;i++){
                newArr[i]=oldArr[i];
            }
            return newArr;
        }
    }
    /*输出：
    返回的newArr元素情况
    10	
    20	
    30	*/

（2）定义一个圆类Circle，定义属性：半径，提供显示圆周长功能的方法

//老师的答案：
    package Project0101;
    public class Homework02 {
        public static void main(String[] args) {
            Circle circle=new Circle(1);
            System.out.println("周长="+circle.len());
        }
    }
    class Circle{
        double radius;
        public Circle(double radius){
            this.radius=radius;
        }
        public double len(){
            return 2*Math.PI*radius;
        }
    }//输出：周长=6.283185307179586

（3）编程创建一个Cale计算类，在其中定义2个变量表示两个操作数，定义四个方法实现求和、差、乘、商（要求除数为0的话，要提示）并创建两个对象，分别测试

//老师的答案：
    package Project0101;
    public class Homework02 {
        public static void main(String[] args) {
            Cale cale=new Cale(2,4);
            System.out.println("和="+cale.sum());
            System.out.println("差="+cale.minus());
            System.out.println("乘="+cale.mul());
            Double divRes=cale.div();
            if(divRes!=null) {
                System.out.println("除=" + divRes);
            }
        }
    }
    class Cale{
        double num1;
        double num2;
        public Cale(double num1,double num2){
            this.num1=num1;
            this.num2=num2;
        }
        public double sum(){
            return num1+num2;
        }
        public double minus(){
            return num1-num2;
        }
        public double mul(){
            return num1*num2;
        }
        public Double div(){
            if(num2==0){
                System.out.println("除数不能为0");
                return null;//重点
            }else {
                return num1 / num2;
            }
        }
    }
    /*输出：
    和=6.0
    差=-2.0
    乘=8.0
    除=0.5*/

3、设计一个Dog类，有名字、颜色和年龄属性，定义输出方法show()显示其信息，并创建对象进行测试

//我的答案：
    package Project0101;
    public class Homework03 {
        public static void main(String[] args) {
            Dog003 t1=new Dog003("jack","red",2);
            t1.show();
        }
    }
    class Dog003{
        String name;
        String color;
        int age;
        public Dog003(String name,String color,int age){
            this.name=name;
            this.color=color;
            this.age=age;
        }
        public void show(){
            System.out.println("name="+name+",color="+color+",age="+age);
        }
    }//输出：name=jack,color=red,age=2

4、写出代码的运行结果（匿名对象）

public class Test{
        int count=9;
        public void count1(){
            count=10;
            System.out.println("count1="+count);//输出：10
        }
        public void count2(){
            System.out.println("count1="+count++);
        }
        //任何一个类都可有main
        public static void main(String args[]){
            //new Test()是匿名对象，匿名对象使用后，就不能使用了
            //new Test().count1()创建好匿名对象后就调用count1()
            new Test().count1();
            Test t1=new Test();
            t1.count2();//输出：9
            t1.count2();//输出：10
        }
    }

![dc1c9d608a0741f5b0acb8556281d6ee.png][]在运行上面代码时报错

原因为：文件名与类名不一致

修改方法：![f60ca2a6565b45d0a9f2a6004f9a1ccf.png][]

修改结果：

![c15a600aadcb4982b5c125caf4fdf5ad.png][]

5、定义Music类，里面有音乐名name,音乐时长times属性，并有播放play功能和返回本身属性信息的功能方法getInfo

//定义Music类，里面有音乐名name,音乐时长times属性，
    // 并有播放play功能和返回本身属性信息的功能方法getInfo
    package Project0101;
    public class Homework05 {
        public static void main(String[] args) {
            Music t1=new Music("笑傲江湖",300);
            t1.play();
            System.out.println(t1.getInfo());
        }
    }
    class Music{
        String name;
        int times;
        public Music(String name,int times){
            this.name=name;
            this.times=times;
        }
        public void play(){
            System.out.println("音乐"+name+"正在播放中……时长为"+times+"秒");
        }
        public String getInfo(){
            return "音乐"+name+"播放时间为"+times;
        }
    }
    /*输出：
    音乐笑傲江湖正在播放中……时长为300秒
    音乐笑傲江湖播放时间为300*/

6、写出代码的运行结果

package Project0101;
    class Demo{
        int i=100;
        public void m(){
            int j=i++;
            System.out.println("i="+i);
            System.out.println("j="+j);
        }
    }
    class Test{
        public static void main(String[] args){
            Demo d1=new Demo();
            Demo d2=d1;//d1和d2都指向同一个对象：i=100
            d2.m();
            System.out.println(d1.i);//访问对象属性，对象属性已经被上一条语句改变了
            System.out.println(d2.i);
        }
    }
    /*输出结果：
    i=101
    j=100
    101
    101*/

7、充分复用构造器

//创建一个Employee类，属性有（名字、性别、年龄、职位、薪水），提供3个构造方法，
    // 可以初始化（1）名字，性别，年龄，职位，薪水（2）名字，性别，年龄（3）职位，薪水
    //要求充分复用构造器
    //我的答案：
    package Project0101;
    public class Homework07 {
        public static void main(String[] args) {
            Employee t1=new Employee("jack","man",18,"manager",50000);
            Employee t2=new Employee("jack","man",18);
            Employee t3=new Employee("manager",50000);
            System.out.println(t1.name+t2.age+t3.salary);
    
        }
    }
    class Employee{
        String name;
        String sex;
        int age;
        String posts;
        int salary;
        public Employee(){
            this(String name,String gender,int age);
            this(String posts,int salary);
        }
        public Employee(String name,String gender,int age){
            this.name=name;
            this.sex=gender;
            this.age=age;
        }
        public Employee(String posts,int salary){
            this.posts=posts;
            this.salary=salary;
        }
    }
    //老师的答案：
     public Employee(String name,String gender,int age,String posts,int salary){
            this(name,gender,age);
            this.posts=posts;//这两个没有办法调用构造器，就直接写
            this.salary=salary;
        }

8、将对象作为参数传递给方法

/*将对象作为参数传递给方法：
    （1）定义一个Circle类，包含一个double型的radius属性半径代表圆的半径，findArea()方法
    返回圆的面积
    （2）定义一个PassObject类，在类中定义一个方法printAreas(),
    定义如下：public void printAreas(Circle c,int times)//方法签名
    （3）在printAreas方法中打印输出半径1，2，3，4，5以及对应的圆面积
    （4）在main方法中调用printAreas()方法，调用完毕后输出当前半径值
    */
    //我的答案：
    package Project0101;
    public class Homework13 {
        public static void main(String[] args) {
            Circle t1=new Circle();
            PassObject t2=new PassObject();
            t2.printAreas(t1,5);
        }
    }
    class Circle{
        double radius;
        public double findArea(double raidus){
            this.radius=raidus;
            return Math.PI*radius*radius;
        }
    }
    class PassObject{
        public void printAreas(Circle c,int times){
            for(int i=1;i<=times;i++){
                System.out.println("半径="+(double)i+";面积="+(Math.PI*i*i));
            }
        }
    }
    /*输出：
    半径=1.0;面积=3.141592653589793
    半径=2.0;面积=12.566370614359172
    半径=3.0;面积=28.274333882308138
    半径=4.0;面积=50.26548245743669
    半径=5.0;面积=78.53981633974483*/
    //老师的答案：
    package Project0101;
    public class Homework13 {
        public static void main(String[] args) {
            Circle c=new Circle();
            PassObject po=new PassObject();
            po.printAreas(c,5);
        }
    }
    class Circle{
        double radius;
        public Circle(){
        }
        public Circle(double radius) {
            this.radius = radius;
        }
        public double findArea(){//返回面积
            return Math.PI*radius*radius;
        }
        public void setRadius(double radius){
            this.radius=radius;
        }
    }
    class PassObject{
        public void printAreas(Circle c,int times){
            System.out.println("radius"+"\t"+"area");//注意"\t"的使用
            for(int i=1;i<=times;i++){
                c.setRadius(i);//修改c对象的半径值,此处我是直接重复写了方法，显得累赘
                System.out.println((double) i+"\t"+c.findArea());
            }
        }
    }
    /*输出：
    radius	area
    1.0	3.141592653589793
    2.0	12.566370614359172
    3.0	28.274333882308138
    4.0	50.26548245743669
    5.0	78.53981633974483*/

9、猜拳游戏（玩家和电脑猜拳）

/*有个人Tom设计他的成员变量.成员方法，可以电脑猜拳，电脑每次都会随机生成0，1，2
    0表示石头，1表示剪刀，2表示布，并要显示Tom的输赢次数*/
    //我的答案：
    package Project0101;
    import java.awt.*;
    import java.util.Random;
    
    public class Homework14 {
        public static void main(String[] args) {
            Tom t1=new Tom();
            System.out.println(t1.win(3));
        }
    }
    class Tom{
        public String win(int times) {
            int wintimes = 0;
            int losetimes = 0;
            Random r = new Random();
            for (int i = 0; i < times; i++) {
                int Tom = r.nextInt(3) + 0;
                int Jack = r.nextInt(3) + 0;
                if ((Tom == 0 && Jack == 1) || (Tom == 1 && Jack == 2) || (Tom == 2 && Jack == 0)) {
                    wintimes++;
                } else if ((Tom == 0 && Jack == 2) || (Tom == 1 && Jack == 0) || (Tom == 2 && Jack == 1)) {
                    losetimes++;
                } else {
                }
                System.out.println("Tom="+Tom+"Jack="+Jack);
            }
            return "Tom's wintimes=" + wintimes + ",Tom's losetimes=" + losetimes;
        }
    }
    /*输出：
    Tom=2Jack=2
    Tom=1Jack=0
    Tom=2Jack=2
    Tom's wintimes=0,Tom's losetimes=1
    */
    //代码写得太简略，太粗糙了

//老师的答案：
    package Project0101;
    import java.util.Random;
    import java.util.Scanner;
    //测试类，主类
    public class Homework14 {
        public static void main(String[] args) {
            //创建一个玩家对象
            Tom t=new Tom();
            int isWinCount=0;//记录输赢次数
            int[][] arr1=new int[3][3];//用于接收局数，Tom出拳情况以及电脑出拳情况
            int j=0;
            String[] arr2=new String[3];//用来接收输赢情况
            Scanner scanner=new Scanner(System.in);
            for(int i=0;i<3;i++){//比赛3次
                System.out.println("请输入你要出的拳（0-拳头，1-剪刀，2-布）：");
                int num=scanner.nextInt();//注意
                t.setTomGuessNum(num);
                //获取玩家出的拳
                int tomGuess=t.getTomGuessNum();
                arr1[i][j+1]=tomGuess;
                //获取电脑出的拳
                int comGuess=t.computerNum();
                arr1[i][j+2]=comGuess;
                //输赢情况
                String isWin=t.vsComputer();
                arr2[i]=isWin;
                arr1[i][j]=t.count;
                //对每一局进行输出
                System.out.println("=================================================");
                System.out.println("局数\t玩家的出拳\t电脑的出拳\t输赢情况");
                System.out.println(t.count+"\t"+tomGuess+"\t\t"+comGuess+"\t\t"+isWin);
                System.out.println("=================================================");
                System.out.println("\n");
                isWinCount=t.winCount(isWin);
            }
            //对游泳的最终结果进行输出
            System.out.println("局数\t玩家的出拳\t电脑的出拳\t输赢情况");
            for(int a=0;a<arr1.length;a++){
                for(int b=0;b<arr1[a].length;b++){
                    System.out.print(arr1[a][b]+"\t");
                }
                System.out.print(arr2[a]);
                System.out.println();
            }
            System.out.println("你赢了"+isWinCount+"次");
        }
    }
    class Tom{
        //创建类的属性
        int tomGuessNum;//玩家出的拳
        int comGuessNum;//电脑出的拳
        int winCountNum;//玩家赢的次数
        int count=1;
        public int computerNum(){//返回0-2的随机数
            Random r=new Random();
            comGuessNum=r.nextInt(3);
            return comGuessNum;
        }
        public void setTomGuessNum(int tomGuessNum){
            if(tomGuessNum>2||tomGuessNum<0){
                throw new IllegalArgumentException("数字输入错误");
            }
            this.tomGuessNum=tomGuessNum;//定义类的属性
        }
        public int getTomGuessNum(){
            return tomGuessNum;
        }
        public String vsComputer(){//比赛的运行机制
            if((tomGuessNum==0&&comGuessNum==1)||(tomGuessNum==1&&comGuessNum==2)||(tomGuessNum==2&&comGuessNum==0)){
                return "你赢了！";
            }else if(tomGuessNum==comGuessNum){
                return "平手！";
            }else{
                return "你输了！";
            }
        }
        public int winCount(String s){//记录玩家赢的次数
            count++;
            if(s.equals("你赢了！")){
                winCountNum++;
            }
            return winCountNum;
        }
    }
    //输出如下：

![4aa5646375fe4a0592481140ea0362b2.png][]

[dc1c9d608a0741f5b0acb8556281d6ee.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/2c9aca175a23474b85b25eaf6501d1df.png
[f60ca2a6565b45d0a9f2a6004f9a1ccf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/f5fad7784879432eb239415ac5a2ce65.png
[c15a600aadcb4982b5c125caf4fdf5ad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/19f7f24fc7ba4766997dd420254b2ac8.png
[4aa5646375fe4a0592481140ea0362b2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/8cc80625f2054e01a53115f601632ad3.png