201871010116-祁英红《面向对象程序设计（java）》第十二周学习总结

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

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

随笔博文正文内容包括：

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

一、集合

1.一般将数据结构分为两大类：线性数据结构和非线性数据结构。

（1）线性数据结构：线性表、栈、队列、串、数组和文件。

（2）非线性数据结构：树和图。

2.线性表：

3.链表：（1）单向链表

（2）循环链表

（3）双向循环链表

4.栈：栈(Stack)也是一种特殊的线性表，是一种后进先出(LIFO)的结构。栈是限定仅在表尾进行插入和删除运算的线性表，表尾称为栈顶(top)，表头称为栈底(bottom)。

5.队列：队列(Queue)是限定所有的插入只能在表的一端进行，而所有的删除都在表的另一端进行的线性表。表中允许插入的一端称为队尾(Rear)，允许删除的一端称为队头(Front)。队列的操作是按先进先出(FIFO)的原则进行的。

6.散列表：散列表又称为哈希表。散列表算法的基本思想是：以结点的关键字为自变量，通过一定的函数关系（散列函数）计算出对应的函数值，以这个值作为该结点存储在散列表中的地址。当散列表中的元素存放太满，就必须进行再散列，将产生一个新的散列表，所有元素存放到新的散列表中，原先的散列表将被删除。

7.JAVA的集合框架：JAVA的集合框架实现对各种数据结构的封装，以降低对数据管理与处理的难度所谓框架就是一个类库的集合，框架中包含很多超类，编程者创建这些超类的子类可较方便的设计设计程序所需的类。例如：Swing类包集合(Collection或称为容器)是一种包含多个元素并提供对所包含元素操作方法的类，其包含的元素可以由同一类型的对象组成，也可以由不同类型的对象组成。

8.集合类的作用：

– Java的集合类提供了一些基本数据结构的支持。
– 例如Vector、Hashtable、Stack等。

9.集合类的使用：

– Java的集合类包含在java.util包中。
– import java.util.*;

10.集合类的特点：

（1）只容纳对象。数组可以容纳基本数据类型数据和对象。

如果集合类中想使用基本数据类型，又想利用集合类的灵活性，可以把基本数据类型数据封装成该数据类型的包装器对象，然后放入集合中处理。

（2） 集合类容纳的对象都是Object类的实例，一旦把一个对象置入集合类中，它的类信息将丢失，这样设计的目的是为了集合类的通用性。

因为Object类是所有类的祖先，所以可以在这些集合中存放任何类的对象而不受限制，但切记在使用集合成员之前必须对它重新造型。

11.新旧集合类：在JDK1.0和JDK 1.1中提供了Vector（矢量），Hashtable （ 哈希表） ， Stack （ 堆栈） ，Properties（属性集）等集合类，

尽管这些类非常有用，但却彼此独立，缺少一个统一集中的机制。

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

（2）Stack类：Stack类是Vector的子类。 Stack类描述堆栈数据结构，即LIFO。

（3）Hashtable类：Hashtable通过键来查找元素。Hashtable用散列码（hashcode）来确定键。

所有对象都有一个散列码，可以通过Object类的hashCode()方法获得。

12.在JDK1.2中，JAVA设计了一个统一的类集，并对上述类进行了改写，使其统一纳入JAVA的集合框架。

集合框架中的基本接口：

（1）Collection：集合层次中的根接口，JDK未提供这个接口的直接实现类。

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

（3）List：是一个有序的集合，可以包含重复的元素。提供了按索引访问的方式。

（4）Map：包含了key-value对。Map不能包含重复的key

（5）SortedMap是一个按照升序排列key的Map。

二、图形程序设计

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

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

3.Swing用户界面库是非基于对等体的GUI工具箱。Swing具有更丰富并且更方便的用户界面元素集合。Swing对底层平台的依赖很少，因此与平台相关的bug很少。Swing会带来交叉平台上的统一视觉体验。Swing类库被放在 javax.swing 包里。

4.大部分AWT组件都有其 Swing的等价组件。Swing组件的名字一般是在AWT组件名前面添加一个字母“J”，如：JButton,JFrame,JPanel等。

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

6.组件类的常用API

 java.awt.Component 1.0

– boolean isVisible() 检查组件是否可见

– void setVisible(boolean b) 设置组件可见

– void setSize(int width,int height) 把组件缩放到指定宽度和高度

– void setBounds(int x,int y,int width,int height) 移动并缩放组件

– Dimension getSize() 得到组件的大小

– void setSize(Dimension d) 把组件缩放到指定的大小

– void setLocation(int x,int y)

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

Container类提供了一个方法add(),用来在容器类 组件对象中添加其他组件。

容器本身也是一个组件，可以把一个容器添加到 另一个容器里，实现容器嵌套。

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

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

Jframe的结构：它由根面板、层级面板、玻璃面板和内容面板（content pane）四层面板构成。

Swing程序员最关心的是内容面板，也称为内容窗格。

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

其中内容窗格是用来添加组件的，添加代码如下：Container contentPane = getContentPane(); Component c=…; contentPane.add(c);

用户也可以自行创建一个组件类，并在组件上进行绘制，此时需要重载paintComponent()。用户的自建组件也可添加到内容窗格里。

paintComponent(Graphics g)定义在JComponent类中，该方法在窗口需要重新绘图时(如扩大窗口或极小化窗口),被系统自动调用.

paintComponent()方法被调用时，系统就自动产生一个Graphics类型的参数，传递给paintComponent方法中的参数g。

第二部分：实验部分

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

测试程序1：

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

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

示例程序1代码如下：

//示例程序1
import java.util.Vector;
class Cat {
	 private int catNumber;
	 Cat(int i) {
		catNumber = i;
	}
	 void print() {
		System.out.println("Cat #" + catNumber);
	 }
}
public class Cats{
public static void main(String[] args){
       Vector<Cat> cats= new Vector<Cat>();
       for(int i=0; i<7; i++)
           cats.addElement(new Cat(i)); 
       for(int i=0; i<cats.size(); i++)
           (cats.elementAt(i)).print();
   }
}

　　程序运行结果如下：

示例程序2代码如下：

//示例程序2
import java.util.*;
public class Stacks
{
   static String[] months={"金","银","铜","铁"};
   public static void main(String[] args){
      Stack<String> stk = new Stack<String> ();
      for(int i=0; i<months.length; i++)
          stk.push(months[i]);
      System.out.println(stk);
      System.out.println("element 2=" + stk.elementAt(2));
      while(!stk.empty())
          System.out.println(stk.pop());
  }
}

　　程序运行结果如下：

示例程序3代码如下：

//示例程序3
import java.util.*;
class Counter {
	int i = 1;
	public String toString() {
		return Integer.toString(i);
	}
}

public class Statistics {
	public static void main(String[] args) {
		Hashtable ht = new Hashtable();
		for (int i = 0; i < 10000; i++) {
			Integer r = new Integer((int) (Math.random() * 20));
if(ht.containsKey(r))
              ((Counter)ht.get(r)).i++;
          else
              ht.put(r, new Counter());
}
		System.out.println(ht);
	}
}

　　程序运行结果如下：

Vetor、Stack、Hashtable三个类的用途：

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

（2）Stack类：Stack类是Vector的子类。 Stack类描述堆栈数据结构，即LIFO。

（3）Hashtable类：Hashtable通过键来查找元素。Hashtable用散列码（hashcode）来确定键。

测试程序2：

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

 程序代码如下：

 ArrayListDemo:

import java.util.*;

public class ArrayListDemo {
	public static void main(String[] argv) {
		ArrayList al = new ArrayList();
		// Add lots of elements to the ArrayList...
		al.add(new Integer(11));
		al.add(new Integer(12));
		al.add(new Integer(13));
		al.add(new String("hello"));
		// First print them out using a for loop.
		System.out.println("Retrieving by index:");
		for (int i = 0; i < al.size(); i++) {
			System.out.println("Element " + i + " = " + al.get(i));
		}
	 }
}

　　运行结果如下：

LinkedListDemo:

import java.util.*;
public class LinkedListDemo {
    public static void main(String[] argv) {
        LinkedList l = new LinkedList();
        l.add(new Object());
        l.add("Hello");
        l.add("zhangsan");
        ListIterator li = l.listIterator(0);
        while (li.hasNext())
            System.out.println(li.next());
        if (l.indexOf("Hello") < 0)   
            System.err.println("Lookup does not work");
        else
            System.err.println("Lookup works");
   }
}

　　运行结果如下：

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

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

程序代码如下：

package linkedList;

import java.util.*;

/**
 * This program demonstrates operations on linked lists.
 * @version 1.12 2018-04-10
 * @author Cay Horstmann
 */
public class LinkedListTest
{
   public static void main(String[] args)
   {
      var a = new LinkedList<String>();
      a.add("Amy");
      a.add("Carl");
      a.add("Erica");

      var b = new LinkedList<String>();
      b.add("Bob");
      b.add("Doug");
      b.add("Frances");
      b.add("Gloria");

   // 将单词从B合并为A

      ListIterator<String> aIter = a.listIterator();
      Iterator<String> bIter = b.iterator();

      while (bIter.hasNext())
      {
         if (aIter.hasNext()) aIter.next();
         aIter.add(bIter.next());
      }

      System.out.println(a);

   // 从B中删除每个第二个单词

      bIter = b.iterator();
      while (bIter.hasNext())
      {
         bIter.next(); // 跳过一个元素
         if (bIter.hasNext())
         {
            bIter.next();  // 跳过下一个元素
            bIter.remove();  // 删除该元素
         }
      }

      System.out.println(b);

      // 批量操作：从A中删除B中的所有单词

      a.removeAll(b);

      System.out.println(a);
   }
}

　　运行结果如下：

ArrayList、LinkList两个类的用途：

 （1）ArrayList 类提供了快速的基于索引的成员访问方式，对尾部成员的增加和删除支持较好。使用 ArrayList 创建的集合，允许对集合中的元素进行快速的随机访问，不过，向 ArrayList 中插入与删除元素的速度相对较慢。

 （2）LinkedList 类采用链表结构保存对象，这种结构的优点是便于向集合中插入或者删除元素。需要频繁向集合中插入和删除元素时，使用 LinkedList 类比 ArrayList 类效果高，但是 LinkedList 类随机访问元素的速度则相对较慢。

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

测试程序1：

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

程序代码如下：

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);    
   }
}

　　运行结果如下：

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

掌握空框架创建方法；

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

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

程序代码如下：

package simpleFrame;

import java.awt.*;
import javax.swing.*;

/**
 * @version 1.34 2018-04-10
 * @author Cay Horstmann
 */
public class SimpleFrameTest
{
   public static void main(String[] args)
   {
	   //事件分派线程中的执行操作
      EventQueue.invokeLater(() ->
         {
            var frame = new SimpleFrame();
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//定义一个用户关闭这个框架时的响应动作
            frame.setVisible(true);//调用setVisible(true)显示一个组件
         });
   }
}

class SimpleFrame extends JFrame
{
   private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 200;
//构造器将框架大小设置为300*200像素
   public SimpleFrame()
   {
      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
   }
}

　　运行结果如下：

 

创建空框架：

1）在Java中，常采用框架（Frame）创建初始界面，即GUI的顶层窗口

 2）AWT库中有一个基于对等体的Frame类。

3）该类的Swing版本为JFrame,JFrame是Frame子类。

测试程序2：

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

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

 程序代码如下：

package sizedFrame;

import java.awt.*;
import javax.swing.*;

/**
 * @version 1.35 2018-04-10
 * @author Cay Horstmann
 */
public class SizedFrameTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() ->
         {
            var frame = new SizedFrame();
            frame.setTitle("SizedFrame");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setVisible(true);
         });
   }
}

class SizedFrame extends JFrame
{
   public SizedFrame()
   {

      Toolkit kit = Toolkit.getDefaultToolkit();//调用Toolkit类的静态方法getDefaultToolkit得到一个Toolkit对象
      Dimension screenSize = kit.getScreenSize();//调用getScreenSize方法，这个方法以Dimension对象的形式返回屏幕的大小
      int screenHeight = screenSize.height;
      int screenWidth = screenSize.width;
      
      //Dimension对象同时用公有实例变量width和height保存着屏幕的宽度和高度

      setSize(screenWidth / 2, screenHeight / 2);//将框架大小设定为上面取值的50%
      setLocationByPlatform(true);//告知窗口系统定位框架

      //使用工具箱加载图像，然后将图像设置为框架的图标
      Image img = new ImageIcon("icon.gif").getImage();
      setIconImage(img);      
   }
}

　　运行结果如下：

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

测试程序3：

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

掌握在框架中添加组件；

掌握自定义组件的用法。

程序代码如下：

package notHelloWorld;

import javax.swing.*;
import java.awt.*;

/**
 * @version 1.34 2018-04-10
 * @author Cay Horstmann
 */
public class NotHelloWorld
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() ->
         {
            var frame = new NotHelloWorldFrame();
            frame.setTitle("NotHelloWorld");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//定义一个用户关闭这个框架时的响应动作
            frame.setVisible(true);//调用setVisible(true)显示一个组件
         });
   }
}

/**
 * A frame that contains a message panel.
 */

//调用pack方法使用框架中填入的组件的首选大小
class NotHelloWorldFrame extends JFrame
{
   public NotHelloWorldFrame()
   {
      add(new NotHelloWorldComponent());
      pack();
   }
}

/**
 * A component that displays a message.
 */

//覆盖getPreferredSize方法，返回一个有首选宽度和高度的Dimension类对象
class NotHelloWorldComponent extends JComponent
{
   public static final int MESSAGE_X = 75;
   public static final int MESSAGE_Y = 100;

   
   private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 200;
   //构造器将框架大小设置为300*200像素
   
   public void paintComponent(Graphics g)
   {
      g.drawString("Not a Hello, World program", MESSAGE_X, MESSAGE_Y);
      //用drawString方法调用，显示文本是一种特殊的绘图：在原始窗口大约水平1/4，垂直1/2的位置显示字符串Not a Hello, World program
   }

   public Dimension getPreferredSize() 
   {  
      return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT); 
   }
}

　　运行结果如下：

创建框架

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

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

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

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型组件外，其它类型组件默认是可见的。

 三、实验总结：（19分）

  本周学习了图形用户界面，即以图形的方式呈现的用户界面。在学习理论知识时初步了解了绘制图形的常用API以及如何设置字体和颜色，在web前端开发技术课程中基本了解了字体、颜色的设置，最基本的用法需要牢记掌握，因此这一章比较容易理解这部分的内容，实验课上通过运行课本上的程序，进一步了解了图形用户界面。通过本章的学习我了解了如何用一些组件去画字，图形，以及图形用户界面的一些基础的设计操作，比如窗口显示不同图形，文字等等，觉得很有意思；但实际用这些知识自己去设计图形还是会有一定的难度。通过练习题集练习学过的内容，对学过的知识进行了再巩固，加深了理解。