JAVA讲义第8章

第8章图形用户界面设计

8.1概述

第5章和第7章的例子中曾涉及到过一些简单的图形用户界面内容。通过图形用户界面（graphics user interface ，GUI），用户和程序之间可以方便地进行交互。在Java语言中提供了专门的类库来生成各种标准图形界面元素和各种处理图形界面的各种事件，以实现图形用户界面的设计。

8.1.1 AWT简介

【引例】AWT实例。

import java.awt.*;

import java.applet.*;

public class Applet2 extends Applet

{

public void init()

{

repaint();

}

public void paint(Graphics g)

{

g.drawString("My applet", 10, 15);

g.draw3DRect(0, 0, 100, 20, true); //绘制三维立体矩形

}

}

该引例实现了一种特殊效果的输出，即在屏幕上用一个三维立体矩形的方框将字符串包围起来。程序中使用的java.awt包就是Java中专门用来生成图形用户界面的类库。

Java的抽象窗口工具包AWT（Abstract Window Toolkit）中包含了许多类来支持GUI 设计。AWT由Java的java.awt提供，该包中有许多用来设计GUI的组件类，如：按钮、菜单、列表、文本框等组件类，同时它还包括窗口、面板等容器。

AWT包中层次关系如图8.1所示。

图8.1 AWT包层次关系图

从图中不难看出，java.awt包中除了包含Font、Color、Graphics、MenuComponent等子类外，还包含了两个重要的概念：组件类（Component）和容器类（Container）。

Component类中包含了Button(按钮)、Canvas(画布)、CheckBox(复选按钮)、Choice(下拉列表)、Label(标签)、List(列表)、Scrollbar(滚动条)、TextField(文本框)、TextArea(多行文本域)子类。

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

Container类包含了Panel(面板)、Window(窗口)、Frame(结构)、Dialog(对话)等子类。Java把由Container的子类或间接子类创建的对象称为一个容器。

Java的Component类提供了一个public add()方法，可以向容器添加组件。即，一个容器可以调用这个方法将组件添加到该容器中。

需要注意：Applet类不是java.awt包中的类，图中只是说明它是Panel的子

类，是Container的间接子类，即由Applet类创建的对象也是一个容器。

8.1.2 基本的构造方法

Java 应用程序和Java Applet程序都可以在图形用户界面中工作，但它们的实现方法不同。

Java Applet程序需要在Web浏览器中运行，而浏览器本身是图形界面的环境，所以Java Applet程序可以且只能在图形界面下工作，所有Applet程序都需要加入import java.awt.*的描述。

与Java Appet程序不同，Java 应用程序没有浏览器提供的现成的图形界面可以直接使用，所以需要创建自己的图形界面，才能实现图形界面下的输入输出功能。

现在来看一看引例中的paint()方法以及相关的其他两种方法。

1．paint()方法

该方法的主要作用是在屏幕上显示文字、图形和其他界面元素。它也是浏览器可自动调用的方法。导致浏览器调用paint()方法的事件主要有如下3种：

（1）Applet程序被启动之后，自动调用paint()来重新描绘自己的界面。

（2）Applet程序所在的浏览器窗口改变时，例如，窗口放大、缩小、移动或被系统的其他部分遮挡、覆盖后又重新显示在屏幕的最前方等。这些情况都要求Applet程序重画它的界面，此时浏览器就自动调用paint()方法来完成此项工作。

（3）Applet程序的其他相关方法被调用时，系统也会相应地调用paint()方法。

2．repaint()方法

该方法在Applet程序需要重绘时随时可以调用。

3．update()方法

该方法由repaint()调用，表明应该更新输出画面。

当repaint()方法被调用时，系统将首先调用update()方法将Applet程序实例所占用的屏幕空间清空，然后调用paint()方法重画之。

【例8.1】用基本构造方法实现动画效果。

import java.applet.Applet;

import java.awt.*;

public class Animator extends Applet

{

image[] mygif; //保存图片序列的Image数组

int total=9; //图片序列中的图片总数

int current=0;

public void init()

{

mygif=new Image[total];

for(int i=0;i

mygif[i]=getImage(getDocumentBase(),"gif\\gif000"+(i+1)+".gif");

}

public void start()

{

current=0; //从第一幅开始显示

}

public void paint(Graphics g)

{

g.drawImage(mygif[current],50,50,this); //显示当前序号图片

current=++current%total; //计算下一个显示图片序号

try{

Thread.sleep(100); //程序休眠100毫秒

}

catch(InterruptedException e){

showStatus(e.toString());

}

repaint();//图片停留100毫秒后被擦除，重新调用paint()显示下一张图片}

}

从第5章已经知道，Applet程序必须被嵌入到HTML代码中方可实现其功能。由于本章的重点是图形用户界面设计，所以，凡是需要HTML代码的地方，本章均省略，读者可自行写出简单的HTML代码文件，运行Applet程序即可。

本例程序运行后，瞬间结果如图8.2所示。

图8.2 例8.1的瞬间结果屏幕

用Java实现动画的原理与放映动画片类似，取若干相关的图像或图片，顺序、连续

地在屏幕上先显示，后擦除，循环往复就可以获得动画的效果。在本程序中，使用Applet 类中的getImage()方法获取所有的.gif图像文件存放于mygif数组中；使用paint()方法一次显示一幅图像，显示图像使用Graphics类的drawImage()方法；每幅图像停留100毫秒后，使用repaint()方法擦除图片，重新调用paint()方法显示下一幅图片。

8.2组件的创建与使用

通过下面的引例不妨认识一下AWT组件的创建和使用方法。注意，有些组件在第5、7章出现过，并详细介绍过。

【引例】简单组件的使用方法。

import java.applet.*;

import java.awt.*;

import java.awt.event.*;

public class example extends Applet implements ActionListener

{

Font MyFont= new Font("隶书",Font.BOLD,12);

TextField text1=new TextField(18); //创建文本框

Button button1=new Button("Click me"); //创建按钮

Button button2=new Button("Click here"); //创建按钮

public void init()

{

add(text1); //加文本框到窗口

text1.setFont(MyFont);

add(button1); //加按钮1到窗口

add(button2); //加按钮2到窗口

button1.addActionListener(this); //将按钮1注册给按下按钮事件的监听者

button2.addActionListener(this); //将按钮2注册给按下按钮事件的监听者}

public void actionPerformed(ActionEvent e) //按钮被按下后的执行方法

{

String b1=new String("欢迎到Java园地!");

String b2=new String("这是一个精彩的世界!");

if(e.getSource()==button1)

text1.setText(b1); //如果单击按钮1，则将b1串设置到文本框中if(e.getSource()==button2)

text1.setText(b2); //如果单击按钮2，则将b2串设置到文本框中}

}

程序的功能：程序中有一个文本框组件和两个按钮组件，当单击“Click me”按钮后，在文本框中显示“欢迎到Java园地!”；当单击“Click here”按钮后，在文本框中显示“这是一个精彩的世界!”。

8.2.1 简单的窗口部件

在Java语言中，GUI标准组件是由AWT包中的对象来代表的，这些对象间的层次关系如图8.1所示。可见所有的GUI标准组件都是java.awt.*包中的根类Component类的子类，Component类的直接子类包括一个容器组件Container和8个基本组件，如Button、Label、Choice、TextComponent等。

Container是所有容器组件的根类，容器组件的主要作用是包容其他组件并按一定的方式组织排列它们，同一个容器中的所有部件通常总是同时被显示和同时被隐藏的。所有的容器组件都是Container类的子类，可分为3组。第1组为Panel和Applet容器，它们都是无边框的；第2组为ScrollPane容器，它是可以自动处理滚动操作的容器；第3组为Window、Frame、Dialog和FileDialog容器，它们是都含有边框，并可以进行移动、放大、缩小、关闭等操作，且具有较强功能的容器。

基本控制组件被安放在容器中的某个位置，它的作用是用来完成一种具体地与用户交互的功能。包括接收用户的一个命令，接收用户的一个文本或选择输入，向用户显示一段文本或一个图形等等。目前常用的控制组件有命令按钮、单选按钮、复选按钮、下拉列表、文本框等，引例中就使用了按钮和文本框组件。

Component类是所有组件和容器的抽象父类，其中定义了每个容器和组件都可能用到的方法，较常用的方法如表8-1所示。

表8-1 Component类常用的方法

8.2.2 文本组件

文本组件（TextComponent）类是用于编辑文本的组件，此类包括了文本框（TextField）和多行文本区域（TextArea）两种子类。

1．TextField类

TextField类用于编辑单行文本，它只有一行。TextField类提供了多种构造方法，用于创建文本框组件的对象。常见的构造方法的使用如下：

TextField name1=new TextField();

TextField name2=new TextField(int columns);

TextField name3=new TextField(String text);

TextField name4=new TextField(String text,int columns);

其中text为文本框中初始字符串，columns为文本框容纳字符的个数。

在引例中使用TextField text1=new TextField(18)创建了一个能容纳18个字符的文本框。

2．TextArea类

TextArea类提供可以编辑或显示多行文本的区域，并且在编辑器内可以见到水平与垂直滚动条。TextArea类提供了多种构造方法，用于创建文本区域组件的对象。常见的构造方法的使用如下：

TextArea textArea1=new TextArea();

TextArea textArea2=new TextArea(int rows,int columns);

TextArea textArea3=new TextArea(String text);

TextArea textArea4=new TextArea(String text,int rows,int columns);

TextArea textArea5=new TextArea(String text,int rows,int columns,int scrollbars);

其中，rows和columns分别表示新建文本区的行数和列数，text为文本区域中初始字符串，scrollbars表示在文本区域中可见滚动条。

例如，如果想创建20行4列的文本区域，可以使用如下的构造方法实现：

TextArea text2=new TextArea(20,4)。

3．TextComponent类中的常用方法

TextComponent类中的方法适合于TextField类和TextArea类，原因是TextField类和TextArea类都是它的子类。TextComponent类中的常用方法如表8-2所示。

表8-2 TextComponent类中常用的方法

表8-3 TextField类中常用的方法

表8-4 TextArea类常用的方法

【例8.2】文本组件实例。

import java.applet.Applet;

import java.awt.*;

import java.awt.event.*;

public class TextComponent extends Applet implements ActionListener

{

TextArea ta=new TextArea(5,30); //创建5行30列的多行文本区域

TextField tf=new TextField(30); //创建容纳30个字符的文本框

Button button=new Button("复制"); //创建一个按钮对象

String text="AWT提供基本的GUI组件，\n"+"具有可以扩展的超类，\n"+ "它们的属性是继承的。\n";

public void init()

{

ta.setText(text); //将text字符串的内容设置到多行文本区域中

ta.setEditable(true); //设置文本区域的内容是可编辑的

add(ta); //将ta对象加到Applet程序窗口画面内。

add(button); //将按钮对象加到Applet程序窗口画面内。

add(tf); //将tf对象加到Applet程序窗口画面内。

button.addActionListener(this); //将按钮注册给按钮事件的监听者}

public void actionPerformed(ActionEvent e) //当按钮按下后的执行方法

{

String s;

s=ta.getSelectedText(); //得到多行文本区域中选定的字符串

if(e.getSource()==button)

tf.setText(s);} //如果单击“复制”按钮，则把s的值设置到文本框中。

}

}

程序运行结果如图8.3所示。

(1) (2)

图8.3 例8.2程序运行结果

8.3容器与布局管理

要为应用程序设计精美的外观，设计和控制窗口组件在容器中的位置和相互关系，就必须学习布局设计的知识。

【引例】容器与布局管理实例。

import java.awt.*;

public class FramePanel extends Frame

{

public static void main (String args[])

{

FramePanel fr = new FramePanel("我的窗口"); //创建一个框架窗口对象

fr.setSize(500,100); //设置窗口大小

fr.setBackground(Color.blue); //设置窗口背景颜色

fr.setLayout(new FlowLayout()) //设置FlowLayout布局风格

Panel p1,p2,p3; //定义3个面板

Label lb1,lb2,lb3; //定义3个标签

Button btn; //定义1个按钮

p1=new Panel(); //创建面板p1

p1.setSize(100,100); //设置p1大小

p1.setBackground(Color.gray); //设置p1背景颜色

p2=new Panel(); //创建面板p2

p2.setSize(100,100); //设置p2大小

p2.setBackground(Color.red); //设置p2背景颜色

p3=new Panel(); //创建面板p3

p3.setSize(100,100); //设置p3大小

p3.setBackground(Color.cyan); //设置p3背景颜色

lb1=new Label("Panel1"); //创建标签lb1

lb2=new Label("Panel2"); //创建标签lb2

lb3=new Label("Panel3"); //创建标签lb3

btn=new Button("in Panel3"); //创建按钮

p1.add(lb1); //加标签lb1到面板p1中

p2.add(lb2); //加标签lb2到面板p2中

p3.add(lb3); //加标签lb3到面板p3中

p3.add(btn); //加按钮到面板p3中

fr.add(p1); //加面板p1到框架窗口中

fr.add(p2); //加面板p2到框架窗口中

fr.add(p3); //加面板p3到框架窗口中

fr.setVisible(true); //设置窗口为可见

}

public FramePanel(String str) //创建框架窗口的构造方法

{

super(str);

}

}

该引例的功能：创建了3个面板，分别在其中放置了一些标签或按钮，再把它们加到了一个框架对象上。程序运行后的画面如图8.4所示。

图8.4 窗口布局画面

8.3.1 容器

容器类都是从Component类继承来的，它可以作为对象容纳任何的可视元素。在各种复杂的用户接口中，容器使得放置组件的操作变得特别容易。

容器类（Container）有两个主要类型：Panel（面板）和Window（窗口）。

1．面板

面板（Panel）是Java中最为通用的容器。对于复选框与按钮而言，这是个非常完美的容器。Panel是从Container类直接继承的，它可以被包含在另一个容器中，或是在Web浏览器的窗口中。当需要摆放许多元素时，就需要将元素按其逻辑关系进行分组，然后放入Panel中，这可以简化处理过程。

Panel显示一个四边形，其他组件可以放入其中。需要注意的是：Panel必须放在Window之中（或Window的子类中）才能显示出来。引例中3个Panel对象都被包含在一个框架对象中。

2．窗口

窗口（Window）与Panel一样，是个通用容器类，但与Panel不同的是，Window 有一个独立于Web浏览器或appletviewer窗口的窗口。程序员不能直接使用Window类，但可以使用它的3个子类，即Frame（框架）、Dialog（对话框）和FileDialog（文件对话框）。

Frame是一个带有标题和缩放角的窗口，它有自己的外边框和自己的标题，创建Frame时可以指定其窗口标题。例如，引例中创建的Frame标题为“我的窗口”，每个Frame在其右上角都有3个控制图标，分别代表将窗口最大化、最小化和关闭的操作，其中，最大化和最小化操作Frame可自动完成，而关闭窗口的操作不能通过单击关闭图标实现，需要程序编写专门的代码完成。

Frame是Java中最重要、最常用的容器之一，是Java 应用程序的图形用户界面容器。作为一个应用程序最外层的容器，它可以被其他容器创建并弹出成为独立的容器。

Dialog没有菜单条，尽管它能移动，但它不能缩放。Dialog可以提醒用户进行所需要的输入或者反馈应答消息。

3．容器的嵌套

容器的嵌套是Java程序GUI界面设计和实现中经常用到的手段，引例中存在如图8.5所示的包含层次关系：

图8.5 引例程序对象层次关系图

这个程序最外层的容器是一个Frame（框架），其中包含了3个组件：第一个组件是一个Panel对象p1，包含一个标签对象lb1；第二组件是另一个Panel对象p2，包含一个标签对象lb3；第3个组件是另一个Panel对象p3，包含一个标签对象lb1和一个按钮btn。

8.3.2 使用布局管理器来组织接口

当在Applet程序中使用了3个或更多的组件时，布局管理器（layout manager）便是不可缺少的.。没有它们，很难快速组织好屏幕元素的布局。Java.awt包中共定义了5种布局管理器类，它们分别是FlowLayout、BorderLayout、CardLayout、GridLayout和GridBagLayout。每个布局管理器类对应一种布局策略。当一个容器选定一种布局策略时，它应该创建该策略对应的布局管理器类的对象，并将此对象设置为自己的布局管理器。没有布局管理器的容器，其中的对象会互相覆盖、遮挡，影响使用，所以必须为每个容器设置一个合适的布局管理器。引例没有指明布局管理器，则所有的容器都使用缺省的FlowLayout布局策略。

1．FlowLayout

FlowLayout是容器Panel和Applet程序缺省使用的布局管理策略，遵循这种策略的容器将其中的组件按照加入的先后顺序从左向右排列，一行排满之后就到下一行继续从左至右排列，每一行中的组件都居中排列；在组件不多时，使用这种策略非常方便，但是当容器内的GUI元素增加时，就显得高低参差不齐。

创建FlowLayout类的对象可以使用下面的方法：

FlowLayout()：设置一个FlowLayout对象。对齐方式为居中对齐，组件间的横纵间距都为5个像素。

FlowLayout(int align,int hgap,int vgap)：align指定每行组件的对齐方式，可以取3个常量：LEFT、CENTER、RIGHT之一；hgap和vgap分别指定各组件间的横向和纵向间的以像素为单位的间距。

FlowLayout(int align)：align指定每行组件的对齐方式，组件间的横纵间距都为5个像素。

创建完FlowLayout对象后，必须使用setLayout()方法进行设定，才能有效。

【例8.3 】创建FlowLayout布局风格。

import java.awt.*;

public class Flow

{

private Frame fr;

private Button bt1, bt2, bt3;

public static void main (String args[])

{

Flow mflow = new Flow ();

mflow.go();

}

public void go()

{

fr= new Frame("Flow Layout"); //创建窗口

fr.setLayout(new FlowLayout()); //设定布局为FlowLayout

bt1 = new Button("Ok");

bt2 = new Button("Open");

bt3 = new Button("Close");

fr.add(bt1);

fr.add(bt2);

fr.add(bt3);

fr.setSize (200,200);

fr.setVisible(true);

}

}

程序运行结果如图8.6所示。

图8.6 例8.3运行结果

2．BorderLayout

BorderLayout也是一种简单的布局策略，它把容器内的空间简单地划分为东、西、南、北、中5个区域，每加入一个组件都应该指明把这个组件加在哪个区域中。

创建BorderLayout类的对象可以使用下面的方法：

BorderLayout()：设置一个BorderLayout对象。它规定各组件间的横、纵间距都为0。

BorderLayout(int hgap,int vgap)：hgap和vgap分别规定各组件间的横、纵间距。

BorderLayout 只能指定5个区域位置。如果容器中需要加入超过5个组件，就必须使用容器的嵌套或改用其他的布局策略。

创建完BorderLayout对象后，必须使用setLayout()方法进行设定，才能有效。

【例8.4】创建BorderLayout布局风格。

import java.awt.*;

public class Border

{

private Frame f;

private Button bn, bs, bw, be, bc;

public static void main(String args[])

{

Border myborder= new Border();

myborder.go();

}

public void go()

{

f = new Frame("Border Layout"); //创建窗口

f.setLayout(new BorderLayout()); //设定布局

bn = new Button("B1");

bs = new Button("B2");

be = new Button("B3");

bw = new Button("B4");

bc = new Button("B5");

f.add(bn, BorderLayout.NORTH); //将按钮B1按钮放置到屏幕上方

f.add(bs, BorderLayout.SOUTH); //将按钮B2 按钮放置到屏幕下方

f.add(be, BorderLayout.EAST); //将按钮B3 按钮放置到屏幕右方

f.add(bw, BorderLayout.WEST); //将按钮B4 按钮放置到屏幕左方

f.add(bc, BorderLayout.CENTER); //将按钮B5 按钮放置到屏幕中方

f.setSize (200, 200);

f.setVisible(true);

}

}

程序的运行结果如图8..7所示。

图8.7 例8.4程序运行结果

3．CardLayout

使用CardLayout的容器表面上可以容纳多个组件，但是实际上同一时刻容器只能从这些组件中选出一个来显示，就象一叠“扑克牌”每次只能显示最上面的一张一样，这个被显示的组件将占据所有的容器空间。使用CardLayout的一般步骤如下：

(1)创建CardLayout对象作为布局管理器：Mycard=new CardLayout()。

(2)使用容器的setLayout()方法为容器设置布局管理器：setLayout(Mycard)。

(3)使用Add(字符串,组件)方法将该容器的每个组件添加到容器，同时为每个组件分配一个字符串的名字，以便布局管理器根据这个名字调用显示这个组件。

(4)使用show(容器名,字符串)方法可按第3步分配的字符串名字显示相应的组件；也可按组件加入容器的顺序显示组件，如first(容器名)方法显示第一个组件，last(容器名)方法显示最后一个组件等。

4．GridLayout

GridLayout是使用较多的布局管理器，其基本布局策略是把容器的空间划分成若干行乘若干列的网格区域，组件就位于这些划分出来的小格中。GridLayout比较灵活，划分多少网格由程序自由控制，而且组件定位也比较精确。

使用GridLayout布局管理器的一般步骤如下：

(1)创建GridLayout对象作为布局管理器。指定划分网格的行数和列数，并使用容器的setLayout()方法为容器设置这个布局管理器：setLayout(new GridLayout(行数,列数))。

(2)调用容器的方法add()将组件加入容器。组件填入容器的顺序将按照第一行第一个、第一行第二个……第一行最后一个、第二行第一个……最后一行最后一个进行。每个网格中都必须填入组件，如果希望某个网格为空白，可以为它加入一个空的标签，例如，add(new Lable())。

【例8.5 】创建GridLayout布局风格。

import java.awt.*;

public class GridEx

{

private Frame f;

private Button b1, b2, b3, b4, b5, b6;

public static void main(String args[])

{

GridEx grid = new GridEx();

grid.go();

}

public void go()

{

f = new Frame("Grid example"); //创建窗口

f.setLayout (new GridLayout (3, 2)); //设定布局

b1 = new Button("1");

b2 = new Button("2");

b3 = new Button("3");

b4 = new Button("4");

b5 = new Button("5");

b6 = new Button("6");

f.add(b1);

f.add(b2);

f.add(b3);

f.add(b4);

f.add(b5);

f.add(b6);

f.pack();

f.setVisible(true);

}

}

程序运行结果如图8.8所示。

图8.8 例8.5程序运行结果

5．GridBagLayout

GridBagLayout是5种布局策略中使用最复杂、功能最强大的一种，它是在GridLayout 的基础上发展而来。因为GridLayout中的每个网格都是大小相同，并且强制组件与网格大小也相同，从而使得容器中的每个组件也都是相同的大小，显得很不自然，而且组件加入容器也必须按照固定的行列顺序，因此不够灵活。在GridBagLayout中，可以为每个组件加入指定其包含的网格个数，可以保留组件原来的大小，可以以任意顺序随意加入容器的任意位置，从而可以真正自由地安排容器中每个组件的大小和位置。

8.4 事件处理

8.4.1 概述

事件表达了程序、系统及使用程序的用户之间的动作。当用户做某些事情（例如用户在程序窗口中单击鼠标），系统将创建一个相应表达该动作的事件，并传送该事件给程序中的事件处理代码（该代码决定了怎样处理事件），以便让用户得到相应的回应。

【引例】简单事件处理。

import java.applet.*;

import java.awt.*;

import java.awt.event.*;

public class simpleEvent extends Applet implements ActionListener

{

Label lb;

TextField in,out;

Public void init()

{

lb=new Label("请输入您的名字");

in=new TextField(6); //创建输入文本框

out=new TextField(20); //创建输出文本框

add(lb);

add(in);

add(out);

in.addActionListener(this); //将文本框注册给文本事件的监听者}

public void actionPerformed(ActionEvent e) //执行动作

{

out.setText(in.getText()+"欢迎光临! ");

}

}

在此例中，加载java.awt包与java.awt.event包的目的是为了使用图形界面及其事件处理功能。引例的功能：从in文本框输入用户名字字符串，当用户输入完毕并按回车时，引发动作事件，将in文本框内容与“欢迎光临！”字符串拼接，结果显示在out文本框中。

图形用户界面的每个可能产生事件的组件被称为事件源，不同事件源上发生的事件的种类不同。例如，引例中当在输入文本框上输入文字并按回车时将产生一个以这个TextField为源的ActionEvent（触发事件）类代表的actionPerformed事件。所以，输入文

本框in为事件源。

如果希望事件源上发生的事件被程序处理，就要把事件源注册给能够处理该事件源上那种类型事件的监听者。例如引例中输入文本框in对象把自己注册给实现了ActionListerner接口的监听者。监听者之所以具有监听和处理某类事件的功能，是因为它实现了有关的接口，所以监听者需要对它所实现的接口的所有抽象方法写出具体的方法体，对应事件源上发生的事件的处理代码就写在这些方法体里。例如，引例中对输入文本框上发生的事件处理代码写在了in对象所注册的监听者的actionPerformed()方法中，这个方法是对ActionListener接口中同名抽象方法的具体实现。

理解AWT中事件的处理是重要的，没有事件，应用程序就无法响应用户的活动。Java语言中存在各种不同类型的事件类用来描述各种类型的用户交互。事件类的层次结构如图8.9所示。

图8.9 AWTEvent类体系结构图

在Java语言的事件处理机制中，不同的事件由不同的监听者处理，所以java.awt.event 包中还定义了11个监听者接口，每个接口内部包含了若干处理相关事件的抽象方法。一般来说，每个事件类都有一个监听者接口与之相对应，每个接口还要求定义一个或多个方法。当发生特定的事件时，就会调用这些方法。表8-5列出了这些(事件)类型，并给出了每个类型对应的接口名称，以及所要求定义的方法。

表8-5事件类型所对应的方法类型和接口

定义了抽象方法为public void actionPerformed(ActionEvent e)。

凡是要处理ActionEvent事件的类都必须实现ActionListener接口，实现ActionListener接口就必须重载上述的actionPerformed()方法，在重载的方法体中，通常需要调用参数e的有关方法。关于具体事件及其处理方法，下面结合GUI组件详细介绍。

8.4.2 标签、按钮与动作事件

1．标签（Label）

标签是用户不能修改只能查看其内容的文本显示区域，它起到信息说明的作用，每个标签用一个Label类的对象表示。

Label提供的构造方法如下：

Label()

Label(String text)

Label(String text,int alignment)

其中，text为标签上显示的文本，alignment是对齐方式，有3个值：CENTER、LEFT、RIGHT。

引例的lb=new Label("请输入您的名字")就是在创建标签对象的同时说明了标签中的字符串。

如果希望修改标签上显示的文本，则可以使用Label对象的方法setText()，同样，可以通过调用Label对象的getText()方法来获得它的文本内容。例如，下面的程序段将修改标签中的文本内容：

if(prompt.getText()=="Hello")

prompt.setText("ok")；

else if(prompt.getText()=="ok")

prompt.setText("Hello");

由于标签不能接受用户的输入，所以不能引发事件。它不是事件源。

2．按钮(Button)

按钮是图形用户界面中非常重要的一种组件，它一般对应一个事先定义好的功能操作，并对应一段程序。当用户单击按钮时，系统自动执行与该按钮相关联的程序，从而完成预先指定的功能。

Button提供的构造方法如下：

Button()

Button(String text)

第二种方式指定了按钮上的标签文字。

调用按钮的getLabel()方法可以返回按钮上标签字符串；调用按钮的setLabel()方法可以修改按钮的标签字符串。

按钮可以引发动作事件，当用户单击一个按钮时会引发一个动作事件。如果希望响应按钮引发的动作事件的程序，必须把按钮注册给实现了ActionListener接口的动作事件监听者，同时，为这个接口的actionPerformed(ActionEvent e)方法书写方法体。在方法体中，可以调用 e.getSource()方法来获取引发动作事件的按钮对象，也可以调用e.getActionCommand()方法来获取按钮的标签或事先为这个按钮设置的命令名。

JAVA类的继承实验报告

《面向对象程序设计》实验报告 实验六、类的继承 课程代码：1H10500学分：6 实验类型：实践型实验学时：4个学时 实验时间：2017.11.23 实验地点：5407 班级：计算机164 专业：计算机科学与技术专业学号：2016011147 姓名：林文辉 一、实验目的 （1）学习JAVA继承的思想 （2）了解JAVA语言继承的实现 二、实验内容及步骤 内容：在圆柱体类Cylinder里，用一个构造方法调用另一个构造方法 步骤：方案的设计与分析（类结构图。。。。。。） （1）找出对象的共同属性和行为 （2）设计代表共同状态与行为的类 （3）决定子类是否需要让某项行为有特定的不同的运行方式 （4）寻找更多抽象化的机会 （5）完成类的继承层次 三、实验过程及结果 实验1代码： abstract class Graphics { abstract void parameter(); abstract void area(); } class Rectangle extends Graphics{ double h,w; Rectangle(double u,double v){h=u;w=v;} void parameter() { S ystem.out.println("矩形高度为:"+h+",矩形宽度为:"+w); } void area() { S ystem.out.println("矩形面积为："+(h*w)); } }

class Circle extends Graphics{ double r; String c; Circle(double u,String v){r=u;c=v;} void parameter() { System.out.println("圆半径为:"+r+",圆颜色为:"+c); } void area() { System.out.println("圆面积为:"+(Math.PI*r*r)); } } class ExamAbs{ public static void main(String args[]) { Rectangle rec=new Rectangle(2.0, 3.0); Circle cir=new Circle(4.0, "Red"); Graphics[]g= {rec,cir}; for(int i=0;i

Java 接口与类之间继承例题

1,定义一个接口Assaultable(可攻击的)，该接口有一个抽象方法attack()。 2,定义一个接口Mobile（可移动的）,该接口有一个抽象方法move()。 3,定义一个抽象类Weapon,实现Assaultable接口和Mobile接口，但并没有给出具体的 实现方法。 4,定义3个类：Tank,Flighter,WarShip都继承自Weapon,分别用不同的方式实现Weapon 类中的抽象方法。 5,写一个类Army,代表一支军队，这个类有一个属性是Weapon数组w（用来存储该军队所拥有的所有武器）；该类还提供一个构造方法，在构造方法里通过传一个int类型的参数来限定该类所能拥有的最大武器数量,并用这一大小来初始化数组w。该类还提供一个方法addWeapon(Weapon wa),表示把参数wa所代表的武器加入到数组w中。在这个类中还定义两个方法attackAll()和moveAll()，让w数组中的所有武器攻击和移动。 6，写一个主方法去测试以上程序。 interface Assaultable{//可攻击的 void attack(); } interface Mobile{//可移动的 void move(); } abstractclass Weapon implements Assaultable,Mobile { publicvoid attack(){} publicvoid move(){} } class Tank extends Weapon{ publicvoid attack(){ System.out.println("坦克攻击！！！"); } publicvoid move(){ System.out.println("坦克移动！！！"); } } class Flighter extends Weapon{ publicvoid attack(){ System.out.println("战斗机攻击！！！"); } publicvoid move(){ System.out.println("战斗机移动！！！");

java培训资料

SSH篇（后台） 一、SSH概述 1.1 SSH的含义 当前J2EE企业级应用分为三层：表现层-业务层-数据源层，而SSH代表了每一层的具体实现，它是三种流行的开源框架的缩写，S-Struts,S-Spring,H-Hibernate。这三者的组合是当前J2EE开发的标准模式，也代表了J2EE正在朝着简化复杂性，轻量化方向发展，最新J2EE 6已证明了这种趋势。 1.2 J2EE开发模式的演变 J2EE应用一直采用三层加构，即表现层-业务层-数据源层。 旧石器时代：J2EE应用采用表现层-远程EJB-实体EJB（或JDBC），这是最为正宗也是最复杂的J2EE开发，适用于银行等小部分项目；随后由于微软.NET的兴起以及其对J2EE的挑战，正宗的J2EE出现了一个变种：表现层-本地EJB-Ibatis，在这种模型中业务层选择了本地EJB，同时数据源层也改为Ibatis，这种模式极大的提高性能，华为大部分项目采用这种构架。在这两种架构中，由于采用了EJB组件模型，从而依赖于EJB容器，而EJB容器以一种全无或全有的方式提供服务，同时业务实现也受制于容器。这种开发模式导致了以下复杂性：依赖于应用服务器，不可移植，开发困难，无法在容器外测试，部署复杂，效率低下。 新石器时代：在新石器时代依然采用了三层加构，只是抛弃了EJB，而采用了Spring等轻量级容器，同时持久化由全自动的Hibernate承担。在这种架构中，由于放弃了EJB，放弃了全功能的应用服务器，在节省了软件许可费用的同时也大大提高了软件开发效率。由于web服务器的可移植也好于应用服务器，从而使得J2EE应用可顺利移植。

java 类的继承 实验报告(含代码)

实验三类的继承 实验目的：掌握类的继承、抽象类的定义和使用、对象的向上转型。实验内容：已知若干图形，求以该图形为底的锥体的体积。 实验要求：用面向抽象的思想实现 实验步骤： 1、程序总体框架 2、在shape包中创建抽象类Shape，代码如下： 3、在centrun包中创建一个类Centrun,代码如下：

Centrun这个类为核心类，在之后的代码编写中可以不做更改，getVolume函数用来求椎体的体积，即利用抽象类getArea进行适应性计算。 4、创建一个包myshape，在其中先创建一个Circle类，代码如下：

Circle是对抽象类shape的继承（记得导入shape包），在Circle类中，利用对getArea 函数代码的重写操作，具体实现了求圆的面积这一操作。【此处的具体实现应该放入该图形的具体面积求法。】 5、创建一个包Test，对以上三个包中的代码进行具体实现，代码如下： 导入myshape包，在main函数中通过向上转型，实例化shape包中的抽象类Shape，然后调用函数输出圆锥的体积。 6、在求出实验结果1，即调试好shape、myshape、centrun这三个包后，不再更改shape、centrun包，而是在myshape包下新建所需的类，如本次实验所需的三角形、矩形； 7、在myshape包下创建一个类Rectangular，代码如下：

8、在myshape包下创建一个类Triangle，需注意的是，求三角形的面积需要判断三角形的三边能否构成三角形（不能构成时返回0），代码如下：

实验结果： 1、Test测试包最终代码：

华为java培训讲义

华为java培训讲义第一天 配置java环境变量： JAVA_HOME：配置JDK的目录 CLASSPATH：指定到哪里去找运行时需要用到的类代码（字节码） PATH：指定可执行程序的位置 LINUX系统（在" .bash_profile "下的环境变量设置） JAVA_HOME=/opt/jdk1.5.0_06 CLASSPATH=.:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar PATH=$PATH:$JAVA_HOME/bin:. export JAVA_HOME CLASSPATH PATH (将指定的环境变量声明为全局的) windows系统： 右击我的电脑-->属性-->高级-->环境变量 Java的运行过程： 编译：生成可执行文件，如C++中利用g++生成a.out，效率高，但不跨平台 解释：解释器把源文件逐行解释，跨平台但效率不高 在java中：先编译后解释，把.java文件编译成.class字节码文件 Java源代码文件(.java文件)---> Java编译器(javac)---> Java字节码文件(.class文件，平台无关的)---> Java解释器(java)，执行Java字节码 Java的垃圾回收： 由一个后台线程gc进行垃圾回收 虚拟机判定内存不够的时候会中断代码的运行，这时候gc才进行垃圾回收 缺点：不能够精确的去回收内存 https://www.doczj.com/doc/0c13908924.html,ng.System.gc(); 建议回收内存，但系统不一定回应，他会先去看内存是否够用，够用则不予理睬，不够用才会去进行垃圾回收 内存中什么算是垃圾： 不再被引用的对象(局部变量，没有指针指向的) java的安全性： 沙箱机制：只能做沙箱允许的操作 通过下面环节，实现安全 加载有用的类文件，不需要的不加载 校验字节码，查看允许的操作 查看代码和虚拟机的特性是否相符 查看代码是否有破坏性

java中继承的相关知识总结

JAVA中继承的总结 一、继承概念： 把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系， 这多个类就具备了这些内容。这个关系叫继承。 二、何时实现继承 A:继承体现的是：is a的关系。 B:采用假设法 三、怎么实现继承 A:用关键字extends表示 B:格式： class 子类名 extends 父类名 {} C:子类 public class 子类 extends 父类 { //增加自己属性 //重写父类的属性 //增加自己的方法 //重写父类的方法 } 四、继承的好处： A:提高了代码的复用性 B:提高了代码的维护性

C:让类与类产生了一个关系，是多态的前提 继承的弊端： A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。 原则：低耦合，高内聚。 耦合：类与类的关系 内聚：自己完成某件事情的能力 B:打破了封装性 五、Java中继承的特点 A:Java中类只支持单继承，只能一个直接父类，Object 根类 B:Java中可以多层(重)继承(继承体系) 六、继承的注意事项： A:子类能继承父类的私有成员,但不是都能访问 B:子类不能继承父类的构造方法，但是可以通过super去访问 C:不要为了部分功能而去继承 七、继承中static用法 A:static:子类可以继承父类的静态方法,但不能重写 B:static 的属性和方法都是不能覆盖的，因为static修饰的部分都是与对象无关的，只与类有关 八、Java继承中的成员关系 A:成员变量 a:子类的成员变量名称和父类中的成员变量名称不一样，这个太简单 b:子类的成员变量名称和父类中的成员变量名称一样，这个怎么访问呢?

Java基础_讲义

Java基础语法 今日内容介绍 方法 第1章方法 1.1方法概述 在我们的日常生活中，方法可以理解为要做某件事情，而采取的解决办法。 如：小明同学在路边准备坐车来学校学习。这就面临着一件事情（坐车到学校这件事情）需要解决，解决办法呢可采用坐公交车或坐出租车的方式来学校，那么，这种解决某件事情的办法，我们就称为方法。 在java中，方法就是用来完成解决某件事情或实现某个功能的办法。 方法实现的过程中，会包含很多条语句用于完成某些有意义的功能——通常是处理文本，控制输入或计算数值。 我们可以通过在程序代码中引用方法名称和所需的参数，实现在该程序中执行（或称调用）该方法。方法，一般都有一个返回值，用来作为事情的处理结果。 1.2方法的语法格式 在Java中，声明一个方法的具体语法格式如下： 修饰符返回值类型方法名(参数类型参数名1,参数类型参数名2,．．．．．．){ 执行语句 ……… return 返回值; }

对于上面的语法格式中具体说明如下： 修饰符：方法的修饰符比较多，有对访问权限进行限定的，有静态修饰符static，还有最 终修饰符final等，这些修饰符在后面的学习过程中会逐步介绍 返回值类型：用于限定方法返回值的数据类型 参数类型：用于限定调用方法时传入参数的数据类型 参数名：是一个变量，用于接收调用方法时传入的数据 return关键字：用于结束方法以及返回方法指定类型的值 返回值：被return语句返回的值，该值会返回给调用者 需要特别注意的是，方法中的“参数类型参数名1，参数类型参数名2”被称作参数列表，它用于描述方法在被调用时需要接收的参数，如果方法不需要接收任何参数，则参数列表为空，即()内不写任何内容。方法的返回值必须为方法声明的返回值类型，如果方法中没有返回值，返回值类型要声明为void，此时，方法中return语句可以省略。 接下来通过一个案例来演示方法的定义与使用，如下图所示。 public class MethodDemo01 { public static void main(String[] args) { int area = getArea(3, 5);

JAVA继承类求几何图形面积周长代码

class shap2D { static double getArea; //面积 static double getPerimeter; //周长 } class circle extends shap2D { double r; double getRadius(){return r=2;} double getArea() {return Math.PI*r*r;} double getPerimeter() {return 2*Math.PI*r;} public String toString() { String s; return s="周长："+getPerimeter()+"面积:"+getArea(); } } class Triangle extends circle { double a,b,c; Triangle (double x,double y,double z) {a=x; b=y;c=z;} void setA(double x){a=x;} double getA(){return a;} public double getPerimeter() {return a+b+c;} public double getArea() { double s=(a+b+c)/2; return Math.sqrt(s*(s-a)*(s-b)*(s-c)); } public boolean isTriangle() { boolean flag=false; if(a>0&&b>0&&c>0&&a+b>c&&a+c>b&&c+b>a) flag=true; return flag; } } class rectangle extends circle { double a,b;

java练习题-继承

一.extends和super的使用和方法的重写 1.定义一个人的类（属性有名字，年龄。写一个能输出各个属性值 的方法showInfo（）），定义一个学生类（属性有性别），学生继承人类 要求：（1）父类的属性赋值用构造方法来实现（分别用有参数构造方法和无参数构造方法实现） （2）子类的属性也用构造方法来赋值。 （3）在子类中重写父类的showInfo（）方法 （4）声明学生类的对象，调用学生的显示信息的方法。 2 定义Animal父类，含有属性name，sex，age，方法sleep，run，编写一个子类Person，继承Animal类，然后调用父类的属性和方法二． 1、试编写三个具有继承关系的类，A、B、C（B继承A，C继承B）。 要求A中包含方法a1()、a2()，B类中的方法b1()访问了a1() 和a2()，C类中的方法c1()访问了a1()、a2()、b1()。 提示：（a1(),a2(),b1(),c1()这些方法体除了实现题目要求之外，其余内容可以任意编写。） 2、请编码实现动物世界的继承关系： 动物（Animal）具有行为：吃（eat）、睡觉（sleep） 动物包括：兔子（Rabbit），老虎（Tiger） 这些动物吃的行为各不相同（兔子吃草，老虎吃肉）；但睡

觉的行为是一致的。 请通过继承实现以上需求，并编写测试类AnimalTest进行测试。3、父类Person 包含like（）方法子类Son 重写父类方法并打印输出 4、(选做)父类Employee 属性：name、sex ，带一个构造方法Employee(String n, char s) 子类Worker继承自Employee 属性：char category;法（）可以调用父类 的所有非私有方法 B) super（）可以调用父类的所有非私有构造函数 C) super.属性可以调用父类的所有非私有属性 D) this和super关键字可以出现在同一个构造函数中 8．以下关于final关键字说法错误的是（A,C）（两项） A) final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性 B) final修饰的类肯定不能被继承 C) final修饰的方法不能被重载 D) final修饰的变量不允许被再次赋值 9．访问修饰符作用范围由大到小是（D） A) private-default-protected-public B) public-default-protected-private C) private-protected-default-public D) public-protected-default-private 10．以下（D）不是Object类的方法 A) clone（） B) finalize（） C) toString（） D) hasNext（） 11．多态的表现形式有（A） A) 重写 B) 抽象 C) 继承 D) 封装 12．以下对重载描述错误的是（B）

Java中类的继承

Java中类的继承 1、方法重载 重载方法必须满足以下条件: ＃方法名相问. ＃方法的参数类型、个数、顺序至少有一项不相同。 ＃方法的返回类型可以不相同。 ＃方法的修饰符可以不相同. 方法覆盖 (1)子类方法的名称、参数签名和返回类型必须与父类方法的名称、参数签名和返回类型一致. (2)子类方法不能缩小父类方法的访问权限. (3)子类方法不能抛出比父类方法史多的异常， (4)方法覆盖只存在于子类和父类(包括直接父类和间接父类)之间.在同一个 类中方法只能被重载，不能被扭盖。 (5)父类的静态方法不能被子类覆盖为非静态方法。 (6)子类可以定义与父类的静态方法同名的静态方法，以便在子类中隐藏父类的静态方法.在编译时，子类定义的静态方法也必须满足与方法覆盖类似的约束。 (7)父类的非静态方法不能被了类覆盖为静态方法。 (8)父类的私有方法不能被子类覆盖。 (9)父类的抽象方法可以被子类通过两种途径覆盖:一是子类实现父类的抽象方法:二是子类重新声明父类的抽象方法。 (10)父类的非抽象方法可以被覆盖为抽象方法. 方法覆盖与方法重载的异同 方法覆盖和方法重载具有以下相同点: ＃都要求方法同名. ＃都可以用于抽象方法和非抽象方法之间. 方法筱盖和方法重载具有以下不同点: ＃.方法覆盖要求参数签名必须一致.而方法重载要求参数签名必须不一致.

＃.方法覆盖要求返回类型必须一致，而方法重载对此不做限制. ＃.方法覆盖只能用于子类覆盖父类的方法，方法重载用于同一个类的所有方d (包括从父类中继承而来的方法)。 ＃.方法覆盖对方法的访问权限和抛出的异常有特殊的要求，而方法重载在这力面没有任何限制。 ＃.父类的一个方法只能被子类覆盖一次，而一个方法在所在的类中可以被重载多次。 super关键字 super和this关键字都可以用来履盖Java语言的默认作用域.使被屏蔽的方法或变 盆变为可见。在以下场合会出现方法或变量被屏蔽的现象. .场合一:在一个方法内.当局部变量和类的成员变量同名，或者局部变量和父类的成员变量同名时，按照变量的作用域规则，只有局部变量在方法内可 见。 .场合二:当子类的某个方法覆盖了父类的一个方法。在子类的范围内，父类 的方法不可见. .场合三:当子类中定义了和父类同名的成员变量时，在子类的范围内，父类 的成员变量不可见。 在程序中，在以下情况下会使用super关键字: ＃在类的构造方法中，通过super语句调用这个类的父类的构造方法。 ＃在子类中访问父类的被屏蔽的方法和属性。 多态性 它是指当系统A访问系统B的服务时，系统B可以通过多种实现方式来提供服务， 而这一切对系统A是透明的. 多态的各种特性 (1)对于一个引用类型的变量，Java编译器按照它声明的类型来处理. (2)对于一个引用类型的变盆.运行时Java虚拟机按照它实际引用的对象来处理.例如以下代码虽然编译可以通过，但运行时会抛出ClassCastException运行时异常. Sub sub=new Sub();

JAVA复习习题(继承)

类的继承习题 一、选择题 1. Java语言的类间的继承关系是( B )。 A) 多重的B) 单重的C) 线程的D) 不能继承 2. 以下关于Java语言继承的说法正确的是( C )。 A)Java中的类可以有多个直接父类B)抽象类不能有子类 C)Java中的接口支持多继承D)最终类可以作为其它类的父类 3. 现有两个类A、B，以下描述中表示B继承自A的是(D)。 A) class A extends B B) class B implements A C) class A implements B D) class B extends A 4. A） 5. A） 6. Java 7. A)Java C)Java 8. A) class C) class 9. 现有类 A) class C) class 10. A） 11. A） 12. A） 13. java A） 14. 饰符是（ A） 15. A） 16. A）public B) protected C) private D) final 17. 下列选项中，表示终极方法的修饰符是：（B） A）interface B) final C) abstract D) implements 18. 下列选项中，定义接口MyInterface的语句正确的是：（A） A）interface MyInterface{ } B) implements MyInterface { } C) class MyInterface{ } D) implements interface My{ } 19. 如果子类中的方法mymethod()覆盖了父类中的方法mymethod()，假设父类方法头部定义如下：void mymethod(int a)，则子类方法的定义不合法的是：（C） A）public void mymethod(int a) B) protected void mymethod(int a) C) private void mymethod(int a) D) void mymethod(int a) 二、填空题 1. 如果子类中的某个变量的变量名与它的父类中的某个变量完全一样，则称子类中的这个变量________了父类

java课堂讲义

Lesson1 1、java与c的关系及不同 .c-----.obj------.exe .exe已经是机器码(含有cup的指令) 编译型语言 .java--编译--.class jdk(JVM javaCPU)解释执行解释型语言 Java字节码是使用javac命令编译源代码后得到的class代码。字节码可以理解成是运行在Java虚拟机上的汇编语言。字节码是Java实现跨平台特性的基础。 绿色版：解压后就可以使用jdk 1.5 1.6 命令javac xx.java java xx jdk：Java开发工具 jre：Java运行环境 jvm：Java虚拟机（JVM javaCPU） D:\software\jdk\bin path D:\software\jdk\bin jdk的安装环境变量配置 JA V A_HOME jdk的路径 path %JA V A_HOME%\bin; java -version--------查看JDK的版本 .net php LAMP linux apache mysql php java oracle ruby 强类型：语法严谨 java 的可移植性portability (跨平台OS)? Windows\Linux\Mac.... java版本javaSE(标准版) GUI：图形用户界面C/S javaEE(企业版) B/S javaME(微型版) 游戏 SQL Server2008 MySQL Android cocos2D ststruts(MVC) spring hibernate SSH2 设计模式

eg:人类 抽象分离封装 属性: 身高体重名字===========>成员变量=========>类 行为:吃睡玩想===========>成员方法=========>类 3、对象:是类的一个实例,它属于一个类 创建一个对象做了几件事情? String s1 = "hello"; String s2 = new String("hello");创建了几个对象？ 4、java 的命名规则见名知意 类名首字母大写class Person Clock 成员变量/方法小写int height; getName();setName(); 驼峰命名法 常量大写int WIDTH=300; 5、一个.java文件就是一个编译单元.一个编译单元里面,只能有一个public修饰的类,文件名必须和public修饰的类的类名相同. 但，类的功能要单一化. 6、java 的基本数据类型 类型字节数默认值封装类 byte 1 0 https://www.doczj.com/doc/0c13908924.html,ng.Byte char 2 '\u0000' Character int 4 0 Integer float 4 0 Float double 8 0 Double boolean 1 false Boolean 1 byte = 8 bit; float f=2.3f; 2.3f===>float 2.3===>double double d = 2.3f; float f = 2.3; float f = (float)2.3; 低精度向高精度转化，会自动类型转化（向上造型） 高精度向低精度转化，要强制类型转化（向下造型） 注：java中的boolean只有true和false，不像C中0表示假，非0表示为真 while(true){} while(1==1){}

java试题操作及答案培训资料

java题操作及答案试/**【程序1】 *题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一 *对兔子，假如兔子都不死，问每个月的兔子总数为多少？ *1.程序分析：兔子的规律为数列1,1,2,3,5,8,13,21.... */ public class Test1{ public static int rabit(int n) { if(n==1||n==2){ return 1; }else if(n>=3){ return (rabit(n-1))+(rabit(n-2)); } return 0; } public static void main(String[] args) { for(int i=1;i<=12;i++){ System.out.println("第"+i+"个月兔子对数为:"+rabit(i));} } } /*【程序2】

*题目：判断101-200之间有多少个素数，并输出所有素数。*1.程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除,则表明此数不是素数 */ public class Test2{ public static void main(String[] args){ System.out.println("101到200间的素数有："); for(int i=101;i<=200;i++){ boolean flag=true; for(int j=2;j<=Math.sqrt(i);j++){ if(i%j==0){ flag=false; break; } } if(flag==true){ System.out.print(i+" "); } continue; } } }

JAVA课程设计——员工工资管理(类的继承)

JAVA课程设计——员工工资管理 import java.util.Scanner; class Employee{ private String name; privateint birthmonth; public String getName() { return name; } publicvoid setName(String name) { https://www.doczj.com/doc/0c13908924.html, = name; } publicint getBirthmonth() { return birthmonth; } publicvoid setBirthmonth(int birthmonth) { this.birthmonth = birthmonth; } publicdouble getSalary(int thismonth){ if(birthmonth==thismonth){ return 100; } else return 0; } publicvoid print(){ System.out.print("员工信息：\n姓名:"+name+"，出生月份："+birthmonth+"，"); } public Employee(String name,int birthmonth){ setName(name); setBirthmonth(birthmonth); } } //固定工资 class SalariedEmployee extends Employee{ privateint salary; public SalariedEmployee(String name, int birthmonth,int salary) { super(name, birthmonth); this.salary=salary; } publicdouble getSalary(int thismonth) { return salary+super.getSalary(thismonth); } publicint basesalary(){return salary;} } //小时工 class HourlyEmployee extends Employee{ privateint hoursalary; privateint monthhour; privateint salary; public HourlyEmployee(String name, int birthmonth,int hoursalary,int monthhour) { super(name, birthmonth);

java 中关于 继承 的一个小例子

上一次跟别人解答，没想到没提交上去，又不想删了，所以做成文档，才入这行朋友可以看下 Question 1. 编码实现动物世界的继承关系： a) 动物（Animal）具有行为：吃（eat）、睡觉（sleep） b) 受保护得物件（接口）具有得行为：beProtected（）; c) 有价值得物件（接口）具有得行为：getMoney（） d) 老虎是动物，同时是有价值且受保护得动物类型。 e) 熊猫是动物，同时是有价值且受保护得动物类型。 f) 这些动物吃的行为各不相同（熊猫吃竹子，老虎吃肉）；但睡觉的行为是一致的；受保护得级别不一致，价值也不一致。 g) 请通过继承，接口实现以上需求，并编写测试类AnimalTest进行测试。 Animail.java父类-动物类 package com; /** * @author Administrator * */ public class Animal { private String name; private String food; //吃的一个行为 public void eat() throws Exception{ System.out.println(https://www.doczj.com/doc/0c13908924.html,+"吃"+this.food+"!"); } //睡觉的一个行为 public void sleep(){ System.out.println(https://www.doczj.com/doc/0c13908924.html,+"在睡觉!"); } public String getName() {

return name; } public void setName(String name) { https://www.doczj.com/doc/0c13908924.html, = name; } public String getFood() { return food; } public void setFood(String food) { this.food = food; } } AnimalInterface.Java 接口 package com; public interface AnimalInterface { //默认为public,因为接口要被实现，并被广范使用， //所以最好是public因为如果不是公开的就没有必要做接口了void beProtected(); void getMoney(); } AnimalTest.java 测试类 package com; public class AnimalTest { /**

java中方法的继承

ava中方法的继承，覆盖 (2011-01-17 02:13:42)转载▼ 标签：杂 谈 首先要明确一点，子类在继承父类时，构造函数是不能被继承的。当创建子类的实例时，子类的构造函数要调用父类的构造函数，也就是说父类要先于子类构造。子类的构造函数可以通过super关键字显式调用父类中的构造函数。如果子类中的构造函数没有显式调用父类中的构造函数，编译器就会自动在子类的构造函数中调用父类中参数为空的构造函数。当父类中没有定义任何构造函数时，编译器就会为它指定一个参数为空的默认的构造函数；如果父类中定义了构造函数，那么编译器就不会为它指定一个参数为空的默认构造函数了。因此，如果某个类有可能成为其他类的父类，为了避免发生不必要的编译错误，最好为它编写一个参数为空的构造函数。父类Sup中没有定义构造函数，编译程序将为它指定一个参数为空的默认构造函数。子类Sub 中也没有定义构造函数，编译程序也会为它指定一个参数为空的默认的构造函数，并且会在这个默认的构造函数中调用父类的参数为空的构造函数。 public class Sub extends Sup{ //子类中没有定义构造函数 public static void main(String args[]){ Sub sub=new Sub(); } } class Sup{ //父类中没有定义构造函数 } 父类Sup中没有定义构造函数，编译程序将为它指定一个参数为空的默认构造函数。子类定义了一个带整型参数的构造函数，在这个构造函数中子类没有显式调用父类的构造函数，所以编译器为在它里面调用父类中参数为空的构造函数。 public class Sub extends Sup{ //子类中定义类一个带整型变量参数的构造函数 public Sub(int i){ // } public static void main(String args[]){ Sub sub=new Sub(1); } } class Sup{ //父类中没有定义构造函数 } 父类中定义了一个带整型参数的构造函数，因此编译器不再为它指定参数为空的默认的构造函数。子类中也定义了一个带整型参数的构造函数。编译时，编译器将试图在子类的构造函数中调用父类的参数为空的构造函数，但是父类中没有定义参数为空的构造函数，所以编译程序将会报

java程序设计类的继承以及super的 使用

实验五:类的继承以及super的使用 一、实验目的 熟练地掌握Java语言的掌握类的继承以及super的使用的编程。通过实验掌握编写程序的思想方法，体会编程的技巧，加深Java语言的应用能力。 二、实验环境 硬件环境：微型计算机。 软件环境：Windows 2000或以上版本，JKD, Jcreator 三、实验内容与要求 用Java语言编程实现以下问题： 1、利用课本类的继承编写程序，定义一个车类Vehicle，代表一类交通工具，在这个类中包含成员变量品牌brand,颜色color，价格price(单位：万元)和一个void SetVehicle()方法，通过这个方法使其成员变量赋值，再定义一个小汽车类Car 去继承车类Vehicle,在这个类中再包含一个成员变量速度speed和一个void SetCar()方法，通过这个方法使其所有的成员变量赋值再定义一个public类，包含main()方法，在这个方法中，用Car这个类创建一个对象，并分配内存空间，用对象去调用SetCar()方法，然后对象去调用各个成员变量并输出其值。 程序： class Vehicle { String brand,color; double price; void SetVehicle(String b,String c,double p) { brand=b; color=c; price=p; } } class car extends Vehicle { double speed; void SetCar(String b,String c,double p,double s) { SetVehicle(b,c,p); speed=s; } } public class che_test { public static void main(String args[]) { car m=new car(); m.SetCar("联想","银白",2.0,100.0); System.out.println("品牌:"+m.brand+" 颜色:"+m.color+" 价格:"+m.price+"

JAVA中类的继承的理解

JAVA中类的继承的理解 Java类的继承可以是多层的，但不能是多头的。也就是说类只能继承一个类而不能继承多个类。好比一个人只能有一个爹，不能有多个爹，当然爹上面还能有爹。 类实现继承的格式：class子类名extends 父类名 类的继承有三方面的内容，一是父类变量与方法的继承，二是父类变量与方法的覆写或称之为重载，三是super与this的使用区别。 类的继承使用范例： class Person { String name; int age; } class Student extends Person { String school; } Public class TestPersonStudentDemo { public static void main(String[] args) { Student s = new Student();//实例化了Student类s https://www.doczj.com/doc/0c13908924.html, = “张三”; //访问Person类中的name属性 s.age = 25; //访问Person类中的age属性 s.school = “北京” ; //访问Student类中的school属性 System.out.println(“姓名：”+https://www.doczj.com/doc/0c13908924.html,+”，年龄：”+s.age+”，学校：”+s.school); } } 子类在继承父类中的方法与属性时，首先会执行父类中的构造方法，再执行子类中的构造方法。一般子类中隐含了super()语句（super主要的功能是完成子类调用父类中的内容）。 类的继承使用范例1： class Person { String name; int age; //父类中的构造方法 public Person(String name,int age) { https://www.doczj.com/doc/0c13908924.html, = name; this.age = age; }

Java继承的概念与实现

继承是类与类之间的关系，是一个很简单很直观的概念，与现实世界中的继承（例如儿子继承父亲财产）类似。 继承可以理解为一个类从另一个类获取方法和属性的过程。如果类B继承于类A，那么B就拥有A的方法和属性。 继承使用 extends 关键字。（参考网站：https://www.doczj.com/doc/0c13908924.html,/RA5iKhq） 例如我们已经定义了一个类 People： 1class People{ 2 String name; 3int age; 4int height; 5 6void say(){ 7 System.out.println("我的名字是 " + name + "，年龄是 " + age + "，身高是 " + height); 8 } 9 } 如果现在需要定义一个类 Teacher，它也有 name、age、height 属性和 say() 方法，另外还需要增加 school、seniority、subject 属性和 lecturing() 方法，怎么办呢？我们要重新定义一个类吗？ 完全没必要，可以先继承 People 类的成员，再增加自己的成员即可，例如： 1class Teacher extends People{ 2 String school; // 所在学校 3 String subject; // 学科 4int seniority; // 教龄 5 6// 覆盖 People 类中的 say() 方法 7void say(){ 8 System.out.println("我叫" + name + "，在" + school + "教" + subject + "，有" + seniority + "年教龄"); 9 } 10 11void lecturing(){ 12 System.out.println("我已经" + age + "岁了，依然站在讲台上讲课"); 13 } 14 }