一、实验目的及要求
- 将你在实验3中设计的模拟堆栈程序，封装成一个类（注意访问控制的运用、getter和setter的运用、构造方法的设计等），并用这个堆栈类重写中缀表达式转换成后缀表达式程序。（体会封装）
- 设计一个时间类MyDate：（日期均大于1900年） a、 其中包括年、月、日、时、分、秒。其他成员变量可根据需要增设；
b、 可以直接获得时间的年、月、日、小时、分钟、秒数；(public修饰) c、 计算日期的dayOfWeek（星期几）；
d、 //实现日期加减一个整数后得到新的日期（加减天数）； e、 输入任意一个月份，将此月的日历输出（按星期格式）；
f、 输入任意年份，将此年的年历输出； g、 //实现两个时间相减得到的小时数、分钟数和秒数；
h、 输出时间，要求三种格式： yyyy年MM月dd日hh小时mm分ss秒；（Chinese） yyyy-MM-dd
hh:mm:ss（European） yyyyMMddhhmmss（compact）
i、 设计三个构造方法：1、参数只有年月日的构造方法，小时分钟秒设为0；2、完全参数的构造方法；3、如果使用无参数的构造方法则初始化为系统时间，系统时间的获得方法：
SimpleDateFormat myDateFormat =new
SimpleDateFormat(“yyyyMMddHHmmss”); java.util.Date date0=new
java.util.Date(); strDate=myDateFormat.format(date0);
strDate中就是有"yyyyMMddHHmmss"时间格式的字符串，从中可以取到各段时间数据（程序源代码的最开始要加import
java.text.SimpleDateFormat;） j、 MyDate的使用： 用无参数构造方法创建实例，然后按三种方法输出时间；
用年月日参数构造方法创建实例，时间为2008年8月8日0点0分0秒；并用三种方法输出时间
用全参数构造方法创建实例，时间为2008年8月8日20点0分0秒，并用三种方法输出
//将两个时间相减，计算差值共多少小时数、或者分钟数、或者秒数，输出 输入2011,4，输出月历； 输入2011，输出年历；
k、 注意理解构造方法重载。 l、 不要直接使用Java提供的Date类，那样就达不到练习的效果了。 - 设计一个字符串链表节点类：
a) 其中包括两个成员变量：Value（String类型）和下一个节点nextNode，方法有：setValue()，getValue()和display();
b) 用此类生成一个循环链表来解决斗地主发牌的问题 c) 注意观察：类引用的使用、浅复制和类中对类自身的引用。 - 设计一个用于管理银行客户的类BankCustomer：
仅描述客户的几个重要方面：帐号、身份证号、姓名、联系方式、密码、账户余额。所有的成员变量均用private访问控制，因此每一个成员变量就要有相应的存取器（getter和setter，即获取和设置其值的相应的成员方法。需要setter还是getter，还是两者都要，视情况而定）
成员方法：
开户（开户时必须要有身份证号），系统自动生成帐号，帐号使用系统时间（格式："yyyyMMddHHmmss"14位），初始密码为“666666”。注意开户和构造方法之间的关系。
存钱、取钱、显示账户信息、修改密码（密码最短要六位）
怎样在main中使用这个类，自行安排，要表现出你设计的类的各个方面，并在main中用英语加以注释
二、实验设备（环境）
三、实验内容与步骤
- 栈类
public class InfixToPostfix
{
public static void main(String[] args)
{
infixToPostfix("3*(2*3-4*1+(3*5)/3)*3+2");
infixToPostfix("2*(9+6/3-5)+4");
System.out.println();
// TODO Auto-generated method stub
}
static void infixToPostfix(String str)
{
Stack myStack=new Stack(50);
boolean flag=true;
StringBuffer theResult=new StringBuffer();//作为可变字符串，方便后续添加元素
char value;
System.out.println("原中缀表达式为："+str);
for(int i=0;i<str.length();i++)
{
switch(str.charAt(i))
{
case ' ':
break;
case '(':
myStack.push('(');
break;
case ')':
while((value=myStack.pop())!= '(')
{
if(myStack.isEmpty()==true)
{
flag=false;
System.out.println("ERROR! 没有找到与右括号匹配的左括号 !ERROR");
return;
}
theResult.append(value);
}
break;
case '+':
if(myStack.isEmpty()==false)
{
value=myStack.showTop();
if(value=='*'||value=='/')
{
while(value=='*'||value=='/'||value=='-'||value== '+')
{
theResult.append(value);
myStack.pop();
if(myStack.isEmpty()==true)
{
break;
}
value=myStack.showTop();
}
}
else if(myStack.isEmpty()==false&&(value=='+'||value== '-'))
{
theResult.append(myStack.pop());
}
}
myStack.push('+');
break;
case '-':
if(myStack.isEmpty()==false)
{
value=myStack.showTop();
if(value=='*'||value=='/')
{
while(value=='*'||value=='/'||value=='-'||value=='+')
{
theResult.append(value);
myStack.pop();
if(myStack.isEmpty()==true)
{
break;
}
value=myStack.showTop();
}
}
else if(myStack.isEmpty()==false&&(value=='+'||value== '-'))
{
theResult.append(myStack.pop());
}
}
myStack.push('-');
break;
case '*':
while(myStack.isEmpty()==false&&(myStack.showTop()=='*'||myStack.showTop()=='/'))
{
theResult.append(myStack.pop());
}
myStack.push('*');
break;
case '/':
while(myStack.isEmpty()==false&&(myStack.showTop()=='*'||myStack.showTop()=='/'))
{
theResult.append(myStack.pop());
}
myStack.push('/');
break;
default:
theResult.append(str.charAt(i));//遇到其他符号直接输出
}
}
while(myStack.isEmpty()==false)
{
value=myStack.pop();
theResult.append(value);
if(value=='(')
{
System.out.println("ERROR! 没有找到与右括号匹配的左括号 !ERROR");
flag=false;
}
}
if(flag==true)
{
System.out.println("后缀表达式为："+theResult);
}
}
}
class Stack
{
public int stackSize;
private char[] myStack;
private int top;
public Stack(int size)
{
stackSize=size;
myStack=new char[stackSize];
top=-1;
}
public boolean push(char value)
{
if(isFull()==false)
{
myStack[++top]=value;
return true;
}
else
{
return false;
}
}
public char pop()
{
if(isEmpty()==false)
{
return myStack[top--];
}
return ' ';
}
public boolean isEmpty()
{
if(top==-1)
{
return true;
}
return false;
}
public boolean isFull()
{
if(top==stackSize-1)
{
return true;
}
return false;
}
public int length()
{
return top+1;
}
public char showTop()
{
if(isEmpty()==false)
{
return myStack[top];
}
else
{
return ' ';
}
}
}
import java.util.Scanner;
import java.text.SimpleDateFormat;
public class UseMyDate
{
public static void main(String[] args)
{
MyDate noArgument=new MyDate();
noArgument.display();//用无参数构造方法创建实例，然后按三种方法输出时间
noArgument.dayOfWeek(noArgument.getYear(),noArgument.getMonth(),noArgument.getDay());
MyDate dateOne=new MyDate(2008,8,8);
dateOne.display();//用年月日参数构造方法创建实例，时间为2008年8月8日0点0分0秒；并用三种方法输出时间
dateOne.dayOfWeek(dateOne.getYear(),dateOne.getMonth(),dateOne.getDay());
MyDate dateTwo=new MyDate(2008,8,8,20,0,0);
dateTwo.display();//用全参数构造方法创建实例，时间为2008年8月8日20点0分0秒，并用三种方法输出
dateTwo.dayOfWeek(dateTwo.getYear(),dateTwo.getMonth(),dateTwo.getDay());
noArgument.outputsTheCalendar(2011,4);//输入2011,4，输出月历
noArgument.outputsTheYearCalendar(2011);//输入2011，输出年历
Scanner scan=new Scanner(System.in);
System.out.println("计算时间差，请输入开始时间的小时：");
int hourOne=scan.nextInt();
System.out.println("请输入开始时间的分钟：");
int minuteOne=scan.nextInt();
System.out.println("请输入开始时间的秒：");
int secondOne=scan.nextInt();
MyDate aDate=new MyDate(2020,10,24,hourOne,minuteOne,secondOne);
System.out.println("请输入结束时间的小时：");
int hourTwo=scan.nextInt();
System.out.println("请输入结束时间的分钟：");
int minuteTwo=scan.nextInt();
System.out.println("请输入结束时间的秒：");
int secondTwo=scan.nextInt();
System.out.println("两个时间相差：");
aDate.subtract(hourTwo,minuteTwo,secondTwo);
// TODO Auto-generated method stub
}
}
class MyDate
{
private int year;
private int month;
private int day;
private int hour;
private int minute;
private int second;
MyDate(int year,int month,int day)//参数只有年月日的构造方法，小时分钟秒设为0
{
this.year=year;
this.month=month;
this.day=day;
hour=0;
minute=0;
second=0;
}
MyDate(int year,int month,int day,int hour,int minute,int second)//完全参数的构造方法
{
this(year,month,day);
this.hour=hour;
this.minute=minute;
this.second=second;
}
MyDate()//无参数的构造方法,初始化为系统时间
{
SimpleDateFormat myDateFormat =new SimpleDateFormat("yyyyMMddHHmmss");
java.util.Date date0=new java.util.Date();
String strDate=myDateFormat.format(date0);
year=Integer.parseInt(strDate.substring(0,4));
month=Integer.parseInt(strDate.substring(4,6));
day=Integer.parseInt(strDate.substring(6,8));
hour=Integer.parseInt(strDate.substring(8,10));
minute=Integer.parseInt(strDate.substring(10,12));
second=Integer.parseInt(strDate.substring(12,14));
}
public int getYear()//直接获得时间的年、月、日、小时、分钟、秒数
{
return year;
}
public int getMonth()
{
return month;
}
public int getDay()
{
return day;
}
public int getHour()
{
return hour;
}
public int getMinute()
{
return minute;
}
public int getSecond()
{
return second;
}
public void display()//输出时间，要求三种格式
{
System.out.println("Chinese:"+year+"年"+month+"月"+day+"日"+hour+"时"+minute+"分"+second+"秒");
System.out.println("European:"+year+"-"+month+"-"+day+" "+hour+":"+minute+":"+second);
System.out.println(String.format("%04d",year)+String.format("%02d",month)+String.format("%02d",day)+String.format("%02d",hour)+String.format("%02d",minute)+String.format("%02d",second));//将任意整数格式化成前面补“0”的4或者2位定长字符串
}
public void outputsTheCalendar(int year, int month)
{
int totalDays=0;
for(int i=1901;i<year;i++)//以1901.01.01为起点，以需求年份第一天为终点，计算天数总和（每一年都有12个月）
for(int j=1;j<=12;j++)
{
totalDays+=getTheNumberOfDaysInAMonth(i,j);
}
for(int j=1;j<month;j++)//再加上需求年份的天数（不一定满12个月）,此时天数为需求月份的第一天
totalDays+=getTheNumberOfDaysInAMonth(year,j);
int week=getTheWeekOfTheDays(totalDays);//得到需求月份第一天的星期
int days=getTheNumberOfDaysInAMonth(year,month);//得到需求月份的天数
System.out.println(" "+year+"年"+month+"月");
System.out.println("-----------------------------");
System.out.println(" 日 一 二 三 四 五 六");
for(int i=0;i<week%7;i++)
System.out.print(" ");//打印1号以前的空格
for(int i=1;i<=days;i++)
{
System.out.print(String.format("%1$ 4d",i));
if((i+week)%7==0)
System.out.println();
}
System.out.println();
}
public void outputsTheYearCalendar(int year)
{
for(int i=1;i<=12;i++)
{
outputsTheCalendar(year,i);
}
}
public int getTheNumberOfDaysInAMonth(int year, int month)
{
int daysOfTheMonth=0;
switch(month)
{
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
daysOfTheMonth=31;
break;
case 4:
case 6:
case 9:
case 11:
daysOfTheMonth=30;
break;
case 2:
if(((year%4==0)&&!(year%100==0))||(year%400==0))
{
daysOfTheMonth=29;
}
else
daysOfTheMonth=28;
break;
}
return daysOfTheMonth;
}
public int getTheWeekOfTheDays(int totalDays)
{
int week[]={1,2,3,4,5,6,7};
int getTheWeek=week[(totalDays+1)%7];//已知1901.01.01为星期二
return getTheWeek;
}
public void dayOfWeek(int year,int month,int day)//计算日期的dayOfWeek（星期几）
{
int totalDays=0;
for(int i=1901;i<year;i++)//以1901.01.01为起点，以需求年份第一天为终点，计算天数总和（每一年都有12个月）
for(int j=1;j<=12;j++)
{
totalDays+=getTheNumberOfDaysInAMonth(i,j);
}
for(int j=1;j<month;j++)//再加上需求年份的天数（不一定满12个月）,此时天数为需求月份的第一天
totalDays+=getTheNumberOfDaysInAMonth(year,j);
for(int k=1;k<day;k++)
{
totalDays+=1;
}
int myWeek=getTheWeekOfTheDays(totalDays);
switch(myWeek)
{
case 1:System.out.println("Today is Monday");
break;
case 2:System.out.println("Today is Tuesday");
break;
case 3:System.out.println("Today is Wednesday");
break;
case 4:System.out.println("Today is Thursday");
break;
case 5:System.out.println("Today is Friday");
break;
case 6:System.out.println("Today is Saturday");
break;
case 7:System.out.println("Today is Sunday");
break;
}
System.out.println();
}
public void subtract(int hourTwo,int minuteTwo,int secondTwo)
{
if(hour>hourTwo)
{
System.out.println("ERROR!无效时间!ERROR");
return;
}
int differenceHour,differenceMinute,differenceSecond;
int flag=0;
if(secondTwo<second)
{
flag=1;
differenceSecond=secondTwo+60-second;
}
else
{
differenceSecond=secondTwo-second;
}
if(flag==1)
{
minuteTwo--;
}
flag=0;
if(minuteTwo<minute)
{
flag=1;
differenceMinute=minuteTwo+60-minute;
}
else
{
differenceMinute=minuteTwo-minute;
}
if(flag==1)
{
hourTwo--;
}
differenceHour=hourTwo-hour;
System.out.println(String.format("%02d",differenceHour)+"时"+String.format("%02d",differenceMinute)+"分"+String.format("%02d",differenceSecond)+"秒");
}
- 链表斗地主发牌
public class Landlords
{
public static void main(String[] args)
{
setValue();
// TODO Auto-generated method stub
}
public static void setValue()
{
String[] valueArray={"A","2","3","4","5","6","7","8","9","T","J","Q","K"};
String[] suitArray={"红桃","梅花","方块","黑桃"};
Node firstCard=new Node("小王","");
Node pointer=firstCard;
pointer.nextNode=new Node("大王","");
pointer=pointer.nextNode;
for(int i=0;i<4;i++)
for(int j=0;j<13;j++)
{
pointer.nextNode=new Node(valueArray[j],suitArray[i]);
pointer=pointer.nextNode;//实现链表串联
}
pointer.nextNode=firstCard;//形成循环链表
deal(firstCard);
}
public static void deal(Node firstCard)
{
int count=0;
int random;
Node pointerSet=firstCard.nextNode;
Node last=firstCard;//last作为pointerDeal的直接前驱
Node dealCards=new Node();//new一个新的链表表头,该链表用于放乱序的新牌
Node pointerDeal=dealCards;//指向新链表的表头
for(int i=54;i>0;i--)
{
random=(int)(Math.random()*i);//第一次在0到53之间产生随机数，第二次在0到52之间，随着牌的发出依次递减
for(int j=0;j<random;j++)//通过循环次数的随机，实现随机指定链表中的一张牌
{
pointerSet=pointerSet.nextNode;
last=last.nextNode;
}
last.nextNode=pointerSet.nextNode;
dealCards.nextNode=pointerSet;
dealCards=dealCards.nextNode;
pointerSet=last.nextNode;//并把发出去的牌在旧的循环链表中删除
}
display(pointerDeal);
}
public static void display(Node pointerDeal)
{
for(int j=1;j<4;j++)
{
System.out.println("玩家"+j+"的牌：");
for(int i=0;i<17;i++)
{
pointerDeal.nextNode.getCard();
pointerDeal=pointerDeal.nextNode;
}
System.out.println();
}
System.out.println("三张底牌");
for(int i=0;i<3;i++)
{
pointerDeal.nextNode.getCard();
pointerDeal=pointerDeal.nextNode;
}
}
}
class Node
{
String value;
String suit;
public Node nextNode;
Node(){}
Node(String value,String suit)
{
this.value=value;
this.suit=suit;
}
public void getCard()
{
System.out.print(suit+value+' ');
}
}
4.银行客户类BankCustomer
import java.util.Scanner;
2. import java.text.SimpleDateFormat;
3.
4. public class Bank
5. {
6. public static void main(String[] args)
7. {
8. // TODO Auto-generated method stub
9. Scanner scan=new Scanner(System.in);
10. System.out.println("输入您的个人信息进行开户：1.请输入您的身份证号");
11. String ID=scan.next();
12. System.out.println("2.请输入您的姓名：");
13. String name=scan.next();
14. System.out.println("3.请输入您的联系电话：");
15. String contact=scan.next();
16. BankCustomer customer=new BankCustomer(ID,name,contact);
17. System.out.print("开户成功！"+'\n'+"初始密码为：666666"+'\n'+"请尽快修改密码");
18.
19. boolean flag=true;
20. while(flag)
21. {
22. menu();
23. int choice=scan.nextInt();
24. switch(choice)
25. {
26. case 1:
27. System.out.println("现在进行修改账户信息，请输入您的密码：");
28. String passwordOne=scan.next();
29. System.out.println("请输入您的新姓名：");
30. String newName=scan.next();
31. System.out.println("请输入您的新联系电话：");
32. String newContact=scan.next();
33. customer.changeAccountInformation(passwordOne, newName, newContact);
34. break;
35. case 2:
36. System.out.println("请输入你的密码：");
37. String passwordTwo=scan.next();
38. System.out.println("请输入存钱金额：");
39. Double depositMoney=scan.nextDouble();
40. customer.deposit(passwordTwo, depositMoney);
41. break;
42. case 3:
43. System.out.println("请输入你的密码：");
44. String passwordThree=scan.next();
45. System.out.println("请输入取钱金额：");
46. Double withdrawMoney=scan.nextDouble();
47. customer.withdraw(passwordThree, withdrawMoney);
48. break;
49. case 4:
50. System.out.println("现在进行显示账户信息，请输入您的密码：");
51. String passwordFour=scan.next();
52. customer.displayAccountInformation(passwordFour);
53. break;
54. case 5:
55. System.out.println("现在进行修改密码，请输入您的原密码：");
56. String oldPassword=scan.next();
57. System.out.println("请输入您的新密码：");
58. String newPassword=scan.next();
59. customer.changePassword(oldPassword, newPassword);
60. break;
61. case 6:
62. System.out.println("退出系统");
63. flag=false;
64. break;
65. default:
66. break;
67. }
68. }
69. }
70.
71. static void menu()
72. {
73. System.out.println();
74. System.out.println("请选择办理以下业务：");
75. System.out.print("1.修改账户信息(姓名、联系电话)"+'\n'+"2.存钱"+'\n'+"3.取钱"+'\n'+"4.显示账户信息"+'\n'+"5.修改密码"+'\n'+"6.退出");
76. System.out.println();
77. }
78. }
79.
80. class BankCustomer
81. {
82. private String account;
83. private String ID;
84. private String name;
85. private String contact;
86. private String password;
87. private double balance;
88.
89. public BankCustomer(String ID,String name,String contact)//开户
90. {
91. this.ID=ID;
92. this.name=name;
93. this.contact=contact;
94. password="666666";
95. SimpleDateFormat myDateFormat =new SimpleDateFormat("yyyyMMddHHmmss");
96. java.util.Date date0=new java.util.Date();
97. account=myDateFormat.format(date0);
98. balance=0;
99. }
100.
101. private boolean isPasswordCorrect(String password)
102. {
103. if(password.equals(this.password))
104. {
105. return true;
106. }
107. else
108. return false;
109. }
110.
111. public void changePassword(String oldPassword,String newPassword)
112. {
113. if(isPasswordCorrect(oldPassword))
114. {
115. if(newPassword.length()==6)
116. {
117. password=newPassword;
118. System.out.println("密码修改成功");
119. }
120. else
121. System.out.println("ERROR! 密码必须为6位数 !ERROR");
122. }
123. else
124. System.out.println("ERROR! 原密码错误 !ERROR");
125. }
126.
127. public void deposit(String password,double money)
128. {
129. if(isPasswordCorrect(password))
130. {
131. balance+=money;
132. System.out.println("存钱成功");
133. System.out.println("您的账户余额："+balance);
134. }
135. else
136. System.out.println("ERROR! 密码错误 !ERROR");
137. }
138.
139. public void withdraw(String password,double money)
140. {
141. if(isPasswordCorrect(password))
142. {
143. if(balance>=money)
144. {
145. balance-=money;
146. System.out.println("取钱成功");
147. System.out.println("您的账户余额："+balance);
148. }
149. else
150. System.out.println("余额不足");
151. System.out.println("您的账户余额："+balance);
152. }
153. else
154. System.out.println("ERROR! 密码错误 !ERROR");
155. }
156.
157. public void displayAccountInformation(String password)
158. {
159. if(isPasswordCorrect(password))
160. {
161. System.out.println("账号："+account);
162. System.out.println("身份证号："+ID);
163. System.out.println("姓名："+name);
164. System.out.println("联系电话："+contact);
165. System.out.println("余额："+balance);
166. }
167. else
168. System.out.println("ERROR! 密码错误 !ERROR");
169. }
170.
171. public void changeAccountInformation(String password,String newName,String newContact)
172. {
173. if(isPasswordCorrect(password))
174. {
175. name=newName;
176. contact=newContact;
177. System.out.println("账户信息修改成功");
178. }
179. else
180. System.out.println("ERROR! 密码错误 !ERROR");
181. }
182. }
}
四、实验结果与数据处理
-
栈类 原中缀表达式为：3*(23-41+(35)/3)3+2 后缀表达式为：32341-353/+32+ 原中缀表达式为：2(9+6/3-5)+4 后缀表达式为：2963/+5-*4+
-
时间类MyDate Chinese:2020年10月24日17时3分56秒 European:2020-10-24 17:3:56 20201024170356 Today is Saturday
Chinese:2008年8月8日0时0分0秒 European:2008-8-8 0:0:0 20080808000000 Today
is FridayChinese:2008年8月8日20时0分0秒 European:2008-8-8 20:0:0 20080808200000
Today is Friday2011年4月----------------------------- 日 一 二 三 四 五 六
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
302011年1月----------------------------- 日 一 二 三 四 五 六
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
30 31
2011年2月
----------------------------- 日 一 二 三 四 五 六
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
2011年3月
----------------------------- 日 一 二 三 四 五 六
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
2011年4月
----------------------------- 日 一 二 三 四 五 六
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 302011年5月----------------------------- 日 一 二 三 四 五 六 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
23 24 25 26 27 28 29 30 31
2011年6月
----------------------------- 日 一 二 三 四 五 六
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
2011年7月
----------------------------- 日 一 二 三 四 五 六
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
31
2011年8月
----------------------------- 日 一 二 三 四 五 六
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
2011年9月
----------------------------- 日 一 二 三 四 五 六
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
2011年10月
----------------------------- 日 一 二 三 四 五 六
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
30 31
2011年11月
----------------------------- 日 一 二 三 四 五 六
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
2011年12月
----------------------------- 日 一 二 三 四 五 六
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31计算时间差，请输入开始时间的小时： 15 请输入开始时间的分钟： 20 请输入开始时间的秒： 20 请输入结束时间的小时： 20
请输入结束时间的分钟： 15 请输入结束时间的秒： 15 两个时间相差： 04时54分55秒 -
链表斗地主发牌 玩家1的牌： 黑桃5 方块Q 黑桃7 红桃7 方块T 红桃T 红桃6 红桃J 黑桃T 梅花T 黑桃A 梅花2 方块K 梅花4 方块6 梅花9 黑桃Q 玩家2的牌： 红桃9 方块4 红桃A 黑桃J 梅花A 梅花6 方块2 红桃8 梅花J 方块A 红桃3
黑桃2 黑桃3 梅花Q 红桃K 红桃2 大王 玩家3的牌： 方块J 梅花5 梅花8 方块9 红桃Q 小王 方块8 方块7 梅花K
黑桃8 梅花7 黑桃4 黑桃6 黑桃K 红桃5 黑桃9 红桃4 三张底牌 方块3 梅花3 方块5 -
银行客户类BankCustomer 输入您的个人信息进行开户：1.请输入您的身份证号 123456789
2.请输入您的姓名： corn
3.请输入您的联系电话： 888888 开户成功！ 初始密码为：666666 请尽快修改密码 请选择办理以下业务：
1.修改账户信息(姓名、联系电话)
2.存钱
3.取钱
4.显示账户信息
5.修改密码
6.退出 1 现在进行修改账户信息，请输入您的密码： 666666 请输入您的新姓名： student 请输入您的新联系电话： 999999 账户信息修改成功请选择办理以下业务：
1.修改账户信息(姓名、联系电话)
2.存钱
3.取钱
4.显示账户信息
5.修改密码
6.退出 2 请输入你的密码： 666666 请输入存钱金额： 5000 存钱成功 您的账户余额：5000.0请选择办理以下业务：
1.修改账户信息(姓名、联系电话)
2.存钱
3.取钱
4.显示账户信息
5.修改密码
6.退出 3 请输入你的密码： 666666 请输入取钱金额： 8000 余额不足 您的账户余额：5000.0请选择办理以下业务：
1.修改账户信息(姓名、联系电话)
2.存钱
3.取钱
4.显示账户信息
5.修改密码
6.退出 4 现在进行显示账户信息，请输入您的密码： 666666 账号：20201027174635 身份证号：123456789 姓名：student 联系电话：999999 余额：5000.0请选择办理以下业务：
1.修改账户信息(姓名、联系电话)
2.存钱
3.取钱
4.显示账户信息
5.修改密码
6.退出 5 现在进行修改密码，请输入您的原密码： 666666 请输入您的新密码： 12345 ERROR! 密码必须为6位数 !ERROR请选择办理以下业务：
1.修改账户信息(姓名、联系电话)
2.存钱
3.取钱
4.显示账户信息
5.修改密码
6.退出 5 现在进行修改密码，请输入您的原密码： 666666 请输入您的新密码： 789456 密码修改成功请选择办理以下业务：
1.修改账户信息(姓名、联系电话)
2.存钱
3.取钱
4.显示账户信息
5.修改密码
6.退出 6 退出系统
五、分析与讨论（体会、感想、意见、建议）
- 栈类 听过课上老师的讲解，在本次实验中我选择用switch方法来实现中缀表达式转换为后缀表达式，‘（’是什么情况，‘）’是什么情况，各种符号的不同处理方式在switch方法下显得清晰可见，不仅写起来思路清晰，代码看起来也通俗易懂。再加上这一次类的使用，进一步让整个代码显得简洁明了。
- 时间类MyDate 经过本次实验的训练，我对课上老师讲的关于类的知识，有了更深入的了解。首先，明白了课上讲的getter,setter方法的具体用法，比如本题中的public
int getYear()方法，虽然其中只有一个简单的return
year;语句，但就是它让private类型的year变得可读了，也就是课上讲的半开半闭的内容；其次，更加理解了重载的含义，以及其在构造方法中的使用，同名的方法如何通过形参的不同来加以区分，也是我在本实验中的一大收获。最后，我也明白了学习一种语言，绝对离不开课下实际操作的点滴积累，不动手是绝对学不会的。 - 链表斗地主发牌 经过本次实验，我对“类对类自身的引用”有了更深刻的认识。本题就是通过一个Node nextNode语句，来实现结点的连接，以此形成一个链表。在本次实验中，我也复习了上一学年学过的数据结构的知识，比如如何实现链表的删除，同时熟练了指针的运用，收获颇丰。
- 银行客户类BankCustomer 在经过设计栈类，时间类的实验后，本实验要求设计一个银行客户类，比之前更加容易上手了，且如何使用switch方法来实现让用户自行选择所需操作，也在前面多次训练过了，因此本实验并没有花太长时间。但值得注意的是，在写isPasswordCorrect方法时，我一开始差点写成
if(password==this.password)) ，后来才记起老师课上曾经说过，String型使用=
=时，比较的是两个字符串的地址，因此我将语句改为if(password.equals(this.password)) 这个错误也提醒了我，学习一门语言，基础一定要打扎实了，课下需要经常复习课上讲过的内容。
1593
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
