java面相对象基础知识1

Delete102

已于 2023-05-20 19:00:22 修改

阅读量241

点赞数

分类专栏： java 文章标签： java 开发语言 eclipse Powered by 金山文档

于 2023-03-29 23:45:51 首次发布

本文链接：https://blog.csdn.net/qq_50147784/article/details/129620390

版权

java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

什么是面相对象

用人的世界观去改变计算机的世界观（人的想法，让计算机按照人的思维去实现出来）

1.1 对象

（万物皆对象）

静态：说明是什么

动态：说明做什么

1.2. 类

具有相同属性（静态）和行为（动态）的一类事物。

1.3 类与对象的关系

类是对象的模板，对象是类的实例。

1.4类的写法

                访问控制修饰符： class   className{
                                                //代码块
                                                        }

1.5方法的定义

 访问控制修饰符： 返回值类型   方法名 ([参数列表]) {
                                                //代码块
                                      }

1.6类与对象练习

题目：

编写一个学生类：

属性：学号、姓名、性别、年龄（要求>=18）

构造方法：一个构造方法给4个属性全部赋值，另一个构造方法只给学号和姓名赋值，性别默认是男，年龄默认18

方法：自我介绍（输出其基本信息），学习（输出***正在学习）

编写测试类，创建两个实例分别调用两个构造方法，并测试其两个方法。

package C;

public class Student {
        int XH=0;
        String Name=null;
        char sex=0;
        int age=20;
        public Student(int xH, String name) {
            super();
            XH = xH;
            Name = name;
            System.out.println(name+"正在学习");
        }
        public Student(int xH, String name, char sex, int age) {
            super();
            XH = xH;
            Name = name;
            this.sex = sex;
            this.age = age;
            System.out.println(name+"正在学习");
        }
        public int getXH() {
            return XH;
        }
        public void setXH(int xH) {
            XH = xH;
        }
        public String getName() {
            return Name;
        }
        public void setName(String name) {
            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;
        }      
}

package C;

public class Address {
    
    
    public static void main(String[] args) {
        Student student=new Student(1910421, "悟空", '女', 120);
        System.out.println(student.getXH()+"\t"+student.getName()+"\t"+student.getSex()+"\t"+student.getAge());
        Student student1=new Student(1910422, "八戒");
        student1.setSex('男');
        student1.setAge(220);
        System.out.println(student1.getXH()+"\t"+student1.getName()+"\t"+student1.getSex()+"\t"+student1.getAge());
    }

}

2.面相对象的特点

2.1封装

2.1.1 概念

隐藏属性 . 方法或方法实现细节的过程。

2.1.2 封装的最终状态

私有属性，共有方法。

2.13 访问控制修饰符及其应用范围

补充：

一个封装至少2个构造方法：无参的和包含所参数的

如果一个类中,没有创建构造方法，那么该类包含一个隐形，无参的构造方法

一旦声明构造方法，就会覆盖原本隐形的和无参构造

2.14 构造方法（构造器）

方法名与类名相同的方法

特点：方法名与类名相同；没有返回值，连 void 都没有

作用：初始化成员变量。

如果一个类中没有创建构造方法，那么该类就包含一个隐性、无参的构造方法；

一旦声明了一个构造方法，那么该构造方法就覆盖了原本隐性、无参的构造方法。。

SUN 公司建议，一个封装类中至少包含两个构造方法，一个是无参的，一个是包含所有参数（属性/字段/成员变量）的。

2.1.5 关键字this

自己的，本类的。

修饰属性：this.属性名，表示本类成员变量。

修饰方法：this.方法名()，表示本类成员方法。

修饰构造方法：this()，只能放第一行。

2.1.6 方法格式

返回值，参数

1、无返回值，无参数

2、无返回值，有参数

3、有返回值，无参数

4、有返回值，有参数

public class Person {
//属性（静态的）以变量来表示的
        private String name; //姓名
        private int age;     //年龄
//无返回值，无参数
public void eat() {
  System.out.println("吃饭");
  }
//无返回值，有参数
public void eat(String name) {
   System.out.println("名字："+name);
   }
//有返回值，有参数
public String eat(String name) {
  return name;
  }
//有返回值，无参数
public String eat() {
   String name = "快餐";
   return name;
}

2.1.7 方法重载(Overload)

方法名相同，参数列表（参数类型，参数个数，参数顺序）不同。

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

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

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

2.1.7.1重载规则:

被重载的方法必须改变参数列表(参数个数或类型不一样)；

被重载的方法可以改变返回类型；

被重载的方法可以改变访问修饰符；

被重载的方法可以声明新的或更广的检查异常；

方法能够在同一个类中或者在一个子类中被重载。

无法以返回值类型作为重载函数的区分标准。

2.1.8 方法重写(Override)

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

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

2.1.7.1方法的重写规则

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

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

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

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

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

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

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

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

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

构造方法不能被重写。

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

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

2.1.9 重写与重载之间的区别

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

2.1.10总结

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

(1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。

(2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。

(3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

2.2 继承extends

2.2.1 概念

在一个类的基础上，产生一个新类的过程叫继承。原来的类叫超类（父类），新产生的类叫

子类（派生类）

2.2.2 特点

1、子类可以继承父类非私有的属性和方法

2、子类可以扩展自己的属性和方法

3、子类不可以继承父类的构造器，只能调用

4、子类可以重写父类的方法（方法重写）

5、可以声明父类，创建子类

a) 声明什么类型，就可以调用该类型的属性和方法

b) 创建什么类型，就可以调用该类型的属性和方法

c) 创建什么类型，就可以强转为该类型

方法重写：方法签名（方法名+参数列表[参数类型，个数，顺序]）相同，实现不同

子类的范围不能严于父类

2.3 多态

2.3.1概念：

同种事物，不同（多种）形态

2.3.2多态的优点

1. 消除类型之间的耦合关系

2. 可替换性

3. 可扩充性

4. 接口性

5. 灵活性

6. 简化性

2.3.3多态存在的三个必要条件

继承

重写

父类引用指向子类对象：Parent p = new Child();

2.3.4 表现

表现：方法重载，方法重写

public class Animal {
        public void eat() {}
}
//---------------------------------------------------------
public class Dog extends Animal {
        @Override
        public void eat() {
            System.out.println("用舌头一下一下舔着吃");
        }
}
//---------------------------------------------------------
public class Pig extends Animal { 
        @Override
        public void eat() {
        System.out.println("吞着吃");
        }
}
//---------------------------------------------------------
public class Demo {
        public static void main(String[] args) {
            Dog dog = new Dog();
            dog.eat();
            Animal an = new Dog();
            // an.eat();
            //instanceof():对象引用运算符（判断左侧的对象是否属于右侧类的实例）
            if(an instanceof Dog) {
                an.eat();
            }
            if(an instanceof Pig) {
                an.eat();
            }
        }
}

2.4 抽象abstract

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

2.4.1 抽象方法

由 abstract 修饰的方法叫抽象方法

特点：没有方法体

作用：用来供子类进行方法重写的

2.4.2 抽象类

由 abstract 修饰的类叫抽象类

特点：不能 new 自己；只能 new（实例化）其子类

2.4.3 抽象方法与抽象类的关系

有抽象方法的类一定是抽象类；抽象类中不一定包含抽象方法。

3.封装

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

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

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

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

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

2.1封装的优点

1. 良好的封装能够减少耦合。

2. 类内部的结构可以自由修改。

3. 可以对成员变量进行更精确的控制。

4. 隐藏信息，实现细节。

2.2实现Java封装的步骤

1. 修改属性的可见性来限制对属性的访问（一般限制为private）。（私有属性）

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

4.接口

interface/implements

由 interface 修饰的类，叫接口

接口中存放的都是抽象方法，这些方法省略了 abstract 关键字

接口相当于一个父类，该类满足了部分子类的需求

一个类既有继承，又有实现，一定是先继承，后实现；如果实现多个接口，多个接口中间用

逗号隔开，它们没有先后顺序。

接口不能 new 自己，只能 new 其实现子类。

5.枚举 enum

Java 枚举是一个特殊的类，一般表示一组常量，比如一年的 4 个季节，一个年的 12 个月份，一个星期的 7 天，方向有东南西北等。

Java 枚举类使用 enum 关键字来定义，各个常量使用逗号 , 来分割。

例如定义一个颜色的枚举类。

enum Color

{

RED, GREEN, BLUE;

}

6.异常（Exception）

6.1什么是异常：

在程序运行过程中出现的不正常情况分类：1.运行时异常 2.编译时异常

6.2异常处理

try....catch:

try::放的是有可能出现异常的代码

catch:捕捉异常，处理异常

finally:放的是一定会执行的代码

int a = 5;
Copyright© ZLZ
6
Everything is possible
int b = 2;
// if(b==0) {
// System.out.println("0不能做除数");
// }else {
// System.out.println(a/b);
// }
try {
System.out.println(a/b);
}catch (Exception e) {
e.printStackTrace();
}finally {//流的关闭，JDBC中链接的关闭
System.out.println("程序执行结束");
}
try{
     //try块中放可能发生异常的代码。
     //如果执行完try且不发生异常，则接着去执行finally块和finally后面的代码（如果有的话）。
     //如果发生异常，则尝试去匹配catch块。
 
}catch(SQLException SQLexception){
    //每一个catch块用于捕获并处理一个特定的异常，或者这异常类型的子类。Java7中可以将多个异常声明在一个catch中。
    //catch后面的括号定义了异常类型和异常参数。如果异常与之匹配且是最先匹配到的，则虚拟机将使用这个catch块来处理异常。
    //在catch块中可以使用这个块的异常参数来获取异常的相关信息。异常参数是这个catch块中的局部变量，其它块不能访问。
    //如果当前try块中发生的异常在后续的所有catch中都没捕获到，则先去执行finally，然后到这个函数的外部caller中去匹配异常处理器。
    //如果try中没有发生异常，则所有的catch块将被忽略。
 
}catch(Exception exception){
    //...
}finally{
 
    //finally块通常是可选的。
   //无论异常是否发生，异常是否匹配被处理，finally都会执行。
   //一个try至少要有一个catch块，否则， 至少要有1个finally块。但是finally不是用来处理异常的，finally不会捕获异常。
  //finally主要做一些清理工作，如流的关闭，数据库连接的关闭等。 
}
需要注意的地方
try块中的局部变量和catch块中的局部变量（包括异常变量），以及finally中的局部变量，他们之间不可共享使用。
每一个catch块用于处理一个异常。异常匹配是按照catch块的顺序从上往下寻找的，只有第一个匹配的catch会得到执行。匹配时，不仅运行精确匹配，也支持父类匹配，因此，如果同一个try块下的多个catch异常类型有父子关系，应该将子类异常放在前面，父类异常放在后面，这样保证每个catch块都有存在的意义。
java中，异常处理的任务就是将执行控制流从异常发生的地方转移到能够处理这种异常的地方去。也就是说：当一个函数的某条语句发生异常时，这条语句的后面的语句不会再执行，它失去了焦点。执行流跳转到最近的匹配的异常处理catch代码块去执行，异常被处理完后，执行流会接着在“处理了这个异常的catch代码块”后面接着执行。

try-catch-finally-return执行顺序
如果不发生异常，不会执行catch部分。
不管有没有发生异常，finally都会执行到。
即使try和catch中有return时，finally仍然会执行
finally是在return后面的表达式运算完后再执行的。（此时并没有返回运算后的值，而是先把要返回的值保存起来，若finally中无return，则不管finally中的代码怎么样，返回的值都不会改变，仍然是之前保存的值），该情况下函数返回值是在finally执行前确定的)
finally部分就不要return了，要不然，就回不去try或者catch的return了。
看一个例子：
public static void main(String[] args) throws IOException {    
       System.out.println("result：" + test());    
   }    
   private static int test() {    
       int temp = 1;    
       try {    
           System.out.println("start execute try,temp is:"+temp);    
           return ++temp;    
       } catch (Exception e) {    
           System.out.println("start execute catch temp is: "+temp);    
           return ++temp;    
       } finally {    
           System.out.println("start execute finally,temp is:" + temp);    
           ++temp;    
       }    
   }

//结果
start execute try,temp is:1    
start execute finally,temp is:2    
result:2

throw

程序员也可以通过throw语句手动显式的抛出一个异常。throw语句的后面必须是一个异常对象。

throw 语句必须写在函数中，执行throw 语句的地方就是一个异常抛出点，它和由JRE自动形成的异常抛出点没有任何差别。

任何Java代码都可以通过 Java 的throw语句抛出异常

public static int divide(int x, int y) throws ArithmeticException {
 if (y == 0) {
 throw new ArithmeticException("抛出除 0 异常");
 }
 return x / y;
}

自定义异常

自定义异常通常是定义一个继承自 Exception 类的子类。因此这样的自定义异常都属于检查异常（checked exception）。如果要自定义非检查异常，则扩展自RuntimeException。

throws与throw的区别

区别1：
 throws:
     跟在方法声明后面，后面跟的是异常类名
 
 throw:
    用在方法体内，后面跟的是异常类对象名   
public static void method() throws ArithmeticException {// 跟在方法声明后面，后面跟的是异常类名
        int a=10;
        int b=0;
        if(b==0) {
            throw new ArithmeticException();用在方法体内，后面跟的是异常类对象名 
        }else {
            System.out.println(a/b);
        }
    }
}
区别2：
throws:
    可以跟多个异常类名，用逗号隔开
 
 throw:
   只能抛出一个异常对象名 

 public static void method() throws ArithmeticException,Exception {//跟多个异常类名，用逗号隔开
        int a=10;
        int b=0;
        if(b==0) {
            throw new ArithmeticException();// 只能抛出一个异常对象名
        }else {
            System.out.println(a/b);
        }
    }
}

区别3：
throws:
     表示抛出异常，由该方法的调用者来处理
 
 throw:
    表示抛出异常，由该方法体内的语句来处理

public class throwandthrows {
    public static void main(String[] args) {
        try {
        method();//由该方法的调用者来处理
    }catch (ArithmeticException e) {
           e.printStackTrace();
    }
    }

    public static void method() throws ArithmeticException {
        int a=10;
        int b=0;
        if(b==0) {
            throw new ArithmeticException();//由该方法体内的语句来处理
        }else {
            System.out.println(a/b);
        }
    }
}


区别4：
throws:
     throws表示有出现异常的可能性，并不一定出现这些异常
 
 throw:
    throw则是抛出了异常，执行throw一定出现了某种异常
1
2
3
4
5
我们向上面例子代码里throws一个IndexOutOfBoundsException异常,编译发现并没有报错，这就体现了throws表示有出现异常的可能性


public class throwandthrows {
    public static void main(String[] args) {
        try {
        method();
    }catch (ArithmeticException e) {
           e.printStackTrace();
    }
    }

    public static void method() throws ArithmeticException,IndexOutOfBoundsException {
        int a=10;
        int b=0;
        if(b==0) {
            throw new ArithmeticException();
        }else {
            System.out.println(a/b);
        }
    }
}

6.3为什么需要自定义异常

Java提供的异常体系不可能预见所有的错误。

业务开发中，使用自定义异常，可以让项目代码更加规范，也便于管理。

按照国际惯例，自定义的异常应该总是包含如下的构造函数：

一个无参构造函数

一个带有String参数的构造函数，并传递给父类的构造函数。

一个带有String参数和Throwable参数，并都传递给父类构造函数

一个带有Throwable 参数的构造函数，并传递给父类的构造函数

public class IOException extends Exception
{
    static final long serialVersionUID = 7818375828146090155L;
 
    public IOException()
    {
        super();
    }
 
    public IOException(String message)
    {
        super(message);
    }
 
    public IOException(String message, Throwable cause)
    {
        super(message, cause);
    }
 
    public IOException(Throwable cause)
    {
        super(cause);
    }
}

6.4 常见的异常情况

NullPointerException

空指针异常，最常见的一个异常类。简言之，调用了未经初始化的对象或者是不存在的对象，就会产生该异常。

ArithmeticException

算术异常类，程序中出现了除数为0这样的运算，就会出现这样的异常。

ClassCastException

类型强制转换异常,它是JVM在检测到两个类型间转换不兼容时引发的运行时异常。

ArrayIndexOutOfBoundsException

数组下标越界异常，跟数组打交道时，需要注意一下这个异常。

FileNotFoundException

文件未找到异常，一般是要读或者写的文件，找不到，导致该异常。

SQLException

操作数据库异常，它是Checked Exception（检查异常）；

IOException

IO异常，一般跟读写文件息息相关，它也是Checked Exception（检查异常）。平时读写文件，记得IO流关闭！

NoSuchMethodException

方法未找到异常

NumberFormatException

字符串转换为数字异常

7.阶段练习

7.1 使用面向对象的方式完成图书借阅管理系统

7.1.1 基础知识写《图书管理系统》

1.基本框架使用数组初始化，判断是否循环do-while（），switch() 来写

2.使用构造方法

3.方法调用

package Books;

import java.util.Scanner;

public class BookManager {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BookTest book=new BookTest();
        Scanner input = new Scanner(System.in);
        int fan = 0;
        boolean flag = true;
        int c = 0;
        do {
            System.out.println("***欢迎使用图书管理系统***");
            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.println("6、退出系统");
            System.out.println("---------------------");
            System.out.print("请选择:");
            c = input.nextInt();
            switch (c) {
            case 1: // 新增
                book.add();
                break;
            case 2:// 查看
                book.cha();
                break;
            case 3:// 删除
                book.delete();
                break;
            case 4:// 借出
                book.borrow();
                break;
            case 5:// 归还
                book.reBook();
                break;
            case 6:// 退出
                System.out.println("-->退出图书");
                flag = false;
                System.out.println("*******************************");
                break;
            default:
                System.out.println("输入错误，请重新输入...");
                continue;
            }
            
    
            if (flag) {
                System.out.print("输入“0”返回：");
                fan = input.nextInt();
            } else {
                break;
            }
            } while (fan == 0);
            System.out.print("谢谢使用！");
    }

}

package Books;

public class Book {
    
    //私有属性
    private String[] zhuangt= {"已借出","可借阅","可借阅",null,null,null};
    private String[] bname={"大学语文","高等数学","数据结构",null,null,null};
    private int[] date= {3,5,6,0,0,0};
    private int[] borr= {888,666,789,0,0,0};
    
    //公有方法
    public String[] getZhuangt() {
        return zhuangt;
    }
    public void setZhuangt(String[] string) {
        this.zhuangt = string;
    }
    public String[] getBname() {
        return bname;
    }
    public void setBname(String[] bname) {
        this.bname = bname;
    }
    public int[] getDate() {
        return date;
    }
    public void setDate(int[] date) {
        this.date = date;
    }
    public int[] getBorr() {
        return borr;
    }
    public void setBorr(int[] borr) {
        this.borr = borr;
    }
    
    //构造器
    public Book(String[] zhuangt, String[] bname, int[] date, int[] borr) {
        super();
        this.zhuangt = zhuangt;
        this.bname = bname;
        this.date = date;
        this.borr = borr;
    }
    public Book() {
        super();
    }
    
}

package Books;

import java.util.Scanner;

//父 Book 子 BookTest
public class BookTest extends Book {
    Scanner input = new Scanner(System.in);
    // get得到
    String[] bname = getBname();
    String[] zhuangt = getZhuangt();
    int[] date = getDate();
    int[] borr = getBorr();
    
    
    int index = -1;// 位置
    int borrDate = 0; // 日期

    public void add() {// 新增
        System.out.println("-->新增图书");
        System.out.print("请输入图书名称：");
        String bk1 = input.next();
        boolean flag1 = false;// 判断是否新增成功
        for (int i = 0; i < bname.length; i++) {
            if (bname[i] == null) {
                zhuangt[i] = "可借阅";
                bname[i] = bk1;
                flag1 = true;
                System.out.println("新增《" + bk1 + "》成功！");
                break;
            }
        }
        if (!flag1) {
            System.out.println("新增《" + bk1 + "》失败！书架已满");
        }
        System.out.println("*******************************");
    }

    public void delete() {// 删除
        System.out.println("-->删除图书");
        System.out.print("请输入要删除的图书名字：");
        String delName = input.next();
        boolean flag2 = false;
        for (int i = 0; i < bname.length; i++) {
            if (bname[i] != null && delName.equals(bname[i]) && zhuangt[i].equals("可借阅")) {// 可借阅
                flag2 = true;
                index = i;
                System.out.println("删除成功");
            }
            else if (bname[i] != null && delName.equals(bname[i]) && zhuangt[i].equals("已借出")) {
                flag2 = true;
                System.out.println("该书本被借出，无法删除");
                break;
            }
        }

        if (index != -1) {
            for (int i = index; i < bname.length; i++) {
                if (i != bname.length - 1) {
                    bname[i] = bname[i + 1];
                    zhuangt[i] = zhuangt[i + 1];
                    borr[i] = borr[i + 1];
                    date[i] = date[i + 1];
                }

                bname[bname.length - 1] = null;
                zhuangt[zhuangt.length - 1] = null;
                date[bname.length - 1] = 0;
                borr[bname.length - 1] = 0;
            }
        }

        if (!flag2) {
            System.out.println("没有找到该图书");
        }
        System.out.println("**********************************");
    }

    public void cha() {// 查看
        System.out.println("-->查看图书");
        System.out.print("序号\t名称\t\t状态\t\t借出日期\t\t借出次数\n");
        for (int i = 0; i <= bname.length - 1; i++) {
            if (bname[i] != null) {
                String bDate = date[i] == 0 ? "" : date[i] + "日";
                System.out.print((i + 1) + "\t" + bname[i] + "\t\t" + zhuangt[i] + "\t\t" + bDate + "\t\t" + borr[i] + "\n");
            }
        }
        System.out.println("*******************************");
    }

    public void borrow() {// 借出
        System.out.println("-->借出图书");
        System.out.print("请输入图书名称：");
        String borrname = input.next();
        for (int i = 0; i < bname.length; i++) {
            if (bname == null) {
                System.out.println("没有找到匹配的book信息！");
                break;
            } else if (borrname.equals(bname[i]) && zhuangt[i].equals("可借阅")) {
                zhuangt[i] = "已借出";
                borr[i]++;
                System.out.println("请输入借出日期：");
                borrDate = input.nextInt();
                while (borrDate < 1 && borrDate > 31) {
                    System.out.println("日期输入错误请重新输入：");
                    borrDate = input.nextInt();
                }
                System.out.println("借出《" + borrname + "》成功！");
                break;
            } else if (borrname.equals(bname[i]) && zhuangt[i].equals("已借出")) {
                System.out.println("该book已借出，无法再借！");
                break;
            } else if (i == bname.length - 1) {
                System.out.println("没有找到匹配的book信息！");
                break;
            }
        }
        System.out.println("*******************************");
    }

    public void reBook() {// 归还
        System.out.println("-->归还图书");
        System.out.print("请输入要归还的图书名称：");
        String returnName = input.next();
        boolean flag3 = false;
        for (int i = 0; i < bname.length; i++) {
            if (bname[i] != null && returnName.equals(bname[i]) && zhuangt[i].equals("已借出")) {// 已借出
                System.out.println("请输入归还日期：");
                int returnDate = input.nextInt();
                while (returnDate < borrDate) {
                    System.out.println("归还日期不能小于借出日期，请重新输入：");
                    returnDate = input.nextInt();
                }
                flag3 = true;
                index = i;
                System.out.println("归还《" + returnName + "》成功");
                System.out.println("借出日期：" + borrDate + "日");
                System.out.println("归还日期：" + returnDate + "日");
                System.out.println("借出日期：" + ((returnDate - borrDate) * 2) + "元");
            } else if (bname[i] != null && returnName.equals(bname[i]) && zhuangt[i].equals("可借阅")) {
                System.out.println("该书本未被借出，无法归还！");
                break;
            }
        }

        if (index != -1) {
            for (int i = 0; i < bname.length; i++) {
                if (i != bname.length - 1) {
                    zhuangt[i] = "可借阅";
                    date[i] = 0;
                }
            }
        }
        if (!flag3) {
            System.out.println("没有找到匹配的book信息！");
        }
        System.out.println("*******************************");
    }
}

5.2 汽车租赁

package moto;

public abstract class MotoVehicle {//汽车
    private String brand;//品牌
    private String vehicleId;//车牌
    private int perRent;//日租金
    
    public abstract float calRent(int days);

    public MotoVehicle(String brand, String vehicleId, int perRent) {
        super();
        this.brand = brand;
        this.vehicleId = vehicleId;
        this.perRent = perRent;
    }

    public MotoVehicle() {
        super();
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getVehicleId() {
        return vehicleId;
    }

    public void setVehicleId(String vehicleId) {
        this.vehicleId = vehicleId;
    }

    public int getPerRent() {
        return perRent;
    }

    public void setPerRent(int perRent) {
        this.perRent = perRent;
    }
}

package moto;

public class Bus extends MotoVehicle{
    private int seatCount; //座位数
    
    
    public Bus(String brand, String vehicleId, int perRent, int seatCount) {
        super(brand, vehicleId, perRent);
        this.seatCount = seatCount;
    }

    public Bus() {
    }

    @Override
    public float calRent(int days) {
        float price = this.getPerRent() * days;
        if(days >=3 && days <7) {
            price *= 0.9f;
        }else if(days >= 7 && days < 30) {
            price *= 0.8f;
        }else if(days >= 30 && days <150) {
            price *= 0.7f;
        }else {
            price *=0.6f;
        }
        return price;
    }

    public int getSeatCount() {
        return seatCount;
    }

    public void setSeatCount(int seatCount) {
        this.seatCount = seatCount;
    }
}

package moto;

public class Car extends MotoVehicle {
    private String type;//型号
    
    public Car(String brand, String vehicleId, int perRent, String type) {
        super(brand, vehicleId, perRent);
        this.type = type;
    }
    
    public Car() {
    }
    
    @Override
    public float calRent(int days) {
        float price = this.getPerRent() * days;
        if(days > 7 && days <= 30) {
            price *= 0.9f;
        }else if(days > 30 && days <=150) {
            price *= 0.8f;
        }else {
            price *= 0.7f;
        }
        return price;
    }

    public String getType() {
        return type;
    }

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

package Books;

import java.util.Scanner;

//父 Book 子 BookTest
public class BookTest extends Book {
    Scanner input = new Scanner(System.in);
    // get得到
    String[] bname = getBname();
    String[] zhuangt = getZhuangt();
    int[] date = getDate();
    int[] borr = getBorr();
    
    
    int index = -1;// 位置
    int borrDate = 0; // 日期

    public void add() {// 新增
        System.out.println("-->新增图书");
        System.out.print("请输入图书名称：");
        String bk1 = input.next();
        boolean flag1 = false;// 判断是否新增成功
        for (int i = 0; i < bname.length; i++) {
            if (bname[i] == null) {
                zhuangt[i] = "可借阅";
                bname[i] = bk1;
                flag1 = true;
                System.out.println("新增《" + bk1 + "》成功！");
                break;
            }
        }
        if (!flag1) {
            System.out.println("新增《" + bk1 + "》失败！书架已满");
        }
        System.out.println("*******************************");
    }

    public void delete() {// 删除
        System.out.println("-->删除图书");
        System.out.print("请输入要删除的图书名字：");
        String delName = input.next();
        boolean flag2 = false;
        for (int i = 0; i < bname.length; i++) {
            if (bname[i] != null && delName.equals(bname[i]) && zhuangt[i].equals("可借阅")) {// 可借阅
                flag2 = true;
                index = i;
                System.out.println("删除成功");
            }
            else if (bname[i] != null && delName.equals(bname[i]) && zhuangt[i].equals("已借出")) {
                flag2 = true;
                System.out.println("该书本被借出，无法删除");
                break;
            }
        }

        if (index != -1) {
            for (int i = index; i < bname.length; i++) {
                if (i != bname.length - 1) {
                    bname[i] = bname[i + 1];
                    zhuangt[i] = zhuangt[i + 1];
                    borr[i] = borr[i + 1];
                    date[i] = date[i + 1];
                }

                bname[bname.length - 1] = null;
                zhuangt[zhuangt.length - 1] = null;
                date[bname.length - 1] = 0;
                borr[bname.length - 1] = 0;
            }
        }

        if (!flag2) {
            System.out.println("没有找到该图书");
        }
        System.out.println("**********************************");
    }

    public void cha() {// 查看
        System.out.println("-->查看图书");
        System.out.print("序号\t名称\t\t状态\t\t借出日期\t\t借出次数\n");
        for (int i = 0; i <= bname.length - 1; i++) {
            if (bname[i] != null) {
                String bDate = date[i] == 0 ? "" : date[i] + "日";
                System.out.print((i + 1) + "\t" + bname[i] + "\t\t" + zhuangt[i] + "\t\t" + bDate + "\t\t" + borr[i] + "\n");
            }
        }
        System.out.println("*******************************");
    }

    public void borrow() {// 借出
        System.out.println("-->借出图书");
        System.out.print("请输入图书名称：");
        String borrname = input.next();
        for (int i = 0; i < bname.length; i++) {
            if (bname == null) {
                System.out.println("没有找到匹配的book信息！");
                break;
            } else if (borrname.equals(bname[i]) && zhuangt[i].equals("可借阅")) {
                zhuangt[i] = "已借出";
                borr[i]++;
                System.out.println("请输入借出日期：");
                borrDate = input.nextInt();
                while (borrDate < 1 && borrDate > 31) {
                    System.out.println("日期输入错误请重新输入：");
                    borrDate = input.nextInt();
                }
                System.out.println("借出《" + borrname + "》成功！");
                break;
            } else if (borrname.equals(bname[i]) && zhuangt[i].equals("已借出")) {
                System.out.println("该book已借出，无法再借！");
                break;
            } else if (i == bname.length - 1) {
                System.out.println("没有找到匹配的book信息！");
                break;
            }
        }
        System.out.println("*******************************");
    }

    public void reBook() {// 归还
        System.out.println("-->归还图书");
        System.out.print("请输入要归还的图书名称：");
        String returnName = input.next();
        boolean flag3 = false;
        for (int i = 0; i < bname.length; i++) {
            if (bname[i] != null && returnName.equals(bname[i]) && zhuangt[i].equals("已借出")) {// 已借出
                System.out.println("请输入归还日期：");
                int returnDate = input.nextInt();
                while (returnDate < borrDate) {
                    System.out.println("归还日期不能小于借出日期，请重新输入：");
                    returnDate = input.nextInt();
                }
                flag3 = true;
                index = i;
                System.out.println("归还《" + returnName + "》成功");
                System.out.println("借出日期：" + borrDate + "日");
                System.out.println("归还日期：" + returnDate + "日");
                System.out.println("借出日期：" + ((returnDate - borrDate) * 2) + "元");
            } else if (bname[i] != null && returnName.equals(bname[i]) && zhuangt[i].equals("可借阅")) {
                System.out.println("该书本未被借出，无法归还！");
                break;
            }
        }

        if (index != -1) {
            for (int i = 0; i < bname.length; i++) {
                if (i != bname.length - 1) {
                    zhuangt[i] = "可借阅";
                    date[i] = 0;
                }
            }
        }
        if (!flag3) {
            System.out.println("没有找到匹配的book信息！");
        }
        System.out.println("*******************************");
    }
}

package moto;

public class MotoOper {
    MotoVehicle [] motos = new MotoVehicle[8];
    
    public void init() {
        motos[0] = new Car("宝马", "陕A1111", 800, "X6");
        motos[1] = new Car("宝马", "陕A2222", 600, "530");
        motos[2] = new Car("奥迪", "陕A3333", 450, "A6");
        motos[3] = new Car("奥迪", "陕A4444", 600, "Q7");
        motos[4] = new Bus("金龙", "陕B5555", 800, 16);
        motos[5] = new Bus("金杯", "陕B6666", 800, 16);
        motos[6] = new Bus("金龙", "陕B7777", 1500, 34);
        motos[7] = new Bus("金杯", "陕B8888", 1500, 34);
    }
    
    //租赁业务实现
    public MotoVehicle motoLeaseOut(String brand,String type,int seat) {
        MotoVehicle moto = null;
        for(MotoVehicle mymoto : motos) {
            if(mymoto instanceof Car) {//确定租赁轿车
                Car car = (Car)mymoto;
                if(car.getBrand().equals(brand) && car.getType().equals(type)) {
                    moto = car;
                    break;
                }
            }else if(mymoto instanceof Bus){//确定租赁客车
                Bus bus = (Bus)mymoto;
                if(bus.getBrand().equals(brand) && bus.getSeatCount()==seat) {
                    moto = bus;
                    break;
                }
            }else {
                
            }
        }
        return moto;
    }
    
//    public MotoVehicle motoLeaseOut(String brand,String type,int seat) {
//        MotoVehicle moto = null;
//        for(MotoVehicle mymoto : motos) {
//            if(mymoto instanceof Car) {//确定租赁轿车
//                Car car = (Car)mymoto;
//                if(car.getBrand().equals(brand) && car.getType().equals(type)) {
//                    return car;
//                }
//            }else {//确定租赁客车
//                Bus bus = (Bus)mymoto;
//                if(bus.getBrand().equals(brand) && bus.getSeatCount()==seat) {
//                    return bus;
//                }
//            }
//        }
//        return null;
//    }
}