PTA7-9作业总结
PTA第7~9次作业总结
7-1: 图形卡片排序游戏
本题主要运用集合ArrayList,接口,继承相关的知识;
ArrayList主要方法有
① 添加元素add()方法;:add（object value） ;将指定元素object value追加到集合的末尾; add（int index, Object obj）;功能：在集合中指定index位置，添加新元素obj
② 删除元素:remove()
③ 获取数组长度:size()
④ 替换元素:set(a,b):
⑤ 清空集合内所有元素clear()
⑥ 查找元素get(int index);返回指定元素
本题还运用到一个知识点:运用了接口Collection.sort排序方法
接口:抽象方法只能存在于抽象类或者接口中,但抽象类中却能存在非抽象方法,即有方法体的方法.接口是百分之百的抽象类
我们不能直接取实例化一个接口,因为接口中的方法都是抽象的,没有方法体的,那如何产生具体的实例呢?我们可以使用接口类型的引用指向一个实现了该接口的对象,并且调用这个接口中的方法.一个类可以实现多个接口,一个接口可以继承于另外一个接口,一个类如果要实现某个接口的话,那么它必须要实现这个接口的所有方法.接口中所有的方法都是抽象的和public .接口的实现主要是用来弥补无法实现多继承的局限
多态的理解: 多态是继封装、继承之后，面向对象的第三大特性。
多态现实意义理解：
现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。
Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。
3.多态体现为父类引用变量可以指向子类对象。
4.前提条件：必须有子父类关系。
5.多态中成员的特定:
多态成员变量：编译运行看左边
Fu f=new Zi();
System.out.println(f.num);//f是Fu中的值，只能取到父中的值
多态成员方法：编译看左边，运行看右边
Fu f1=new Zi();
System.out.println(f1.show());//f1的门面类型是Fu,但实际类型是Zi,所以调用的是重写后的方法。
6.instanceof关键字:用来判断某个对象是否属于某种数据类型
如: Fu f1=new Zi();
Fu f2=new Son();
if(f1 instanceof Zi){
System.out.println("f1是Zi的类型");
}
else{
System.out.println("f1是Son的类型");
}
主要的点:多态的转型:::
多态的转型分为向上转型和向下转型两种
向上转型：多态本身就是向上转型过的过程
使用格式：父类类型 变量名=new 子类类型();
适用场景：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作。
向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型
使用格式：子类类型 变量名=（子类类型） 父类类型的变量；
适用场景：当要使用子类特有功能时。
8-1ATM机类设计
本题第一个遇到的问题:如何对输入的信息处理
解决办法:正则表达式
StringBuilder sb = new StringBuilder();
while(!((data = input.nextLine()).equals("#"))) {
sb.append(data + "\n");//加换行的目的是为了将得到数据用split()分开
}
String[] dt = sb.toString().split("\n");
for(int i = 0; i < dt.length; i++) {
String[] dataLine = dt[i].toString().split("\\s+");
if(dataLine.length == 1) {
}else {
}
本题迭代器的方法:
public static Card getCardbyCardNO(UnionPay unionPay,String cardNO) {
Card card = null;
Iterator<Bank> bankItr = unionPay.getBankList().iterator();
while(bankItr.hasNext()) {
ArrayList<Account> accountList = bankItr.next().getAccountList();
Iterator<Account> accountItr = accountList.iterator();
while(accountItr.hasNext()) {
ArrayList<Card> cardList = accountItr.next().getList();
Iterator<Card> cardItr = cardList.iterator();
while(cardItr.hasNext()) {
card = cardItr.next();
if(card.getCardNO().equals(cardNO)) {
return card;
}
}
}
}
return null;
}
每个集合都可以生成iterator();方法
迭代的原理:hasNext()判断是否还有下一个元素
Next()指针下移将下一个元素返回
本题中的判断合法类型,单独创了个类,实现类的设计方法中的单一原则: 单一职责原则是最简单的面对对象设计原则，它用于控制类的粒度大小。
public class ValidateData {
/**
* 校验卡号是否存在
* @param unionPay
* @param cardNO
* @return
*/
public static Card getCardbyCardNO(UnionPay unionPay,String cardNO) {
Card card = null;
Iterator<Bank> bankItr = unionPay.getBankList().iterator();
while(bankItr.hasNext()) {
ArrayList<Account> accountList = bankItr.next().getAccountList();
Iterator<Account> accountItr = accountList.iterator();
while(accountItr.hasNext()) {
ArrayList<Card> cardList = accountItr.next().getList();
Iterator<Card> cardItr = cardList.iterator();
while(cardItr.hasNext()) {
card = cardItr.next();
if(card.getCardNO().equals(cardNO)) {
return card;
}
}
}
}
return null;
}
/**
* 校验ATM ID是否存在
* @param unionPay
* @param ATMID
* @return
*/
public static ATM getATMbyATMID(UnionPay unionPay,String ATMID) {
Iterator<Bank> bankItr = unionPay.getBankList().iterator();
Bank bank = null;
ATM aTM = null;
while(bankItr.hasNext()) {
bank = bankItr.next();
Iterator<ATM> aTMItr = bank.getATMList().iterator();
while(aTMItr.hasNext()) {
aTM = aTMItr.next();
if(aTM.getATMID().equals(ATMID)) {
return aTM;
}
}
}
return null;
}
}
在软件系统中，一个类（大到模块，小到方法）承担的职责越多，它被复用的可能性就越小，而且一个类承担的职责过多，就相当于将这些职责耦合在一起，当其中一个职责变化时，可能会影响其他职责的运作，因此要将这些职责进行分离，将不同的职责封装在不同的类中，即将不同的变化原因封装在不同的类中，如果多个职责总是同时发生改变则可将它们封装在同一类中。
我们写程序的目标就是 高内聚 低耦合!什么叫高内聚低耦合呢，举个例子：你房子里边有墙和窗 ，那墙和窗就有了关联，耦合度 是松还是紧 就看你的 关联 是强还是弱，也就是修改的代价，比如 你窗是扣死在墙里的 那么你修改窗子就必须修改墙 这就比较紧密了，但是如果你窗是按照某种规格的 可以自由拆装的 那么修改的代价就小，耦合度也就低了
遵循单一职责原的优点有：
1.可以降低类的复杂度，一个类只负责一项职责，其逻辑肯定要比负责多项职责简单的多；
2.提高类的可读性，提高系统的可维护性；
3.变更引起的风险降低，变更是必然的，如果单一职责原则遵守的好，当修改一个功能时，可以显著降低对其他功能的影响
。
本题在写题踩坑如下:当遇到String类型的匹配时,用==没用equals,程序不报错,但并没有达到匹配的效果,以至于找了半天的错误…
遍历:for增强循环
For(object a ;object){
}
当我想要返回集合中含有特定元素的对象时:
ublic User1 getuser1(){
User1 user=null;
Iterator<User1> user1Iterator = list.iterator();
while (user1Iterator.hasNext()){
user = user1Iterator.next();
if(user.cardno.equals(a)){
return user;
}
}
return null;
}
}
① StringBuilder详解：
(1)
区别:StringBuilder的原理和StringBuffer一样，不同之处在于StringBuilder不需要考虑线程安全，主要操作有append,insert
如果对字符串的改变少，使用String；
如果对字符串修改的较多，需要线程安全就用StringBuffer，不需要就使用StringBuilder。
简单的StringBuilder操作
1：public class StringBuilderFun {
public static void main(String[] args) {
//内部默认为空字符串
StringBuilder builder = new StringBuilder();
//用于在字符串末尾追加
//努力学习java，为了更好的生活
builder.append("努力学习java，为了更好的生活");
//用于更改字符串，通过字符串下标
//努力学习java,为了改变世界
builder.replace(9, 16,"为了改变世界");
//用于删除字符串
//为了改变世界
builder.delete(0, 8);
//用于插入字符串
//活着，为了改变世界
builder.insert(0, "或者");
//把builder转换为字符串
System.out.println(builder.toString());
//字符串反转reverse()
String str = "123456";
StringBuilder bui = new StringBuilder(str);
bui.reverse();
System.out.println(bui.toString());//输出结果654321
}
}
②spilt（）函数：
1.函数说明：
/* String.split(sourceStr,maxSplit)
* String.split(sourceStr)
* 参数说明：sourceStr是被分割的字符串，maxSplit是最大的分割数
* 返回值说明：split函数的返回值是一个字符串数组String[]
*/
2.空格拆分：
/*
* String s1 = "A B C";
* String[]s2 = s1.split(" "); // 以1个空格拆分字符串
* String[]s2 = s1.split("\\s+"); // 以1个或多个空格拆分字符串
* String[]s2 = s1.split(" ");
*/
3.特殊（在正则表达式中有特殊含义的符号）：
/* 1."."在正则表达式中有特殊的含义，因此使用的时候必须进行转义。
* 比如：String s1 = "a.b.c";
* String[]s = s1.split("."); 输出是空的
* String[]s = s1.split("\\."); 需要在前面加上\\
*
* 2.同样的 ,对于字符"|" , "*" , "+"都得加上转义字符，前面加上"\\"
*
* 3.而如果是"\"，那么就得写成"\\\\"
正则表达式中的相关知识:
Pattern类：
String pattern() 返回正则表达式的字符串形式,其实就是返回Pattern.complile(String regex)的regex参数
Matcher类：
boolean matches() 最常用方法:尝试对整个目标字符展开匹配检测,也就是只有整个目标字符串完全匹配时才返回真值
- boolean find() 对字符串进行匹配,匹配到的字符串可以在任何位置
- boolean lookingAt() 对前面的字符串进行匹配,只有匹配到的字符串在最前面才会返回true
浙公网安备 33010602011771号