国产四虎永久免费观看,亚洲熟女精品一区二区,国产一区二区三区av在线无码观看

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類的貧血模型，暴露了我對面向對象設計原則理解的不足。在未來的編程實踐中，我將更注重單一職責原則，合理運用設計模式，加強異常處理和邊界條件檢查，同時提高代碼注釋和文檔編寫的意識。這次經歷雖然充滿挫折，但讓我獲得了寶貴的經驗教訓，這將指引我在軟件開發道路上不斷進步和完善。失敗是成功之母，這些不完美的代碼正是我成長過程中最真實的見證。

posted on 2025-04-20 21:17 UnKn0wN__XD 閱讀(14) 評論(0) 收藏舉報

刷新頁面返回頂部

UnKn0wN-XD

Java三次電梯題目BLOG

導航

公告