201871010135 张玉晶《面向对象程序设计（java）》第十二周学习总结

 

 

	内容
这个作业属于哪个课程	https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里	https://www.cnblogs.com/zyja/p/11865491.html
作业学习目标	(1) 掌握Vetor、Stack、Hashtable三个类的用途及常用API； (2)  掌握ArrayList、LinkList两个类的用途及常用API； (3) 了解java集合框架体系组成； (4) 掌握Java GUI中框架创建及属性设置中常用类的API； (5) 了解Java GUI中2D图形绘制常用类的API；

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

第九章 

1.Java的集合框架 ： 实现了对各种数据结构的封装

     •  框架： 就是一个类库，框架中包含一些通用接口和超类，编程者实现这些接口或创建这些超类的子类就可方便的设计程序所需要的类

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

     •  Java的集合类包含在Java.util包中

     •  集合类只容纳对象，数组可以容纳基本数据类型和对象。

2. Vector类

    •  类似长度可变的数组

    •  只能存放对象

    •   其元素通过下标进行访问

    •   关键方法：    ——void  addElement(Object   obj)

                               ——void   add（int  index，  Object   element）

                               ——Object  elementAt（int   index）

                               ——void   insertElementAt（Object   obj，  int  index）

3. Stack类

     • 描述堆栈数据结构，即FILO

     •  关键方法： -public void push(Object item) //把项压入栈顶

                           -public Object pop()  //出栈

                           -public boolean empty()  //测试堆栈是否为空  

                          -public Object peek()  //查看栈顶对象而不移除它

4. Hashtable 类

    • Hashtable通过键来查找元素

    • 用散列码来确定键，所有对象都有一个散列码，可以通过Object类的hashCode()方法获得

5. 集合框架中的基本接口

     • Collection : 集合层次中的根接口。

     •  Set： 不能包含重复的元素。对象可能不是按存放的次序存放，也就是说不能像数组一样按索引的方式进行访问，SortedSet是一个按照升序排列元素的Set.

                  HashSet：底层的数据结构是哈希表（散列表）。无序，比数组查询效率高，线程不同步。

                  TreeSet：底层数据结构是二叉树。可以对Set集合的元素按照指定规则进行排序。线程不同步。

     •  List: 是一个有序的集合，可以包含重复的元素。提供了按索引访问的方式----ArrayList(按顺序存储）和 linklist（按链式存储）

                 ArrayList类可以将其看作是能够自动增长容量的数组，利用ArrayList的toArray()返回一个数组

                 LinkedList类是采用双向循环链表实现的；利用LinkedList实现栈，队列，双向队列，类内除了数据本身外，还有两个引用，分别指向前一个元素和后一个元素；

     •  Map: 包含了Key-value对，不能包含重复的key。元素是成对出现的，以键和值的形式体现出来，键要保证唯一性。

     •  SortedMap是一个按照升序排列key的Map.

第十章

1. AWT： Java的抽象窗口工具箱包含在Java.awt包中，他提供了许多用来设计GUI的组件类和容器类

               

 

 

 2.  String类概述： Swing新一代的图形界面工具。位于javax.swing包中。

       

 

 

 3.   创建框架：顶层窗口被称为框架（frame)

       •  Frame 类的Swing版本名为JFrame,它扩展于Frame. 

       •  组件： 由component类的子类或间接子类的对象称为一个组件。

                     组件内的常用API：

                    

 

 

 4. 容器 ： 是Java中能容纳和排列组件的组件，常用的容器是 框架。

 5. 添加组件： Container类提供了一个方法 add()， 用来在容器内组件对象中添加其他组件 

 6.  在 Swing 中有三种可以使用的顶层容器，分别是 JFrame、JDialog 和 JApplet。

           a . JFrame：用于框架窗口的类，此窗口带有边框、标题、关闭和最小化窗口的图标。带 GUI 的应用程序至少使用一个框架窗口。

           b.  JDialog：用于对话框的类。

           c.  JApplet：用于使用 Swing 组件的 Java Applet 类.

7.  框架定位和框架属性： 

         setLocation和setBounds方法用于设置框架的位置。

         setIconImage用于告诉窗口系统在标题栏、任务切换窗口等位置显示哪个图标。

         setTitle：改变标题栏文字。

         setResizable:利用一个boolean值确定框架的大小是否允许用户改变。

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

11.  JFrame类本身只包含若干个改变外观的方法。然而，继承了各个超类中许多处理框架大小和位置的方法。如：

       dispose方法用于关闭窗口，并回收创建窗口所使用的全部系统资源。
       setIconImage方法用于将窗口极小化时的图标设置为Image对象。
       setTitle方法用于改变标题栏中的文本。
       setResizable方法利用一个boolean值确定框架的大小是否允许用户改变。
       setLocation（x，y）方法将窗口放置在坐标为x，y的位置。
       setBounds（x，y，width，height）方法将窗口指定位置，同时设定窗口大小。

12. 处理2D图形

    Graphics类包含绘制直线，矩形或者椭圆的方法。但是绘制图形的能力有限，不能改变线的粗细，不能旋转这些图形 

    Java 2D 支持更加复杂的图形，如圆弧，二次曲线，三次曲线和通用路径。 

     2D图形类使用浮点数坐标系

13. 颜色的使用：

     Graphics 2D类的setPaint方法（Graphics  类为setColor方法）用来设置颜色；

 

第二部分：实验内容和步骤

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

测试程序1：

1.

 1 import java.util.Vector;
 2 class Cat {
 3      private int catNumber;
 4      Cat(int i) {
 5         catNumber = i;
 6     }
 7      void print() {
 8         System.out.println("Cat #" + catNumber);
 9      }
10 }
11 public class Cats{
12 public static void main(String[] args){
13        Vector cats= new Vector();
14        for(int i=0; i<7; i++)
15            cats.addElement(new Cat(i)); 
16        for(int i=0; i)
17            (cats.elementAt(i)).print();
18    }
19 }

运行结果如下：

    

 

2.   

 1 import java.util.*;
 2 public class Stacks
 3 {
 4    static String[] months={"金","银","铜","铁"};
 5    public static void main(String[] args){
 6       Stack stk = new Stack ();//创建String类型的栈对象str
 7       for(int i=0; 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 }

运行结果如下：

    

 

 3.

 1 import java.util.*;
 2 class Counter {
 3     int i = 1;
 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)之间的随机数
14           if(ht.containsKey(r))
15               ((Counter)ht.get(r)).i++;//统计每个随机数出现的次数
16           else
17               ht.put(r, new Counter());
18 }
19         System.out.println(ht);
20     }
21 }

运行结果如下：

 

测试程序2：

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

 1 package 实验十;
 2 import java.util.*;
 3 
 4 public class ArrayListDemo {
 5     public static void main(String[] argv) {
 6         ArrayList al = new ArrayList();
 7         // 初始化a1这个对象
 8         al.add(new Integer(11));
 9         al.add(new Integer(12));
10         al.add(new Integer(13));
11         al.add(new String("hello"));
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 }

运行结果如下：    

    

 

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

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

 1 import java.util.*;
 2 public class LinkedListTest
 3 {
 4    public static void main(String[] args)
 5    {
 6       List a = new LinkedList();//创建了一个线性表a,a的元素类型是String类
 7       a.add("Amy");
 8       a.add("Carl");
 9       a.add("Erica");
10 
11       LinkedList b = new LinkedList();
12       b.add("Bob");
13       b.add("Doug");
14       b.add("Frances");
15       b.add("Gloria");
16 
17       // 把b中的元素合并到a
18 
19       ListIterator aIter = a.listIterator();
20       Iterator bIter = b.iterator();
21 
22       while (bIter.hasNext())
23       {
24          if (aIter.hasNext()) aIter.next();
25          aIter.add(bIter.next());
26       }
27 
28       System.out.println(a);
29 
30       //
31 
32       bIter = b.iterator();
33       while (bIter.hasNext())
34       {
35          bIter.next(); // 跳过一个元素
36          if (bIter.hasNext())
37          {
38             bIter.next(); //跳过下一个元素
39             bIter.remove(); // 删除那个元素
40          }
41       }
42 
43       System.out.println(b);
44 
45       //批量操作：从a中删除b中的所有元素
46 
47       a.removeAll(b);
48 
49       System.out.println(a);
50    }
51 }

运行结果如下：

 

 

 1 import java.util.*;
 2 public class LinkedListDemo {
 3     public static void main(String[] argv) {
 4         LinkedList l = new LinkedList();
 5         l.add(new Object());
 6         l.add("Hello");
 7         l.add("zhangsan");
 8         ListIterator li = l.listIterator(0);
 9         while (li.hasNext())
10             System.out.println(li.next());
11         if (l.indexOf("Hello") < 0)   
12             System.err.println("Lookup does not work");
13         else
14             System.err.println("Lookup works");
15    }
16 }

 

 

 

 

 

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

测试程序1：

 1 package 实验十;
 2 
 3 import javax.swing.*;
 4 public class SimpleFrameTest
 5 {
 6    public static void main(String[] args)
 7    {
 8      JFrame  frame = new JFrame(); 
 9      frame.setBounds(0, 0,300, 200);//给出组件的位置及大小
10      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);////定义一个用户关闭框架时的响应动作
11      frame.setVisible(true);  //该组件是可见的  
12    }
13 }

2. 

 1 import java.awt.*;
 2 import javax.swing.*;
 3 
 4 /**
 5  * @version 1.34 2018-04-10
 6  * @author Cay Horstmann
 7  */
 8 public class SimpleFrameTest
 9 {
10    public static void main(String[] args)
11    {
12        //事件分派线程
13       EventQueue.invokeLater(() ->
14          {
15             SimpleFrame frame = new SimpleFrame();
16             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//定义一个用户关闭框架时的响应动作
17             frame.setVisible(true);//frame这个对象是可见的，即这个框架是可见的
18          });
19    }
20 }
21 
22 class SimpleFrame extends JFrame
23 {
24    private static final int DEFAULT_WIDTH = 300;
25    private static final int DEFAULT_HEIGHT = 200;
26 
27    public SimpleFrame()
28    {
29       setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);//给定这个组件的宽度和高度，设置其大小
30    }
31 }

运行结果如下：

  

 

测试程序2：

 1 import java.awt.*;
 2 import javax.swing.*;
 3 
 4 /**
 5  * @version 1.35 2018-04-10
 6  * @author Cay Horstmann
 7  */
 8 public class SizedFrameTest
 9 {
10    public static void main(String[] args)
11    {
12       EventQueue.invokeLater(() ->
13          {
14             JFrame frame = new SizedFrame();
15             frame.setTitle("SizedFrame");//给出组件的标题
16             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
17             frame.setVisible(true);
18          });
19    }
20 }
21 
22 class SizedFrame extends JFrame
23 {
24    public SizedFrame()
25    {
26       // 获取屏幕尺寸
27 
28       Toolkit kit = Toolkit.getDefaultToolkit();//创建Toolkit类对象
29       Dimension screenSize = kit.getScreenSize();  //调用getScreenSize方法，并以Dimension对象的形式返回屏幕的大小
30       int screenHeight = screenSize.height;
31       int screenWidth = screenSize.width;
32 
33       // 设置框架宽度、高度并让平台拾取屏幕位置
34 
35       setSize(screenWidth / 2, screenHeight / 2);
36       setLocationByPlatform(true);
37 
38       // 设置框架的图标
39 
40       Image img = new ImageIcon("icon.gif").getImage();
41       setIconImage(img);      
42    }
43 }

 

运行结果如下：

    

测试程序3：

 1 package notHelloWorld;
 2 
 3 import javax.swing.*;
 4 import java.awt.*;
 5 
 6 public class NotHelloWorld
 7 {
 8    public static void main(String[] args)
 9    {
10       EventQueue.invokeLater(() ->
11          {
12             JFrame frame = new NotHelloWorldFrame();
13             frame.setTitle("NotHelloWorld");//给出组件标题
14             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
15             frame.setVisible(true);//这个组件是可见的
16          });
17    }
18 }
19 
20 
21 class NotHelloWorldFrame extends JFrame
22 {
23    
24     private static final long serialVersionUID = -6750546436103958866L;
25 
26 public NotHelloWorldFrame()
27    {
28       add(new NotHelloWorldComponent());
29       pack();//调用pick()方法，使得在框架中填入组件时只使用它们的首选大小
30    }
31 }
32 
33 
34 class NotHelloWorldComponent extends JComponent
35 {
36    public static final int MESSAGE_X = 75;
37    public static final int MESSAGE_Y = 100;
38 
39    private static final int DEFAULT_WIDTH = 300;
40    private static final int DEFAULT_HEIGHT = 200;
41 
42    public void paintComponent(Graphics g)
43    {
44       g.drawString("Not a Hello, World program", MESSAGE_X, MESSAGE_Y);//在坐标（75，100）位置显示"Not a Hello, World program"这个字符串
45    }
46 
47    public Dimension getPreferredSize() 
48    {  
49       return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT); //返回一个有首选宽度和高度的Dimension对象
50    }
51 }

运行结果如下：

    

 

 实验总结： 在集合中学到了集合类，主要有Vector类，Stack类和Hashtable类。Vector类类似于数组，但其长度是可变的。Stack类描述了堆栈的数据结构，即FILO。Hashtable类通过键来查找元素，用散列码来确定键。集合中的基本接口中，collection是层次中的根接口，Set不能包含重复的元素，而list 是一个有序集合，主要有两个类的实现，ArrayList 和 LinkList类。  String类是新一代的图形界面工具，位于javax.swing包中。顶层窗口称为框架。由component类的子类或间接子类的对象称为一个组件，还有容器的概念。框架属性和框架定位的一些基本方法。因为都是一些验证性的实验，再加上看书，所以就理解的还可以。