Java基础 DAY14

于 2022-10-07 22:55:29 发布
阅读量191 收藏
点赞数
分类专栏： Java基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_62100455/article/details/127167496
版权

在这里插入图片描述

package com.hspedu.smallchange;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class SmallChangeSys {
    //化繁为简
    //1、先完成显示菜单，并可以选择菜单，给出相应提示
    //2、完成零钱通明细
    //3、完成收益入账
    //4、完成消费
    //5、退出
    public static void main(String[] args) {
        //定义相关变量
        boolean loop = true;
        Scanner scanner = new Scanner(System.in);
        String key = "";

        //2、完成零钱通明细
        //（1）可以把收益入账和消费，保存到数组（2）可以使用对象（3）简单的话可以使用String拼接
        String details = "-----------零钱通明细-------------";

        //3、完成收益入账
        //定义新的变量，完成功能驱动程序员增加新的变量和代码
        double money = 0;
        double balance = 0;
        Date date = null;//date 是java.util.Date
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm"); //可以用于日期格式化的

        //4、消费
        //定义新变量，保存消费的原因
        String note ="";
        do{
            System.out.println("\n===========零钱通菜单===========");
            System.out.println("\t\t1 零钱通明细");
            System.out.println("\t\t2 收益入账");
            System.out.println("\t\t3 消费");
            System.out.println("\t\t4 退出");

            System.out.println("请选择1-4：");
            key = scanner.next();
            //使用switch分支结构
            switch (key){
                case "1":
                    System.out.println(details);
                    break;
                case "2":
                    System.out.print("收益入账金额:");
                    money = scanner.nextDouble();
                    //money 的值范围应该校验 -》 一会在完善
                    //老师思路, 编程思想
                    //找出不正确的金额条件，然后给出提示, 就直接break
                    if(money <= 0) {
                        System.out.println("收益入账金额 需要 大于 0");
                        break;
                    }
                    //找出正确金额的条件
                    balance += money;
                    //拼接收益入账信息到 details
                    date = new Date(); //获取当前日期
                    details += "\n收益入账\t+" + money + "\t" + sdf.format(date) + "\t" + balance;
                    break;
                case "3":
                    System.out.print("消费金额:");
                    money = scanner.nextDouble();
                    //money 的值范围应该校验 -》 一会在完善
                    //找出金额不正确的情况
                    //过关斩将 校验方式.
                    if(money <= 0 || money > balance) {
                        System.out.println("你的消费金额 应该在 0-" + balance);
                        break;
                    }
                    System.out.print("消费说明:");
                    note = scanner.next();
                    balance -= money;
                    //拼接消费信息到 details
                    date = new Date(); //获取当前日期
                    details += "\n" + note + "\t-" + money + "\t" + sdf.format(date) + "\t" + balance;
                    break;
                case "4":
                    //用户输入4退出时，给出提示"你确定要退出吗? y/n"，必须输入正确的y/n ，
                    // 否则循环输入指令，直到输入y 或者 n
                    // (1) 定义一个变量 choice, 接收用户的输入
                    // (2) 使用 while + break, 来处理接收到的输入是 y 或者 n
                    // (3) 退出while后，再判断choice是y还是n ,就可以决定是否退出
                    // (4) 建议一段代码，完成一个小功能，尽量不要混在一起
                    String choice = "";
                    while (true) { //要求用户必须输入y/n ,否则就一直循环
                        System.out.println("你确定要退出吗? y/n");
                        choice = scanner.next();
                        if ("y".equals(choice) || "n".equals(choice)) {
                            break;
                        }
                        //第二个方案
//                        if("y".equals(choice)) {
//                            loop = false;
//                            break;
//                        } else if ("n".equals(choice)) {
//                            break;
//                        }
                    }
                    if (choice.equals("y")) { //当用户退出while ,进行判断
                        loop = false;
                    }
                    break;
                default:
                    System.out.println("菜单选择有误，重新选啊");
            }
        }while (loop);
        System.out.println("~~~~~~~退出了零钱通项目~~~~~~~");
    }
}

在这里插入图片描述

package com.hspedu.smallchange.oop;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

/**
 * 该类是完成零钱通的各个功能的类
 * 使用OOP(面向对象编程)
 * 将各个功能对应一个方法.
 */
public class SmallChangeSysOOP {

    //属性..
    //定义相关的变量
    boolean loop = true;
    Scanner scanner = new Scanner(System.in);
    String key = "";

    //2. 完成零钱通明细
    //老韩思路, (1) 可以把收益入账和消费，保存到数组 (2) 可以使用对象 (3) 简单的话可以使用String拼接
    String details = "-----------------零钱通明细------------------";

    //3. 完成收益入账  完成功能驱动程序员增加新的变化和代码
    //老韩思路, 定义新的变量
    double money = 0;
    double balance = 0;
    Date date = null; // date 是 java.util.Date 类型，表示日期
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm"); //可以用于日期格式化的

    //4. 消费
    //定义新变量，保存消费的原因
    String note = "";

    //先完成显示菜单，并可以选择
    public void mainMenu() {
        do {

            System.out.println("\n================零钱通菜单(OOP)===============");
            System.out.println("\t\t\t1 零钱通明细");
            System.out.println("\t\t\t2 收益入账");
            System.out.println("\t\t\t3 消费");
            System.out.println("\t\t\t4 退     出");

            System.out.print("请选择(1-4): ");
            key = scanner.next();

            //使用switch 分支控制
            switch (key) {
                case "1":
                    this.detail();
                    break;
                case "2":
                    this.income();
                    break;
                case "3":
                    this.pay();
                    break;
                case "4":
                    this.exit();
                    break;
                default:
                    System.out.println("选择有误，请重新选择");
            }

        } while (loop);
    }

    //完成零钱通明细
    public void detail() {
        System.out.println(details);
    }
    //完成收益入账
    public void income() {
        System.out.print("收益入账金额:");
        money = scanner.nextDouble();
        //money 的值范围应该校验 -》 一会在完善
        //老师思路, 编程思想
        //找出不正确的金额条件，然后给出提示, 就直接return
        if(money <= 0) {
            System.out.println("收益入账金额 需要 大于 0");
            return; //退出方法，不在执行后面的代码。
        }
        //找出正确金额的条件
        balance += money;
        //拼接收益入账信息到 details
        date = new Date(); //获取当前日期
        details += "\n收益入账\t+" + money + "\t" + sdf.format(date) + "\t" + balance;

    }
    //消费
    public void pay() {
        System.out.print("消费金额:");
        money = scanner.nextDouble();
        //money 的值范围应该校验 -》 一会在完善
        //找出金额不正确的情况
        //过关斩将 校验方式.
        if(money <= 0 || money > balance) {
            System.out.println("你的消费金额 应该在 0-" + balance);
            return;
        }
        System.out.print("消费说明:");
        note = scanner.next();
        balance -= money;
        //拼接消费信息到 details
        date = new Date(); //获取当前日期
        details += "\n" + note + "\t-" + money + "\t" + sdf.format(date) + "\t" + balance;
    }

    //退出
    public void exit() {
        //用户输入4退出时，给出提示"你确定要退出吗? y/n"，必须输入正确的y/n ，
        // 否则循环输入指令，直到输入y 或者 n
        // 老韩思路分析
        // (1) 定义一个变量 choice, 接收用户的输入
        // (2) 使用 while + break, 来处理接收到的输入时 y 或者 n
        // (3) 退出while后，再判断choice是y还是n ,就可以决定是否退出
        // (4) 建议一段代码，完成一个小功能，尽量不要混在一起
        String choice = "";
        while (true) { //要求用户必须输入y/n ,否则就一直循环
            System.out.println("你确定要退出吗? y/n");
            choice = scanner.next();
            if ("y".equals(choice) || "n".equals(choice)) {
                break;
            }
            //第二个方案
//                        if("y".equals(choice)) {
//                            loop = false;
//                            break;
//                        } else if ("n".equals(choice)) {
//                            break;
//                        }
        }

        //当用户退出while ,进行判断
        if (choice.equals("y")) {
            loop = false;
        }
    }
}
===========================================
package com.hspedu.smallchange.oop;

/**
 * 这里我们直接调用SmallChangeSysOOP 对象，显示主菜单即可
 */
public class SmallChangeSysApp {

    public static void main(String[] args) {
        System.out.println("====hello公司====");
        new SmallChangeSysOOP().mainMenu();
    }
}

在这里插入图片描述

package com.hspedu.Homework;
/*
   定义一个Person类 {name, age, job},
   初始化Person 对象数组，有3个person对象，
   并按照 age 从大到小进行排序, 提示，使用冒泡排序
    */
public class Homework01 {
    public static void main(String[] args) {
        Person[] persons = new Person[3];
        persons[0] =new Person("jack",10,"student");
        persons[1] =new Person("mary",13,"student");
        persons[2] =new Person("wallace",20,"actor");

        for (int i = 0; i < persons.length; i++) {
            System.out.println(persons[i]);//默认对象的 toString
        }
        Person tmp = null;//临时变量，用于交换
        for(int i = 0; i < persons.length -1 ;i++) {//外层循环
            for(int j = 0; j < persons.length -1 - i; j++) {//内层循环
                //并按照 age 从 大到 小进行排序, 如果前面的人的age < 后面人的年龄，就交换
                //要求按照名字的长度从小到大 if(persons[i].getName().length() > persons[i+1].getName().length())
                if(persons[j].getAge() > persons[j+1].getAge()) {
                    tmp = persons[j];
                    persons[j] = persons[j+1];
                    persons[j+1]= tmp;
                }

            }
        }
    }
}
class Person{
    private String name;
    private int age;
    private String job;

    public Person(String name, int age, String job) {
        this.name = name;
        this.age = age;
        this.job = job;
    }

    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 getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", job='" + job + '\'' +
                '}';
    }
}

在这里插入图片描述
public,protected,默认，private
在这里插入图片描述
在这里插入图片描述

package com.hspedu.Homework;

/*
(1) 要求有属性“姓名name”，“年龄age”，“职称post”，“基本工资salary”
(2) 编写业务方法， introduce（），实现输出一个教师的信息。

 */
package com.hspedu.Homework;

/*
(1) 要求有属性“姓名name”，“年龄age”，“职称post”，“基本工资salary”
(2) 编写业务方法， introduce（），实现输出一个教师的信息。

 */
public class Homework03 {
    public static void main(String[] args) {
        Professor professor = new Professor("张三", 28, "高级职称", 20000, 1.3);
        professor.introduce();
    }
}
class Teacher{
    private String name;
    private int age;
    private String post;
    private double salary;

    private double grade;

    public Teacher(String name, int age, String post, double salary, double grade) {
        this.name = name;
        this.age = age;
        this.post = post;
        this.salary = salary;
        this.grade = grade;
    }

    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 getPost() {
        return post;
    }

    public void setPost(String post) {
        this.post = post;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public double getGrade() {
        return grade;
    }

    public void setGrade(double grade) {
        this.grade = grade;
    }

    public void introduce(){
        System.out.println("name: " + name + " age: " + age
                + " post: " + post + " salary:"
                + salary + " grade:" + grade);
    }
}

class Professor extends Teacher{
    public Professor(String name, int age, String post, double salary, double grade) {
        super(name, age, post, salary, grade);
    }

    @Override
    public void introduce() {
        System.out.println("这是教授的信息：");
        super.introduce();
    }
}

在这里插入图片描述

package com.hspedu.Homework;

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

        Manager manage = new Manager("wang", 100, 20, 1.2);
        //设置奖金
        manage.setBonus(3000);
        //打印经理的工资情况
        manage.printSal();

        Worker worker = new Worker("zhang", 50, 10, 1.0);
        worker.printSal();
    }
}
class Employee{
    private String name;
    private double daySal;
    private double workDays;
    private double grade;

    public void printSal(){
        System.out.println(name + daySal + workDays + grade);
    }
    public Employee(String name, double daySal, double workDays, double grade) {
        this.name = name;
        this.daySal = daySal;
        this.workDays = workDays;
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

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

    public double getDaySal() {
        return daySal;
    }

    public void setDaySal(double daySal) {
        this.daySal = daySal;
    }

    public double getWorkDays() {
        return workDays;
    }

    public void setWorkDays(int workDays) {
        this.workDays = workDays;
    }

    public double getGrade() {
        return grade;
    }

    public void setGrade(double grade) {
        this.grade = grade;
    }
}


class Manager extends Employee{
    private double bonus;
    //创建Manager对象时，奖金是多少并不是确定的，因为老师在构造器中，不给bonus
    //,可以通过setBonus
    public Manager(String name, double daySal, double workDays, double grade) {
        super(name, daySal, workDays, grade);
    }
    public double getBonus() {
        return bonus;
    }
    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
    //重写父类printSal方法
    @Override
    public void printSal() {
        //经理的工资计算方式和Employee不同，所以重写
        System.out.println("经理 " + getName() + " 工资是="
                + (bonus + getDaySal() * getWorkDays() * getGrade()));
    }
}


class Worker extends Employee{
    //普通员工没有特有属性
    public Worker(String name, double daySal, double workDays, double grade) {
        super(name, daySal, workDays, grade);
    }
    //重写printSal
    //因为普通员工和Employee输出工资情况一下，所以直接调用父类的printSal()

    @Override
    public void printSal() {
        System.out.print("普通员工 ");
        super.printSal();//调用父类的方法，复用代码
    }
}

在这里插入图片描述
在这里插入图片描述

package com.hspedu.Homework;

public class homework11 {
    public static void main(String[] args) {
        //向上转型：父类的引用指向子类对象
        Person11 p = new Student11();
        p.run();//student run，
        p.eat();//从子类Student开始找，子类中没有eat方法，所以向上找父类，输出person eat
        // 写代码的时候，编译器只认编译类型，
        // 真正执行的时候是运行类型，运行时会有动态绑定机制，时Student类


        //向下转型：把指向子类对象的父类引用，转成指向子类对象的子类引用
        Student11 s = (Student11)p;
        s.run();//student run
        s.study();//student run
        s.eat();//person eat

    }
}
class Person11{//父类
    public void run(){
        System.out.println("person run");
    }
    public void eat(){
        System.out.println("person eat");
    }

}
class Student11 extends Person11{//子类
    public void run(){
        System.out.println("student run");
    }
    public void study(){
        System.out.println("student study");
    }
}

在这里插入图片描述
在这里插入图片描述

package com.hspedu.Homework;

public class homework09 {
    public static void main(String[] args) {
        LabeledPoint labeledPoint = new LabeledPoint(10.3, 11.4, "wallace");
    }
}

=============================================
package com.hspedu.Homework;

public class Point {
    double x;
    double y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
}
==============================================
package com.hspedu.Homework;

public class LabeledPoint extends Point {
    private String label;

    public LabeledPoint(double x, double y, String label) {
        super(x, y);
        this.label = label;
    }
}

在这里插入图片描述

package com.hspedu.Homework;

public class homework10 {
    public static void main(String[] args) {
        Doctor doctor1 = new Doctor("Jack", 20, "牙科医生", '男', 20000);
        Doctor doctor2 = new Doctor("Jack", 20, "牙科医生", '男', 20000);

        System.out.println(doctor1.equals(doctor2));//true
    }
}
==============================================
package com.hspedu.Homework;

import java.util.Objects;

public class Doctor {
    private String name;
    private int age;
    private String job;
    private char gender;
    private double sal;

    public Doctor(String name, int age, String job, char gender, double sal) {
        this.name = name;
        this.age = age;
        this.job = job;
        this.gender = gender;
        this.sal = sal;
    }

    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 getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public char getGender() {
        return gender;
    }

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

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }

   public boolean equals(Object obj){
        //判断两个比较对象是否相同
       if(this == obj){
           return true;
       }
       //判断obj 是否是Doctor类型或其子类
       if(!(obj instanceof Doctor)){//obj如果不是Doctor运行类型，
           return false;
       }
       //向下转型，因为obj的运行类型是Doctor或者其子类型
       Doctor doctor = (Doctor)obj;
       return this.name.equals(doctor.name) && this.age ==doctor.age &&
               this.gender == doctor.gender && this.job.equals(doctor.job) && this.sal == doctor.sal;
   }
}

在这里插入图片描述
在这里插入图片描述

package com.hspedu.Homework.Homework13;

public class Person {//父类
    private String name;
    private char sex;
    private int age;

    public Person(String name, char sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

    public String play(){//把共有的输出内容写到父类
        return name + "爱玩";
    }

    //返回基本信息
    public String basicInfo(){
        return "姓名:" + name + "\n年龄：" + age + "\n性别：" + sex;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                '}';
    }
}

==============================================================
package com.hspedu.Homework.Homework13;

public class Teacher extends Person {
   //特有属性
    private int work_age;
    //构造器
    public Teacher(String name, char sex, int age, int work_age) {
        super(name, sex, age);
        this.work_age = work_age;
    }

    public int getWork_age() {
        return work_age;
    }

    public void setWork_age(int work_age) {
        this.work_age = work_age;
    }

    //方法
    public void teach(){
        System.out.println("我承诺，我会认真教学");
    }

    @Override
    public String play() {
        return super.play() + "象棋";
    }
    //编写一个输出信息的方法，体现出封装
    public void printInfo(){
        System.out.println("教师信息：");
        System.out.println(super.basicInfo());
        System.out.println("工号："+ work_age);
        teach();//组合
        System.out.println(play());
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "work_age=" + work_age +
                '}' + super.toString();
    }
}
=================================================================
package com.hspedu.Homework.Homework13;

public class Student extends Person{
    //特有属性
    private String stu_id;
    //构造器
    public Student(String name, char sex, int age, String stu_id) {
        super(name, sex, age);
        this.stu_id = stu_id;
    }

    public String getStu_id() {
        return stu_id;
    }

    public void setStu_id(String stu_id) {
        this.stu_id = stu_id;
    }

    //方法
    public void study(){
        System.out.println("我承诺，我会好好学习");
    }

    @Override
    public String play() {
        return super.play() + "足球";
    }

    //编写一个输出信息的方法，体现出封装
    public void printInfo(){
        System.out.println("学生信息：");
        System.out.println(super.basicInfo());
        System.out.println("学号："+ stu_id);
        study();//组合
        System.out.println(play());
    }

    @Override
    public String toString() {
        return "Student{" +
                "stu_id='" + stu_id + '\'' +
                '}' + super.toString();
    }
}
=================================================================
package com.hspedu.Homework.Homework13;

public class homework13 {
    public static void main(String[] args) {
        Student student = new Student("wallace", '男', 18,"12345");
        student.printInfo();

        System.out.println("================");
        Teacher teacher = new Teacher("WANG", '女', 30, 11);
        teacher.printInfo();

        //定义多态数组，里面保存2个学生和2个教师，要求按年龄从高到低排序
        Person[] persons = new Person[4];
        persons[0] = new Student("JACK",'男',10,"001");
        persons[1] = new Student("wallace",'男',20,"002");
        persons[2] = new Teacher("MARRY",'女',30,10);
        persons[3] = new Teacher("KITTY",'女',40,15);

        //创建对象
        homework13 homework = new homework13();
        homework.bubbleSort(persons);
        //输出排序
        System.out.println("=====排序后的数组====");
        for (int i = 0; i < persons.length; i++) {
            System.out.println(persons[i]);
        }

        //遍历数组，调用test方法
        System.out.println("=======================");
        for (int i = 0; i < persons.length; i++) {//遍历多态数组
            homework.test(persons[i]);
        }

    }
    //方法,完成年龄从高到底排序
    public void bubbleSort(Person[] persons) {
        Person temp = null;
        for (int i = 0; i < persons.length - 1; i++) {
            for (int j = 0; j < persons.length - 1 - i; j++) {
                //判断条件, 注意这里的条件可以根据需要，变化
                if(persons[j].getAge() < persons[j+1].getAge()) {
                    temp = persons[j];
                    persons[j] = persons[j + 1];
                    persons[j + 1] = temp;
                }
            }
        }
    }

    //定义方法，形参为Person类型，功能：调用学生的study或教师的teach方法
    //分析这里会使用到向下转型和类型判断
    public void test(Person p){
        if(p instanceof Student) {//p 的运行类型如果是Student
            ((Student) p).study();
        } else if(p instanceof  Teacher) {
            ((Teacher) p).teach();
        } else {
            System.out.println("do nothing...");
        }
    }

}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值