Java学习笔记-3

knoci

已于 2024-04-25 21:14:25 修改

阅读量935

点赞数 18

分类专栏： Java学习文章标签： java 笔记

于 2024-02-01 21:01:45 首次发布

本文链接：https://blog.csdn.net/knoci/article/details/135981804

版权

Java学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

CustomerView类(包含main方法)

Java 重写与重载

重写(Override)

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，抛出 IOException 异常或者 IOException 的子类异常。

在面向对象原则里，重写意味着可以重写任何现有方法。实例如下：

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
 
      b.move();//执行 Dog 类的方法
   }
}

以上实例编译运行结果如下：

动物可以移动
狗可以跑和走

在上面的例子中可以看到，尽管 b 属于 Animal 类型，但是它运行的是 Dog 类的 move方法。

这是由于在编译阶段，只是检查参数的引用类型。

然而在运行时，Java 虚拟机(JVM)指定对象的类型并且运行该对象的方法。

因此在上面的例子中，之所以能编译成功，是因为 Animal 类中存在 move 方法，然而运行时，运行的是特定对象的方法。

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
   public void bark(){
      System.out.println("狗可以吠叫");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
      b.move();//执行 Dog 类的方法
      b.bark();
   }
}

以上实例编译运行结果如下：

TestDog.java:30: cannot find symbol
symbol  : method bark()
location: class Animal
                b.bark();
                 ^

该程序将抛出一个编译错误，因为b的引用类型Animal没有bark方法。

方法的重写规则

参数列表与被重写方法的参数列表必须完全相同。

返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。

访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。

父类的成员方法只能被它的子类重写。

声明为 final 的方法不能被重写。

声明为 static 的方法不能被重写，但是能够被再次声明。

子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。

子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。

重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。

构造方法不能被重写。

如果不能继承一个类，则不能重写该类的方法。

Super 关键字的使用

当需要在子类中调用父类的被重写方法时，要使用 super 关键字。

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      super.move(); // 应用super类的方法
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
 
      Animal b = new Dog(); // Dog 对象
      b.move(); //执行 Dog类的方法
 
   }
}

以上实例编译运行结果如下：

动物可以移动
狗可以跑和走

重载(Overload)

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

重载规则:

被重载的方法必须改变参数列表(参数个数或类型不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。

实例

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }
 
    public void test(int a){
        System.out.println("test2");
    }   
 
    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   
 
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   
 
    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

重写与重载之间的区别

区别点	重载方法	重写方法
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
访问	可以修改	一定不能做更严格的限制（可以降低限制）

总结

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

(1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
(2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
(3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

Java 封装

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

要访问该类的代码和数据，必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

封装的优点

1. 良好的封装能够减少耦合。
2. 类内部的结构可以自由修改。
3. 可以对成员变量进行更精确的控制。
4. 隐藏信息，实现细节。

实现Java封装的步骤

1. 修改属性的可见性来限制对属性的访问（一般限制为private），例如：

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

这段代码中，将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。

2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：

public class Person{
    private String name;
    private int age;

    public int getAge(){
      return age;
    }

    public String getName(){
      return name;
    }

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

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

采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。

实例

/* 文件名: EncapTest.java */
public class EncapTest{
 
   private String name;
   private String idNum;
   private int age;
 
   public int getAge(){
      return age;
   }
 
   public String getName(){
      return name;
   }
 
   public String getIdNum(){
      return idNum;
   }
 
   public void setAge( int newAge){
      age = newAge;
   }
 
   public void setName(String newName){
      name = newName;
   }
 
   public void setIdNum( String newId){
      idNum = newId;
   }
}

以上实例中public方法是外部类访问该类成员变量的入口。

通常情况下，这些方法被称为getter和setter方法。

因此，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。

Java 继承

继承的概念

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

生活中的继承：

兔子和羊属于食草动物类，狮子和豹属于食肉动物类。

食草动物和食肉动物又是属于动物类。

所以继承需要符合的关系是：is-a，父类更通用，子类更具体。

虽然食草动物和食肉动物都是属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。

类的继承格式

在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：

class 父类 { } class 子类 extends 父类 { }

为什么需要继承

接下来我们通过实例来说明这个需求。

开发动物类，其中动物分别为企鹅以及老鼠，要求如下：

企鹅：属性（姓名，id），方法（吃，睡，自我介绍）
老鼠：属性（姓名，id），方法（吃，睡，自我介绍）

企鹅类：

public class Penguin { 
    private String name; 
    private int id; 
    public Penguin(String myName, int  myid) { 
        name = myName; 
        id = myid; 
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是"         + id + "号" + name + "."); 
    } 
}

老鼠类：

public class Mouse { 
    private String name; 
    private int id; 
    public Mouse(String myName, int  myid) { 
        name = myName; 
        id = myid; 
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是"         + id + "号" + name + "."); 
    } 
}

从这两段代码可以看出来，代码存在重复了，导致后果就是代码量大且臃肿，而且维护性不高(维护性主要是后期需要修改的时候，就需要修改很多的代码，容易出错)，所以要从根本上解决这两段代码的问题，就需要继承，将两段代码中相同的部分提取出来组成一个父类：

公共父类：

public class Animal { 
    private String name;  
    private int id; 
    public Animal(String myName, int myid) { 
        name = myName; 
        id = myid;
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是"         + id + "号" + name + "."); 
    } 
}

这个Animal类就可以作为一个父类，然后企鹅类和老鼠类继承这个类之后，就具有父类当中的属性和方法，子类就不会存在重复的代码，维护性也提高，代码也更加简洁，提高代码的复用性（复用性主要是可以多次使用，不用再多次写同样的代码）继承之后的代码：

企鹅类：

public class Penguin extends Animal { 
    public Penguin(String myName, int myid) { 
        super(myName, myid); 
    } 
}

老鼠类：

public class Mouse extends Animal { 
    public Mouse(String myName, int myid) { 
        super(myName, myid); 
    } 
}

继承类型

需要注意的是 Java 不支持多继承，但支持多重继承。

继承的特性

子类拥有父类非 private 的属性、方法。

子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

子类可以用自己的方式实现父类的方法。

Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。

提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

继承关键字

继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承 Object（这个类在 java.lang 包中，所以不需要 import）祖先类。

extends关键字

在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, int myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
 
public class Penguin  extends  Animal{ 
}

implements关键字

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

输出结果为：

animal : eat
dog : eat
animal : eat

final 关键字

final 可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。

final 含义为 "最终的"。

使用 final 关键字声明类，就是把类定义定义为最终类，不能被继承，或者用于修饰方法，该方法不能被子类重写：

声明类：
```
final class 类名 {//类体}
```

声明方法：

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

注： final 定义的类，其中的属性、方法不是 final 的。

构造器

子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

class SuperClass {
  private int n;
  SuperClass(){
    System.out.println("SuperClass()");
  }
  SuperClass(int n) {
    System.out.println("SuperClass(int n)");
    this.n = n;
  }
}
// SubClass 类继承
class SubClass extends SuperClass{
  private int n;
  
  SubClass(){ // 自动调用父类的无参数构造器
    System.out.println("SubClass");
  }  
  
  public SubClass(int n){ 
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}
// SubClass2 类继承
class SubClass2 extends SuperClass{
  private int n;
  
  SubClass2(){
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass2");
  }  
  
  public SubClass2(int n){ // 自动调用父类的无参数构造器
    System.out.println("SubClass2(int n):"+n);
    this.n = n;
  }
}
public class TestSuperSub{
  public static void main (String args[]){
    System.out.println("------SubClass 类继承------");
    SubClass sc1 = new SubClass();
    SubClass sc2 = new SubClass(100); 
    System.out.println("------SubClass2 类继承------");
    SubClass2 sc3 = new SubClass2();
    SubClass2 sc4 = new SubClass2(200); 
  }
}

输出结果为：

------SubClass 类继承------
SuperClass()
SubClass
SuperClass(int n)
SubClass(int n):100
------SubClass2 类继承------
SuperClass(int n)
SubClass2
SuperClass()
SubClass2(int n):200

Java项目二（案例）：客户信息管理软件

软件功能

记录客户的个人信息，并能够打印客户列表。

软件说明

每个客户的信息被保存在Customer对象中。
以一个Customer类型的数组来记录当前所有的客户。
每次“添加客户”（菜单1）后，客户（Customer）对象被添加到数组中。
每次“修改客户”（菜单2）后，修改后的客户（Customer）对象替换数组中原对象。
每次“删除客户”（菜单3）后，客户（Customer）对象被从数组中清除。
执行“客户列表 ”（菜单4）时，将列出数组中所有客户的信息。

涉及Java知识点

面向对象编程
类结构的使用：属性、方法及构造器
对象的创建与使用
类的封装性
声明和使用数组
数组的插入、删除和替换
关键字的使用：this

程序代码示例

程序共有四个类文件，分别保存在四个包下，分别是：
com.kaho.java.bean ----- Customer.java
com.kaho.java.service ----- CustomerList.java
com.kaho.java.util ----- CMUtility.java
com.kaho.java.ui ----- CustomerView

Customer类

package com.kaho.java.bean;
/**
 Customer为实体类，用来封装客户信息
 该类封装客户的以下信息：
String name ：客户姓名
char gender ：性别
int age ：年龄
String phone：电话号码
String email ：电子邮箱
 提供各属性的get/set方法
 提供所需的构造器（可自行确定）

 这是一个JavaBean类型文件
 这个类中定义的方法用于对具体的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;
    }

    //getter、setter方法
    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;
    }

    //用于返回客户所有个人信息的方法
    public String getDetails(){
        return name + "\t\t" + gender + "\t\t" + age + "\t\t" + phone + "\t\t" + email;
    }

}

CustomerList类

package com.kaho.java.service;

import com.kaho.java.bean.Customer;  //该类用到了bean包下的Customer类

/**
CustomerList为Customer对象的管理模块，内部使用一维数组管理一组Customer对象
本类封装以下信息：
Customer[] customers：用来保存客户对象的数组
int total = 0 ：记录已保存客户对象的数量
该类至少提供以下构造器和方法：
public CustomerList(int totalCustomer)
public boolean addCustomer(Customer customer)
public boolean replaceCustomer(int index, Customer cust)
public boolean deleteCustomer(int index)
public Customer[] getAllCustomers()
public Customer getCustomer(int index)
public int getTotal()

 这个类中定义的各个方法用于对客户对象整体进行操作而不对具体对象的内部细节(即个人信息属性)进行操作

 */
public class CustomerList {
    private Customer[] customers;     //声明一个Customer类型的customers数组(未初始化)来保存多个客户"对象"
    private int total = 0;            //用来记录已保存客户对象的数量

    /**
    用途：构造器，用来初始化customers数组
    参数：totalCustomer：指定customers数组的最大空间
     */
    public CustomerList(int totalCustomer){
        customers = new Customer[totalCustomer];      //初始化数组，预先设定数组的总长度
    }

    //方法(增、删、改、查等)
    /**
    用途：将参数customer添加到数组中最后一个客户对象记录之后
    参数：customer指定要添加的客户对象
    返回：添加成功返回true；false表示数组已满，无法添加
     */
    public boolean addCustomer(Customer customer){
        if (total >= customers.length) return false;
        //total初始值为0，而后每添加一个客户对象会对total进行一次自增
        customers[total] = customer;
        total++;
        return true;
    }

    /**
    用途：用参数cust(Customer类型)替换数组中由索引index指定的对象
    参数：cust指定替换的新客户对象
		 index指定所替换对象在数组中的位置，从0开始
    返回：替换成功返回true；false表示索引无效，无法替换
     */
    public boolean replaceCustomer(int index, Customer cust){
        if (index > total - 1 || index < 0) return false;
        customers[index] = cust;  //将customers数组在索引index的元素赋为一个新的客户对象cust
        return true;
    }

    /**
    用途：从数组中删除参数index指定索引位置的客户对象记录
    参数： index指定所删除对象在数组中的索引位置，从0开始
    返回：删除成功返回true；false表示索引无效，无法删除
     */
    public boolean deleteCustomer(int index){
        if (index > total - 1 || index < 0) return false;
        for (int i = index;i < total - 1;i++){
            customers[i] = customers[i + 1];    //类似于顺序表的删除，从前往后，将后一位数组元素赋给前一位
        }
        customers[total - 1] = null; //将新数组已赋值部分(0 ~ total-1)的最后一个多出来的重复元素抹去，设置为空指针(引用型数据类型)
        total--;        //删除一个客户对象，数组已赋值部分长度减一
        return true;
    }

    /**
    用途：返回数组中记录的所有客户对象
    返回： Customer[] 数组中包含了当前所有客户对象，该数组长度与对象个数相同。
     注意：不能直接return customers，因为实际上customers数组的长度是初始化时的totalCustomer(即 10)，而非已赋了值的前 total个
     */
    public Customer[] getAllCustomers(){
        Customer[] cust = new Customer[total];
        for (int i = 0;i < total;i++){
            cust[i] = customers[i];     //这里是将对象的地址赋给新数组，两个数组保存的都是这几个已记录的客户对象
        }
        return cust;
    }

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

    /**
    用途：获取当前已记录的客户数量
    返回：当前customers[]数组的长度
     */
    public int getTotal(){
        return total;
    }
}

Utility类

package com.kaho.java.util;

import java.util.*;   //导入util包

/**
 CMUtility工具类：
 将不同的功能封装为方法，就是可以直接通过调用方法使用它的功能，而无需考虑具体的功能实现细节。
 */
public class CMUtility {
    private static Scanner scanner = new Scanner(System.in);

    /**
     用于界面菜单的选择。该方法读取键盘，如果用户键入’1’-’5’中的任意字符，则方法返回。返回值为用户键入字符。
     */
    public static char readMenuSelection() {
        char c;
        for ( ; ; ) {
            String str = readKeyBoard(1, false);
            c = str.charAt(0);       //charAt()返回字符串中指定索引的字符,这里读取键盘输入的一串字符串中的第一个字符
            if (c != '1' && c != '2' &&
                    c != '3' && c != '4' && c != '5') {
                System.out.print("选择错误，请重新输入：");
            } else break;
        }
        return c;
    }

    /**
     从键盘读取一个字符，并将其作为方法的返回值。
     */
    public static char readChar() {
        String str = readKeyBoard(1, false);
        return str.charAt(0);          //charAt()返回字符串中指定索引的字符
    }

    /**
     从键盘读取一个字符，并将其作为方法的返回值。
     如果用户不输入字符而直接回车，方法将以defaultValue 作为返回值。
     */
    public static char readChar(char defaultValue) {
        String str = readKeyBoard(1, true);
        return (str.length() == 0) ? defaultValue : str.charAt(0);
    }

    /**
     从键盘读取一个长度不超过2位的整数，并将其作为方法的返回值。
     */
    public static int readInt() {
        int n;
        for ( ; ; ) {
            String str = readKeyBoard(2, false);
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }

    /**
     从键盘读取一个长度不超过2位的整数，并将其作为方法的返回值。
     如果用户不输入字符而直接回车，方法将以defaultValue 作为返回值。
     */
    public static int readInt(int defaultValue) {
        int n;
        for (; ; ) {
            String str = readKeyBoard(2, true);
            if (str.equals("")) {
                return defaultValue;
            }

            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }

    /**
     从键盘读取一个长度不超过limit的字符串，并将其作为方法的返回值。
     */
    public static String readString(int limit) {
        return readKeyBoard(limit, false);
    }

    /**
     从键盘读取一个长度不超过limit的字符串，并将其作为方法的返回值。
     如果用户不输入字符而直接回车，方法将以defaultValue 作为返回值。
     */
    public static String readString(int limit, String defaultValue) {
        String str = readKeyBoard(limit, true);
        return str.equals("")? defaultValue : str;
    }

    /**
     用于确认选择的输入。该方法从键盘读取‘Y’或’N’，并将其作为方法的返回值。
     */
    public static char readConfirmSelection() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1, false).toUpperCase();
            c = str.charAt(0);
            if (c == 'Y' || c == 'N') {
                break;
            } else {
                System.out.print("选择错误，请重新输入：");
            }
        }
        return c;
    }

    private static String readKeyBoard(int limit, boolean blankReturn) {
        String line = "";

        while (scanner.hasNextLine()) {
            line = scanner.nextLine();
            if (line.length() == 0) {
                if (blankReturn) return line;
                else continue;
            }

            if (line.length() < 1 || line.length() > limit) {
                System.out.print("输入长度（不大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
        }

        return line;
    }
}

CustomerView类(包含main方法)

package com.kaho.java.ui;

//分别导入位于其他包内的几个需要使用到的类
import com.kaho.java.bean.Customer;
import com.kaho.java.util.CMUtility;
import com.kaho.java.service.CustomerList;

/**
 * @Description CustomerView为主模块，负责菜单的显示和处理用户操作
 * @author Kaho
 * @version
 * @date 2020.10.16
 *
 */
public class CustomerView {
    CustomerList customerList = new CustomerList(10);
    //创建CustomerList的对象，供以下各成员方法使用。同时该对象通过构造器初始化了一个最大能包含十个客户对象的Customer类型数组customers

    /**
    用途：显示主菜单，响应用户输入，根据用户操作分别调用其他相应的成员方法，以完成客户信息处理。
     */
    public void enterMainMenu(){
        boolean isFlag = true;     //定义一个boolean类型的标记作为是否终止循环的判断条件
        do {
            System.out.println("-------------------客户信息管理软件--------------------\n");
            System.out.println("                    1.添加客户");
            System.out.println("                    2.修改客户");
            System.out.println("                    3.删除客户");
            System.out.println("                    4.客户列表");
            System.out.println("                    5. 退  出\n");
            System.out.print("请选择(1-5):");

            char key = CMUtility.readMenuSelection();  //读取用户菜单选择
            switch (key) {
                case '1':
                    addNewCustomer();  //添加客户
                    break;
                case '2':
                    modifyCustomer();  //修改客户信息
                    break;
                case '3':
                    deleteCustomer();  //删除客户
                    break;
                case '4':
                    listAllCustomers();//显示客户列表
                    break;
                case '5':
                    System.out.print("是否确定退出？(Y/N):");         //退出软件
                    //再次读取用户是否确认退出
                    char exit = CMUtility.readConfirmSelection();
                    if (exit == 'Y'){
                        isFlag = false;
                    }
                    break;
            }

        }while(isFlag);
    }

    /**
     * 用途：调用CustomerList类和CMUtility类中的方法读取新客户的信息并将封装好的客户对象添加到customers数组中
     */
    private void addNewCustomer(){
        System.out.println("-------------------添加客户--------------------\n");
        //读取新客户各项信息并保存到相应变量中
        System.out.print("姓名：");
        String name = CMUtility.readString(5);
        System.out.print("性别：");
        char gender = CMUtility.readChar();
        System.out.print("年龄：");
        int age = CMUtility.readInt();
        System.out.print("电话：");
        String phone = CMUtility.readString(13);
        System.out.print("邮箱：");
        String email = CMUtility.readString(20);

        //将读取到的信息全部导入一个新的对象中，即封装成一个新的客户对象
        Customer customer = new Customer(name,gender,age,phone,email);

        //调用CustomerList中的方法将此客户对象添加到customerList对象属性的customers数组中
        boolean isFlag = customerList.addCustomer(customer);
        if (isFlag == true){
            System.out.println("-------------------添加完成--------------------\n");
        }else{
            System.out.println("-------------人数已达上限，添加失败！-------------\n");
        }

    }

    /**
     * 用途：修改指定索引的客户信息
     */
    private void modifyCustomer(){
        System.out.println("-------------------修改客户--------------------\n");
        Customer customer;  //用于存放单个对象，作为中转站
        int index;    //存放用户输入的编号(从1开始)

        //用来找到指定对象的模块
        for ( ; ; ){
            System.out.print("请选择待修改客户编号(-1退出):");

            //客户编号index从1开始
            index = CMUtility.readInt();

            if (index == -1){
                return;
            }

            /*
            将合法编号(长度不超过2的整数)上的那个客户对象赋给customer，这样下面修改信息的模块
            就可直接用customer调用相应get方法得到该对象的各个属性
             */
            customer = customerList.getCustomer(index - 1);

            if (customer == null){
                System.out.println("无法找到指定客户！");
            }else{
                break;    //若customer存在(即指定位置上客户对象存在:非空指针)，则跳出循环，进行下面的修改信息模块
            }
        }

        //用来修改客户信息的模块
        System.out.print("姓名(" + customer.getName() + "):");
        //如果用户输入了姓名，则返回用户输入的信息，如果用户没有输入，直接回车，则返回customer.getName()。以下的几个方法也一样
        String name = CMUtility.readString(5,customer.getName());

        System.out.print("性别(" + customer.getGender() + "):");
        char gender = CMUtility.readChar(customer.getGender());

        System.out.print("年龄(" + customer.getAge() + "):");
        int age = CMUtility.readInt(customer.getAge());

        System.out.print("电话(" + customer.getPhone() + "):");
        String phone = CMUtility.readString(13,customer.getPhone());

        System.out.print("邮箱（" + customer.getEmail() + "):");
        String email = CMUtility.readString(20,customer.getEmail());

        // 获取用户输入的新的信息以后，用新的信息封装成一个最新的Customer对象，再赋给customer
        customer = new Customer(name,gender,age,phone,email);

        //用修改后得到的新的客户对象customer替换掉原来对象数组中相应位置未修改的客户对象
        //注意：新的客户对象的地址与原本的customers[index - 1]上的元素(未修改信息的对象)的地址不同，因为是新new的对象
        boolean isFlag = customerList.replaceCustomer(index - 1,customer);

        if (isFlag == true){
            System.out.println("-------------------修改完成--------------------\n");
        }else{
            System.out.println("-------------------修改失败--------------------\n");
        }
    }



    /**
     * 用途：删除客户
     */
    private void deleteCustomer(){
        System.out.println("-------------------删除客户--------------------\n");
        Customer customer;  //定义一个Customer类型的变量用于存储客户对象，并没有new一个新的对象
        int index;
        for ( ; ; ) {
            System.out.print("请选择待删除客户编号(-1退出):");

            //客户编号index从1开始
            index = CMUtility.readInt();    //读取一个客户编号

            //如果读取到用户输入-1，则退出删除客户模式
            if (index == -1) {
                return;
            }

            //将合法编号(长度不超过2的整数)上的那个客户对象赋给customer
            customer = customerList.getCustomer(index - 1);

            //如果该编号上有客户对象存在则跳出循环，否则输出提示并重新循环
            if (customer == null) {
                System.out.println("无法找到指定客户！");
            } else {
                break;
            }
        }

        // 一旦找到相应的索引位置的customer以后，让用户决定是否确认删除
        System.out.print("确认是否删除(Y/N):");
        char deleteOrNot = CMUtility.readConfirmSelection();
        System.out.println();
        if (deleteOrNot == 'Y'){
            boolean isFlag = customerList.deleteCustomer(index - 1);
            /*
            用customerList对象调用deleteCustomer()操作，其删除的是customerList对象属性的数组customers[]中的相应位置元素对象。
            若删除成功返回true；false表示索引无效，无法删除
             */

            if (isFlag == true){
                System.out.println("-------------------删除完成--------------------\n");
            }else{
                System.out.println("-------------------删除失败--------------------\n");
            }
        }else{
            return;
        }
    }


    /**
     * 用途：显示客户列表
     */
    private void listAllCustomers(){
        System.out.println("-------------------客户列表--------------------\n");

        //定义一个Customer类型数组customers用于存放通过customerList调用方法获取到的属性数组中的所有已记录的客户对象
        Customer[] customers = customerList.getAllCustomers();

        if (customers.length == 0){
            System.out.println("没有任何客户记录！\n");
        }else {
            System.out.println("编号\t\t姓名\t\t性别\t\t电话号码\t\t电子邮箱");
            for (int i = 0; i < customers.length; i++) {
                Customer cust = customers[i];
                /*
                把数组内的每一个元素(即一个Customer客户对象)赋给Customer类型的变量cust。
                由于cust的定义在for循环中，故每进行一次循环赋一个新的对象，每个对象只被下面这条语句
                调用一次用于一次性得到客户所有信息。
                 */
                System.out.println( (i+1) +"\t\t"+ cust.getDetails());
            }
        }
        System.out.println("-----------------客户列表完成------------------\n");
    }


    /**
     * main()方法部分
     * @param args
     */
    public static void main(String[] args) {
        CustomerView view = new CustomerView();
        view.enterMainMenu();
    }

}

knoci

关注

18
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
Java学习笔记-3

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。(1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。(2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
复制链接

扫一扫