JAVA博客作业（三）

一、前言

　　（1）涉及知识点

　　　　　　①abstract抽象类的设计

　　　　　　②接口的使用方法

　　　　　　③comparable类、comparator类、ArrayList arr=new ArrayList();的使用

　　　　　　④加强for循环的使用

　　（2）题量评估

　　　　　　题集7：一般

　　　　　　题集8：一般

　　　　　　题集9：一般

　　（3）难度评估

　　　　　　题集7：困难

　　　　　　题集8：困难

　　　　　　题集9：一般

二、设计与分析

　　（1）7-1 图形卡片排序游戏（一）&&7-2 图形卡片分组游戏（二）

 

Comparable接口

Comparable接口在JDK8中的源码：

 

package java.lang;
import java.util.*;

package java.lang;
public interface Comparable<T> {
    public int compareTo(T o);
}

int compareTo(T o)

比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

Comparator类
当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用Comparator的对象来排序，强行对多个对象进行整体排序的比较。

重写compare(Object o1,Object o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大o2；如果返回0，表示相等；返回负整数，表示o1小于o2。

可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制。

还可以使用 Comparator 来控制某些数据结构（如有序 set或有序映射）的顺序，或者为那些没有自然顺序的对象 collection 提供排序。

ArrayList＜Integer＞的使用：

1.添加元素

ArrayList<Integer> list= new ArrayList<Integer>();
list.add(1);
list.add(54);

2.最大最小值————— Collections.max(list),mina = Collections.min(list);

3.拷贝

ArrayList<Integer> list2 = new ArrayList<Integer>();

list2.addAll(list);

4.排序

Collections.sort(list);

5.倒序

Collections.reverse(list);

6.求的某元素首次出现位置

int i = list.indexOf(23);//list中23元素首次出现的位置

8.求和

int sum = 0;
for (int i=0;i<list2.size();i++){
    sum += list2.get(i);
}
System.out.println("list2 sum is "+sum);


//利用stream求和
List<Integer> ls = new ArrayList<Integer>();
ls.add(43);
ls.add(27);
int sum2 = ls.stream().mapToInt(a->a).sum();
System.out.println("sum is "+sum2);

设计思路

设计图形抽象类，使其他图形可以继承共同特点，又可对不同之处进行重写：

abstract class Shape{//图形抽象类
    private String type;
    Shape(){}
    Shape(String type){//构造图形
        this.type = type;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public abstract double getArea();//抽象方法——获得面积
    public abstract boolean validate();//抽象方法——获得判断
    @Override
    public String toString() {//返回结果
        return this.type;
    }
}

设计具体图形类,并继承图形类

class Circle extends Shape {
    private double r;
    private double area;
    Circle(){}
    Circle(double radius){
        this.r = radius;
    }
    public double getR() {
        return r;
    }
    public void setR(double r) {
        this.r = r;
    }
    @Override
    public double getArea() {
        this.area = r*r*Math.PI;
        return area;
    }
    @Override
    public boolean validate() {
        if (r>0){
            return true;
        }
        else return false;
    }
}
class Rectangle extends Shape {//长方形
    private double length;
    private double width;
    private double area;
    Rectangle(){}
    Rectangle(double l,double w){
        this.length = l;
        this.width = w;
    }
    public void setWidth(double width) {
        this.width = width;
    }
    public void setLength(double length) {
        this.length = length;
    }
    public double getLength() {
        return length;
    }
    public double getWidth() {
        return width;
    }

    @Override
    public double getArea() {
        this.area = this.length*this.width;
        return this.area;
    }
    @Override
    public boolean validate() {
        if (length>0&&width>0){
            return true;
        }
        else return false;
    }
}
class Triangle extends Shape {//三角形
    private double a;
    private double b;
    private double c;
    Triangle(){}
    Triangle(double l1,double l2,double l3){
        this.a = l1;
        this.b = l2;
        this.c = l3;
    }
    @Override
    public double getArea() {
        double p = 0.5*(a+b+c);
        double area = p*(p-a)*(p-b)*(p-c);
        return Math.pow(area,0.5);
    }

    @Override
    public boolean validate() {
        if (a>0&&b>0&&c>0&&(a+b>c&&a+c>b&&b+c>a)){
            return true;
        }else {
            return false;
        }
    }
}
class Trapezoid extends Shape {//梯形
    double h;
    double hl;
    double dl;
    Trapezoid(){}
    Trapezoid(double hl,double dl,double h){
        this.hl = hl;
        this.dl = dl;
        this.h = h;
    }
    @Override
    public double getArea() {
        double area = (hl+dl)*h*0.5;
        return area;
    }
    @Override
    public boolean validate() {
        if (hl>0&&dl>0&&h>0){
            return true;
        }else
            return false;
    }
}

创建一个新的类，继承comparable类，用来进行图形的比较：

class C implements Comparable<C>{//创建接口（implement） 继承comparable类，重写比较方法
    private Shape shape;
    public C(){}
    public C(Shape shape){
        this.shape = shape;
    }
    public void setShape(Shape shape) {
        this.shape = shape;
    }

    public Shape getShape() {
        return shape;
    }

    @Override
    public int compareTo(C card) {
        return -(int)(shape.getArea()-card.getShape().getArea());
    }
}

设计一个类专门负责对输入制的处理，通过调用这个类的创建方法来判断应该创建什么类型的卡片，完成对象的建造，并在这个类中设计相应的值得判断、整体排序、整体面积输出等游戏功能

class DealCardList{
    ArrayList<C> cardList =new ArrayList<>();
    DealCardList(){}
    DealCardList(ArrayList<Integer> list){
        for(Integer card:list){//便利list数组，将其存入card中
            switch (card){//将图形存入cardlist
                case 1://圆形
                    double r = work7_1.Game.input.nextDouble();
                    C card1 = new C(new Circle(r));
                    card1.getShape().setType("Circle");
                    cardList.add(card1);
                    break;
                case 2://矩形
                    double h = work7_1.Game.input.nextDouble();
                    double w = work7_1.Game.input.nextDouble();
                    C card2 = new C(new Rectangle(h,w));
                    card2.getShape().setType("Rectangle");
                    cardList.add(card2);
                    break;
                case 3://三角形
                    double a = work7_1.Game.input.nextDouble();
                    double b = work7_1.Game.input.nextDouble();
                    double c = work7_1.Game.input.nextDouble();
                    C card3 = new C(new Triangle(a,b,c));
                    card3.getShape().setType("Triangle");
                    cardList.add(card3);
                    break;
                case 4://梯形
                    double hl = work7_1.Game.input.nextDouble();
                    double dl = work7_1.Game.input.nextDouble();
                    double l = work7_1.Game.input.nextDouble();
                    C card4 = new C(new Trapezoid(hl,dl,l));
                    card4.getShape().setType("Trapezoid");
                    cardList.add(card4);
                    break;
            }

        }
    }
    public boolean validate(){//有效性
        for(C card:cardList){
            if (!card.getShape().validate()){
                return false;
            }
        }
        return true;
    }
    public void cardSort(){//做排序
        TreeSet<C> cards = new TreeSet<>(cardList);
        for (C card : cards) {
            System.out.print(card.getShape()+":");
            System.out.printf("%.2f ",card.getShape().getArea());
        }
    }
    public double getAllArea(){
        double sum = 0;
        for (C card : cardList){
            sum+=card.getShape().getArea();
        }
        return sum;
    }
    public void showResult(){
        System.out.println("The original list:");//大家的面积
        for (C card : cardList){
            System.out.print(card.getShape()+":");
            System.out.printf("%.2f ",card.getShape().getArea());
        }
        System.out.println();
        System.out.println("The sorted list:");//排序后的面积
        cardSort();
        System.out.println();
        System.out.printf("Sum of area:%.2f",getAllArea());//要用printf才能使用%.2f
    }
}

 在主函数中首先创建ArrayList<Integer> list = new ArrayList<Integer>();用于输入数据的存放，然后进行输入的数据校验，第一次校验合格后在进行下一步卡片的创建。在卡片创建时再对输入的各个参数进行校验，当一切校验完成后再进行相应数值的计算并输出

 

　　（2）7-3 ATM机类结构设计（一）&&7-1 ATM机类结构设计（二）

 设计思路

设计银行（Bank类），带有银行姓名，ATM列表

设计用户类（Account类），带有用户、账户、密码、金额数。用于虚拟构建一个用户

设计存款机（ATM类）完成对ATM机功能的实现，可进行卡号校验、金额校验、操作校验、余额查询等功能的实现

class Bank{
    String bankname;
    ArrayList<String> AList;
    public Bank(){
    }
    public Bank(String name,ArrayList<String> ATM){
        this.bankname = name;
        this.AList = ATM;
    }
    public void setAList(ArrayList<String> AList) {
        this.AList = AList;
    }

    public void setBankname(String bankname) {
        this.bankname = bankname;
    }

    public String getBankname() {
        return bankname;
    }

    public ArrayList<String> getAList() {
        return AList;
    }

}
class Account{
    private String Uname;//用户
    private String account;//账户
    private String password;//账户密码
    private double money;
    ArrayList<String> cardList = new ArrayList<>();
    public Account(){
    }
    public Account(String name,String account,String password,double money,ArrayList<String> cardList){
        this.account = account;
        this.Uname = name;
        this.password = password;
        this.cardList = cardList;
        this.money = money;
    }

    public ArrayList<String> getCardList() {
        return cardList;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public String getAccount() {
        return account;
    }

    public String getUname() {
        return Uname;
    }

    public String getPassword() {
        return password;
    }
}
class ATM{

    ArrayList<Account> accountList;
    ArrayList<Bank> atmList;
    String card;
    String password;
    String Ano;
    double money;
    boolean check = false;
    int location = 0;
    int Blocation = 0;
    public ATM(ArrayList<Account> accountList,ArrayList<Bank> ATMList,String card,String password,String no,double money){//更改内容构造向ATM存入数据
        this.Ano = no;
        this.accountList = accountList;
        this.money = money;
        this.card = card;
        this.password = password;
        this.atmList = ATMList;
    }
    public ATM(ArrayList<Account> accountList,String card){//查看金额构造
        this.accountList = accountList;
        this.card = card;
    }

    public void setAno(String ano) {
        Ano = ano;
    }

    public String getAno() {
        return Ano;
    }
    public void CheckATMno(){//ATM编号校验
        int i;
        int j;
        int flag = 0;
        for(i = 0;i<atmList.size();i++){
            for (j=0;j<atmList.get(i).getAList().size();j++){
                if (Ano.equals(atmList.get(i).getAList().get(j))){
                    flag = 1;
                    Blocation = i;
                    break;
                }
            }
            if (flag == 1){
                break;
            }
        }
        if (flag==0){//没找到
            System.out.println("Sorry,the ATM's id is wrong.");
            check = false;
        }
    }
    public void CheckUser(){//用户校验（卡号存在性）
        int i;
        int j;
        for (i=0;i<accountList.size();i++){//账号是否存在
            for (j = 0;j<accountList.get(i).getCardList().size();j++) {
                if (card.equals(accountList.get(i).getCardList().get(j))) {
                    check = true;
                    this.location = i;
                    break;
                }
            }
            if (check == true){
                break;
            }
        }if(check == false) {//没找到卡号
            System.out.println("Sorry,this card does not exist.");
        }
    }
    public void CheckKey() {//密码校验
        if (check == true) {
            if (!password.equals(accountList.get(location).getPassword())) {//密码错误
                System.out.println("Sorry,your password is wrong.");
                check = false;
            }
        }
    }
    public boolean CheckMoney(){//金额校验
        if (money>0&&(accountList.get(location).getMoney()-money)<0){
            System.out.println("Sorry,your account balance is insufficient.");
            return false;
        }else return true;
    }
    public void UserChange(){//用户操作
        double exMoney = accountList.get(location).getMoney()-money;
        accountList.get(location).setMoney(exMoney);
    }
    public void moneyCheck(){//金额查询
        System.out.printf("¥%.2f\n",accountList.get(location).getMoney());
    }
    public void CheckCrossBank(){//跨行校验，05、06号机器——中国工商

    }
    public void menu(){
        if(money<0) {
            System.out.printf(accountList.get(location).getUname() + "在" + atmList.get(Blocation).getBankname() + "的" + Ano + "号ATM机上存款¥%.2f\n",Math.abs(money));
        }else {
            System.out.printf(accountList.get(location).getUname() + "在" + atmList.get(Blocation).getBankname() + "的" + Ano + "号ATM机上取款¥%.2f\n",money);
        }
        System.out.printf("当前余额为¥%.2f\n",accountList.get(location).getMoney());
    }
}

主函数部分：

首先要进行数据的存储。运用ArrayList<String>a= new ArrayList<>()的功能，完成如ATM机号列表、卡号账户列表的创建。再使用ArrayList<类>= new ArrayList<>()，将其中的类替换为银行类/用户类，即可再创建出相应的类列表，作为数据库，方便后期的查找校验。

 

 功能部分，首先对输入进行判断，再调用ATM相关校验函数完成用户相应操作

Scanner scanner = new Scanner(System.in);
        String uinput;
        uinput = scanner.nextLine();
        while (!uinput.equals("#")){
            String[] user=uinput.split("\\s+");
            if (user.length==1){//只查看存款
                ATM atm1 = new ATM(Account,user[0]);
                atm1.CheckUser();
                atm1.moneyCheck();
            }else if (user.length!=1){//
                ATM atm2 = new ATM(Account,ATMList,user[0],user[1],user[2],Double.parseDouble(user[3]));
                atm2.CheckUser();//检验账户存在问题
                atm2.CheckKey();//检验密码
                atm2.CheckATMno();//校验ATM编号是否存在
                if (atm2.check == true) {//卡号存在、密码正确、ATM编号正确——进行存取操作
                    if (atm2.CheckMoney()==true){//钱数充足
                        atm2.UserChange();
                        atm2.menu();
                    }
                }

            }
            uinput = scanner.nextLine();
        }

 第二次ATM实验在原有基础上进行改动，相对简单不少，基于原有的类形式仅增加了税率属性设置，更改了菜单的样式。在本次作业中修补了原先无法实现跨行检测的bug。

增添功能：

①透支操作

public boolean TzChange(){//透支操作
        double tMoney = Math.abs(money-accountList.get(location).getMoney());
        double sxMoney = 0;
        if (tMoney<50000) {//可以透支
            if (accountList.get(location).getMoney()<=0){//没有余额
                sxMoney=money*tCharge;
            }else {//有余额
                sxMoney=tMoney*tCharge;
            }
            accountList.get(location).setMoney(-(tMoney+sxMoney+cCharge));
            return true;
        }else {//违规透支
            return false;
        }
    }

②税率设置

public Bank(String name,ArrayList<String> ATM,double charge){
        this.bankname = name;
        this.AList = ATM;
        this.charge = charge;//新增税率设置
    }

三、踩坑心得

　　①起初不了解ArrayList＜＞类、加强for循环的使用环境与方法的很多功能，在实际项目中使用后发现是真的好用

　　②类的设计不够好，部分功能没有进行准确的封装，比如在写ATM管理的题目时，基本对原先的功能如金额校验等进行了重写。

四、改进建议

　　①ATM机的题还应该再次对ATM类进行修改，，目前的功能实现都是由主函数直接调用ATM中的功能。应该争取将主函数中的判断部分都交由ATM实行，仅在主函数中仅构造出一个ATM就可以完成全部工作。

五、总结

　　这三次作业的题量整体是不多的，难得主要是对所有学过的知识的综合运用，很多时候编程都存在着拿不准应该使用什么结构，运用什么类更合适的问题，大部分的作业还需要去借鉴CSDN上的思路才完成。个人独立编写程序的能力还有很大的提升空间。在试验时也发现自己对于虚拟类的使用以及各种继承、重写、接口的使用方法都不是很了解，还需要在这些方面进行提升，