java菜鸟进阶历程(①)

0.前言

本次博客是关于阶段性java作业（第四次，第五次，第六次大作业）的总结

1.作业过程总结

①第四次作业是关于简单的继承，蒙特卡罗方法求圆周率和水文数据处理；第五次作业是关于图形继承与多态和一元多项式求导；第六次作业是关于图形卡片排序，分组问题（涉及类的继承，多态和接口的应用），还有一道加分题--求素数的算法优化设计。关于这三次作业的知识得迭代情况--主要是考察类的继承，在类的继承得基础上加大难度，比如：对正则表达式的运用，对接口的运用，对优化算法设计的应用。

②通过作业逐步理解面向对象的封装性、继承性与多态性三大技术特性以及对面向对象三大技术特性之间关系的理解

封装:在面向对象的使用过程中经常用到,某些成员禁止的对象的外部进行访问,这种情况下需要对成员进行封装.常用的关键字private。成员属性私有化:private $sex=’值’;成员方法的私有化:private function  方法名()

私有化特征:1.一旦某个成员被私有化(private),那么在对象的外部不能够被修改和访问。2.私有化成员在对象的内部可以使用$this 进行访问。3.声明关键字private 不能够和var 关键字同时使用。在作业中的每个类里都用私有属性，如在class Circle中定义:private double radius

继承的特性:

在面向对象的开发过程中,2个类之间可能存在代码大部分重复的情况,为了解决这种问题,引入继承概念,一个类继承另一个类之后就具备该类的所有成员。父类:被其他类继承的类称之为父类。子类:继承其他类的类成为子类,也叫做派生类。继承的实现方式:class 子类名 extends 父类名。如在这几次作业中，图形继承，先有class shape，然后又有cirle类，就可以用继承class circle extends shape,并在circle类里使用super()方法，继承父类的属性。但在类中具有继承关系的类,子类中可以重载父类中的方法。

多态的特性：对象根据所接收的消息而做出动作。同一消息被不同的对象接受时可产生完全不同的行动，这种现象称为多态性。

③在Java作业中难免会遇到各种各样的问题，如：水文数据处理和一元多项式求导中，需要用到正则表达式，然而我对于正则表达式不是很掌握，所以会查阅资料（看Java菜鸟教程中的正则表达式。附上链接：https://www.runoob.com/java/java-regular-expressions.html）还有一些关于继承的使用，会向同学请教，对于第六次作业接口的问题，属实没弄懂，所以在作业中没有使用接口的方法。

三次作业花费时间比例：每次作业大概都需要三个小时左右

2.OO设计心得

①面向对象设计的基本原则理解（单一职责原则及“开-闭”原则）

单一职责原则：一个对象应该只包含单一的职责，并且该职责被完整地封装在一个类中。 类的职责要单一，不能将太多的职责放在一个类中，不能使一个类太累。单一职责原则是实现高内聚、低耦合的指导方针。我觉得这是面向对象设计的一种魅力，代码看起来很舒服，改bug也很容易。

import java.util.Scanner;
public class Main {
    public static void main (String [] args){    
        Scanner input=new Scanner(System.in);
        String b[]=new String[1000];//类型
        double c[]=new double[1000];//面积
        String name[]=new String[1000];
        int a[]=new int[100],length=0,flag=1;
        double sum1=0,sum2=0,sum3=0,sum4=0,max;
       int num = input.nextInt();        
        while(num==0)
        {
            System.out.println("Wrong Format");    
                System.exit(0);
        }
        while(num != 0)
        {   

            if(num <=0 || num > 4)
            {     
                System.out.println("Wrong Format");    
                System.exit(0);    
                }
            a[length]=num;
            num = input.nextInt(); 
            length++;//总共输入length个有效；
        } 
        for(int j=0;j<length;j++) {
            if(a[j]==0)
            {
                flag=1;
                System.out.println("Wrong Format");  
            }
            if(a[j]==1) {
                double r=input.nextDouble();
                Circle circle=new Circle(r);  
                if(circle.validate()){
                    flag=1;
                    b[j]= "Circle";
                    c[j]=circle.getArea();
                }
            }
            if(a[j]==2){
                double l=input.nextDouble();
                double w=input.nextDouble();
                Rectangle rectangle=new Rectangle(l,w);
                if(rectangle.validate()){
                    flag=1;
                    b[j]= "Rectangle";
                    c[j]=rectangle.getArea();
                }
            }
            if(a[j]==3){
                double s1=input.nextDouble();
                double s2=input.nextDouble();
                double s3=input.nextDouble();
                Triangle triangle = new Triangle(s1,s2,s3);
                if(triangle.validate()){
                    flag=1;
                   b[j]= "Triangle";
                    c[j]=triangle.getArea();
                }
            }
            if(a[j]==4) {
                double t=input.nextDouble();
                double bot=input.nextDouble();
                double h=input.nextDouble();
                Trapezoid trapezoid = new Trapezoid(t,bot,h);
                if(trapezoid.validate()){
                    flag=1;
                    b[j]="Trapezoid";
                    c[j]=trapezoid.getArea();
                }
            }
        }
        if(flag==0)
        System.out.println("Wrong Format");
        if(flag==1){
            System.out.println("The original list:");
            System.out.print("[");
            for(int j=0;j<length;j++) {
                System.out.printf(b[j]+":"+String.format("%.2f",c[j])+" ");
            }
            System.out.print("]");
                    
            System.out.println("
The Separated List:");
            System.out.print("[");
            for(int j=0;j<length;j++) 
            {        
                if(a[j]==1)
                System.out.print(b[j]+":"+String.format("%.2f",c[j])+" ");                
            }
            System.out.print("]");
            
             System.out.print("[");
                for(int j=0;j<length;j++) 
                {        
                    if(a[j]==2)
                    System.out.print(b[j]+":"+String.format("%.2f",c[j])+" ");                
                }
                System.out.print("]");
                
                 System.out.print("[");
                    for(int j=0;j<length;j++) 
                    {        
                        if(a[j]==3)
                        System.out.print(b[j]+":"+String.format("%.2f",c[j])+" ");                
                    }
                    System.out.print("]");
                    
                     System.out.print("[");
                        for(int j=0;j<length;j++) 
                        {        
                            if(a[j]==4)
                            System.out.print(b[j]+":"+String.format("%.2f",c[j])+" ");                
                        }
                        System.out.print("]");
                        
           for(int i=0;i<length;i++)
            {            
                for(int j=0;j<length-1-i;j++)
                {       
                    
                    
                    if(c[j]<c[j+1])
                    {                    
                        double temp=c[j];                    
                        c[j]=c[j+1];                    
                        c[j+1]=temp;
                        String s=b[j];
                        b[j]=b[j+1];
                        b[j+1]=s;
                    }            
                
                }
            }
            System.out.println("
The Separated sorted List:");
             System.out.print("[");
                for(int j=0;j<length;j++) 
                {        
                    if(a[j]==1)
                    System.out.print(b[j]+":"+String.format("%.2f",c[j])+" ");                
                }
                System.out.print("]");
                 System.out.print("[");
                    for(int j=0;j<length;j++) 
                    {        
                        if(a[j]==2)
                        System.out.print(b[j]+":"+String.format("%.2f",c[j])+" ");                
                    }
                    System.out.print("]");
                    System.out.print("[");
                    for(int j=0;j<length;j++) 
                    {        
                        if(a[j]==3)
                        System.out.print(b[j]+":"+String.format("%.2f",c[j])+" ");                
                    }
                    System.out.print("]");
                     System.out.print("[");
                        for(int j=0;j<length;j++) 
                        {        
                            if(a[j]==4)
                            System.out.print(b[j]+":"+String.format("%.2f",c[j])+" ");                
                        }
                        System.out.print("]");
                        
                
                
            
            for(int j=0;j<length;j++)
            {
                if(a[j]==1)
                {
                    sum1+=c[j];
                }
                if(a[j]==2)
                {
                    sum2+=c[j];
                }
                if(a[j]==3)
                {
                    sum3+=c[j];
                }
                if(a[j]==4)
                {
                    sum4+=c[j];
                }
            }
            max=sum1;
            if(sum2>max)
                max=sum2;
            if(sum3>max)
                max=sum3;
            if(sum4>max)
                max=sum4;
            System.out.println("
The max area:"+String.format("%.2f",max));
        }    
    }
}
abstract class Shape{
    public abstract double getArea();
    public abstract boolean validate();
    public abstract String toString ();
}
class Circle extends Shape{
    private double radius;
    public Circle(){

    }
    public Circle(double radius){
        setRadius(radius);
    }
    public void setRadius(double radius){
        this.radius=radius;
    }
    public double getRadius(){
        return this.radius;
    }
    @Override
    public double getArea(){
        return Math.PI*radius*radius;
    }
    @Override
    public boolean validate(){
        if(radius>0)
        return true;
        else
        return false;
    }
    @Override
    public String toString(){
        return null;
    }
}


class Rectangle extends Shape{
    private double length,width;
    public Rectangle(){

    }
    public Rectangle(double length,double width){
        setLength(length);
          setWidth(width);
    }
    public void setWidth(double width){
         this.width=width;       
    }
    public double getWidth(){
         return this.width;
    }
    public void setLength(double length){
        this.length=length;
    }
    public double getLength(){
         return this.length;
    }
    @Override
    public double getArea(){
        return length*width;
    }
    @Override
    public boolean validate(){
        if(length>0&&width>0)
        return true;
        else
        return false;
    }
    @Override
    public String toString(){
        return null;
    }
}
class Triangle extends Shape{ 
    private double side1,side2,side3;
    public Triangle(){ 

    } 
    public Triangle(double side1,double side2,double side3){ 
        setSide1(side1);
        setSide2(side2);
        setSide3(side3);
    } 
    public void setSide1(double side1){
        this.side1=side1;
    }
    public double getSide1(){
        return this.side1;
    }
    public void setSide2(double side2){
        this.side2=side2;
    }
    public double getSide2(){
        return this.side2;
    }
    public void setSide3(double side3){
        this.side3=side3;
    }
    public double getSide3(){
        return this.side3;
    }
    @Override
    public double getArea(){  
        double l=(side1+side2+side3)/2;
        return  Math.sqrt(l*(l-side1)*(l-side2)*(l-side3));      
    }
    @Override
    public boolean validate(){
        if(side1+side2>side3&&side1+side3>side2&&side2+side3>side1)
        return true;
        else 
        return false;
    } 
    @Override                                                            
    public String toString(){
        return null;
    }
}
class Trapezoid extends Shape{ 
    private double topSide,bottomSide,height;
    public Trapezoid(){ 

    } 
    public Trapezoid(double topSide,double bottomSide,double height){ 
        setTopSide(topSide);
        setBottomSide(bottomSide);
        setHeight(height);
    } 
    public void setTopSide(double topSide){
        this.topSide=topSide;
    }
    public double getTopSide(){
        return this.topSide;
    }
    public void setBottomSide(double bottomSide){
        this.bottomSide=bottomSide;
    }
    public double getBottomSide(){
        return this.bottomSide;
    }
    public void setHeight(double height){
        this.height=height;
    }
    public double getHeight(){
        return this.height;
    }
    @Override
    public double getArea(){  
        return  (topSide+bottomSide)*height/2;
    }
    @Override
    public boolean validate(){
        if(topSide>0&&bottomSide>0&&height>0)
        return true;
        else 
        return false;
    } 
    @Override                                                            
    public String toString(){
        return null;
    }
}

注：这就是我不会用接口，然后导致Main类太复杂，改BUG改半天改不出的后果，哭了哭了。。

开-闭原则：开-闭原则则是对于扩展是开放的，对于修改是关闭的。开闭原则是面向对象的可复用设计的第一块基石，是面向对象设计的目标。

我看过一篇博客，对这两个原则分析的很到位，在此附上链接(https://blog.csdn.net/iteye_568/article/details/82610391)

②OO编程思维的理解(Object oriented)

面向对象将事物都看成对象，将具有相同特征的实物看作类。通过对类与对象的继承，封装，多态的实现，完成模拟现实从而解决问题。

③类设计心得

设计类要根据题目的要求，再用继承，封装，多态，接口等方法实现类，注意不要再一个类里放太多的方法，不然可能会使程序出现问题。

3.测试的理解与实践

①代码质量保证了，功能才能稳定，稳定可靠的功能就是最好的宣传。保证代码质量就是程序员练内功，内功扎实，才能在上面构建更多的可能性。但往往在平时作业中可能我们的代码都是有漏洞的，但pta开发环境可能检测不到我们的漏洞，所以在平时写代码的时候，需要严谨的思考。对此，建议大家可以看看有关测试方面的书籍--譬如《谷歌测试之道》，《微软测试之道》，《持续交付》，《测试驱动开发》，《自动化测试》。

②用Junit也可以对程序进行测试(链接：https://blog.csdn.net/qq_42618969/article/details/81082382)

4.课程收获

最大的收获当然是又学到了更多的关于Java的新知识，虽然有些地方还没有完全搞懂，但我会慢慢消化，学好OO设计编程。当然，在收获的同时当然也会又教训，比较大的教训可能就是对Java类理解的不够到位，导致在每次大作业的时候都需要请教同学某个类里的某个方法到底起什么作用。

5.对课程的建议

还是老话，希望老师每次能把上课讲得实例代码发出来，对于我这种啥都不会的小白可是有很好的作用的。