201521123005《java程序设计》第三周学习总结

1. 本周学习总结

初学面向对象，会学习到很多碎片化的概念与知识。使用思维导图将这些碎片化的概念、知识组织起来。使用工具画出本周学习到的知识点。

参考资料:

百度脑图

XMind

2. 书面作业

·Q1 代码阅读

public class Test1 {
    private int i = 1;//这行不能修改
    private static int j = 2;

    public static void main(String[] args) {
        geti();
        Test1getj();
}

    public static void geti() {
        System.out.println(i);
    }

    public static void getj() {
        System.out.println(j);
    }

}

(1)以上代码可否编译通过？哪里会出错?为什么？尝试改正？

   答：编译不能通过。总共有两个地方出错。第一，没有Test1getj()函数可以调用，可以建立一个Test1getj()，或者改成getj();第二，gtti()是被声明为static的成员而i
      不是，可以把代码第二行改成 private static int i=1，或者如果不改i，改函数的话会很麻烦要main(），geti（），getj()这三个都不能是被声明为static的成员。

(2)如果创建3个Test1对象，在内存中有几个i，几个j?

   答： 在内存中有3个i，1个j。因为非static的变量，每个实例都会有一块内存来存储这个变量。staitc 的变量所有实例共享一块内存,如果一个对象数组中其中的某个属
       性大家都是相同的，即可以使用静态。静态一旦创建，生命周期就会从创建开始到该程序结束才会死亡。

·Q2构造函数有什么用？其编写格式是什么？如果一个类不写构造函数，它有构造函数吗？如果一个类中只有带参的构造函数，它有没有不带参数的默认构造函数？

    答：1.构造函数的作用：
       （1）创建对象时初始化对象,即为对象成员变量赋初始值，避免没有初始化函数带来数据的不安全；
       （2）当参数类型不同或个数不同，可以定义多个构造函数，这样就不用苦恼方法名称设计，可以用一致的名称来调用类似功能的方法；
       （3）它没有返回值，也不能用void来修饰.这就保证了它不仅什么也不用自动返回,而且根本不能有任何选择.而其他方法都有返回值.即使是void返回值,尽管方法体本
           身不会自动返回什么,但仍然可以让它返回一些东西,而这些东西可能是不安全的。

   2.编写格式：
     （1）注意：
          a.构造方法的方法名必须与类名相同。
          b.构造方法没有返回类型，也不能定义为void，不能有return 语句,在方法名前面不声明方法类型。
          c.构造方法的主要作用是完成对象的初始化工作，它能够把定义对象时的参数传给对象的域。
          d.一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构造器，这个构造器不执行任何代码。
          e.构造方法可以重载，以参数的个数，类型，或排列顺序区分。
     (2)方法：
        class 类名称 {
              访问修饰符 类名称() {
                    初始化操作;
                }
        }
       构造函数的重载，即实现构造函数的重载:
       class 类名称 {
              访问修饰符 类名称() {
                    初始化操作1;
                }
                访问修饰符 类名称( 参数类型1 参数1......) {
                    初始化操作2;
                }  访问修饰符 类名称( 参数类型2 参数1......) {
                     初始化操作3;
                }
        }

       3.如果一个类不写构造函数，它有构造函数，因为一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构造
         器，没有参数的构造函数被称为默认构造函数，这个构造器不执行任何代码。如果非静态类的类体中没有声明构造函数，类将自动提供一个默认构造函数，并将类成
         员初始化为默认值。

      4.定义了一个有参的构造函数，为了保证正确性，那么系统不再提供默认构造函数，此时用户如果还要使用无参构造函数，则需要自己重载构造函数。

·Q3使用java.lang.Math类的函数时，为什么不需要new？如果new Math()会产生什么错误？

    答：
       1.Math并非一个静态类，但是它的方法以及成员变量都是静态的。根据静态的定义，如果一个方法是静态的，它是属于整个类的，可以用类名.方法来直接访问，也就
         不用new出一个实例对象来进行访问了。
         可以看一下Math的源代码，拿sin的方法来看一下public static double sin(double a)，显示方法是静态的；

   2.用Eclipse编译一下，结果报错，如下图,可见Math类不需用new Math()去建立一个对象来访问，也不让你建立。

·Q4什么是重载？什么是构造函数重载？在java.lang.Math类中举出函数重载的例子？怎么才能区分两个重载函数？

    答：1.百度一下，重载，简单说，就是函数或者方法有相同的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方
          法。我觉得重载就像一个榨汁机，根据你放了什么水果就榨出什么果汁，但是无论榨的是什么水果，方法都是一样的。（不知这个比喻是否恰当）
          重载条件：
                   函数名必须相同，返回值可以相同，也可以不同，但是特征标必须不同。是函数名来确定函数的不同，是特征标是函数可以重载。编译器首先选在函数
                   名，然后再根据特征标在众多重载的函数中找到合适的
          例：
            public class Override{
                    void add(){
                }
                void add(int i){ //重载了。
                }
                void add(int i,double s) //重载了。
            }
        重载的价值在于它允许相关的方法可以使用同一个名字来访问。

    2.构造函数重载：
      a.Java中构造函数重载和方法重载很相似。可以为一个类创建多个构造函数。每一个构造函数必须有它自己唯一的参数列表。
      b.构造函数重载就是根据传入的参数不同设置多个构造函数，来供实例化时调用。
      c.构造函数重载相当于同一个方法，不同的实现方式。即一个类当中，可定义多个同名的方法，只要他们的参数的个数、参数类型、亦或是仅仅参数的顺序不同。
      d.这样，就给使用这个类创建对象时，有了多样化的创建方式
      例;下面是对构造函数的重载
       public Student (String s){
        }
       public Student(int t){
        }
        //参数类型不同

       public Student(String s,int t){
        }
       public Student(int t,String s){
        }
      //参数的顺序不同

        3.区分两个重载函数的方法：参数的不同（类型，个数，顺序）

·Q5final修饰的变量不能改变，为什么如下代码可以正常运行？

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

　NUMBS[2] = 1;

    答：当使用final修饰基本类型变量时，不能对基本类型变量重新赋值，因此基本类型变量不能被改变。但对于引用类型的变量而言，它保存的仅仅是一个引用，final只
        保证这个引用所引用的地址不会改变，即一直引用同一个对象，但这个对象完全可以发生改变。即修饰对象，值可变,引用不变。相当于把数据放在一个盒子里，你用
        绳子牵着盒子。你牵着绳子这个事实不能改变，但是你盒子里的东西可以改变。

·Q6阅读代码EmployeeTest.java，回答：

·6.1.为什么其属性均为private?这样设计有什么好处?

    答：首先private成员具有良好的封装性，如果修改服务代码的内部实现也不需要改动客户代码。（这个是百度的，虽然不是很理解，但是从这可以看出private的
        便捷性）。其次private是访问权限修饰符，用于控制外界对类内部成员的访问，表明对象成员是完全私有的，不容许外界的任何访问，即只有自己类可以访问
        别人都不可以访问。而且Java的访问权限从小到大是： private-> default->  protected-> public，从这方面来看用private更安全，这样就不能让对象直接
        通过【 对象.属性名 】来使用和修改，而是通过set属性名,get属性名。

·6.2.为Employee类增加一个无参构造函数，调用其有参构造函数，设置name为雇员1, salary为3000, hireDay的年月日为2017年3月5日。(粘贴代码)

    import java.util.Date;
    import java.util.GregorianCalendar;
    class Employee
    {
         private String name;
         private double salary;
         private Date hireDay;

         public Employee()
         {
         }
         public Employee(String name,double salary,int year,int month,int day)
         {
	         this.name=name;
	         this.salary=salary;
	         GregorianCalendar calendar = new GregorianCalendar(year, month-1, day);
                     hireDay = calendar.getTime();
         }
        public String getName() {
	        return name;
        }
        public void setName(String name) {
	        this.name = name;
        }
        public double getSalary() {
	        return salary;
        }
        public void setSalary(double salary) {
	         this.salary=salary;
        }
        public Date getHireDay() {
	        return hireDay;
        }
        public void setHireDay(int year,int month,int day) {
	        GregorianCalendar calendar = new GregorianCalendar(year, month-1, day);
            hireDay = calendar.getTime();
        }

    }
    public class Main {

        public static void main(String[] args) {
	Employee moumou = new Employee("雇员1",3000,2017, 3, 5);
           System.out.println("name=" + moumou.getName() + ",salary=" + moumou.getSalary() + ",hireDay="+ moumou.getHireDay());
         }
}

里面有用到GregorianCalendar类的使用，特别注意：参数中的月份是从0开始，即0对应1月，2对应3月。

具体用法可以看：http://blog.csdn.net/pangjiawei19/article/details/8624089

·6.3.为Employee类再增加一个有参构造函数，参数只有name与salary，hideDay为当前日期。(粘贴代码)

    public Employee(String name, double salary){
     this.name=name;
     this.salary=salary;
     Calendar Day=Calendar.getInstance();
     int year=Day.get(GregorianCalendar.YEAR);//得到当前年份
     int month=Day.get(GregorianCalendar.MONTH);//得到当前月份
     int day=Day.get(GregorianCalendar.DAY_OF_MONTH);//得到当前是几日
     GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day);
     // GregorianCalendar uses 0 for January
     hireDay = calendar.getTime();
    }
    public class Main {
    public static void main(String[] args) {
	    // TODO Auto-generated method stub
            Employee moumou = new Employee("雇员1",3000,2017, 3, 5);
               System.out.println("name=" + moumou.getName() + ",salary=" + moumou.getSalary() + ",hireDay="+ moumou.getHireDay());
               Employee moumou1 = new Employee("雇员1",3000);
              System.out.println("name=" + moumou1.getName() + ",salary=" + moumou1.getSalary() + ",hireDay="+ moumou1.getHireDay());
     }
}

·Q7编写函数public static boolean isMondayToFriday()

功能：判断今天如果是周一到周五，直接输出如“上班时间”并返回true，否则输出“休息时间”。

提示：使用LocalDateTime, DayOfWeek

参考资料：

JAVA 8：健壮、易用的时间-日期API - ImportNew.pdf

Java8DateTimeTest.java

    LocalDateTime提供时间和日期的信息，它是不可变类且线程安全的
    星期日为一周的第一天	SUN	MON	TUE	WED	THU	FRI	SAT
    DAY_OF_WEEK返回值	1	2	3	4	5	6	7
    星期一为一周的第一天	MON	TUE	WED	THU	FRI	SAT	SUN
    DAY_OF_WEEK返回值	1	2	3	4	5	6	7

    import java.time.LocalDateTime;
    public class DateTimeDemonstration {
    public static boolean isMondayToFriday() {
        LocalDateTime localDateTime = LocalDateTime.now();
        int day = localDateTime.getDayOfWeek().getValue();
        if (day >= 1 && day <= 5) {
            System.out.println("上班时间");
            return true;
        }
        System.out.println("休息时间");
        return false;
    }
    }

·Q8Runnable Jar(可选)

我们以前编写的程序，必须打开Eclipse或者将相应的.class文件拷贝出来在命令行下执行相应命令才能运行，如果.class文件较多且类文件中有包名，需要将完整的目录结构及文件拷贝出来，才能运行。现在希望将Eclipse项目中的Java文件打打成一个可运行的jar包，在命令行直接运行。改造题目7，使其从命令行接收参数，参数为年-月-日，将项目打成jar包，然后在命令行通过java -jar运行，并截图。参考文件如下：

Eclipse生成Runnable jar

3. 码云代码提交记录

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

4. PTA实验

题目集：jmu-Java-03-面向对象1-基础-封装继承 中的编程（5-1, 5-2, 5-3）

    5-1:这道题目，我还开始做的时候，老师就有教如何做，基本该注意的问题都说了，所以没遇到太大问题。但是从这道题，我学到了如何编写有参数和无参数的函数，
        如何定义一个类以及toString函数。
    5-2：这道题做得比较久。虽然是在5-1的基础上再多加一个初始化块。一开始真心不懂题目的意思，搞了很多弯路。看到输出id值有变，还以为是什么从键盘输入不在屏
        幕显示这样搞出来的，然后百度一下，没找到这种方法，后来问了隔壁宿舍，她说是自己直接输出，我就去找有关初始化的来看。
        class Person{
        private String name;
        private int age;
	    private boolean gender;
	    private static int nextId;
	    private int id;
	    {
		    id=nextId;
		    nextId++;
		    System.out.println("This is initialization block, id is " + Integer.toString(id));
	    }
        }
       关键是要弄一个nextId，并且是static,这样才能保证nextId保存上一次的值不被改变。
    5-3：这道题做得很顺，没什么问题。在写public int getPerimeter()函数时，它返回值是int型，而Math.PI返回值是double型。你写完会发现有错。但是Eclipse真的很
        方便，它就建议你add cast to "int",你点一下就可以直接帮你改正。它就把类型强制转换。