201871010119-帖佼佼《面向对象程序设计（java）》第十二周学习总结
博客正文开头格式：
|
项目 |
内容 |
|
这个作业属于哪个课程 |
https://www.cnblogs.com/nwnu-daizh/ |
|
这个作业的要求在哪里 |
https://www.cnblogs.com/nwnu-daizh/p/11435127.html |
|
作业学习目标 |
|
第一部分：总结第九章、第十章理论知识（40分）
第九章 集合
1、Java的集合框架：
Java的集合框架实现对各种数据结构的封装；
所谓框架就是一个类库，框架中包括一些通用接口和超类，编程者实现这些接口或者 创建这些超类的子类就可方便的设计程序所需要的类；
集合（或者称为容器）是一类包含多个元素并提供对所包含元素的操作方法的类，其包含的元素可以由同一类型的对象组成，也可以由不同类型的对象组成；
集合框架：Java集合类库的统一架构。
2、集合类的作用：
（1）Java的集合类提供了对基本数据类型的支持；
（2）例如：Vector、Hashtable、Stack等；
3、集合类的使用：
Java的集合类包含在java.util包中；
import java.util.*；
4、集合类的特点：
只容纳对象：
注意：数组可以容纳基本数据类型的数据和对象；
如果集合类中想使用基本数据类型，邮箱利用集合类的灵活性，可以把基本数据类型数据封装成该数据类型的包装器对象，然后放入集合中处理；
5、新旧集合类：
在Java1.0和JDK1.1中提供了Vector（矢量），Hashtable（哈希表），Stack(堆栈)，Properties（属性集）等集合类，尽管这些类非常有用，但是彼此独立，缺少一个统一集中的机制。
6、Vector类
Vector类类似长度可变的数组；
Vector中只能存放对象；
Vector的元素通过下标进行访问；
Vector类关键属性：
——capacity表示集合最多能容纳的元素个数；
——capacityIncrement表示每次增加多少容量；
——size表示当前元素的集合；
7、Vector类的关键方法：
——void addElement(Object obj)
——void add（int index， Object element）
——Object elementAt（int index）
——void insertElementAt（Object obj， int index）
8、Stack类：
Stack类是Vectoe类的子类；
Stack类描述堆栈数据结构，即FILO；
Stack类的关键方法：
——public void push（Object item) //把项压入栈顶
——public Object pop() //移除栈顶元素对象并作为此函数的值返回该对象
——public Object peek() //查看栈顶元素而不移除它
——public Boolean empty() //测试堆栈是否为空
9、Hashtable类：
Hashtable类通过键值来查找元素；
Hashtable类用散列码（hashcode）来确定值。所有对象都有一个散列码，可以通过Object类的hashCode（）方法来获得；
10、集合的基本框架：
11、集合框架中的基本接口：
Collection：集合层次中的根接口；
Set：不能包含重复的元素。对象可能不是按存放次序存放，也就是说不能像数组一样按索引的方式进行访问，SortedSet是一个按照升序排列元素的Set；
LIst：是一个有序集合，可以包含重复的元素，提供了按索引访问的方式；
Map：包含了key—value 对，不能包含重复的key；
SortedMap：是一个按升序排列key的Map。
12、集合框架中的类：
（1）Collection接口：
（2）List：
List的明显特征是它的元素都有一个确定的顺序；
实现它的类有ArrayList和LinkedList，前者中的元素的内存中是顺序存储；后者的元素在内存中是链表方式存储；
ArrayList：可以将其看成是能够自动增长容量的数组，利用ArrayList的toArrY()返回一个数组；Arrays.asList()返回一个列表；
LinkedList是采用双向循环链表实现的；利用LinkedList实现栈，队列，双向队列，类内除了数据本身外，还有两个引用，分别指向前一个元素和后一个元素；
（3）Set：
Set中的元素必须唯一；
添加到Set中的对象元素必须定义equals方法，以提供算法来判断欲添加进来的元素是否与已经存在的某对象相等，从而建立对象的唯一性；
实现Set接口的类有HashSet，TreeSet。
(4)TreeSet:
是一个有序集合，TreeSet中元素按照升序排列，缺省是按照自然顺序进行排序，意味着TreeSet中元素要实现Comparable接口；
可以在构造TreeSet对象时，传递实现了Comparable接口的比较器对象；
HashSet是基于Hash算法实现的，其性能通常都优于TreeSet，通常使用HashSet，需要排序的功能时，使用TreeSet。
（5）Map：
Map接口用来处理”键—值“对，以便通过键值来查找相应的元素；
HashMap基于散列表实现（替代Hashtable）；
TreeMap在一个二叉树的基础上实现。
（6）Map定义：
Map接口映射唯一关键字的值。关键字（key）是以后用于检索值得对象。给定一个关键字和值，可以存储这个值到一个Map对象中。当这个值被存储以后，就可以使用它的关键字来检索它；
Map循环使用两个基本操作：get（）和put()。使用put（）方法可以将一个指定了”关键字和值“得值加入映射，为了得到值，可以通过将关键字作为参数来调用get（）方法。调用返回该值。
13、Map接口的方法：
boolean containsKey（Object K） 检查调用映射中是否包含关键字K；
boolean containsValue（Object v） 检查调用映射中是否包含值k；
Object get（Object k） 返回与关键字k相关联的值；
Boolean isEmpty（） 如果调用映射是空的，则返回true，否则返回false；
Object put（Object k， Object v） 将一个键值对加入调用映射；
Object remove （Object k） 删除关键字等于k的键值对；
int size () 返回映射中关键字/值对的个数；
Set entrySet（） 返回包含了映射中的项的集合（Set）。该集合包含了类型Map.Entry的对象。这个方法为调用映射提供了一个集合”视图“；
Collection values() 返回了包含了映射中值的类集。这个方法为映射中的值提供了一个集合的”视图”。
14、Map中的接口：
Map接口的实现类有：HashMap、TreeMap、Hashtable、properties；
HashMap对可以进行散列；
TreeMap按照key进行篇排序；
第十章 图形程序设计
1、用户界面：用户与计算机系统（各种程序）交互的接口；
2、图形用户界面：以图形方式呈现的用户界面；
3、AWT：
Java的抽象窗口工具箱包含在java.util包中，它提供了许多用来设计GUI的组件类和容器类；
AWT库处理用户界面元素的方法：
把图形元素的创建和行为委托给本地的GUI工具箱进行处理；
AWT库使用缺陷：
菜单、滚动条、和文本域等用户界面元素，在不同的平台，操作行为存在一些微妙的差异。
4、AWT组件：
5、Swing：
Swing库具有更加丰富且方便的用户界面元素的集合；
Swing对底层平台的依赖很少，因此与平台相关的bug很少；
Swing会带来交叉平台上统一视觉体验；
Swing类库放在javax.swing包里；
Swing组件层次关系：
6、AWT与Swing的关系：
（1）组件：构成图形用户界面的元素。用图形显示。
（2）通常把由Comparable类的子类后者间接子类创建的对象称为一个组件。
（3）组件类的API：
——boolean isVisible（） 检查组件可见
——void setVisible（boolean b） 设置组件可见
——void setSize（int x， int y， int width， int height） 移动并缩放组件
——void setBounds （int width， int height） 把组件缩放到指定宽度和高度
——Dimension getSize（）得到组件的大小
——void setSize（Dimension d） 把组件缩放到指定的大小
——void setLocation（int x，int y）
7、容器：
容器是Java中能容纳和排列组件的组件；
常用的容器时框架：（Frame，J Frame）
（1）常用的API：
——void setResizable（boolean b） 缩放框架
——void set Title（String s）设置框架标题
——void setIconImage（Image image） 将Image用作框架图标
（2）添加组件：
Container类提供了一个方法add()，用来在容器类组件对象中添加其他组件；
容器本身也是一个组件，可以把一个容器添加到另一个容器里，实现容器嵌套；
8、框架的创建（Frame）
（1）创建空框架：
在Java中，常采用框架创建初始界面，即GUI的顶层窗口；
AWT库中有一个基于对等体的Frame类；
该类的Swing版本为JFrame，JFrame是Frame的子类；
（2）框架定位于框架属性：
定位：——常用Component类的setLocation和setBounds方法
常用属性：——Title：框架标题；
——IconImage：框架图标；
（3）确定框架大小：
通过调用Toolkit类的方法来得到屏幕尺寸信息；
9、在组件中显示信息：
（1）JFrame的结构：
有根面板、层级面板、玻璃面板和内容面板四层面板；
用户也可以自行创建一个组件类；此时需要重载paintComponent（）；
用户的自建组件也可以添加到内容窗口格里；
paintComponent（Graphics g）定义在Component类中，该方法在窗口需要重新绘图时（如扩大窗口或极小化窗口），被系统自动调用；
paintComponent（）方法被调用时，系统就自动产生一个Graphics类型的参数，传递给paintComponent方法中的参数g；
（2）常见的API：
——Container getContentPane（） 返回JFrame的内容
——Component add（Component c） 添加组件
——void repaint （） 重新绘制组件
——void repaint （int x， int y， int width， int height） 重新绘制组件的一部分
——void paintCommponent（Graphics g） 自定义组件时需要覆盖该方法来说明自定义组件应如何绘制；
10、图形编程：
（1）2D图形
2D库提供了一个非常强大的图形操作库集；
2D库的类是Graphics类的子类，2D类对象通常可用Graphics对象转换而来；
（2）坐标系：
2D图形类使用浮点数坐标系；
（3）图形类：
2D库为每一个图形类提供了两个版本的静态内部类：
——Retangle2D.float
——Retangle2D.Double
11、颜色的使用：
Graphics 2D类的setPaint方法（Graphics 类为setColor方法）用来设置颜色；
（1）Color类中定义的13种标准颜色：
BLACK、BLUE、CYAN DARK_GRAY GRAY GREEN LIGHT_GRAY MAGENTA ORANGE PINK RED WHITE YELLOW
(2)复合色：
通过指定红绿蓝三色比例，用color类对象来复合成一种新的颜色；
Color的构造器：
Color（int redness ， int greenness， int blueness）
（3）图形颜色常用的API：
——void Color（int r， int g， int b）
——void setColor（color c）
——void getColor（）；
——void setPaint（Paint p）；
——void fill（Shape s）；
——void setBackground（Color c）
——void setForeground（Color c）
12、字体的使用：
（1）AWT的五种逻辑字体名：
SanaSerif Serif Monospaced Dialog Dialoginput。这些逻辑字体在不同语言和操作系统上映射为不同的物理字体；
（2）字体风格：
Font.PLAIN Font.BOLD Font.ITALIC Font.BOLD+Font.ITALIC
（3）设置字体：
13、图像：
（1）在Java应用程序中，一旦图像保存在本地或因特网的某个位置上，就可以将他们直接读入到Java应用程序中。
（2）以下代码将一个图像文件加载到程序中，再调用Graphics类提供的DrawImage（）显示它；
public void paintComponent（Graphics g）
{
。。。。。。。
g.drawImage（image， x ， y，null）
}
第二部分：实验部分
实验1：测试程序1（6分）
l 使用JDK命令运行编辑、运行以下三个示例程序，结合运行结果理解程序；
| 掌握Vetor、Stack、Hashtable三个类的用途及常用API。
实验代码如下：
package chart10;
//示例程序1
import java.util.Vector; //矢量类包
class Cat {
private int catNumber; //Cat类的整型私有变量catNumber
Cat(int i) { //Cat构造器
catNumber = i;
}
void print() { //print方法定义
System.out.println("Cat #" + catNumber);
}
}
public class Cats{
public static void main(String[] args){
Vector<Cat> cats= new Vector<Cat>(); //创建一个Vector<Cat>类对象cats
for(int i=0; i<7; i++) //for循环通过Vector<Cat>类对象cats来调用addElement()方法
cats.addElement(new Cat(i));
for(int i=0; i<cats.size(); i++)
(cats.elementAt(i)).print(); //通过Vector<Cat>类对象cats来调用elementAt()方法以及Cat类的print()方法
}
}
运行结果如下：
实验代码如下：
package chart10;
//示例程序2
import java.util.*;
public class Stacks //堆栈类
{
static String[] months={"金","银","铜","铁"}; //定义一个字符类数组months[],其中元素为金、银、铜、铁
public static void main(String[] args){
Stack<String> stk = new Stack<String> (); //创建一个Stack<String>类对象stk
for(int i=0; i<months.length; i++)
stk.push(months[i]); //通过对象名来调用push()方法
System.out.println(stk);
System.out.println("element 2=" + stk.elementAt(2));
while(!stk.empty()) //当stk不为空时，将通过对象名调用pop()方法
System.out.println(stk.pop());
}
}
运行结果如下：
实验代码如下：
package chart10;
//示例程序3
import java.util.*;
class Counter { //Counter类
int i = 1; //定义一个整型的Counter类变量i
public String toString() { //toString()方法
return Integer.toString(i);
}
}
public class Statistics {
public static void main(String[] args) {
Hashtable ht = new Hashtable(); //创建一个Hashtable类对象ht。Hashtable保存了一批键值对
for (int i = 0; i < 10000; i++) {
Integer r = new Integer((int) (Math.random() * 20));
//创建一个Integer类对象r，调用Math包的random()方法随机生成10000个1-20之间的随机数，强制类型转换为int型
if(ht.containsKey(r)) //如果r的键值不为空
((Counter)ht.get(r)).i++; //将Hashtable类对象ht强制转换为Counter类，调用get()方法然后再让i（r的出现次数）加一
else
ht.put(r, new Counter()); //否则Hashtable类对象ht调用put()方法，再创建一个Counter类对象
}
System.out.println(ht); //将ht输出在控制台上
}
}
运行结果如下：
实验1 测试程序2：（6分）
l 使用JDK命令编辑运行ArrayListDemo和LinkedListDemo两个程序，结合程序运行结果理解程序；
l 在Elipse环境下编辑运行调试教材360页程序9-1，结合程序运行结果理解程序；
l 掌握ArrayList、LinkList两个类的用途及常用API。
实验代码如下：
package chart10;
import java.util.*;
public class ArrayListDemo {
public static void main(String[] args) {
ArrayList al = new ArrayList(); //创建一个ArrayList类对象al
// Add lots of elements to the ArrayList...
al.add(new Integer(11)); //通过al调用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:"); //将Retrieving by index:（按索引搜索）输出在控制台上
for (int i = 0; i < al.size(); i++) { //i小于数组类对象al的大小时，输出i的值
System.out.println("Element " + i + " = " + al.get(i));
}
}
}
运行结果如下：
实验代码如下：
package chart10;
import java.util.*;
public class LinkedListDemo {
public static void main(String[] argv) {
LinkedList l = new LinkedList(); //创建一个LinkedList类的对象l
l.add(new Object()); //通过l调用add()方法增加元素
l.add("Hello");
l.add("zhangsan");
ListIterator li = l.listIterator(0); //创建一个ListIterator类的对象li
while (li.hasNext()) //这是java的迭代器的用法。使用hasNext()检查序列中是否还有元素。
System.out.println(li.next()); //使用next()获得序列中的下一个元素。
if (l.indexOf("Hello") < 0) //indexOf检测如果不存在就会返回Lookup does not work
System.err.println("Lookup does not work");
else
System.err.println("Lookup works");
}
}
运行结果如下：
实验代码如下：
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)
{
LinkedList<String> a = new LinkedList<String>();//创建一个LinkedList<String>类对象
a.add("Amy"); //通过a调用add()方法添加元素
a.add("Carl");
a.add("Erica");
LinkedList<String> b = new LinkedList<String>();//创建一个LinkedList<String>类对象
b.add("Bob"); //通过b调用add()方法添加元素
b.add("Doug");
b.add("Frances");
b.add("Gloria");
// merge the words from b into a
ListIterator<String> aIter = a.listIterator(); //listIterator接口是iterator的子接口
Iterator<String> bIter = b.iterator();
while (bIter.hasNext()) //如果存在访问的元素，返回ture
{
if (aIter.hasNext()) aIter.next(); //如果aIter中存在访问的元素使用next()获得序列中的下一个元素。
aIter.add(bIter.next()); //添加bIter.next()得到的元素到aIter中
}
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()获得序列中的下一个元素。
{
bIter.next(); // skip next element 使用next()获得序列中的下一个元素。
bIter.remove(); // remove that element 删除bIter中的元素
}
}
System.out.println(b);
// bulk operation: remove all words in b from a
a.removeAll(b); //删除b中所有的来自a的元素
System.out.println(a);
}
}
运行结果如下：
实验2：测试程序1（6分）
l 运行下列程序，观察程序运行结果。
package chart10;
import javax.swing.*;
public class SimpleFrameTest
{
public static void main(String[] args)
{
JFrame frame = new JFrame(); //创建一个JFrame类对象frame，
frame.setBounds(0, 0,300, 200); //通过frame来调用setBounds()方法，后面的参数分别是像素最初始位置，以及框架的宽度和长度
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //通过调用setDefaultCloseOperation()方法。可关闭
frame.setVisible(true); //调用setVisible()方法，
}
}
运行结果如下：
l 在elipse IDE中调试运行教材407页程序10-1，结合程序运行结果理解程序；与上面程序对比，思考异同；
l 掌握空框架创建方法；
l 了解主线程与事件分派线程概念；
l 掌握GUI顶层窗口创建技术。
实验代码如下：
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表达式
{
SizedFrame frame = new SizedFrame(); //创建一个SizedFrame类对象frame
frame.setTitle("SizedFrame"); //通过frame对象来调用setTitle()方法，来设置标题
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //调用setDefaultCloseOperation()方法来设置取消窗口界面
frame.setVisible(true); //调用setVisible()方法来决定窗口是否可见
});
}
}
class SizedFrame extends JFrame //创建一个类SizedFrame类来继承JFrame类
{
public SizedFrame() //构造器
{
// get screen dimensions
Toolkit kit = Toolkit.getDefaultToolkit(); //创建一个Toolkit类对象kit，通过类名来调用getDefaultToolkit()方法
Dimension screenSize = kit.getScreenSize(); //调用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);
// set frame icon
Image img = new ImageIcon("icon.gif").getImage(); //创建一个Image对象来设置灰度
setIconImage(img);
}
}
运行结果如下：
实验2：测试程序2（6分）
l 在elipse IDE中调试运行教材412页程序10-2，结合运行结果理解程序；
l 掌握确定框架常用属性的设置方法。
实验代码如下：
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(); //创建一个SimpleFrame类对象
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //调用setDefaultCloseOperation()方法来取消窗口
frame.setVisible(true); //调用setVisible()方法决定窗口是否可见
});
}
}
class SimpleFrame extends JFrame //创建一个SimpleFrame类继承JFrame类
{
private static final int DEFAULT_WIDTH = 300; //定义私有常量DEFAULT_WIDTH和DEFAULT_HEIGHT的值
private static final int DEFAULT_HEIGHT = 200;
public SimpleFrame() //SimpleFrame构造器
{
setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT); //设置宽度和长度的大小
}
}
运行结果如下：
实验2：测试程序3（6分）
l 在elipse IDE中调试运行教材418页程序10-3，结合运行结果理解程序；
l 掌握在框架中添加组件；
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(() -> //lambda表达式
{
NotHelloWorldFrame frame = new NotHelloWorldFrame(); //创建一个NotHelloWorldFrame类对象
frame.setTitle("NotHelloWorld"); //通过frame来调用setTitle()方法，来设置标题
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//调用setDefaultCloseOperation()方法取消窗口
frame.setVisible(true); //调用setVisible()方法设置窗口是否可见
});
}
}
/**
* A frame that contains a message panel.
*/
class NotHelloWorldFrame extends JFrame //创建一个NotHelloWorldFrame类来继承JFrame类
{
public NotHelloWorldFrame() //NotHelloWorldFrame构造器
{
add(new NotHelloWorldComponent()); //add()方法添加窗口
pack();
}
}
/**
* A component that displays a message.
*/
class NotHelloWorldComponent extends JComponent //创建一个NotHelloWorldComponent类继承JComponent类
{
public static final int MESSAGE_X = 75; //私有属性，常量MESSAGE_X以及MESSAGE_Y 的定义
public static final int MESSAGE_Y = 100;
private static final int DEFAULT_WIDTH = 300; //私有属性，常量DEFAULT_WIDTH以及DEFAULT_HEIGHT 的定义
private static final int DEFAULT_HEIGHT = 200;
public void paintComponent(Graphics g) //paintComponent()方法定义来实现绘图
{
g.drawString("Not a Hello, World program", MESSAGE_X, MESSAGE_Y);
}
public Dimension getPreferredSize() //getPreferredSize()得到维度
{
return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT);
}
}
运行结果如下：
实验总结：（19分）
这周学习了集合以及图像程序设计两章的内容，对于集合一章来说，学习了集合类以及集合的基本框架，了解了Vector类，Stack类以及Hashtable类，以及实现的接口。知道了集合框架中的类以及实现的接口，还有常用的API 的了解。还有就是第十章的内容，图像程序设计的内容，关于这个在学习理论知识时初步了解了绘制图形的常用API、如何创建看框架以及如何设置字体和颜色，实验课上通过运行课本上的程序以及老师给的代码，进一步了解了图形用户界面，对此有了更深的掌握。这周的实验都是验证性的实验，不是很难，就是在理解倒数第三个代码上还有点问题。后面看了书，都是调用了一些方法，就可以理解了。
