知识点范围：面向对象

一、选择题

1. 使用下列哪个权限修饰符修饰的类的成员变量和方法，可以被当前包中所有类以及它的子类访问（ B ）。（选择1项）

• • A：public
• • B：protected
• • C：默认
• • D：private

解析：

image.png

2. 给出如下代码，如何使成员变量m被方法fun()直接访问（ C ）。（选择1项）

class Test {
    private int m;

    public static void fun() {
    }
}

• • A：将private int m改为protected int m
• • B：将private int m改为public int m
• • C：将private int m改为static int m
• • D：将private int m改为int m

解析：
静态方法内访问非静态成员变量有两种方式：

1. 成员变量前加static
2. 创建对象进行调用

3. 以下关于继承条件下构造方法执行过程的代码的执行结果是（ A ）。（选择1项）

class Person {
    public Person() {
        System.out.println("execute Person()");
    }
}

class Student extends Person {
    public Student() {
        System.out.println("execute Student() ");
    }
}

class PostGraduate extends Student {
    public PostGraduate() {
        System.out.println("execute PostGraduate()");
    }
}

public class Test {
    public static void main(String[] args) {
        new PostGraduate();
    }
}

• • A：

execute Person()
execute Student() 
execute PostGraduate()

• • B：execute PostGraduate()
• • C：

execute PostGraduate()
execute Student() 
execute Person()

• • D：没有结果输出

解析：
如果子类想创建空参构造方法，则必须保证父类也有空参构造方法。
如果子类想执行空参构造方法，则必须先执行父类的空参构造方法。

4. 以下关于this和super关键字的说法错误的是（ BD ）。（选择2项）

• • A：this关键字指向当前类的对象，super关键字指向当前类的直接父类的对象
• • B：在main方法中可以存在this或super关键字，但不能同时存在
• • C：this和super关键字都可以访问成员属性、成员方法和构造方法
• • D：在一个类的构造方法中可以同时使用this和super来调用其他构造方法

解析：

• A选项：this代表本类对象的一个引用，super代表本类直接父类的一个引用，正确
• B选项：静态方法、静态代码块等不允许使用this或super关键字，错误
• C选项：this和super代表的是对象的引用，可以调用类的属性和方法，正确
• D选项：在类的构造方法，this和super只能存在一个，且只能在第一行，错误

5. 给出下面的代码段，在// assignment x = a, y = b处写入如下（ D ）代码是正确的。（选择1项）

public class Base {
    int w, x, y, z;

    public Base(int a, int b) {
        x = a;
        y = b;
    }

    public Base(int a, int b, int c, int d) {
        // assignment x = a, y = b
        w = d;
        z = c;
    }
}

• • A：Base(a, b);
• • B：x = a, y = b;
• • C：this(a), this(b);
• • D：this(a, b);

解析：
this关键字可以调用构造方法。

6. 以下Java程序编译运行后的输出结果是（ A ）。（选择1项）

class HelloA {
    public HelloA() {
        System.out.println("HelloA");
    }

    {
        System.out.println("I'm A class");
    }

    static {
        System.out.println("static A");
    }
}

public class HelloB extends HelloA {
    public HelloB() {
        System.out.println("HelloB");
    }

    {
        System.out.println("I'm B class");
    }

    static {
        System.out.println("static B");
    }

    public static void main(String[] args) {
        new HelloB();
    }
}

• • A：

static A
static B
I'm A class
HelloA
I'm B class
HelloB

• • B：

static A
static B
I'm A class
I'm B class
HelloA
HelloB

• • C：

static A
I'm A class
HelloA
static B
I'm B class
HelloB

• • D：

static A
static B
HelloA
HelloB 
I'm A class
I'm B class

解析：
先父类后子类，先静态后构造，先代码后方法。

7. 下列选项中关于Java中super关键字的说法正确的是（ AD ）。（选择2项）

• • A：super关键字是在子类对象内部指代其父类对象的引用
• • B：super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
• • C：子类通过super关键字只能调用父类的方法，而不能调用父类的属性
• • D：子类通过super关键字可以调用父类的构造方法

解析：

• A选项：super代表本类直接父类的一个引用，正确
• B选项：super只能引用子类的直接父类对象，不能引用父类的父类对象，错误
• C选项：为了区分父类和子类重复的属性或方法时，可以使用super进行分区，错误
• D选项：允许使用super调用父类的构造方法，且必须是在首行进行调用，正确

8. Person类和Test类的代码如下所示，则代码中的错误语句是（ C ）。（选择1项）

class Person {
    public String name;

    public Person(String name) {
        this.name = name;
    }
}

public class Test {
    public static void main(String[] args) {
        final Person person = new Person("欧欧");
        person.name = "美美";
        person = new Person("亚亚");
    }
}

• • A：final Person person = new Person("欧欧");
• • B：person.name = "美美";
• • C：person = new Person("亚亚");
• • D：没有错误

解析：
final关键字：

1. 可以修饰类，则此类为终结类，不能有子类
2. 可以修饰变量，则此变量为常量，值不能再改变
3. 可以修饰方法，则此方法不能被覆写，允许被重载
4. 可以修饰对象，则此对象的引用地址不能再改变，但是对象的值允许改变

9. 以下Java代码运行的结果是（ B ）。（选择1项）

public class Test {
    final int age;

    public Test() {
        age = 10;
    }

    public static void main(String[] args) {
        System.out.println(new Test().age);
    }
}

• • A：输出：0
• • B：输出：10
• • C：输出：null
• • D：运行时出现异常

解析：
被final修饰的变量声明和赋值可以不在同一行，并在第一次赋值后不可再改变。

10. 以下代码中错误的语句是（ D ）。（选择1项）

public class Something {
    public static void main(String[] args) {
        final Other o = new Other();
        new Something().addOne(o);// 1
    }

    public void addOne(Other o) {
        o.i++;// 2
        o = new Other();// 3
    }
}

class Other {
    public int i;
}

• • A：1
• • B：2
• • C：3
• • D：没有错误

解析：
被final修饰的引用数据类型的变量的引用地址不可改变，但在调用方法时，对于引用数据类型的变量来说，形参只是实参的引用地址的一个拷贝，并没有用final修饰，所以引用地址可以改变。

11. 下列选项中，关于Java的抽象类和抽象方法说法正确的是（ AC ）。（选择2项）

• • A：抽象类中可以含有0个或多个抽象方法
• • B：抽象类中不可以有构造方法
• • C：一个类中若有抽象方法，则这个类必为抽象类
• • D：子类必须重写父类所有的抽象方法

解析：

• A选项：抽象类既可以有抽象方法，也可以没有抽象方法，正确
• B选项：抽象类允许有构造方法，但是不允许直接创建对象，需要借助子类向上转型，错误
• C选项：如果一个类中存在抽象方法，此类必须是抽象类或接口，接口是一种特殊的抽象类，正确
• D选项：如果子类也是抽象类，则不是必须重写抽象方法，错误

12. 在Java中关于abstract关键字，以下说法正确的是（ AB ）。（选择2项）

• • A：abstract类中可以没有抽象方法
• • B：abstract类的子类也可以是抽象类
• • C：abstract方法可以有方法体
• • D：abstract类可以直接创建对象

解析：

• A选项：抽象类既可以有抽象方法，也可以没有抽象方法，正确
• B选项：抽象类的子类可以是抽象类，也可以是普通类，正确
• C选项：抽象方法不允许有方法体，错误
• D选项：抽象类只能依靠子类向上转型来实例化对象，错误

13. 以下选项可替换题目中// add code here而不产生编译错误的是（ AD ）。（选择2项）

public abstract class MyClass {
    public int constInt = 5;

    // add code here
    public void method() {}
}

• • A：public abstract void method(int a);
• • B：constInt = constInt + 5;
• • C：public int method();
• • D：public abstract void anotherMethod();

解析：

• A选项：此方法是一个抽象方法，而且方法的形参和同名的method方法不同，满足方法重载，正确
• B选项：constInt变量属于成员变量，只有在创建对象时，才会为其分配空间，对象还没有创建时不允许进行运算，错误
• C选项：只有返回值不同时不构成方法重载，错误
• D选项：符合正常抽象方法的定义，正确

14. 在Java接口中，下列选项中属于有效的方法声明是（ A ）。（选择1项）

• • A：public void aMethod();
• • B：final void aMethod();
• • C：`void aMethod() {};
• • D：private void aMethod();

解析：
接口中只能定义抽象方法和全局常量，在JDK1.8之后允许定义static方法和default方法，且只允许用public和abstract修饰，public和abstract可以省略

15. 下列关于接口定义正确的说法是（ A ）。（选择1项）

• • A：接口中只能定义全局常量和抽象方法，JDK1.8后可以存在静态方法
• • B：接口中可以定义普通方法和普通变量
• • C：接口可以被new，抽象方法不行
• • D：接口不可以被继承，只能被实现，也可以被多个类实现

解析：

• A选项：接口中只能定义抽象方法和全局常量，在JDK1.8之后允许定义static方法和default方法，正确
• B选项：接口中不可以定义普通方法和普通变量，错误
• C选项：接口和抽象类都只能依靠子类向上实例化对象，错误
• D选项：接口可以被接口继承，错误

二、简答题

1. 简述private、默认、protected、public四个权限修饰符的作用。

   
   
   image.png

2. 说明成员变量和局部变量的区别。

   
   
   image.png
3. 说明方法重载和方法重写（覆盖）的区别。
   • 方法覆写(override)：
     1. 子类的方法覆盖父类的方法，要求子类与父类的返回值、方法名和参数列表都相同
     2. 子类方法抛出的异常不能超出父类相应方法抛出的异常
     3. 子类方法的访问权限不能低于父类相应方法的访问权限且父类方法不能是private
   • 方法重载(overload)：
     同一个类中的两个或两个以上的方法，拥有相同的方法名和不同的参数列表，最常见的重载的例子就是类的构造方法，如有参构造器和无参构造器
4. 说明==和equals()的联系和区别。
   • 基本数据类型：==表示判断两者值是否相等，没有equals()
   • 引用数据类型：==表示判断两者引用地址是否相同，equals()会默认调用==。因为String和包装类中的equals()覆写了Object中的equals()，所以会比较具体值是否相等而非判断引用地址是否相同，如：

Integer i1 = new Integer(10); 
Integer i2 = new Integer(10); 
i1 == i2;// false 
i1.equals(i2);// true 

5. 说明多态的前提条件。
   1. 要有继承关系
   2. 要有方法重写
   3. 要有父类引用指向子类的对象，如：父 f = new 子();
6. 说明final关键字的作用。
   • final 变量：若为基本数据类型则表示值恒定不变，若为引用数据类型则表示引用恒定不变
   • final 方法：把方法锁死，以防任何继承类通过覆写修改它的含义
   • final 类：表明无法继承当前类

7. 说明接口和抽象类的联系和区别。

   
   
   image.png

三、编码题

1. 使用面向对象的思想，编写自定义类描述狗的信息。设定属性包括：品种、年龄、心情、名字，方法包括：叫、跑。

• 要求：
  1. 设置属性的私有访问权限，通过公有的get/set方法实现对属性的访问
  2. 限定心情只能有“心情好”和“心情不好”两种情况，如果无效输入则进行提示，默认设置“心情好”
  3. 设置构造方法实现对属性的赋值
  4. 叫和跑的方法需要根据心情好坏，描述不同的行为方式
  5. 编写测试类，测试狗类的对象及相关方法

  6. 运行效果图：

     
     
     image.png
• 代码：

package leif;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        try {
            System.out.print("名字：");
            String name = scanner.next();
            System.out.print("年龄：");
            int age = scanner.nextInt();
            System.out.print("品种：");
            String breed = scanner.next();
            System.out.print("心情：");
            String mood = scanner.next();
            Dog dog = null;

            if ("心情好".equals(mood)) {
                dog = new Dog(name, age, breed, true);
            } else if ("心情不好".equals(mood)) {
                dog = new Dog(name, age, breed, false);
            } else {
                throw new Exception();
            }

            dog.run();
            dog.bark();
        } catch (Exception e) {
            System.out.println("输入信息错误，这只狗狗今天心情很好！");
        } finally {
            scanner.close();
        }
    }
}

class Dog {
    private String name;
    private int age;
    private String breed;
    private boolean mood;

    public Dog(String name, int age, String breed, boolean mood) {
        this.name = name;
        this.age = age;
        this.breed = breed;
        this.mood = mood;
    }

    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 getBreed() {
        return breed;
    }

    public void setBreed(String breed) {
        this.breed = breed;
    }

    public boolean isMood() {
        return mood;
    }

    public void setMood(boolean mood) {
        this.mood = mood;
    }

    public void bark() {
        System.out.print("名叫" + name + "的" + age + "岁" + breed + "心情");

        if (mood) {
            System.out.println("很好，开心的汪汪叫");
        } else {
            System.out.println("不好，伤心的呜呜叫");
        }
    }

    public void run() {
        System.out.print("名叫" + name + "的" + age + "岁" + breed + "心情");

        if (mood) {
            System.out.println("很好，开心的围着主人身边转");
        } else {
            System.out.println("不好，伤心的一动不动");
        }
    }
}

• 结果截图：

  
  
  image.png
  
  
  image.png
  
  
  image.png

2. 使用面向对象的思想，设计自定义类，描述出租车和家用轿车的信息。

• 设定：
  • 出租车类:
    属性：车型、车牌、所属出租公司
    方法：启动、停止
  • 家用轿车类：
    属性：
    车型、车牌、车主姓名
    方法：启动、停止
• 要求
  1. 提取出父类——汽车类
  2. 利用继承机制，实现出租车类和家用轿车类
  3. 编写测试类，分别测试汽车类、出租车类和家用轿车类对象的相关方法

  4. 运行效果图如下：

     
     
     image.png
• 代码：

package leif;

public class Test {
    public static void main(String[] args) {
        Car car = new Car("布加迪威龙", "豫J66666");
        car.start();
        car.stop();
        System.out.println("====================");
        FamilySedan familySedan = new FamilySedan("保时捷", "沪A77777", "楚子航");
        familySedan.start();
        familySedan.stop();
        System.out.println("====================");
        Taxi taxi = new Taxi("玛莎拉蒂", "京A88888", "卡塞尔出租车公司");
        taxi.start();
        taxi.stop();
    }
}

class Car {
    private String type;
    private String licencePlate;

    public Car(String type, String licencePlate) {
        this.type = type;
        this.licencePlate = licencePlate;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getLicencePlate() {
        return licencePlate;
    }

    public void setLicencePlate(String licencePlate) {
        this.licencePlate = licencePlate;
    }

    @Override
    public String toString() {
        return "Car [type=" + type + ", licencePlate=" + licencePlate + "]";
    }

    public void start() {
        System.out.println(toString());
        System.out.println("我是车，我启动");
    }

    public void stop() {
        System.out.println(toString());
        System.out.println("我是车，我停止");
    }
}

class FamilySedan extends Car {
    private String ownerName;

    public FamilySedan(String type, String licencePlate, String ownerName) {
        super(type, licencePlate);
        this.ownerName = ownerName;
    }

    public String getOwnerName() {
        return ownerName;
    }

    public void setOwnerName(String ownerName) {
        this.ownerName = ownerName;
    }

    @Override
    public String toString() {
        return "FamilySedan [type=" + super.getType() + ", licencePlate=" + super.getLicencePlate() + ", ownerName=" + ownerName + "]";
    }

    @Override
    public void start() {
        System.out.println(toString());
        System.out.println("我是" + ownerName + "，我的汽车我做主");
    }

    @Override
    public void stop() {
        System.out.println(toString());
        System.out.println("目的地到了，我们去玩吧");
    }
}

class Taxi extends Car {
    private String company;

    public Taxi(String type, String licencePlate, String company) {
        super(type, licencePlate);
        this.company = company;
    }

    public String getCompany() {
        return company;
    }

    public void setCompany(String company) {
        this.company = company;
    }

    @Override
    public String toString() {
        return "Taxi [type=" + super.getType() + ", licencePlate=" + super.getLicencePlate() + ", company=" + company + "]";
    }

    @Override
    public void start() {
        System.out.println(toString());
        System.out.println("乘客您好，我是" + company + "的，我的车牌是" + super.getLicencePlate() + "，您要去哪里？");
    }

    @Override
    public void stop() {
        System.out.println(toString());
        System.out.println("目的地已经到了，请您付费下车，欢迎再次乘坐");
    }
}

• 结果截图：

  
  
  image.png

3. 编写程序实现乐手弹奏乐器。乐手可以弹奏不同的乐器从而发出不同的声音，可以弹奏的乐器包括二胡、钢琴和琵琶。

• 思路：
  1. 定义乐器类Instrument，包括方法makeSound()
  2. 定义乐器类的子类：二胡Erhu、钢琴Piano和小提琴Violin
  3. 定义乐手类Musician，可以弹奏各种乐器play(Instrument i)
• 代码：

package leif;

public class Test {
    public static void main(String[] args) {
        Musician musician = new Musician();
        musician.play(new Instrument());
        musician.play(new Erhu());
        musician.play(new Piano());
        musician.play(new Violin());
    }
}

class Instrument {
    public void makeSound() {
        System.out.println("乐器的声音");
    }
}

class Erhu extends Instrument {
    @Override
    public void makeSound() {
        System.out.println("二胡的声音");
    }
}

class Piano extends Instrument {
    @Override
    public void makeSound() {
        System.out.println("钢琴的声音");
    }
}

class Violin extends Instrument {
    @Override
    public void makeSound() {
        System.out.println("小提琴的声音");
    }
}

class Musician {
    public void play(Instrument instrument) {
        instrument.makeSound();
    }
}

• 结果截图：

  
  
  image.png

4. 实现符合不同PCI规范的适配器。

• 思路：
  1. 定义PCI接口，具有传送数据send()方法
  2. 定义显卡VideaCard类，实现PCI接口
  3. 定义声卡AudioCard类，实现PCI接口
  4. 定义网卡NetCard类，实现PCI接口
  5. 定义测试类，让显卡、声卡、网卡发送数据
• 代码：

package leif;

public class Test {
    public static void main(String[] args) {
        new VideaCard().send();
        new AudioCard().send();
        new NetCard().send();
    }
}

interface PCI {
    public abstract void send();
}

class VideaCard implements PCI {
    @Override
    public void send() {
        System.out.println("显卡发送数据");
    }
}

class AudioCard implements PCI {
    @Override
    public void send() {
        System.out.println("声卡发送数据");
    }
}

class NetCard implements PCI {
    @Override
    public void send() {
        System.out.println("网卡发送数据");
    }
}

• 结果截图：

  
  
  image.png

5. 编写程序描述影视歌三栖艺人。

• 思路：
  • 分析影视歌三栖艺人的特性
    1. 可以演电影
    2. 可以演电视剧
    3. 可以唱歌
  • 定义多个接口描述特性
    1. 演电影的接口——方法：演电影
    2. 演电视剧的接口——方法：演电视剧
    3. 唱歌的接口——方法：唱歌

  • 定义艺人类实现多个接口，运行结果如下图：

    
    
    image.png
• 代码：

package leif;

public class Test {
    public static void main(String[] args) {
        Artist artist = new Artist("马素素");
        System.out.println(artist.toString());
    }
}

interface PlayFilms {
    public abstract String playFilems();
}

interface PlayTeleplays {
    public abstract String playTeleplays();
}

interface SingSongs {
    public abstract String singSongs();
}

class Artist implements PlayFilms, PlayTeleplays, SingSongs {
    private String name;

    public Artist(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "大家好！我是" + name + "\n我能" + playFilems() + "\n我能" + playTeleplays() + "\n我能" + singSongs();
    }

    @Override
    public String singSongs() {
        return "演电影";
    }

    @Override
    public String playTeleplays() {
        return "演电视剧";
    }

    @Override
    public String playFilems() {
        return "唱歌";
    }
}

• 结果截图：

  
  
  image.png

四、程序题

• 项目结构+README：

  
  
  image.png
  
  
  image.png
• 代码：

package entity;

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

    public Customer() {}

    public Customer(String name, String 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 String getGender() {
        return gender;
    }

    public void setGender(String 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;
    }

    @Override
    public String toString() {
        return "Customer [name=" + name + ", gender=" + gender + ", age=" + age + ", phone=" + phone + ", email=" + email + "]";
    }
}

package dao;

import java.util.ArrayList;
import java.util.List;

import entity.Customer;

public class CustomerDao {
    private static List<Customer> customerList;

    static {
        customerList = new ArrayList<Customer>();
    }

    private CustomerDao() {}

    public static List<Customer> getCustomerList() {
        return customerList;
    }
}

package service;

import java.util.List;

import entity.Customer;

public interface CustomerService {
    public abstract void create(Customer customer);

    public abstract void removeById(int id);

    public abstract List<Customer> find();

    public abstract Customer findById(int id);
}

package service.impl;

import java.util.List;

import dao.CustomerDao;
import entity.Customer;
import service.CustomerService;

public class CustomerServiceImpl implements CustomerService {
    private CustomerServiceImpl() {}

    private static volatile CustomerServiceImpl customerServiceImpl = null;

    public static CustomerServiceImpl getInstance() {
        if (customerServiceImpl == null) {
            synchronized (CustomerServiceImpl.class) {
                if (customerServiceImpl == null) {
                    customerServiceImpl = new CustomerServiceImpl();
                }
            }
        }

        return customerServiceImpl;
    }

    @Override
    public void create(Customer customer) {
        CustomerDao.getCustomerList().add(customer);
    }

    @Override
    public void removeById(int id) {
        CustomerDao.getCustomerList().remove(id);
    }

    @Override
    public List<Customer> find() {
        return CustomerDao.getCustomerList();
    }

    @Override
    public Customer findById(int id) {
        return CustomerDao.getCustomerList().get(id);
    }
}

package controller;

import java.util.Scanner;

import entity.Customer;
import service.CustomerService;
import service.impl.CustomerServiceImpl;
import util.CustomerUtil;

public class CustomerController {
    private static CustomerService customerService;

    static {
        customerService = CustomerServiceImpl.getInstance();
    }

    public CustomerController(int flag, Scanner scanner) {
        switch (flag) {
            case 1:
                System.out.println("----------添加客户----------");
                System.out.print("姓名：");
                String name1 = scanner.next();
                System.out.print("性别：");
                String gender1 = scanner.next();
                System.out.print("年龄：");
                int age1 = scanner.nextInt();
                System.out.print("电话：");
                String phone1 = scanner.next();
                System.out.print("邮箱：");
                String email1 = scanner.next();
                customerService.create(new Customer(name1, gender1, age1, phone1, email1));
                System.out.println("----------添加完成----------");
                break;
            case 2:
                System.out.println("----------修改客户----------");
                System.out.print("请选择待修改客户编号（-1退出）：");
                int id2 = scanner.nextInt();

                if (id2 == -1) {
                    break;
                }

                Customer customer = null;

                try {
                    customer = customerService.findById(id2 - 1);
                } catch (IndexOutOfBoundsException indexOutOfBoundsException) {
                    System.out.println("查无此人");
                    break;
                }

                scanner.nextLine();
                System.out.print("姓名（" + customer.getName() + "）：");
                String name2 = scanner.nextLine();

                if (!CustomerUtil.isEnter(name2)) {
                    customer.setName(name2);
                }

                System.out.print("性别（" + customer.getGender() + "）：");
                String gender2 = scanner.nextLine();

                if (!CustomerUtil.isEnter(gender2)) {
                    customer.setGender(gender2);
                }

                System.out.print("年龄（" + customer.getAge() + "）：");
                String age2 = scanner.nextLine();

                if (!CustomerUtil.isEnter(age2)) {
                    customer.setAge(Integer.valueOf(age2));
                }

                System.out.print("电话（" + customer.getPhone() + "）：");
                String phone2 = scanner.nextLine();

                if (!CustomerUtil.isEnter(phone2)) {
                    customer.setPhone(phone2);
                }

                System.out.print("邮箱（" + customer.getEmail() + "）：");
                String email2 = scanner.nextLine();

                if (!CustomerUtil.isEnter(email2)) {
                    customer.setEmail(email2);
                }

                System.out.println("----------修改完成----------");
                break;
            case 3:
                System.out.println("----------删除客户----------");
                System.out.print("请选择待删除客户编号（-1退出）：");
                int id3 = scanner.nextInt();

                if (id3 == -1) {
                    break;
                }

                System.out.print("确认是否删除（Y/N）：");

                if (CustomerUtil.isConfirmed(scanner.next())) {
                    customerService.removeById(id3 - 1);
                    System.out.println("----------删除完成----------");
                }

                break;
            case 4:
                System.out.println("----------客户列表----------");
                System.out.println("编号\t姓名\t性别\t年龄\t电话\t\t邮箱");
                int counter = 1;

                for (Customer customer4 : customerService.find()) {
                    System.out.println(counter + "\t" + customer4.getName() + "\t" + customer4.getGender() + "\t" + customer4.getAge() + "\t" + customer4.getPhone() + "\t" + customer4.getEmail());
                }

                System.out.println("----------客户列表----------");
                break;
            case 5:
                scanner.close();
                System.exit(0);
            default:
                System.out.println("输入错误！");
                break;
        }
    }
}

package util;

public class CustomerUtil {
    private CustomerUtil() {}

    public static boolean isEnter(String string) {
        if ("".equals(string)) {
            return true;
        } else {
            return false;
        }
    }

    public static boolean isConfirmed(String string) {
        if ("Y".equals(string) || "y".equals(string)) {
            return true;
        } else {
            if (!"N".equals(string) && !"n".equals(string)) {
                System.out.println("输入错误！");
            }

            return false;
        }
    }
}

package test;

import java.util.Scanner;

import controller.CustomerController;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (true) {
            System.out.println("-----客户信息管理软件-----");
            System.out.println("1. 添加客户");
            System.out.println("2. 修改客户");
            System.out.println("3. 删除客户");
            System.out.println("4. 客户列表");
            System.out.println("5. 退出");
            System.out.print("请选择（1~5）：");
            int flag = scanner.nextInt();
            new CustomerController(flag, scanner);
        }
    }
}

• 结果截图：

  
  
  image.png
  
  
  image.png
  
  
  image.png
  
  
  image.png
  
  
  image.png