201871010112-梁丽珍《面向对象程序设计（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；

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

第9章  集合
●JAVA中的集合框架
●JDK1.1版本集合类.
●JDK1.2以上版本集合类

JAVA的集合框架
1）JAVA的集合框架实现对各种数据结构的封装。

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

3）集合(或称为容器)是一类包含多个元素并提供对所包含元素操作方法的类，其包含的元素可以由同一类型的对象组成，也可以由不同类型的对象组成。

4）集合框架: JAVA集合类库的统一架构。

Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。

集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：

• 接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象

• 实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。

• 算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。

除了集合，该框架也定义了几个 Map 接口和类。Map 里存储的是键/值对。尽管 Map 不是集合，但是它们完全整合在集合中。

集合框架体系如图所示

Java 集合框架提供了一套性能优良，使用方便的接口和类，java集合框架位于java.util包中， 所以当使用集合框架的时候需要进行导包。

集合类的作用
　　集合类的作用:
　　1）Java的集合类提供了对基本数据结构的支持。
　　　例如Vector、Hashtable、 Stack等 。
　　集合类的使用:
　　2）Java的集合类包含在java.util包中。
　　　import java.util.*;

集合类的特点
　　1）只容纳对象。
　　　　注意:数组可以容纳基本数据类型数据和对象。
　　　　如果集合类中想使用基本数据类型，又想利用集合类的灵活性，可以把基本数据类型数据封装成该数据类型的包装器对象，然后放入集合中处理。

新旧集合类

　　1）在JDK1.0和JDK 1.1中提供了Vector (矢量)，Hashtable (哈希表),，Stack (堆栈) ,Properties (属性集)等集合类，尽管这些类非常有用，但却彼此独立，缺少一个统-集中的机制。

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

集合接口

序号	接口描述
1	Collection 接口 Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。 Collection 接口存储一组不唯一，无序的对象。
2	List 接口 List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。 List 接口存储一组不唯一，有序（插入顺序）的对象。
3	Set Set 具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。 Set 接口存储一组唯一，无序的对象。
4	SortedSet 继承于Set保存有序的集合。
5	Map Map 接口存储一组键值对象，提供key（键）到value（值）的映射。
6	Map.Entry 描述在一个Map中的一个元素（键/值对）。是一个Map的内部类。
7	SortedMap 继承于 Map，使 Key 保持在升序排列。
8	Enumeration 这是一个传统的接口和定义的方法，通过它可以枚举（一次获得一个）对象集合中的元素。这个传统接口已被迭代器取代。

Set和List的区别

• 1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。

• 2. Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。

• 3. List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

集合实现类（集合类）

　　Java提供了一套实现了Collection接口的标准集合类。其中一些是具体类，这些类可以直接拿来使用，而另外一些是抽象类，提供了接口的部分实现。

序号	类描述
1	AbstractCollection  实现了大部分的集合接口。
2	AbstractList  继承于AbstractCollection 并且实现了大部分List接口。
3	AbstractSequentialList  继承于 AbstractList ，提供了对数据元素的链式访问而不是随机访问。
4	LinkedList 该类实现了List接口，允许有null（空）元素。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个List，则必须自己实现访问同步，解决方法就是在创建List时候构造一个同步的List。例如： Listlist=Collections.synchronizedList(newLinkedList(...)); LinkedList 查找效率低。
5	ArrayList 该类也是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%，插入删除效率低。
6	AbstractSet  继承于AbstractCollection 并且实现了大部分Set接口。
7	HashSet 该类实现了Set接口，不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能一个。
8	LinkedHashSet 具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
9	TreeSet 该类实现了Set接口，可以实现排序等功能。
10	AbstractMap  实现了大部分的Map接口。
11	HashMap HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。 该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。
12	TreeMap 继承了AbstractMap，并且使用一颗树。
13	WeakHashMap 继承AbstractMap类，使用弱密钥的哈希表。
14	LinkedHashMap 继承于HashMap，使用元素的自然顺序对元素进行排序.
15	IdentityHashMap 继承AbstractMap类，比较文档时使用引用相等。

序号	类描述
1	Vector 该类和ArrayList非常相似，但是该类是同步的，可以用在多线程的情况，该类允许设置默认的增长长度，默认扩容方式为原来的2倍。
2	Stack 栈是Vector的一个子类，它实现了一个标准的后进先出的栈。
3	Dictionary Dictionary 类是一个抽象类，用来存储键/值对，作用和Map类相似。
4	Hashtable Hashtable 是 Dictionary(字典) 类的子类，位于 java.util 包中。
5	Properties Properties 继承于 Hashtable，表示一个持久的属性集，属性列表中每个键及其对应值都是一个字符串。
6	BitSet 一个Bitset类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。

Vector类
　　1)Vector类类似长度可变的数组。
　　2）Vector中只能存放对象。
　　3）Vector的元素通过下标进行访问。
　　4）Vector类关键属性:
　　　　— capacity表示集合最多能容纳的元素个数。
　　　　— capacityIncrement表示每次增加多少容量。
　　　　— size表示集合当前元素个数。
　　　Vector v = new Vector(100)

　Vector类的关键方法:
　　- void addElement(Object obj)
　　- void add(int index, Object element)
　　- Object elementAt(int index)
　　- void insertElementAt(Object obj, int index)

 Stack类
　　1）Stack类是Vector的子类。
　　2）Stack类描述堆栈数据结构，即FILO。
　　3）Stack类的关键方法:
　　　　— public void push(Object item) //把项压入栈顶
　　　　— public Object pop()
　　　　　　//移除栈顶对象并作为此函数的值返回该对象
　　　　— public Object peek()
　　　　　　//查看栈顶对象而不移除它
　　　　— public boolean empty()

　　　　　　//测试堆栈是否为空

 Hashtable类
　　1）Hashtabl e通过键来查找元素。
　　2）Hashtable用散列码( hashcode)来确定键。所有对象都有一个散列码，可以通过0bject类的hashCode()方法获得。

Hashtable类举例
　　1）示例检验Math.random()方法的随机性。理想情况下，该访法产生一系列随机分布的数字。为了验

证,需要生成数量众多的随机数字，然后计算落在不同范围内的数字量。

　　2）示例程序生成10000个随机数，查看它们在0~20之间的分布如何。

　　3）Math.random()
　　　　返回带正号的double值，大 于或等于0.0，小于1.0.

 集合框架中的基本接口
　　1）Collection: 集合层次中的根接口。
　　2）Set:不能包含重复的元素。对象可能不是按存放的次序存放，也就是说不能像数组一样按索引的方式进行

访问，SortedSet是---个按照升序排列元素的Set。
　　3）List: 是一个有序的集合，可以包含重复的元素。提供了按索引访问的方式。

　　4）Map:包含了key-value对，不能包含重复的key。
　　5）SortedMap是一个 按照升序排列key的Map。

 集合框架中的类

 

Collection接口

Collection接口作为集合类的父类接口，Collectio位于java.util包下，Collectio定义了很多集合操作的方法。

　　Collection接口源码

Collection接口继承Iterable接口。

　　Collection接口方法汇总以及详解

package java.util;

import java.util.function.Predicate;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public interface Collection<E> extends Iterable<E> {
    /**
     * @return 用于返回集合中元素的个数（最大个数）
     */
    int size();

    /**
     * @return 用于判断集合中是否存在某个元素，不存在返回true
     */
    boolean isEmpty();

    /**
     * 判断集合中是否存在指定元素，存在返回true
     *
     * @param o是用于判断的元素
     */
    boolean contains(Object o);

    /**
     * @return 返回可用于遍历的迭代器
     */
    Iterator<E> iterator();

    /**
     * @return 将集合转变成数组
     */
    Object[] toArray();

    /**
     * @return 将指定集合转变成对应的数组
     */
    <T> T[] toArray(T[] a);

    /**
     * @return 往集合中添加元素，添加成功返回true
     */
    boolean add(E e);

    /**
     * @return 在集合中删除指定的元素，成功返回true
     */
    boolean remove(Object o);

    /**
     * @return 判断集合中是否包含集合C，如果包含返回true
     */
    boolean containsAll(Collection<?> c);

    /**
     * @return 将集合C添加到集合中，添加成功返回true
     */
    boolean addAll(Collection<? extends E> c);

    /**
     * @return 从集合中删除集合C，删除成功返回true
     */
    boolean removeAll(Collection<?> c);

    /**
     * @return 删除集合中复合条件的元素，删除成功返回true
     * @since 1.8
     */
    default boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        final Iterator<E> each = iterator();
        while (each.hasNext()) {
            if (filter.test(each.next())) {
                each.remove();
                removed = true;
            }
        }
        return removed;
    }

    /**
     * @return 保留集合中集合C中的元素
     */
    boolean retainAll(Collection<?> c);

    /**
     * 清空集合中的所有元素
     */
    void clear();

    /**
     * @return 比较O与集合中的元素
     */
    boolean equals(Object o);

    /**
     * @return 返回此集合的哈希码值。
     */
    int hashCode();

    /**
     *
     * @return a {@code Spliterator} over the elements in this collection
     * @since 1.8
     */
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }

    /**
     * @return a sequential {@code Stream} over the elements in this collection
     * @since 1.8
     */
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    /**
     * @return a possibly parallel {@code Stream} over the elements in this
     * collection
     * @since 1.8
     */
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
}

List

　　1)List的明显特征是它的元素都有一个确定的顺序。

　　2)实现它的类有ArrayList和L inkedL ist。

　　　　— ArrayList中的元素在内存中是顺序存储的。

　　　　— LinkedList中 的元素在内存中是以链表方式存储的。

 ArrayList 和linkedList
　　1)ArrayList:可 以将其看作是能够自动增长容量的数组。
　　3)利用ArrayList的toArray()返回一个数组。
　　4)Arrays.asList()返回一个列表。
　　5)LinkedList是采用双向循环链表实现的。
　　6)利用LinkedList实现栈(stack)、队列(queue)、双向队列(double-ended queue )。

　　7)LinkedList的底层数据采用双向链表(double-linked list)，类内除了数据本身外，还有两个引用，分别指向前一个元素和后一个元素。

　　8)如果经常在List中进行插入和删除操作，应该使用LinkedList,否则，使用ArrayList将更加快速。

　  9)ArrayList是基于动态数组的数据结构(地址连续)，而LinkedList是基于链表的数据结构(地址是任意的)。

Set
　　1)Set中 的元素必须唯一。
　　2)添加到Set中的对象元素必须定义equals方法，以提供算法来判断欲添加进来的对象是否与

已经存在的某对象相等，从而建立对象的唯一一性。

　　3)实现Set接口的类有HashSet,TreeSet。

HashSet 与 TreeSet 

　　1）TreeSet是一个有序集合，TreeSet中元素将按照升序排列，缺省是按照自然顺序进行排列，意味着TreeSet中元素要实现Comparable接口。

　　2）可以在构造TreeSet对象时，传递实现了Comparator接口的比较器对象。

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

　　4）HashSet底层用的是哈希表，TreeSet采用的数据结构是红黑树

　　5）HashSet中元素可以是null，但只能有一个，TreeSet不允许放入null

Map

　　1）Map接口用来处理“键一值”对，以便通过键来查找相应的值。

　　2）HashMap基于散列表实现(替代Hashtable)。

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

 Map定义
　　1）Map接口映射唯一关键字到值。关键字(key)是以后用于检索值的对象。给定一个关键字和一个值，可以存储这个值到一个Map对象中。当这个值被存储以后，就可以使用它的关键字来检索它

　　2）Map循环使用两个基本操作:get()和put()。使用put( )方法可以将一个指定了”关键字和值”的值加入映射。为了得到值，可以通过将关键字作为参数来调用get( )方法。调用返回该值。

 Map接口的方法
　　1）boolean containsKey(Object k)检查调用映射中是否包含关键字K
　　2）boolean containsValue(Object v)检查调用映射中是否包含值V
　　3）Object get(Object k)返回与关键字k相关联的值
　　4）booleanisEmpty()如果调用映射是空的，则返回true;否则返回
false
　　5）Object put(Object k, Object v)将一个键值对加入调用映射
　　6）Object remove(Object k)删除关键字等于k的键值对
　　7）int size( )返回映射中关键字/值对的个数
　　8）Set entrySet( )返回包含了映射中的项的集合(Set) 。该集合包含了类型Map.Entry的对象。这个方法为调用映射提供了一个集合“视图”

　　9）Set keySet( ). 返回一个包含调用映射中关键字的集合(Set) 。这个方法为调用映射的关键字提供了一一个集合“视图”

　　10）Collection values( )返回-一个包含了映射中的值的类集。这个方法为映射中的值提供了一个类集“视图

Map接口
　　1）Map接口的实现类主要有:
　　　　HashMap、TreeMap、 Hashtable、 Properties 。
　　2）Hashtable、Properties 是JDK1.0/1.1。
　　3）HashMap对key进行散列。
　　4）TreeMap按照key进行排序。
　　5）HashMap的速度通常都比TreeMap快，只有在需要排序的功能的时候，才使用TreeMap。

　　Map使用举例:
　　　　Map m=new HashMap();
　　　　m.put("张三","13000001111");
　　　　m.put("李四","13111110000");
　　　　m.put("王五","13333332222");
　　　　m.put("张三","13800008888"); I/覆 盖掉第一个值
　　　　System.out.println("是否有李四的电话号码:"+m.containsKey("李四"));

　　　　m.remove("王五"); //删除王五的记录
　　　　String zsCode=(String)m.get("张三");

JDK1.2对以前类集的替代
　　1）java.util的 最初版本中不包括类集框架，它只定义了几个类和接口提供专门的方法用于存储对象。随着在Java1.2中引入类集，有几种最初的类被重新设计成支持类集接口。因此它们与框架完全兼容。尽管实际上没有类被摒弃，但其中某些仍被认为是过时的。一般地，对从以前版本遗留下来的类的支持是因为仍然存在大量使用它们

的基本代码。包括现在仍在被Java 2的应用编程接口(API)使用的程序。

　　2）Vector: 用ArrayList代替Vector。
　　3）Hashtable: 用HashMap代替Hashtable。
　　4）Satck: 用LinkedList代替Stack.
　　5）相对于ArrayList和HashMap，Vector和Hashtable中 所有的方法都是线程同步的。

集合总结
　　1）集合框架为程序员提供了一个功能强大的设计方案以解决编程过程中面临的大多数任务。

　　2）类集不仅仅是专为那些“大型作业”，它们对于一些小型作业也是很有效的。

　　3）对于采用基于类集的解决方案而受益的问题种类只受限于你的想象力。

第十章  图形程序设计

10.1 AWT与Swing简介
10.2框架的创建
10.3图形程序设计
10.4显示图像

概述
　　用户界面(User Interface)
　　　　用户与计算机系统(各种程序)交互的接口
　　图形用户界面(Graphical User Interface)
　　　　以图形方式呈现的用户界面

10.1 AWT与Swing简介
　　10.1. 1 AWT
　　10. 1.2 Swing
　　10.1.3 AWT与Swing的关系

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

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

　　3）AWT库使用缺陷。菜单、滚动条和文本域等用户界面元素，在不同的平台上，操作行为上存在一些

微妙的差异。

10.1.2 Swing
　　1）Swing库具有更丰富且方便的用户界面元素集合。
　　2）Swing对底层平台的依赖很少，因此与平台相关的bug很少。

　　3）Swing会带来交叉平台上的统一视觉体验。
　　4）Swi ng类库被放在javax. swing包里。

　　Swing组件层次关系

10.1.3 AWT与Swing的关系
　　1）大部分AWT组件都有其Swing的等价组件。
　　2）Swing组件的名字一般是 在AWT组件名前面添加一个字母“J”，如: JButton, JFrame, JPanel等。

10.2创建框架
　　10.2.1 组件
　　10.2.2容器
　　10.2.3添加组件
　　10.2.4框架(Frame)
　　10.2.5在组件中显示信息

10.2.1组件
　　1）什么是组件?
　　　　构成图形用户界面的元素
　　2）用图形表示(能在屏幕上显示，能和用户进行交互)
　　　　一Button、Checkbox、Scrollbar、 Choice、Frame

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

　　　　例: Button button = new Button() ;
　　　　例: TextField textField = new TextFieldO ;
　　　　例: Label label = new Labe1();

　　组件类的常用API 
　　　　java. awt. Component 1. 0
　　　　boolean isVisibleO检查组件是否可见
　　　　void setVisible (boolean b)设置组件可见
　　　　void setSize (int width, int height)把组件缩放到指定宽度和高度
　　　　void setBounds(int x int y, int width, int height)移动并缩放组件
　　　　Dimension getSize0得到组件的大小
　　　　void setSize (Dimension d)把组件缩放到指定的大小
　　　　void setLocation(int x, int y)

10.2.2容器
　　1）容器是Java中能容纳和排列组件的组件。
　　2）常用的容器是框架(Frame, JFrame)
　　　　例:
　　　　　　Frame fra = new Frame( “这是一个窗口”);
　　3）java. awt. Frame类的常用API (教材414页)
　　　　　　void. setResizable (boolean, .b)缩放框架
　　　　　　void setTitle(String s)设置框架标题
　　　　void setIconImage (Image image) 将Image用作框架图标

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

　　　　例:   fra. add (button);
　　　　　　fra. add (textFie1d) ;
　　　　　　
　　2）容器本身也是-一个组件，可以把一一个容器添加到另一个容器里，实现容器嵌套。

10.2.4框架(Frame)的创建
　　(1)创建空框架
　　　　1）在Java中，常采用框架(Frame) 创建初始界面，即GUI的项层窗口

　　　　2）AWT库中有-一个基于对等体的Frame类。
　　　　3）该类的Swi ng版本为JFrame, JFrame是Frame子类。

　　(2)示例代码

1. import javax swing.-*;
2. public class SimpleFrameTest
3.{
1. public static void main(StringD args)
2.
{
3.
JFrame frame = new JFrame();
4.
frame. setBounds(0, 0,300, 200);
5.
frame. setDefaultCloseOperation(JFrame. EXIT_ ON CLOSE),
6.
frame. setVisible(true),
7. }
8.}

　

1. class SimpleFrame extends JFrame
2.
3.
public SimpleFrame(
4.
{
5.
setSize(WIDTH, HEIGHT);
6. }
7.
8.public static final int WIDTH= 300;
9.public static final int HEIGHT = 200,
10.}

1. import javax swing.;
2. public dlass SimpleFrameTest
3. {
4. public static void main(StringD args)
5. {
6.
EventQueue invokel ater(()>
7.{
8.　　SimpleFrame frame = new SimpleFrameO;
9.　　frame setDefautCloseOperation(JFrame EXIT_ ON CLOSE);
10.　　frame setVisible(true);
11.});
12.}
13.}

　　(3)框架定位与框架属性
　　　　定位:
　　　　　　一常 用Component类的setLocati on和setBounds方法
　　　　常用属性：
　　　　　　— Tit1e: 框架标题
　　　　　　一 IconImage:框架图标

　　(4)确定框架大小
　　　　通过调用Toolki t类的方法来得到屏幕尺寸信息。
　　　　　　Toolkit kit = Toolkit. getDefaultToolkitO: //生成Toolkit对象
　　　　　　Dimension screnSize = kit. getScreenSize0 ://返回Dimension对象的屏幕大小
　　　　　　int screenWidth = sereenSize. width://获得Dimension对象所幕的宽度
　　　　　　int sereenHeight=screenSize. height: ://获得Di mension对象屏再的高度

创建框架时的常用类及API
　　1）java. awt. Component 1. 0
　　　　— boolean isVisibleO 检查组件是否可见
　　　　— void setVisible (boolean b)设置组件可见
　　　　一void setSize (int width, int height) 把组件缩放到指定宽度和高度
　　　　一void setBounds(int x int y, int width, int height)移动并缩放组件
　　　　一Dimension getSize 0得到组件的大小
　　　　一void setSize Dimension d)把组件缩放到指定的大小
　　2）java. awt. Window 1.0
　　　　一void toProntO放在其它窗口前面
　　　　- void toBack0 放在其它窗口后面
　　　　—void setLocationByPlatform (boolean b)由平台选择个合适的位置
　　3）java. awt. Frame 1.0
　　　　一void setResizable (boolean b)缩放框架
　　　　一void setTitle(String s)设置框架标题
　　　　- void setIconImage (Image image) 将Image用作框架图标
　　4）java. awt. Toolkit 1. 0
　　　　- static Toolkit getDefaultToolkitO 返回默认工具箱
　　　　一Dimension getScreenSizeO得到用户屏幕大小

10.2.5在组件中显示信息
　　1）Jframe的结构:有根面板、层级面板、玻璃面板和内容面板( content pane)四层面板。

　　2）Swing程序员关心的是内容面板(内容窗格)。
　　3）在AWT中可调用add ()方法把组件直接添加到AWT Frame中,在Swing中组件则添加到内容窗格里。

　　　　代码如下:
　　　　　　Container contentPane = getContentPane 0 ;
　　　　　　Component c=--;
　　　　　　contentPane. add(c) ;

　　4）用户也可以自行创建一个组件类，此时需要重载 paintComponent ()。

　　5）用户的自建组件也可添加到内容窗格里。
　　6）paintComponent (Graphics g) 定义在JComponent类中，该方法在窗口需要重新绘图时(如扩大窗口

或极小化窗口1),被系统自动调用.

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

　　8）创建一个能够进行绘制的组件
　　　　dlass MyComponent extends JComponent
　　　　{
　　　　　　public void paintComponent(Graphics g)
　　　　　　super.paintComponent(Graphics g)；
　　　　　　g drawString( "Hello!world" )； II在缺省位置显示字符串
　　　　　　-----
　　　　　　}

　　9)常用API (教材419页)
　　　　1.javax. swing. JFrame 1. 2
　　　　　　— Container getContentPane(返回JFrame的内容窗格
　　　　　　— Component add (Component c)添加组件
　　　　2.java. awt. Component 1. 0
　　　　　　— void repaint(重新绘制组件
　　　　　　— void repaint(int x, int y, intwidth, int height) 重新绘制组件的-部分

　　　　3.javax. swi ng. JComponent 1. 2
　　　　　　— void paintComponent (Graphics g)自定 义组件时需要覆盖该方法来说明自定义的组件应如何绘制

 10.3图形编程
　　10.3.1处理2D图形
　　10.3.2颜色的使用
　　10.3.2字体的使用

 10.3.1 2D图形
　　(1) 2D库
　　　　1）2D库提供了一个非常强大的图形操作库集。
　　　　2）2D库的类是Graphics类的子类，2D类对 象通常可
　　　　　　用Graphics对象转换而来。
　　　　　　例:
　　　　　　　　public void paintComponent(Graphics g)
　　　　　　　　{
　　　　　　　　　　graphics2D g2=(graphics 2D)g；

　　　　　　　　　　……
　　　　　　　　}

　　(2)坐标系
　　　　1）2D图形类使用浮点数坐标系。
　　　　2）存在的问题:
　　　　　　Retangle2D .....
　　　　　　float f=r.getWidth(); //Error
　　　　　　getWidth ()返回double值,应进行转换:
　　　　　　float f=(float)r .getWidth();

　　（3）2D库中图形类之间的关系

　　　　

　　(4)常用2D图形类的API 
　　　　1） java. awt.geom.Retangle2D.Double 1.2
　　　　　　　　— Retangle2D.Double(double x,double y, double w,double h)
　　　　2）java awt geom Retangle2D.Float 1.2
　　　　　　　　— Retangle2D.Float(foat x.foat y.float w, float h)
　　　　3）java awt geom Elipse2D.Double 1.2
　　　　　　　　— Ellipse2D.Double(double x, double y,double w, double h)
　　　　4）java.awt.geom.Point2D.Double 1.2
　　　　　　　　— Point2D.Double(double x,double y)
　　　　5）java.awt.geom.Line2D.Double 1.2
　　　　　　　　一 Line2D.double(Point2D start,Point2D end)
　　　　　　　　— Line2D.double(double startX,double startY,double endX,double endY)
　　　　　　　　一 fill(Graphics2D rec)填充颜色
　　　　　　　　— draw(Graphics2D rec) 绘制图形rec
　　　　6）java.awt.Graphic2D 1.2
　　　　　　　　— void drawString(String str, int x, inty);
　　　　　　　　一void draw(Shape s);

10.3.2颜色的使用
　　　　Graphi cs2D类的setPaint方法(Graphics类为setColor方法)用来设置颜色。

　　　　　　例:   g2. setPaint (Color. RED) ;
　　　　　　　　g2. drawString(“Set Color” ，100, 100) ;
　　　　(1) Color类中定义的13种标准颜色
　　　　　　BLACK、BLUE、 CYAN、 DARK_ _GRAY、GRAY、GREEN、LIGHT_ _GRAY、MAGENTA、 ORANGE、 PINK、 RED、WHITE、YELLOW

　　　　(2)复合色
　　　　　　1）通过指定红绿蓝三色比例，用Color类对象来复成一种新的颜色。

　　　　　　2）Color构造器如下:
　　　　　　　　Color(int redness,int greenness,int blueness)
　　　　　　其中参数取值为0- -255
　　　　　　例:
　　　　　　　　g.setPaint(new Color(0,128,128));

　　　　(3)图形颜色常用API
　　　　　　1）java. awt Color 1.0
　　　　　　　　　　— void Color(int r,int g,int b)
　　　　　　2）java. awt.Graphics 1.0
　　　　　　　　　　— void setColor(Color C)
　　　　　　　　　　— Color getColor( );
　　　　　　3）java awt.Graphic2D 1.2
　　　　　　　　　　— void setPaint(paint p)
　　　　　　　　　　— void fll(Shape s)
　　　　　　4）java. awt.Cmponent 1.0
　　　　　　　　　　— void setBackground(Color c)
　　　　　　　　　　— void setForeground(Color c)

  10.3.3字体的使用
　　　　(1) AWT的五种逻辑字体名
　　　　　　●SanaSerif
　　　　　　●Serif
　　　　　　●Monospaced
　　　　　　●Dialog
　　　　　　●DialogInput
　　　　这些逻辑字体在不同语言和操作系统上映射为不同的物理字体。

　　　　(2)字体风格
　　　　　　●Font.Pl AIN
　　　　　　●Font.BOLD
　　　　　　●Fond.ITALIC
　　　　　　●Fond.BOLD + Font.ITALIC
　　　　(3)设置字体
　　　　　　●Font serif=new Font("Serif",Font.BOLD,14);
　　　　　　●g2.setFont(serif);

　　　　(4)字体应用的常用API 
　　　　　　1) java. awtFont 1.0
　　　　　　　　一Font(String name,int style,int Size)
　　　　　　　　一String getFontName()
　　　　　　　　— String getFamily()
　　　　　　　　— String getName()
　　　　　　　　一Retangle2D getStingBounds(String s,FontRenderContext context)
　　　　　　2）java awt.font.L ineMetrics 1.2
　　　　　　　　一float getAscent()
　　　　　　　　— float getHeight()
　　　　　　　　— float getWeight()
　　　　　　3）java awt Graphics 1.0
　　　　　　　　一void setFont(Font font)
　　　　　　　　— void DrawString(String str,int x,int y)
　　　　　　4）java awt Graphic2D 1.2
　　　　　　　　— vnid drawString(String str int x int y)

　　10.4图像
　　　　(1) Java应用程序中，一旦图像保存在本地或因特网的某个位置上，就可以将它们直接读入到java应

用程序中。
　　　　　　String flename=...”
　　　　　　Image image = Imagelcon(lename) getlmage();

　　　　(2)以下代码将-一个图像文件加载到程序中，再调用Graphics类提供的DrawImage ()显示它。

　　　　　　public void paintComponent(Graphics g)
　　　　　　{
　　　　　　　　g.drawlmage(image, X, y, nul);
　　　　　　}

　　　　(3)常用API 
　　　　　1）java.awtGraphics 1.0
　　　　　　— boolean drawlmage(lmage img.int x,int y,ImageObserver observer)
　　　　　　— boolean drawlmage(lmage img,int x int y ,int width,int height,ImageObserver observer)

　　　　　　— void copyArea(int x.int y,int width, int heigh,int dx,int dy)

2、实验内容和步骤

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

测试程序1：

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

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

Vector类：

package test;
//示例程序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>();	//使用Vector的构造方法进行创建
     for(int i=0; i<7; i++)
         cats.addElement(new Cat(i)); //加入的为Cat的对象
     for(int i=0; i<cats.size(); i++)	//获得Vector中已有元素的个数并进行遍历
         (cats.elementAt(i)).print();	//调用elementAt方法
 }
}

运行结果：

 Stacks类：

package test;

//示例程序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());
}
}

运行结果：

 Hashtable类：

package test;

//示例程序3
import java.util.*;
class Counter {
	int i = 1;
	public String toString() {		//调用toString()方法遍历所有的键值对
		return Integer.toString(i);
	}
}

public class Statistics {
	public static void main(String[] args) {
		Hashtable ht = new Hashtable();	//创建一个Hashtable对象
		for (int i = 0; i < 10000; i++) {
			Integer r = new Integer((int) (Math.random() * 20));
			//调用Math.random()方法产生随机数，没产生一个随机数就会被封装到一个Integer对象里
if(ht.containsKey(r))//判断哈希表是否包含特定键，其返回值为true或false
            ((Counter)ht.get(r)).i++;//调用get方法获取r对应的值
        else
            ht.put(r, new Counter());
//调用put方法对外提供接口，让Hashtable对象可以通过r的值添加到Hashtable中
}
		System.out.println(ht);
	}
}

运行结果：

测试程序2：

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

ArrayListDemo代码：

package test;

import java.util.*;

public class ArrayListDemo {
	public static void main(String[] argv) {
		ArrayList al = new ArrayList();
		// Add lots of elements to the ArrayList...
		//调用add方法，向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.
		 // 首先使用for循环将它们打印出来
		System.out.println("Retrieving by index:");
		for (int i = 0; i < al.size(); i++) {
			System.out.println("Element " + i + " = " + al.get(i));
		}
	 }
}

运行：

 LinkedListDemo代码：

package test;

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

运行：

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

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

9-1代码：

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)
   {
	 //add方法在迭代器位置之前添加一个新对象
      var a = new LinkedList<String>();//创建一个泛型类，用a引用它
      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");

      // merge the words from b into a
      //将a和b合并起来
     //LinkedList 类的 listIterator 方法返回一个实现了 ListIterator 接口的迭代器对象
      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);	//通过调用AbstractCollection 类中的toString方法打印出链表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);	//通过调用AbstractCollection 类中的toString方法打印出链表b中的所有元素

      // bulk operation: remove all words in b from a 

      a.removeAll(b);

      System.out.println(a);	//通过调用AbstractCollection 类中的toString方法打印出链表a中的所有元素
   }
}

运行：

小结：

1.LinkedList类实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在 LinkedList的首部或尾部。

2.ArrayList实现了可变大小的数组。

3.ArrayList方便查询，占用空间小。LinkedList方便添加删除等修改操作，占用空间大。

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

测试程序1：

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

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

}

}

代码：

package test;

import javax.swing.JFrame;

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);//设置可见性
	}
}

运行：

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

l 掌握空框架创建方法；

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

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

10-1代码：

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();	//创建SimpleFrame对象
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);	//定义一个用户关闭这个框架时的响应动作
            frame.setVisible(true);
         });
   }
}

class SimpleFrame extends JFrame
{
   private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 200;

   public SimpleFrame()
   {
      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
   }
}

运行：

测试程序2：

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

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

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();	//创建SimpleFrame对象
            frame.setTitle("SizedFrame");//设置标题
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);	//定义一个用户关闭这个框架时的响应动作
            frame.setVisible(true);
         });
   }
}

class SizedFrame extends JFrame
{
   public SizedFrame()
   {
      // get screen dimensions

      Toolkit kit = Toolkit.getDefaultToolkit();//生成Toolkit对象
      Dimension screenSize = kit.getScreenSize();
      int screenHeight = screenSize.height;
      int screenWidth = screenSize.width;

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

      setSize(screenWidth / 2, screenHeight / 2);//将框架大小设定为上面取值的%50
      setLocationByPlatform(true);

      // set frame icon
      //使用工具箱加载图像，设置框架图标
      Image img = new ImageIcon("icon.gif").getImage();//定义图形用户界面图标
      setIconImage(img);
   }
}

运行：

测试程序3：

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

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

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

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

/**
 * A frame that contains a message panel.
 */
class NotHelloWorldFrame extends JFrame
{
   public NotHelloWorldFrame()
   {
      add(new NotHelloWorldComponent());//调用add方法
      pack();//知道首选大小
   }
}

/**
 * A component that displays a message.
 */
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;

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

运行：

实验总结：

    本次实验我们学习了集合，掌握了java中集合的概念，学习了集合的知识以及使用方法。学习掌握了Java GUI中框架创建及属性设置中常用类的API；我知道了图形用户界面的一些基础的设计操作，比如窗口显示不同图形，文字等等，觉得挺有意思的。