201871010106-丁宣元 《面向对象程序设计（java)》第十二周学习总结

　　　　　　　　　　　　　　　　　　　　　　201871010106-丁宣元 《面向对象程序设计（java)》第十二周学习总结

正文开头:

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

正文内容:

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

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

　　　　1.框架：一个类库

　　　　　　　包括一些通用接口和超类，实现这些接口或者创建这些超类的子类就可方便的设计程序所需要的类

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

　　　　 3.集合框架：Java集合类库的统一架构

　　　　4.作用： (1)Java的集合类提供了对基本数据类型的支持       eg:Vector、Hashtable、Stack

　　　　　　        (2)集合类的使用：集合类包含在java.util包中        导入用import.java.util.*

　　　　5.特点：只容纳对象

　　　　　　　　数组可以容纳基本数据类型的数据和对象

　　　　6.新旧集合类

　　　　  Java1.0和JDK1.1中:Vector（矢量），Hashtable（哈希表），Stack(堆栈)，Properties（属性集）

　　　　　　a.Vector类：类似长度可变的数组，只能存放对象，通过下标进行访问

　　　　　　　　关键属性：capacity：集合最多能容纳的元素个数

　　　　　　　　　　　　　capacityIncrement：每次增加多少容量

　　　　　　　　　　　　　size：当前元素的集合

　　　　　　　　关键方法：void  addElement(Object   obj)，

　　　　　　　　　　void   add（int  index，  Object   element），

　　　　　　　　　　Object  elementAt（int   index），

　　　　　　　　　　void   insertElementAt（Object   obj，  int  index）

　　　　　　b.Stack类：Vectoe类的子类

　　　　　　　　　　   Stack类描述堆栈数据结构，即FILO

　　　　　　　　　　  关键方法:public   void  push（Object   item)

　　　　　　　　　　　　　　　public  Object   pop()

　　　　　　　　　　　　　　　public  Object  peek()

　　　　　　　　　　　　　　   public    Boolean   empty()

　　　　　　c.Hashtable类：通过键值来查找元素

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

　　　　Java1.2:设计了一个统一的类集：Collection,

　　　　　　　　　　　　　　　　　　　　List,

　　　　　　　　　　　　　　　　　　　　Set,

　　　　　　　　　　　　　　　　　　　　Map

　9-2 集合框架中的基本接口

　　　　

　　　　1.详解：

　　　　　　Collection：集合层次中的根接口

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

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

　　　　　　Map：包含key—value 对，不能包含重复的key

　　　　　　SortedMap：是一个按升序排列key的Map。

　　    2.集合框架中的类：

　　　　a.List：元素都有一个确定的顺序；

　　　　类ArrayListLinkedList，元素在内存中是顺序存储

　　　　　　能够自动增长容量的数组，利用ArrayList的toArrY()返回一个数组

　　　　　　Arrays.asList()返回一个列表

　　　　  类LinkedList，元素在内存中是链表方式存储

　　　　　　采用双向循环链表实现的

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

　　      b.Set：必须定义equals方法，提供算法来判断欲添加进来的元素是否与已经存在的某对象相等

　　　　　　实现Set接口的类:HashSet，TreeSet。

　　　c.TreeSet:一个有序集合

　　　　　　   元素按照升序排列，TreeSet中元素要实现Comparable接口

　　　　　　在构造TreeSet对象时，传递实现了Comparable接口的比较器对象

　　　　　　HashSet是基于Hash算法实现的，其性能通常都优于TreeSet，使用HashSet，需要排序的功能时，使用TreeSet。

　　　d.Map：用来处理”键—值“对，以便通过键值来查找相应的元素

　　　　　　  基于散列表实现（替代Hashtable）

　　　　　　  TreeMap在一个二叉树的基础上实现。

　　　　　1.定义：

　　　　　　　　Map接口映射唯一关键字的值。

　　　　　　　　关键字（key）:用于检索值得对象。

　　　　　　　　　　给定一个关键字和值，可以存储这个值到一个Map对象中。

　　　　　　　　　　当值被存储后，就可以使用关键字来检索它

　　　　　　2.Map循环:get（）

　　　　　　　　　　　put（）：可以将一个指定了”关键字和值“得值加入映射，为了得到值，可以将关键字作为参数来调用get（）方法。

　　　　　　3.方法：boolean   containsKey（Object   K） ；

　　　　　　　　　　 boolean   containsValue（Object  v）  ；

　　　　　　　　　　Object   get（Object  k） ；

　　　　　　　　　　Boolean  isEmpty（）；

　　　　　　　　　　Object   put（Object  k， Object  v） ;

　　　　　　　　　　 Object  remove （Object  k）

　　　　　　4.接口：实现类：HashMap、TreeMap、Hashtable、properties

　　　　　第九章总结：

　　　　　　可以为大型，小型作业提供便利；

　　第十章

　　　　10-1AWT与Swing简介

　　　　　1.用户界面：用户与计算机系统（各种程序）交互的接口

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

　　　　　2.AWT：

　　　　　　　　Java的抽象窗口工具箱在java.util包中，提供了许多用来设计GUI的组件类和容器类；

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

　　　　　　　　缺陷：菜单、滚动条、和文本域等用户界面元素，在不同的平台，操作行为存在一些微妙的差异。

　　　　　3.AWT组件

　　　　　4.Swing：具有更加丰富且方便的用户界面元素的集合；底层平台的依赖很少；Swing类库在javax.swing包里；组件层次关系　　　　　　

　　　　 5.AWT与Swing的关系

　　　　　　　　组件：构成图形用户界面的元素，用图形显示。

　　　　　　　　通常把由Comparable类的子类后者间接子类创建的对象称为一个组件。

　　　　  6.容器：Java中能容纳和排列组件的组件

　　　　　　　　a.常用的容器时框架：（Frame，JFrame）

　　　　　　　　　　　　API：void   setResizable（boolean   b） ，

　　　　　　　　　　　　　　void    set Title（String    s），

　　　　　　　　　　　　　　void   setIconImage（Image  image）

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

　　　　　　　　　　　　　　eg:fra.add(button)

　　　　　　　　　　可以把一个容器添加到另一个容器里，实现容器嵌套

　　　　7.框架的创建（Frame）

　　　　　　　　a.创建空框架：常采用框架创建初始界面，即GUI的顶层窗口

　　　　　　　　 b.框架定位于框架属性

　　　　　　　　　　　　定位：用Component类的setLocation和setBounds方法

　　　　　　　　　　　　属性：Title：框架标题

　　　　　　　　　　　　　　　IconImage：框架图标

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

　　　　8.在组件中显示信息：

　　　　　　a.JFrame的结构：根面板、层级面板、玻璃面板和内容面板四层面板

　　　　　　　　用户也可以自行创建一个组件类；此时需要重载paintComponent（）

　　　　*9.图形编程：2D图形   坐标系         图形类：

　　　　10.颜色的使用：Graphics 2D类的setPaint方法

　　　　　　a.标准色

　　　　　　b.复合色

　　　　11.字体的使用： (1)  AWT的五种逻辑字体名：SanaSerif      Serif     Monospaced    Dialog    Dialoginput

　　　　　　　　　　　  （2）字体风格：Font.PLAIN        Font.BOLD     Font.ITALIC     Font.BOLD+Font.ITALIC

　　　　12.图像：

　　　　　　 将一个图像文件加载到程序中，调用Graphics类提供的DrawImage（）显示

　　　　　　　　eg:

　　　　　　　　　　public   void   paintComponent（Graphics  g）

　　　　　　　　　　{   g.drawImage（image   x ， y，null）}

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

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

　　   测试程序1：

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

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

　　　　示例代码1：

//示例程序1
import java.util.Vector;
class Cat {
     private int catNumber;//Cat的私有属性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++)      //for循环
           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={"金","银","铜","铁"};//字符串数组month
   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));//数组下标从0开始，故element 2应为铜
      while(!stk.empty())    //循环出栈，直至栈内元素为空
          System.out.println(stk.pop());//打印出栈元素，先入后出，即出栈的顺序为铁，铜，银，金
  }
}

　　结果：

　　示例代码3：

　　

import java.util.*;
class Counter {
    int i = 1;//friendly
    public String toString() {//将其他类型的数据转换为字符串类型
        return Integer.toString(i);
    }
}

public class Statistics {
    public static void main(String[] args) {
        Hashtable ht = new Hashtable();//创建哈希表这个数据类型，名为ht
        for (int i = 0; i < 10000; i++) {
            Integer r = new Integer((int) (Math.random() * 20));//将自动生成的0—20的数强制类型转换为int
            if(ht.containsKey(r))   //判断r是否是哈希表中某个元素的键值
              ((Counter)ht.get(r)).i++;//是，则用get方法获得值，i++
            else
              ht.put(r, new Counter());
}
        System.out.println(ht);
    }
}

　　结果：

　　测试程序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...   在ArrayList中添加元素
        al.add(new Integer(11));//利用add方法
        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);//通过迭代器生成对象产生方法hasNext返回
        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)
   {
      List<String> a = new LinkedList<String>();//创建泛型a链表
      a.add("Amy");
      a.add("Carl");
      a.add("Erica");

      List<String> b = new LinkedList<String>();//创建泛型b链表
      b.add("Bob");
      b.add("Doug");
      b.add("Frances");
      b.add("Gloria");

      // merge the words from b into a  合并a,b中的单词

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

      // remove every second word from b   从第二个链表中每隔一个元素删除一个元素

      bIter = b.iterator();
      while (bIter.hasNext())
      {
         bIter.next(); // skip one element 跳到第一个元素
         if (bIter.hasNext())
         {
            bIter.next(); // skip next element 跳到下一个元素
            bIter.remove(); // remove that element
         }
      }

      System.out.println(b);

      // bulk operation: remove all words in b from a 批量操作: 删除从b到a的所有单词

      a.removeAll(b);

      System.out.println(a);
   }
}

　　结果：

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

　　 测试程序1：

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

　　　　代码：

package linkedList;
import javax.swing.*;
public class SimpleFrameTest
{
   public static void main(String[] args)
   {
     JFrame  frame = new JFrame(); //JFrame框架
     frame.setBounds(0, 0,300, 200);//setBounds方法，从左上角开始，width:300,height: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(() ->   //lambda表达式
         {
            SimpleFrame frame = new SimpleFrame();
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置关闭框
            frame.setVisible(true);//窗口可见
         });
   }
}

class SimpleFrame extends JFrame//SimpleFrame继承JFrame
{
   private static final int DEFAULT_WIDTH = 300;//常量
   private static final int DEFAULT_HEIGHT = 200;

   public SimpleFrame()
   {
      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);//设置大小
   }
}

　　结果：

　　测试程序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(() ->     //lambda表达式
         {
             JFrame frame = new SizedFrame();
            frame.setTitle("SizedFrame");//设置标题
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置关闭
            frame.setVisible(true);//窗口可见
         });
   }
}

class SizedFrame extends JFrame//SizedFrame继承于JFrame
{
   public SizedFrame()
   {
      // get screen dimensions得到屏幕的大小

      Toolkit kit = Toolkit.getDefaultToolkit();
      Dimension screenSize = kit.getScreenSize();//以Dimension对象的形式返回屏幕的大小
      int screenHeight = screenSize.height;
      int screenWidth = screenSize.width;

      // set frame width, height and let platform pick screen location

      setSize(screenWidth / 2, screenHeight / 2);//将框架设置为屏幕大小的一半
      setLocationByPlatform(true);

      // set frame icon

      Image img = new ImageIcon("icon.gif").getImage();//提供图标
      setIconImage(img);
   }
}

　　结果：

　　测试程序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(() ->     //lambda表达式
         {
            JFrame frame = new NotHelloWorldFrame();
            frame.setTitle("NotHelloWorld");//标题为NotHelloWorld
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置关闭
            frame.setVisible(true);//可见
         });
   }
}

/**
 * A frame that contains a message panel.
 */
class NotHelloWorldFrame extends JFrame//NotHelloWorldFrame继承JFrame
{
   public NotHelloWorldFrame()
   {
      add(new NotHelloWorldComponent());//添加窗口
      pack();
   }
}

/**
 * A component that displays a message.
 */
class NotHelloWorldComponent extends JComponent//NotHelloWorldComponent继承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;

   public void paintComponent(Graphics g)//绘图
   {
      g.drawString("Not a Hello, World program", MESSAGE_X, MESSAGE_Y);
   }

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

　　结果：

　　

　　关于结对编程：

　　　　以下图片是一个结对编程场景：两位学习伙伴坐在一起，面对着同一台显示器，使用着同一键盘，同一个鼠标，他们一起思考问题，一起分析问题，一起编写程序。关于结对编程的阐述可参见以下链接：

　　　　http://www.cnblogs.com/xinz/archive/2011/08/07/2130332.html，http://en.wikipedia.org/wiki/Pair_programming

　　　　 对于结对编程中代码设计规范的要求参考：http://www.cnblogs.com/xinz/archive/2011/11/20/2255971.html

　　　　结对编程：一种敏捷软件开发的方法，两个程序员在一个计算机上共同工作。一个人输入代码，而另一个人审查他输入的每一行代码。输入代码的人称作驾驶员，审查代码的人称作观察员。观察员同时考虑工作的战略性方向，提出改进的意见，增加代码的健壮性。在写代码时，可以互相讨论，提供思路。

 

三.实验总结

　　通过本次实验，我了解了：1.Vetor、Stack、Hashtable三个类用途及API           2.ArrayList、LinkList类的用法

3.Java GUI中框架创建及简单属性设置

　　本次实验以验证性实验为主，主要集中于加深对数据结构中常见类的用法和简单框架的构造，对简单的数据结构有了更进一步的理解。存在的问题是对Hashtable代码的理解有一些困难，还有lambda表达式不太理解，熟悉。在空闲时间我要把lambda表达式多下一些功夫再次理解。在理解书上代码后，尝试着在理解的基础上自己动手敲代码有困难，在写的过程中问题很多，有些问题看似明白了，实质上对本质还是不理解，致使写出来很空难，要多尝试多写写。其次对结对编程的要求和优点有了了解。