201621123062《java程序设计》第三周作业总结

1.本周学习总结

初学面向对象，会学习到很多碎片化的概念与知识。尝试学会使用

将这些碎片化的概念、知识点组织起来。请使用工具画出本周学习到的知识点及知识点之间的联系。步骤如下：

1.1写出你认为本周学习中比较重要的知识点关键词，如类、对象、封装等

关键词：包、类、对象、属性、方法、封装性、public、private。

1.2 用思维导图或者Onenote或其他工具将这些关键词组织起来。

2. 书面作业

2.1.以面向对象方式改造数据结构作业'有理数'（重点）

2.1.1 截图你主要代码（需要在程序中出现你的学号和姓名）并粘贴程序的git地址。

主要代码：

public class Yls {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
			System.out.println("201621123062吴雅思");
			Scanner sc = new Scanner(System.in );
		int v1,v2,i,e = 0;
		Rational T1=new Rational();
		Rational T2=new Rational();
		Rational T3=new Rational();
		v1=sc.nextInt();
		v2=sc.nextInt();
			T1.InitRational(T1,v1,v2);
		v1=sc.nextInt();
		v2=sc.nextInt();
			T2.InitRational(T2,v1,v2);
		T3=T3.Add(T1,T2,T3);
		T3.answer(T3);
		T3=T3.Multiply(T1,T2,T3);
		T3.answer(T3);
		i=sc.nextInt();
		e=T1.GetRational(T1,i,e);
			System.out.println(e);
			sc.close();
	}
}

代码地址

2.1.2 对比你的代码与历程的代码，说明面向对象编程与面向过程编程有何区别？

区别:

• 面向过程的（如c语言）主要对程序的执行过程的编写。
• 面向对象（如java语言）主要是对类的编写和应用，注重对象的属性和解决方法。

2.2. 构造函数与初始化块

2.2.1结合PTA-5(构造函数与toString)说明构造函数有什么用？其函数格式有何特征

作用：做PTA的这个题目时，使用了有参和无参构造函数，构造函数用于对象的初始化，并且可以带参数。

特征：构造函数不具有任何类型(不是void)，不返回任何值。

2.2.2 如果一个类不写构造函数，它有构造函数吗？如果一个类中只有带参的构造函数，它有没有不带参数的默认构造函数？

（1）有构造函数，是系统默认有一个无参构造方法，会自动调用默认构造函数

（2）没有，已经有带参的构造函数，系统就会默认使用这个带参的构造函数。

2.2.3 查看String类的源代码，找出3个看得懂的String类的构造函数，并使用自己的话描述这3个构造函数的区别。

三个函数：

public String(char value[]) {

this.value = Arrays.copyOf(value, value.length);

}

public String() {

this.value = "".value;

}

public String(String original) {

this.value = original.value;

this.hash = original.hash;

}

区别：第一个是参数为字符数组的构造函数，第二个是不带参数的构造函数，第三个是参数为String类型的构造函数。

2.2.4 结合PTA(构造函数与初始化块)说明初始化块与构造函数的异同。并说明，初始化块与构造函数谁先执行？初始化块与静态初始化块有何不同，谁先执行？

（1）同：都是对参数进行操作,并且有一个对象就执行一次。

异：初始化块是在构造函数前执行的。

（2）做pta题目时，我把初始化块放在构造函数前面，然后我对比了结对编程舍友的代码，她是放在构造函数后面，然后两个在PTA提交都能过。查找资料发现

初始化块会在构造函数之前执行,跟代码的位置没关系。

（3）静态初始化块先执行。

不同：静态的初始化块，它会在对象装载到系统的时候执行一次，执行完成便销毁，它仅能初始化类变量，而非静态初始化块可以初始化类的实例变量。

2.3代码分析:Math类

2.3.1使用java.lang.Math类的方法时，为什么不需要new出一个Math对象，然后调用该对象上相应的方法？

原因：通过查阅java的API文档，知道了Math类本身不是静态的，但它的方法以及成员变量都是静态的，所以可以用类名.方法来直接访问，也就不用new出一个实例对象来进行访问。

2.3.2 如果new Math()会产生什么错误？尝试阅读Math类源代码，分析原因

错误：在eclipse上敲了Math m=new Math();，发现报错The constructor Math() is not visible

原因：阅读了Math源码，发现:

public final class Math {

    /**
     * Don't let anyone instantiate this class.
     */

意思就是不能被任何人实例化，因此会出现错误。

2.3.3 进一步：你觉得什么样的对象需要new出来才能用，调用什么方法时不必创建相应对象就可以使用？(重点检查)

答：通过Math这个例子，我感觉调用静态的方法时不必创建相应的对象就可以使用，而非静态的对象需要new出来才能用。

2.4重载Overload

2.4.1什么是重载？什么是构造函数重载？怎么才能区分两个重载的方法？

重载:

重载可使函数、运算符等处理不同类型数据，或接受不同个数的参数的一种方法。

构造函数重载：

构造函数具有相同的名字，而参数的个数或参数类型不相同

区分:

通过不同的参数

2.4.2 在java.lang.Math类中举出1个方法重载的例子？

举例：

    public static int round(float a) {
        int intBits = Float.floatToRawIntBits(a);
        int biasedExp = (intBits & FloatConsts.EXP_BIT_MASK)
                >> (FloatConsts.SIGNIFICAND_WIDTH - 1);
        int shift = (FloatConsts.SIGNIFICAND_WIDTH - 2
                + FloatConsts.EXP_BIAS) - biasedExp;
        if ((shift & -32) == 0) { // shift >= 0 && shift < 32
            // a is a finite number such that pow(2,-32) <= ulp(a) < 1
            int r = ((intBits & FloatConsts.SIGNIF_BIT_MASK)
                    | (FloatConsts.SIGNIF_BIT_MASK + 1));
            if (intBits < 0) {
                r = -r;
            }
            // In the comments below each Java expression evaluates to the value
            // the corresponding mathematical expression:
            // (r) evaluates to a / ulp(a)
            // (r >> shift) evaluates to floor(a * 2)
            // ((r >> shift) + 1) evaluates to floor((a + 1/2) * 2)
            // (((r >> shift) + 1) >> 1) evaluates to floor(a + 1/2)
            return ((r >> shift) + 1) >> 1;
        } else {
            // a is either
            // - a finite number with abs(a) < exp(2,FloatConsts.SIGNIFICAND_WIDTH-32) < 1/2
            // - a finite number with ulp(a) >= 1 and hence a is a mathematical integer
            // - an infinity or NaN
            return (int) a;
        }
    }

    /**
     * Returns the closest {@code long} to the argument, with ties
     * rounding to positive infinity.
     *
     * <p>Special cases:
     * <ul><li>If the argument is NaN, the result is 0.
     * <li>If the argument is negative infinity or any value less than or
     * equal to the value of {@code Long.MIN_VALUE}, the result is
     * equal to the value of {@code Long.MIN_VALUE}.
     * <li>If the argument is positive infinity or any value greater than or
     * equal to the value of {@code Long.MAX_VALUE}, the result is
     * equal to the value of {@code Long.MAX_VALUE}.</ul>
     *
     * @param   a   a floating-point value to be rounded to a
     *          {@code long}.
     * @return  the value of the argument rounded to the nearest
     *          {@code long} value.
     * @see     java.lang.Long#MAX_VALUE
     * @see     java.lang.Long#MIN_VALUE
     */
    public static long round(double a) {
        long longBits = Double.doubleToRawLongBits(a);
        long biasedExp = (longBits & DoubleConsts.EXP_BIT_MASK)
                >> (DoubleConsts.SIGNIFICAND_WIDTH - 1);
        long shift = (DoubleConsts.SIGNIFICAND_WIDTH - 2
                + DoubleConsts.EXP_BIAS) - biasedExp;
        if ((shift & -64) == 0) { // shift >= 0 && shift < 64
            // a is a finite number such that pow(2,-64) <= ulp(a) < 1
            long r = ((longBits & DoubleConsts.SIGNIF_BIT_MASK)
                    | (DoubleConsts.SIGNIF_BIT_MASK + 1));
            if (longBits < 0) {
                r = -r;
            }
            // In the comments below each Java expression evaluates to the value
            // the corresponding mathematical expression:
            // (r) evaluates to a / ulp(a)
            // (r >> shift) evaluates to floor(a * 2)
            // ((r >> shift) + 1) evaluates to floor((a + 1/2) * 2)
            // (((r >> shift) + 1) >> 1) evaluates to floor(a + 1/2)
            return ((r >> shift) + 1) >> 1;
        } else {
            // a is either
            // - a finite number with abs(a) < exp(2,DoubleConsts.SIGNIFICAND_WIDTH-64) < 1/2
            // - a finite number with ulp(a) >= 1 and hence a is a mathematical integer
            // - an infinity or NaN
            return (long) a;
        }
    }

2.5代码阅读: final

2.5.1final修饰的变量不能改变，为什么如下代码却可正常运行？

final int[] NUMBS= {1,2,3,4,5}; NUMBS[2] = 1;

原因:final含义是这个变量的引用不能被重新赋值，本题final是限定NUMBS这个变量,但是对象本身的修改不受限制。

2.6 Java8中的时间日期类：编写函数public static boolean isMondayToFriday()

功能：判断今天如果是周一到周五，返回true，返回false。main函数中调用该函数，如果为true则输出“工作日+姓名学号”，否则输出"休息+姓名学号"。

截图：关键代码。

提示：使用LocalDateTime, DayOfWeek类

函数：（本题参考同学代码）

import java.time.DayOfWeek;
import java.time.LocalDateTime;

public class Date {
	public static boolean isMondayToFriday() {
		LocalDateTime datetime=LocalDateTime.now();
		DayOfWeek dayofweek=datetime.getDayOfWeek();
		if(dayofweek.equals("SATURDAY")||dayofweek.equals("SUNDAY"))
			return false;
		return true;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		if(isMondayToFriday()==true)
			System.out.println("工作日 吴雅思 201621123062");
		else
			System.out.println("休息 吴雅思 201621123062");
	}

}

2.7 封装

2.7.1结合PTA(形状)，请用自己的话简单总结一下面向对象中封装是什么意思？有何好处？

意思：封装就是将对象的属性和操作对象的一些方法放在一起。

结合：个人理解在PTA题目中的这段代码，就是一个封装。将圆的属性和一些方法（函数）放在一个类里面。

class Circle{
	private int radius;
	public Circle(int radius) {
		this.radius=radius;
	}
	public int getPerimeter(int radius) {
		double result=2*Math.PI*radius;
		return (int)result;
	}
	public int getArea(int radius) {
		double result=Math.PI*radius*radius;
		return (int)result;
	}
	public String toString() {
		return "Circle [radius=" + radius + "]";
	}

好处：对象不必关心具体的实现，只需要了解公共的使用方法就可以了，且具有安全性，内部的东西不会遭到篡改。

2.7.2 和封装有关的关键字有哪些？

关键字：

• public 表示全局，类内部外部子类都可以访问；
• protected表示受保护的，只有本类或子类或父类中可以访问；
• private表示私有的，只有本类内部可以使用；

2.8 结对编程实践(未完成，0分)

找一个水平相近的同学完成1-2题实验题。开始编程前，可先对内容进行讨论。

写出体验报告，包括以下内容：1.对方姓名。2.所完成的题目。3.感想。4.照片（上次很多同学并未贴照片，请贴上）

1.对方姓名：靳天婷

2.所完成的题目：7-2 jmu-Java-03面向对象基础-02-构造函数与初始化块

3.感想：这道实验题老师上课讲的比较详细，而且和第一题基本一样就是加了初始化块。里面用的很多都是用alt+shitf+s，然后选出对应的自动生成函数。所以我们的基本思路都是一样的，主要就是在初始化块这里。她是把初始化块放在了构造函数后面，当时我查资料说是初始化块在构造函数前执行，于是我以为初始化块得放在前面，讨论了一下，并做了测试，发现是都可以的。感觉自己对概念的理解不清晰。我发现结对编程能够发现更多的可能性，也能对概念掌握的更透彻。

4.照片

3. 码云及PTA

3.1在码云的项目中，依次选择“统计-Commits历史-设置时间段”, 然后搜索并截图

3.2 截图PTA题集完成情况图

3.3 统计本周完成的代码量

周数	行数	新增行数	文件数	新增文件数
1	57	57	5027	5027
2	400	400	10	10
3	508	508	23	13