21201701-陈荟光第二次学习总结

前言：

随着学习的不断深入，Java类设计的题目也愈加难了起来，近两周的作业难度更是达到了令人头皮发麻的程度。先不论继承多态的综合应用，单是设计那些数量繁多功能繁杂的类就已经让人头皮发麻。除此之外还有大量的数学领域的复杂计算，不禁让人怀疑人生。本篇报告选取了PTA题目集06的7-5、本次期中考试试题、超星作业中双向链表的设计以及第五次农夫过河的迭代实验，主要讲述关于我对容器、多态、继承的个人理解以及在设计上述实验时的思路。

设计与分析与采坑心得与改进建议：

ATM机类结构设计（一）

实验要求请参考https://images.ptausercontent.com/93fc7ad6-5e85-445a-a759-5790d0baab28.pdf

关于本次实验，我的设计思路大致分为如下几个阶段：

一、大方向设计

根据实验手册中的信息，可以知道，本实验中涉及到的实体有：银行、用户、银行账户、银行卡和ATM机；涉及到的抽象信息有：用户名、隶属银行、银行账号、余额、隶属卡号和密码和ATM机编号。由此一来，我们便可以以填空的形式构建类的初始信息。

首先，根据我们日常生活中的经验可以知道，用户名是用户的基础信息，而每个用户可以拥有多个银行账户，所以用户类下应该含有两个属性：用户名和银行账户列表。

然后是银行账户类。银行账号是识别银行账户的根本信息，而银行账户都是隶属于某个银行的，且用户的存款也是存到账户中，每个银行账户又可以开通多张银行卡，故银行账户类下应该含有四个属性：银行账号、隶属银行、存款数额以及银行卡列表。

再然后是银行卡类。在本实验情境中，不难看出，银行卡只是从银行账户取款的手段，也就是我们俗称的“工具人”，故银行卡的属性只有银行卡号和密码。

关于银行类，由于本题中并未调用其方法，所以我仅将它作为一个参数，没有设计类；而ATM机类也仅仅是作为验证码一样的存在，同样是工具人，所以ATM机类的属性只需要ATM机编号和隶属银行便足以。

二、实体类方法设计

在设计实体类之前，我们需要知道存取款的原理。根据日常生活的经验，我们知道，要想取钱，首先得在ATM机上插入银行卡，然后输入密码，访问自己的银行账户，然后进行存取款等操作。这一系列的流程的实质是，用户在ATM机通过银行卡密访问银行数据库，银行的计算机会遍历数据库找到和银行卡号相匹配的账户，然后我们再进行操作。银行卡本身不进行任何操作，因此银行卡类除了setter和getter外不需要其他方法；而对于银行账户，首先我们要构建存取款方法，然后我们要为银行账户构建修改其名下的银行卡的方法，本实验中由于并不需要用到后者，因此我并没有构建这一方法；对于用户，首先，我们需要能访问我们的银行账户，所以我们需要一个方法来在所有账户中遍历，从而找到和我们使用的银行卡相匹配的方法，其次，我们需要拥有能设置我们的银行账户的方法，如开户和销户，本实验中虽然用不到，但我也顺手做了一对了；ATM机类仅供验证用，故只需要getter和setter用于获取其信息便足以。

三、业务类设计

在完成了对所有实体类的创建以后，我们要做的便是构建一个将所有实体类关联起来，在本实验中，我们要做的便是一个类似银行系统的业务类。

在实体类设计中，我们已经说明了银行系统的职业，这里就不再赘述。总的来说，我们的银行系统要做到以下两点：1.用户输入正确的卡密后访问其对应的账户；2.根据用户的输入调用其账户的对应方法，并给予反馈；3.检测用户是否有诸如跨行取款的不合法行为并给予相应的反馈。

为了完成上述需求，首先，我们需要创建一个静态的用户类容器作为数据库，用于记录下所有数据；然后我们需要创建一个静态的ATM类容器用于验证用户行为的合法性；我们需要构建方法用于检测用户的输入信息和用户行为的合法性并给出相应的反馈，另外针对不同的操作需要构建不同的方法(如存取款与查看余额)。至此，设计阶段已然完成，接下来便是代码实现了。

四、代码实现

最终代码：

 

import java.util.ArrayList;
import java.util.Scanner;

public class Main {

    public static Scanner input = new Scanner(System.in);
    
    public static void main(String[] args){
        
        Model model = new Model();
        //初始化ATM
        Model.atms.add(new ATM("01", "中国建设银行"));
        Model.atms.add(new ATM("02", "中国建设银行"));
        Model.atms.add(new ATM("03", "中国建设银行"));
        Model.atms.add(new ATM("04", "中国建设银行"));
        Model.atms.add(new ATM("05", "中国工商银行"));
        Model.atms.add(new ATM("06", "中国工商银行"));
        //创建初始账户
        Model.users.add(new User("杨过",new ArrayList<Account>() {
            {
                add(new Account("3217000010041315709", "中国建设银行", 10000.00, new ArrayList<Card>() {
                    {
                        add(new Card("6217000010041315709", "88888888"));
                        add(new Card("6217000010041315715", "88888888"));
                    }
                }));
                add(new Account("3217000010041315715", "中国建设银行", 10000.00, new ArrayList<Card>() {
                    {
                        add(new Card("6217000010041315718", "88888888"));
                    }
                }));
            }
        }));
        
        Model.users.add(new User("郭靖",new ArrayList<Account>() {
            {
                add(new Account("3217000010051320007", "中国建设银行", 10000.00, new ArrayList<Card>() {
                    {
                        add(new Card("6217000010051320007", "88888888"));
                    }
                }));
            }
        }));
        
        Model.users.add(new User("张无忌",new ArrayList<Account>() {
            {
                add(new Account("3222081502001312389", "中国工商银行", 10000.00, new ArrayList<Card>() {
                    {
                        add(new Card("6222081502001312389", "88888888"));
                    }
                }));
                add(new Account("3222081502001312390", "中国工商银行", 10000.00, new ArrayList<Card>() {
                    {
                        add(new Card("6222081502001312390", "88888888"));
                    }
                }));
                add(new Account("3222081502001312399", "中国工商银行", 10000.00, new ArrayList<Card>() {
                    {
                        add(new Card("6222081502001312399", "88888888"));
                        add(new Card("6222081502001312400", "88888888"));
                    }
                }));
            }
        }));
        Model.users.add(new User("韦小宝",new ArrayList<Account>() {
            {
                add(new Account("3222081502051320785", "中国工商银行", 10000.00, new ArrayList<Card>() {
                    {
                        add(new Card("6222081502051320785", "88888888"));
                    }
                }));
                add(new Account("3222081502051320786", "中国工商银行", 10000.00, new ArrayList<Card>() {
                    {
                        add(new Card("6222081502051320786", "88888888"));
                    }
                }));
            }
        }));
        model.work();
    }
    
}


class Model {
    

    public static ArrayList<User> users = new ArrayList<>();
    public static ArrayList<ATM> atms = new ArrayList<>();
    
    private String pattern1 = "\\d{19}\\s+\\d+\\s+\\d+\\s+(\\+|-)?\\d+(\\.\\d+)?";
    private String pattern2 = "\\d{19}";

    public Model() {
    }
    
    public void work() {
        while (true) {
            String command = Main.input.nextLine();
            if (command.matches(pattern1)) {
                changeDeposit(command);
            } else if (command.matches(pattern2)){
                checkDeposit(command);
            } else {
                break;
            }
        }
    }
    
    public ATM searchATM(String ATMID) {
        for (ATM atm:atms) {
            if (atm.getNumber().equals(ATMID)) {
                return atm;
            }
        }
        System.out.println("Sorry,the ATM's id is wrong.");
        System.exit(0);
        return null;
    }

    public User searchUser(String cardID) {
        for (User user:Model.users) {
            for (Account account:user.getAccounts()) {
                for (Card card:account.getCards()) {
                    if (card.getCardID().equals(cardID)) {
                        return user;
                    }
                }
            }
        }
        System.out.println("Sorry,this card does not exist.");
        System.exit(0);
        return null;
    }
    
    public void changeDeposit(String command) {
        String[] imformation = command.split("\\s+");
        User user = searchUser(imformation[0]);
        Account account = user.accessAccount(imformation[0], imformation[1]);
        ATM atm = searchATM(imformation[2]);
        if (!atm.validate(account.getBank())){
            System.out.println("Sorry,cross-bank withdrawal is not supported.");
            System.exit(0);
        }
        double amount = -(Double.parseDouble(imformation[3]));
        if (account.getDeposit() + amount < 0) {
            System.out.println("Sorry,your account balance is insufficient.");
            System.exit(0);
        } else {
            account.changeDeposit(amount);
            if (amount >= 0) {
                System.out.println(user.getUserName() + "在" + atm.getBankName() + "的" + imformation[2] + "号ATM机上存款¥" + String.format("%.2f", amount) + "\n当前余额为¥" + String.format("%.2f", account.getDeposit()));
            } else {
                System.out.println(user.getUserName() + "在" + atm.getBankName() + "的" + imformation[2] + "号ATM机上取款¥" + String.format("%.2f", -amount) + "\n当前余额为¥" + String.format("%.2f", account.getDeposit()));
            }
        }
    }
    
    public void checkDeposit(String cardID) {
        User user = searchUser(cardID);
        Account account = user.searchAccount(cardID);
        System.out.printf("¥%.2f\n", account.getDeposit());
    }

}


class User {
    
    private String userName;
    private ArrayList<Account> accounts;

    public User() {
        // TODO Auto-generated constructor stub
    }

    public User(String userName, ArrayList<Account> accounts) {
        super();
        this.userName = userName;
        this.accounts = accounts;
    }

    public void openAccount(Account newAccount) {
        accounts.add(newAccount);
    }
    
    public void closeAccount(Account newAccount) {
        if (!accounts.remove(newAccount)) {
            System.out.print("Sorry,this card does not exist.");
        }
    }
    
    public Account accessAccount(String cardID, String password) {
        for (Account account:accounts) {
            for (Card card:account.getCards()) {
                if (card.getCardID().equals(cardID)) {
                    if (card.getPassword().equals(password)) {
                        return account;
                    } else {
                        System.out.print("Sorry,your password is wrong.");
                        System.exit(0);
                        return null;
                    }
                }
            }
        }
        System.out.println("Sorry,this card does not exist.");
        System.exit(0);
        return null;
    }
    
    public Account searchAccount(String cardID) {
        for (Account account:accounts) {
            for (Card card:account.getCards()) {
                if (card.getCardID().equals(cardID)) {
                    return account;
                }
            }
        }
        System.out.println("Sorry,this card does not exist.");
        System.exit(0);
        return null;
    }
    
    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public ArrayList<Account> getAccounts() {
        return accounts;
    }

    public void setAccounts(ArrayList<Account> accounts) {
        this.accounts = accounts;
    }

}


class Account {
    
    private String AccountID;
    private String bank;
    private double deposit;
    private ArrayList<Card> cards;

    public Account(String accountID, String bank, double deposit) {
        super();
        AccountID = accountID;
        this.bank = bank;
        this.deposit = deposit;
        cards = new ArrayList<Card>();
    }
    
    public Account(String accountID, String bank, double deposit, ArrayList<Card> cards) {
        super();
        AccountID = accountID;
        this.bank = bank;
        this.deposit = deposit;
        this.cards = cards;
    }
    
    public void changeDeposit(double amount) {
        deposit += amount;
    }
    
    public String getAccountID() {
        return AccountID;
    }

    public void setAccountID(String accountID) {
        AccountID = accountID;
    }
    
    public String getBank() {
        return bank;
    }

    public void setBank(String bank) {
        this.bank = bank;
    }

    public double getDeposit() {
        return deposit;
    }

    public void setDeposit(double deposit) {
        this.deposit = deposit;
    }
    
    public ArrayList<Card> getCards() {
        return cards;
    }

    public void setCards(ArrayList<Card> cards) {
        this.cards = cards;
    }

    @Override
    public boolean equals(Object obj) {
        Account account = (Account) obj;
        if (account.getAccountID().equals(AccountID)) {
            return true;
        } else {
            return false;
        }
    }
    
}


class Card {
    
    private String cardID;
    private String password;
    
    public Card() {
        
    }

    public Card(String cardID, String password) {
        super();
        this.cardID = cardID;
        this.password = password;
    }

    public String getCardID() {
        return cardID;
    }

    public void setCardID(String cardID) {
        this.cardID = cardID;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public boolean equals(Object obj) {
        Card card = (Card) obj;
        if (card.getCardID().equals(cardID)) {
            return true;
        } else {
            return false;
        }
    }
    
}


class ATM {

    private String number;
    private String bankName;
    
    public ATM() {
        // TODO Auto-generated constructor stub
    }

    public ATM(String number, String bankName) {
        super();
        this.number = number;
        this.bankName = bankName;
    }
    
    public boolean validate(String bankName) {
        if (this.bankName.equals(bankName)) {
            return true;
        } else {
            return false;
        }
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public String getBankName() {
        return bankName;
    }

    public void setBankName(String bankName) {
        this.bankName = bankName;
    }

}

 

PowerDesigner类图：

 

 

 

点线面问题

一、点线面问题（类设计）

 

由于类图指引过于清晰，故本部分仅提及一些编程技巧

1.在确认输入数据符合要求的情况下，可以使用.next()过滤空格；

2.浮点数保留数位可以先通过String.format()将浮点数转成需要的格式的字符串，然后使用Double.parseDouble()将字符串转换回浮点数，或使用Interge.parseInt()将字符串转换为整数；

以下是本人的源代码。

 

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        
        Scanner input = new Scanner(System.in);
        
        Line line = new Line(new Point(input.nextDouble(), input.nextDouble()), new Point(input.nextDouble(), input.nextDouble()), input.next());
        
        line.display();
    }

}


class Point {
    
    private double x;
    private double y;
    
    public Point() {
        
    }
    
    public Point(double x, double y) {
        if (x > 0 && x <= 200 && y > 0 && y <= 200) {
            this.x = x;
            this.y = y;
        } else {
            System.out.println("Wrong Format");
            System.exit(0);
        }
    }

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }
    
    public void display() {
        System.out.println("(" + String.format("%.2f", x) + "," + String.format("%.2f", y) + ")");
    }
    
}


class Line {

    private Point point1;
    private Point point2;
    private String color;
    
    public Line() {
        // TODO Auto-generated constructor stub
    }
    
    public Line(Point p1, Point p2, String color) {
        super();
        point1 = p1;
        point2 = p2;
        this.color = color;
    }

    public Point getPoint1() {
        return point1;
    }

    public void setPoint1(Point point1) {
        this.point1 = point1;
    }

    public Point getPoint2() {
        return point2;
    }

    public void setPoint2(Point point2) {
        this.point2 = point2;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
    
    public double getDistance() {
        double distance = Math.sqrt(Math.pow(point1.getX() - point2.getX(), 2) + Math.pow(point1.getY() - point2.getY(), 2));
        return Double.parseDouble(String.format("%.2f", distance));
    }
    
    public void display() {
        System.out.println("The line's color is:" + color);
        System.out.println("The line's begin point's Coordinate is:");
        point1.display();
        System.out.println("The line's end point's Coordinate is:");
        point2.display();
        System.out.println("The line's length is:" + getDistance());
    }
    
}

 

二、点线面问题重构（继承与多态）

关于继承，我发现很多同学都不理解抽象类和实体类之间的关系，不知道该如何设计父类和子类，这里我借此题，仅代表我个人简略阐述我对于抽象类设计的理解。

 

 

 根据本题的类图可知，本题要求Line与Point均继承抽象类Element，即Element为父类，Line与Point为子类。我们会发现，Line和Point看上去几乎毫无相似之处，该如何让它们继承同一个抽象类呢？其实，继承自同一抽象类的实体类完全可以大不相同。

首先我们需要知道抽象类的意义何在。假设没有Element这个抽象类，同时我们这边又有非常多的Point和Line，当我们想让这些Point和Line打印它们自己的信息时，我们至少需要构建两个容器ArrayList<Point>和ArrayList<Line>来存放它们，并写两个for循环来对它们进行遍历。这只是两个类，如果我们除了Point和Line以外，还有Arc、Curve等等多个类，那我们便需要新建更多的容器，写更多的for循环来遍历所有的内容，这样的工作量无疑非常巨大且重复性高。而假设我们让所有的类都继承了Element类，情况便会大大不同：我们只需要一个容器：ArrayList<Element>便可以存放所有数据，同时只需要用一个for循环遍历这个容器，并调用容器中每个Element的display()函数，Element便会将之映射到它们的子类中，并调用子类的display()实现按照预设的格式打印每个实体的信息。

由此不难看出，抽象类最大的作用便是使系统可以通过抽象类名引用子类，并可以简单快捷地通过抽象方法调用各子类中对应的方法。

那么我们该如何根据子类设计抽象类呢？说白了就是找不同。从属性到方法，功能一致的都可以作为抽象方法或者抽象类共有属性，写进抽象类，至于连实现方法都完全相同的则可以直接写进抽象类里面作为正常函数使用。就算没有一点相似也没有关系，只要把父类写成一个空抽象类就行了；继承的唯一要求便是父类中有的项目子类必须全部涵盖，对此只需要写一个空抽象类便可以作为一个万能父类使用。

而在本题中Line和Point虽然几乎没有相似处，但它们有个共同的函数：display()，这两个display()方法虽然功能相同但它们的实现方法均不相同，故只能作为抽象方法写进Element类，即“public abstract void display();”，除此之外，本题与第一题基本没有区别。

完整代码如下：

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        
        Scanner input = new Scanner(System.in);
        
        Point p1 = new Point(input.nextDouble(), input.nextDouble());
        Point p2 = new Point(input.nextDouble(), input.nextDouble());
        
        String color = input.next();
        
        Line line = new Line(p1, p2, color);
        
        Plane plane = new Plane(color);
        
        Element element;
        
        element = p1;//起点Point
        element.display();
          
        element = p2;//终点Point
        element.display();
          
        element = line;//线段
        element.display();
          
        element = plane;//面
        element.display();

    }

}


abstract class Element {

    public Element() {
        // TODO Auto-generated constructor stub
    }
    
    public abstract void display();

}


class Point extends Element {
    
    private double x;
    private double y;
    
    public Point() {
        
    }
    
    public Point(double x, double y) {
        if (x > 0 && x <= 200 && y > 0 && y <= 200) {
            this.x = x;
            this.y = y;
        } else {
            System.out.println("Wrong Format");
            System.exit(0);
        }
    }

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }
    
    @Override
    public void display() {
        System.out.printf("(%.2f,%.2f)\n", x, y);
    }
    
}


class Line extends Element {

    private Point point1;
    private Point point2;
    private String color;
    
    public Line() {
        // TODO Auto-generated constructor stub
    }
    
    public Line(Point p1, Point p2, String color) {
        super();
        point1 = p1;
        point2 = p2;
        this.color = color;
    }

    public Point getPoint1() {
        return point1;
    }

    public void setPoint1(Point point1) {
        this.point1 = point1;
    }

    public Point getPoint2() {
        return point2;
    }

    public void setPoint2(Point point2) {
        this.point2 = point2;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
    
    public double getDistance() {
        return Math.sqrt(Math.pow(point1.getX() - point2.getX(), 2) + Math.pow(point1.getY() - point2.getY(), 2));
    }
    
    @Override
    public void display() {
        System.out.println("The line's color is:" + color);
        System.out.println("The line's begin point's Coordinate is:");
        point1.display();
        System.out.println("The line's end point's Coordinate is:");
        point2.display();
        System.out.printf("The line's length is:%.2f\n", getDistance());
    }
    
}


class Plane extends Element {

    private String color;
    
    public Plane() {
        // TODO Auto-generated constructor stub
    }

    public Plane(String color) {
        this.color = color;
    }
    
    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public void display() {
        System.out.print("The Plane's color is:" + color);
    }

}

 

 

 三、点线面问题再重构（容器类）

 

 

所谓容器，其实便是同一元素的集合，如ArrayList<Interge>便是一个整型容器，作用基本等同于整型数组。容器便像是我们曾学过的C语言中的结构体数组，不过在C语言中我们通过“结构体名 结构体数组名[预设容量]”来声明结构体数组，而在Java中我们通过“ArrayList<类名> 类容器名”来声明容器。ArrayList类拥有很多附带的方法，如add、remove等等，这使得ArrayList在使用时非常方便。除此之外本题并无难点，以下便是我的源码。

class Main {

    public static void main(String[] args) {
        
        Scanner input = new Scanner(System.in);
        
        GeometryObject list = new GeometryObject();
        
        int choice = input.nextInt();
        while(choice != 0) {
            switch(choice) {
                case 1://insert Point object into list 
                    Point p = new Point(input.nextDouble(), input.nextDouble());
                    list.add(p);
                    break;
                case 2://insert Line object into list
                    Line line = new Line(new Point(input.nextDouble(), input.nextDouble()), new Point(input.nextDouble(), input.nextDouble()), input.next());
                    list.add(line);
                    break;
                case 3://insert Plane object into list
                    Plane plane = new Plane(input.next());
                    list.add(plane);
                    break;
                case 4://delete index - 1 object from list
                    int index = input.nextInt();
                    list.remove(index);
                    }
            choice = input.nextInt();
        }
        for (Element each:list.getList()) {
            each.display();
        }
    }

}


abstract class Element {

    public Element() {
        // TODO Auto-generated constructor stub
    }
    
    public abstract void display();

}


class Point extends Element {
    
    private double x;
    private double y;
    
    public Point() {
        
    }
    
    public Point(double x, double y) {
        if (x > 0 && x <= 200 && y > 0 && y <= 200) {
            this.x = x;
            this.y = y;
        } else {
            System.out.println("Wrong Format");
            System.exit(0);
        }
    }

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }
    
    @Override
    public void display() {
        System.out.printf("(%.2f,%.2f)\n", x, y);
    }
    
}


class Line extends Element {

    private Point point1;
    private Point point2;
    private String color;
    
    public Line() {
        // TODO Auto-generated constructor stub
    }
    
    public Line(Point p1, Point p2, String color) {
        super();
        point1 = p1;
        point2 = p2;
        this.color = color;
    }

    public Point getPoint1() {
        return point1;
    }

    public void setPoint1(Point point1) {
        this.point1 = point1;
    }

    public Point getPoint2() {
        return point2;
    }

    public void setPoint2(Point point2) {
        this.point2 = point2;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
    
    public double getDistance() {
        return Math.sqrt(Math.pow(point1.getX() - point2.getX(), 2) + Math.pow(point1.getY() - point2.getY(), 2));
    }
    
    @Override
    public void display() {
        System.out.println("The line's color is:" + color);
        System.out.println("The line's begin point's Coordinate is:");
        point1.display();
        System.out.println("The line's end point's Coordinate is:");
        point2.display();
        System.out.printf("The line's length is:%.2f\n", getDistance());
    }
    
}


class Plane extends Element {

    private String color;
    
    public Plane() {
        // TODO Auto-generated constructor stub
    }

    public Plane(String color) {
        this.color = color;
    }
    
    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public void display() {
        System.out.println("The Plane's color is:" + color);
    }

}


class GeometryObject {

    private ArrayList<Element> list = new ArrayList<>();
    
    public GeometryObject() {
        // TODO Auto-generated constructor stub
    }
    
    public void add(Element e) {
        list.add(e);
    }
    
    public void remove(int index) {
        if (index <= list.size()) {
            list.remove(index - 1);
        }
    }
    
    public ArrayList<Element> getList(){
        return list;
    }

}

 

 

Java实现链表

就我个人的感觉上来说，Java实现链表与C语言实现链表并无二致，无非是将C语言中的struct element{ xxx xxxxx;  ……;  element * next; };换成了class Node<E> {  private E o;  private Node<E> next;  ……  }，因此便不作分析，仅将我的双向链表的PowerDesigner类图与源码奉上。

 

public class Main {

    public static void main(String[] args) {
        DoubleLinkedList<String> list1 = new DoubleLinkedList<>();
        System.out.println("\"The list1 is empty\" is " + list1.isEmpty());
        list1.add("第1个元素");
        list1.add("第2个元素");
        list1.add("第5个元素");
        list1.add("第4个元素");
        list1.printList();
        list1.add(3, "第3个元素");
        list1.add(6, "越界元素");    //越界数据测试（边界值）
        list1.printList();
        System.out.println("列表的长度是" + list1.getSize());
        list1.remove(0);
        list1.printList();
        list1.remove(4);        //越界数据测试（边界值）
        list1.printList();
        list1.add(0, "临时元素1");    //有效数据测试（边界值）
        list1.printList();
        list1.add(6, "临时元素5");    //有效数据测试（边界值）
        list1.printList();
        list1.remove(5);        //有效数据测试（边界值）
        list1.printList();
        list1.remove(1);        //有效数据测试（边界值）
        list1.printList();
        System.out.println("第三个元素是{" + list1.getData(3) + "}");
        System.out.println("第五个元素是{" + list1.getData(4) + "}");    //越界数据测试（边界值）
        System.out.println("\"The list1 is empty\" is " + list1.isEmpty());
        System.out.println("列表的长度是" + list1.getSize());
    }

}


class Node<E> {

    private E data;//数据域，类型为泛型E

    private Node<E> next = null;//后继引用（指针）

    private Node<E> previous = null;//前驱引用（指针）

    public Node() {
        
    }
    
    public Node(E data) {
        super();
        this.data = data;
    }

    public E getData() {
        return data;
    }

    public void setData(E data) {
        this.data = data;
    }

    public Node<E> getNext() {
        return next;
    }

    public void setNext(Node<E> next) {
        this.next = next;
    }

    public Node<E> getPrevious() {
        return previous;
    }

    public void setPrevious(Node<E> previous) {
        this.previous = previous;
    }

}


interface DoubleLinkedListImpl<E> {

     public boolean isEmpty();

     public int getSize();

     public E getData(int index);

     public void remove();

     public void remove(int index);

     public void add(int index, E theElement);

     public void add(E element);

     public void printList(); 

     public E getFirst(); 

     public E getLast();

}


class DoubleLinkedList<E> implements DoubleLinkedListImpl<E> {

     private Node<E> head;//头结点，非第一个节点

     private Node<E> curr;//当前节点

     private Node<E> tail;//最后一个节点

     private int size;
     
    public DoubleLinkedList() {
        super();
        head = new Node<>();
        curr = head;
        tail = head;
    }

    @Override
    public boolean isEmpty() {
        if (size == 0) {
            return true;
        } else {
            return false;
        }
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public E getData(int index) {
        if (index > size || index < 0) {
            System.out.println("Index \"" + index + "\" out of list!");
            return null;
        } else {
            curr = head;
            for (int i = 0; i < index; i ++, curr = curr.getNext());
            return curr.getData();
        }
    }

    @Override
    public void remove() {
        curr = tail.getPrevious();
        tail = curr;
        tail.setNext(null);
        size --;
    }

    @Override
    public void remove(int index) {
        if (index > size || index <= 0) {
            System.out.println("Index \"" + index + "\" out of list!");
        } else {
            if (index == size) {
                tail = tail.getPrevious();
                tail.setNext(null);
                size --;
            }
            else {
                curr = head;
                for (int i = 0; i < index - 1; i ++, curr = curr.getNext());
                curr.setNext(curr.getNext().getNext());
                curr.getNext().setPrevious(curr);
                size --;
            }
        }
    }

    @Override
    public void add(int index, E theElement) {
        if (index > size || index <= 0) {
            System.out.println("Index \"" + index + "\" out of list!");
        } else {
            curr = head;
            Node<E> temp = new Node<>(theElement);
            for (int i = 0; i < index - 1; i ++, curr = curr.getNext());
            curr.getNext().setPrevious(temp);
            temp.setPrevious(curr);
            temp.setNext(curr.getNext());
            curr.setNext(temp);
            size ++;
        }
    }

    @Override
    public void add(E element) {
        Node<E> temp = new Node<>(element);
        tail.setNext(temp);
        temp.setPrevious(tail);
        tail = temp;
        size ++;
    }

    @Override
    public void printList() {
        curr = head;
        if (curr.getNext() == null) {
            System.out.println("The list is empty!");
        } else {
            curr = head.getNext();
            for (int i = 0; i < size; i++, curr = curr.getNext()) {
                if (i > 0) {
                    System.out.print(", ");
                }
                System.out.print("Node" + (i + 1) + "{" + curr.getData() + "}");
            }
            System.out.println();
        }
    }

    @Override
    public E getFirst() {
        if (head.getNext() == null) {
            System.out.println("The first data is null!");
            return null;
        } else {
            return head.getNext().getData();
        }
    }

    @Override
    public E getLast() {
        if (tail.getData() == null) {
            System.out.println("The last data is null!");
            return null;
        } else {
            return tail.getData();
        }
    }//当前链表节点数

}

 

 

 

 

 

农夫过河ver.5

 

 

 一见到这张类图，想必大家都与我一样感觉头皮发麻。但事实上，我大约用了2小时便实现了代码的迭代与调试，下面我便来与大家说说我的设计思路。

一眼望去，不难发现这张类图中共有4个抽象类，分别为AbstractGame、MaterialObject、AbstractTransport和AbstractRule，这四个类和它们的子类几乎占据了类图的所有内容。射人先射马，擒贼先擒王，我们便从这4个类的子类开始着手设计。

首先是MaterialObject类，子类分别为Animal、Person和Plant；根据类图中的信息，MaterialObject拥有3个私有属性：type、place、isExist，其中type用于记录人为赋予的实体的种类名，如“羊”、“狼”等，place用于记录实体当前的位置，isExist用于记录实体的存活状态；同时MarterialObject还拥有3个方法，分别是用于更改存活状态的diedOut()、用于获取存活状态的isExist()和用于展示实体当前状态的showStatus()。在了解上述信息以后，我们便可以开始着手子类的设计。关于Animal类，它有一个私有属性recipe（食谱），和4个主要方法：eat()（吃掉其他实体）、addedToRecipe()（将实体添加至食谱）、isFood()（判断实体是否在自己的食谱中）和canBeEat()（判断实体能否被自己吃到）。前三个方法并没有什么难度，要注意的只有canBeEat()，所谓判断实体能否被吃掉，其实就是判断是否该实体与自己在河的同一侧且农夫不在场，如果是则返回true，反之返回false。由于农夫和植物均不会吃其它生物，故不需要设置上述属性。

然后是AbstractTransport类。其子类Boat拥有board()（载货上船）和disembark()(卸货下船)两个方法，实现方式便示将实体加入到父类的容器goodses（货物）中和将实体从中移除，另外需注意的是当向船上装货时，船的capacity（容量）也应当相应的减少，同时每次装货都应当检测货物与船是否在同一个地方以及船是否有足够的容量。至于crossRiver的实现方法便是改变船和所有货物的位置。

以下是我的powerDesigner类图及源码。

 

 

 

农夫过河ver.5

import java.util.ArrayList;
import java.util.Scanner;
import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        Game game = new Game();
        game.play();    
    }
    
}


abstract class MaterialObject {

    private String type;
    private String place;
    private boolean crossed = false;
    private boolean isExist = false; 
    
    public MaterialObject() {
        
    }
    
    public void diedOut() {
        isExist = true;
    }
    
    public boolean isExist() {
        return isExist;
    }
    
    public void showStatus() {
        System.out.println(type + " is alive\t:" + (!isExist) + "\t"+ type + " has cross\t:" + crossed);
    }

    @Override
    public boolean equals(Object obj) {
        MaterialObject m = (MaterialObject) obj;
        if (m.type.equals(type)) {
            return true;
        } else {
            return false;
        }
    }

    public String getType() {
        return type;
    }

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

    public String getPlace() {
        return place;
    }

    public void setPlace(String place) {
        this.place = place;
    }

    public boolean isCrossed() {
        return crossed;
    }

    public void setCrossed(boolean crossed) {
        this.crossed = crossed;
    }

    public void setExist(boolean isExist) {
        this.isExist = isExist;
    }

}


class Animal extends MaterialObject {

    private HashSet<MaterialObject> recipe;
    
    public Animal(String type) {
        super.setType(type);
        recipe = new HashSet<>();
    }
    
    public boolean eat(MaterialObject m) {
        m.diedOut();
        return true;
    }
    
    public void addedToRecipe(MaterialObject m) {
        recipe.add(m);
    }

    public boolean isFood(MaterialObject m) {
        for (MaterialObject each:recipe) {
            if (each.equals(m)) {
                return true;
            }
        }
        return false;
    }
    
    public boolean canBeEat(MaterialObject m) {
        if (isFood(m) && (super.isCrossed() == m.isCrossed()) && GameData.farmer.isCrossed() != isCrossed()) {
            return true;
        } else {
            return false;
        }
    }
    
}


class Person extends MaterialObject {
    
    public Person(String type) {
        super.setType(type);
    }
    
}


class Plant extends MaterialObject {
    
    public Plant(String type) {
        super.setType(type);
    }
    
}


abstract class AbstracTransport {

    private String place;
    private int capacity;
    private boolean crossed;
    private ArrayList<MaterialObject> goodses = new ArrayList<>();
    
    public AbstracTransport() {
        
    }
    
    public void moveTo(String destination) {
        place = destination;
        for (MaterialObject each:goodses) {
            each.setPlace(destination);
        }
    }

    public String getPlace() {
        return place;
    }

    public void setPlace(String place) {
        this.place = place;
    }

    public int getCapacity() {
        return capacity;
    }

    public void setCapacity(int capacity) {
        this.capacity = capacity;
    }

    public ArrayList<MaterialObject> getGoodses() {
        return goodses;
    }

    public void setGoodses(ArrayList<MaterialObject> goodses) {
        this.goodses = goodses;
    }

    public boolean isCrossed() {
        return crossed;
    }

    public void setCrossed(boolean crossed) {
        this.crossed = crossed;
    }
    
}


class Boat extends AbstracTransport {

    public Boat(int capacity) {
        super.setCapacity(capacity);
    }

    public void crossRiver() {
        GameData.farmer.setCrossed(!GameData.farmer.isCrossed());
        super.setCrossed(!super.isCrossed());
        for (MaterialObject each:super.getGoodses()) {
            each.setCrossed(!each.isCrossed());
        }
    }
    
    public void board(MaterialObject m) {
        if (super.isCrossed() == m.isCrossed()) {
            if (super.getCapacity() > 0) {
                super.getGoodses().add(m);
                super.setCapacity(super.getCapacity() - 1);
            } else {
                System.out.println("The boat is full!");
            }
        } else {
            System.out.println("The " + m.getType() + " and the boat are not on the same side!");
        }
        
    }
    
    public void disembark(MaterialObject m) {
        if (!super.getGoodses().remove(m)) {
            System.out.println("The " + m.getType() + " is not on the boat");
        }
        super.setCapacity(super.getCapacity() + 1);
    }
    
}


abstract class AbstractRule {

    public AbstractRule() {
        // TODO Auto-generated constructor stub
    }
    
    public abstract boolean judge();

}


class GameSuccessRule extends AbstractRule{
    
    private CrossRiverRule crossRiverRule;
    private ObjectExistRule objectExistRule;

    public GameSuccessRule(CrossRiverRule crossRiverRule, ObjectExistRule objectExistRule) {
        super();
        this.crossRiverRule = crossRiverRule;
        this.objectExistRule = objectExistRule;
    }

    @Override
    public boolean judge() {
        return !objectExistRule.judge() && crossRiverRule.judge();
    }

}


class GameOverRule extends AbstractRule{

    private ObjectExistRule objectExistRule;

    public GameOverRule(ObjectExistRule objectExistRule) {
        super();
        this.objectExistRule = objectExistRule;
    }

    @Override
    public boolean judge() {
        return objectExistRule.judge();
    }

}


class ObjectExistRule extends AbstractRule{

    private GameData gameData;
    
    public ObjectExistRule(GameData gameData) {
        this.gameData = gameData;
    }

    @Override
    public boolean judge() {
        for (MaterialObject each:gameData.getObjects()) {
            if (each.isExist()) {
                return true;
            }
        }
        return false;
    }

}


class CrossRiverRule extends AbstractRule{

    private GameData gameData;
    
    public CrossRiverRule(GameData gameData) {
        this.gameData = gameData;
    }

    @Override
    public boolean judge() {
        for (MaterialObject each:gameData.getObjects()) {
            if (!each.isCrossed()) {
                return false;
            }
        }
        return true;
    }
    
    public boolean hasCross(MaterialObject m) {
        return m.isCrossed();
    }

    public GameData getGameData() {
        return gameData;
    }

    public void setGameData(GameData gameData) {
        this.gameData = gameData;
    }

}


class GameUI {

    public void menu() {
        /* 显示菜单 */
        System.out.println("==================Please choose operation============");
        System.out.println("\t==========1:Cross the river alone===========");
        System.out.println("\t==========2:Cross the river with wolf=========");
        System.out.println("\t==========3:Cross the river with sheep============");
        System.out.println("\t==========4:Cross the river with cabbage==========");
        System.out.println("\t==========0:Quit===============");   
        System.out.println("===================================================");
        System.out.println("Input the number(0~4):");
    }    

    public void showStatus(GameData gameData) {
        for (MaterialObject each:gameData.getObjects()) {
            each.showStatus();
        }
    }

}


class GameData {
    
    public static Person farmer = new Person("farmer");
    
    private Animal wolf;
    private Animal sheep;
    private Plant cabbage;
    private Boat boat;
    private ArrayList<MaterialObject> objects;
    
    public GameData() {
        wolf = new Animal("wolf");
        sheep = new Animal("sheep");
        cabbage = new Plant("cabbage");
        boat = new Boat(1);
        
        wolf.addedToRecipe(sheep);
        sheep.addedToRecipe(cabbage);
        objects = new ArrayList<>() {
            {
                add(wolf);
                add(sheep);
                add(cabbage);
                add(farmer);
            }
        };
    }

    public Animal getWolf() {
        return wolf;
    }

    public void setWolf(Animal wolf) {
        this.wolf = wolf;
    }

    public Animal getSheep() {
        return sheep;
    }

    public void setSheep(Animal sheep) {
        this.sheep = sheep;
    }

    public Plant getCabbage() {
        return cabbage;
    }

    public void setCabbage(Plant cabbage) {
        this.cabbage = cabbage;
    }

    public Boat getBoat() {
        return boat;
    }

    public void setBoat(Boat boat) {
        this.boat = boat;
    }

    public ArrayList<MaterialObject> getObjects() {
        return objects;
    }

    public void setObjects(ArrayList<MaterialObject> objects) {
        this.objects = objects;
    }

}


abstract class AbstractGame {

    private AbstractRule gameOverRule;
    private AbstractRule gameSuccesRule;
    private GameData gameData;
    
    public AbstractGame() {
        // TODO Auto-generated constructor stub
    }
    
    public abstract void play();

    public AbstractRule getGameOverRule() {
        return gameOverRule;
    }

    public void setGameOverRule(AbstractRule gameOverRule) {
        this.gameOverRule = gameOverRule;
    }

    public AbstractRule getGameSuccesRule() {
        return gameSuccesRule;
    }

    public void setGameSuccesRule(AbstractRule gameSuccesRule) {
        this.gameSuccesRule = gameSuccesRule;
    }

    public GameData getGameData() {
        return gameData;
    }

    public void setGameData(GameData gameDate) {
        this.gameData = gameDate;
    }

}


class Game extends AbstractGame{
    
    private GameUI gui;
    
    public Game() {
        gui = new GameUI();
        super.setGameData(new GameData());
        super.setGameOverRule(new GameOverRule(new ObjectExistRule(super.getGameData())));
        super.setGameSuccesRule(new GameSuccessRule(new CrossRiverRule(super.getGameData()), new ObjectExistRule(super.getGameData())));
    }
    
    public void play() {
        
        Scanner input = new Scanner(System.in);
        while(!super.getGameOverRule().judge()) {
            gui.menu();
            char choice = input.next().charAt(0);//用户输入选择
            switch(choice) {
                case '0': 
                    System.out.println("game over!");
                    break;
                case '1':/* 农夫独自过河的处理 */
                    super.getGameData().getBoat().crossRiver();
                    break;
                case '2':/* 农夫带狼的处理 */
                    super.getGameData().getBoat().board(super.getGameData().getWolf());
                    super.getGameData().getBoat().crossRiver();
                    super.getGameData().getBoat().disembark(super.getGameData().getWolf());
                    break;
                case '3':/* 农夫带羊的处理 */
                    super.getGameData().getBoat().board(super.getGameData().getSheep());
                    super.getGameData().getBoat().crossRiver();
                    super.getGameData().getBoat().disembark(super.getGameData().getSheep());
                    break;
                case '4':/* 农夫带白菜的处理 */
                    super.getGameData().getBoat().board(super.getGameData().getCabbage());
                    super.getGameData().getBoat().crossRiver();
                    super.getGameData().getBoat().disembark(super.getGameData().getCabbage());
                    break;
                default:
                    System.out.println("This command is no found!");
            }
            if (super.getGameData().getSheep().canBeEat(super.getGameData().getCabbage())) {
                super.getGameData().getSheep().eat(super.getGameData().getCabbage());
            }
            if (super.getGameData().getWolf().canBeEat(super.getGameData().getSheep())) {
                super.getGameData().getWolf().eat(super.getGameData().getSheep());
            }
            gui.showStatus(super.getGameData());
            if (super.getGameSuccesRule().judge()) {
                System.out.println("game over: you win !");
                break;
            } else if (super.getGameOverRule().judge()) {
                System.out.println("game over: you lose !");
                break;
            }
        }
        input.close();

    }
    
}

 

 

总结：

经过这四周的学习，我已经熟练掌握了继承与多态、对象容器等的用法，并对Java类设计有了一定的认识和见解。关于近几周的学习情况，或许是封校使我懈怠了许多，对此我还需要进一步端正学习态度。以上便是本篇博客的全部内容，感谢阅读。