作业总结
一. 前言
最近阶段的练习，总体而言，越来越难，电信收费系统让我感觉很困难，有种无从下手的感觉。学习java以来，感觉java这么难。最近的几次作业，所涉及的知识点仍然包含正则表达式的运用，然后就是继承于多态以及父类与子类还有接口等等。从题量上来说，题目量虽然不是很大，每次都是两三道题目，但是难度确实比较大。有时候花几个小时做一道题目都拿不了多少分。对于各种解题技巧我并不是很会，只是老老实实的按照最普通的方法写。
1.作业总结
（1）第六次作业
第六次作业一共有两道题，第一题是 电信计费系列1-座机计费算是比较发杂的一道题
第二题是多态测试 还算是比较简单。
（2）第七次作业
第七次作业一共有三道题，比较难的只有第一道题目。与第六作业中的第一题类似。先设计出所需要的方法，点可以设计容器，用容器储存，使用父类与子类的知识点，去设计思路。这样是会方便很多，但不太好操作，知识点用多了总会莫名其妙的报错，但这样确实方便很多，不需要通篇的去修改题目，只需要改一个地方，所有地方都会改变。
（3）第八次作业
第八次作业一共三道题目，主要是考察对电信计费的知识点，然后是继承与多态。这三个知识点一共三道题目，每道题都上升一个层次，最后将所有知识点串在一起，这三道题目难度不是很大，只需要根据类图去写代码就好，思考怎么设计方法。但是测试点比较多，还是比较难过的。
二.设计与分析
第六次第一题
题目的设计主要是这样
实现一个简单的电信计费程序：
假设南昌市电信分公司针对市内座机用户采用的计费方式：
月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途拨打0.6元/分钟。不足一分钟按一分钟计。
南昌市的区号：0791，江西省内各地市区号包括：0790~0799以及0701。
题目要求
实现一个简单的电信计费程序：
假设南昌市电信分公司针对市内座机用户采用的计费方式：
月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途拨打0.6元/分钟。不足一分钟按一分钟计。
南昌市的区号：0791，江西省内各地市区号包括：0790~0799以及0701。
代码如下：
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) throws ParseException {
// TODO Auto-generated method stub
ArrayList<String> users = new ArrayList<String>();
ArrayList<String> records = new ArrayList<String>();
Scanner in = new Scanner(System.in);
String s = in.nextLine();
StringBuilder builder = new StringBuilder();
String[] ps;
String[] ps1;
String ks, ks1;
String ns, ns1;
boolean judge1 = true;
boolean judge2 = true;
while(!s.equals("end")) {
if(s.charAt(0) == 'u') {
for(String e:users) {
if(s.equals(e)) {
judge1 = false;
}
}
if(judge1 = false) {
s = in.nextLine();
judge1 = true;
continue;
}
if(!Treat.match1(s)) {
s = in.nextLine();
continue;
}
users.add(s);
}
else if(s.charAt(0) == 't') {
for(String e:records) {
if(s.equals(e)) {
judge2 = false;
}
}
if(judge2 = false) {
s = in.nextLine();
judge2 = true;
continue;
}
if(!Treat.match2(s)) {
s = in.nextLine();
continue;
}
records.add(s);
}
s = in.nextLine();
}
ArrayList<User> user = Treat.b(users, records);
for (User e : user) {
System.out.printf("%s %.1f %.1f\n", e.getNumber(), e.calCost(), e.getBalance());
}
}
}
abstract class ChargeMode {
private ArrayList<ChargeRule> chargeRules = new ArrayList<ChargeRule>();
public double calCost(UserRecords userRecords) {
double sum = 0;
chargeRules.add(new LandPhoneInCityRule());
chargeRules.add(new LandPhoneInProvinceRule());
chargeRules.add(new LandPhoneInlandRule());
LandPhoneInCityRule city = (LandPhoneInCityRule) chargeRules.get(0);
LandPhoneInProvinceRule province = (LandPhoneInProvinceRule) chargeRules.get(1);
LandPhoneInlandRule land = (LandPhoneInlandRule) chargeRules.get(2);
sum = sum + city.calCost(userRecords.getCallingInCityRecords())
+ province.calCost(userRecords.getCallingInProvinceRecords())
+ land.calCost(userRecords.getCallingInLandRecords());
return sum;
}
public double getMonthlyRent() {
return 0;
}
}
class ChargeMode0 extends ChargeMode {
private double monthlyRent = 20;
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
return super.calCost(userRecords);
}
@Override
public double getMonthlyRent() {
// TODO Auto-generated method stub
return monthlyRent;
}
}
class ChargeMode1 extends ChargeMode {
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
return super.calCost(userRecords);
}
@Override
public double getMonthlyRent() {
// TODO Auto-generated method stub
return super.getMonthlyRent();
}
}
class ChargeMode2 extends ChargeMode {
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
return super.calCost(userRecords);
}
@Override
public double getMonthlyRent() {
// TODO Auto-generated method stub
return super.getMonthlyRent();
}
}
class LandlinePhoneCharging extends ChargeMode {
private double monthlyRent = 20;
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
return super.calCost(userRecords);
}
@Override
public double getMonthlyRent() {
// TODO Auto-generated method stub
return super.getMonthlyRent();
}
}
class User {
private UserRecords userRecords = new UserRecords();
private double balance = 100;
private ChargeMode chargeMode;
private String number;
public User(ChargeMode chargeMode, String number) {
super();
this.chargeMode = chargeMode;
this.number = number;
}
public double calBalance() {
return balance - chargeMode.getMonthlyRent() - calCost();
}
public double calCost() {
return chargeMode.calCost(userRecords);
}
public UserRecords getUserRecords() {
return userRecords;
}
public void setUserRecords(UserRecords userRecords) {
this.userRecords = userRecords;
}
public double getBalance() {
return calBalance();
}
public void setBalance(double balance) {
this.balance = balance;
}
public ChargeMode getChargeMode() {
return chargeMode;
}
public void setChargeMode(ChargeMode chargeMode) {
this.chargeMode = chargeMode;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
}
class UserRecords {
private ArrayList<CallRecord> callingInCityRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> callingInProvinceRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> callingInLandRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerInCityRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerInProvinceRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerInLandRecords = new ArrayList<CallRecord>();
private ArrayList<MessageRecord> sendMessageRecords = new ArrayList<MessageRecord>();
private ArrayList<MessageRecord> receiveMessageRecord = new ArrayList<MessageRecord>();
public void addCallingInCityRecords(CallRecord callRecord) {
callingInCityRecords.add(callRecord);
}
public void addCallingInProvinceRecords(CallRecord callRecord) {
callingInProvinceRecords.add(callRecord);
}
public void addCallingInLandRecords(CallRecord callRecord) {
callingInLandRecords.add(callRecord);
}
public void addAnswerInCityRecords(CallRecord callRecord) {
answerInCityRecords.add(callRecord);
}
public void addAnswerInProvinceRecords(CallRecord callRecord) {
answerInProvinceRecords.add(callRecord);
}
public void addAnswerInLandRecords(CallRecord callRecord) {
answerInLandRecords.add(callRecord);
}
public ArrayList<CallRecord> getCallingInCityRecords() {
return callingInCityRecords;
}
public ArrayList<CallRecord> getCallingInProvinceRecords() {
return callingInProvinceRecords;
}
public ArrayList<CallRecord> getCallingInLandRecords() {
return callingInLandRecords;
}
public ArrayList<CallRecord> getAnswerInCityRecords() {
return answerInCityRecords;
}
public ArrayList<CallRecord> getAnswerInProvinceRecords() {
return answerInProvinceRecords;
}
public ArrayList<CallRecord> getAnswerInLandRecords() {
return answerInLandRecords;
}
public ArrayList<MessageRecord> getSendMessageRecords() {
return sendMessageRecords;
}
public ArrayList<MessageRecord> getReceiveMessageRecord() {
return receiveMessageRecord;
}
}
abstract class CommunicationRecord {
protected String callingNumber;
protected String answerNumber;
public CommunicationRecord(String callingNumber, String answerNumber) {
super();
this.callingNumber = callingNumber;
this.answerNumber = answerNumber;
}
public String getCallingNumber() {
return callingNumber;
}
public void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}
public String getAnswerNumber() {
return answerNumber;
}
public void setAnswerNumber(String answerNumber) {
this.answerNumber = answerNumber;
}
}
class MessageRecord extends CommunicationRecord {
private String message;
public MessageRecord(String callingNumber, String answerNumber, String message) {
super(callingNumber, answerNumber);
this.message = message;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
class CallRecord extends CommunicationRecord {
private Date startTime;
private Date endTime;
private String callingAddressAreaCode;
private String answerAddressAreaCode;
public CallRecord(String callingNumber, String answerNumber, Date startTime, Date endTime,
String callingAddressAreaCode, String answerAddressAreaCode) {
super(callingNumber, answerNumber);
this.startTime = startTime;
this.endTime = endTime;
this.callingAddressAreaCode = callingAddressAreaCode;
this.answerAddressAreaCode = answerAddressAreaCode;
}
public Date getStartTime() {
return startTime;
}
public void setStartTime(Date startTime) {
this.startTime = startTime;
}
public Date getEndTime() {
return endTime;
}
public void setEndTime(Date endTime) {
this.endTime = endTime;
}
public String getCallingAddressAreaCode() {
return callingAddressAreaCode;
}
public void setCallingAddressAreaCode(String callingAddressAreaCode) {
this.callingAddressAreaCode = callingAddressAreaCode;
}
public String getAnswerAddressAreaCode() {
return answerAddressAreaCode;
}
public void setAnswerAddressAreaCode(String answerAddressAreaCode) {
this.answerAddressAreaCode = answerAddressAreaCode;
}
}
abstract class ChargeRule {
}
abstract class CallChargeRule extends ChargeRule {
public double calCost(ArrayList<CallRecord> callRecords) {
return 0;
}
}
class LandPhoneInCityRule extends CallChargeRule {
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
// TODO Auto-generated method stub
BigDecimal time;
double sum = 0;
double timex;
// 都是市内的拨打记录
for (CallRecord e : callRecords) {
time = new BigDecimal(e.getEndTime().getTime()).subtract((new BigDecimal(e.getStartTime().getTime())));
timex = time.doubleValue() / 60000.0;
if (timex != (int) timex) { // java中1等于1.0，但1.01不等于1
timex = timex + 1;
}
sum = sum + (int) timex * 0.1;
}
return sum;
}
}
class LandPhoneInProvinceRule extends CallChargeRule {
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
// TODO Auto-generated method stub
BigDecimal time;
double sum = 0;
double timex;
// 都是市内的拨打记录
for (CallRecord e : callRecords) {
time = new BigDecimal(e.getEndTime().getTime()).subtract((new BigDecimal(e.getStartTime().getTime())));
timex = time.doubleValue() / 60000.0;
if (timex != (int) timex) { // java中1等于1.0，但1.01不等于1
timex = timex + 1;
}
sum = sum + (int) timex * 0.3;
}
return sum;
}
}
class LandPhoneInlandRule extends CallChargeRule {
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
// TODO Auto-generated method stub
BigDecimal time;
double sum = 0;
double timex;
// 都是市内的拨打记录
for (CallRecord e : callRecords) {
time = new BigDecimal(e.getEndTime().getTime()).subtract((new BigDecimal(e.getStartTime().getTime())));
timex = time.doubleValue() / 60000.0;
if (timex != (int) timex) { // java中1等于1.0，但1.01不等于1
timex = timex + 1.0;
}
sum = sum + (int) timex * 0.6;
}
return sum;
}
}
class caculate {
private ArrayList<String> a = new ArrayList<String>();
String s;
public void kk() {
// Pattern pattern = Pattern.compile("\\d+\\s\\d");//多个数字
// Matcher matcher = pattern.matcher(s);
// String k[] = s.split("\\s");
// t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
String[] records = s.split("\\s+");
// String z = s.substring(2);
// String local = s.substring(2, 6);
// String number = s.substring(0, 0);
// String way =s.substring(0,8);
//
}
}
class Treat {
public static ArrayList<User> b(ArrayList<String> u, ArrayList<String> r) throws ParseException {
ArrayList<User> users = new ArrayList<User>();
ArrayList<CallRecord> callRecords = new ArrayList<CallRecord>();
// user列表所用的临时数组
String[] ab;
ChargeMode chargeMode = null;
// 创建好顾客对象
for (String e : u) {
// "u-079186300001 0";
ab = e.split("\\s+");
switch (ab[1]) {
case "0":
chargeMode = new ChargeMode0();
break;
case "1":
chargeMode = new ChargeMode1();
break;
case "2":
chargeMode = new ChargeMode2();
break;
}
users.add(new User(chargeMode, ab[0].substring(2)));
}
// 创建好记录列表
// t-079186300001 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:25
// t-079186300002 058686330022 2022.1.3 11:00:25 2022.1.3 11:05:25
// t-079186300001 079186300001 2022.1.3 12:00:25 2022.1.3 12:05:25
// records列表所用的临时数组、临时地址、两个匹配项、号码、时间、以及为了取出一个user对象的临时用户对象TemptUser
String ks,ks1;
String[] ps;
String area1, area2;
Pattern pattern = Pattern.compile("079[0-9]|0701");//
Matcher matcher1, matcher2;
String number1, number2;
Date date1 = new Date(), date2 = new Date();
int judge = 0;
User TemptUser = null;
StringBuilder builder = new StringBuilder();
for (String e : r) {
ps = e.split("\\s+");
// 先分出地址
area1 = ps[0].substring(2, 6);
area2 = ps[1].substring(0, 4);
matcher1 = pattern.matcher(area1);
matcher2 = pattern.matcher(area2);
if (area2.equals("0791")) { //都是南昌市内用户
judge = 0;
} else if (matcher2.matches()) { // 是省内则true
judge = 1;
} else {
judge = 2;
}
// 再分出号码
number1 = ps[0].substring(2);
number2 = ps[1];
// 时间
// 时间1的具体
String[] time1 = ps[2].split("\\.");
String[] time1Two = ps[3].split(":");
// 时间2的具体
String[] time2 = ps[4].split("\\.");
String[] time2Two = ps[5].split(":");
builder.append(ps[2]);
builder.append(" ");
builder.append(ps[3]);
ks = builder.toString();
builder.setLength(0);
builder.append(ps[4]);
builder.append(" ");
builder.append(ps[5]);
ks1 = builder.toString();
builder.setLength(0);
date1 = returnDate(ks);
date2 = returnDate(ks1);
// 上述步骤我们获得了所有数据，然后我们找到拨打方的信息，将记录给与它
for (User a : users) {
if (a.getNumber().equals(number1)) {
TemptUser = a;
break;
}
}
switch (judge) {
case 0:
TemptUser.getUserRecords()
.addCallingInCityRecords((new CallRecord(number1, number2, date1, date2, area1, area2)));
break;// 市内对象
case 1:
TemptUser.getUserRecords()
.addCallingInProvinceRecords((new CallRecord(number1, number2, date1, date2, area1, area2)));
break;// 省内
case 2:
TemptUser.getUserRecords()
.addCallingInLandRecords((new CallRecord(number1, number2, date1, date2, area1, area2)));
break;// 宇宙之内
}
}
Collections.sort(users, new Comparator<User>() {
@Override
public int compare(User o1, User o2) {
// return o1.getScore() - o2.getScore();//升序
return (int) (Long.parseLong(o1.getNumber()) - Long.parseLong(o2.getNumber())); // 降序
}
});
return users;
}
public static boolean isValidDate(String str) {
boolean convertSuccess = true;
// 指定日期格式为四位年/两位月份/两位日期，注意yyyy/MM/dd区分大小写；
SimpleDateFormat format = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
// 设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
format.setLenient(false);
format.parse(str);
} catch (ParseException e) {
// e.printStackTrace();
// 如果throw java.text.ParseException或者NullPointerException，就说明格式不对
convertSuccess = false;
}
return convertSuccess;
}
public static Date returnDate(String str) throws ParseException {
SimpleDateFormat format = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
return format.parse(str);
}
public static boolean isValidNumber(String str) {
boolean judge = false;
Pattern pattern = Pattern.compile("\\d+");// 全是数字且符合11位或是12位
Matcher matcher = pattern.matcher(str);
if (matcher.matches() && (str.length() == 11 || str.length() == 12)) {
judge = true;
}
return judge;
}
public static boolean isVaildT(String str) {
boolean judge =false;
String[] a = str.split(" ");
String s=a[0].substring(2);
Pattern pattern = Pattern.compile("\\d+\\s\\d");//很多数字，空格，加个数字
Matcher matcher = pattern.matcher(str.substring(2));
if (matcher.matches()&& str.substring(0, 2).equals("u-") && isValidNumber(s)) {
judge = true;
}
return judge;
}
public static boolean isVaildU(String str) {
boolean judge = false;
// t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
Pattern pattern = Pattern.compile("\\d+");//很多数字
Matcher matcher = pattern.matcher(str.substring(2));
if (matcher.matches()&& str.substring(0, 2).equals("t-")) {
judge = true;
}
return judge;
}
public static boolean isValidTwo(String str) {
boolean judge = false;
String[] a = str.split(" ");
StringBuilder builder1 = new StringBuilder();
StringBuilder builder2 = new StringBuilder();
builder1.append(a[2]);
builder1.append(" ");
builder1.append(a[3]);
builder2.append(a[4]);
builder2.append(" ");
builder2.append(a[5]);
// t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
Pattern pattern = Pattern.compile("\\d+");//很多数字
Matcher matcher = pattern.matcher(a[0].substring(2));
if (matcher.matches()&& a[0].substring(0, 2).equals("t-") && Treat.isValidNumber(a[0].substring(2)) && Treat.isValidNumber(a[1]) && isValidDateTwo(builder1.toString()) && isValidDateTwo(builder2.toString())) {
judge = true;
}
return judge;
}
public static boolean isValidDateTwo(String str) {
boolean convertSuccess = true;
Pattern pattern = Pattern.compile("[1-9]\\d*.([1-9]|10|11|12).([1-9]|[1-2]\\d|30|31) (0\\d|1\\d|2[0-3]):[0-5]\\d:[0-5]\\d");// 全是数字且符合11位或是12位
Matcher matcher = pattern.matcher(str);
if(!matcher.matches()) {
convertSuccess = false;
}
return convertSuccess;
}
public static boolean match1(String s) {
boolean judge = false;
String sk = "u-\\d{11,12} [0-2]";
Pattern pattern = Pattern.compile(sk);// 全是数字且符合11位或是12位
Matcher matcher = pattern.matcher(s);
if(matcher.matches()) {
judge = true;
}
return judge;
}
public static boolean match2(String s) {
boolean judge = false;
String regStr2 = "[t]-0791[0-9]{7,8}\\s" + "0[0-9]{9,11}\\s" +
"((([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]|[0-9][1-9][0-9]{2}|[1-9][0-9]{3})\\.(((0?[13578]|1[02])\\.(0?" +
"[1-9]|[12][0-9]|3[01]))|(([469]|11)\\.([1-9]|[12][0-9]|30))|(2\\.([1-9]|[1][0-9]|2[0-8]))))|(((" +
"[0-9]{2})([48]|[2468][048]|[13579][26])|(([48]|[2468][048]|[3579][26])00))\\.2\\.29))" +
"\\s([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])\\s" +
"((([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]|[0-9][1-9][0-9]{2}|[1-9][0-9]{3})\\.((([13578]|1[02])\\.(" +
"[1-9]|[12][0-9]|3[01]))|(([469]|11)\\.([1-9]|[12][0-9]|30))|(2\\.([1-9]|[1][0-9]|2[0-8]))))|(((" +
"[0-9]{2})([48]|[2468][048]|[13579][26])|(([48]|[2468][048]|[3579][26])00))\\.2\\.29))" +
"\\s([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])";
Pattern pattern = Pattern.compile(regStr2);// 全是数字且符合11位或是12位
Matcher matcher = pattern.matcher(s);
if(matcher.matches()) {
judge = true;
}
return judge;
}
}
主要运用到的知识点就是类的设计，继承于多态，还有父类与子类，接口等等。
接口：
官方解释：Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。
我的解释：接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。接口是解决Java无法使用多继承的一种手段，但是接口在实际中更多的作用是制定标准的。或者我们可以直接把接口理解为100%的抽象类，既接口中的方法必须全部是抽象方法。（JDK1.8之前可以这样理解）
就像一个类一样，一个接口也能够拥有方法和属性，但是在接口中声明的方法默认是抽象的。（即只有方法标识符，而没有方法体）。
接口指明了一个类必须要做什么和不能做什么，相当于类的蓝图。
一个接口就是描述一种能力，比如“运动员”也可以作为一个接口，并且任何实现“运动员”接口的类都必须有能力实现奔跑这个动作（或者implement move()方法），所以接口的作用就是告诉类，你要实现我这种接口代表的功能，你就必须实现某些方法，我才能承认你确实拥有该接口代表的某种能力。
如果一个类实现了一个接口中要求的所有的方法，然而没有提供方法体而仅仅只有方法标识，那么这个类一定是一个抽象类。（必须记住：抽象方法只能存在于抽象类或者接口中，但抽象类中却能存在非抽象方法，即有方法体的方法。接口是百分之百的抽象类）
一个JAVA库中接口的例子是：Comparator 接口，这个接口代表了“能够进行比较”这种能力，任何类只要实现了这个Comparator接口的话，这个类也具备了“比较”这种能力，那么就可以用来进行排序操作了。
为什么要用接口？
接口被用来描述一种抽象。
因为Java不像C++一样支持多继承，所以Java可以通过实现接口来弥补这个局限。
接口也被用来实现解耦。
接口被用来实现抽象，而抽象类也被用来实现抽象，为什么一定要用接口呢？接口和抽象类之间又有什么区别呢？原因是抽象类内部可能包含非final的变量，但是在接口中存在的变量一定是final，public,static的。
为了声明一个接口，我们使用interface这个关键字，在接口中的所有方法都必须只声明方法标识，而不要去声明具体的方法体，因为具体的方法体的实现是由继承该接口的类来去实现的，因此，接口并不用管具体的实现。接口中的属性默认为Public Static Final.一个类实现这个接口必须实现这个接口中定义的所有的抽象方法。
一个简单的接口就像这样：拥有全局变量和抽象方法。
什么是类？类就是用来创建对象的。在面向对象程序设计中，类（class）是一种面向对象计算机编程语言的构造，是创建对象的蓝图，描述了所创建的对象共同的属性和方法。
那么子类与父类呢？
子类和父类的概念是在继承中才会有的，继承的前提是 is-a 原则，比如：Student is a Person，那么我们就可以表示为Student extends Person。
子类又叫派生类，子类一定具有父类的全部属性与行为，并且拥有的属性更多，具体的行为更加丰富，表示的范围更小；父类又名超类。
子类对象在进行实例化之前一定会首先实例化父类对象，先有父类对象才有子类对象，即先调用父类的构造方法之后再调用子类构造方法!
子类在继承父类时会继承父类的所有结构 (包括私有属性、构造方法、普通方法)
① 隐式继承：父类中所有的私有域(私有属性、方法 private)，子类不能直接使用 – 属性可以setter/getter，然而方法则没辙。
② 显示继承：所有的非私有域属于显示继承，子类对象可以直接调用。
继承(inheritance) 机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础.上进行扩展,增加功能。这样产生新的类,称派生类。继承呈现了面向对象程序设计的层次结构。体现了由简单到复杂的认识过程。
多态性(polymorphism) 多态性是考虑在不同层次的类中，以及在同一类中，同名的成员函数之间的关系问题。函数的重载，运算符的重载，属于编译时的多态性。以虚基类为基础的运行时的多态性是面向对象程序设计的标志题。函数的重载，运算符的重载，属于编译时的多态性。以虚基类为基础的运行时的多态性是面向对象程序设计的标志。
三.踩坑心得
对于这几次作业的一个坑点，我觉得就是一开始要好好的设计类图，然后通过类图去设计方法，这样比较方便也不会随意出错。要好好运用父类与子类的特点，这样可以减少重复的代码，提高写代码的效率，并且在后期维护或者说修改代码的时候可以方便很多。然后在类多了以后要清楚各个类的对象是否通用，很容易出错，或者是这个成员变量是否通用，要清楚父类与子类的关系。
四．改进建议
对于前这三次作业而言，我的代码一般都是大家的惯性思维，由于怕出错，所以都写得比较常规，有些题目确实有更简单的思路，但是我不知道怎么去运用哪些方法，可能是知识量储备的比较少吧。例如第六次作业的题目，可以用正则表达式去筛选出输入格式错误的情况，但是我是把输入错误的情况一一表达出来，然后通过判断语句去解决。首先是对正则表达式认知的不到位，不知道怎么去正确使用正则表达式去筛选出输入格式错误的地方，如果将这个点弄明白的话，代码的复杂程度就会降低很多。然后对于其中考试的题目，我认为还可以做到一部分代码简化，去优化一下代码，提高使用效率。
五．总结
通过这三次的习题练习，我学到了挺多的东西。
比如说继承与多态，继承(inheritance) 机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础.上进行扩展,增加功能。这样产生新的类,称派生类。继承呈现了面向对象程序设计的层次结构。体现了由简单到复杂的认识过程。
多态性(polymorphism) 多态性是考虑在不同层次的类中，以及在同一类中，同名的成员函数之间的关系问题。函数的重载，运算符的重载，属于编译时的多态性。以虚基类为基础的运行时的多态性是面向对象程序设计的标志题。函数的重载，运算符的重载，属于编译时的多态性。以虚基类为基础的运行时的多态性是面向对象程序设计的标志。
子类与父类
子类和父类的概念是在继承中才会有的，继承的前提是 is-a 原则，比如：Student is a Person，那么我们就可以表示为Student extends Person。
子类又叫派生类，子类一定具有父类的全部属性与行为，并且拥有的属性更多，具体的行为更加丰富，表示的范围更小；父类又名超类。
子类对象在进行实例化之前一定会首先实例化父类对象，先有父类对象才有子类对象，即先调用父类的构造方法之后再调用子类构造方法!
子类在继承父类时会继承父类的所有结构 (包括私有属性、构造方法、普通方法)
隐式继承：父类中所有的私有域(私有属性、方法 private)，子类不能直接使用 – 属性可以setter/getter，然而方法则没辙。
显示继承：所有的非私有域属于显示继承，子类对象可以直接调用。·
浙公网安备 33010602011771号