201871010105- Cao in "object-oriented programming (java)" twelfth week learning summary

201871010105- Cao in "object-oriented programming (java)" twelfth week learning summary

project	content
This work belongs courses	https://www.cnblogs.com/nwnu-daizh/
Where this requirement in the job	https://www.cnblogs.com/nwnu-daizh/p/11435127.html
Job learning objectives	(1) master Vetor, Stack, Hashtable three classes of common use and the API; (2) master ArrayList, LinkList two classes of common use and the API; (3) a set of java understood framework composition; (4) to grasp the Java GUI framework to create and property of the commonly used class of API; (5) understand the Java GUI 2D graphics rendering commonly used class of API;

The first part: Summary Chapter IX, Chapter X of theoretical knowledge

List, Set, Map is an interface, the first two to inherit the Collection interface, Map is independent interface
There HashSet, LinkedHashSet, TreeSet under Set
There ArrayList, Vector, LinkedList under List
There Hashtable, LinkedHashMap, HashMap, TreeMap under Map
in Java, the array may store a plurality of objects. It can be defined this way:

int[] score={1,2,3};
int[] score=new int[10];

We usually define the array when the array which will give the assignment, its contents determined. But such an array there is a drawback, and that is not the length of the array side, variable content.
We need to be able to change at any time in a real development in the array. At this point, you can use collections of --collection Java

Set representing a group of objects which are called elements. Some collections allow duplicate elements, and other collections is not allowed.

class MyClass {public 
    public static void main (String [] args) { 
       // interface method Collection 
        T1 = the ArrayList new new Collection <String> (); 
        t1.add ( "Jack"); 
        t1.add ( "Marry"); 
        System.out.println (T1); 

        // delete an object 
        t1.remove ( "Jack"); 
        System.out.println (T1); 

        // Get the number of elements 
        System.out.println (t1.size ()) ; 

        // comprises determining whether an element, can be used to operate contains 
        iF (t1.contains ( "Marry")) { 
            System.out.println ( "there Marry"); 
        } the else { 
            System.out.println ( "not Marry" ); 
        } 

        // determines whether the air 
        if (t1.isEmpty()){
            System.out.println ( "IS empty"); 
        } the else { 
            System.out.println ( "Not empty"); 
        } 

        // set determining whether two identical 
        Collection <String> T2 = new new the ArrayList <> (); 
        T2 .add ( "Jack"); 
        t2.add ( "Marry"); 

        IF (that t1.equals (T2)) { 
            System.out.println ( "set of two identical"); 
        } the else { 
            System.out.println ( "two sets are not the same"); 
        } 

        // clear 
        t1.clear (); 
        System.out.println (T2)

Elements in the collection may vary.

Add elements add addAll
Remove elements remove (): Delete an object
Insert elements
Accessing element
Gets the element number size
It contains an element contains
Is empty isEmpty
Comparing the set of equals
Empty clear

Through the collection of

1. Use Iterator to traverse

// hasNext determine whether there is an element
// next Gets the next object
// remove deleted after the current object traversal

迭代（iterate），指的是按照某种顺序逐个访问列表中的每一项。比如，for语句。

Iterator iterator=t2.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        while (iterator.next()!=null){
            System.out.println(iterator.next());
        }

2.for-each 增强for循环

 for (String obj:t2){
            System.out.println(obj);
        }

3.for-i

 for (int i=0; i < t2.size(); i++){
            System.out.println(((ArrayList<String>) t2));
        }

List接口

 List接口 extends Collection

有序集合（也称为序列）。该界面的用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引（列表中的位置）访问元素，并搜索列表中的元素。

与集合不同，列表通常允许重复的元素。更正式地，列表通常允许元素e1和e2成对使得e1.equals(e2) ，并且如果它们允许空元素，它们通常允许多个空元素。有人可能希望实现一个禁止重复的列表，当用户尝试插入时会抛出运行时异常，但是我们预计这种使用是罕见的。

该List接口放置额外的约定，超过在Collection指定接口上的iterator，add，remove，equals和hashCode方法合同。其他继承方法的声明也包括在这里以方便。

ArrayList和 LinkedArrayList
它们一个是Array(动态数组)的数据结构，一个是Link(链表)的数据结构，此外，它们两个都是对List接口的实现。
前者是数组队列，相当于动态数组；后者为双向链表结构，也可当作堆栈、队列、双端队列
ArrayList: 可调整大小的数组的实现List接口。实现所有可选列表操作，并允许所有元素，包括null 。除了实现List 接口之外，该类还提供了一些方法来操纵内部使用的存储列表的数组的大小。（这个类是大致相当于Vector，不同之处在于它是不同步的）。
每个ArrayList实例都有一个容量。容量是用于存储列表中的元素的数组的大小。它总是至少与列表大小一样大。当元素添加到ArrayList时，其容量会自动增长。
LinkedArrayList:

ArrayList<Integer> score = new ArrayList<>();
        score.add(2);
        score.add(3);//在末尾添加
        score.add(0,1);//在指定位置插入

        //访问指定元素
        score.get(1);

        //修改一个指定元素
        score.set(0,0);
        System.out.println(score);

        //删除指定元素
        score.remove((Integer) 2);//删除指定位置的对象
        System.out.println(score);

        score.clear();//删除所有 清空
        System.out.println(score);

        ArrayList<Integer> a2 =new ArrayList<>();
        a2.add(1);
        a2.add(2);
        a2.add(3);

        //将一个集合里面的内容添加到当前集合中
        score.addAll(a2);
        System.out.println(score);


        ArrayList<Integer> a3 = new ArrayList<>();
        a3.add(1);
        a3.add(2);
        score.retainAll(a3);//去两个集合的交集
        System.out.println(score);

        //访问某个对象在集合里面的索引
        ArrayList<Integer> a4 = new ArrayList<>();
        a4.add(1);
        a4.add(2);
        a4.add(2);
        a4.add(4);
        System.out.println(a4.indexOf(1));//第一次出现的位置
        System.out.println(a4.lastIndexOf(2));//最后一次出现的位置

//集合里面只能存放对象
//byte char int long float double boolean
//包装4类
//Byte Char Int Long Float Double Boolean
//自动将基本数据类型包装为对应的类
有时候在一些Dmeo中就需要把将ArrayList转化为普通数组。那么怎样来进行转换呢。

Integer[] objects = new Integer[a4.size()];
        a4.toArray(objects);
        for (Integer i:objects){
            System.out.println(i);
        }
        Iterator iterator =a4.iterator();//遍历数组
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

删除某个范围内的对象

 block          
  Lambda表达式

 return (var1) -> {   
    return !this.test(var1);            };           
 return 20;

获取集合某个范围内的子集和

  List<Integer> integers=a4.subList(1,3);
        System.out.println(integers);
        ArrayList<Integer> nums= new ArrayList<>();
        nums.add(1);
        nums.add(2);
        nums.add(3);
        nums.add(4);

闭包 Closure(就是Lambda表达式把函数作为一个方法的参数)

class ArrayClass{
    public void test(int[] target,Show s){
        for (int element:target){
            s.customShow(element);
        }
//必须是接口，这个接口里面只有一个方法（这里就像我们做一件事情做不了，就需要通过其他的人来做）
interface Show{
    void customShow(int element);
}

怎么去使用上面的方法呢，也就是 test方法。

1.使用方式:定义一个类实现接口
        ArrayClass ac= new ArrayClass();
        int[] num={1,2,3,4,5,6};
        yjxClass yc= new yjxClass();
        ac.test(num,yc);//这里让yc去把这个数组里面的内容弄出来，也就是把对象告诉它，在它执行的时候，就去照这个对象


        //2.使用匿名类
       ArrayClass ac= new ArrayClass();
        int[] num={1,2,3,4,5,6};

        ac.test(num, new Show() {
            @Override
            public void customShow(int element) {
                System.out.println(element);
            }
        });


        //3.
      ArrayClass ac= new ArrayClass();
        int[] num={1,2,3,4,5,6};
        ac.test(num,(int element)->{
            System.out.println(element);
        });

        //5.如果代码块里面只有一行语句 ，大括号可以省略
    ArrayClass ac= new ArrayClass();
        int[] num={1,2,3,4,5,6};

        ac.test(num,element -> System.out.println(element));

继承这个yc接口 ac.test(num,yc);

class yjxClass implements Show{
    @Override
    public void customShow(int element) {
        System.out.println(element);
    }
}

　　第十章.图形程序设计

1 Swing概述

现在，Swing是不对等基于GUI工具箱的正式名字。它已是Java基础类库(Java Foundation Class, JFC)的一部分。完整的JFC十分庞大，其中包含的内容远远大于Swing GUI工具箱。

JFC特性不仅仅包含了Swing组件，而且还包含了一个可访问性API、一个2D API和一个可拖放API。

注释：Swing没有完全替代AWT,而是基于AWT架构之上。Swing仅仅提供了能力更加强大的用户界面组件。尤其在采用Swing编写的程序中，还需要使用基本的AWT处
理事件。从现在开始，Swing是指“被绘制的”用户界面类；AWT是指像事件处理这样的窗口工具箱的底层机制。

当然，在用户屏幕上显示基于Swing用户界面的元素要比显示AWT的基于对等体组件的速度慢一些。鉴于以往的经验，对于任何一台现代的计算机来说，微小的速度差别无妨大碍。另外，由于下列几点无法抗拒的原因，人们选择Swing：

Swing拥有一个丰富、便捷的用户界面元素集合。
Swing对底层平台依赖的很少，因此与平台相关的bug很少。
Swing给予不同平台的用户一致的感觉。

不过，上面第三点存在着一个潜在的问题：如果在所有平台上用户界面元素看起来都一样，那么它们就有可能与本地控件不一样，而这些平台的用户对此可能并不熟悉。

Swing采用了一种很巧妙的方式来解决这个问题。在程序员编写Swing程序时，可以为程序指定专门的“观感”。

此外，Sun开发了一种称为Metal的独立于平台的观感。现在，市场上人们将它称为“Java 观感”。不过，绝大多数程序员还继续沿用Metal这个术语，在本书中也将这样称呼。

有些人批评Metal有点笨重，而在Java SE 5.0中看起来却焕然一新(参见图10-3)。现在，Metal外观支持多种主题，每一种主题的颜色和字体都有微小的变化。默认的主题叫做Oceano在Java SE 6中，Sun改进了对Windows和GTK本地观感的支持。Swing应用程序将会支持色彩主题的个性化设置，逼真地表现着动态按钮和变得十分时尚的滚动条。

2 .创建框架

在Java中，顶层窗口（就是没有包含在其他窗口中的窗口）被称为框架(frame)。在AWT库中有一个称为Frame的类，用于描述顶层窗口。这个类的Swing版本名为JFrame,它扩展于Frame类。JFrame是极少数几个不绘制在画布上的Swing组件之一。因此，它的修饰部件（按钮、标题栏、图标等）由用户的窗口系统绘制，而不是由Swing绘制。

警告：绝大多数Swing 组件类都以“J”开头，例如，JButton、JFrame等。在Java中有Button和Frame这样的类，但它们属于AWT组件。如果偶然地忘记书写“J”，程序仍然可以进行编译和运行，但是将Swing和AWT组件混合在一起使用将会导致视觉和行为的不一致。

在本节中，将介绍有关Swing的JFrame的常用方法。程序清单10-1给出了一个在屏幕中显示一个空框架的简单程序

package simpleFrame;
import java.awt.*;
import javax.swing.*;
* ©version 1.33 2015-05-12
* author Cay Horstmann

public class SimpleFrameTest {
    public static void main(String[] args) {
        EventQueue.invokeLater(() -> {
                SimpleFrame frame = new SimpleFrame();
                frame.setDefault(CloseOperationJFrame.EXIT_0N_CL0SE);
                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);
    }
}

Swing类位于javax.swing包中。包名javax表示这是一个Java扩展包，而不是核心包。出于历史原因Swing类被认为是一个扩展。不过从1.2版本开始，在每个Java SE实现中都包含它。

在默认情况下，框架的大小为0x0像素，这种框架没有什么实际意义。这里定义了一个子类SimpleFmme，它的构造器将框架大小设置为300 x 200像素。这是SimpleFrame和JFrame之间唯一的差别。

在SimpleFrameTest类的main方法中，我们构造了一个SimpleFrame对象使它可见。

在每个Swing程序中，有两个技术问题需要强调。

首先，所有的Swing组件必须由事件分派线程(event dispatch thread)进行配置，线程将鼠标点击和按键控制转移到用户接口组件。下面的代码片断是事件分派线程中的执行代码：

EventQueue.invokeLater(() -> {
    statements
});

接下来，定义一个用户关闭这个框架时的响应动作。对于这个程序而言，只让程序简单地退出即可。选择这个响应动作的语句是frame.setDefaultCloseOperation(JFrame. EXIT_0N_CL0SE);

在包含多个框架的程序中，不能在用户关闭其中的一个框架时就让程序退出。在默认情况下，用户关闭窗口时只是将框架隐藏起来，而程序并没有终止(在最后一个框架不可见之后，程序再终止，这样处理比较合适，而Swing却不是这样工作的)。

简单地构造框架是不会自动地显示出来的，框架起初是不可见的。这就给程序员了一个机会，可以在框架第一次显示之前往其中添加组件。为了显示框架，main方法需要调用框架的setVisible方法。

在初始化语句结束后，main方法退出。需要注意，退出main并没有终止程序，终止的只是主线程。事件分派线程保持程序处于激活状态，直到关闭框架或调用System.exit方法终止程序。

图10-5中显示的是运行程序清单10-1的结果，它只是一个很枯燥的顶层窗口。在这个图中看到的标题栏和外框装饰（比如，重置窗口大小的拐角）都是由操作系统绘制的，而不是Swing 库。在Windows、GTK或Mac下运行同样的程序，会得到不同的框架装饰。Swing库负责绘制框架内的所有内容。在这个程序中，只用默认的背景色填充了框架。

注释：可以调用frame.setUndecorated(true)关闭所有框架装饰

3. 框架定位

超类中继承了许多用于处理框架大小和位置的方法其中最重要的有下面几个：

setLocation和setBounds方法用于设置框架的位置。
setlconlmage用于告诉窗口系统在标题栏、任务切换窗口等位置显示哪个图标。
setTitle用于改变标题栏的文字。
setResizable利用一个boolean值确定框架的大小是否允许用户改变。

图10-6给出了JFrame类的继承层次。

    Object
       |
       |
    Component
       |
       |
    Container
       |
       |
JComponent  Windows
    | | | | JPanel Frame | | JFrame

对Component类（是所有GUI对象的祖先）和Window类(是Frame类的超类)需要仔细地研究一下，从中找到缩放和改变框架的方法。例如，在Component类中的setLocation方法是重定位组件的一个方法。如果调用setLocation(x, y)则窗口将放置在左上角水平x像素，垂直y像素的位置，坐标(0,0)位于屏幕的左上角。

同样地，Component中的setBounds方法可以实现一步重定位组件(特别是JFrame)大小和位置的操作，例如：

setBounds(x, y, width, height);

可以让窗口系统控制窗口的位置，如果在显示窗口之前调用

setLocationByPlatform(true);

窗口系统会选用窗口的位置（而不是大小)，通常是距最后一个显示窗口很少偏移量的位置。

注释：对于框架来说，setLocation和setBounds中的坐标均相对于整个屏幕。在第12章中将会看到，在容器中包含的组件所指的坐标均相对于容器。

3.1 框架属性

组件类的很多方法是以获取/设置方法对形式出现的，例如，Frame类的下列方法：

public String getTitle();
public void setTitle(String title);

这样的一个获取设置方法对被称为一种属性。属性包含属性名和类型。将get或set之后的第一个字母改为小写字母就可以得到相应的属性名。例如，Frame类有一个名为title且类型为String的属性。

从概念上讲，title是框架的一个属性。当设置这个属性时，希望这个标题能够改变用户屏幕上的显示。当获取这个属性时，希望能够返回已经设置的属性值。

我们并不清楚（也不关心）Frame类是如何实现这个属性的。或许只是简单的利用对等框架存储标题。或许有一个实例域：

private String title; // not required for property

如果类没有匹配的实例域，我们将不清楚（也不关心）如何实现获取和设置方法。或许只是读、写实例域，或许还执行了很多其他的操作。例如，当标题发生变化时，通知给窗口系统。

针对get/set约定有一个例外：对于类型为boolean的属性，获取方法由is开头。例如，下面两个方法定义了locationByPlatform属性：

public boolean islocationByPIatforn()
public void setLocationByPIatforra(boolean b)

4. 在组件中显示信息

可以将消息字符串直接绘制在框架中，但这并不是一种好的编程习惯。在Java中，框架被设计为放置组件的容器，可以将菜单栏和其他的用户界面元素放置在其中。在通常情况下，应该在另一组件上绘制信息，并将这个组件添加到框架中。

JFrame的结构相当复杂。在图10-8中给出了JFrame的结构。可以看到，在JFrame中有四层面板。其中的根面板、层级面板和玻璃面板人们并不太关心；它们是用来组织菜单栏和内容窗格以及实现观感的。

Swing程序员最关心的是内容窗格(contentpane)。在设计框架的时候，要使用下列代码将所有的组件添加到内容窗格中：

Container contentPane = frame.getContentPane() ;
Component c = ...;
contentPane.add(c) ;

在Java SE 1.4及以前的版本中，JFrame 类中的add 方法抛出了一个异常信息“Do not use JFrame.add().Use JFrame.getContentPane().add instead”。如今，JFrame.add方法不再显示

这些提示信息，只是简单地调用内容窗格的add，因此，可以直接调用

frame.add(c) ;

在这里，打算将一个绘制消息的组件添加到框架中。绘制一个组件，需要定义一个扩展JAComponent的类，并覆盖其中的paintComponent方法。

paintComponent方法有一个Graphics类型的参数，这个参数保存着用于绘制图像和文本的设置，例如，设置的字体或当前的颜色。在Java中，所有的绘制都必须使用Graphics对象，其中包含了绘制图案、图像和文本的方法。

第二部分：实验部分

1、实验目的与要求

(1) 掌握Vetor、Stack、Hashtable三个类的用途及常用API；

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

(3) 掌握Java GUI中框架创建及属性设置中常用类的API；

(4) 应用结对编程（Pair programming），体验程序开发中的两人合作。

2、实验内容和步骤

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

测试程序1：

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

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

//示例程序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

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

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

}

}

运行结果如下

测试程序2：

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

ArrayListDemo：

package cyz;

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：

package cyz;

import java.util.LinkedList;
import java.util.ListIterator;

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);// listIterator(int index) 构造器，可以从指定下标处开始遍历
        while(li.hasNext())
            System.out.println(li.next());
        if(l.indexOf("Hello")<0)//public int indexOf(int ch): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
            System.out.println("Lookup does not work");
        else
            System.out.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");

      // merge the words from b into 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);

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

      // 批量操作，从a中删除b中所有单词；

      a.removeAll(b);

      System.out.println(a);
   }
}

　　运行结果如下

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

测试程序1：

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

package cyz;

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

   }

}

　运行结果如下：　

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;//将构造器框架设置成300*200像素；

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

运行结果如下：

测试程序2：

l 在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();
      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);
      setLocationByPlatform(true);

      //设置新图标

      Image img = new ImageIcon("icon.gif").getImage();
      setIconImage(img);      
   }
}

运行结果如下：

测试程序3：

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

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

掌握自定义组件的用法。

代码如下：

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());
      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构造图趣味，由于本次试验都是验证性实验，所以在完成的过程中没有与大太

难的问题，从而有更多的时间理解消化内容，希望在以后的学习中，通过不断努力，我可以学到更多的关于Java编程的相关知识。