201871010118-唐敬博《面向对象程序设计（java）》第十二周学习总结

博文正文开头格式：（2分）

项目	内容
这个作业属于哪个课程	https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里	https://www.cnblogs.com/lily-2018/p/11441372.html
作业学习目标	(1) 掌握Vetor、Stack、Hashtable三个类的用途及常用API； (2) 掌握ArrayList、LinkList两个类的用途及常用API。 (3) 掌握Java GUI中框架创建及属性设置中常用类的API； (4) 应用结对编程（Pair programming），体验程序开发中的两人合作。

随笔博文正文内容包括：

第一部分：总结第九章、第十章理论知识（40分）

1.数据结构：分为a.线性数据结构，如线性表、栈、队列、串、数组和文件。

b.非线性数据结构，如树和图。

1）所有数据元素在同一个线性表中必须是相同的数据类型。

　　线性表按其存储结构可分为顺序表和链表。

2）栈：也是一种特殊的线性表，是一种后进先出(LIFO)的结构。

　　栈是限定仅在表尾进行插入和删除运算的线性表，表尾称为栈顶，表头称为栈底。

3）队列：限定所有的插入只能在表的一端进行，而所有的删除都在表的另一端进行的线性表。是一种先进先出(FIFO)的结构。

　　表中允许插入的一端称为队尾，允许删除的一端称为队头。

2.集合：（容器）是一种包含多个元素并提供对所包含元素操作方法的类，其包含的元素可以由同一类型的对象组成，也可以由不同类型的对象组成。

　　1）集合框架：JAVA集合类库的统一架构。

　　2）集合类的作用（包含在java.util包中）：提供一些基本数据结构的支持，如Vector、Hashtable、Stack等。

　　3）集合类的特点：a.只容纳对象;

b.集合类容纳的对象都是Object类的实例(一旦把一个对象置入集合类中，它的类信息将丢失)

　　4）Vector类：类似长度可变的数组。它只能存放对象，其元素通过下标进行访问。

　　5）Stack类（Vector的子类）：它描述堆栈数据结构。（所有对象都有一个散列码，可以通过Object类的hashCode方法获得。）

3.集合框架中的基本接口：a.Collection（构造类集框架的基础）：集合层次中的根接口，JDK未提供这个接口的直接实现类。

b.Set：不能包含重复的元素，即元素必须唯一。对象可能不是按存放的次序存放。（实 现 Set 接口的类有HashSet，TreeSet）

c.List：有序的集合，可以包含重复的元素。提供了按索引访问的方式。实现它的类有ArrayList和LinkedLis（如ArrayList：能够自动增长容量的数组）

d.Map：Map接口映射唯一关键字到值。包含了key-value对。Map不能包含重复的key。SortedMap是一个按照升序排列key的Map。

3.用户界面：用户与计算机系统(各种程序)交互的接口

　　图形用户界面：以图形方式呈现的用户界面

4.AWT:Java 的抽象窗口工具箱（ Abstract WindowToolkit, AWT)包含在java.awt包中，它提供了许多用来设计GUI的组件类和容器类。

　　AWT库处理用户界面元素的方法：把图形元素的创建和行为委托给本地GUI工具箱进行处理。

5.Swing：Swing用户界面库是非基于对等体的GUI工具箱。

　　Swing具有更丰富并且更方便的用户界面元素集合。

　　Swing对底层平台的依赖很少，因此与平台相关的bug很少。

　　Swing类库被放在javax.swing包里。

大部分AWT组件都有其Swing的等价组件。Swing组件的名字一般是在AWT组件名前面添加一个字母“J”。

创建框架

1.组件：构成图形用户界面的元素，拿来即用用图形表示(能在屏幕上显示，能和用户进行交互)

2.通常把由Component类的子类或间接子类创建的对象称为一个组件。

3.容器：容器是Java中能容纳和排列组件的组件。常用的容器是框架（Frame,JFrame)

定位：
　　—常用Component类的setLocation和setBounds方法
常用属性
　　—Title：框架标题
　　—IconImage：框架图标

　　确定框架的大小：通过调用Toolkit类的方法来得到屏幕尺寸信息。

4.在组件中显示信息

在AWT中可调用add()方法把组件直接添加到AWTFrame中,在Swing中组件则添加到内容窗格里。

其中内容窗格是用来添加组件的，添加代码如下：

　　Container contentPane = getContentPane();

用户也可以自行创建一个组件类，并在组件上进行绘制，此时需要重载paintComponent()。

用户的自建组件也可添加到内容窗格里。

public void setEnabled(boolean b)：设置组件是否可被激活。
　　当参数b取值true时，组件可以被激活。
　　当参数b取值false 时，组件不可激活。
　　默认情况下，组件是可以被激活的。
public void setVisible(boolean b)：设置组件在该容器中的可见性。
　　当b取值true时，组件在容器中可见。
　　当b取值false时，组件在容器中不可见。
　　除了Window型组件外，其它类型组件默认是可见的。

第二部分：实验部分

实验1：测试程序1（6分）

导入第9章示例程序，测试程序并进行代码注释。

※使用JDK命令运行编辑、运行以下三个示例程序，结合运行结果理解程序；

※掌握Vetor、Stack、Hashtable三个类的用途及常用API。

Vetor：

实验程序如下：

 1 import java.util.Vector;  //实现自动增长的对象数组
 2
 3 class Cat {
 4      private int catNumber;
 5      Cat(int i) {
 6         catNumber = i;
 7     }
 8      void print() {
 9         System.out.println("Cat #" + catNumber);
10      }
11 }
12 public class Cats{
13 public static void main(String[] args){
14        Vector<Cat> cats= new Vector<Cat>();
15        for(int i=0; i<7; i++)
16            cats.addElement(new Cat(i));
17        for(int i=0; i<cats.size(); i++)
18            (cats.elementAt(i)).print();  //进行强制类型转化
19    }
20 }
运行结果如下：

Stack：

实验程序如下：

 1import java.util.*;
 2 public class Stacks  //栈（先进后出）
 3 {
 4    static String[] months={"金","银","铜","铁"};
 5    public static void main(String[] args){
 6       Stack<String> stk = new Stack<String> ();
 7       for(int i=0; i<months.length; i++)
 8           stk.push(months[i]);  //进栈
 9       System.out.println(stk);
10       System.out.println("element 2=" + stk.elementAt(2));
11       while(!stk.empty())
12           System.out.println(stk.pop());  //输出出栈元素
13   }
14 }
实验结果如下：

Hashtable：

实验程序如下：

import java.util.*;
 2 class Counter {
 3     int i = 1;  //不加权限修饰符：friendly型
 4     public String toString() {  //把其他类型的数据转为字符串类型的数据
 5         return Integer.toString(i);
 6     }
 7 }
 8
 9 public class Statistics {
10     public static void main(String[] args) {
11         Hashtable ht = new Hashtable();
12         for (int i = 0; i < 10000; i++) {
13             Integer r = new Integer((int) (Math.random() * 20));  //生成0到20(不包括20）的整型随机数
14             if(ht.containsKey(r))  //判断r是否是哈希表中一个元素的键值
15               ((Counter)ht.get(r)).i++;  //通过get方法获得其值
16           else
17               ht.put(r, new Counter());  //ht不存在
18 }
19         System.out.println(ht);
20     }
21 }
实验结果如下：

实验1：测试程序2（6分）

※使用JDK命令编辑运行ArrayListDemo和LinkedListDemo两个程序，结合程序运行结果理解程序；

ArrayListDemo:

实验程序如下：

 1 import java.util.*;
 2
 3 public class ArrayListDemo   //ArrayList使用了数组的实现
 4 {
 5     public static void main(String[] argv) {
 6         ArrayList al = new ArrayList();
 7         // Add lots of elements to the ArrayList...
 8         al.add(new Integer(11));
 9         al.add(new Integer(12));
10         al.add(new Integer(13));
11         al.add(new String("hello"));  //下标从0开始，添加4个元素
12         // First print them out using a for loop.
13         System.out.println("Retrieving by index:");
14         for (int i = 0; i < al.size(); i++) {
15             System.out.println("Element " + i + " = " + al.get(i));
16         }
17      }
18 }
实验结果如下：

LinkedListDemo:

实验程序如下：

 1 import java.util.*;
 2
 3 public class LinkedListDemo
 4 {
 5     public static void main(String[] argv)
 6     {
 7         //创建一个链表
 8         LinkedList l = new LinkedList();
 9         l.add(new Object());
10         l.add("Hello");
11         l.add("zhangsan");
12         ListIterator li = l.listIterator(0);
13         while (li.hasNext())
14             System.out.println(li.next());
15         if (l.indexOf("Hello") < 0)
16             System.err.println("Lookup does not work");
17         else
18             System.err.println("Lookup works");
19    }
20 }
实验结果如下：

实验1：测试程序3（6分）

※Elipse环境下编辑运行调试教材360页程序9-1，结合程序运行结果理解程序；

※掌握ArrayList、LinkList两个类的用途及常用API。

实验程序如下：

1 import java.util.*;
 2
 3 /**
 4  * This program demonstrates operations on linked lists.
 5  * @version 1.11 2012-01-26
 6  * @author Cay Horstmann
 7  */
 8 public class LinkedListTest
 9 {
10    public static void main(String[] args)
11    {
12        //创建a和b两个链表
13       List<String> a = new LinkedList<>();//泛型
14       a.add("Amy");
15       a.add("Carl");
16       a.add("Erica");
17
18       List<String> b = new LinkedList<>();//泛型
19       b.add("Bob");
20       b.add("Doug");
21       b.add("Frances");
22       b.add("Gloria");
23
24       //合并a和b中的词
25
26       ListIterator<String> aIter = a.listIterator();
27       Iterator<String> bIter = b.iterator();
28
29       while (bIter.hasNext())
30       {
31          if (aIter.hasNext()) aIter.next();
32          aIter.add(bIter.next());
33       }
34
35       System.out.println(a);
36
37       //从第二个链表中每隔一个元素删除一个元素
38
39       bIter = b.iterator();
40       while (bIter.hasNext())
41       {
42          bIter.next(); // skip one element
43          if (bIter.hasNext())
44          {
45             bIter.next(); // skip next element
46             bIter.remove(); // remove that element
47          }
48       }
49
50       System.out.println(b);
51
52       // bulk operation: remove all words in b from a
53
54       a.removeAll(b);
55
56       System.out.println(a);//通过AbstractCollection类中的toString方法打印出链表a中的所有元素
57    }
58 }
实验结果如下：

实验2：测试程序1（6分）

※运行下列程序，观察程序运行结果。

import javax.swing.*;

public class SimpleFrameTest

{

public static void main(String[] args)

{

JFrame  frame = new JFrame();

frame.setBounds(0, 0,300, 200);

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.setVisible(true);

}

}

实验程序如下：

 1 import javax.swing.*;
 2 public class SimpleFrameTest
 3 {
 4    public static void main(String[] args)
 5    {
 6      JFrame  frame = new JFrame(); //创建一个frame类对象
 7      frame.setBounds(0, 0,300, 200);//定义坐标以及宽度和高度
 8      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//窗口关闭操作
 9      frame.setVisible(true);//窗口是否可见
10    }
11 }

※在elipse IDE中调试运行教材407页程序10-1，结合程序运行结果理解程序；与上面程序对比，思考异同；

※掌握空框架创建方法；

※了解主线程与事件分派线程概念；

※掌握GUI顶层窗口创建技术。

实验程序如下：

 1 package simpleFrame;
 2
 3 import java.awt.*;
 4 import javax.swing.*;
 5
 6 /**
 7  * @version 1.33 2015-05-12
 8  * @author Cay Horstmann
 9  */
10 public class SimpleFrameTest
11 {
12    public static void main(String[] args)
13    {
14       EventQueue.invokeLater(() ->//lambda表达式：通过线程开启一个队列
15          {
16             SimpleFrame frame = new SimpleFrame();//创建一个类对象
17             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置对象点击关闭操作
18             frame.setVisible(true);//页面是否可见
19          });
20    }
21 }
22
23 class SimpleFrame extends JFrame
24 {
25    private static final int DEFAULT_WIDTH = 300;
26    private static final int DEFAULT_HEIGHT = 200;
27
28    public SimpleFrame()//构造器
29    {
30       setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);//设置大小
31    }
32 }
实验结果如下：

实验2：测试程序2（6分）

※在elipse IDE中调试运行教材412页程序10-2，结合运行结果理解程序；

※掌握确定框架常用属性的设置方法。

实验程序如下：

1 package simpleFrame;
 2
 3 import java.awt.*;
 4 import javax.swing.*;
 5
 6 /**
 7  * @version 1.34 2015-06-16
 8  * @author Cay Horstmann
 9  */
10 public class SizedFrameTest
11 {
12    public static void main(String[] args)
13    {
14       EventQueue.invokeLater(() ->//lambda表达式：通过线程开启一个队列
15          {
16             JFrame frame = new SizedFrame();//创建一个frame类对象
17             frame.setTitle("SizedFrame");//设置标题
18             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭操作
19             frame.setVisible(true);//设置可见性
20          });
21    }
22 }
23
24 class SizedFrame extends JFrame//继承
25 {
26    public SizedFrame()//构造器
27    {
28       //得到屏幕维度
29
30       Toolkit kit = Toolkit.getDefaultToolkit();//生成Toolkit对象
31       Dimension screenSize = kit.getScreenSize();
32       int screenHeight = screenSize.height;
33       int screenWidth = screenSize.width;
34
35       // set frame width, height and let platform pick screen location
36
37       setSize(screenWidth / 2, screenHeight / 2);//尺寸大小
38       setLocationByPlatform(true);
39
40       // set frame icon
41
42       Image img = new ImageIcon("icon.gif").getImage();
43       setIconImage(img);
44    }
45 }
实验结果如下：

实验2：测试程序3（6分）

※在elipse IDE中调试运行教材418页程序10-3，结合运行结果理解程序；

※掌握在框架中添加组件；

※掌握自定义组件的用法。

实验程序如下：

1 package simpleFrame;
 2
 3 import javax.swing.*;
 4 import java.awt.*;
 5
 6 /**
 7  * @version 1.33 2015-05-12
 8  * @author Cay Horstmann
 9  */
10 public class NotHelloWorld
11 {
12    public static void main(String[] args)
13    {
14       EventQueue.invokeLater(() ->//lambda表达式：通过线程开启一个队列
15          {
16             JFrame frame = new NotHelloWorldFrame();
17             frame.setTitle("NotHelloWorld");//标题
18             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
19             frame.setVisible(true);
20          });
21    }
22 }
23
24 /**
25  * A frame that contains a message panel
26  */
27 class NotHelloWorldFrame extends JFrame//继承
28 {
29    public NotHelloWorldFrame()//构造器
30    {
31       add(new NotHelloWorldComponent());//添加窗口
32       pack();
33    }
34 }
35
36 /**
37  * A component that displays a message.
38  */
39 class NotHelloWorldComponent extends JComponent
40 {
41    public static final int MESSAGE_X = 75;
42    public static final int MESSAGE_Y = 100;
43
44    private static final int DEFAULT_WIDTH = 300;
45    private static final int DEFAULT_HEIGHT = 200;
46
47    public void paintComponent(Graphics g)//绘图
48    {
49       g.drawString("Not a Hello, World program", MESSAGE_X, MESSAGE_Y);
50    }
51
52    public Dimension getPreferredSize() { return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT); }
53 }
实验结果如下：

三，实验总结：（19分）

通过本周的学习，我学习到了用JAVA语言更方便的实现数据结构的一些知识，理论课感觉自己能听懂，但实践课一动手发现自己还是有很多知识不知道，因此，在后面的学习中，除了多练习代码，我还会多翻书去记下一些细节和概念。努力学好这门课程。