20172327 2017-2018-2 《程序设计与数据结构》第七周学习总结

学号 2017-2018-2 《程序设计与数据结构》第七周学习总结

教材学习内容总结

- 创建子类：

1.编写类是定义一组类似的对象；类建立了对象的特征和行为，但并没有为声明的变量预留内存空间（除非所声明的变量是静态的）；类是一种设计，而对象是该设计的具体实现。
2.继承就是从现有类派生出新类的过程，目的是复用现有软件，在“子类”和“父类”之间建立一种“是”关系。
3.子类的实例化并不依赖于父类的实例化。继承具有单项性，父类不能引用子类内部声明的变量和方法。
4.父类的公共方法或变量可以在子类通过名称访问，或者通过子类对象访问；而父亲的私有方法或变量不能在子类中访问，或通过子类对象访问。
5.当一个变量或方法声明为protected可见性时，子类就可以引用它，并且使父类保持了一定的封装性。
6.可见性：protected > public
封装性：protected < private
7.构造方法不能被继承！
8.super引用的用处之一是调用父类方法。一般情况下，构造方法的第一行应该用super引用调用父类构造方法。如果不存在这样的调用，则Java会自动在构造方法的开始处产生一行super（）调用。这种做法可以确保在子类构造方法执行之前，父类构造方法会先初始化自己的变量。用super引用调用父类构造方法的操作只能在子类中执行，并且必须是第一行执行。

9.Java的继承方法称为单继承，即子类只能有唯一的父类。一些面向对象语言允许子类有多个父类，这种方法称为多继承，对于需要两种类描述的对象时是有用的。在Java中依赖接口提供多继承的最好特性而不会增加歧义性。

- 重写方法：

1.当子类和父类有相同的方法和签名时，子类方法将重写父类方法，子类方法优先。重写的需求常常发生继承的情况中。
2.可用final修饰符定义一个方法，子类将不能重写final方法。
3.子类可以定义与父类同名的变量，应该注意重新声明一个变量和给一个继承变量赋值的区别。如果在一个子类中声明一个同名变量，则该变量称为影子变量。

- 类层次结构：

1.从一个父类派生出的子类，还可以是它自己子类的父类，并且多个子类可以从一个父类派生。因此，继承关系常发展成为一个类层次结构。
2.同一个父类的两个子类，成为同胞。尽管同胞类共享它们共同的父类传下来的特征，但是二者没有继承关系，因为不会用其中一个类派生另一个类。
3.应当合理地将类的公共特征保持在尽可能高的类层级上。
4.在Java中，所有的类归根到底都是由Object类派生。如果一个类的定义中没有用extends子句显式地从另一个类中派生自己，则将作为默认处理，自动从Object类派生。
5.Object类定义在Java标准类库的java.lang包中。
6.抽象类通常含有一个或多个尚未定义（没有实现代码）的抽象方法，不能被实例化。包含一个或多个抽象方法的类必须被声明为抽象的。抽象类在类层次结构中充当占位符。
7.由抽象类派生出来的子类必须重写所有父类的抽象方法，否则该子类仍然是抽象类。
8.继承的概念可以应用到接口，以便由一个接口派生另一个接口。类的继承与接口的继承不能重叠，即接口不能用于派生新类，类不能用于派生接口。仅当一个类设计为实现一个接口时，这个实现类和接口之间才有交互。。

- 可见性：

1.父类的私有成员也被子类继承，虽不能以成员名直接地访问这些私有成员，但可以间接地访问。

- 类间继承关系地设计：

1.软件设计中必须特别精心地研究和设计类间继承关系地参差结构。
2.final方法常用于保证该方法能在所有的子类中得到使用。final修饰符也可以作用于整个类。final类不能再用于派生新类。

教材学习中的问题和解决过程

• 问题1：权限修饰符有哪些，分别有什么作用？
  
• 问题1解决方案：

1: 什么是权限修饰符，他有什么作用，为什么需要他；

一个Java应用有很多类，但是有些类，并不希望被其他类使用。每个类中都有数据成员和方法成员，但是并不是每个数据和方法，都允许在其他类中调用。如何能做到访问控制呢？就需要使用访问权限修饰符。

1.权限修饰符就是用于控制被修饰变量、方法、类的可见范围.也就是其作用范围；

2：java中权限修饰符包括4种：

1.公共类型 public ； 2.public可以修饰类，成员变量，构造方法，方法成员。 3.被public修饰的成员，可以在任何一个类中被调用，不管同包或不同包， 4.是权限最大的一个修饰符

1.私有类型 private；
2.可以修饰成员变量，构造方法，成员方法，不能修饰类（此处指外部类，不考虑内部类）。
3.被private修饰的成员，只能在定义它们的类中使用，在其他类中不能调用。

1.默认类型 default；
2.可用于修饰类，成员变量，构造方法，方法，都能够使用默认权限，即不写任何关键字。
3.默认权限即同包权限，同包权限的元素只能在定义它们的类中，以及同包的类中被调用。

1.保护类型 protect；
2.可以修饰数据成员，构造方法，方法成员，不能修饰类（此处指外部类，不考虑内部类）。
3.被protected修饰的成员，能在定义它们的类中，同包的类中被调用。
4.如果有不同包的类想调用它们，那么这个类必须是定义它们的类的子类。

3: 关于权限修饰符还要注意几个问题；

1.并不是每个修饰符都可以修饰类（指外部类），只有public和default可以。
2.所有修饰符都可以修饰数据成员，方法成员，构造方法。
3.为了代码安全起见，修饰符不要尽量使用权限大的，而是适用即可。比如，数据成员，如果没有特殊需要，尽可能用private。加强封装性；
4.修饰符修饰的是“被访问”的权限。

• 问题2：this和super引用有啥不同：
  
• 问题2解决方案：

this

this是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指针。 this的用法在java中大体可以分为3种：

1.普通的直接引用
这种就不用讲了，this相当于是指向当前对象本身。
2.形参与成员名字重名，用this来区分.
3.引用构造函数this（参数）：
调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）。

super

super可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。 super也有三种用法：

1.普通的直接引用
与this类似，super相当于是指向当前对象的父类，这样就可以用super.xxx来引用父类的成员。
2.子类中的成员变量或方法与父类中的成员变量或方法同名
3.引用构造函数
super（参数）：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。

super和this的异同：

super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）
this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）

super:　它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）

this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）

调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。

super()和this()类似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它方法。

super()和this()均需放在构造方法内第一行。

尽管可以用this调用一个构造器，但却不能调用两个。

this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。

this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。

从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

• 问题3：Java语言的设计者为啥明确决定不支持多继承？
  
• 问题3解决方案：

James Gosling在1995年2月发表了一篇名为”Java概览”的Java白皮书，文章解释了Java不支持多重继承的原因。

Java去除了一些C++中很少用、而且被经常误解而错用的功能，如操作符的重载(operator overloading)(尽管Java仍旧保留方法的重载)，多重继承(multiple inheritance)，以及广泛的自动强迫同型(extensive automatic coercions)。

我想在这里分享一下James Gosling对于Java的定义。

Java: 一种简单的，面向对象的，分布式的，解释型的（译者注：Java既不是纯解释型也不是纯编译型的语言），健壮的，安全的，架构中立的，可移植的，高性能的，支持多线程的，动态语言。

看看定义的美妙之处吧。现代程序语言应该有这样的特性。我们看到，定义第一个特性是什么？是简单。

为了强化简单这个特点，这就是我们去除多重继承的原因。下面来看个例子，多重继承的菱形继承问题。

有两个类B和C继承自A。假设B和C都继承了A的方法并且进行了覆盖，编写了自己的实现。假设D通过多重继承继承了B和C，那么D应该继承B和C的重载方法，那么它应该继承哪个的呢？是B的还是C的呢？

C++中经常会掉入这个陷阱，虽然它也提出了替代的方法来解决这个问题。我们在Java中就不会出现这个问题。就算两个接口拥有同样的方法，实现的类只会有一个方法，这个方法由实现的类编写。动态的加载类会让多重继承的实现变得困难。

代码调试中的问题和解决过程

• 问题1：在做pp9.1时，遇到到了下面这个问题
  

• 问题1解决方案：这是我对Coin类完全没改造成的，在Coin类中，我们应该将face的修饰符改为protected。

• 问题2：在做pp9.1时，我在测试类中选择创建一个大小为5的数组，但我定义时，只定义了三个，所以最后运行时，无法将sum值算出来。
  
  

• 问题2解决方案：前面一个问题改一下顺序就可以，后面一个问题我又设了一个变量b，把计算过程分开才可以。

上周考试错题总结

• 第一题：In Java, arrays are
  A .primitive data types
  B .objects
  C .interfaces
  D .primitive data types if the type stored in the array is a primitive data type and objects if the type stored in the array is an object
  E .Strings

• 分析：在书的第245页，有说在Java中，数组是必须实例化的对象。

• 第二题：The "off-by-one" error associated with arrays arises because
  A .the first array index is 0 and programmers may start at index 1, or may use a loop that goes one index too far
  B .the last array index is at length + 1 and loops may only iterate to length, missing one
  C .the last array element ends at length - 1 and loops may go one too far
  D .programmers write a loop that goes from 0 to length - 1 whereas the array actually goes from 1 to length
  E .none of the above, the "off-by-one" error has nothing to do with arrays

• 分析：索引值必须大于等于0并且小于数组的元素个数。如果数组中有X个元素，则索引值是0~X-1.

• 第三题：If an int array is passed as a parameter to a method, which of the following would adequately define the parameter list for the method header?
  A .(int[ ])
  B .(int a[ ])
  C .(int[ ] a)
  D .(int a)
  E .(a[ ])

• 分析：参数被定义为变量最初被声明为类型参数名称。这里，类型为int[]，参数为a。

• 第四题：Assume that BankAccount is a predefined class and that the declaration BankAccount[ ] firstEmpireBank; has already been performed. Then the following instruction reserves memory space for
  firstEmpireBank = new BankAccount[1000];
  A .a reference variable to the memory that stores all 1000 BankAccount entries
  B .1000 reference variables, each of which point to a single BankAccount entry
  C .a single BankAccount entry
  D .1000 BankAccount entries
  E .1000 reference variables and 1000 BankAccount entries

• 分析：第一次银行帐户;为firstentity银行保留内存空间，它本身是指向BankAccount[]对象的引用变量。第一次银行账户=新银行账户[1000];实例化BankAccount[]对象为1000个BankAccount对象。

• 第五题：Given the following declarations, which of the following variables are arrays?
  int[ ] a, b;
  int c, d[ ];
  A .a
  B .a and b
  C .a and d
  uD .a, b and d
  E .a, b, c and d

• 分析：第一个声明声明a和b都是int数组。第二个声明声明c和d是ints，但对于d，一个int数组。a b和d都是int数组。

• 第六题If a and b are both int arrays, then a = b; will
  A .create an alias
  B .copy all elements of b into a
  C .copy the 0th element of b into the 0th element of a
  D .return true if each corresponding element of b is equal to each corresponding element of a (that is, a[0] is equal to b[0], a[1] is equal to b[1] and so forth) and return false otherwise
  E .return true if a and b are aliases and return false otherwise

• 分析：这样使得两个数组是相同的，所以a和b所引用的数组是同一个，所以一个称为另一个的别名。

• 第七题：A Java main method uses the parameter (String[ ] variable) so that a user can run the program and supply "command-line" parameters. Since the parameter is a String array, however, the user does not have to supply any parameters.
  A .true
  B .false

• 分析：在java命令之后，在命令行输入的任何内容都将被接受为命令行参数。如果是由空格分隔的几个单词，那么每个单词都作为一个单独的字符串数组元素存储。

• 第八题：An array index cannot be a float, double, boolean or String.
  A .true
  B .false

• 分析：数组索引必须是int类型，或者可以扩展为int类型的值(因此，char、byte和short也是允许的)。

• 第九题：An array, when instantiated, is fixed in size, but an ArrayList can dynamically change in size when new elements are added to it.
  A .true
  B .false

• 分析：数组的一个缺点是它的固定大小。一旦实例化，它的大小是固定的。ArrayList是一个使用数组的类，它会自动创建一个更大的数组，将旧数组复制到新数组中，这样ArrayList就可以根据需要更大。虽然这可以解决抛出异常的问题，但它确实会导致性能较差，因为每次增加ArrayList大小时，必须从一个数组复制到另一个数组。

• 第十题：Just as arrays can only have a fixed number of elements, set at the time the array is declared, a parameter list also can only have a fixed number of elements, set at the time the method is declared.
  A .true
  B .false

• 分析：Java为可变长度参数列表提供了特殊的表示法。省略号(…)用于指定可变长度参数列表。

• 第十一题：So long as one is only accessing the elements of an ArrayList, its efficiency is about the same as that of an array. It's only when one begins to insert or remove elements towards the front portion of an ArrayList that its efficiency deteriorates.
  A .true
  B .false

• 分析：对ArrayList的前部分进行插入或删除时，就会发生大量的元素复制，从而降低其效率。

代码托管

结对及互评

• 20172317

Because his blog is writed by english, so my comment is also write by english.

• The learning or problem of blogging:

  1. The blog is very long, the variety is very complete, the language is refined, the English level is very high, so that I need a dictionary in some places.
  2. Hope later blog layout style can read better, try to focus on use different color, give you recommend a site:
  • Based on the scoring criteria, I gave this blog a score of 14.The score is as follows:
  1. Use Markdown grammar correctly (add 1 point) :
  2. Complete elements in the template (add 1 point)
  3. Problems and solutions in teaching materials, plus 4 points.
  4. Add 4 points to problems and solutions in code debugging.
  5. This week, the effective code is over 300 branches, plus 2 points.
  6. Additional points plus 2 points:
  7. Pure English blog, let your bother me look very confused, add 1 point.
  8. beautifully arranged with one point.
  9. add 1 point to the learning time and improvement in the progress bar.

• Worthy learning or problem in code:

1. Some of the ideas are different from me, and some of the questions I ask are not the ones I have encountered, which are very enlightening.

   • 20172320

• 博客中值得学习的或问题：
  还是很全的，背景很好看

  • 基于评分标准，我给本博客打分：11。得分情况如下：
  1. 正确使用Markdown语法（加1分）：
  2. 教材学习中的问题和解决过程, 加4分
  3. 代码调试中的问题和解决过程, 加4分
  4. 本周有效代码超过300分行，加2分

• 代码中值得学习的或问题：
  问题解释仍需全面

点评过的同学博客和代码

• 本周结对学习情况

  • 20172317
  • [20172320](）
  • 结对学习内容
    • 讨论问题
    • 互评博客

• 上周博客互评情况

  • 20172320

其他（感悟、思考等，可选）

概念很多，嘚仔细看，有很多细节，和前面的章节联系紧密。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	95/95	1/1	18/18
第二周	515/620	1/2	22/40
第三周	290/910	1/3	20/60
第四周	1741/2651	1/4	30/84
第五周	579/3230	1/5	20/104
第六周	599/3829	1/6	18/122
第七周	732/4561	1/6	24/146

参考：软件工程软件的估计为什么这么难，软件工程 估计方法

• 计划学习时间:22小时

• 实际学习时间:24小时

• 改进情况：稍有点

(有空多看看现代软件工程 课件
软件工程师能力自我评价表)

参考资料

• 《Java程序设计与数据结构教程（第二版）》

• 《Java程序设计与数据结构教程（第二版）》学习指导

• Java中this与super的用法总结

• 为什么Java不支持多重继承