Java基础8

拼电商客户管理系统

Customer类的设计

public class Customer {
    private String name;
    private char gender;
    private int age;
    private String phone;
    private String email;

    public Customer(){
    }

    public Customer(String name, char gender, int age, String phone, String email) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.phone = phone;
        this.email = email;
    }

    public String getName() {
        return name;
    }

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

    public char getGender() {
        return gender;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

CustomerList类的设计

public class CustomerList {
    private Customer[] customers;
    private int total; // 记录已保存客户对象的数量

    public CustomerList(int totalCustomer){
        customers = new Customer[totalCustomer]; // totalCustomer保存数组的最大空间
    }

    /**
     * 用途： 在customers 数组中最后添加一个客户对象
     * @param customer
     * @return 添加成功返回true,否则返回false.
     */
    public boolean addCustomer(Customer customer){
        if (customers.length > total){
            customers[total++] = customer;
            return true;
        }else{
            return false;
        }
    }

    /**
     * 用参数cust替换数组customers中的index指定的对象
     * @param index 指定所替换对象在数组的位置  从0开始
     * @param cust  指定替换的新客户对象
     * @return  替换成功返回true  false表示索引无效，无法替换
     */
    public boolean replaceCustomer(int index,Customer cust){
        if (index >= 0 && index < total){
            customers[index] = cust;
            return  true;
        } else {
            return false;
        }
    }

    /**
     * 从数组中删除参数index指定索引位置的客户对象记录
     * @param index  指定所删除对象在数组中的索引位置，从0开始
     * @return  删除成功则返回true  false表示索引无效，无法删除
     */
    public boolean deleteCusotmer(int index){
        if (index >= 0 && index < total - 1){  //特别注意把 index = total -1 的情况额外考虑
            for (int i = index; i < total - 1; i ++){
                customers[i] = customers[i+1];
            }
            customers[total - 1] = null;
            total--;
            return  true;
        }else if(index == total - 1){
            customers[index] = null;
            total--;
            return true;
        }else{
            return false;
        }
    }

    /**
     * 返回数组中记录的所有客户对象
     * @return  Customer[] 数组中包含了当前所有客户对象，该数组长度与对象个数相同
     */
    public Customer[] getCustomers(){
        // 错误写法： return customers;  我们数组长度为10要是只有3个用户 则还会返回7个null 不符合要求
        Customer[] custs = new Customer[total];
        // custs = customers; 不能够这样将custs赋值  因为这样custs会变成容量和customers一样的数组 并且后面还是会输出null
        for (int i = 0; i < total; i ++){
            custs[i] = customers[i];
        }
        return custs;
    }

    /**
     * 返回参数index指定索引位置的客户对象记录
     * @param index 指定所要获取的客户在数组中的索引位置，从0开始
     * @return 封装了客户信息的Customer对象
     */
    public Customer getCustomer(int index){
        if (index >= 0 && index < total){
            return customers[index];
        }
        return null;
    }
    public int getTotal(){
        return total;
    }
}

CustomerView类的设计

import java.util.Scanner;

public class CustomerView {
    CustomerList customerList = new CustomerList(10);
    Scanner scan  = new Scanner(System.in);
    /**
     * 进入主界面的方法
     */
    public void enterMainMeun(){
        boolean flag = true;
        while (flag){
            System.out.println("\n ---------------------拼电商客户管理系统--------------------\n");
            System.out.println("                        1.添 加 客 户");
            System.out.println("                        2.修 改 客 户");
            System.out.println("                        3.删 除 客 户");
            System.out.println("                        4.客 户 列 表");
            System.out.println("                        5.退      出\n");
            System.out.println("                     请选择（1-5）：");
            int meun = scan.nextInt();
            while (meun != 1 && meun != 2 && meun != 3 && meun != 4 &&  meun != 5){
                System.out.println("输入错误！请重新输入：");
                meun = scan.nextInt();
            }
            switch (meun) {
                case 1:
                    addNewCustomer();
                    break;
                case 2:
                    modifyCustomer();
                    break;
                case 3:
                    deleteCustomer();
                    break;
                case 4:
                    listAllCustomers();
                    break;
                case 5:
                    System.out.print("是否确认退出(Y/N)：");
                    char c = scan.next().charAt(0);
                    while (c != 'Y' && c != 'N'){
                        System.out.println("输入错误！请重新输入：");
                        c = scan.next().charAt(0);
                    }
                    if (c == 'Y')
                        flag = false;
                    break; // 这里是跳出switch语句
            }

        }
    }
    private void addNewCustomer(){
        System.out.println("\n ---------------------添加客户--------------------\n");
        System.out.println("请输入客户姓名：");
        String name = scan.next();
        System.out.println("请输入客户性别：");
        char gender = scan.next().charAt(0);
        System.out.println("请输入客户年龄：");
        int age =scan.nextInt();
        System.out.println("请输入客户电话：");
        String phone = scan.next();
        System.out.println("请输入客户邮箱：");
        String email = scan.next();
        Customer cust = new Customer(name,gender,age,phone,email);
        boolean flag = customerList.addCustomer(cust);
        if (flag){
            System.out.println("\n ---------------------添加成功！--------------------");
        }else{
            System.out.println("\n ---------------------添加失败！--------------------");
        }
    }
    private void modifyCustomer(){
        System.out.println("\n ---------------------修改客户--------------------\n");
        int index = -2;
        while(true){
            System.out.println("请输入您所要修改的客户的编号(-1退出)：");
            index = scan.nextInt();
            if (index == -1)
                return;
            Customer cust = customerList.getCustomer(index -1);
            if (cust == null){
                System.out.println("无法找到指定用户！");
            }else{
                System.out.println("姓名"+cust.getName()+"  请更改：");
                String name = scan.next();
                cust.setName(name);
                System.out.println("性别"+cust.getGender()+"  请更改：");
                char gender = scan.next().charAt(0);
                cust.setGender(gender);
                System.out.println("年龄"+cust.getAge()+"  请更改：");
                int age = scan.nextInt();
                cust.setAge(age);
                System.out.println("电话"+cust.getPhone()+"  请更改：");
                String phone = scan.next();
                cust.setPhone(phone);
                System.out.println("邮箱："+cust.getEmail()+"  请更改：");
                String email = scan.next();
                cust.setEmail(email);
                System.out.println("-----------------------修改成功-----------------------");
                return;
            }
        }
    }
    private void deleteCustomer(){
        System.out.println("------------------------删除客户---------------------");
        int index = 0;
        System.out.println("请输入您要删除的客户(-1退出)：");
        while(true) {
            System.out.println("请输入您所要修改的客户的编号(-1退出)：");
            index = scan.nextInt();
            if (index == -1)
                return;
            Customer cust = customerList.getCustomer(index - 1);
            if (cust == null) {
                System.out.println("无法找到指定用户！");
            } else {
                System.out.println("姓名" + cust.getName());
                System.out.println("是否删除(Y/N)：");
                char c = scan.next().charAt(0);
                while (c != 'Y' && c != 'N') {
                    System.out.println("输入错误！请重新输入：");
                    c = scan.next().charAt(0);
                }
                if (c == 'Y') {
                    boolean flag = customerList.deleteCusotmer(index - 1);
                    if (flag) {
                        System.out.println("-----------------------删除成功----------------------");
                    } else {
                        System.out.println("-----------------------删除失败-----------------------");
                    }
                }
                return;
            }
        }
    }
    private void listAllCustomers(){
        System.out.println("---------------------客户列表--------------------------");
        if (customerList.getTotal() == 0) {
            System.out.println("没有客户记录！");
        } else {
            System.out.println("编号\t\t姓名\t\t性别\t\t年龄\t\t电话\t\t\t\t邮箱");
            Customer[] custs = customerList.getCustomers();
            for (int i = 0; i < custs.length; i++) {
                System.out.println((i + 1) + "\t\t" + custs[i].getName() + "\t\t" + custs[i].getGender() + "\t\t"
                        + custs[i].getAge() + "\t\t" + custs[i].getPhone() + "\t\t" + custs[i].getEmail());
            }
        }
        System.out.println("--------------------客户列表完成------------------------");
    }
    public static void main(String[] args){
        CustomerView customerView = new CustomerView();
        customerView.enterMainMeun();
    }
}

面向对象特征之二：继承性

继承性的理解

> 自上而下：定义一个类A,在定义另一个类B时，发现类B的功能和A类似，考虑B继承于A类

> 自下而上：定义了类B,C,D等，发现B,C,D有类似的属性和方法，则可以考虑将相同的属性和方法进行抽取，封装到A类中，让B,C,D中相似的功能可以删除。

继承性的作用：

> 子类获取到父类中声明的所有的属性和方法。

> 但是，由于封装性的影响，可能子类不能直接调用父类中声明的属性或方法（比如private的属性就没法直接子类用）。

> 子类在继承父类以后，还可以拓展自己特有的功能（体现：增加特有的属性和方法）子类和父类的理解：区别于集合和子集

继承性的优势：

- 继承性的出现减少代码冗余，提高了代码的复用性。

- 继承性的出现，更有利于功能的拓展。

- 继承性的出现让类与类之间产生了 ' is-a '的关系，为多态的使用提供了前提。继承描述书屋之间的所属关系 ' is-a '的关系。

格式：

class A{

　　//属性、方法

}

class B extends A{

}

Java中声明的类，如果没有显示的声明其父类时，默认继承于java.lang.Object

基本概念：

类A: 父类、superClass、超类、基类

类B：子类、subClass、派生类

> java是支持多层继承故有：直接父类、间接父类

> Java中的子类的概念是相对的。 Java中一个父类可以有多个子类，但！一个子类只能有一个父类（Java的单继承性）

练习一

public class Mankind {
    private int sex;
    private int salary;

    /**
     * 首先习惯性的提供两个构造器  一个空参，一个全部包含的
     */
    public Mankind(){
    }
    public Mankind(int sex, int salary) {
        this.sex = sex;
        this.salary = salary;
    }

    /**
     * 提供所有参数的get set方法
     * @return
     */
    public int getSex() {
        return sex;
    }

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

    public int getSalary() {
        return salary;
    }

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

    /**
     * 根据sex的值显示"man"(sex == 1) 或者"woman"(sex == 0)
     */
    public void manOrWoman(){
        if(sex == 1){
            System.out.println("man");
        }else if (sex == 0){
            System.out.println("woman");
        }
    }

    /**
     * 根据salary的值显示"no job"(salary == 0) 或者"job"(salary!=0)
     */
    public void employeed(){
        if(salary == 0){
            System.out.println("no job");
        } else {
            System.out.println("job");
        }
    }
}

public class Kids extends Mankind{
    private int yearsOld;

    /**
     * 创建构造器 一个空参构造器  两个含参
     */
    public Kids(){
    }
    public Kids(int yearsOld) {
        this.yearsOld = yearsOld;
    }
    public Kids(int sex, int salary, int yearsOld){
        this.yearsOld = yearsOld;
        setSex(sex);  //因为sex 和 salar是父类中的  并且用private声明不可以直接在子类调用 所以只能用set方法赋值
        setSalary(salary);
    }
    public int getYearsOld() {
        return yearsOld;
    }

    public void setYearsOld(int yearsOld) {
        this.yearsOld = yearsOld;
    }

    public void printAge(){
        System.out.println("I am "+yearsOld+ " years old!");
    }
}

public class KidsTest {
    public static void main(String[] args) {
        Kids Kid = new Kids();
        Kid.setSex(1);
        Kid.setSalary(1000);
        Kid.setYearsOld(19);
        //来自于父类声明的方法
        Kid.manOrWoman();
        Kid.employeed();
        //Kids定义的方法
        Kid.printAge();
    }
}

练习二

public class Circle {
    private double radius;

    public Circle(){
        radius = 1; //默认初始化
    }

    public Circle(double radius) {
        this.radius = radius;
    }

    public void setRadius(double radius){
        this.radius = radius;
    }
    public double getRadius(){
        return radius;
    }
    public double findArea(){
        return (Math.PI*radius*radius);
    }
}

public class Cylinder extends Circle{
    private double length;
    public Cylinder(){
        length = 1; //默认初始化
    }
    public Cylinder(double length){
        this.length = length;
    }
    public Cylinder(double length, double radius){
        this.length = length;
        setRadius(radius);
    }

    public double getLength() {
        return length;
    }
    public void setLength(double length) {
        this.length = length;
    }

    public double findVolume(){
        return (findArea()*length);
    }
}

public class CylinderTest {
    public static void main(String[] args) {
        Cylinder c1 = new Cylinder();
        c1.setRadius(2.3);
        c1.setLength(1.4);
        System.out.println(c1.findVolume());
    }
}

方法的重写

为什么需要方法的重写：

子类在继承父类以后，就获得了父类中声明的所有方法。但是，父类中的方法可能不适用于子类。

因此，子类需要对父类的方法进行覆盖、覆写的操作。

遵循的规则

方法的声明格式：权限修饰符返回值类型方法名（形参列表）[throws 异常类型]{ //方法体 }

父类被重写的方法与子类重写的方法的方法名和形参列表相同
子类重写的方法的权限修饰符不能小于父类被重写方法的权限修饰符
- 子类不能重写父类中声明为private权限修饰的方法
关于返回值类型：
- 父类被重写的方法返回值是void，则子类重写的方法的返回值必须是void
- 父类被重写的方法的返回值类型是基本数据类型，则子类重写的方法的返回值类型必须与被重写方法的返回值类型相同。
- 父类被重写的方法的返回值类型是引用数据类型（比如类），则子类重写的方法的返回值类型可以与被重写的方法的返回值类型相同或者是被重写方法的返回值类型的子类
（后续内容）子类重写的方法抛出的异常类型可以与父类被重写的方法抛出的异常类型相同，或是父类被重写方法抛出的异常的子类

补充：方法体：没有要求。但是子类重写的方法的方法体必然与父类被重写的方法的方法体不同！

重载和重写的区分：

重载：“两同一不同” 同一个类、相同的方法名　　参数列表不同（① 参数个数不同 ② 参数类型不同）和返回值类型没什么关系

重写：继承以后，子类覆盖父类中同名同参数的方法

public class Circle {
    private double radius;
    public void setRadius(double radius){
        this.radius = radius;
    }
    public double getRadius(){
        return radius;
    }
    public double findArea(){
        return (Math.PI*radius*radius);
    }
}

public class Cylinder extends Circle{
    private double length;

    public double getLength() {
        return length;
    }
    public void setLength(double length) {
        this.length = length;
    }

    /**
     * 对Circle里面的findArea方法的重写
     * @return 圆柱的表面积
     */
    public double findArea(){ //在这里不能再用Circle里面的面积方法了  自己重写了 并且不可以用radius 私有
        return Math.PI*getRadius()*getRadius()*2 + 2*Math.PI*getRadius()*length;
    }
}

public class CylinderTest {
    public static void main(String[] args) {
        Cylinder c1 = new Cylinder();
        c1.setRadius(2.3);
        c1.setLength(1.4);
        System.out.println("圆柱的表面积：" + c1.findArea());
    }
}

posted on 2024-08-16 17:15 gjwqz 阅读(6) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Java基础10

· Java基础7

· Java-面向对象中

· Java基础

· JavaSE

阅读排行：
· winform 绘制太阳，地球，月球运作规律
· 超详细：普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· AI 智能体引爆开源社区「GitHub 热点速览」
· 写一个简单的SQL生成工具

gjwqz