这篇文章主要围绕狄慧201771010104《面向对象程序设计和java》第十周学习总结展开，旨在为您提供一份详细的参考资料。我们将全面介绍狄慧201771010104《面向对象程序设计的优缺点，解答

这篇文章主要围绕狄慧 201771010104《面向对象程序设计和java》第十周学习总结展开，旨在为您提供一份详细的参考资料。我们将全面介绍狄慧 201771010104《面向对象程序设计的优缺点，解答java》第十周学习总结的相关问题，同时也会为您带来2017-2018-2 20179204《网络攻防实践》第十周学习总结 缓冲区溢出漏洞实验、20172306《Java程序设计与数据结构》第十周学习总结、20172310 2017-2018-2 《程序设计与数据结构》第十周学习总结、20172325 2017-2018-2 《Java程序设计》第十周学习总结的实用方法。

• 狄慧 201771010104《面向对象程序设计（java）》第十周学习总结（面向对象程序设计java答案）
• 2017-2018-2 20179204《网络攻防实践》第十周学习总结 缓冲区溢出漏洞实验
• 20172306《Java程序设计与数据结构》第十周学习总结
• 20172310 2017-2018-2 《程序设计与数据结构》第十周学习总结
• 20172325 2017-2018-2 《Java程序设计》第十周学习总结

狄慧 201771010104《面向对象程序设计（java）》第十周学习总结（面向对象程序设计java答案）

实验十  泛型程序设计技术

实验时间 2018-11-1

第一部分：理论知识学习部分

(一)、泛型程序设计的定义

1、JDK 5.0 中增加的泛型类型，是 Java 语言中类型安全的一次重要改进。

2、 泛型：也称参数化类型 (parameterized type)，就是在定义类、接口和方法时，通过类型参数指示将要处理的对象类型。（如 ArrayList 类）

3、泛型程序设计（Generic programming）：编写代码可以被很多不同类型的对象所重用。

4、一个泛型类（generic class）就是具有一个或多个类型变量的类，即创建用类型作为参数的类。如一个泛型类定义格式如下：class Generics＜K,V＞其中的 K 和 V 是类中的可变类型参数。

5、Pair 类引入了一个类型变量 T，用尖括号（<>）括起来，并放在类名的后面。

6、 泛型类可以有多个类型变量。例如:public class Pair<T, U> { … }

7、 类定义中的类型变量用于指定方法的返回类型以及域、局部变量的类型。

(二)、泛型方法的声明

1、 泛型方法

（1） 除了泛型类外，还可以只单独定义一个方法作为泛型方法，用于指定方法参数或者返回值为泛型类型，留待方法调用时确定。

（2） 泛型方法可以声明在泛型类中，也可以声明在普通类中。

第二部分：实验

1、实验目的与要求

(1) 理解泛型概念；

(2) 掌握泛型类的定义与使用；

(3) 掌握泛型方法的声明与使用；

(4) 掌握泛型接口的定义与实现；

(5) 了解泛型程序设计，理解其用途。

2、实验内容和步骤

实验 1： 导入第 8 章示例程序，测试程序并进行代码注释。

测试程序 1：

l  编辑、调试、运行教材 311、312 页 代码，结合程序运行结果理解程序；

l  在泛型类定义及使用代码处添加注释；

l  掌握泛型类的定义及使用。

package pair1;

/**
 * @version 1.00 2004-05-10
 * @author Cay Horstmann
 */
public class Pair<T> //Pair类引入了一个类型变量T，用尖括号括起来
{
   private T first;
   private T second;//指方法的返回类型以及域和局部变量的类型
   public Pair() { first = null; second = null; }
   public Pair(T first, T second) { this.first = first;  this.second = second; }

   public T getFirst() { return first; }
   public T getSecond() { return second; }

   public void setFirst(T newValue) { first = newValue; }
   public void setSecond(T newValue) { second = newValue; }
}

package pair1;

/**
 * @version 1.01 2012-01-26
 * @author Cay Horstmann
 */
public class PairTest1
{
   public static void main(String[] args)
   {
      String[] words = { "Mary", "had", "a", "little", "lamb" };//ArrayAlg调用静态方法minmax()；
      Pair<String> mm = ArrayAlg.minmax(words);
      
      System.out.println("min = " + mm.getFirst());
      System.out.println("max = " + mm.getSecond());
   }
}

class ArrayAlg
{
   /**
    * Gets the minimum and maximum of an array of strings.
    * @param a an array of strings
    * @return a pair with the min and max value, or null if a is null or empty
    */
   public static Pair<String> minmax(String[] a)//定义静态泛型方法，将类型变量实例化为String；
   {
      if (a == null || a.length == 0) return null;//a.length是数组的属性值；
      String min = a[0];
      String max = a[0];
      for (int i = 1; i < a.length; i++)
      {
         if (min.compareTo(a[i]) > 0) min = a[i];
         if (max.compareTo(a[i]) < 0) max = a[i];
      }
      return new Pair<>(min, max);//调用泛型类对象，返回一个实例化后的类对象；
   }
}

测试程序 2：

l  编辑、调试运行教材 315 页 PairTest2，结合程序运行结果理解程序；

l  在泛型程序设计代码处添加相关注释；

l  掌握泛型方法、泛型变量限定的定义及用途。

package pair2;

/**
 * @version 1.00 2004-05-10
 * @author Cay Horstmann
 */
public class Pair<T> 
{
   private T first;
   private T second;

   public Pair() { first = null; second = null; }
   public Pair(T first, T second) { this.first = first;  this.second = second; }

   public T getFirst() { return first; }
   public T getSecond() { return second; }

   public void setFirst(T newValue) { first = newValue; }
   public void setSecond(T newValue) { second = newValue; }
}

package pair2;
//import PairTest1.Pair;
import java.time.*;

/**
 * @version 1.02 2015-06-21
 * @author Cay Horstmann
 */
public class PairTest2
{
   public static void main(String[] args)
   {
      LocalDate[] birthdays = 
         { //按ASCII码比较，大写字母比小写字母的ASCII码小;
            LocalDate.of(1906, 12, 9), // G. Hopper
            LocalDate.of(1815, 12, 10), // A. Lovelace
            LocalDate.of(1903, 12, 3), // J. von Neumann
            LocalDate.of(1910, 6, 22), // K. Zuse
         };
      //ArrayAlg调用静态方法minmax();
      Pair<LocalDate> mm = ArrayAlg.minmax(birthdays);
      System.out.println("min = " + mm.getFirst());
      System.out.println("max = " + mm.getSecond());
   }
}

class ArrayAlg
{
   /**
      Gets the minimum and maximum of an array of objects of type T.
      @param a an array of objects of type T
      @return a pair with the min and max value, or null if a is 
      null or empty
   */
    public static <T extends Comparable> Pair<T> minmax(T[] a) //泛型变量加了泛型约束的方法;
   {
      if (a == null || a.length == 0) return null;
      T min = a[0];
      T max = a[0];
      for (int i = 1; i < a.length; i++)
      {
         if (min.compareTo(a[i]) > 0) min = a[i];
         if (max.compareTo(a[i]) < 0) max = a[i];
      }
      return new Pair<>(min, max);//返回一个实例化泛型Pair类对象；
   }
}

测试程序 3：

l  用调试运行教材 335 页 PairTest3，结合程序运行结果理解程序；

l  了解通配符类型的定义及用途。

package pair3;

/**
 * @version 1.00 2004-05-10
 * @author Cay Horstmann
 */
public class Pair<T> 
{
   private T first;
   private T second;

   public Pair() { first = null; second = null; }
   public Pair(T first, T second) { this.first = first;  this.second = second; }

   public T getFirst() { return first; }
   public T getSecond() { return second; }

   public void setFirst(T newValue) { first = newValue; }
   public void setSecond(T newValue) { second = newValue; }
}

package pair3;

/**
 * @version 1.01 2012-01-26
 * @author Cay Horstmann
 */
public class PairTest3
{
   public static void main(String[] args)
   {
      Manager ceo = new Manager("Gus Greedy", 800000, 2003, 12, 15);
      Manager cfo = new Manager("Sid Sneaky", 600000, 2003, 12, 15);
      Pair<Manager> buddies = new Pair<>(ceo, cfo);      
      printBuddies(buddies);

      ceo.setBonus(1000000);
      cfo.setBonus(500000);
      Manager[] managers = { ceo, cfo };

      Pair<Employee> result = new Pair<>();
      minmaxBonus(managers, result);
      System.out.println("first: " + result.getFirst().getName() 
         + ", second: " + result.getSecond().getName());
      maxminBonus(managers, result);
      System.out.println("first: " + result.getFirst().getName() 
         + ", second: " + result.getSecond().getName());
   }

   public static void printBuddies(Pair<? extends Employee> p)
  //<? extends type>表示带有上界 
   
   {
      Employee first = p.getFirst();
      Employee second = p.getSecond();
      System.out.println(first.getName() + " and " + second.getName() + " are buddies.");
   }
 //"?"在这儿是通配符，符号表明参数的类型可以是任何一种类型，它和参数T的含义是有区别的
   public static void minmaxBonus(Manager[] a, Pair<? super Manager> result)//<? super type>表示带有下界
{
      if (a.length == 0) return;
      Manager min = a[0];
      Manager max = a[0];
      for (int i = 1; i < a.length; i++)
      {
         if (min.getBonus() > a[i].getBonus()) min = a[i];
         if (max.getBonus() < a[i].getBonus()) max = a[i];
      }
      result.setFirst(min);
      result.setSecond(max);
   }//T表示一种未知类型，而“？”表示任何一种类型
   public static void maxminBonus(Manager[] a, Pair<? super Manager> result)
   {
      minmaxBonus(a, result);
      PairAlg.swapHelper(result); // swapHelper捕获通配符类型
   }
}

class PairAlg
{
   public static boolean hasNulls(Pair<?> p)
   {
      return p.getFirst() == null || p.getSecond() == null;
   }

   public static void swap(Pair<?> p) { swapHelper(p); }

   public static <T> void swapHelper(Pair<T> p)
   {
      T t = p.getFirst();
      p.setFirst(p.getSecond());
      p.setSecond(t);
   }
}

package pair3;

import java.time.*;

public class Employee
{  
   private String name;
   private double salary;
   private LocalDate hireDay;

   public Employee(String name, double salary, int year, int month, int day)
   {
      this.name = name;
      this.salary = salary;
      hireDay = LocalDate.of(year, month, day);
   }

   public String getName()
   {
      return name;
   }

   public double getSalary()
   {  
      return salary;
   }

   public LocalDate getHireDay()
   {  
      return hireDay;
   }

   public void raiseSalary(double byPercent)
   {  
      double raise = salary * byPercent / 100;
      salary += raise;
   }
}

package pair3;

public class Manager extends Employee
{  
   private double bonus;

   /**
      @param name the employee''s name
      @param salary the salary
      @param year the hire year
      @param month the hire month
      @param day the hire day
   */
   public Manager(String name, double salary, int year, int month, int day)
   {  
      super(name, salary, year, month, day);
      bonus = 0;
   }

   public double getSalary()
   { 
      double baseSalary = super.getSalary();
      return baseSalary + bonus;
   }

   public void setBonus(double b)
   {  
      bonus = b;
   }

   public double getBonus()
   {  
      return bonus;
   }
}

实验 2：编程练习：

编程练习 1：实验九编程题总结

l  实验九编程练习 1 总结（从程序总体结构说明、模块说明，目前程序设计存在的困难与问题三个方面阐述）。

1 > 程序总体结构：主类 Main 和子类 test；

2 > 模块说明：主类当中进行文件的读取以及操作，test 类实现了 comparable 接口，控制其输出形式；

3 > 困难与问题：对捕获知识掌握的不好，对变量名有时不能统一。

l  实验九编程练习 2 总结（从程序总体结构说明、模块说明，目前程序设计存在的困难与问题三个方面阐述）。

1 > 程序总体结构：主类和 yunsuan 类；

2 > 模块说明：主类调用以及实现 yunsuan 类的功能，yunsuan 类主要模块化实现各种操作；

3 > 困难与问题：在 yunsuan 类的编写中，很多操作不知怎样具体化，对于 switch 语句掌握不好，不符合基础运算的要求。

编程练习 2：采用泛型程序设计技术改进实验九编程练习 2，使之可处理实数四则运算，其他要求不变。

package fghjg;
import java.util.Random;
import java.util.Scanner;

import java.io.FileNotFoundException;

import java.io.PrintWriter;

public class Main{
    public static void main(String[] args)
    {
        
        yunsuan counter=new yunsuan();//与其它类建立联系
    PrintWriter out=null;
    try {
        out=new PrintWriter("D:/text.txt");//将文件里的内容读入到D盘名叫text的文件中
         
    }catch(FileNotFoundException e) {
        System.out.println("文件找不到");
        e.printStackTrace();
    }
    
    
    int sum=0;

    for(int i=0;i<10;i++)
    {
    int a=new Random().nextInt(100);
    int b=new Random().nextInt(100);
    Scanner in=new Scanner(System.in);
    //in.close();
    
    switch((int)(Math.random()*4))
    
    {
    
    case 0:
        System.out.println( ""+a+"+"+b+"=");
        
        int c1 = in.nextInt();
        out.println(a+"+"+b+"="+c1);
        if (c1 == counter.plus(a, b)) {
            sum += 10;
            System.out.println("答案正确");
        }
        else {
            System.out.println("答案错误");
        }
        
        break ;
    case 1:
        if(a<b)
                        {
                                 int temp=a;
                                 a=b;
                                 b=temp;
                             }//为避免减数比被减数大的情况

         System.out.println(""+a+"-"+b+"=");
         /*while((a-b)<0)
         {  
             b = (int) Math.round(Math.random() * 100);
             
         }*/
        int c2 = in.nextInt();
        
        out.println(a+"-"+b+"="+c2);
        if (c2 == counter.minus(a, b)) {
            sum += 10;
            System.out.println("答案正确");
        }
        else {
            System.out.println("答案错误");
        }
         
        break ;
    
      

    
    case 2:
        
         System.out.println(""+a+"*"+b+"=");
        int c = in.nextInt();
        out.println(a+"*"+b+"="+c);
        if (c == counter.multiply(a, b)) {
            sum += 10;
            System.out.println("答案正确");
        }
        else {
            System.out.println("答案错误");
        }
        break;
    case 3:
        
        
         
        while(b==0)
        {  b = (int) Math.round(Math.random() * 100);//满足分母不为0
        }
        while(a%b!=0)
        {
              a = (int) Math.round(Math.random() * 100);
              b = (int) Math.round(Math.random() * 100);
        }
        System.out.println(""+a+"/"+b+"=");
     int c0= in.nextInt();
    
     out.println(a+"/"+b+"="+c0);
     if (c0 == counter.divide(a, b)) {
         sum += 10;
         System.out.println("答案正确");
     }
     else {
         System.out.println("答案错误");
     }
    
     break;
     

    }
    }
    System.out.println("totlescore:"+sum);
    out.println(sum);
    
    out.close();
    }
    }

package fghjg;
public class yunsuan <T>{
    private T a;
    private T b;
    public void yunsaun()
    {
        a=null;
        b=null;
    }
    public void yunsuan(T a,T b)
    {
        this.a=a;
        this.b=b;
    }
   public int plus(int a,int b)
   {
       return a+b;
       
   }
   public int minus(int a,int b)
   {
    return a-b;
       
   }
   public int multiply(int a,int b)
   {
       return a*b;
   }
   public int divide(int a,int b)
   {
       if(b!=0  && a%b==0)
       return a/b;
       else
           return 0;
   }
   }

三、实验总结：

        本章我们学习了泛型程序设计技术，理解了泛型概念，掌握了泛型类的定义与使用和泛型方法的声明与使用。在验证实验中，通过对代码的解读，更好的学习了泛型程序 <T> 的使用，虽然不是很熟练，但还是做出来了，感觉依旧存在些小问题，在接下来的实验中要更好的解决。

2017-2018-2 20179204《网络攻防实践》第十周学习总结 缓冲区溢出漏洞实验

第1节 实验简介

缓冲区溢出是指程序试图向缓冲区写入超出预分配固定长度数据的情况。这一漏洞可以被恶意用户利用来改变程序的流控制，甚至执行代码的任意片段。这一漏洞的出现是由于数据缓冲器和返回地址的暂时关闭，溢出会引起返回地址被重写。

第2节 实验准备

系统用户名shiyanlou，实验楼提供的是64位Ubuntu linux，而本次实验为了方便观察汇编语句，我们需要在32位环境下作操作，因此实验之前需要做一些准备。 ###2.1 输入命令安装一些用于编译32位C程序的东西： ###2.2 输入命令“linux32”进入32位linux环境。此时你会发现，命令行用起来没那么爽了，比如不能tab补全了，所以输入“/bin/bash”使用bash：

第3节 练习1实验步骤

###3.1 初始设置 Ubuntu和其他一些Linux系统中，使用地址空间随机化来随机堆（heap）和栈（stack）的初始地址，这使得猜测准确的内存地址变得十分困难，而猜测内存地址是缓冲区溢出攻击的关键。因此本次实验中，我们使用以下命令关闭这一功能：sudo sysctl -w kernel.randomize_va_space=0

此外，为了进一步防范缓冲区溢出攻击及其它利用shell程序的攻击，许多shell程序在被调用时自动放弃它们的特权。因此，即使你能欺骗一个Set-UID程序调用一个shell，也不能在这个shell中保持root权限，这个防护措施在/bin/bash中实现。

linux系统中，/bin/sh实际是指向/bin/bash或/bin/dash的一个符号链接。为了重现这一防护措施被实现之前的情形，我们使用另一个shell程序（zsh）代替/bin/bash。下面的指令描述了如何设置zsh程序：

  sudo su
  cd /bin
  rm sh
  ln -s zsh sh
  exit

###3.2 漏洞程序 代码保存为“stack.c”文件，保存到 /tmp 目录下。

编译该程序，并设置SET-UID。命令如下：

  sudo su
  gcc -m32 -g -z execstack -fno-stack-protector -o stack stack.c
  chmod u+s stack
  exit

GCC编译器有一种栈保护机制来阻止缓冲区溢出，所以我们在编译代码时需要用 –fno-stack-protector 关闭这种机制。

而 -z execstack 用于允许执行栈。

###3.3 攻击程序 我们的目的是攻击刚才的漏洞程序，并通过攻击获得root权限。

把代码保存为“exploit.c”文件，保存到 /tmp 目录下。

“\x??\x??\x??\x??”处需要添上shellcode保存在内存中的地址，因为发生溢出后这个位置刚好可以覆盖返回地址。

而 strcpy(buffer+100,shellcode); 这一句又告诉我们，shellcode保存在 buffer+100 的位置。

现在我们要得到shellcode在内存中的地址，输入命令：

  gdb stack
  disass main

结果如图：

根据语句 strcpy(buffer+100,shellcode); 我们计算shellcode的地址为 0xffffd1b0(十六进制)+100(十进制)=0xffffd214(十六进制)

现在修改exploit.c文件！将 \x??\x??\x??\x?? 修改为 \xb4\xd3\xff\xff 然后，编译exploit.c程序：

###3.4 攻击结果

先运行攻击程序exploit，再运行漏洞程序stack，观察结果：

第4节 练习1

通过命令”sudo sysctl -w kernel.randomize_va_space=2“打开系统的地址空间随机化机制，重复用exploit程序攻击stack程序，观察能否攻击成功，能否获得root权限。 无法获得root权限。

第5节 练习2

将/bin/sh重新指向/bin/bash（或/bin/dash），观察能否攻击成功，能否获得root权限。 无法获得root权限。

##第6节 小结 在练习二中，由于地址空间随机化被开启，导致之前计算的地址与实际的地址出现了不同，从而不能完成攻击。

而练习三中，使用的bash程序，当shell运行时，没有root权限，此时，即便攻击程序攻击了漏洞程序，也无法完成攻击。

20172306《Java程序设计与数据结构》第十周学习总结

20172306《Java程序设计》第十周学习总结

教材学习内容总结

本章主要的讲的是集合有关的知识： 1.集合与数据结构 - 集合是一种对象，集合表示一个专用于保存元素的对象，并该对象还提供增添、删除等管理所保存元素的服务。 - 同构：就是存放同种类型。异构：就是可以存放不同类型的。 - 一个抽象数据类型室友数据和在该数据上所实施的具体操作构成的集合。 - 对象实际上就是将变量和相关的方法封装在一起的实体。 - 集合可以用各种方式实现，我认为这是集合的一个很特别的方面。 2.数据结构的动态表示 - 数组是有局限性的，根据第八章可以知道，我们在创建一个数组的时候需要给数组一定的长度，对于数组来说，每当需要扩大数组时，就创建一个更大的数组并将原有的数组复制到新数组。这说明数组有局限；而我们学习的ArrayList的长度不是固定的，这就有很大的空间给我们的设计者。 - 学习了动态链接的列表。主要是是要了解它在增加和删除还有插入的过程，对于删除和插入已经在码云中有代码。这一部分是我认为比较重要的一点。对于在串联的时候，应该将其看作一个指针，继而不断的进行联系，还要考虑到连接方式的先后顺序，避免会出现丢失的现象。 3.线性数据结构。 - 队列类似于列表，队列使用先进先出。堆栈使用后进先出。对于栈的内容，在编程四则运算中就运用了栈的相关内容。 - 学习了LinkedList的一些内容，在教材问题中有解答。 4.非线性数据结构 - 树：由一个根节点和构成层次结构的多个节点组成。类之间的继承关系可以用一棵普通的树结构来表示。用静态表示方式（数组）实现树数组结构也是有可能的。 - 图：图没有像树根节点那样的初始入口点。与树类似，虽然可以用数组实现图，但是更常用动态链实现图。 5.Java集合类API - Java集合类API中的类定义为泛型，是指一个集合所管理的对象的类型要在实例化该集合的对象时才确定。泛型保证了集合中对象类型的兼容性。

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

• 问题1：书中写了抽象数据类型，但是我还是对于书中写的不是很理解。

• 问题1解决方案：书中说ADT是由数据和在该数据上所实施的具体操作构成的集合。ADT之所以被称为抽象数据类型，是因为ADT上可以执行的操作与底层的实现分离开了。后来我又上网查了一下有关ADT的有关知识，主要内容是开发者可以利用ADT的方法来使用ADT的相关属性，但是并不知道它究竟是如何操作的。线性表、堆栈、队列就属于ADT。线性表，堆栈和队列的内部结构可以用许多方式实现。例如，我们可以使用一个有序数组或者一个链表来实现每个结构。关键的一点是不论你如何实现其内部结构，它对外的接口总是不变的。这使得你能够修改或者升级底层的实现过程而不需要改变公共接口部分。具体我参照了这篇博客API

• 问题2：对于书中说要做insert的方法和delete的方法。最开始我大致懂得它的大致思路，但是其具体的流程还是不懂。

• 问题2解决方案：老师在课上讲了，但是后来再想的时候，就记得不清晰了，然后问了同学，才知道它整个的流程是怎样的。 1.插入：首先要判断是在开头还是在中间，如果是开头，只需要将指针指向要插入的部分，然后和之后的相连接，就可以了。如果是在中间的话，需要先将所插入部分和后面的部分相连，然后再和前面的相连接，这样的顺序是为了避免后面的东西被当做垃圾而消失。 2.删除：如果是最后一个的进行删除，只需要将前一个的下一个指针为空即可。如果是要删除中间的某个，只需要将其前一个的指针指向要删除的后一个就可以，这样越过要删除的，就可以保证链条中删除这个。

• 问题3：老师在上课的时候有提到Linkedlist的相关知识，所以自己上网找了一下。

• 问题3解决方案：LinkedList我自己通过网上的一些教程，利用IDEA学习了一些有关的内容。

  建立一个Linkedlist的对象，实现对其中进行增加内容：

  对于已有的一部分，对首项和尾项进行了增添：

  对首项进行删除以及对指定的索引的地方进行删除：

  对指定的索引处的值进行改变：

其实还有很多内容，包括Linkedlist和数组以及队列还有Arraylist的转换等内容，还在继续学习。

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

 在学习的时候，这一章的内容主要内容都是大同小异的所以只要了解其中的套路就可以编写，所以这周的代码我没有什么具体的问题，有几个比较基础的问题已经问了同学解决了。

代码托管

上周考试错题总结

本题选B 重载只是为具有不同参数列表的方法提供了备选方案。重写提供了多态性，因为适当的方法是根据当前被引用的对象而调用的。嵌入是类中包含的类。抽象与多态没有任何关系。封装是使用可见性修饰符（公共的、私有的、受保护的）实现的。

本题选A Upcasting是完全安全的，它是Java支持的单一继承结构的产物。相比之下，Downcasting必须由程序员显式地完成。Java只在一个方向上自动转换。在使用的可见性修饰符方面，Upcasting和Downcasting的规则并不依赖于任何方式。

本题选A 虽然继承和接口支持多态，但只有在有后期绑定时才会这样做。但是，重载是多态性一（方法）名的一种形式，多个主体，只要程序使用重载，多态就在使用中。

• 本题A 精确!由于println（）本质上是高度多态的，所以它能够正确地打印各种预定义的（库）和内置（原始）数据。

结对及互评

结对伙伴

• 博客中值得学习的或问题

• 他在博客中写有关数组和集合之间的区别，看了之后自己也学到了这种知识。

• 他在看书的时候想到的问题都很有思想，而且可以抛开书本看网上的内容并学习，值得学习。

• 基于评分标准，我给本博客打分：8分。

点评过的同学博客和代码

20172325

• 本周结对学习情况

  • 结对学习内容
    • 我们一起学习了第十三章的内容。
    • 继续了四则运算的项目，将项目完善。
    • 进行了蓝墨云的实验。

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

第十三章学完了，我们《Java程序设计和数据结构》这本书就算是学完了。这一章的内容不是很多，而且自己是在老师讲完课之后自己才看的书，所以理解起来更明白些。总的来说，这本书结束了，虽然学到了一些东西，但是可能放在Java的时间不够多再加上进程太快了，自己对于整本书的掌握一直处于半懂半不懂的程度。如果要我自己对于这个学习打一个分的话，我只能给自己打5分，没有及格。所以在之后的学习中，如果有可能，还希望能够重新温习一下。

学习进度条

参考资料

• Java学习笔记(第8版)

• 《Java学习笔记(第8版)》学习指导

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

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

教材学习内容总结

本周学习的是第十三章

• 集合与数据结构

  • 集合是一种对象，类似于保存其他对象的存储库。我们常用集合表示一个专用于保存元素的对象,并且该对象还提供增添,删除等管理 所保存元素的服务。
  • 集合是同构的,意味着这种集合保存类型全部相同的对象;另一些集合则是异构的,即这种集合可以保存各种类型的 对象。
  • 分离接口与实现： 1、一个抽象数据类型(ADT)是由数据和在该数据上所实施的具体操作构成的集合。一个ADT有名称、 值域和一组允许执行的操作。ADT如何保存数据和执行方法的细节与其概念分离开了。实质上,“集合”和抽象数据类型”是可以互换的等同概念。 2、对象具有定义良好的接口,从而成为一种实现集合的完善机制。

• <font color=#DC143C face="STCAIYUN">数据结构的动态表示</font>

  • 数组是表示列表的方式之一,但数组在存在期间只能有固定的大小，不是动态的。
  • 动态数据结构的大小规模随需要增长和收缩。
  • 一个动态数据结构用链来实现。
  • 通过保存和更新对象引用来实现一个链表的管理。

• 线性数据结构 <font color=#DC143C face="STCAIYUN">队列和堆栈</font>

  • 队列（queue）：类似于列表，但队列元素存取方式有限制，队列采取先进先出（FIFO）的存取方式，即类似于生活中我们排队的情况，我们是从队尾入队，队首出队。

  • 堆栈（stack）：堆栈类似于队列，不同之处在于元素的存取方式，它是采用后进先出（LIFO）的存取方式，也就是堆栈元素在堆栈的同一端进入和移出栈堆，最后进入的是第一个移出的。

• 非线性数据结构 <font color=#DC143C face="STCAIYUN">树和图</font>

  • 树（tree）：是一个非线性数据结构,由一个节点和构感层次结构的多个节点组成(除根节点外的所有节点称为内部节点,没有子节点。 注意,要由上至下地一棵树,根节点在顶层,叶节点在底层。 重点概念:树是一种以层次结构组织数据的非性数据结构

  • 二叉树（binary tree）上，每个节点不能有超过两个的子节点。

  • 图（graph）：图没有类似于树根节点那样的初始入口点。在一个图中，一个节点到另一个节点的连接称为边，连接一个图内各节点的边数一般没有限制。

数据结构_非线性结构_图

• Java集合类API
  • Java集合类API是Java标准类库中的一组类，代表不同类型的集合体，在这组类中,大多数的类名表明了集合类型及其基本实现方法。如ArrayList和LinkedList。-
  • 泛型：Java集合类API中定义的类定义为泛型，是指一个集合所管理的对象的类型要在实例化时该集合对象时才能确定。
  • 泛型保证了集合中对象类型的兼容性。
  • 在建立集合时，如果没有指定该集合中可能存放的对象的类型，则将默认定义为Object类型，即该集合可以存放任何类型的对象。

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

• 问题1：为什么对象特别适于实现抽象数据类型?我看到这个问题的时候觉得我可能对“对象”这个概念的理解还是不够充分。

• 问题1解决方案：之前理解的是：类就是具备某些共同特征的实体的集合，它是一种抽象的数据类型，它是对所具有相同特征实体的抽象。在面向对象的程序设计语言中，类是对一类“事物”的属性与行为的抽象。 对象就是一个真实世界中的实体，对象与实体是一一对应关系的，意思就是现实世界的每一个实体都是一个对象，所以对象是一个具体的概念。 类是对象的集合，对象是类的实例;对象是通过new className产生的，用来调用类的方法;类的构造方法 。 这个理解是对的，但是我没有看到他背后更根本的实现的方式。 ADT是一个包含数据和施加在这些数据类型上的操作的集合。<font color=#DC143C face="STCAIYUN">对象实际上就是将相关变量和相关方法封装在一起的实体</font>。对象隐藏了ADT背后的实现细节，并且将接口和底层的实现相分离，使得实现发生变化后并不影响接口。

• 问题2： class Node { int info; Node next; }

实例化两个Node对象，并使一个Node对象的变量next指向另一个Node对象，从而将两 个对象链接在一起。第二个对象的引用变量next又可指向更三个Node对象，依次类推,最后建立 起一个链表。

我以为我看懂了这句话，理解了链的结构，但是当在实现链表插入和删除方法的时候，我才发现其实自己根本就没有懂。(；´д｀)ゞ <font color=#DC143C face="STCAIYUN">那么链表到底怎么理解呢？还有链表和LinkedList有什么关系呢？用链表来进行数据管理有什么好处呢？</font>

• 问题2解决方案：
  • 对于第一个问号：我再好好看了好几遍课本上的例子，觉得之前我没有理解的关键就是没有弄懂指针和next的概念。链表是相同类型的若干个结构体用其自身携带的指针（指针只是起一个指示的作用，我的理解就是表明现在的节点在什么位置，接下来的操作是在什么位置进行的）按照一定顺序串联成的一个链。举个简单例子进行类比：structnode{inta;structnode*next;};把这个链表节点的结构体structnode看作是人，结构体内的next指针看作是人的一只手，这只手只能用于指向人（别人或自己）。如果有多个人排成一排，每个人都举起右手指向右边的人，就形成一个人组成的链表。

LinkedList类(链接列表) LinkedList实现了List接口，允许null元素。但除了有List中所有方法以外,还有get,remove,insert以及最开头元素和最结尾元素等方法,而这些方法使得LinkedList既能当stack,queue和double-end queue(Deque)。 LinkedList是将每个对象存放在独立的内存空间中，而且，每个空间中还保存有下一个链接的索引(如果是双向链表，那么它还保存了上一个链接的索引。Java是双向链表)

对顺序访问进行了优化，向List中间插入与删除得开销不大，随机访问则相对较慢(因为LinkedList是必须从头开始搜索，可用ArrayList代替)。它具有方法addFirst()、addLast()、getFirst()、getLast()、removeFirst()、removeLast()，linkedList也是不同步的。

再给大家一篇参考Linked List 链表详解

• 链表是一种动态结构，通常是将它与静态的数组相比较

相对于数组来说: 优点: 通过索引(数组下标)可以很快地访问数组元素; 缺点: 插入/删除元素需要对数组进行调整, 效率低;

而链表: 优点：插入/删除速度很快，而且不用对整个链表进行调整； 缺点：只能进行顺序访问，不能随机访问（像数组一样用下标）。

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

• 问题1：在实现链表的删除和插入的方法时我遇到了这样一个问题，就是插入和删除后链表剩下的就只有插入的数据或是变成了空的。 （截图被我弄丢了o(╥﹏╥)o）
• 问题1解决方案：感谢我的队友的帮助，发现自己是因为在写红框中的循环条件的时候用的是index > 0 （这是现在正确代码的截图）

又给了我一个小经验，一定注意循环的条件要好好设计。

代码托管

上周考试错题总结

• 错题1及原因，理解情况

如果J等于a的长度，返回false；如果j=b的长度而不等于a的长度，返回true；既不等于a的长度，又不等于b的长度，则调用递归计算（a，b，j+1）。我当时的判读是反了的，应该是只有当a的长度大于b的长度时，才会返回true。

• 错题2及原因，理解情况

递归的情况是用相同的参数调用自己的方法，所以n不会改变，因此如果（n-0）最初是正确的，它仍然是正确的。但当n>0时，永远不可能为基本情况。逻辑我是理解的，但是给出的选项没有理解好。

• 错题3及原因，理解情况 A选项的意思是：当一个方法调用自己时，就会发生直接递归;间接递归发生在有干预方法的时候。 当时没有理解什么是干预方法。 直接递归意味着一个方法直接调用自己，而不使用中间方法。当在原始方法再次被调用之前有一个或多个中间方法时，就会发生间接递归。

这次的题目大多是考察我们能不能看懂代码的逻辑关系，所以这次花费的时间就比较长，因为要一点点理清代码一步一步要实现的事。这次容易犯错误的地方也就是因为逻辑没有理清，以后自己写代码实现递归时一定要好好设计。

结对及互评

点评模板：

• 博客中值得学习的或问题：

  • 本周教材的总结比较简单，但是重点都有总结到。
  • 每次博客中教材的问题都很好，值得学习。

• 代码中值得学习的或问题：

  • 过程描述很清楚，问题也很好的解决了。

• 参考示例

点评过的同学博客和代码

• 本周结对学习情况

  • 20172309

  • 结对学习内容

    • 实验三 敏捷开发与XP实践
    • 教材十三章

• 上周博客互评情况

  • 20172309
  • 20172310

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

时间过得真的很快，一下子这么厚的一本课本就翻到了最后一页。但是“学习本无底，前进莫徬徨。” 但说句实话，我对课本的掌握的还是不好，所以我一定要好好复习，一有时间就该拿起课本看看，而不应该抱着学完就完事的想法，最后相告诉大家一句话

对世界上的一切学问与知识的掌握也并非难事，只要持之以恒地学习，努力掌握规律，达到熟悉的境地，就能融会贯通，运用自如了。

学习进度条

参考资料

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

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

• 数据结构_非线性结构_图

20172325 2017-2018-2 《Java程序设计》第十周学习总结

20172325 2017-2018-2 《Java程序设计》第十周学习总结

教材学习内容总结

1.集合与数据结构

• 集合是一种对象
• 集合按照保存类型来看可以分为两种： （1）同构集合：只能保存类型全部相同的对象； （2）异构集合：可以保存各种类型的对象。

2.分离接口与实现

• 集合可以用各种方式实现
• ADT：是由数据和在该数据上所实施的具体操作构成的集合，一个ADT有名称、值域和一组允许执行的操作。
• 集合和抽象数据类型可以互换的等同概念。

3.数据结构的动态表示

• ArrayList类解决可变大小数组问题的方法是创建一个更大的数组并将原有的数据复制到新数组里，但这种方法未必是最高效的。
• 一个动态数据结构用链来实现。利用对象引用作为连接对象间的链。
• 动态数据结构的大小规模需要增长和收缩。

4.线性数据结构 1、队列：类似于列表，但是在存取方式上有所不同，是一种先进先出方式管理数据的线形数据结构； 2、堆栈：也类似于列表和队列，但是是一种以后进先出方式管理数据的线形数据结构；

5.非线性结构 1、树：是一种以层次结构组织数据的非线性数据结构； 2、图：是非线性数据结构，使用常见的边来连接节点；

6.Java集合类API。

• Java标准类库中定义了几种表示不同类型集合的类，常称为Java集合类API。
• 泛型：一个集合所管理的对象的类型要在实例化该集合对象时才确定。
• 集合所能存放的对象与继承关系有关。

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

• 问题1：对于集合和数组关系理解得不是很清楚

• 问题1解决方案： 数组特点：大小固定，只能存储相同数据类型的数据 集合特点：大小可动态扩展，可以存储各种类型的数据 虽然存在不同，但是二者之间可以实现转换

• 问题2：紧接着问题一，既然集合可动态扩展，但是课本上说道她不是一种高效的实现数据结构动态表示的方法，也就是说不能用集合实现，这又是因为什么呢？

• 问题2解决方案：参考下列博客

就是说，按照链来实现的话就能够达到动态的实践，根据需要增长和收缩，而集合时通过在静态时的声明来达到的，每次改变的储存空间相同，没有体现出动态这个概念。

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

本周代码与之前的内容有相似，没有遇到太大问题。

代码托管

上周考试错题总结

• 错题1：
• 解析：调用堆栈跟踪提供了存储在运行时堆栈上的方法的名称。方法名称从堆栈中删除以相反的顺序放置,也就是说,最早的方法是先放在这里,下一个方法其次,等等,所以最近调用的方法是在堆栈上最后一项,这是第一个删除。然后堆栈跟踪显示所有的活动方法，它们被称为(最近的第一次)。
• 错题2：
• 解析：数据流表示特定的源或目标流，用于输入或输出。处理流就像一个数据流，其中添加了一些额外的进程(is)，添加到输入或输出中。例如，一个处理字节流可以从一个文件中输入所有的项目，并删除任何不是数字的ASCII字符，这样输入的数字将不会抛出NumberFormatException。
• 错题3：
• 解析：Java程序的输入很困难，因为它需要大量的开销。扫描器类实现了所有的开销，这样程序员就不必看到它了。因此，扫描器是执行输入操作的抽象，而不需要细节。这些细节包括导入java.IO类，以某种方式处理IOexception，从标准输入流中输入，将输入划分为单个令牌，并根据需要将每个令牌转换为请求形式。
• 错题4：
• 解析：异常传播意味着一个异常被匹配的catch子句在当前try块级别,如果没有匹配,然后在下一个封闭try块级别,等等,直到异常已经被匹配的条款或异常的主程序和被Java虚拟机。

结对及互评

• 博客中值得学习的或问题：
  • 排版有进步
  • 问题跟踪详细解答清晰
• 基于评分标准，我给本博客打分：9分。

点评过的同学博客和代码

• 本周结对学习情况
  • 20172306
  • 结对学习内容 我们一起学习了第十三章的内容。 继续了四则运算的项目，将项目完善。 进行了蓝墨云的实验。- 上周博客互评情况（只要链接，具体点评放相应博客下）

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

课本的第一遍学习已经完成，但是由于进度等问题，对于很对知识的理解和运用都不是很清楚，所以还需要回头去重新查缺补漏，希望能够在复习中发现问题解决问题，提高自己对java的掌握力度。

学习进度条

参考资料

• Java学习笔记(第8版)

• 《Java学习笔记(第8版)》学习指导

关于狄慧 201771010104《面向对象程序设计和java》第十周学习总结的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于2017-2018-2 20179204《网络攻防实践》第十周学习总结 缓冲区溢出漏洞实验、20172306《Java程序设计与数据结构》第十周学习总结、20172310 2017-2018-2 《程序设计与数据结构》第十周学习总结、20172325 2017-2018-2 《Java程序设计》第十周学习总结等相关内容，可以在本站寻找。