当前位置： 首页 > article >正文

案例学习java

article 2024/11/14 15:25:13

对象数组学习1：

//商品存储
public class Good{
    private String id;
    private String name;
    private double price;
    private int count;

    public Good() {
    }

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

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

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

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }
}
public class goodTest {
    public static void main(String[] args) {
        Good[] goods=new Good[3];
        Good g1=new Good("001","华为p40",5999.0,100);
        Good g2=new Good("002","保温杯",227.0,50);
        Good g3=new Good("003","枸杞",21.0,70);
        goods[0]=g1;
        goods[1]=g2;
        goods[2]=g3;
        for (int i = 0; i <goods.length ; i++) {
            Good g=goods[i];
            System.out.println(g.getId()+","+g.getName()+","+g.getPrice()+","+g.getCount());

        }




    }
}

键盘录入知识点：

第二套：遇到回车才停止接收数据。

两个体系不要混用。

对象数组学习2

//存储汽车信息
public class Car{

    private String name;
    private int price;
    private String color;

    public Car() {
    }

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

    public String getName() {
        return name;
    }

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

    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;
    }
}
public class carTest {
    public static void main(String[] args) {
        Car[] cars=new Car[3];
        Scanner sc =new Scanner(System.in);
        for (int i = 0; i <cars.length ; i++) {
            Car c=new Car();
            System.out.println("输入汽车品牌");
            String name=sc.next();
            c.setName(name);
            System.out.println("输入汽车价格");
            int price=sc.nextInt();
            c.setPrice(price);
            System.out.println("输入汽车颜色");
            String color=sc.next();
            c.setColor(color);
            cars[i]=c;
        }
        for (int i = 0; i <cars.length ; i++) {
            Car c=cars[i];
            System.out.println(c.getName()+","+c.getPrice()+","+c.getColor());
        }




    }
}

复杂对象数组练习

数组长度为3，存储3名学生对象最为初始数据，
要求1，添加一个学生，要做学号唯一性判断，要求2，添加完毕，遍历所有学生
//存储学生信息
public class Student{

    private String name;
    private int age;
    private int id;//字符串比较还没学，id暂时是int类型

    public Student() {
    }

    public Student(String name, int age, int id) {
        this.name = name;
        this.age = age;
        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;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}
//数组长度为3，存储3名学生对象最为初始数据，
//要求1，添加一个学生，要做学号唯一性判断，要求2，添加完毕，遍历所有学生
//要求3，通过id删除学生信息，存在，删除，不存在，提示删除失败。要求4，删除完毕后，遍历所有学生，要求5，查询id‘002’的学生，如果存在，年龄加1
public class studentTest {
    public static void main(String[] args) {
        Student[] student=new Student[3];
        Student s1=new Student("小王",15,001);
        Student s2=new Student("小明",14,002);
        Student s3=new Student("小刘",16,003);
        student[0]=s1;
        student[1]=s2;
        student[2]=s3;
        Student s4=new Student("张三",15,004);
        boolean flag=exitID(student,s4.getId());
        Student[] newStu=newStudent(student);
        if(flag){
            System.out.println("学号重复，重新输入");
        }
        else {
            if (getSize(student) == student.length) {
                //增加一个位置，把原数组复制过去

                newStu[getSize(student)] = s4;

                printArr(newStu);

            } else {
                //直接加进去，要判断一下学号

                student[getSize(student)] = s4;

                printArr(student);
            }
        }

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

        }
        return count;
    }
    public static Student[] newStudent(Student[] arr){
        Student[] newStu=new Student[arr.length+1];
        for (int i = 0; i <arr.length ; i++) {
            newStu[i]=arr[i];
        }
        return newStu;
    }
    public static boolean exitID(Student[] arr,int id ){
        for (int i = 0; i <arr.length ; i++) {
            if(arr[i]!=null){
                Student s=arr[i];
                if(s.getId()==id){
                    return true;
                }
            }

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

        }
    }
}

要求3，通过id删除学生信息，存在，删除，不存在，提示删除失败。要求4，删除完毕后，遍历所有学生 

//数组长度为3，存储3名学生对象最为初始数据，
//要求1，添加一个学生，要做学号唯一性判断，要求2，添加完毕，遍历所有学生
//要求3，通过id删除学生信息，存在，删除，不存在，提示删除失败。要求4，删除完毕后，遍历所有学生，要求5，查询id‘002’的学生，如果存在，年龄加1
public class studentTest {
    public static void main(String[] args) {
        Student[] student=new Student[3];
        Student s1=new Student("小王",15,001);
        Student s2=new Student("小明",14,002);
        Student s3=new Student("小刘",16,003);
        student[0]=s1;
        student[1]=s2;
        student[2]=s3;
//        Student s4=new Student("张三",15,004);
//        boolean flag=exitID(student,s4.getId());
//        Student[] newStu=newStudent(student);
//        if(flag){
//            System.out.println("学号重复，重新输入");
//        }
//        else {
//            if (getSize(student) == student.length) {
//                //增加一个位置，把原数组复制过去
//
//                newStu[getSize(student)] = s4;
//
//                printArr(newStu);
//
//            } else {
//                //直接加进去，要判断一下学号
//
//                student[getSize(student)] = s4;
//
//                printArr(student);
//            }
//        }
        int index=getIndex(student,2);
        if(index<0){
            System.out.println("x学号不存在");
        }else{
            student[index]=null;
            printArr(student);
        }

    }
    public static int getIndex(Student[] arr,int id){
        for (int i = 0; i <arr.length ; i++) {
            if(arr[i]!=null){
                Student s=arr[i];
                if(s.getId()==id)
                    return i;
            }
        }
        return -1;
    }
    public static int getSize(Student[] arr){
        int count=0;
        for (int i = 0; i <arr.length ; i++) {
            if(arr[i]!=null)
                count++;

        }
        return count;
    }
    public static Student[] newStudent(Student[] arr){
        Student[] newStu=new Student[arr.length+1];
        for (int i = 0; i <arr.length ; i++) {
            newStu[i]=arr[i];
        }
        return newStu;
    }
    public static boolean exitID(Student[] arr,int id ){
        for (int i = 0; i <arr.length ; i++) {
            if(arr[i]!=null){
                Student s=arr[i];
                if(s.getId()==id){
                    return true;
                }
            }

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

        }
    }
}

要求5：查询id‘002’的学生，如果存在，年龄加1

//数组长度为3，存储3名学生对象最为初始数据，
//要求1，添加一个学生，要做学号唯一性判断，要求2，添加完毕，遍历所有学生
//要求3，通过id删除学生信息，存在，删除，不存在，提示删除失败。要求4，删除完毕后，遍历所有学生，要求5，查询id‘002’的学生，如果存在，年龄加1
public class studentTest {
    public static void main(String[] args) {
        Student[] student=new Student[3];
        Student s1=new Student("小王",15,001);
        Student s2=new Student("小明",14,002);
        Student s3=new Student("小刘",16,003);
        student[0]=s1;
        student[1]=s2;
        student[2]=s3;
        int index=getIndex(student,2);
        if(index>=0){
            Student s=student[index];
            int newAge=s.getAge()+1;
            s.setAge(newAge);
            printArr(student);
        }else{
            System.out.println("所查学号不存在");
        }
//        Student s4=new Student("张三",15,004);
//        boolean flag=exitID(student,s4.getId());
//        Student[] newStu=newStudent(student);
//        if(flag){
//            System.out.println("学号重复，重新输入");
//        }
//        else {
//            if (getSize(student) == student.length) {
//                //增加一个位置，把原数组复制过去
//
//                newStu[getSize(student)] = s4;
//
//                printArr(newStu);
//
//            } else {
//                //直接加进去，要判断一下学号
//
//                student[getSize(student)] = s4;
//
//                printArr(student);
//            }
//        }
//        int index=getIndex(student,2);
//        if(index<0){
//            System.out.println("x学号不存在");
//        }else{
//            student[index]=null;
//            printArr(student);
//        }

    }
    public static int getIndex(Student[] arr,int id){
        for (int i = 0; i <arr.length ; i++) {
            if(arr[i]!=null){
                Student s=arr[i];
                if(s.getId()==id)
                    return i;
            }
        }
        return -1;
    }
    public static int getSize(Student[] arr){
        int count=0;
        for (int i = 0; i <arr.length ; i++) {
            if(arr[i]!=null)
                count++;

        }
        return count;
    }
    public static Student[] newStudent(Student[] arr){
        Student[] newStu=new Student[arr.length+1];
        for (int i = 0; i <arr.length ; i++) {
            newStu[i]=arr[i];
        }
        return newStu;
    }
    public static boolean exitID(Student[] arr,int id ){
        for (int i = 0; i <arr.length ; i++) {
            if(arr[i]!=null){
                Student s=arr[i];
                if(s.getId()==id){
                    return true;
                }
            }

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

        }
    }
}


http://www.kler.cn/a/393137.html

相关文章：

  • docker配置代理解决不能拉镜像问题
  • UDP协议和TCP协议之间有什么具体区别？
  • MySQL系列之如何在Linux只安装客户端
  • 软件工程概论项目(二)，node.js的配置，npm的使用与vue的安装
  • 贪心算法入门（二）
  • 事件循环 -- 资源总结(浏览器进程模型、事件循环机制、练习题)
  • AI大模型开发架构设计（18）——基于大模型构建企业知识库案例实战
  • 24年下软考网络工程师真题及答案，估分、备考速看！
  • React第一个项目
  • 【Lucene】详细讲解创建索引的步骤：分词、去停用词、语言处理、倒排表构建
  • 深入了解支持向量机：机器学习中的经典算法
  • Ue5 umg学习（三）文本控件
  • 交互新体验：Axure动态面板下的图片拖动技巧
  • 统信UOS开发环境支持rust
  • 计算机网络：运输层 —— TCP 协议概述与 TCP 报文段首部格式
  • JavaWeb常见注解
  • Flutter【05】企业级Flutter架构实践
  • 鸿蒙生态：开发者的新征程与挑战并存
  • conda和pip的镜像源配置和删除
  • 在双显示器环境中利用Sunshine与Moonlight实现游戏串流的同时与电脑其他任务互不干扰
  • k8s拓扑域 :topologyKey
  • 快递物流查询API接口如何用C#调用
  • Docker 安装Immich教程
  • 【Linux】内核模版加载modprobe | lsmod
  • 【Java Web】分页查询
  • 材质（二）——材质参数化，从源材质继承生成不同的材质实例