第二次博客作业(4-6题目集)

                     前言

通过这接下来的三次题目及来看，应该说是由难到易，考察的知识点也是最近新学的，比如继承与多态，抽象的类与接口，还考了几道关于正则表达式的用法的题，老师的目的也很明确，就是让我们复习巩固之前所学的内容，题量并不大，而是非常基础，我觉得这样的效果更好，能够增加学生们的自信心，毕竟才刚学，没必要整的太过高深，这样的效果反倒更好。

            设计与分析

（1）我们先来分析这两道类似的题目，根据它们的类图我们不难看出

 

 

 

 

 

 

一个是通过主函数main,分别再去设计几个类，由dateutil类来调用day,day类再来调用month，month再year;而另一个则是从dateutil直接分出三个分别为year,month,day的类，它们之间并不相互影响。

因为聚合可以维护代码的可重用性，打个比方，为了让学生、学院地址和工作人员都具有地址，现在，我们不需要一次又一次地使用相同的代码；我们只需要在定义每个类时引用Address类就行。

 

 

 

可以看出我的复杂度有些偏高了，仍需要改进。

因此，我们可以通过使用聚合关系来提高代码的可重用性。

相比较而言，第二个更能体现出代码的可重用性。

（2）从题目集四的7-3来看，运用的便是继承等方面的知识，继承和习惯性说法不同，子类并不是父类的一个子集，而且一个子类通常比它的父类包含更多的信息和方法。父类中的私有数据域在该类之外是不可访问的。所以我们便知道不能在子类中直接使用。但是，如果父类中定义了公共的访问器，那么可以通过这些公共发的访问器访问他们。也并不是所有的is-a关系都用继承来建模。继承是用来“是一种”关系建模的。不要仅，仅为了重用方法这个原因而盲目的继用特性。因此，一个父类和它的子类之间必须存在“是一种”关系。Java中是不允许多重继承的。一个Java类只可能直接继承一个父类。也称单一继承。

 

 

 

 

 

 

题目集六的5，6题，考察的是对多态还有接口方面的问题，多态意味着父类型的变量可以引用子类型的对象，多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作。   

多态的转型分为向上转型和向下转型两种

向上转型：多态本身就是向上转型过的过程

 使用格式如下

父类类型 变量名=new 子类类型();

 

当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作。

向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型

 使用格式如下

子类类型 变量名=（子类类型） 父类类型的变量；当要使用子类特有功能时使用

显而易见，这两道题用的就是这种方法。

 

 

 

这里的复杂度还是有点高，仍需要改进

 

接口在许多方面和抽象类很相似，但目的都是指明相关或者不相关类的对象的共同行为。使用了适当的接口，可以知名这些对象是可以比较的，可克隆的。

（3）关于正则表达式的用法，网络上有非常多的教学，我领略了不少，其中就包括如下(验证输入的Email，qq等，)

public static void main(String[] args) {

  // 要验证的字符串

 String str = "service@xsoftlab.net";

    // 邮箱验证规则

    String regEx = "[a-zA-Z_]{1,}[0-9]{0,}@(([a-zA-z0-9]-*){1,}\\.){1,3}[a-zA-z\\-]{1,}";

    // 编译正则表达式

    Pattern pattern = Pattern.compile(regEx);

    // 忽略大小写的写法

    // Pattern pat = Pattern.compile(regEx, Pattern.CASE_INSENSITIVE);

    Matcher matcher = pattern.matcher(str);

    // 字符串是否与正则表达式相匹配

    boolean rs = matcher.matches();

    System.out.println(rs);

}

 

 

 

 

 

 

 

 

 

 

包括验证码等等的校验

 

 

在字符串中查询字符或字符串

public static void main(String[] args) {

    // 要验证的字符串

    String str = "baike.xsoftlab.net";

    // 正则表达式规则

    String regEx = "baike.*";

    // 编译正则表达式

    Pattern pattern = Pattern.compile(regEx);

    // 忽略大小写的写法

    // Pattern pat = Pattern.compile(regEx, Pattern.CASE_INSENSITIVE);

    Matcher matcher = pattern.matcher(str);

    // 查找字符串中是否有匹配正则表达式的字符/字符串

    boolean rs = matcher.find();

    System.out.println(rs);

}

正则表达式是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为“元字符”）。模式描述在搜索文本时要匹配的一个或多个字符串。

Java的正则表达式有判断，分割和替换等功能。

public boolean matches(String regex)

public String[] split(String regex)

public String replaceAll(String regex,String replacement)

（4）针对题目集五（7-4）的结构分析，我们首先知道关键字包括如下

 

 

 

 在这里的基础上，运用了正则表达式的查找方法

          

 

 

从中筛选出符合要求的字符串及关键字

 

 

 

再通过筛选，将注释中和字符串中的的关键字排除在外，筛选出符合条件的关键字并输出。

 

 

 

                采坑心得

首先我想要说的便是正则表达式，正则表达式的掌握和运用对我们来说，非常重要。正则表达式（Regular Expression）是用于描述一组字符串特征的模式，用来匹配特定的字符串。通过特殊字符+普通字符来进行模式描述，从而达到文本匹配目的工具。它可以进行验证查找和替换的基本操作，例如我们进行qq号校验

import java.util.Scanner;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

 

public class Main {

 

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner cy=new Scanner(System.in);

String qq =cy.nextLine();

String regex = "[1-9][0-9]{4,14}";//第一位1-9之间的数字，第二位0-9之间的数字，数字范围4-14个之间

boolean flag = qq.matches(regex);

if(flag) {

System.out.print("你输入的QQ号验证成功");

}else {

System.out.print("你输入的QQ号验证失败");

 

}

 

}

}

 

 

String regex="(2020)((1[1-7])|(7[1-3])|(8[1-2]))(([0][1-9])|([1-3][0-9])|(40))";//还有这里，我之前一直写，却总是报错，原因如下，一是因为题意理解的不正确，二是正则表达式的使用还是不熟练导致了半天也没有更改成功。所以要切记要多加练习，方可立于不败之地。

 

最近学习的继承与多态，静态方法只有在可访问时才能重写。如果父类中定义的静态方法在子类中重新定义，那么父类中的定义方法将被隐藏。

Java中的每个类都继承自java.lang.Object类。如果一个类在定义时没有指定继承关系，那么它的父类就是Object。

如果一个方法的参数类型是父类，而一向该方法的参数传递任何子类的对象，这便是我对多态的理解。

一个类定义一个类型。子类定义为子类型，父类定义为父类型。

像题目集四的第三题，运用的就是这一方面的知识。

  class Shape{    

public Shape(){

       System.out.println("Constructing Shape");

}

public double getArea(){

   return 0.0;

}

}

 

class Circle extends Shape{

public Circle(){

       System.out.println("Constructing Circle");

}

 

private double radius;

public void setRadius(double radius){

this.radius = radius;

}

 

public double getRadius() {

return radius;

}

 

@Override

public double getArea() {

// TODO Auto-generated method stub

return Math.PI*radius*radius;

}

 

}

    class Rectangle extends Shape{

public Rectangle() {

       System.out.println("Constructing Rectangle");

}

private double length;

private double width;

 

public void setLength(double length) {

this.length = length;

}

public double getLength(){

return length;

}

 

public void setWidth(double width){

this.width = width;

}

 

public double getWidth(){

return width;

}

@Override

public double getArea() {

// TODO Auto-generated method stub

return length*width;

}

 

}

class Ball extends Circle{

public Ball(){

       System.out.println("Constructing Ball");

}

 

@Override

public double getArea(){

// TODO Auto-generated method stub

return 4.0*super.getArea();

}

public double getVolume(){

double r1=getRadius();

return 4.0/3.0*Math.PI*r1*r1*r1;

}

 

}

 

class Box extends Rectangle{

public Box(){

       System.out.println("Constructing Box");

}

private double height;

public double getHeight(){

return height;

}

public void setHeight(double height){

this.height = height;

}

public double getVolume(){

return height*super.getArea();

}

@Override

public double getArea(){

// TODO Auto-generated method stub

double length2=getLength();

double width2=getWidth();

 

return (length2*width2+width2*height+length2*height)*2;

}

 

 

}

这里就充分体现了继承这一特性。可以使用final修饰符来表明一个类是最终类，是不能被继承的，也可以表明一个方法是最终的，是不能被重写的。

 

我们再说说多态，多态意味着父类型的变量可以引用自类型的对象。我们创建一个角色为父类对象的引用而指向子类，那么该角色拥有父类，也就是拥有所有属性和行为，同时它有该角色自己的行为即函数方法（简单来说就是技能技能）。多态的优势就体现出来了，当我们需要创建大量的类时，他们可能都有基类里通用的函数方法，但是每个角色又不尽相同，那么不同之处我们就可以用多态来实现解决，既节省了大量代码和时间，同时又符合面向对象的思想。这就是我在学习过程中对多态的理解，举个例子

Public class PolymorphismDemo{

public static void main(String[] args){
// Display circle and rectangle properties
displayObject(new Circle(1, "red”, false));
display0bject(new Rectangle(1, 1, "black", true))；
/*Display geometric object properties */
public static void disp1ay0bject(GeometricObject object){

System.out.print1n(“Created on” + object.getDateCreated()+”. Color is "+ object.getColor())；

}

}

这里displayObject具有GeometricObject类型的参数。可以通过传递任何一个GeometricObject 的实例  。我们在new Circle和new Rectangle来调用displayObject。使用父类对象的地方都可以使用子类的对象。

有的时候，我们要防止继承和重写，在在这种情况下，使用final修饰符表明一个类是最终类，是不能作为父类的。我们知道Math类就是一个最终类。像String.StringBuilder和StringBuffer类以及所有基本数据类型的包装类也都是最终类。

但是我们一定要注意的是修饰符 public、protected、private、static、abstract以及final可以用在类
和类的成员(数据和方法)上，只有final修饰符还可以用在方法中的局部变量上。方法内的局部变量就是常量。

例如

Public class Test{

Public final void m(){

}

}

这些便是我觉得需要注意的地方。

    改进建议

在题目集六的倒数第二道题中，在探究三角形属性非法这一点，我觉得我用的方法就不是很好。我在网上看到的方法就非常好，巧妙的运用数组排序来解决，我就觉得比我的要简单并且要高大上许多，看截图如下

 

 

 

 

 

 

 

显而易见，我用的是简单粗暴一点，用了最通俗易懂的if语句，但是用他们的话，圈复杂度会非常的高，然而如果用第二个图的方法的话，就会方便精妙很多。所以给我的一点提示就是要尽量少用或不用if。我觉得这边是我所需要提高的地方。

 

 

 

 

 

                  总结

对本阶段三次题目集的综合性总结，我学到了封装，继承，多态和接口等方面相关的知识，也复习了一下正则表达式。可以从现有的类定义新的类，这称为类的继承。新类称为子类或继承类，现有的类称为超类、父类或基类。
又知道构造方法用来构造类的实例。不同于属性和方法，子类不会继承父类的构造方法。它们只能用关键字super从子类的构造方法中调用。
构造方法可以调用重载的构造方法或其父类的构造方法。这种调用必须是构造方法的第一条语句。如果没有显式地调用它们中的任何一个，编译器就会把super()作为构造方法的第一条语句，它调用的是父类的无参构造方法。
如果你想为了重写一个方法，必须使用与它的父类中的方法一样的签名、一样或者兼容的返回类型来定义子类中的方法。

在多态中，子类可以调用父类中的所有方法。

多态主要体现为重载和重写。

相同的行为不同的实现方式。多态主要应用为多态参数和多态集合。

在最后一次题目集的最后一题使用的便是接口，接口可以看作是抽象类的特例。抽象类有抽象方法，也有具体方法，但接口只能有抽象方法，不能有具体方法。

接口与抽象类的区别就是抽象类需要被继承，而且只能单继承。 接口需要被实现，而且可以多实现。但是我所了解的也仅仅只是皮毛而已，要想完全理解透彻，我们还需要去不断地学习和不断的练习，正所谓熟能生巧，愿意多花出时间和精力，就能收获不一样的理解。但是我对数组和Array list之间的异同还是不太明确，对列表的创建非常生疏，希望自己可以多加练习，把它掌握于心。Java是一门非常难的学科，希望自己可以努力攻克拿下它。

对于教师的意见就是我觉得老师应该多多和学生互动，这样可以调动学生们的积极心，也防止会出现课上无活力氛围的感觉，还有就是我觉得老师应该多多休息，我觉得老师真的挺忙的，有的时候竟然还要工作到凌晨2点，就希望老师能多多注意休息吧。

对于老师的教学方式，我很满意，没什么改进的意见，希望老师有更好更有趣的教学方法可以带动学生的积极性。其他就没什么了。