Java三次电梯题目BLOG

一，前言：
这三次题目以面向对象为主，要求我们写出电梯运行的代码，其中主要包含电梯运行请求处理和调度控制等功能，程序通过接收用户输入的外部请求和内部请求，模拟电梯的运行过程，包括电梯移动、方向判断、开关门等行为。经历三次电梯题目，充分让我认识到自身能力的不足。但同时在不断改错，完善代码的过程中也让我成长了许多，三次题目没一次做出来，不仅是能力上的不足，也是我在一开始对于学习的不认真导致的结果。这次的题目上的失利也教会我很多。
第一次的代码
`import java.util.Scanner;
import java.util.LinkedList;
enum Direction {
UP,
DOWN,
None;
}
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int min=sc.nextInt();
int max=sc.nextInt();
Elevator DT=new Elevator(max,min,1);
Queue QU=new Queue();
Control CT=new Control(DT,QU);
while(true)
{
String in=sc.next();
if(in.equalsIgnoreCase("end"))
{
break;
}
if(in.startsWith("<")&&in.endsWith(">"))
{
if(in.matches("<\d+,(UP|DOWN)>"))
{
String a=in.replaceAll("[<>,]","");
String number=a.replaceAll("[A-Z]","");
Integer num = Integer.valueOf(number);
if(num>CT.eleget().maxget()||num<CT.eleget().minget())
{
continue;
}
String Dir=a.replaceAll("[0-9]","");
if(Dir.equals("DOWN"))
{
Requst n=new Requst(num,Direction.DOWN);
CT.queueget().outadd(n);
}
else if(Dir.equals("UP"))
{
Requst n=new Requst(num,Direction.UP);
CT.queueget().outadd(n);
}

            }
            else
            {
                String number=in.replaceAll("[<>]","");
                Integer num = Integer.valueOf(number);
                if(num>CT.eleget().maxget()||num<CT.eleget().minget())
                {
                    continue;
                }
                CT.queueget().inadd(num);
            }
        }
        else continue;

    }
    //System.out.println(CT.queueget().inget());
   while(true)
   {
       if(CT.queueget().outget().isEmpty()&&CT.queueget().inget().isEmpty())
       {
           return;
       }
       CT.check();
   }



}

}
class Elevator {
private int maxFloor;
private int minFloor;
private int nowFloor;
private Direction direction;

public Elevator()
{
    this.maxFloor=1;
    this.minFloor=1;
    this.nowFloor=1;
    this.direction=Direction.UP;
}
public Elevator(int max,int min,int now)
{
    this.minFloor=min;
    this.maxFloor=max;
    this.nowFloor=now;
    this.direction=Direction.UP;
}
public void maxset(int a)
{
    this.maxFloor=a;
}
public void minset(int a)
{
    this.minFloor=a;
}

public void nowset(int a)
{
    this.nowFloor=a;
}
public int maxget()
{
    return this.maxFloor;
}
public int minget()
{
    return this.minFloor;
}
public int nowget()
{
    return this.nowFloor;
}
public Direction dirget()
{
    return this.direction;
}
public void dirset(Direction dir)
{
    this.direction=dir;
}

}
class Queue {
private LinkedList inrequst;
private LinkedList exrequst;
public Queue()
{
this.inrequst=new LinkedList<>();
this.exrequst =new LinkedList<>();
}
public Queue(LinkedList inside,LinkedList exrequst)
{
this.inrequst=inside;
this.exrequst = exrequst;
}
public LinkedList inget()
{
return this.inrequst;
}
public LinkedList outget()
{
return this.exrequst;
}
public void inadd(Integer e)
{
this.inrequst.addLast(e);
}
public void outadd(Requst e)
{
this.exrequst.addLast(e);
}
public void indel(int i)
{
this.inrequst.remove(i);
}
public void outdel(int i)
{
this.exrequst.remove(i);
}

}
class Control {
private Elevator elevator;
private Queue queue;
public Control()
{
this.elevator=new Elevator();
this.queue=new Queue();
}
public Control(Elevator elevator,Queue queue)
{
this.elevator=elevator;
this.queue=queue;
}
public void eleset(Elevator elevator)
{
this.elevator=elevator;
}
public Elevator eleget()
{
return this.elevator;
}
public void queueset(Queue queue)
{
this.queue=queue;
}
public Queue queueget()
{
return this.queue;
}
public void move()
{
int now=this.elevator.nowget();
switch(this.elevator.dirget())
{
case UP:
if(now+1>this.elevator.maxget())
{
this.elevator.dirset(Direction.DOWN);
//this.elevator.nowset(now-1);
}
else this.elevator.nowset(now+1);
break;
case DOWN:
if(now-1<this.elevator.minget())
{
this.elevator.dirset(Direction.UP);
//this.elevator.nowset(now+1);
}
else this.elevator.nowset(now-1);
break;
}

}
public void check()
{
    if(this.queue.inget().isEmpty() &&this.queue.outget().isEmpty())
    {
        elevator.dirset(Direction.None);
        return;
    }
    int now=this.elevator.nowget();
    if(isStop())
    {
        System.out.printf("Current Floor: %d Direction: %s%n",this.elevator.nowget(),this.elevator.dirget().name());
        System.out.printf("Open Door # Floor %d%n",now);
        System.out.println("Close Door");
    }
    else
    {
        System.out.printf("Current Floor: %d Direction: %s%n",this.elevator.nowget(),this.elevator.dirget().name());
    }
    boolean pd1=false;
    boolean pd2=false;
    switch(this.elevator.dirget())
    {
        case UP:
            for(int i=0;i<this.queue.inget().size();i++)
            {
                if(now<this.queue.inget().get(i))
                {
                    pd1=true;
                }
            }

            for(int i=0;i<this.queue.outget().size();i++)
            {
                if(this.queue.outget().get(i).dirget()==Direction.UP &&this.queue.outget().get(i).floorget()>now)
                {
                    pd1=true;
                }

            }
            for(int i=0;i<this.queue.inget().size();i++)
            {
                if(now>this.queue.inget().get(i))
                {
                    pd2=true;
                }
            }

            for(int i=0;i<this.queue.outget().size();i++)
            {
                if(this.queue.outget().get(i).dirget()==Direction.DOWN &&this.queue.outget().get(i).floorget()<now)
                {
                    pd2=true;
                }

            }

            if(!pd1&&pd2)
            {
                this.elevator.dirset(Direction.DOWN);
            }
            break;
        case DOWN:
            for(int i=0;i<this.queue.inget().size();i++)
            {
                if(now<this.queue.inget().get(i))
                {
                    pd1=true;
                }
            }

            for(int i=0;i<this.queue.outget().size();i++)
            {
                if(this.queue.outget().get(i).dirget()==Direction.UP &&this.queue.outget().get(i).floorget()>now)
                {
                    pd1=true;
                }

            }
            for(int i=0;i<this.queue.inget().size();i++)
            {
                if(now>this.queue.inget().get(i))
                {
                    pd2=true;
                }
            }

            for(int i=0;i<this.queue.outget().size();i++)
            {
                if(this.queue.outget().get(i).dirget()==Direction.DOWN &&this.queue.outget().get(i).floorget()<now)
                {
                    pd2=true;
                }

            }

            if(!pd2&&pd1)
            {
                this.elevator.dirset(Direction.UP);
            }
            break;
        case None:
            this.elevator.dirset(this.queue.outget().getFirst().dirget());
            break;

    }
    if(!this.queue.inget().isEmpty()||!this.queue.outget().isEmpty())
    {
        move();
    }

}
public boolean isStop()
{
    for(int i=0;i<this.queue.outget().size();i++)
    {
        if(this.queue.outget().get(i).dirget()==this.elevator.dirget()&&this.queue.outget().get(i).floorget()==this.elevator.nowget())
        {
            this.queue.outdel(i);
            return true;
        }
    }
    int now=this.elevator.nowget();
   for(int i=0;i<this.queue.inget().size();i++)
   {
       if(this.queue.inget().get(i)==now)
       {
           this.queue.indel(i);
           return true;
       }

   }

   return false;
}

}
class Requst {
private Integer floor;
private Direction dir;
public Requst()
{
this.floor=0;
this.dir=Direction.None;
}
public Requst(Integer floor,Direction dir)
{
this.floor=floor;
this.dir=dir;
}
public Integer floorget()
{
return this.floor;
}
public Direction dirget()
{
return this.dir;
}
}`
主要类结构：
2.1 Direction枚举
定义了电梯运行的三种方向状态：

UP：向上运行

DOWN：向下运行

None：无方向（初始或空闲状态）

2.2 Elevator类
电梯实体类，包含以下属性和方法：

属性：最高楼层(maxFloor)、最低楼层(minFloor)、当前楼层(nowFloor)、运行方向(direction)

方法：各种getter和setter方法，用于获取和设置电梯状态

2.3 Queue类
请求队列管理类，包含两个LinkedList：

inrequst：存储内部请求（乘客在电梯内按下的楼层按钮）

exrequst：存储外部请求（乘客在楼层按下的上下按钮）

2.4 Requst类
外部请求类，包含：

floor：请求的楼层

dir：请求方向（UP或DOWN）

2.5 Control类
核心控制类，负责电梯调度逻辑：

包含电梯和队列的引用

实现电梯移动(move)、检查(check)和停止判断(isStop)等核心逻辑

2.6 Main类
程序入口，处理用户输入并启动电梯模拟

可以看出Control类承担了过多职责，既负责电梯调度算法，又处理请求队列管理，违反了单一职责原则。理想情况下，调度算法应该与队列管理分离，形成独立的策略类。Elevator类虽然封装了电梯状态，但大量属性仍通过getter/setter暴露，实际上是一种"贫血模型"。更合理的做法是将电梯行为(如移动、转向)封装在Elevator类内部，而不是由Control类外部控制。同时命名不规范，类名Requst拼写错误(Request)，方法名如eleget(),minget()不符合Java命名规范(应使用getMin(), getElevator())，变量名pd1,pd2含义不明确等。check()方法中UP和DOWN分支有大量重复代码，可读性差。虽然实现了基本功能，但从面向对象设计、算法效率、代码质量和健壮性等方面都存在明显不足。主要问题包括：职责划分不清、算法效率低下、异常处理缺失、扩展性差等。
第二次代码
`import java.util.Scanner;
import java.util.LinkedList;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int min=sc.nextInt();
int max=sc.nextInt();
Elevator DT=new Elevator(max,min,1);
Queue QU=new Queue();
Control CT=new Control(DT,QU);
while(true)
{
String in=sc.next();
if(in.equalsIgnoreCase("end"))
{
break;
}
if(in.startsWith("<")&&in.endsWith(">"))
{
if(in.matches("<\d+,(UP|DOWN)>"))
{
String a=in.replaceAll("[<>,]","");
String number=a.replaceAll("[A-Z]","");
Integer num = Integer.valueOf(number);
if(!CT.queueget().outget().isEmpty()){
if(num.equals(CT.queueget().outget().getLast().floorget()))
{
continue;
}
}
if(num>CT.eleget().maxget()||num<CT.eleget().minget())
{
continue;
}
String Dir=a.replaceAll("[0-9]","");
if(Dir.equals("DOWN"))
{
Requst n=new Requst(num,Direction.DOWN);
CT.queueget().outadd(n);
}
else if(Dir.equals("UP"))
{
Requst n=new Requst(num,Direction.UP);
CT.queueget().outadd(n);
}

            }
            else
            {
                String number=in.replaceAll("[<>]","");
                Integer num = Integer.valueOf(number);
                if(num>CT.eleget().maxget()||num<CT.eleget().minget())
                {
                    continue;
                }
                else if(!CT.queueget().inget().isEmpty()&&num.equals(CT.queueget().inget().getLast()))
                {
                    continue;
                }
                else{
                CT.queueget().inadd(num);}
            }
        }
        else continue;

    }
    System.out.println("Current Floor: 1 Direction: UP");
   while(true)
   {
       if(CT.queueget().outget().isEmpty()&&CT.queueget().inget().isEmpty())
       {
           return;
       }
       CT.check();
   }



}

}
class Elevator {
private int maxFloor;
private int minFloor;
private int nowFloor;
private Direction direction;

public Elevator()
{
    this.maxFloor=1;
    this.minFloor=1;
    this.nowFloor=1;
    this.direction=Direction.UP;
}
public Elevator(int max,int min,int now)
{
    this.minFloor=min;
    this.maxFloor=max;
    this.nowFloor=now;
    this.direction=Direction.UP;
}
public void maxset(int a)
{
    this.maxFloor=a;
}
public void minset(int a)
{
    this.minFloor=a;
}

public void nowset(int a)
{
    this.nowFloor=a;
}
public int maxget()
{
    return this.maxFloor;
}
public int minget()
{
    return this.minFloor;
}
public int nowget()
{
    return this.nowFloor;
}
public Direction dirget()
{
    return this.direction;
}
public void dirset(Direction dir)
{
    this.direction=dir;
}

}
class Queue {
private LinkedList inrequst;
private LinkedList exrequst;
public Queue()
{
this.inrequst=new LinkedList<>();
this.exrequst =new LinkedList<>();
}
public Queue(LinkedList inside,LinkedList exrequst)
{
this.inrequst=inside;
this.exrequst = exrequst;
}
public LinkedList inget()
{
return this.inrequst;
}
public LinkedList outget()
{
return this.exrequst;
}
public void inadd(Integer e)
{
this.inrequst.addLast(e);
}
public void outadd(Requst e)
{
this.exrequst.addLast(e);
}
public void indel(int i)
{
this.inrequst.remove(i);
}
public void outdel(int i)
{
this.exrequst.remove(i);
}

}
class Control {
private Elevator elevator;
private Queue queue;
public Control()
{
this.elevator=new Elevator();
this.queue=new Queue();
}
public Control(Elevator elevator,Queue queue)
{
this.elevator=elevator;
this.queue=queue;
}
public void eleset(Elevator elevator)
{
this.elevator=elevator;
}
public Elevator eleget()
{
return this.elevator;
}
public void queueset(Queue queue)
{
this.queue=queue;
}
public Queue queueget()
{
return this.queue;
}
public void move()
{
int now=this.elevator.nowget();
switch(this.elevator.dirget())
{
case UP:
if(now+1>this.elevator.maxget())
{
this.elevator.dirset(Direction.DOWN);
//this.elevator.nowset(now-1);
}
else this.elevator.nowset(now+1);
break;
case DOWN:
if(now-1<this.elevator.minget())
{
this.elevator.dirset(Direction.UP);
//this.elevator.nowset(now+1);
}
else this.elevator.nowset(now-1);
break;
}
System.out.printf("Current Floor: %d Direction: %s%n",this.elevator.nowget(),this.elevator.dirget().name());
}
public void check()
{
if(this.queue.inget().isEmpty() &&this.queue.outget().isEmpty())
{
elevator.dirset(Direction.None);
return;
}
int now=this.elevator.nowget();
if(isStop())
{
System.out.printf("Open Door # Floor %d%n",now);
System.out.println("Close Door");
return;
}
boolean pd1=false;
boolean pd2=false;
switch(this.elevator.dirget())
{
case UP:
if(!this.queue.inget().isEmpty()&&now<this.queue.inget().getFirst())
{
pd1 = true;
}
if(!this.queue.outget().isEmpty()&&this.queue.outget().getFirst().dirget()==Direction.UP &&this.queue.outget().getFirst().floorget()>now)
{
pd1=true;
}

                if(!this.queue.inget().isEmpty()&&now>this.queue.inget().getFirst())
                {
                    pd2=true;
                }
                if(!this.queue.outget().isEmpty()&&this.queue.outget().getFirst().dirget()==Direction.DOWN &&this.queue.outget().getFirst().floorget()<now)
                {
                    pd2=true;
                }
            if(!pd1&&pd2)
            {
                this.elevator.dirset(Direction.DOWN);
            }
            break;
        case DOWN:
                if(!this.queue.inget().isEmpty()&&now<this.queue.inget().getFirst())
                {
                    pd1=true;
                }
                if(!this.queue.outget().isEmpty()&&this.queue.outget().getFirst().dirget()==Direction.UP &&this.queue.outget().getFirst().floorget()>now)
                {
                    pd1=true;
                }
                if(!this.queue.inget().isEmpty()&&now>this.queue.inget().getFirst())
                {
                    pd2=true;
                }
                if(!this.queue.outget().isEmpty()&&this.queue.outget().getFirst().dirget()==Direction.DOWN &&this.queue.outget().getFirst().floorget()<now)
                {
                    pd2=true;
                }
            if(!pd2&&pd1)
            {
                this.elevator.dirset(Direction.UP);
            }
            break;
        case None:
            this.elevator.dirset(this.queue.outget().getFirst().dirget());
            break;

    }
    if(!this.queue.inget().isEmpty()||!this.queue.outget().isEmpty())
    {
        move();
    }

}
public boolean isStop()
{
    for(int i=0;i<1;i++)
    {
        if(this.queue.outget().get(i).dirget()==this.elevator.dirget()&&this.queue.outget().get(i).floorget()==this.elevator.nowget())
        {
            this.queue.outdel(i);
            return true;
        }
    }
    int now=this.elevator.nowget();
   for(int i=0;i<this.queue.inget().size();i++)
   {
       if(this.queue.inget().get(i)==now)
       {
           this.queue.indel(i);
           return true;
       }

   }

   return false;
}

}
class Requst {
private Integer floor;
private Direction dir;
public Requst()
{
this.floor=0;
this.dir=Direction.None;
}
public Requst(Integer floor,Direction dir)
{
this.floor=floor;
this.dir=dir;
}
public Integer floorget()
{
return this.floor;
}
public Direction dirget()
{
return this.dir;
}
}
enum Direction {
UP,
DOWN,
None;
}![](https://img2024.cnblogs.com/blog/3636650/202504/3636650-20250420204154730-5281257.png) **基础指标分析** 基本规模指标 总行数: 359行 语句数: 194条 类/接口数: 6个 方法数: 约32个(6类×5.33方法/类) 问题出现在方法拆分不够细致，单个类承载功能过多，缺乏合理的抽象层次，分支语句占比偏高，特别是Control.check()方法复杂度突出，表明该方法承担了过多决策逻辑，可能存在过度嵌套的条件判断，状态管理可能不够清晰。 **代码结构的问题** 平均每个类5.33个方法 平均每个方法4.47条语句 方法复杂度分布不均衡，缺乏类/方法级别的文档注释，关键算法无解释说明，复杂逻辑无注释说明意图。Control.check()方法问题有包含大量嵌套的条件判断，同时处理多种状态和边界条件，违反了单一职责原则 设计问题： 状态管理混乱：高分支占比说明状态转换逻辑分散 缺乏抽象层次：平均方法数尚可但存在极端值，说明抽象不一致 紧耦合：Control类可能过度依赖其他类的实现细节 接近零注释：增加后续维护难度 复杂度集中：check()方法成为系统瓶颈 测试困难：高分支覆盖率难以保证 **第三次代码**import java.util.Scanner;
import java.util.LinkedList;
import java.util.Iterator;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int min=sc.nextInt();
int max=sc.nextInt();
Elevator DT=new Elevator(max,min,1);
Queue QU=new Queue();
Control CT=new Control(DT,QU);
while(true)
{
String in=sc.next();
if(in.equalsIgnoreCase("end"))
{
break;
}
if(in.startsWith("<")&&in.endsWith(">"))
{
if(in.matches("<\d+,\d+>"))

            {
                String numbers = in.substring(1, in.length() - 1);
                String[] parts = numbers.split(",");
                int num1 = Integer.parseInt(parts[0]);
                int num2 = Integer.parseInt(parts[1]);
                User newUser=new User(num1,num2);
                CT.queueget().outadd(newUser);
            }
            else
            {
                String number=in.replaceAll("[<>]","");
                Integer num = Integer.valueOf(number);
                if(num>CT.eleget().maxget()||num<CT.eleget().minget())
                {
                    continue;
                }
                else if(!CT.queueget().inget().isEmpty()&&num.equals(CT.queueget().inget().getLast()))
                {
                    continue;
                }
                else{
                CT.queueget().inadd(num);}
            }
        }
        else continue;

    }
   while(true)
   {
       if(CT.queueget().outget().isEmpty()&&CT.queueget().inget().isEmpty())
       {
           return;
       }
       CT.check();
   }



}

}
class Elevator {
private int maxFloor;
private int minFloor;
private int nowFloor;
private Direction direction;

public Elevator()
{
    this.maxFloor=1;
    this.minFloor=1;
    this.nowFloor=1;
    this.direction=Direction.UP;
}
public Elevator(int max,int min,int now)
{
    this.minFloor=min;
    this.maxFloor=max;
    this.nowFloor=now;
    this.direction=Direction.UP;
}
public void maxset(int a)
{
    this.maxFloor=a;
}
public void minset(int a)
{
    this.minFloor=a;
}

public void nowset(int a)
{
    this.nowFloor=a;
}
public int maxget()
{
    return this.maxFloor;
}
public int minget()
{
    return this.minFloor;
}
public int nowget()
{
    return this.nowFloor;
}
public Direction dirget()
{
    return this.direction;
}
public void dirset(Direction dir)
{
    this.direction=dir;
}

}
class Queue {
private LinkedList inrequst;
private LinkedList exrequst;
public Queue()
{
this.inrequst=new LinkedList<>();
this.exrequst =new LinkedList<>();
}
public Queue(LinkedList inside,LinkedList exrequst)
{
this.inrequst=inside;
this.exrequst = exrequst;
}
public LinkedList inget()
{
return this.inrequst;
}
public LinkedList outget()
{
return this.exrequst;
}
public void inadd(Integer e)
{
this.inrequst.addLast(e);
}
public void outadd(User e)
{
this.exrequst.addLast(e);
}
public void indel(int i)
{
this.inrequst.remove(i);
}
public void outdel(int i)
{
this.exrequst.remove(i);
}

}
class Control {
private Elevator elevator;
private Queue queue;
public Control()
{
this.elevator=new Elevator();
this.queue=new Queue();
}
public Control(Elevator elevator,Queue queue)
{
this.elevator=elevator;
this.queue=queue;
}
public void eleset(Elevator elevator)
{
this.elevator=elevator;
}
public Elevator eleget()
{
return this.elevator;
}
public void queueset(Queue queue)
{
this.queue=queue;
}
public Queue queueget()
{
return this.queue;
}
public void move()
{
int now=this.elevator.nowget();
switch(this.elevator.dirget())
{
case UP:
if(now+1>this.elevator.maxget())
{
this.elevator.dirset(Direction.DOWN);
}
else this.elevator.nowset(now+1);
break;
case DOWN:
if(now-1<this.elevator.minget())
{
this.elevator.dirset(Direction.UP);
}
else this.elevator.nowset(now-1);
break;
}
System.out.printf("Current Floor: %d Direction: %s%n",this.elevator.nowget(),this.elevator.dirget().name());
}
public void check()
{
if(this.queue.inget().isEmpty() &&this.queue.outget().isEmpty())
{
elevator.dirset(Direction.None);
return;
}
int now=this.elevator.nowget();
if(isStop())
{
System.out.printf("Open Door # Floor %d%n",now);
System.out.println("Close Door");
return;
}
boolean pd1=false;
boolean pd2=false;
if(!this.queue.inget().isEmpty()&&now<this.queue.inget().getFirst())
{
pd1=true;
}
if(!this.queue.outget().isEmpty()&&((this.queue.outget().getFirst().dirget()<now&&this.queue.outget().getFirst().ispick())||(this.queue.outget().getFirst().floorget()<now&&!this.queue.outget().getFirst().ispick())))
{
pd1=true;
}
if(!this.queue.inget().isEmpty()&&now>this.queue.inget().getFirst())
{
pd2=true;
}
if(!this.queue.outget().isEmpty()&&((this.queue.outget().getFirst().dirget()>now&&this.queue.outget().getFirst().ispick() )||(this.queue.outget().getFirst().floorget()>now&&!this.queue.outget().getFirst().ispick())))
{
pd2=true;
}
switch(this.elevator.dirget())
{
case UP:
if(!pd1&&pd2)
{
this.elevator.dirset(Direction.DOWN);
}
break;
case DOWN:
if(!pd2&&pd1)
{
this.elevator.dirset(Direction.UP);
}
break;
case None:
this.elevator.dirset(Direction.UP);
break;

    }
    if(!this.queue.inget().isEmpty()||!this.queue.outget().isEmpty())
    {
        move();
    }
}
public boolean isStop() {
    int now = this.elevator.nowget();
    boolean shouldStop = false;
    while (queue.inget().contains(now)) {
        queue.inget().removeFirstOccurrence(now);
        shouldStop = true;
    }
    Iterator<User> it = queue.outget().iterator();
    while (it.hasNext()) {
        User u = it.next();
        if (u.floorget() == now) {
            queue.inadd(u.dirget());
            it.remove();
            shouldStop = true;
        }
    }

    return shouldStop;
}

}
class User {
private Integer infloor;
private Integer dirfloor;
private boolean isPick;
public User()
{
this.infloor=0;
this.dirfloor=0;
this.isPick=false;
}
public User(Integer floor, Integer dir)
{
this.infloor=floor;
this.dirfloor =dir;
this.isPick=false;
}
public Integer floorget()
{
return this.infloor;
}
public Integer dirget()
{
return this.dirfloor;
}
public boolean ispick()
{
return this.isPick;
}
public void pick()
{
this.isPick=true;
}
}
enum Direction {
UP,
DOWN,
None;
}
`

这段电梯模拟程序代码虽然实现了基本功能，但从面向对象设计、代码质量、算法效率和健壮性等方面都存在显著缺陷。首先在架构设计上，Control类严重违反了单一职责原则，承担了电梯移动控制、请求队列管理、调度算法实现和输入输出处理等多重职责，导致check()方法仍然臃肿复杂（80+行），Elevator类也仍是缺乏行为的"贫血模型"。代码质量问题突出表现在命名不规范（如无意义的pd1/pd2变量）、条件逻辑混乱（check()中深度嵌套的条件判断形成"箭头代码"）以及资源管理缺陷（Scanner未关闭）。功能实现方面存在多处逻辑漏洞，如isStop()方法可能漏删元素、None状态处理简单粗暴设为UP方向、请求去重仅检查最后一个元素等。性能问题主要源于低效的LinkedList使用导致O(n)操作频繁，以及isStop()中重复全列表扫描的低效实现。最严重问题集中在Control类的check()和isStop()方法，暴露出过程式编程思维而非面向对象、缺乏合理抽象层次和对边界条件考虑不周等深层次问题。

结语
通过这三次电梯模拟程序的开发实践，我深刻认识到自己在面向对象编程和系统设计方面的不足。第一次尝试虽然构建了基本框架，但存在严重的职责分配不均和代码结构问题；第二次改进时虽然优化了部分逻辑，却未能解决核心架构缺陷；第三次虽然引入了更复杂的用户请求处理，但整体设计依然臃肿低效。这三次迭代让我明白，优秀的代码不仅需要实现功能，更要注重可维护性、可扩展性和健壮性。特别是Control类的过度膨胀和Elevator类的贫血模型，暴露了我对面向对象设计原则理解的不足。在未来的编程实践中，我将更注重单一职责原则，合理运用设计模式，加强异常处理和边界条件检查，同时提高代码注释和文档编写的意识。这次经历虽然充满挫折，但让我获得了宝贵的经验教训，这将指引我在软件开发道路上不断进步和完善。失败是成功之母，这些不完美的代码正是我成长过程中最真实的见证。