新手小白Java学习8——面向对象3

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

抽象类、内部类、接口

一、抽象类

1. 为什么需要抽象类

尽管在当前阶段，即使没有抽象类也可以实现大部分功能，但在特定场景下，使用抽象类能够更好地组织代码，提高代码的可维护性和复用性。

1.1 代码解释

• 从代码层面考虑，当多个子类需要重写父类的同一个或几个方法时，如果这些方法的实现逻辑在父类中没有实际意义，可以考虑将这些方法定义为没有方法体的方法。
• 有两种方式可以实现上述需求：
  • native方法： 子类可以选择不重写这些方法（编译时不会报错），但在运行时可能会出现错误。此外，可以通过引入第三方语言开发的接口调用native方法，或者所有子类都重写native方法。
  • abstract方法： 如果一个类中包含抽象方法，那么这个类必须声明为抽象类。同样地，如果一个类中包含抽象方法且还包含子类，在编译时会报错。解决办法是将类声明为抽象类，或者所有子类都重写父类的抽象方法。

通过抽象方法的引入，我们可以引出抽象类的概念。

@Setter
@Getter
@AllArgsConstructor
@NoArgsConstructor
public abstract class Teacher {
     private int id;
     private String name;
     private int age;
     public void introduce() {
         System.out.println(this.toString());//继承关系下 this: ?类对象
     }
     //在讲解?法的组成部分的时候
     //?个?法?法体可以不?带的
     //每个?类都重写了?类的?法 发现?类提供的代码逻辑 没有任何意义的
     //需求: ?类?法不需要提供?法体。
     //?个类中 出现了没有?法体?法
     //1. native的?法
     //2. 抽象?法 abstract
    // public native Object teach();
     //调?teach?法 不会报错
     //1.1 加载第三?语?提供teach功能的接?
     //1.2 ?类全部重写teach?法
     //1.3 对于native的?法 在编译期间 ?类不重写 ?类不会报错
     //抽象?法: 没有?法体。 就是规则。针对于?类，要求?类全部重写?类??提供的抽象?
    法
     //有可能会报错: ?个类中出现了抽象?法 这个类肯定是个抽象类
     public abstract Object teach();
     
     //满???替换原则
     //1. ?类出现的任意?个地?都可以使??类替换
     //2. ?类不要重写?类的?法
     //3. 如果要重写 尽可能使?抽象类以及接?。
}

1.2 程序设计解释

//从程序设计/开发规范(习惯)?度进?解释
//抽象类: 对类的抽象。----> ?类 -----> 抽象类肯定也是作为?类使?。
//?个类作为?类使? 这个类?般就是?个抽象类。AbstractXXX / BaseXXX
//?不?都可以。
//?个普通类依然可以作为?类使?。?类服务于?类。
//在继承关系下 ?般不会创建?类对象
//?前是?个普通类作为?类 可以创建普通类对象 没有意义。 抽象类 更加体现这?点设计思
想。

2. 语法

抽象类和抽象方法的语法如下所示：

public abstract class 类名{
 
}

简单来说，Java中的抽象就是声明接口（方法签名）而不实现具体的功能。

3. 组成部分

@Setter
@Getter
public abstract class MyAbstractClass { //?般都是作为?类
     //1. 抽象类中不?定有抽象?法
     //2. ?个类中 有抽象?法 这个类必须是?个抽象类
     //组成部分
     private String name;
     private static void demo() {
     }
     //抽象?法: 没有?法体的?法-----> 必须要实现----> ?类实现
     //abstract可以与哪些修饰符综合使?? public protected 默认
     public abstract void demo1();
     protected abstract void demo2();
     abstract void demo3();

     //构造?法
     public MyAbstractClass(String name) {
         this.name = name;
     }
}

4. 作用

作为父类使用，定义所有子类都应具备的行为。功能上与普通类相似，主要区别在于包含了抽象方法。

public class Child extends MyAbstractClass {
     //?类继承抽象类 报错?
     //1. 对于?类?? 可以将?类也改为抽象类
     //2. 对于?类?? 必须重写抽象类??所有的抽象?法
     //3. 对于调??法 ?需关注?类的?法功能 直接看?类即可

     @Override
     public void demo1() {

     }
     @Override
     protected void demo2() {
     }
     @Override
     void demo3() {
     }
 
}

5. 总结

利用抽象的概念，可以在开发项目中构建具有良好扩展性的架构，优化程序设计。抽象类和抽象方法是软件开发过程中的设计层面概念，通常由设计人员设计，而程序员则负责继承这些抽象类并覆盖抽象方法，实现具体功能。抽象类是抽象方法的容器，如果一个类中包含抽象方法，该类必须声明为抽象类。即使没有抽象方法，只要一个类不应该有具体对象，也应该声明为抽象类。抽象类不能直接实例化，只能用于继承。抽象类的子类应该提供对所有抽象方法的具体实现。如果子类没有实现所有抽象方法，该子类仍然为抽象类，只能用于继承，不能实例化，但可以有构造函数，用于帮助子类快速初始化共有的属性。

二、内部类

内部类是在一个类的内部创建的另一个类。理解内部类有助于我们更好地阅读和理解底层源码。

1. 成员内部类

与成员变量和方法处于同一级别，在类的内部但在方法的外部。

1.1 静态内部类

public class User {
     public int num = 100;
     public void a() {
         System.out.println("a.....");
     }
     //成员内部类
     //1. ?静态内部类 (不允许维护static修饰的成员)
     public class AClass {
         public String str = "hello";
         public void demo1() {
             System.out.println("demo1...........");
         }
         public AClass() {
         }
     }
}

public static void main(String[] args) {
     //获得AClass?? str demo1()
     //User user = new User();
     //System.out.println(user.num);
     //user.a();
     //User.AClass aClass = user.new AClass();
     User.AClass aClass = new User().new AClass();
     System.out.println(aClass.str);
     aClass.demo1();
}

1.2 静态内部类

public class User {
     public int num = 100;
     public void a() {
         System.out.println("a.....");
     }
     public static String name = "admin";
     //成员内部类
     //2.静态内部类 static 组成部分推荐使?static
     public static class BClass {
     public int num3 = 1000;
     public static int num4 = 4000;
     public static void demo2() {
         System.out.println("demo2...........");
     }
     public void demo3() {
         System.out.println("demo3...........");
     }
     public BClass() {
     }
 }

private static void demo2() {
     //调?BClass类??的属性+?法
     System.out.println(User.name);
     System.out.println(User.BClass.num4);
     User.BClass.demo2();
     User.BClass bClass = new User.BClass();
     bClass.demo3();
     System.out.println(bClass.num3);
}

2. 局部内部类

在方法体内部编写的类。

public class User {
     public int num = 100;
     public int a() {
         System.out.println("a.....");
         //2 局部内部类 只能服务于本?法
         class CClass {
                 private int a = 100;
                 public int test() {
                 System.out.println("test.....级别?较?的逻辑");
                 return a += 100;
             }
         }
         return new CClass().test();
     }
}

3. 匿名内部类

任何类都可以创建匿名内部类，相当于类的子类。语法如下：

类名 引用/对象 = new 类名(){};

private static void demo4() {
     //User user1 = new User();
     User user2 = new User(){
         public int aaa = 100;
         @Override
         public void b() {
         System.out.println("匿名内部类....重写b.....");
     }
     };//匿名内部类===> ?类
     user2.b();
}

三、接口

1. 接口语法

1.1 接口概念

在生活中，最常见的接口例子就是USB接口。许多设备带有预定义的接口，用户使用特定的产品进行连接。接口就是规则，就像电脑上的USB接口一样，许多厂商根据这些规则提供具体的产品（具体实现）。类似的例子还包括电脑与鼠标/键盘的连接、手机与充电线的连接、灯泡与灯头的连接、主板与内存条的连接等。这些例子都体现了接口提供的可扩展性。

在程序中，接口的概念与生活中的接口相似。程序中的接口用于定义规则，根据不同的需求提供不同的实现。可以将接口视为生活中店铺的“招牌”，看到“招牌”就能知道店铺销售的商品。因此，程序中的接口主要用于封装行为。

1.2 面向接口编程

接口是设计层面的概念，通常由设计师设计，将定义与实现分离。程序员实现接口，实现具体方法。面向接口编程并不独立于面向对象编程，而是面向对象编程体系的一部分，体现了面向对象编程的思想精髓之一。面向接口编程意味着在面向对象的系统中，所有类或模块之间的交互都是通过接口完成的。

1.3 接口语法

[访问权限修饰符] interface 接?名 {
    公开静态常量列表；
    公开抽象?法列表；
}

在开发中:
 接?的命名?式只有2种
 XXXDao/DAO.java XXXDaoImpl.java 
 xxxService.java xxxServiceImpl.java

1.4 接口组成部分

目前我们使用的是JDK11。

//jdk1.8+ 接?声明为函数式接? 使?标记注解 @FunctionalInterface
//@FunctionalInterface //有且只有1个抽象?法
public interface MyInterface {
     //组成部分----> 都是public
     //1.常量 public static final 默认 final修饰的变量都是常量
     //接?作为常量类使?---->维护模块中很多不可变的数据
     //1.1 常量名称全部?写
     //1.2 必须赋值
     //1.3 值不允许被更改
     String NAME = "admin";
     int USER_PASS = 1234;
     //2.?法 接??抽象类还要抽象 jdk1.8之前 接???的?法全部都是抽象?法 public abstract 默认
     //2.1 抽象?法 对于程序猿来说 使?量最多还是仅仅抽象?法 (封装?为)
     void demo1();
     int max(int num1, int num2);
     //2.2 功能?法---->有?法体的?法 jdk1.8+ public default
     default void demo2() {
     System.out.println("MyInterface。。。。。demo2.。。。。");
     }
     //2.3 静态?法 jdk1.8+
     static String staticMethod() {
     System.out.println("MyInterface。。。。。staticMethod.。。。。");
     return "static";
     }
     //2.4 私有的静态?法 jdk1.9+ 服务于其它public static的?法
     private static void privateStaticMethod() {
     System.out.println("MyInterface。。。。。。privateStaticMetho
    d。。。。");
     }

     //2.5 接?没有构造?法----->不能直接实例化 其实也可以 创建了 匿名内部类
}

1.5 使用接口

1.5.1 接口继承接口（extends）

接口与接口之间属于多继承关系。一个接口可以继承多个接口，使用extends关键字实现。

public interface AInterface extends BInterface,CInterface,....{
}

public interface AInterface {
     void a();
}
interface CInterface {
     void c();
}
interface BInterface extends AInterface, CInterface {//?接?与?接?的关系
     void b();
}

1.5.2 类实现接口（implements）

类与接口之间属于多实现关系。一个类可以实现多个接口，使用implements关键字实现。Java语言是面向对象的，最终还需要与类结合使用。接口是比抽象类更高层次的抽象概念，因此和抽象类一样，接口不能用于实例化对象，只能作为继承树的顶层结构被子类实现。

类实现接口的概念，实际上与类继承类类似，但存在关键差异：“一个类仅能继承一个类，即单继承，而一个类却能够同时实现多个接口”，只需用逗号分隔即可。实现类需重写所有接口中的抽象方法，若未实现，则该类也应声明为抽象类。

public class 类名 extends Object implements AInter,BInter{
 
}

注意: 一个普通类实现接口时可能会遇到错误。

public interface UserInterface {
     //常量
     String PASS = "1234";
     String NAME = "admin";
     //?法
     boolean login(String name, String pass);
     void register();
     default void defaultMethod() {
         System.out.println("UserInterface.....
             public....defaultMethod......");
     }
     static void staticMethod() {
         System.out.println("UserInterface.....public....
         staticMethod......");
     }
     private void privateMethod() {
         System.out.println("UserInterface.....private....
         privateMethod......");
     }
}

//类实现接?称为接?的实现类
//接?就像 "招牌"
//只要类实现接? 就代表这个类中具有这些功能
//因此?个接?可以有多个实现类，有多套实现
public class UserInterfaceImpl implements UserInterface{
     //?个普通类 实现接?的时候 这个类可能会报错
     //解决?式:
     // 1. 将这个类改为抽象类
     // 2. 普通类重写/实现接???的所有的抽象?法
}

作业

1. 结合多态实现乐器演奏功能

乐器（Instrument）分为钢琴（Piano）、小提琴（Violin），不同乐器的演奏（play）方式各异。

编写一个测试类InstrumentTest，具体要求如下：

• 编写方法testPlay，用于测试各种乐器的演奏。根据乐器类型，执行相应的演奏方法。
• 在main方法中进行测试。

public class Instrument {
    private String name;

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

    public void play(){

    }

    public String getName() {
        return name;
    }

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

public class Piano extends Instrument{
    public Piano() {
    }

    public Piano(String name) {
        super(name);
    }

    @Override
    public void play() {
        System.out.println(this.getName()+"正在弹奏~~~");
    }
}

public class Violin extends Instrument{
    public Violin() {
    }

    public Violin(String name) {
        super(name);
    }

    @Override
    public void play() {
        System.out.println(this.getName()+"正在弹奏~~~~~");
    }
}

public class MainWork {
    public static void main(String[] args) {
        testPlay();
    }
    public static void testPlay(){
        Instrument  instrument= new Piano("钢琴一号");
        Instrument instrument1= new Violin("小提琴一号");

        instrument.play();
        instrument1.play();
    }
}

2. 地下城勇士游戏怪物模块设计

现有两种怪物：哥布林和猫妖，它们共享一些基本属性，如名称、生命值、攻击力和防御力。

哥布林的独特属性包括狂暴度，其特有能力有攻击（使用头部攻击）和移动（缓慢移动）。

猫妖的能力包括攻击（使用爪子攻击）和移动（跳跃移动）。

测试类需创建两只哥布林和两只猫妖，将其存入数组中统一管理，并循环调用每只怪物的攻击和移动方法，利用多态思想实现。

public class Monster {
    private String name;
    private int bloodNum;
    private int attackPower;
    private int defensecapability;

    public Monster() {
    }

    public Monster(String name, int bloodNum, int attackPower, int defensecapability) {
        this.name = name;
        this.bloodNum = bloodNum;
        this.attackPower = attackPower;
        this.defensecapability = defensecapability;
    }

    public void attack() {
        System.out.println("怪物都会攻击.....");
    }

    public void move() {
        System.out.println("怪物都会移动.....");
    }

    public void show() {
        System.out.println("怪物信息:");
        System.out.println("怪物名称：" + this.name);
        System.out.println("怪物血量：" + this.bloodNum);
        System.out.println("怪物攻击力：" + this.attackPower);
        System.out.println("怪物防御力：" + this.defensecapability);
    }

    public String getName() {
        return name;
    }

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

    public int getBloodNum() {
        return bloodNum;
    }

    public void setBloodNum(int bloodNum) {
        this.bloodNum = bloodNum;
    }

    public int getAttackPower() {
        return attackPower;
    }

    public void setAttackPower(int attackPower) {
        this.attackPower = attackPower;
    }

    public int getDefensecapability() {
        return defensecapability;
    }

    public void setDefensecapability(int defensecapability) {
        this.defensecapability = defensecapability;
    }
}

public class Goblin extends Monster{
    private int   frenzyDegree;

    public Goblin() {
    }

    public Goblin(String name, int bloodNum, int attackPower, int defensecapability, int frenzyDegree) {
        super(name, bloodNum, attackPower, defensecapability);
        this.frenzyDegree = frenzyDegree;
    }

    @Override
    public void attack() {
        System.out.println(this.getName()+"正在攻击，注意格挡......");
    }

    @Override
    public void move() {
        System.out.println(this.getName()+"正在急速靠近，注意距离.....");
    }

    @Override
    public void show() {
        super.show();
        System.out.println("怪物暴怒度:"+this.frenzyDegree);
    }

    public double getFrenzyDegree() {
        return frenzyDegree;
    }

    public void setFrenzyDegree(int frenzyDegree) {
        this.frenzyDegree = frenzyDegree;
    }
}

public class CatMonster extends Monster{
    public CatMonster() {
    }

    public CatMonster(String name, int bloodNum, int attackPower, int defensecapability) {
        super(name, bloodNum, attackPower, defensecapability);
    }

    @Override
    public void move() {
        System.out.println(this.getName()+"正在尽速靠近，注意闪避....");
    }

    @Override
    public void attack() {
        System.out.println(this.getName()+"正在攻击注意距离......");
    }

    @Override
    public void show() {
        super.show();
    }
}

public class TestDemo {
    private Monster[] monsters;

    public TestDemo() {
    }

    public TestDemo(Monster[] monsters) {
        this.monsters = monsters;
    }
    public void test(){
        Scanner scanner= new Scanner(System.in);
        System.out.println("游戏加载中.....");
        for(int i=0;i<monsters.length;i++){
            if(i<2) {
                monsters[i].setAttackPower((int)(Math.random() * 101 + 100));
                monsters[i].setName("哥布林"+(i+1));
                monsters[i].setBloodNum((int)(Math.random()*1001+1000));
                monsters[i].setDefensecapability((int)(Math.random()*101+100));
                Goblin goblin=(Goblin)monsters[i];
                goblin.setFrenzyDegree((int)(Math.random()*10+1));
            }else{
                monsters[i].setAttackPower((int)(Math.random() * 101 + 100));
                monsters[i].setName("猫妖"+(i+1));
                monsters[i].setBloodNum((int)(Math.random()*1001+1000));
                monsters[i].setDefensecapability((int)(Math.random()*101+100));
            }
        }
        System.out.println("加载完毕");
        for(int k=0;k<monsters.length;k++){
            monsters[k].show();
            System.out.println();
        }
        System.out.println("是否开始游戏？y/n:");
        String str=scanner.next();
        if("y".equals(str)){
            for(int j=0;j<monsters.length;j++){
                while (monsters[j].getBloodNum() > 0) {
                        monsters[j].move();
                        monsters[j].attack();
                        System.out.println("你收到了攻击，并作出了反击！");
                        monsters[j].setBloodNum((monsters[j].getBloodNum()-(int)(Math.random() * 500 + 100-monsters[j].getDefensecapability())));
                        if (monsters[j].getBloodNum()>0) {
                            System.out.println(monsters[j].getName() + "血量还剩" + monsters[j].getBloodNum());
                        }
                }
                System.out.println("怪物已经死亡...");
                if(j==monsters.length-1)
                    break;
                System.out.println("是否进行下一场游戏？y/n:");
                str=scanner.next();
                if("n".equals(str)) {
                    System.out.println("你中途退出游戏，所以你输了，即将结束游戏.....");
                    break;
                };
                System.out.println("下一只怪物即将来袭.....");
            }
            if(monsters[monsters.length-1].getBloodNum()<0)
                System.out.println("怪物全部死亡！恭喜你赢得了比赛！");
        }

    }
}

public class MainWork {
    public static void main(String[] args) {
            Monster[] monsters={new Goblin(),new Goblin(),new CatMonster(),new CatMonster()};
        new TestDemo(monsters).test();
    }
}

3. 画图软件图案绘制模块设计

画图软件支持绘制线条、矩形和圆形。每个图案都有坐标X轴、Y轴及颜色等公共属性，以及一个抽象的绘制方法。

线条的独有属性为终点X轴坐标和终点Y轴坐标；矩形的独有属性为长度和宽度；圆形的独有属性为半径。

编写测试类验证每个图案的绘制功能，为了便于管理，使用数组对象存储这些图案对象，每种图案创建一个实例并保存到数组中，循环调用绘制方法。

要求使用抽象方法实现多态。

public abstract class Graphic {
    private double coordinateX;
    private double coordinateY;
    private String graphilColor;

    public abstract void painting();

    public Graphic(double coordinateX, double coordinateY, String graphilColor) {
        this.coordinateX = coordinateX;
        this.coordinateY = coordinateY;
        this.graphilColor = graphilColor;
    }

    public double getCoordinateX() {
        return coordinateX;
    }

    public void setCoordinateX(double coordinateX) {
        this.coordinateX = coordinateX;
    }

    public double getCoordinateY() {
        return coordinateY;
    }

    public void setCoordinateY(double coordinateY) {
        this.coordinateY = coordinateY;
    }

    public String getGraphilColor() {
        return graphilColor;
    }

    public void setGraphilColor(String graphilColor) {
        this.graphilColor = graphilColor;
    }
}

public class Circle extends Graphic{
    private double radius;

    @Override
    public void painting() {
        System.out.println("画圆形模块从坐标("+super.getCoordinateX()+","+super.getCoordinateY()+")以"+
                this.radius+"为半径画了一个"+super.getGraphilColor()+"的原型");
    }

    public Circle(double coordinateX, double coordinateY, String graphilColor, double radius) {
        super(coordinateX, coordinateY, graphilColor);
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }
}

public class Line extends Graphic{
    private double finCoordinateX;
    private double finCoordinateY;

    @Override
    public void painting() {
        System.out.println("线条画图模块从坐标("+super.getCoordinateX()+","+super.getCoordinateY()+")到坐标("+
        this.finCoordinateY+","+this.finCoordinateY+")画了一条"+super.getGraphilColor()+"的线条");
    }

    public Line(double coordinateX, double coordinateY, String graphilColor, double finCoordinateX, double finCoordinateY) {
        super(coordinateX, coordinateY, graphilColor);
        this.finCoordinateX = finCoordinateX;
        this.finCoordinateY = finCoordinateY;
    }

    public double getFinCoordinateX() {
        return finCoordinateX;
    }

    public void setFinCoordinateX(double finCoordinateX) {
        this.finCoordinateX = finCoordinateX;
    }

    public double getFinCoordinateY() {
        return finCoordinateY;
    }

    public void setFinCoordinateY(double finCoordinateY) {
        this.finCoordinateY = finCoordinateY;
    }
}

public class Rectangle extends Graphic{
    private int length;
    private int width;

    @Override
    public void painting() {
        System.out.println("画矩形模块从坐标("+super.getCoordinateX()+","+super.getCoordinateY()+")画了一个长为"+
   this.length+"宽为"+this.width+"的"+super.getGraphilColor()+"的矩形");
    }

    public Rectangle(double coordinateX, double coordinateY, String graphilColor, int length, int width) {
        super(coordinateX, coordinateY, graphilColor);
        this.length = length;
        this.width = width;
    }

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    public int getWidth() {
        return width;
    }

    public void setWidth(int width) {
        this.width = width;
    }
}

public class MainWork {
    public static void main(String[] args) {
        test();
    }

    private static void test() {
        Graphic[] graphic=new Graphic[3];
        graphic[0]=new Line(1,2,"绿色",5,6);
        graphic[1]=new Rectangle(2,4,"黄色",8,3);
        graphic[2]=new Circle(2,5,"红色",6);

        for (int i = 0; i < graphic.length; i++) {
            graphic[i].painting();
        }
    }
}

4. 模拟腾讯QQ系统使用接口构建

为确保系统的易维护性和可扩展性，整个系统基于一个主程序作为框架，所有功能均以插件形式加载至主程序，主程序启动时会加载插件，并显示加载过程的信息，同时支持插件的卸载。

模拟添加QQ空间、QQ音乐、QQ游戏三个功能插件，并编写测试类验证插件加载过程。

public interface Plugins {
    void star();
    void stop();
    String getName();
}

public class QQGamePlugin implements Plugins{
    @Override
    public void star() {
        System.out.println("QQ游戏插件正在运行中......");
    }

    @Override
    public void stop() {
        System.out.println("QQ游戏插件已停止运行！");

    }

    @Override
    public String getName() {
        return "QQ游戏";
    }
}

public class QQMusicPlugin implements Plugins{
    @Override
    public void star() {
        System.out.println("QQ音乐插件正在运行中.....");
    }

    @Override
    public void stop() {
        System.out.println("QQ音乐插件已停止!");

    }

    @Override
    public String getName() {
        return "QQ音乐";
    }
}

public class QQZonePlugin implements Plugins{
    @Override
    public void star() {
        System.out.println("QQ空间插件正在运行中....");
    }

    @Override
    public void stop() {
        System.out.println("QQ空间插件已停止运行！");
    }

    @Override
    public String getName() {
        return "QQ空间";
    }
}

public class QQMainProgram {
    private Plugins[] plugins=new Plugins[10];
    private static int count=0;

    public  void loadPlugin(Plugins plug){
        if(count<plugins.length){
            System.out.println("正在加载"+plug.getName()+"插件");
            plugins[count++]=plug;
            System.out.println(plug.getName()+"插件加载成功");
            //plug.star();
        }
        else{
            System.out.println("插件库已满，无发进行加载插件！");
        }
    }

    public void unloadPlugin(String str){
        for (int i = 0; i < count; i++) {
            if(plugins[i].getName().equals(str)){
                System.out.println("正在卸载插件"+str);
                plugins[i].stop();
                for(int j=i;j<count-1;j++){
                    plugins[j]=plugins[j+1];
                }
                count--;
                System.out.println(str+"卸载成功！");
            }
        }
    }

    public void showPlugins(){
        System.out.println("*****当前已加载的插件*****");
        if(count==0){
            System.out.println("当前无已加载的插件！");
        }else{
            for (int i = 0; i < count; i++) {
                System.out.println("\t\t"+plugins[i].getName());
            }
        }
        System.out.println("***********************");
    }

    public void runAllPlugins(){
        if(count==0){
            System.out.println("当前已无插件可运行！");
        }else{
            for (int i = 0; i < count; i++) {
                plugins[i].star();
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        QQMainProgram qqMainProgram =new QQMainProgram();

        Plugins qqZone=new QQZonePlugin();
        Plugins qqMusic =new QQMusicPlugin();
        Plugins qqGamePlugin = new QQGamePlugin();

        qqMainProgram.loadPlugin(qqZone);
        qqMainProgram.loadPlugin(qqMusic);
        qqMainProgram.loadPlugin(qqGamePlugin);

        qqMainProgram.showPlugins();

        System.out.println("正在启动所有插件");
        qqMainProgram.runAllPlugins();

        qqMainProgram.unloadPlugin("QQ游戏");

        qqMainProgram.showPlugins();

        System.out.println("测试结束！");

    }
}

5. 图形类的设计

描述图形、矩形、圆形三个类，每个类都包含计算面积和周长的方法。

在计算类中定义一个方法，接受所有图形对象，并输出每个图形的周长和面积。

计算类还需定义一个方法，返回任意图形对象。

public interface Graphic {
    double circumference();
    double area();
}

public class Circle implements Graphic {
    private double radius;


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

    @Override
    public double circumference() {
        return 2*Math.PI*radius;
    }

    @Override
    public double area() {
        return Math.pow(radius,2)*Math.PI;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }
}

public class Rectangle implements Graphic {
    private int length;
    private int width;

    public Rectangle(int length, int width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public double circumference() {
        return 2*(this.length+this.width);
    }

    @Override
    public double area() {
        return this.length*this.width;
    }


    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    public int getWidth() {
        return width;
    }

    public void setWidth(int width) {
        this.width = width;
    }
}

public class Calculation {
    public Calculation() {
    }

    public void calAreaCir(Graphic graphic){
        System.out.println("该图形的面积是:"+graphic.area());
        System.out.println("该图形的周长是:"+graphic.circumference());
    }
    public Graphic gra(String str){

        if("矩形".equals(str)){
            return new Rectangle((int)(Math.random()*10+1),(int)(Math.random()*5+1));
        }
        else if ("圆形".equals(str)){
            return new Circle(Math.random()*8+1);
        }
        System.out.println("输入错误！(圆形/矩形)");
        return null;
    }
}

public class MainWork {
    public static void main(String[] args) {
        test();

    }

    private static void test() {
        Scanner scanner=new Scanner(System.in);
        Graphic graphic=new Circle(6.4);
        Graphic graphic1= new Rectangle(5,8);

        Calculation calculation=new Calculation();
        System.out.println("半径为6.4的圆形的面积和周长如下:");
        calculation.calAreaCir(graphic);
        System.out.println("长为5，宽为8的矩形的面积和周长如下:");
        calculation.calAreaCir(graphic1);

        System.out.println("输入你想创建的图形(圆形/矩形):");
        String str=scanner.next();
        if ("圆形".equals(str)) {
            Circle circle=(Circle) calculation.gra(str);
            System.out.println("创建了一个半径为"+circle.getRadius()+"的圆形");
        }
        else if("矩形".equals(str)){
            Rectangle rectangle=(Rectangle) calculation.gra(str);
            System.out.println("创建了一个长为"+rectangle.getLength()+"宽为"+rectangle.getWidth()+"的矩形");

        }
    }


}

6. 学生类的设计

描述一个学生类，具有id和name两个属性，所有学生都能学习，但部分学生在学习的同时还能赚钱。

普通学生：学习，不赚钱。

赚钱的学生：学习，还会赚钱。

public interface Student {
    void study();
    default void makeMoney(){
        System.out.println("该学生不会赚钱");
    }
}

public class StudentAbs {
    private String name;
    private int id;

    public StudentAbs() {
    }

    public StudentAbs(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

public class OrdinaryStudent extends StudentAbs implements Student{
    public OrdinaryStudent() {
    }

    public OrdinaryStudent(String name, int id) {
        super(name, id);
    }

    @Override
    public void study() {
        System.out.println("普通学生"+super.getName()+"在努力学习......");
    }
}

public class SmartStudent extends StudentAbs implements Student{
    public SmartStudent() {
    }

    public SmartStudent(String name, int id) {
        super(name, id);
    }

    @Override
    public void study() {
        System.out.println(super.getName()+"在努力学习");
    }

    @Override
    public void makeMoney() {
        System.out.println("该生不仅会学习还会赚钱");
    }
}

public class MainWork {
    public static void main(String[] args) {
        OrdinaryStudent ordinaryStudent= new OrdinaryStudent("产同同",202501);
        Student student=ordinaryStudent;
        student.study();
        student.makeMoney();

        student=new SmartStudent("产思意",202502);
        student.study();
        student.makeMoney();


    }
}

7. 迷你共享单车项目的实现

//个人实现（未严格遵循面向对象原则，仅供参考）

public class ShareBike {
    private int bikeId;
    private String bikeName;
    private int status;
    private Date borrowTime;

    public ShareBike() {
    }

    public ShareBike(int bikeId, String bikeName, int status, Date borrowTime) {
        this.bikeId = bikeId;
        this.bikeName = bikeName;
        this.status = status;
        this.borrowTime = borrowTime;
    }

    public int getBikeId() {
        return bikeId;
    }

    public void setBikeId(int bikeId) {
        this.bikeId = bikeId;
    }

    public String getBikeName() {
        return bikeName;
    }

    public void setBikeName(String bikeName) {
        this.bikeName = bikeName;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public String  getBorrowTime() {
        if(borrowTime!=null) {
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String formattedDate = dateFormat.format(borrowTime);
            //System.out.println(formattedDate);
            return formattedDate;
        }else{
            return null;
        }
    }

    public void setBorrowTime(Date borrowTime) {
        this.borrowTime = borrowTime;
    }
}

public class ShareBikeCompany {
   private int bikeCompanyId;
   private String bikeCompanyName;
   private ShareBike[] sharedBikes;
   private int bikeSum=0;
   private int sharedCount;

    public ShareBikeCompany() {
    }

    public ShareBikeCompany(int bikeCompanyId, String bikeCompanyName, ShareBike[] sharedBikes, int bikeSum, int sharedCount) {
        this.bikeCompanyId = bikeCompanyId;
        this.bikeCompanyName = bikeCompanyName;
        this.sharedBikes = sharedBikes;
        this.bikeSum = bikeSum;
        this.sharedCount = sharedCount;
    }

    public int getBikeCompanyId() {
        return bikeCompanyId;
    }

    public void setBikeCompanyId(int bikeCompanyId) {
        this.bikeCompanyId = bikeCompanyId;
    }

    public String getBikeCompanyName() {
        return bikeCompanyName;
    }

    public void setBikeCompanyName(String bikeCompanyName) {
        this.bikeCompanyName = bikeCompanyName;
    }

    public ShareBike[] getSharedBikes() {
        return sharedBikes;
    }

    public void setSharedBikes(ShareBike[] sharedBikes) {
        this.sharedBikes = sharedBikes;
    }

    public int getBikeSum() {
        return bikeSum;
    }

    public void setBikeSum(int bikeSum) {
        this.bikeSum = bikeSum;
    }

    public int getSharedCount() {
        return sharedCount;
    }

    public void setSharedCount(int sharedCount) {
        this.sharedCount = sharedCount;
    }
}

public class RunDemo {


    private ShareBikeCompany[] shareBikeCompanies=new ShareBikeCompany[3];
    private ShareBike[] shareBikes1=new ShareBike[3];
    private ShareBike[] shareBikes2=new ShareBike[3];
    private ShareBike[] shareBikes3=new ShareBike[3];
    Scanner scanner=new Scanner(System.in);

    public RunDemo() {

    }

    public void run(){
        this.initialization();

        String str;
        do{
            System.out.println("\t\t欢迎使用共享单车系统");
            System.out.println("**************************************");
            System.out.println("\t\t\t1.投放单车");
            System.out.println("\t\t\t2.查看单车");
            System.out.println("\t\t\t3.删除单车");
            System.out.println("\t\t\t4.借出单车");
            System.out.println("\t\t\t5.归还单车");
            System.out.println("\t\t\t6.单车排行榜");
            System.out.println("\t\t\t7.退   出");
            System.out.println("**************************************");
            System.out.println("选择您要进行的操作:");
            int num=scanner.nextInt();
            switch (num){
                case 1:
                    eployBikes();
                    break;
                case 2:
                    showAllBikes();
                    break;
                case 3:
                    removeBikes();
                    break;
                case 4:
                    borrowBikes();
                    break;
                case 5:
                    backBikes();
                    break;
                case 6:
                    rankBikes();
                    break;
                default:
                    return;
            }
            System.out.println("是否继续y/n：");
            str=scanner.next();
        }while ("y".equals(str));
        //this.showAllBikes();
    }

    private void rankBikes() {
        ShareBikeCompany[] shareBikeCompanies1=Arrays.copyOf(shareBikeCompanies,shareBikeCompanies.length);
        Arrays.sort(shareBikeCompanies1, new Comparator<ShareBikeCompany>() {
            @Override
            public int compare(ShareBikeCompany o1, ShareBikeCompany o2) {
                return o2.getSharedCount()-o1.getSharedCount();
            }
        });
        for (int i = 0; i < shareBikeCompanies1.length; i++) {
            System.out.println(shareBikeCompanies1[i].getBikeCompanyName()+"共借出"+shareBikeCompanies1[i].getSharedCount()+"次");
        }
    }

    private void backBikes()  {
        int comNum = getComNum();
        System.out.println("请输入想要借出的单车编号:");
        int biekNum=scanner.nextInt();

        ShareBike[] shareBikes=shareBikeCompanies[comNum-1].getSharedBikes();

        for (int i = 0; i < shareBikeCompanies[comNum-1].getBikeSum(); i++) {
            if(shareBikes[i].getBikeId()==biekNum&&shareBikes[i].getStatus()==1){
                String dateString = shareBikes[i].getBorrowTime();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                Date date = null;
                try {
                    date = sdf.parse(dateString);
                    //System.out.println(date); // 输出转换后的Date对象
                } catch (ParseException e) {
                    e.printStackTrace(); // 打印异常信息，例如日期格式不正确等。
                }
                // 将毫秒转换为秒
                long seconds = date.getTime() / 1000;
                Date date2=new Date();

                long seconds1= date2.getTime()/1000;
                long secondsRe= seconds1-seconds;

                SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String formattedDate = dateFormat.format(date2);
                shareBikes[i].setStatus(0);
                shareBikes[i].setBorrowTime(null);
                System.out.println("还车成功，还车时间:"+formattedDate);
                System.out.println("此次花费:"+secondsRe*0.001);
                return;
            }else if(shareBikes[i].getStatus()==0){
                System.out.println("此单车处于可借状态，无需还出，请重新输入！");
                return;
            }
        }
        System.out.println("单车编号不对！请重新输入！");
    }

    private void borrowBikes() {
        int comNum = getComNum();

        System.out.println("请输入想要借出的单车编号:");
        int biekNum=scanner.nextInt();

        ShareBike[] shareBikes=shareBikeCompanies[comNum-1].getSharedBikes();

        for (int i = 0; i < shareBikeCompanies[comNum-1].getBikeSum(); i++) {
            if(shareBikes[i].getStatus()==0&&shareBikes[i].getBikeId()==biekNum){
                shareBikes[i].setStatus(1);
                shareBikes[i].setBorrowTime(new Date());
                shareBikeCompanies[comNum-1].setSharedCount(shareBikeCompanies[comNum-1].getSharedCount()+1);
                return;
            }
        }
        System.out.println("查无此单车，重新借出！");


    }

    private void removeBikes() {
        int comNum = getComNum();
        System.out.println("请输入想要删除的单车编号:");
        int bikeNum= scanner.nextInt();

        ShareBike[] shareBike=shareBikeCompanies[comNum-1].getSharedBikes();
        for (int i = 0; i < shareBikeCompanies[comNum-1].getBikeSum(); i++) {
            if(shareBike[i].getBikeId()==bikeNum){
                if(shareBike[i].getStatus()==0){
                    for (int j = i; j < (shareBikeCompanies[comNum-1].getBikeSum() - 1); j++) {
                        shareBike[j] = shareBike[j + 1];
                    }
                    shareBike[shareBikeCompanies[comNum-1].getBikeSum()-1]=null;
                    //shareBikeCompanies[comNum].setSharedBikes(shareBike);
                    shareBikeCompanies[comNum-1].setBikeSum(shareBikeCompanies[comNum-1].getBikeSum()-1);
                    System.out.println("编号：" + bikeNum + "单车移除成功");
                    return;
                }else{
                    System.out.println("此编号单车处于借出状态无法进行移除，请先归还单车！");
                    return;
                }
            }
        }
        System.out.println("查无此单车，请重新进行操作！");
    }

    private int getComNum() {
        System.out.println("请输入单车公司编号:");
        System.out.println("1.美团");
        System.out.println("2.哈啰");
        System.out.println("3.青桔");
        int comNum=scanner.nextInt();
        return comNum;
    }

    public ShareBikeCompany[] getShareBikeCompanies() {
        return shareBikeCompanies;
    }

    public void initialization() {
        for (int i = 0; i < shareBikeCompanies.length; i++) {
            shareBikeCompanies[i]=new ShareBikeCompany();
            shareBikeCompanies[i].setBikeCompanyId(i+1);
            //shareBikeCompanies[i].setBikeSum(3);
            shareBikeCompanies[i].setSharedCount(0);
            if(i==0){
                shareBikeCompanies[i].setBikeCompanyName("美团");
                for (int j = 0; j < shareBikes1.length; j++) {
                    shareBikes1[j]=new ShareBike();
                    shareBikes1[j].setBikeId(j+1);
                    shareBikes1[j].setBikeName("美团单车"+j);
                    shareBikes1[j].setStatus(0);
                    shareBikes1[j].setBorrowTime(null);
                    shareBikeCompanies[i].setBikeSum(shareBikeCompanies[i].getBikeSum()+1);
                }
                shareBikeCompanies[i].setSharedBikes(shareBikes1);
            }else if(i==1){
                shareBikeCompanies[i].setBikeCompanyName("哈啰");
                for (int j = 0; j < shareBikes2.length; j++) {
                    shareBikes2[j]=new ShareBike();
                    shareBikes2[j].setBikeId(j+1);
                    shareBikes2[j].setBikeName("哈啰单车"+j);
                    shareBikes2[j].setStatus(0);
                    shareBikeCompanies[i].setBikeSum(shareBikeCompanies[i].getBikeSum()+1);
                }
                shareBikeCompanies[i].setSharedBikes(shareBikes2);

            }else{
                shareBikeCompanies[i].setBikeCompanyName("青桔");
                for (int j = 0; j < shareBikes3.length; j++) {
                    shareBikes3[j]=new ShareBike();
                    shareBikes3[j].setBikeId(j+1);
                    shareBikes3[j].setBikeName("青桔单车"+j);
                    shareBikes3[j].setStatus(0);
                    shareBikeCompanies[i].setBikeSum(shareBikeCompanies[i].getBikeSum()+1);
                }
                shareBikeCompanies[i].setSharedBikes(shareBikes3);
            }
        }
    }

    public void showAllBikes(){
        for (int i = 0; i < shareBikeCompanies.length; i++) {
            System.out.println("序号\t品牌\t数量\t借出次数");
            System.out.print(shareBikeCompanies[i].getBikeCompanyId()+"\t");
            System.out.print(shareBikeCompanies[i].getBikeCompanyName()+"\t");
            System.out.print(shareBikeCompanies[i].getBikeSum()+"\t");
            System.out.println(shareBikeCompanies[i].getSharedCount());
            System.out.println("单车编号\t单车名称\t单车状态\t借出时间");

            ShareBike[] shareBikes=shareBikeCompanies[i].getSharedBikes();

            for (int j = 0; j < shareBikeCompanies[i].getBikeSum(); j++) {
                System.out.print(shareBikes[j].getBikeId()+"\t\t");
                System.out.print(shareBikes[j].getBikeName()+"\t");
                if(shareBikes[j].getStatus()==0) {
                    System.out.print( "可借\t");
                }else{
                    System.out.print("借出\t");
                }
                System.out.println(shareBikes[j].getBorrowTime());
            }
        }
    }

    public void eployBikes(){
        System.out.println("------->1.投放单车");
        System.out.println("""
                1.美团单车
                2.哈啰单车
                3.青桔单车
                """);
        System.out.println("请选择要投放的单车品牌:");
        int ll=scanner.nextInt();
        System.out.println("请输入要投放的数量");
        int ln =scanner.nextInt();
        if(ll==1) {
            if ((shareBikeCompanies[ll - 1].getBikeSum() + ln) > shareBikeCompanies[ll - 1].getSharedBikes().length) {
                System.out.println("空间不足，已经参照配置进行扩容");
                shareBikes1= Arrays.copyOf(shareBikes1,shareBikes1.length+ln);
                //System.out.println(shareBikeCompanies[ll-1].getBikeSum());
                shareBikeCompanies[ll-1].setSharedBikes(shareBikes1);
                for(int i=shareBikeCompanies[ll-1].getBikeSum();i<(shareBikeCompanies[ll-1].getBikeSum()+ln);i++){
                    shareBikes1[i]=new ShareBike();
                    shareBikes1[i].setBikeId(i+1);
                    shareBikes1[i].setBikeName("美团单车"+i);
                    shareBikes1[i].setStatus(0);

                }
                shareBikeCompanies[ll-1].setBikeSum(shareBikeCompanies[ll-1].getBikeSum()+ln);
            }else{
                for(int i=shareBikeCompanies[ll-1].getBikeSum();i<(shareBikeCompanies[ll-1].getBikeSum()+ln);i++){
                    shareBikes1[i]=new ShareBike();
                    shareBikes1[i].setBikeId(i+1);
                    shareBikes1[i].setBikeName("美团单车"+i);
                    shareBikes1[i].setStatus(0);

                }
                System.out.println("投放"+ln+"辆美团单车成功");
                shareBikeCompanies[ll-1].setBikeSum(shareBikeCompanies[ll-1].getBikeSum()+ln);
            }
        }else if(ll==2){
            if ((shareBikeCompanies[ll - 1].getBikeSum() + ln) > shareBikeCompanies[ll - 1].getSharedBikes().length) {
                System.out.println("空间不足，已经参照配置进行扩容");
                shareBikes2= Arrays.copyOf(shareBikes2,shareBikes2.length+ln);
                shareBikeCompanies[ll-1].setSharedBikes(shareBikes2);
                for(int i=shareBikeCompanies[ll-1].getBikeSum();i<(shareBikeCompanies[ll-1].getBikeSum()+ln);i++){
                    shareBikes2[i]=new ShareBike();
                    shareBikes2[i].setBikeId(i+1);
                    shareBikes2[i].setBikeName("哈啰单车"+i);
                    shareBikes2[i].setStatus(0);

                }
                shareBikeCompanies[ll-1].setBikeSum(shareBikeCompanies[ll-1].getBikeSum()+ln);
            }else {
                for (int i = shareBikeCompanies[ll - 1].getBikeSum(); i < (shareBikeCompanies[ll-1].getBikeSum()+ln); i++) {
                    shareBikes2[i] = new ShareBike();
                    shareBikes2[i].setBikeId(i + 1);
                    shareBikes2[i].setBikeName("哈啰单车" + i);
                    shareBikes2[i].setStatus(0);
                }
                shareBikeCompanies[ll-1].setBikeSum(shareBikeCompanies[ll-1].getBikeSum()+ln);
            }
            System.out.println("投放"+ln+"辆哈啰单车成功");
        }else{
            if ((shareBikeCompanies[ll - 1].getBikeSum() + ln) > shareBikeCompanies[ll - 1].getSharedBikes().length) {
                System.out.println("空间不足，已经参照配置进行扩容");
                shareBikes3= Arrays.copyOf(shareBikes3,shareBikes3.length+ln);
                shareBikeCompanies[ll-1].setSharedBikes(shareBikes3);
                for(int i=shareBikeCompanies[ll-1].getBikeSum();i<(shareBikeCompanies[ll-1].getBikeSum()+ln);i++){
                    shareBikes3[i]=new ShareBike();
                    shareBikes3[i].setBikeId(i+1);
                    shareBikes3[i].setBikeName("青桔单车"+i);
                    shareBikes3[i].setStatus(0);
                }
                shareBikeCompanies[ll-1].setBikeSum(shareBikeCompanies[ll-1].getBikeSum()+ln);
            }else {
                for (int i = shareBikeCompanies[ll - 1].getBikeSum(); i < (shareBikeCompanies[ll-1].getBikeSum()+ln); i++) {
                    shareBikes3[i] = new ShareBike();
                    shareBikes3[i].setBikeId(i + 1);
                    shareBikes3[i].setBikeName("青桔单车" + i);
                    shareBikes3[i].setStatus(0);
                }
                shareBikeCompanies[ll-1].setBikeSum(shareBikeCompanies[ll-1].getBikeSum()+ln);
            }
            System.out.println("投放"+ln+"辆哈啰单车成功");
        }
    }
}

public class MainSystem {
    public static void main(String[] args) {
        new RunDemo().run();
    }
}

//参考更规范的面向对象实现，有助于提升面向对象编程能力

public class ShareBike {
    private int bikeId;
    private String bikeName;
    private int status;
    private Date borrowTime;

    public ShareBike() {
    }

    public ShareBike(int bikeId, String bikeName, int status, Date borrowTime) {
        this.bikeId = bikeId;
        this.bikeName = bikeName;
        this.status = status;
        this.borrowTime = borrowTime;
    }
}

public interface ShareBikeBehavior {
    void addBikes(int num);
    void viewBikes();
    void removeBikes(int num);
    void borrowBikes(int num);
    void backBikes(int num);

}

public class ShareBikeCompany implements ShareBikeBehavior{
    private int bikeCompanyId;
    private String bikeCompanyName;
    private ShareBike[] sharedBikes;
    private int bikeSum;
    private int sharedCount;


    public ShareBikeCompany(int bikeCompanyId, String bikeCompanyName, ShareBike[] sharedBikes, int bikeSum, int sharedCount) {
        this.bikeCompanyId = bikeCompanyId;
        this.bikeCompanyName = bikeCompanyName;
        this.sharedBikes = sharedBikes;
        this.bikeSum = bikeSum;
        this.sharedCount = sharedCount;
    }

    public ShareBikeCompany() {
    }



    @Override
    public void addBikes(int num) {
        if (bikeSum + num> sharedBikes.length) {
            System.out.println("空间不足，已经参照配置进行扩容");
            sharedBikes = Arrays.copyOf(sharedBikes, sharedBikes.length + num);
            //System.out.println(shareBikeCompanies[ll-1].getBikeSum());
            //shareBikeCompanies[ll-1].setSharedBikes(shareBikes1);
            for (int i = bikeSum; i < bikeSum + num; i++) {
                sharedBikes[i] = new ShareBike();
                sharedBikes[i].setBikeId(i + 1);
                sharedBikes[i].setBikeName("美团单车" + i);
                sharedBikes[i].setStatus(0);

            }
            System.out.println("投放"+num+"辆美团单车成功");
            bikeSum += num;
        }else{
            for(int i=bikeSum;i<bikeSum+num;i++){
                sharedBikes[i]=new ShareBike();
                sharedBikes[i].setBikeId(i+1);
                sharedBikes[i].setBikeName("美团单车"+i);
                sharedBikes[i].setStatus(0);

            }
            System.out.println("投放"+num+"辆美团单车成功");
            bikeSum+=num;
        }
    }

    @Override
    public void viewBikes() {

    }

    @Override
    public void removeBikes(int num) {
        //ShareBike[] shareBike=shareBikeCompanies[comNum-1].getSharedBikes();
        for (int i = 0; i < bikeSum; i++) {
            if(sharedBikes[i].getBikeId()==num){
                if(sharedBikes[i].getStatus()==0){
                    for (int j = i; j < bikeSum - 1; j++) {
                        sharedBikes[j] = sharedBikes[j + 1];
                    }
                    sharedBikes[bikeSum-1]=null;
                    //shareBikeCompanies[comNum].setSharedBikes(shareBike);
                    bikeSum-=1;
                    System.out.println("编号：" + num + "单车移除成功");
                    return;
                }else{
                    System.out.println("此编号单车处于借出状态无法进行移除，请先归还单车！");
                    return;
                }
            }
        }
        System.out.println("查无此单车，请重新进行操作！");

    }

    @Override
    public void borrowBikes(int num) {
        for (int i = 0; i < bikeSum; i++) {
            if(sharedBikes[i].getStatus()==0&&sharedBikes[i].getBikeId()==num){
                sharedBikes[i].setStatus(1);
                sharedBikes[i].setBorrowTime(new Date());
                sharedCount+=1;
                return;
            }
        }
        System.out.println("查无此单车，重新借出！");

    }

    @Override
    public void backBikes(int num) {
            for (int i = 0; i < bikeSum; i++) {
                if(sharedBikes[i].getBikeId()==num&&sharedBikes[i].getStatus()==1){
                    String dateString = sharedBikes[i].getBorrowTime();
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    Date date = null;
                    try {
                        date = sdf.parse(dateString);
                        //System.out.println(date); // 输出转换后的Date对象
                    } catch (ParseException e) {
                        e.printStackTrace(); // 打印异常信息，例如日期格式不正确等。
                    }
                    // 将毫秒转换为秒
                    long seconds = date.getTime() / 1000;
                    Date date2=new Date();

                    long seconds1= date2.getTime()/1000;
                    long secondsRe= seconds1-seconds;

                    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    String formattedDate = dateFormat.format(date2);
                    sharedBikes[i].setStatus(0);
                    sharedBikes[i].setBorrowTime(null);
                    System.out.println("还车成功，还车时间:"+formattedDate);
                    System.out.println("此次花费:"+secondsRe*0.001);
                    return;
                }else if(sharedBikes[i].getStatus()==0){
                    System.out.println("此单车处于可借状态，无需还出，请重新输入！");
                    return;
                }
            }
        System.out.println("单车编号不对！请重新输入！");


    }

    public int getBikeCompanyId() {
        return bikeCompanyId;
    }

    public void setBikeCompanyId(int bikeCompanyId) {
        this.bikeCompanyId = bikeCompanyId;
    }

    public String getBikeCompanyName() {
        return bikeCompanyName;
    }

    public void setBikeCompanyName(String bikeCompanyName) {
        this.bikeCompanyName = bikeCompanyName;
    }

    public ShareBike[] getSharedBikes() {
        return sharedBikes;
    }

    public void setSharedBikes(ShareBike[] sharedBikes) {
        this.sharedBikes = sharedBikes;
    }

    public int getBikeSum() {
        return bikeSum;
    }

    public void setBikeSum(int bikeSum) {
        this.bikeSum = bikeSum;
    }

    public int getSharedCount() {
        return sharedCount;
    }

    public void setSharedCount(int sharedCount) {
        this.sharedCount = sharedCount;
    }
}

public class QjBikeCompany extends ShareBikeCompany{
    public QjBikeCompany(int bikeCompanyId, String bikeCompanyName, ShareBike[] sharedBikes, int bikeSum, int sharedCount) {
        super(bikeCompanyId, bikeCompanyName, sharedBikes, bikeSum, sharedCount);
    }

    public QjBikeCompany() {
    }
}

public class MtBikeCompany extends ShareBikeCompany{
    public MtBikeCompany(int bikeCompanyId, String bikeCompanyName, ShareBike[] sharedBikes, int bikeSum, int sharedCount) {
        super(bikeCompanyId, bikeCompanyName, sharedBikes, bikeSum, sharedCount);
    }

    public MtBikeCompany() {
    }
}

public class HaloBikeCompany extends ShareBikeCompany{
    public HaloBikeCompany(int bikeCompanyId, String bikeCompanyName, ShareBike[] sharedBikes, int bikeSum, int sharedCount) {
        super(bikeCompanyId, bikeCompanyName, sharedBikes, bikeSum, sharedCount);
    }

    public HaloBikeCompany() {
    }
}

public class ShareBikeMag {
    private ShareBikeCompany[] shareBikeCompanies;
    Scanner scanner=new Scanner(System.in);

    public void run(){
        initial();
        String str;
        do {
            System.out.println("\t\t欢迎使用共享单车系统");
            System.out.println("**************************************");
            System.out.println("\t\t\t1.投放单车");
            System.out.println("\t\t\t2.查看单车");
            System.out.println("\t\t\t3.删除单车");
            System.out.println("\t\t\t4.借出单车");
            System.out.println("\t\t\t5.归还单车");
            System.out.println("\t\t\t6.单车排行榜");
            System.out.println("\t\t\t7.退   出");
            System.out.println("**************************************");
            System.out.println("选择您要进行的操作:");
            int num=scanner.nextInt();
            switch (num){
                case 1:
                    addBikes();
                    break;
                case 2:
                    viewBikes();
                    break;
                case 3:
                   removeBikes();
                    break;
                case 4:
                    borrowBikes();
                    break;
                case 5:
                    backBikes();
                    break;
                case 6:
                    rankBikes();
                    break;
                default:
                    return;
            }
            System.out.println("是否继续y/n：");
            str=scanner.next();
        } while ("y".equals(str));
    }

    private void rankBikes() {
        ShareBikeCompany[] shareBikeCompanies1=Arrays.copyOf(shareBikeCompanies,shareBikeCompanies.length);
        Arrays.sort(shareBikeCompanies1, new Comparator<ShareBikeCompany>() {
            @Override
            public int compare(ShareBikeCompany o1, ShareBikeCompany o2) {
                return o2.getSharedCount()-o1.getSharedCount();
            }
        });
        for (int i = 0; i < shareBikeCompanies1.length; i++) {
            System.out.println(shareBikeCompanies1[i].getBikeCompanyName()+"共借出"+shareBikeCompanies1[i].getSharedCount()+"次");
        }
    }

    private void backBikes() {
        int comNum = getComNum();
        System.out.println("请输入想要归还的单车编号:");
        int bikeNum= scanner.nextInt();

        shareBikeCompanies[comNum-1].backBikes(bikeNum);
    }

    private void borrowBikes() {
        int comNum = getComNum();
        System.out.println("请输入想要借出的单车编号:");
        int bikeNum= scanner.nextInt();

        shareBikeCompanies[comNum-1].borrowBikes(bikeNum);
    }

    private void removeBikes() {
        int comNum = getComNum();
        System.out.println("请输入想要删除的单车编号:");
        int bikeNum= scanner.nextInt();

        shareBikeCompanies[comNum-1].removeBikes(bikeNum);

    }

    private void addBikes() {
        int comN = getComNum();
        System.out.println("请输入要投放的数量");
        int bikeNum =scanner.nextInt();
        shareBikeCompanies[comN-1].addBikes(bikeNum);
    }

    private int getComNum() {
        System.out.println("------->投放单车");
        System.out.println("""
                1.美团单车
                2.哈啰单车
                3.青桔单车
                """);
        System.out.println("请选择要投放的单车品牌:");
        int ll=scanner.nextInt();
        return ll;
    }

    public void viewBikes() {
        for (int i = 0; i < shareBikeCompanies.length; i++) {
            System.out.println("序号\t品牌\t数量\t借出次数");
            System.out.print(shareBikeCompanies[i].getBikeCompanyId()+"\t");
            System.out.print(shareBikeCompanies[i].getBikeCompanyName()+"\t");
            System.out.print(shareBikeCompanies[i].getBikeSum()+"\t");
            System.out.println(shareBikeCompanies[i].getSharedCount());
            System.out.println("单车编号\t单车名称\t单车状态\t借出时间");

            ShareBike[] shareBikes=shareBikeCompanies[i].getSharedBikes();

            for (int j = 0; j < shareBikeCompanies[i].getBikeSum(); j++) {
                System.out.print(shareBikes[j].getBikeId()+"\t\t");
                System.out.print(shareBikes[j].getBikeName()+"\t");
                if(shareBikes[j].getStatus()==0) {
                    System.out.print( "可借\t");
                }else{
                    System.out.print("借出\t");
                }
                System.out.println(shareBikes[j].getBorrowTime());
            }
        }
    }

    private void initial() {
            shareBikeCompanies =new ShareBikeCompany[3];
            shareBikeCompanies[0]=new MtBikeCompany(1,"美团",new ShareBike[3],0,0);
            shareBikeCompanies[1]=new MtBikeCompany(1,"哈啰",new ShareBike[3],0,0);
            shareBikeCompanies[2]=new MtBikeCompany(1,"青桔",new ShareBike[3],0,0);

        for (int i = 0; i < shareBikeCompanies.length; i++) {
            //shareBikeCompanies[i]=new smjava.homework1117myself.ShareBikeCompany();
            //shareBikeCompanies[i].setBikeCompanyId(i+1);
            //shareBikeCompanies[i].setBikeSum(3);
            //shareBikeCompanies[i].setSharedCount(0);
            ShareBike[] shareBike=shareBikeCompanies[i].getSharedBikes();
            if(i==0){
                //shareBikeCompanies[i].setBikeCompanyName("美团");
                for (int j = 0; j < shareBike.length; j++) {
                    shareBike[j]=new ShareBike();
                    shareBike[j].setBikeId(j+1);
                    shareBike[j].setBikeName("美团单车"+j);
                    shareBike[j].setStatus(0);
                    shareBike[j].setBorrowTime(null);
                    shareBikeCompanies[i].setBikeSum(shareBikeCompanies[i].getBikeSum()+1);
                }
                //shareBikeCompanies[i].setSharedBikes(shareBikes1);
            }else if(i==1){
                shareBikeCompanies[i].setBikeCompanyName("哈啰");
                for (int j = 0; j < shareBike.length; j++) {
                    shareBike[j]=new ShareBike();
                    shareBike[j].setBikeId(j+1);
                    shareBike[j].setBikeName("哈啰单车"+j);
                    shareBike[j].setStatus(0);
                    shareBikeCompanies[i].setBikeSum(shareBikeCompanies[i].getBikeSum()+1);
                }
                //shareBikeCompanies[i].setSharedBikes(shareBike);

            }else{
                shareBikeCompanies[i].setBikeCompanyName("青桔");
                for (int j = 0; j < shareBike.length; j++) {
                    shareBike[j]=new ShareBike();
                    shareBike[j].setBikeId(j+1);
                    shareBike[j].setBikeName("青桔单车"+j);
                    shareBike[j].setStatus(0);
                    shareBikeCompanies[i].setBikeSum(shareBikeCompanies[i].getBikeSum()+1);
                }
                shareBikeCompanies[i].setSharedBikes(shareBike);
            }
        }
    }


}

public class TestDemo {
    public static void main(String[] args) {
        new ShareBikeMag().run();
    }

}

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏0 回帖

关键词：java学习 面向对象 Java jav Capability

相关内容：Java面向对象学习