面向对象综合训练

已于 2024-09-18 20:52:29 修改
阅读量146 收藏 4
点赞数 4
文章标签： java 前端 服务器
于 2024-09-18 20:31:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ling_suu/article/details/142312523
版权 
public class Test {
    public static void main(String[] args) {

        // 两部分参数：
        // 第一部分参数：要输出的内容%s（占位）
        // 第二部分参数：填充的数据
        System.out.printf("你好啊%s","lhj");
        System.out.println();
        System.out.printf("%s你好啊%s","lhj","fjq");
    }
}

运行结果：

  • System.out.printf()；并没有换行效果，并且需要有两部分参数，每个参数一一对应

文字版格斗游戏

package com.itheima.test7;

import java.util.Random;

public class Role {
    private String name;
    private int blood;
    private char gender;
    private String face;

    String[] boyfaces= {"风流俊雅","气宇轩昂","相貌英俊","五官端正","相貌平平","一塌糊涂","面目狰狞"};
    String[] girlfaces ={"美奂绝伦","沉鱼落雁","婷婷玉立","身材娇好","相貌平平","相貌简陋","惨不忍睹"};

    // attack 攻击描述：
    String[] attacks_desc={
            "%s使出了一招【背心钉】，转到对方的身后，一掌向%s背心的灵台穴拍去。",
            "%s使出了一招【游空探爪】，飞起身形自半空中变掌为抓锁向%s。",
            "%s大喝一声，身形下伏，一招【劈雷坠地】，捶向%s双腿。",
            "%s运气于掌，一瞬间掌心变得血红，一式【掌心雷】，推向%s。",
            "%s阴手翻起阳手跟进，一招【没遮拦】，结结实实的捶向%s。",
            "%s上步抢身，招中套招，一招【劈挂连环】，连环攻向%s。"
    };

    // injured 受伤描述：
    String[] injureds_desc={
            "结果%s退了半步，毫发无损",
            "结果给%s造成一处瘀伤",
            "结果一击命中，%s痛得弯下腰",
            "结果%s痛苦地闷哼了一声，显然受了点内伤",
            "结果%s摇摇晃晃，一跤摔倒在地",
            "结果%s脸色一下变得惨白，连退了好几步",
            "结果『轰』的一声，%s口中鲜血狂喷而出",
            "结果%s一声惨叫，像滩软泥般塌了下去"
    };

    public Role() {
    }

    public Role(String name, int blood, char gender) {
        this.name = name;
        this.blood = blood;
        this.gender = gender;
        setFace(gender);
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public String getFace() {
        return face;
    }

    public void setFace(char gender) {
        Random r = new Random();
        if (gender == '男') {
            int index = r.nextInt(boyfaces.length);
            this.face = boyfaces[index];
        } else if (gender == '女') {
            int index = r.nextInt(girlfaces.length);
            this.face = girlfaces[index];
        } else {
            this.face = "面目狰狞";
        }
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return blood
     */
    public int getBlood() {
        return blood;
    }

    /**
     * 设置
     * @param blood
     */
    public void setBlood(int blood) {
        this.blood = blood;
    }

    public void attack(Role role) {
        Random random = new Random();
        int index = random.nextInt(attacks_desc.length);
        System.out.printf(attacks_desc[index], this.getName(), role.getName());
        System.out.println();
        int hurt = random.nextInt(20) + 1;
        int remainBlood = role.getBlood() - hurt;
        remainBlood = remainBlood < 0 ? 0 : remainBlood;
        role.setBlood(remainBlood);
        if (remainBlood > 90) {
            System.out.printf(injureds_desc[0], role.getName());
        } else if (remainBlood > 80 && remainBlood <= 90) {
            System.out.printf(injureds_desc[1], role.getName());
        } else if (remainBlood > 70 && remainBlood <= 80) {
            System.out.printf(injureds_desc[2], role.getName());
        } else if (remainBlood > 60 && remainBlood <= 70) {
            System.out.printf(injureds_desc[3], role.getName());
        } else if (remainBlood > 40 && remainBlood <= 60) {
            System.out.printf(injureds_desc[4], role.getName());
        } else if (remainBlood > 20 && remainBlood <= 40) {
            System.out.printf(injureds_desc[5], role.getName());
        } else if (remainBlood > 10 && remainBlood <= 20) {
            System.out.printf(injureds_desc[6], role.getName());
        } else {
            System.out.printf(injureds_desc[7], role.getName());
        }
        System.out.println();
    }

    public void showRoleInfo() {
        System.out.println("姓名：" + this.getName());
        System.out.println("血量：" + this.getBlood());
        System.out.println("性别：" + this.getGender());
        System.out.println("长相：" + this.getFace());
    }
}

package com.itheima.test7;

public class GameTest {
    public static void main(String[] args) {
        Role r1 = new Role("lhj", 100, '男');
        Role r2 = new Role("fjq", 100, '女');

        r1.showRoleInfo();
        r2.showRoleInfo();

        while (true) {
            r1.attack(r2);
            if (r2.getBlood() == 0) {
                System.out.println(r1.getName() + "K.O了" + r2.getName());
                break;
            }

            r2.attack(r1);
            if (r1.getBlood() == 0) {
                System.out.println(r2.getName() + "K.O了" + r1.getName());
                break;
            }
        }
    }
}

两个对象数组练习

键盘录入：

  • 第一套体系：
    • nextInt(); 接收整数
    • nextDouble(); 接收小数
    • next(); 接收字符串
    • 遇到空格、制表符、回车就停止接收，这些符号后面的数据就不会接收了

  • 第二套体系：
    • nextLine(); 接收字符串
    • 可以接收空格、制表符，遇到回车才停止接收数据

  • 键盘录入的两套体系不能混用
  • 弊端：先用nextInt，再用nextLine会导致下面的nextLine接收不到数据

package com.itheima.test8;

public class Goods {
    private String id;
    private String name;
    private double price;
    private int count;


    public Goods() {
    }

    public Goods(String id, String name, double price, int count) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.count = count;
    }

    /**
     * 获取
     * @return id
     */
    public String getId() {
        return id;
    }

    /**
     * 设置
     * @param id
     */
    public void setId(String id) {
        this.id = id;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return price
     */
    public double getPrice() {
        return price;
    }

    /**
     * 设置
     * @param price
     */
    public void setPrice(double price) {
        this.price = price;
    }

    /**
     * 获取
     * @return count
     */
    public int getCount() {
        return count;
    }

    /**
     * 设置
     * @param count
     */
    public void setCount(int count) {
        this.count = count;
    }

}

package com.itheima.test8;

public class GoodsTest {
    public static void main(String[] args) {

        Goods[] arr = new Goods[3];

        Goods goods1 = new Goods("001", "手机", 1999.99, 60);
        Goods goods2 = new Goods("002", "电脑", 8999.99, 40);
        Goods goods3 = new Goods("003", "耳机", 999.99, 70);

        arr[0] = goods1;
        arr[1] = goods2;
        arr[2] = goods3;

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i].getId() + "," + arr[i].getName() + "," + arr[i].getPrice() + "," + arr[i].getCount());
        }
    }
}

 

package com.itheima.test9;

public class Car {
    private String brand;
    private int price;
    private String color;


    public Car() {
    }

    public Car(String brand, int price, String color) {
        this.brand = brand;
        this.price = price;
        this.color = color;
    }

    /**
     * 获取
     * @return brand
     */
    public String getBrand() {
        return brand;
    }

    /**
     * 设置
     * @param brand
     */
    public void setBrand(String brand) {
        this.brand = brand;
    }

    /**
     * 获取
     * @return price
     */
    public int getPrice() {
        return price;
    }

    /**
     * 设置
     * @param price
     */
    public void setPrice(int price) {
        this.price = price;
    }

    /**
     * 获取
     * @return color
     */
    public String getColor() {
        return color;
    }

    /**
     * 设置
     * @param color
     */
    public void setColor(String color) {
        this.color = color;
    }

}

package com.itheima.test9;

import java.util.Scanner;

public class CarTest {
    public static void main(String[] args) {

        Car[] car = new Car[3];

        for (int i = 0; i < car.length; i++) {
            Car c = new Car();
            System.out.println("请输入车的品牌：");
            Scanner sc = new Scanner(System.in);
            String brand = sc.next();
            c.setBrand(brand);

            System.out.println("请输入车的价格：");
            int price = sc.nextInt();
            c.setPrice(price);

            System.out.println("请输入车的颜色：");
            String color = sc.next();
            c.setColor(color);

            car[i] = c;
        }
        for (int i = 0; i < car.length; i++) {
            System.out.println(car[i].getBrand() + "," + car[i].getPrice() + "," +car[i].getColor());
        }
    }
}

对象数组练习——判断并统计

package com.itheima.test10;

public class Phone {
    private String brand;
    private int price;
    private String color;

    public Phone() {
    }

    public Phone(String brand, int price, String color) {
        this.brand = brand;
        this.price = price;
        this.color = color;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

package com.itheima.test10;

public class PhoneTest {
    public static void main(String[] args) {
        Phone[] arr = new Phone[3];

        Phone p1 = new Phone("华为", 5999, "白");
        Phone p2 = new Phone("小米", 4999, "灰");
        Phone p3 = new Phone("oppo", 3999, "黑");

        arr[0] = p1;
        arr[1] = p2;
        arr[2] = p3;

        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum = sum + arr[i].getPrice();
        }
        double avg = sum * 1.0 / arr.length;

        System.out.println(avg);
    }
}

 

package com.itheima.test11;

public class GirlFriend {
    private String name;
    private int age;
    private String gender;

    public GirlFriend() {
    }

    public GirlFriend(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
}

package com.itheima.test11;

public class GirlFriendTest {
    public static void main(String[] args) {
        GirlFriend[] arr = new GirlFriend[3];

        GirlFriend g1 = new GirlFriend("111", 18, "女");
        GirlFriend g2 = new GirlFriend("222", 20, "女");
        GirlFriend g3 = new GirlFriend("333", 22, "女");

        arr[0] = g1;
        arr[1] = g2;
        arr[2] = g3;

        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum = sum + arr[i].getAge();
        }
        int avg = sum / arr.length;

        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i].getAge() < avg) {
                System.out.println(arr[i].getName() + "," + arr[i].getAge());
                count++;
            }
        }
        System.out.println(count);
    }
}

复杂对象数组练习——添加、遍历、删除和修改

package com.itheima.test12;

public class Student {
    private int id;
    private String name;
    private int age;

    public Student() {
    }

    public Student(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.itheima.test12;

public class StudentTest {
    public static void main(String[] args) {
        Student[] arr = new Student[3];

        Student s1 = new Student(1, "lhj", 18);
        Student s2 = new Student(2, "fjq", 19);
        Student s3 = new Student(3, "hwd", 20);

        arr[0] = s1;
        arr[1] = s2;
        arr[2] = s3;

        Student s4 = new Student(4, "zxy", 21);

        Boolean flag = contain(arr, s4.getId());
        if (flag) {
            if (getcount(arr) == arr.length) {
                Student[] Arr = createNewArr(arr);
                Arr[getcount(arr)] = s4;
                printArr(Arr);
            } else {
                arr[getcount(arr)] = s4;
                printArr(arr);
            }
        } else {
            System.out.println("存在重复学号");
        }

//        int index = getIndex(arr, 2);
//        if (index >= 0) {
//            arr[index-1] = null;
//            printArr(arr);
//        } else {
//            System.out.println("该学号不存在");
//        }

        int index = getIndex(arr, 2);
        if (index >= 0) {
            int age = arr[index-1].getAge() + 1;
            arr[index-1].setAge(age);
            printArr(arr);
        } else {
            System.out.println("该学号不存在");
        }
    }

    public static Boolean contain (Student[] arr, int id) {

        for (int i = 0; i < arr.length; i++) {
            if (arr[i].getId() == id) {
                return false;
            }
        }
        return true;
    }

    public static int getcount (Student[] arr) {
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] != null) {
                count++;
            }
        }
        return count;
    }

    public static Student[] createNewArr (Student[] arr) {
        Student[] Arr = new Student[arr.length + 1];
        for (int i = 0; i < arr.length; i++) {
            Arr[i] = arr[i];
        }
        return Arr;
    }

    public static void printArr (Student[] arr) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] != null) {
                System.out.println(arr[i].getId() + "," + arr[i].getAge() + "," + arr[i].getName());
            }
        }
    }

    public static int getIndex (Student[] arr, int index) {

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] != null) {
                if (arr[i].getId() == index) {
                    return index;
                }
            } else {
                return -1;
            }
        }
        return -1;
    }
}

Ling_suu
关注
Java面向对象综合训练综合练习
weixin_54707168的博客
01-07 318
​ 格斗游戏，每个游戏角色的姓名，血量，都不相同，在选定人物的时候（new对象的时候），这些信息就应该被确定下来。定义一个长度为3的数组，数组存储1~3名学生对象作为初始数据，学生对象的学号，姓名各不相同。​ 长相是提前定义好的，提前放在一个数组当中，程序运行之后，从数组中随机获取。​ 乔峰举起拳头打了鸠摩智一下，造成了XX点伤害，鸠摩智还剩下XXX点血。​ 鸠摩智举起拳头打了鸠摩智一下，造成了XX点伤害，乔峰还剩下XXX点血。​ 乔峰举起拳头打了鸠摩智一下，造成了XX点伤害，鸠摩智还剩下XXX点血。
java血条_java编写两玩家对打程序，需要生命值，攻击和防御，生命为0则死亡。...
weixin_34566436的博客
02-21 893
展开全部publicclassPlayer{//模拟交战publicstaticvoidEngage(){62616964757a686964616fe58685e5aeb931333337383932System.out.println("战斗开始!");newPlayer("悟空",200,50,10).Attack(newPlayer("八戒",300,40,6));Sys...
java_面向对象_练习
Y_cen的博客
01-25 87
java面向对象练习
JAVA回合制pk游戏
m0_63726131的博客
07-10 1524
JAVA回合制pk游戏
JAVA小游戏——双人格斗文字版（回合制）
qq_63058812的博客
12-14 1569
由于我想让每次攻击伤害都不一样，浮动式的伤害，所以并没有生成攻击的私有成员变量而是在成员方法里生成了（因为伤害每回合是随机的，所以需要把他放在成员方法里）。还有一个关于玩家对打的成员方法，我想要的效果是，在主函数里当我使用了这个成员方法，玩家已经对打完了。所以定义一个Fight的成员方法，他的作用就是让两个玩家对打，并且输出对战信息。主函数：引用Role的Fight方法，当两角色打完后，判断一下被攻击方，血量是否为0，如果为0，那么代表战斗结束了，反之，继续对打（也就是继续调用Fight方法与判断）。
python做一个简单的对战游戏
weixin_47430224的博客
12-24 3692
今天没什么事情，就自己做了一个简单的对战游戏。 这个小游戏流程大概是这样的 开始游戏 ↓ 选择人物出场顺序及技能 ↓ ←←←←←←←←← ← ↖ 开始战斗→胜利方→＋1分 ↓ ↓ 失败方← ← ← ← ←↙ ↓ ↑ ↑ ...
47.面向对象综合训练-汽车
weixin_71068901的博客
09-16 826
定义存储3个汽车对象，汽车的属性：品牌，价格，颜色，数据通过键盘录入而来，并把数据存入到数组当中
JAVA学习第七章——面向对象综合训练
weixin_43791933的博客
08-06 1195
暑期JAVA自学习过程
Java面向对象基础篇综合训练（附带全套源代码及逐语句分析）-＞基于javabeen
2302_80329073的博客
07-10 975
还是那句话面向对象是Java的重点，同时也是难点，小编会在此部分分享一些综合型的案例，难度从易到难，本篇文章只是一些基础的操作，综合能力并不是太高。大家可以试着观看一遍自己去打开编译器尝试一下。不知道有多少读者是跟着小编进行学习的，今天是学习Java的第五天，希望大家能够一同坚持下去。为了防止读者们遗忘，小编将基础部分放在下面了欧。
【系统分析师】-面向对象方法
宣晨光
09-04 2171
(1)信息系统综合知识 统一建模语言：熟练掌握 UML(2.x版)的图形表示、含义和用法。 面向对象的分析：熟练掌握继承、抽象、封装、多态的概念和用法;面向对象分析的基本概念;利用UML对系统需求建模，熟练掌握基于场景的建模 面向对象的设计：面向对象设计方法;利用UML对软件设计建模:熟练掌握面向对象程序设计;掌握设计模式。 面向对象软件的测试：面向对象软件的测试层次。 设计模式：经典的 GoF23 种模式的定义和结构。. (2)系统分析设计案例 对象业务流的提取和确认：在面向对象的系统中，提取基于对象
Java+Java基础知识+基本概念+运算符+判断和循环+循环高级和数组+方法+综合练习+面向对象+面向对象综合熏硫胺+字符串等
11-06
Java基础知识，其中包括基本概念+运算符+判断和循环+循环高级和数组+方法+综合练习+面向对象+面向对象综合训练+字符串+集合&学生管理系统+学生管理系统升级版+面向对象进阶（static&继承+多态+包&final&权限+抽象类&...
《面向对象程序课程设计》课程实践报告.doc
12-14
【标题】《面向对象程序课程设计》课程实践报告主要涵盖了使用Java编程语言和MySQL数据库开发一个学生信息管理系统。这个系统具备增加、删除、修改和查询学生信息的基本功能，旨在加深学生对Java语言的理解，提高其...
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 330
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 395
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java分布式锁
juanmiao的专栏
10-12 718
每种方法都有其优点和适应的场景，数据库通常简单，但可能存在性能问题，redis非常快，但需要第三方库，并且可能引入网诺问题，Zookeeper提供了更复杂的同步原语，但需要额外学习曲线。分布式锁的实现比线程锁和进程锁要复杂得多，因为它需要在网诺中的多个节点之间进行协调，以保证锁的唯一性和一致性。在实现分布式锁时，通常会有一个中心节点（或者称为锁服务），所有需要获取锁的节点都需要向这个中心节点申请。这个中心节点负责协调和管理所有节点的锁请求，确保锁的唯一性和一致性。创建临时节点，执行业务逻辑，释放锁。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 692
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
确保Spring Boot定时任务只执行一次方案
2301_76419561的博客
10-14 573
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
【SpringBoot的启动、处理请求整体流程（二）】
m0_50149847的博客
10-13 914
同时，如果文章有错误，也欢迎批评指正。本篇文章继之后，可以先阅读第一篇文章。
面向对象方法课程设计实战指南
"面向对象方法课程设计是一个教育过程，旨在帮助学生通过实践应用深化理论知识，提高他们的编程、调试和项目开发技能。该课程设计强调分析问题和解决问题的能力，要求学生掌握面向对象编程方法，熟悉C++编程环境，并...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值