题目集4~6的总结性Blog
作者：互联网
一、前言
这三周的题目集练习，学到的东西挺多，学到了类的继承、类的多态、类的接口、类的聚合，抽象类，正则表达式的熟悉使用，字符串的处理（对字符进行排序），ArrayList的使用……
关于类的继承，他是指在一个现有的类的基础上去构建一个新的类，构建出来的类称为子类，现有类被称为父类，子类继承父类，子类会拥有父类所有可继承的属性和方法（这里一般指共有属性和公有方法）。关键字为：extends。另外，还有超类的概念：如果多个类中存在相同的属性和行为，将这些内容抽取到单独的的一个类中，该类无需再定义这些属性和行为，只要继承即可，多个类称为子类，而该单独类称为父类或超类。
*子类可以访问父类中的共有属性和行为
*子类无法继承父类的私有内容
此外，类的继承中还存在父类属性和行为的覆盖和重载。
覆盖：
在子类中操作（不同类中操作），关键字：override，
覆盖是指，当子类需要使用父类的方法，但同时又需要特定的功能时，可以复写父类的方法，再添加自己特有的内容。这样即沿袭了父类的方法，又定义了子类特有的方法。
比如：class father{
void show(){
System.out.println("I'mfather");
}
}
class son extends father{
void show(){
System.out.println("I'm son");
}
}
注意：
* 父类中的私有方法不可被覆盖
* 当父类为static的方法时无法覆盖
* 覆盖时，子类权限一定要大于等于父类方法的权限
重载：
在同一个类中操作（父类子类中均可操作）
重写是指，在同一个类中，可以有两个甚至多个名字相同的方法，但其所带的参数列表（即参数个数、参数类型）一定不能相同。调用时，通过方法参数列表的不同区别。
比如：
int add(int x,int y){
return x+y;
}
int add(int x,int y,int z){
return x+y+z;
}
重载在某些时候可以使编程更加方便。
构造函数
作用：用于对对象进行初始化。
每个类里面都必须有构造函数，即使你不写，也默认为有一个无参数的构造函数，构造函数用于类与类之间的调用时的初始化。
特点：
1、分为有参构造函数，无参数构造函数
2、构造函数的函数名要与类名相同
3、构造函数没有返回值类型（注意：不是返回值）
4、系统默认有一个无参数构造函数
5、构造函数只能在创建对象时调用
类的多态性
多态性的解释：
1、子类对象的多态性，父类的引用指向子类对象
2、虚拟方法调用：通过父类的引用指向子类的对象实体，当调用方法时，实际上时执行的时子类重写父类的方法
多态性的前提
1、要有类的继承
2、要有子类对父类的方法的重写
#注意点：程序分为编译状态和运行状态
对于多态性来说，编译时“看左边”，将此引用变量理解为父类类型，
运行时“看右边”，关注与真正对象的实体（子类的对象），那么执行的方法就是子类重写的；
类的接口
接口是功能的集合，比抽象类更抽象，是数据类型，但不是类。
接口只描述所具备的方法，并没有具体的实现，具体实现由接口实现类完成。
关键字：interface
接口中的方法都是公共访问的抽象方法。不允许使用其他权限
接口中也无法定义其他普通的成员变量，必须是常量，比如：int i=1；其中，i的值永远不变。
定义变量的格式为 public static final 数据类型 变量名 =值。
final 表示不许更改，永远不变，final也可省略不写，但不写不等于没有。
接口的使用：
public interface 接口名{
抽象方法
}
类的聚合
在题目集4、题目集5中都用到了类的聚合的相关知识，也从中学到了很多。
如果一个类有另一个类的实体引用（类中的类），则称他为聚合。说白了就是一个类调用另一个类中的属性和方法，就需要在该类中定义一个被调类类型的变量来进行调用。例如：
class Employee{
int id;
String name ;
Grade grade;
grade.getGrade(75);
}
class Grade{
private double grade;
public getGrade(double grade){
this.grade=grade;
}
}
这样就实现了类与类之间的调用。
ArrayList类
ArrayList是大小可变的动态数组，存储在内的数据称为元素。此类提供一些方法可对内部存储的数据进行操作。ArrayList中可不断添加元素，其大小也自动增长。
语法格式：
ArrayList<数据类型> 变量名=new ArrayList<数据类型>()；
ArrayList的一些常用方法：
add（object）：向链表的尾部添加指定的元素。例如： list.add（“name”）；
add（int index ，Object O）：在列表的指定位置插入指定元素，插入到原来位置的后面
size () :返回链表的元素个数
get（int index）:返回链表中指定位置的元素，index从0开始
clear（） ：从列表中移除所有元素；
isEmpty () :判断列表中是否包含元素，不包含则返回true,否则返回false
remove（int index）：移除列表中指定的位置的元素，并返回被删除的元素，同时后面的元素先前移动
remove（object o）：移除集合中第一次出现的指定元素，移除成功返回true，否则返回false
comtains（Object O）：如果列表包含指定元素，则返回true
set（int i，Object O）：将索引i位置的元素替换成元素O，并返回被替换的元素。
iterator（）：返回安适当顺序在列表的元素上进行的迭代器
二、设计与分析
①题目集4（7-2）、题目集5（7-4）两种日期类聚合设计的优劣比较
先用报表生成两个题目两种聚合
7-2
class Year{
private int value;
Year()
{
}
Year(int value)
{
this.value=value;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public boolean isLeapYear(int value) {
if((value%100!=0&&value%4==0)||value%400==0) {
return true;
}
else
{
return false;
}
}
public void yearIncrement()
{
value=value+1;
}
public void yearReduction()
{
value=value-1;
}
public boolean validate(int value)
{
if(value<1900||value>2050)
return true;
else
return false;
}
}
class Month{
private int value;
private Year year=new Year();
private int Year;
Month(){
}
Month(int yearValue,int monthValue){
Year=yearValue;
value=monthValue;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public Year getYear() {
return year;
}
public void setYear(Year year) {
this.year = year;
}
public void resetMin()
{
value=1;
}
public void resetMax()
{
value=12;
}
public boolean validate(int value) {
if(value>12||value<1)
{
return true;
}
else
return false;
}
public void monthIncrement()
{
if(value==12)
{
resetMin();
year.yearIncrement();
}
else
{
value=value+1;
}
}
public void monthReduction()
{
if(value==1){
resetMax();
year.yearReduction();
}
else
value=value-1;
}
}
class Day{
private int value;
private Month month=new Month();
private Year year=new Year();
int Year;
int Month;
int[] mon_maxnum= {31,29,31,30,31,30,31,31,30,31,30,31};
int[] mon_minnum= {31,28,31,30,31,30,31,31,30,31,30,31};
Day(){
}
Day(int yearValue,int monthValue,int dayValue)
{
Year=yearValue;
Month=monthValue;
value=dayValue;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public Month getMonth() {
return month;
}
public void setMonth(Month month) {
this.month = month;
}
public void resetMin()
{
value=1;
}
public void resetMax()
{
if(year.isLeapYear(year.getValue()))
value= mon_maxnum[month.getValue()-1];
else
value= mon_minnum[month.getValue()-1];
}
public Year getYear() {
return year;
}
public void setYear(Year year) {
this.year = year;
}
public boolean validate(int value)
{
if(Month==1||Month==3||Month==5||Month==7||Month==8||Month==10||Month==12)
{
if(value<1||value>31)
return true;
else
return false;
}
else if (Month==4||Month==6||Month==9||Month==11)
{
if(value<1||value>30)
return true;
else
return false;
}
else
{
if(year.isLeapYear(Year))
{
if(value>29||value<1)
{
return true;
}
else
{
return false;
}
}
else
{
if(value>28||value<1)
{
return true;
}
else
{
return false;
}
}
}
}
public void dayIncrement()
{
if(year.isLeapYear(year.getValue()))
{
if(value==mon_maxnum[month.getValue()-1])
{
resetMin();
month.monthIncrement();
}
else
value=value+1;
}
else
{
if(value==mon_minnum[month.getValue()-1])
{
resetMin();
month.monthIncrement();
}
else
value=value+1;
}
}
public void dayReduction()
{
if(value==1)
{
month.monthReduction();
resetMax();
}
else
value=value-1;
}
}
class DateUtil{
private Day day=new Day();
private Month month=new Month();
private Year year=new Year();
private int Day;
private int Year;
private int Month;
DateUtil(int y,int m,int d)
{
Day=d;
Month=m;
Year=y;
}
public Day getDay() {
return day;
}
public void setDay(Day day) {
this.day = day;
}
public Month getMonth() {
return month;
}
public void setMonth(Month month) {
this.month = month;
}
public Year getYear() {
return year;
}
public void setYear(Year year) {
this.year = year;
}
public int getyear()
{
return Year;
}
public int getmonth()
{
return Month;
}
public int getday()
{
return Day;
}
public boolean checkInputValidity()
{
if(day.validate(Day)||month.validate(Month)||year.validate(Year))
{
return true;
}
else
return false;
}
}
7-4
class DateUtil {
Day day;
Year year;
Month month;
int[] mon_maxnum = {31,28,31,30,31,30,31,31,30,31,30,31};
public DateUtil() {
}
public DateUtil(int d,int m,int y) {
year = new Year(y);
month = new Month(m);
day = new Day(d);
}
public Day getDay() {
return day;
}
public void setDay(Day day) {
this.day = day;
}
public Year getYear() {
return year;
}
public void setYear(Year year) {
this.year = year;
}
public Month getMonth() {
return month;
}
public void setMonth(Month month) {
this.month = month;
}
public void setDayMax() {
if(year.isLeapYear()&&month.value == 2) {
day.value = 29;
}else {
day.value = mon_maxnum[month.value-1];
}
}
public void setDayMin() {
day.value = 1;
}
public boolean checkInputValidity() {
if(month.value < 1 || month.value > 12) {
return false;
}
if(day.value > 0 && day.value <= mon_maxnum[month.value-1]
&&year.validate()&&month.validate()) {
return true;
}
return false;
}
public boolean compareDates(DateUtil date) { //date在day前则返回true
if(year.value < date.year.value) {
return true;
}
else if(year.value == date.year.value) {
if(month.value < date.month.value) {
return true;
}
else if(month.value == date.month.value) {
if(day.value < date.day.value) {
return true;
}
else
return false;
}
else
return false;
}
else
return false;
}
public boolean equalTwoDates(DateUtil date) {
if(year.value == date.year.value) {
if(month.value == date.month.value) {
if(day.value == date.day.value)
return true;
else
return false;
}
else
return false;
}
else
return false;
}
public String showDate() {
String Date =""+ year.value;
Date = Date + "-" + month.value;
Date = Date + "-" + day.value;
return Date;
}
public DateUtil getNextNDays(long nest) {
DateUtil date = this;
for(int i = 0;i < nest;i++) {
if(year.isLeapYear()&&month.value == 2) {
if(day.value == 29) {
month.monthIncrement();
day.value = 1;
}else {
day.dayIncrement();
}
}else {
if(day.value == mon_maxnum[month.value - 1]) {
if(month.value == 12) {
day.value = 1;
month.resetMin();
year.yearIncrement();
}else {
month.monthIncrement();
day.value = 1;
}
}else {
day.dayIncrement();
}
}
}
return date;
}
public DateUtil getPreviousNDays(long nest1) {
DateUtil date = this;
for(int i = 0;i < nest1;i++) {
if(day.value == 1) {
if(month.value == 1) {
month.resetMax();
day.value = mon_maxnum[month.value -1];
year.yearReduction();
}else if(month.value == 3 ){
if(year.isLeapYear()) {
month.monthReduction();
day.value = 29;
}else {
month.monthReduction();
day.value = 28;
}
}else {
month.monthReduction();
day.value = mon_maxnum[month.value -1];
}
}else {
day.dayReduction();
}
}
return date;
}
public int getDaysofDates(DateUtil date) {
if(equalTwoDates(date)) {
return 0;
}
else if(compareDates(date)==false) {
int js = 0;
while(equalTwoDates(date) == false) {
js++;
date = date.getNextNDays(1);
}
return js;
}
else {
int js = 0;
while(equalTwoDates(date)==false) {
js++;
date = date.getPreviousNDays(1);
}
return js;
}
}
}
两种聚合设计方式不同，题目集4（7-2）中的聚合方式就像一个链条，一个类连着一个类，看上去每个类的独立性不高，年月日这三个类由于都有公共属性，所以在定义了年year中的value属性之后，在月这个类就中要加上Day型的day属性，在日这个类中Mongth型的month属性和Day型的day属性，由此在DateUtil类的方法中想要调用年月日这三个类中的方法时就得使借用月和日中的属性来完成，这样做可能会导致程序的执行效率不高，类和类之间的关联性较强，不太利于程序的复用。
②.题目集4（7-3）、题目集6（7-5、7-6）三种渐进式图形继承设计的思路与技术运用（封装、继承、多态、接口等）
7-3
import java.text.DecimalFormat;
import java.util.Scanner;
public class Main {
public static void main(String[]args)
{
Scanner in=new Scanner(System.in);
DecimalFormat df = new DecimalFormat("#0.00");
int a=in.nextInt();
if(a<1||a>4)
{
System.out.println("Wrong Format");
System.exit(0);
}
if(a==1)
{
Circle A=new Circle();
A.setRadius(in.nextDouble());
double x=A.getArea();
System.out.println("Constructing Shape");
System.out.println("Constructing Circle");
System.out.println("Circle's area:"+df.format(x));
}
if(a==2)
{
Rectangle A=new Rectangle();
A.setLength(in.nextDouble());
A.setWidth(in.nextDouble());
double x=A.getArea();
System.out.println("Constructing Shape");
System.out.println("Constructing Rectangle");
System.out.println("Rectangle's area:"+df.format(x));
}
if(a==3)
{
Ball A=new Ball();
A.setRadius(in.nextDouble());
double x=A.getArea();
double y=A.getVolume();
System.out.println("Constructing Shape");
System.out.println("Constructing Circle");
System.out.println("Constructing Ball");
System.out.println("Ball's surface area:"+df.format(x));
System.out.println("Ball's volume:"+df.format(y));
}
if(a==4)
{
Box A=new Box();
A.setHeight(in.nextDouble());
A.setLength(in.nextDouble());
A.setWidth(in.nextDouble());
double x=A.getArea();
double y=A.getVolume();
System.out.println("Constructing Shape");
System.out.println("Constructing Rectangle");
System.out.println("Constructing Box");
System.out.println("Box's surface area:"+df.format(x));
System.out.println("Box's volume:"+df.format(y));
}
}
}
class Shape{
Shape(){
}
public double getArea() {
return 0.0;
}
}
class Circle extends Shape{
private double radius;
Circle(){
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
if(this.radius<=0)
{
System.out.println("Wrong Format");
System.exit(0);
}
}
public double getArea() {
return radius*radius*3.1415926;
}
}
class Rectangle extends Shape{
private double width;
private double length;
Rectangle(){
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
if(width<=0)
{
System.out.println("Wrong Format");
System.exit(0);
}
}
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
if(length<=0)
{
System.out.println("Wrong Format");
System.exit(0);
}
}
public double getArea() {
return width*length;
}
}
class Ball extends Circle{
private double radius;
Ball(){
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
if(radius<=0)
{
System.out.println("Wrong Format");
System.exit(0);
}
}
public double getArea() {
return radius*radius*4*Math.PI;
}
public double getVolume() {
return radius*radius*radius*Math.PI*4/3;
}
}
class Box extends Rectangle{
private double width;
private double length;
private double height;
Box(){
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
if(width<=0)
{
System.out.println("Wrong Format");
System.exit(0);
}
}
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
if(length<=0)
{
System.out.println("Wrong Format");
System.exit(0);
}
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
if(height<=0)
{
System.out.println("Wrong Format");
System.exit(0);
}
}
public double getArea() {
return 2*(length*height+width*length+width*height);
}
public double getVolume() {
return length*height*width;
}
}
类图如下
7-5
import java.text.DecimalFormat;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] arg) {
Scanner in = new Scanner(System.in);
DecimalFormat df = new DecimalFormat("#0.00");
double[]sum=new double[100];
int a=in.nextInt();
int b=in.nextInt();
int c=in.nextInt();
int x=0;
if(a<0||b<0||c<0)
{
System.out.println("Wrong Format");
System.exit(0);;
}
int i;
for(i=0;i<a;i++)
{
Circle circle=new Circle(in.nextDouble());
if(circle.hf())
{
sum[x]=circle.getArea();
x++;
}
else
{
System.out.println("Wrong Format");
System.exit(0);
}
}
for(i=0;i<b;i++)
{
Rectangle ractangle=new Rectangle(in.nextDouble(),in.nextDouble());
if(ractangle.hf())
{
sum[x]=ractangle.getArea();
x++;
}
else
{
System.out.println("Wrong Format");
System.exit(0);
}
}
for(i=0;i<c;i++)
{
Triangle triangle=new Triangle(in.nextDouble(),in.nextDouble(),in.nextDouble());
if(triangle.hf())
{
sum[x]=triangle.getArea();
x++;
}
else
{
System.out.println("Wrong Format");
System.exit(0);
}
}
if(a==0&&b==0&&c==0){
System.out.println("Original area:");
System.out.println("");
System.out.println("Sum of area:0.00");
System.out.println("Sorted area:");
System.out.println("");
System.out.println("Sum of area:0.00");
System.exit(0);
}
double he=0;
for(i=0;i<sum.length;i++)
{
he=he+sum[i];
}
System.out.println("Original area:");
for(i=0;i<x;i++)
{
if(i==(x-1))
System.out.println(df.format(sum[i])+" ");
else
System.out.print(df.format(sum[i])+" ");
}
double tem;
for(i=x-1;i>0;i--)
{
for(int j=0;j<i;j++)
{
if(sum[j]>sum[j+1])
{
tem=sum[j];
sum[j]=sum[j+1];
sum[j+1]=tem;
}
}
}
System.out.println("Sum of area:"+df.format(he));
System.out.println("Sorted area:");
for(i=0;i<x;i++)
{
if(i==(x-1))
System.out.println(df.format(sum[i])+" ");
else
System.out.print(df.format(sum[i])+" ");
}
System.out.print("Sum of area:"+df.format(he));
}
}
class Circle{
double radius;
Circle(double radius)
{
this.radius=radius;
}
public boolean hf()
{
if(radius<=0)
{
return false;
}
else
return true;
}
public double getArea() {
return Math.PI*radius*radius;
}
}
class Rectangle{
double width;
double length;
Rectangle(double width,double length)
{
this.width=width;
this.length=length;
}
public boolean hf() {
if(width>0&&length>0)
return true;
else
return false;
}
public double getArea() {
return width*length;
}
}
class Triangle{
double a;
double b;
double c;
Triangle(double a,double b,double c){
this.a=a;
this.b=b;
this.c=c;
}
public boolean hf() {
if(a<0&&b<0&&c<0)
return false;
else if(a+b>c&&b+c>a&&a+c>b)
return true;
else
return false;
}
public double getArea() {
double s =(a+b+c)/2f;
double S = (double) Math.sqrt(s*(s-a)*(s-b)*(s-c));
return S;
}
}
类图如下：
7-6
import java.text.DecimalFormat;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
DecimalFormat df = new DecimalFormat("#0.00");
Circle A=new Circle();
Rectangle B=new Rectangle();
A.setRadius(in.nextDouble());
B.setLength(in.nextDouble());
B.setWidth(in.nextDouble());
double x=A.getArea();
System.out.println(df.format(x));
double y=B.getArea();
System.out.println(df.format(y));
}
}
class Shape{
Shape(){
}
public double getArea() {
return 0.0;
}
}
class Circle extends Shape{
private double radius;
Circle(){
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
if(this.radius<=0)
{
System.out.println("Wrong Format");
System.exit(0);
}
}
public double getArea() {
return radius*radius*3.1415926;
}
}
class Rectangle extends Shape{
private double width;
private double length;
Rectangle(){
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
if(width<=0)
{
System.out.println("Wrong Format");
System.exit(0);
}
}
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
if(length<=0)
{
System.out.println("Wrong Format");
System.exit(0);
}
}
public double getArea() {
return width*length;
}
}
类图如下：
三、踩坑心得
（1)在写题目集4第一题的时候，那题是关于正则表达式的题目，一开始由于不知道怎么分割字符串提取出相应部分，给人感觉出一种无从下手的感觉，后面通过老师在课堂上面的一些讲解，发现其实没有那么复杂，然后通过写正则表达式将输入的字符串分割，然后就可以做出来，其实真没有想像中的那么难。在写前n天时，一直不能满分，因为我算法有问题，直接一天一天加的话好容易就超时了，所以就从年开始算，计算有多少年，多少月，可是每次输入数据进去的时候总是少几天或者多几天，过了几天还是找不到错误，到后面我想还是一天一天加，结果就差2个超时的测试点没过，然后再改进一下，有多少年算一下，然后那个超时的测试点也过了。
（2）继承一定要注意父类和子类的关系，可以用super来继承父类的方法，也可以重写。
四、改进建议
关于代码的改进，我想说一下7-5 图形继承与多态，这个题，主要把太多的经历放在了主方法中，如何去对数据进行排序等方面去了，明显能感觉到代码的头重脚轻。这样的代码是没有什么效率的的，可以说复用率很低。我想到的改进方法是再写一个类，从而减轻Main类的Main方法的压力，通过再写的这个类，实现将所求面积的种类，个数，以及面积大小的排序。最后再在主函数中打印，从而提高代码的可维护性。
还有关于日期类的聚合，我们已经写了两种完全不同的代码，第五次作业所写的代码，相较于第四次作业写的那个代码，可维护性提高了不少，聚合方式也有了很大的改变，也就是我们所说的可复用性。
图形继承，该题父类功能太单一，仅仅是一个求面积的方法，子类只有和父类相同的功能时，才能实现对应功能。在这种情况下可能使用类的接口时会更好一些，接口在符合规则的前提下，其他的功能子类都可调用到接口中同名的功能方法，接口中的抽象方法都得以实现，且多个无关的类可以实现同一个接口，一个类可以实现多个无关的接口。因为接口的属性和抽象方法默认是必须公开的所以如果有需要保护私有的的属性或者方法时，必须用继承一个类。
五、总结
总的来说，这三次的题目集中我学习到了很多，接触到了很多之前没接触过的知识点，比如：ArrayList的使用，类的多态，类的接口，抽象类的使用...... 也巩固复习了前几次学习过的知识点，比如：排序法，字符串的处理，正则表达式的使用......有学新的东西，也有巩固复习旧的知识，我觉得这是一种很好的学习方式。但其实也对自己又些不太满意，比如题目集四中第一题还没写出来，题目集5中的7-5也没有拿到满分，题目集4（7-3）中的一些缺陷也没有及时找出，而是在题目集5中才恍然大悟，发现自己的错误。由于一些不可预测的原因，没有对其进行足够的测试，还有就是自己没能花足够的时间在这门学科的学习，这些都是我这一阶段所存在的不足。有些时候，题目考的不只是知识点的学习，而是对实际的一些理解，这就需要我们培养自己的思考问题的思维了。比如题目集四中的（7-1）我就是没能够理解导致我没能完成这一道题目。总的来说，这一阶段中有许多好的地方，同时也存在许多的不足，需要我在以后的学习中不断地改正，完善。加强自主学习的能力，在这门学科中投入更多的时间和精力
标签：总结性,题目,int,double,System,value,Blog,return,public 来源： https://www.cnblogs.com/tiaotiao395/p/14726582.html