项目

内容

这个作业属于哪个课程

<任课教师博客主页链接>https://www.cnblogs.com/nwnu-daizh/

这个作业的要求在哪里

<作业链接地址>https://www.cnblogs.com/nwnu-daizh/p/11995615.htmll

作业学习目标

（1）掌握GUI布局管理器用法；

（2）掌握Java Swing文本输入组件用途及常用API；

（3）掌握Java Swing选择输入组件用途及常用API。

第一部分：总结菜单、对话框两类组件用途及常用API

菜单：

1.JMenuBar 菜单栏

菜单栏是窗口中用于容纳菜单JMenu的容器。 JFrame对象可以调用setJMenuBar()方法将一个菜单栏实例menubar添加到容器中，作为整个菜单树的根基。菜单栏被添加到窗口的上方，不受布局管理器控制。

注意：只能向窗口中添加一个菜单栏。

1
2
3
4
5
6
public JMenuBar(){
//默认构造方法,创建新的菜单栏
}
public JMenu add(JMenu c){
//将菜单追加到菜单栏末尾
}

2.JMenu 菜单

菜单是若干个菜单项(JMenuItem)或子菜单的容器，它能被添加到JMenuBar或其他JMenu中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public JMenu(){
//默认构造方法,创建没有文本的新菜单
}
public JMenu(String s){
//构造方法,用提供的字符串作为文本构造一个新菜单
}
public Component add(Component c){
//将某个组件追加到此菜单的末尾
}
public JMenuItem add(JMenuItem c){
//将某个菜单项追加到此菜单的末尾
}
public void addSeparator(){
//将新分隔符追加到菜单的末尾
}

3.JMenuItem 菜单项
   菜单项是组成菜单或快捷键的最小单位，用于完成特定功能。

1
2
3
4
5
6
7
8
9
public JMenuItem(){
//默认构造方法,创建不带文本或图标的菜单项
}
public JMenuItem(String text){
//构造方法
}
public void setAccelerator(KeyStroke keystroke){
//为菜单项设置快捷键
}

4.选择菜单项
   Java除了提供JMenuItem，还提供了两种可选择的菜单项：复选菜单项(JCheckBoxMenuItem)和单选菜单项(JRadioButtonMenuItem)。
5.JPopupMenu 快捷菜单项

菜单除了可以放置在窗口，也可以依附于一个组件，当用户右击鼠标时弹出

1
2
3
4
5
6
7
8
9
10
11
12
public JPopupMenu(){
//默认构造方法
}
public JPopupMenu(String s)
//构造方法,具有指定标题
}
public JMenuItem add(JMenuItem jm){
//将指定菜单项添加到此菜单的末尾
}
public void addSeparator(){
//将新分隔符追加到菜单的末尾
}

对话框：

1、对话框模式
       对话框分为无模式和有模式两种。

如果一个对话框是有模式的，那么当这个对话框处于激活状态时，只让程序响应对话框内部的事件，而且将堵塞其它线程的执行，用户不能再激活对话框所在程序中的其它窗口，直到该对话框消失不可见。

无模式对话框处于激活状态时，能再激活其它窗口，也不堵塞其它线程执行。

3、文件对话框(FileDialog)
       文件对话框是一个从文件中选择文件的界面，文件对话框事实上并不能打开或保存文件，它只能得到要打开或保存的文件的名字或所在的目录，要想真正实现打开或保存文件，还必须使用输入、输出流。

javax.swing包中的JFileChooser类可以创建文件对话框，使用该类的构造方法JFileChooser()创建初始不可见的有模式的文件对话框。showSaveDialog(Component a), showOpenDialog(Component a)都可使得对话框可见，但外观有所不同。showSaveDialog(Component a)方法提供保存文件的界面，showOpenDialog(Component a)方法提供打开文件的界面。参数a指定对话框可见时的位置。
       当用户单击文件对话框上的“确定”、“取消”按键或关闭图标，文件对话框将消失，方法返回：JFileChooser.APPROVE_OPTION和JFileChooser.CANCEL_OPTION之一。当返回值是JFileChooser.APPROVE_OPTION时，可以使用JFileChooser类的getSelectedFile()得到文件对话框所选择的文件。

FileDialog是Dialog的子类，主要方法有：
　　1、FileDialog(Frame f,String s,int mode)：构造方法，f为所依赖的窗口对象，s是对话框的名字，mode取值为FileDialog.LOAD或FileDialog.SAVE。
　　2、public String getDirwctory()：获取当前对话框中所显示的文件目录。
　　3、public String getFile()：获取对话框中显示的文件的字符串表示，如不存在则为null。

4、消息对话框
       消息对话框是有模式对话框，进行一个重要的操作动作之前，弹出一个消息对话框。可以用javax.swing包中的JOptionPane类的静态方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static void showMessageDialog(Component parentComponent,String message, String title, int messageType);
 
Component parentComponent：//消息对话框依赖的组件
 
String message：// 要显示的消息
 
String title：//对话框的标题
 
int messageType)：//对话框的外观，取值如下：
 
JOptionPane.INFORMATION_MESSAGE
 
JOptionPane.WARNING_MESSAGE
 
JOptionPane.ERROR_MESSAGE
 
JOptionPane.QUESTION_MESSAGE
 
JOptionPane.PLAIN_MESSAGE

5、输入对话框
       输入对话框含有供用户输入文本的文本框、一个“确定”和“取消”按钮，是有模式对话框。当输入对话框可见时，要求用户输入一个字符串。javax.swing包中的JOptionPane类静态方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static String showInputDialog(Component parentComponent, Object message, String title, int messageType);
 
Component parentComponent//指定输入对话框所依赖的组件。
 
Object message//指定对话框上的提示信息。
 
String title//对话框上的标题。
 
int messageType//确定对话框的外观，取值如下：
 
ERROR_MESSAGE
 
INFORMATION_MESSAGE
 
WARNING_MESSAGE
 
QUESTION_MESSAGE
 
PLAIN_MESSAGE

6、确认对话框
       确认对话框是有模式对话框，可以用javax.swing包中的JOptionPane类的静态方法创建：
　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static int showConfirmDialog(Component parentComponent, Object message, String title, int optionType);
 
Component parentComponent //对话框所依赖的组件。
 
Object messag //对话框上显示的消息
 
String titl //对话框的标题
 
int optionType //对话框的外观，取值如下：
 
JOptionPane.YES_NO_OPTION
 
JOptionPane.YES_NO_CANCEL_OPTION
 
JOptionPane.OK_CANCEL_OPTION

当对话框消失后，showConfirmDialog方法会返回下列整数之一：

JOptionPane.YES_OPTION

JOptionPane.NO_OPTION

JOptionPane.CANCEL_OPTION

JOptionPane.OK_OPTION

JOptionPane.CLOSED_OPTION

7、颜色对话框
      使用java.swing包中的JColorChooser类表静态方法创建：

1
2
3
4
5
6
7
public static Color showDialog(Component component,String title,Color initialColor);
 
Component component//对话框所依赖的组件。
 
String title//对话框的标题。
 
Color initialColor)//对话框消失后返回的默认颜色

第二部分：实验部分

1、实验目的与要求

(1) 掌握菜单组件用途及常用API；

(2) 掌握对话框组件用途及常用API；

(3) 学习设计简单应用程序的GUI。

2、实验内容和步骤

实验1： 导入第12章示例程序，测试程序并进行组内讨论。

测试程序1

l 在elipse IDE中调试运行教材512页程序12-8，结合运行结果理解程序；

l 掌握菜单的创建、菜单事件监听器、复选框和单选按钮菜单项、弹出菜单以及快捷键和加速器的用法。

l 记录示例代码阅读理解中存在的问题与疑惑。

代码如下：

MenuTest.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package menu;
 
import java.awt.*;
import javax.swing.*;
 
/**
 * @version 1.25 2018-04-10
 * @author Cay Horstmann
 */
public class MenuTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         var frame = new MenuFrame();
         frame.setTitle("MenuTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

MenuFrame.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
package menu;
 
import java.awt.event.*;
import javax.swing.*;
 
/**
 * A frame with a sample menu bar.
 */
public class MenuFrame extends JFrame
{
   private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 200;
   private Action saveAction;
   private Action saveAsAction;
   private JCheckBoxMenuItem readonlyItem;
   private JPopupMenu popup;
 
   /**
    * A sample action that prints the action name to System.out.
    */
   class TestAction extends AbstractAction
   {
      public TestAction(String name)
      {
         super(name);
      }
 
      public void actionPerformed(ActionEvent event)
      {
         System.out.println(getValue(Action.NAME) + " selected.");
      }
   }
 
   public MenuFrame()
   {
      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
 
      var fileMenu = new JMenu("File");//构建菜单
      fileMenu.add(new TestAction("New"));
 
      // demonstrate accelerators
 
      var openItem = fileMenu.add(new TestAction("Open"));//添加菜单项
      openItem.setAccelerator(KeyStroke.getKeyStroke("ctrl O"));
 
      fileMenu.addSeparator();//添加分隔符
 
      saveAction = new TestAction("Save");
      JMenuItem saveItem = fileMenu.add(saveAction);
      saveItem.setAccelerator(KeyStroke.getKeyStroke("ctrl S"));
 
      saveAsAction = new TestAction("Save As");
      fileMenu.add(saveAsAction);
      fileMenu.addSeparator();
 
      //采用扩展抽象类AbstractAction来定义一个实现Action接口的类
      fileMenu.add(new AbstractAction("Exit")
         {
          /**
             *
             */
            private static final long serialVersionUID = 1L;
 
        //指定菜单项标签并且覆盖actionPerformed方法来获得菜单动作处理器
            public void actionPerformed(ActionEvent event)
            {
               System.exit(0);
            }
         });
 
      // demonstrate checkbox and radio button menus
 
      readonlyItem = new JCheckBoxMenuItem("Read-only");//用给定标签构造一个复选框菜单项
      //匿名内部类设置监听事件
      readonlyItem.addActionListener(new ActionListener()
         {
            public void actionPerformed(ActionEvent event)
            {
               boolean saveOk = !readonlyItem.isSelected();
               saveAction.setEnabled(saveOk);//启用或禁用菜单项
               saveAsAction.setEnabled(saveOk);
            }
         });
       
      /*
         * 复选框和单选按钮菜单项
       */
      var group = new ButtonGroup();
 
      var insertItem = new JRadioButtonMenuItem("Insert");//构造单选钮菜单项
      insertItem.setSelected(true);
      var overtypeItem = new JRadioButtonMenuItem("Overtype");
 
      group.add(insertItem);
      group.add(overtypeItem);
 
      // demonstrate icons
 
      var cutAction = new TestAction("Cut");
      cutAction.putValue(Action.SMALL_ICON, new ImageIcon("cut.gif"));
      var copyAction = new TestAction("Copy");
      copyAction.putValue(Action.SMALL_ICON, new ImageIcon("copy.gif"));
      var pasteAction = new TestAction("Paste");
      pasteAction.putValue(Action.SMALL_ICON, new ImageIcon("paste.gif"));
 
      var editMenu = new JMenu("Edit");
      editMenu.add(cutAction);
      editMenu.add(copyAction);
      editMenu.add(pasteAction);
 
      // demonstrate nested menus
 
      var optionMenu = new JMenu("Options");
 
      optionMenu.add(readonlyItem);
      optionMenu.addSeparator();
      optionMenu.add(insertItem);
      optionMenu.add(overtypeItem);
 
      editMenu.addSeparator();
      editMenu.add(optionMenu);
 
      // demonstrate mnemonics
 
      //调用setMnemonic方法，为菜单设置快捷键
      var helpMenu = new JMenu("Help");
      helpMenu.setMnemonic('H');
 
      var indexItem = new JMenuItem("Index");
      indexItem.setMnemonic('I');
      helpMenu.add(indexItem);
 
      // you can also add the mnemonic key to an action
      var aboutAction = new TestAction("About");
      aboutAction.putValue(Action.MNEMONIC_KEY, new Integer('A'));
      helpMenu.add(aboutAction);
       
      // add all top-level menus to menu bar
 
      //创建菜单栏
      var menuBar = new JMenuBar();
      setJMenuBar(menuBar);
 
      //将顶层菜单添加到菜单栏中
      menuBar.add(fileMenu);
      menuBar.add(editMenu);
      menuBar.add(helpMenu);
 
      // demonstrate pop-ups
 
      //创建弹出菜单
      popup = new JPopupMenu();
      popup.add(cutAction);
      popup.add(copyAction);
      popup.add(pasteAction);
 
      var panel = new JPanel();
      panel.setComponentPopupMenu(popup);
      add(panel);
   }
}

运行结果如图：

小结：位于窗口顶部的菜单栏包括了下拉菜单的名字。点击一个名字就可以打开包含菜单项和子菜单的菜单。当用户点击菜单项时，所有的菜单都会被关闭并且将一条消息发送给程序。

测试程序2

l 在elipse IDE中调试运行教材517页程序12-9，结合运行结果理解程序；

l 掌握工具栏和工具提示的用法；

l 记录示例代码阅读理解中存在的问题与疑惑。

程序代码如下：

ToolBarTest.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package toolBar;
 
import java.awt.*;
import javax.swing.*;
 
/**
 * @version 1.15 2018-04-10
 * @author Cay Horstmann
 */
public class ToolBarTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         var frame = new ToolBarFrame();
         frame.setTitle("ToolBarTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

ToolBarFrame.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
package toolBar;
 
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
 
/**
 * A frame with a toolbar and menu for color changes.
 */
public class ToolBarFrame extends JFrame
{
   private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 200;
   private JPanel panel;
 
   public ToolBarFrame()
   {
      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
 
      // add a panel for color change
 
      panel = new JPanel();
      add(panel, BorderLayout.CENTER);
 
      // set up actions
 
      var blueAction = new ColorAction("Blue", new ImageIcon("blue-ball.gif"), Color.BLUE);
      var yellowAction = new ColorAction("Yellow", new ImageIcon("yellow-ball.gif"),Color.YELLOW);
      var redAction = new ColorAction("Red", new ImageIcon("red-ball.gif"), Color.RED);
 
      var exitAction = new AbstractAction("Exit", new ImageIcon("exit.gif"))
         {
            public void actionPerformed(ActionEvent event)
            {
               System.exit(0);
            }
         };
      exitAction.putValue(Action.SHORT_DESCRIPTION, "Exit");
 
      // populate toolbar
      //创建工具栏
      var bar = new JToolBar();
      bar.add(blueAction);
      bar.add(yellowAction);
      bar.add(redAction);
      bar.addSeparator();//添加分隔符
      bar.add(exitAction);
      add(bar, BorderLayout.NORTH);//将工具栏添加到框架中
 
      // populate menu
 
      var menu = new JMenu("Color");
      menu.add(yellowAction);
      menu.add(blueAction);
      menu.add(redAction);
      menu.add(exitAction);
      var menuBar = new JMenuBar();
      menuBar.add(menu);
      setJMenuBar(menuBar);
   }
 
   /**
    * The color action sets the background of the frame to a given color.
    */
   class ColorAction extends AbstractAction
   {
      public ColorAction(String name, Icon icon, Color c)
      {
         putValue(Action.NAME, name);
         putValue(Action.SMALL_ICON, icon);
         putValue(Action.SHORT_DESCRIPTION, name + " background");
         putValue("Color", c);
      }
 
      public void actionPerformed(ActionEvent event)
      {
         Color c = (Color) getValue("Color");
         panel.setBackground(c);
      }
   }
}

运行结果如图：

小结：工具栏是在程序中提供的快速访问常用命令的按纽栏，工具栏可以随处移动，也可以完全脱离框架，关闭时会回到原来的位置。

测试程序3

l 在elipse IDE中调试运行教材544页程序12-15、12-16，结合运行结果理解程序；

l 掌握选项对话框的用法。

l 记录示例代码阅读理解中存在的问题与疑惑。

程序代码如下：

OptionDialogTest.Java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package optionDialog;
 
import java.awt.*;
import javax.swing.*;
 
/**
 * @version 1.35 2018-04-10
 * @author Cay Horstmann
 */
public class OptionDialogTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         var frame = new OptionDialogFrame();
         frame.setTitle("OptionDialogTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

OptionDialogFrame.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
package optionDialog;
 
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.util.*;
import javax.swing.*;
 
/**
 * A frame that contains settings for selecting various option dialogs.
 */
public class OptionDialogFrame extends JFrame
{
   private ButtonPanel typePanel;
   private ButtonPanel messagePanel;
   private ButtonPanel messageTypePanel;
   private ButtonPanel optionTypePanel;
   private ButtonPanel optionsPanel;
   private ButtonPanel inputPanel;
   private String messageString = "Message";
   private Icon messageIcon = new ImageIcon("blue-ball.gif");
   private Object messageObject = new Date();
   private Component messageComponent = new SampleComponent();
 
   public OptionDialogFrame()
   {
       //创建一个面板，设置为两行三列的网格，每个网格中定义一个单选的面板
      var gridPanel = new JPanel();
      gridPanel.setLayout(new GridLayout(2, 3));
 
      typePanel = new ButtonPanel("Type", "Message", "Confirm", "Option", "Input");
      messageTypePanel = new ButtonPanel("Message Type", "ERROR_MESSAGE", "INFORMATION_MESSAGE","WARNING_MESSAGE", "QUESTION_MESSAGE", "PLAIN_MESSAGE");
      messagePanel = new ButtonPanel("Message", "String", "Icon", "Component", "Other", "Object[]");
      optionTypePanel = new ButtonPanel("Confirm", "DEFAULT_OPTION", "YES_NO_OPTION","YES_NO_CANCEL_OPTION", "OK_CANCEL_OPTION");
      optionsPanel = new ButtonPanel("Option", "String[]", "Icon[]", "Object[]");
      inputPanel = new ButtonPanel("Input", "Text field", "Combo box");
 
      gridPanel.add(typePanel);
      gridPanel.add(messageTypePanel);
      gridPanel.add(messagePanel);
      gridPanel.add(optionTypePanel);
      gridPanel.add(optionsPanel);
      gridPanel.add(inputPanel);
 
      // add a panel with a Show button
 
      //创建一个按钮组件，设置监听事件
      var showPanel = new JPanel();
      var showButton = new JButton("Show");
      showButton.addActionListener(new ShowAction());
      showPanel.add(showButton);
 
      add(gridPanel, BorderLayout.CENTER);
      add(showPanel, BorderLayout.SOUTH);
      pack();
   }
 
   /**
    * Gets the currently selected message.
    * @return a string, icon, component, or object array, depending on the Message panel selection
    */
   public Object getMessage()
   {
      String s = messagePanel.getSelection();
      if (s.equals("String")) return messageString;
      else if (s.equals("Icon")) return messageIcon;
      else if (s.equals("Component")) return messageComponent;
      else if (s.equals("Object[]")) return new Object[] { messageString, messageIcon,
            messageComponent, messageObject };
      else if (s.equals("Other")) return messageObject;
      else return null;
   }
 
   /**
    * Gets the currently selected options.
    * @return an array of strings, icons, or objects, depending on the Option panel selection
    */
   public Object[] getOptions()
   {
      String s = optionsPanel.getSelection();
      if (s.equals("String[]")) return new String[] { "Yellow", "Blue", "Red" };
      else if (s.equals("Icon[]")) return new Icon[] { new ImageIcon("yellow-ball.gif"),
            new ImageIcon("blue-ball.gif"), new ImageIcon("red-ball.gif") };
      else if (s.equals("Object[]")) return new Object[] { messageString, messageIcon,
            messageComponent, messageObject };
      else return null;
   }
 
   /**
    * Gets the selected message or option type
    * @param panel the Message Type or Confirm panel
    * @return the selected XXX_MESSAGE or XXX_OPTION constant from the JOptionPane class
    */
   public int getType(ButtonPanel panel)
   {
      String s = panel.getSelection();
      try
      {
         return JOptionPane.class.getField(s).getInt(null);
      }
      catch (Exception e)
      {
         return -1;
      }
   }
 
   /**
    * The action listener for the Show button shows a Confirm, Input, Message, or Option dialog
    * depending on the Type panel selection.
    */
   private class ShowAction implements ActionListener
   {
      public void actionPerformed(ActionEvent event)
      {
        //显示一个确认对话框或者内部确认对话框
         if (typePanel.getSelection().equals("Confirm")) JOptionPane.showConfirmDialog(
               OptionDialogFrame.this, getMessage(), "Title", getType(optionTypePanel),
               getType(messageTypePanel));
         else if (typePanel.getSelection().equals("Input"))
         {
             ////显示一个输入对话框或者内部输入对话框
            if (inputPanel.getSelection().equals("Text field")) JOptionPane.showInputDialog(
                  OptionDialogFrame.this, getMessage(), "Title", getType(messageTypePanel));
            else JOptionPane.showInputDialog(OptionDialogFrame.this, getMessage(), "Title",
                  getType(messageTypePanel), null, new String[] { "Yellow", "Blue", "Red" },
                  "Blue");
         }
       //显示一个消息对话框或者内部消息对话框
         else if (typePanel.getSelection().equals("Message")) JOptionPane.showMessageDialog(
               OptionDialogFrame.this, getMessage(), "Title", getType(messageTypePanel));
       //显示一个选项对话框或者内部选项对话框
         else if (typePanel.getSelection().equals("Option")) JOptionPane.showOptionDialog(
               OptionDialogFrame.this, getMessage(), "Title", getType(optionTypePanel),
               getType(messageTypePanel), null, getOptions(), getOptions()[0]);
      }
   }
}
 
/**
 * A component with a painted surface
 */
 
class SampleComponent extends JComponent
{
   public void paintComponent(Graphics g)
   {
      var g2 = (Graphics2D) g;
      var rect = new Rectangle2D.Double(0, 0, getWidth() - 1, getHeight() - 1);
      g2.setPaint(Color.YELLOW);
      g2.fill(rect);
      g2.setPaint(Color.BLUE);
      g2.draw(rect);
   }
 
   public Dimension getPreferredSize()
   {
      return new Dimension(10, 10);
   }
}

ButtonPanel.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package optionDialog;
 
import javax.swing.*;
 
/**
 * A panel with radio buttons inside a titled border.
 */
public class ButtonPanel extends JPanel
{
   private ButtonGroup group;
 
   /**
    * Constructs a button panel.
    * @param title the title shown in the border
    * @param options an array of radio button labels
    */
   public ButtonPanel(String title, String... options)
   {
      setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(), title));
      setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
      group = new ButtonGroup();
 
      // make one radio button for each option
      for (String option : options)
      {
         var button = new JRadioButton(option);
         button.setActionCommand(option);
         add(button);
         group.add(button);
         button.setSelected(option == options[0]);
      }
   }
 
   /**
    * Gets the currently selected option.
    * @return the label of the currently selected radio button.
    */
   public String getSelection()
   {
      return group.getSelection().getActionCommand();
   }
}

运行结果如图：

小结：简单的对话框，用于获取用户的一些简单信息。输入对话框用于接受用户输入的额外组件。选项包括：1：选择对话框的类型，2：选择图标，3;选择消息，4：对于确认对话框，选择选项类型，5;对于选项对话框，选择选项，6：调用JOptionPane API中的相应方法。

测试程序4

l 在elipse IDE中调试运行教材552页程序12-17、12-18，结合运行结果理解程序；

l 掌握对话框的创建方法；

l 记录示例代码阅读理解中存在的问题与疑惑。

程序代码如下：

DialogTest.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package dialog;
 
import java.awt.*;
import javax.swing.*;
 
/**
 * @version 1.35 2018-04-10
 * @author Cay Horstmann
 */
public class DialogTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         var frame = new DialogFrame();
         frame.setTitle("DialogTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}　

DialogFrame.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package dialog;
 
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
 
/**
 * A frame with a menu whose File->About action shows a dialog.
 */
public class DialogFrame extends JFrame
{
   private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 200;
   private AboutDialog dialog;
 
   public DialogFrame()
   {
      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
 
      // construct a File menu
 
      var menuBar = new JMenuBar();
      setJMenuBar(menuBar);
      var fileMenu = new JMenu("File");
      menuBar.add(fileMenu);
 
      // add About and Exit menu items
 
      // the About item shows the About dialog
 
      var aboutItem = new JMenuItem("About");
      //lambda表达式
      aboutItem.addActionListener(event -> {
         if (dialog == null) // first time
             //建立新的对话框对象，设置可见
            dialog = new AboutDialog(DialogFrame.this);
         dialog.setVisible(true);
      });
      fileMenu.add(aboutItem);
 
      // the Exit item exits the program
 
      var exitItem = new JMenuItem("Exit");
      exitItem.addActionListener(event -> System.exit(0));
      fileMenu.add(exitItem);
   }
}

AboutDialog.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package dialog;
 
import java.awt.BorderLayout;
 
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
/**
 * A sample modal dialog that displays a message and waits for the user to click
 * the OK button.
 */
 
public class AboutDialog extends JDialog
{
    //调用超类JDialog的构造器
   public AboutDialog(JFrame owner)
   {
      super(owner, "About DialogTest", true);
 
     //添加对话框的用户界面组件
      add(
         new JLabel(
            "<html><h1><i>Core Java</i></h1><hr>By Cay Horstmann</html>"),
         BorderLayout.CENTER);
 
      // OK button closes the dialog
      //点击OK按钮时，对话框被关闭
      var ok = new JButton("OK");
      ok.addActionListener(event -> setVisible(false));
 
      // add OK button to southern border
 
      var panel = new JPanel();
      panel.add(ok);
      add(panel, BorderLayout.SOUTH);
 
      pack();
   }
}

运行结果如图：

小结：实现一个对话框，需要从JDialog派生一个类。具体过程如下：1：在对话框构造器中调用超类JDialog的构造器，2：添加对话框的用户界面组件，3：添加事件处理器，4;设置对话框的大小。

测试程序5

l 在elipse IDE中调试运行教材556页程序12-19、12-20，结合运行结果理解程序；

l 掌握对话框的数据交换用法;

l 记录示例代码阅读理解中存在的问题与疑惑。

程序代码如下：

DataExchangeTest.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package dataExchange;
 
import java.awt.*;
import javax.swing.*;
 
/**
 * @version 1.35 2018-04-10
 * @author Cay Horstmann
 */
public class DataExchangeTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         var frame = new DataExchangeFrame();
         frame.setTitle("DataExchangeTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

DataExchangeFrame.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
package dataExchange;
 
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
 
/**
 * A frame with a menu whose File->Connect action shows a password dialog.
 */
public class DataExchangeFrame extends JFrame
{
   public static final int TEXT_ROWS = 20;
   public static final int TEXT_COLUMNS = 40;
   private PasswordChooser dialog = null;
   private JTextArea textArea;
 
   public DataExchangeFrame()
   {
      //创建一个菜单
 
      var mbar = new JMenuBar();
      setJMenuBar(mbar);
      var fileMenu = new JMenu("File");
      mbar.add(fileMenu);
 
      //添加菜单项
 
      var connectItem = new JMenuItem("Connect");
      connectItem.addActionListener(new ConnectAction());
      fileMenu.add(connectItem);
 
      // the Exit item exits the program
 
      var exitItem = new JMenuItem("Exit");
      exitItem.addActionListener(event -> System.exit(0));
      fileMenu.add(exitItem);
 
      textArea = new JTextArea(TEXT_ROWS, TEXT_COLUMNS);
      add(new JScrollPane(textArea), BorderLayout.CENTER);
      pack();
   }
 
   /**
    * The Connect action pops up the password dialog.
    */
   //添加监听事件
   private class ConnectAction implements ActionListener
   {
      public void actionPerformed(ActionEvent event)
      {
         // if first time, construct dialog
 
         if (dialog == null) dialog = new PasswordChooser();
 
         // set default values
         dialog.setUser(new User("yourname", null));
 
         // pop up dialog
         if (dialog.showDialog(DataExchangeFrame.this, "Connect"))
         {
            // if accepted, retrieve user input
            User u = dialog.getUser();
            textArea.append("user name = " + u.getName() + ", password = "
               + (new String(u.getPassword())) + "\n");
         }
      }
   }
}
PasswordChooser.java:
 
package dataExchange;
 
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Frame;
import java.awt.GridLayout;
 
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JPasswordField;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;
 
/**
 * A password chooser that is shown inside a dialog.
 */
public class PasswordChooser extends JPanel
{
   private JTextField username;
   private JPasswordField password;
   private JButton okButton;
   private boolean ok;
   private JDialog dialog;
 
   public PasswordChooser()
   {
      setLayout(new BorderLayout());
 
      // construct a panel with user name and password fields
 
      var panel = new JPanel();
      panel.setLayout(new GridLayout(2, 2));
      panel.add(new JLabel("User name:"));
      panel.add(username = new JTextField(""));
      panel.add(new JLabel("Password:"));
      panel.add(password = new JPasswordField(""));
      add(panel, BorderLayout.CENTER);
 
      // create Ok and Cancel buttons that terminate the dialog
 
      okButton = new JButton("Ok");
      okButton.addActionListener(event -> {
         ok = true;
         dialog.setVisible(false);
      });
 
      var cancelButton = new JButton("Cancel");
      cancelButton.addActionListener(event -> dialog.setVisible(false));
 
      // add buttons to southern border
 
      var buttonPanel = new JPanel();
      buttonPanel.add(okButton);
      buttonPanel.add(cancelButton);
      add(buttonPanel, BorderLayout.SOUTH);
   }
 
   /**
    * Sets the dialog defaults.
    * @param u the default user information
    */
   //PasswordChooser类提供的setUser方法
   public void setUser(User u)
   {
      username.setText(u.getName());
   }
 
   /**
    * Gets the dialog entries.
    * @return a User object whose state represents the dialog entries
    */
   public User getUser()
   {
      return new User(username.getText(), password.getPassword());
   }
 
   /**
    * Show the chooser panel in a dialog.
    * @param parent a component in the owner frame or null
    * @param title the dialog window title
    */
   //在showDialog方法中动态建立JDialog对象
   public boolean showDialog(Component parent, String title)
   {
      ok = false;
 
      // locate the owner frame
 
      Frame owner = null;
      if (parent instanceof Frame)
         owner = (Frame) parent;
      else
         owner = (Frame) SwingUtilities.getAncestorOfClass(Frame.class, parent);
 
      // if first time, or if owner has changed, make new dialog
 
      if (dialog == null || dialog.getOwner() != owner)
      {
         dialog = new JDialog(owner, true);
         dialog.add(this);
         dialog.getRootPane().setDefaultButton(okButton);//在对话框的根窗口中设置默认按钮
         dialog.pack();
      }
 
      // set title and show dialog
 
      dialog.setTitle(title);
      dialog.setVisible(true);
      return ok;
   }
}

User.java:

 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package dataExchange;
 
/**
 * A user has a name and password. For security reasons, the password is stored as a char[], not a
 * String.
 */
public class User
{
   private String name;
   private char[] password;
 
   public User(String aName, char[] aPassword)
   {
      name = aName;
      password = aPassword;
   }
 
   public String getName()
   {
      return name;
   }
 
   public char[] getPassword()
   {
      return password;
   }
 
   public void setName(String aName)
   {
      name = aName;
   }
 
   public void setPassword(char[] aPassword)
   {
      password = aPassword;
   }
}

测试程序6

l 在elipse IDE中调试运行教材556页程序12-21、12-22、12-23，结合程序运行结果理解程序；

l 掌握文件对话框的用法;

l 记录示例代码阅读理解中存在的问题与疑惑。

程序代码如下：

FileChooserTest.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package fileChooser;
 
import java.awt.*;
import javax.swing.*;
 
/**
 * @version 1.26 2018-04-10
 * @author Cay Horstmann
 */
public class FileChooserTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         var frame = new ImageViewerFrame();
         frame.setTitle("FileChooserTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

FileIconView.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
package fileChooser;
 
import java.io.*;
import javax.swing.*;
import javax.swing.filechooser.*;
import javax.swing.filechooser.FileFilter;
 
/**
 * A file view that displays an icon for all files that match a file filter.
 */
public class FileIconView extends FileView
{
   private FileFilter filter;
   private Icon icon;
 
   /**
    * Constructs a FileIconView.
    * @param aFilter a file filter--all files that this filter accepts will be shown
    * with the icon.
    * @param anIcon--the icon shown with all accepted files.
    */
   public FileIconView(FileFilter aFilter, Icon anIcon)
   {
      filter = aFilter;
      icon = anIcon;
   }
 
   public Icon getIcon(File f)
   {
      if (!f.isDirectory() && filter.accept(f)) return icon;
      else return null;
   }
}
ImagePreviewer.java:
 
package fileChooser;
  
import java.awt.*;
import java.io.*;
  
import javax.swing.*;
  
/**
 * A file chooser accessory that previews images.
 */
public class ImagePreviewer extends JLabel
{
   /**
    * Constructs an ImagePreviewer.
    * @param chooser the file chooser whose property changes trigger an image
    *        change in this previewer
    */
   public ImagePreviewer(JFileChooser chooser)
   {
      setPreferredSize(new Dimension(100, 100));
      setBorder(BorderFactory.createEtchedBorder());
  
      chooser.addPropertyChangeListener(event -> {
         if (event.getPropertyName() == JFileChooser.SELECTED_FILE_CHANGED_PROPERTY)
         {
            //用户选择了一个新文件
            File f = (File) event.getNewValue();
            if (f == null)
            {
               setIcon(null);
               return;
            }
  
            //将影像读取成图示
            ImageIcon icon = new ImageIcon(f.getPath());
  
            // 如果图标太大，无法安装，请缩放
            if (icon.getIconWidth() > getWidth())
               icon = new ImageIcon(icon.getImage().getScaledInstance(
                     getWidth(), -1, Image.SCALE_DEFAULT));
  
            setIcon(icon);
         }
      });
   }
}
ImageViewerFrame.java:
 
package fileChooser;
  
import java.io.*;
  
import javax.swing.*;
import javax.swing.filechooser.*;
import javax.swing.filechooser.FileFilter;
  
/**
 * A frame that has a menu for loading an image and a display area for the
 * loaded image.
 */
public class ImageViewerFrame extends JFrame
{
   private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 400;
   private JLabel label;
   private JFileChooser chooser;
  
   public ImageViewerFrame()
   {
      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
  
      // 设置菜单栏
      JMenuBar menuBar = new JMenuBar();
      setJMenuBar(menuBar);
  
      JMenu menu = new JMenu("File");
      menuBar.add(menu);
  
      JMenuItem openItem = new JMenuItem("Open");
      menu.add(openItem);
      openItem.addActionListener(event -> {
         chooser.setCurrentDirectory(new File("."));
  
         // 显示文件选择器对话框
            int result = chooser.showOpenDialog(ImageViewerFrame.this);
  
            // 如果图像文件被接受，将其设置为标签的图标
            if (result == JFileChooser.APPROVE_OPTION)
            {
               String name = chooser.getSelectedFile().getPath();
               label.setIcon(new ImageIcon(name));
               pack();
            }
         });
  
      JMenuItem exitItem = new JMenuItem("Exit");
      menu.add(exitItem);
      exitItem.addActionListener(event -> System.exit(0));
  
      //使用标签显示影像
      label = new JLabel();
      add(label);
  
      // 设置文件选择器
      chooser = new JFileChooser();
  
      //接受所有以之结尾的影像档案。JPG图形交换格式
      FileFilter filter = new FileNameExtensionFilter(
            "Image files", "jpg", "jpeg", "gif");
      chooser.setFileFilter(filter);
  
      chooser.setAccessory(new ImagePreviewer(chooser));
  
      chooser.setFileView(new FileIconView(filter, new ImageIcon("palette.gif")));
   }
}

运行结果如图：

小结：文件对话框，调用showOpenDialog。接受文件的按钮被自动的标签为Open或者Save，也可以调用showDialog方法为按钮设定标签。

测试程序7

l 在elipse IDE中调试运行教材570页程序12-24，结合运行结果理解程序；

l 了解颜色选择器的用法。

l 记录示例代码阅读理解中存在的问题与疑惑。

程序代码如下：

ColorChooserTest.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package colorChooser;
 
import java.awt.*;
import javax.swing.*;
 
/**
 * @version 1.04 2015-06-12
 * @author Cay Horstmann
 */
public class ColorChooserTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         JFrame frame = new ColorChooserFrame();
         frame.setTitle("ColorChooserTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

ColorChooserPane.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
package colorChooser;
 
import java.awt.Color;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JColorChooser;
import javax.swing.JDialog;
import javax.swing.JPanel;
 
/**
 * A panel with buttons to pop up three types of color choosers
 */
public class ColorChooserPanel extends JPanel
{
   public ColorChooserPanel()
   {
       //在面板设置三个按钮
      JButton modalButton = new JButton("Modal");
      modalButton.addActionListener(new ModalListener());
      add(modalButton);
 
      JButton modelessButton = new JButton("Modeless");
      modelessButton.addActionListener(new ModelessListener());
      add(modelessButton);
 
      JButton immediateButton = new JButton("Immediate");
      immediateButton.addActionListener(new ImmediateListener());
      add(immediateButton);
   }
 
   /**
    * This listener pops up a modal color chooser
    */
   //设置了Modal按钮的监听事件
   private class ModalListener implements ActionListener
   {
      public void actionPerformed(ActionEvent event)
      {
         Color defaultColor = getBackground();
         Color selected = JColorChooser.showDialog(ColorChooserPanel.this, "Set background",
               defaultColor);
         if (selected != null) setBackground(selected);
      }
   }
 
   /**
    * This listener pops up a modeless color chooser. The panel color is changed when the user
    * clicks the OK button.
    */
   //设置了Modeless按钮的监听事件
   private class ModelessListener implements ActionListener
   {
      private JDialog dialog;
      private JColorChooser chooser;
 
      public ModelessListener()
      {
         chooser = new JColorChooser();
         dialog = JColorChooser.createDialog(ColorChooserPanel.this, "Background Color",
               false /* not modal */, chooser,
               event -> setBackground(chooser.getColor()),
               null /* no Cancel button listener */);
      }
 
      public void actionPerformed(ActionEvent event)
      {
         chooser.setColor(getBackground());
         dialog.setVisible(true);
      }
   }
 
   /**
    * This listener pops up a modeless color chooser. The panel color is changed immediately when
    * the user picks a new color.
    */
 //设置了Immediate按钮的监听事件
   private class ImmediateListener implements ActionListener
   {
      private JDialog dialog;
      private JColorChooser chooser;
 
      public ImmediateListener()
      {
         chooser = new JColorChooser();
         chooser.getSelectionModel().addChangeListener(
               event -> setBackground(chooser.getColor()));
 
         dialog = new JDialog((Frame) null, false /* not modal */);
         dialog.add(chooser);
         dialog.pack();
      }
 
      public void actionPerformed(ActionEvent event)
      {
         chooser.setColor(getBackground());
         dialog.setVisible(true);
      }
   }
}

ColorChooserFrame.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package colorChooser;
 
import javax.swing.*;
 
/**
 * A frame with a color chooser panel
 */
public class ColorChooserFrame extends JFrame
{
   private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 200;
 
   public ColorChooserFrame()
   {     
      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
 
      // add color chooser panel to frame
 
      ColorChooserPanel panel = new ColorChooserPanel();//创建一个颜色选择器
      add(panel);
   }
}

运行结果如图：

 

小结：颜色选择器是一个组件，包含了用于创建包含颜色选择器组件的对话框方法。有三种对话框类型。如果点击Model按钮，则需要选择一个颜色才能继续后面的操作。如果点击Modaless按钮，则会得到一个无模式对话框。只有点击OK按钮时，颜色才会发生改变。如果点击Immediate按钮，会得到一个没有按钮的无模式对话框。

3、实验总结:

1）FlowLayout: 流布局(Applet和Panel的默认布局管理器）
（2）BorderLayout:边框布局( Window、Frame和Dialog的默认布局管理器）
（3）GridLayout: 网格布局
（4）GridBagLayout: 网格组布局
（5）CardLayout :卡片布局

201871010124-王生涛《面向对象程序设计（java）》第十五周学习总结的更多相关文章

  1. 201571030332 扎西平措 《面向对象程序设计Java》第八周学习总结

    <面向对象程序设计Java>第八周学习总结   项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https: ...

  2. 201771010118马昕璐《面向对象程序设计java》第八周学习总结

    第一部分:理论知识学习部分 1.接口 在Java程序设计语言中,接口不是类,而是对类的一组需求描述,由常量和一组抽象方法组成.Java为了克服单继承的缺点,Java使用了接口,一个类可以实现一个或多个 ...

  3. 201771010134杨其菊《面向对象程序设计java》第八周学习总结

    第八周学习总结 第一部分:理论知识 一.接口.lambda和内部类:  Comparator与comparable接口: 1.comparable接口的方法是compareTo,只有一个参数:comp ...

  4. 201771010134杨其菊《面向对象程序设计java》第七周学习总结

    第七周学习总结 第一部分:理论知识 1.继承是面向对象程序设计(Object Oriented Programming-OOP)中软件重用的关键技术.继承机制使用已经定义的类作为基础建立新的类定义,新 ...

  5. 201871010126 王亚涛《面向对象程序设计 JAVA》 第十三周学习总结

      内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p/ ...

  6. 201871010126 王亚涛 《面向对象程序设计 (Java)》第十七周学习总结

    内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p/12 ...

  7. 马凯军201771010116《面向对象程序设计Java》第八周学习总结

    一,理论知识学习部分 6.1.1 接口概念 两种含义:一,Java接口,Java语言中存在的结构,有特定的语法和结构:二,一个类所具有的方法的特征集合,是一种逻辑上的抽象.前者叫做“Java接口”,后 ...

  8. 周强201771010141《面向对象程序设计Java》第八周学习总结

    一.理论知识学习部分 Java为了克服单继承的缺点,Java使用了接口,一个类可以实现一个或多个接口. 接口体中包含常量定义和方法定义,接口中只进行方法的声明,不提供方法的实现. 类似建立类的继承关系 ...

  9. 201777010217-金云馨《面向对象程序设计Java》第八周学习总结

    项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p ...

  10. 20155322 2016-2017-2 《Java面向对象程序设计》第十二周课堂练习之Arrays和String单元测试

    20155322 2016-2017-2 <Java面向对象程序设计>第十二周课堂练习之Arrays和String单元测试 练习目地 在IDEA中以TDD的方式对String类和Array ...

随机推荐

  1. 配置Ngnix1.15.11+php5.4出现502 Bad Gateway问题

    今天在调试Ngnix1.15.11+php5.4网站时候,因为网站数据和并发过大,出现502 Bad Gateway问题,所以记下笔记. 只需要修改php-fpm.conf的request_termi ...

  2. C++ 模板类示例 template class

    声明和实现在一个文件中: template<class T> class book { public: book(); ~book(); private: }; template<c ...

  3. Centos7防火墙添加端口

    添加 firewall-cmd --zone=public --add-port=80/tcp --permanent   (--permanent永久生效,没有此参数重启后失效) 重新载入 fire ...

  4. C# git忽略文件 （.gitignore ）

    # Visual Studio # User-specific files *.suo *.user *.userosscache *.sln.docstates # User-specific fi ...

  5. HDU 6298(数学)

    题意是给出一个数,找出这个数的三个因子且这三个因子的和等于这个数,输出满足条件的乘积最大的一组因子的乘积,如果不存在这样的因子,就输出 -1. 第一次 wa 了,因为把题目中的 x | n 当做了位或 ...

  6. 阿里Sentinel整合Zuul网关详解

    前面我们讲解了Sentinel整合Spring Cloud Gateway,详细请查看文章:阿里Sentinel支持Spring Cloud Gateway啦 目前来说,大部分公司线上的网关应该是Zu ...

  7. Course: ISA 414

    Assignment #4Course: ISA 414Points:100Due date: November 18th, 2019, before 11:59 pmSubmission instr ...

  8. 单个视频播放控制&默认横屏播放

    一.视频列表中控制只允许一个视频播放 // 获取DOM中所有的video标签 var videoTags = document.querySelectorAll('video'); // 控制播放的视 ...

  9. mysql批量更新数据(性能优化) 第一种方式

    首先想到的是,一条一条更新的速度太慢了,然后就想批量更新,一次更新N条数据.实践是检验真理的唯一标准,不一会儿,代码就敲完了,重新试了一下,效果依旧不理想.啊哦,真是要崩溃!后面又想到了利用异步,我一 ...

  10. 微软宣布.NET Native预览版 C#可编译为本地机器码【转】

    英文原文:Announcing .NET Native Preview 微软在 MSDN 博客上宣布了 .NET Native 的开发者预览版..NET Native 可以将 C# 代码编译成本地机器 ...