华为项目java代码示例 华为java 百度文库

求几个JAVA小项目源代码,供自己学习参考

package com.test01;

创新互联是一家网站设计公司,集创意、互联网应用、软件技术为一体的创意网站建设服务商,主营产品:成都响应式网站建设公司品牌网站建设成都全网营销。我们专注企业品牌在网站中的整体树立,网络互动的体验,以及在手机等移动端的优质呈现。成都网站制作、成都网站建设、移动互联产品、网络运营、VI设计、云产品.运维为核心业务。为用户提供一站式解决方案,我们深知市场的竞争激烈,认真对待每位客户,为客户提供赏析悦目的作品,网站的价值服务。

import java.util.Scanner;

public class oop5 { public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

// int x = 9;

// int y = 1;

int x = sc.nextInt();

int y = sc.nextInt();

int z;

z = add(x, y);

System.out.println("x的值为:" + x);

System.out.println("y的值为:" + y);

System.out.println("二者之和为:" + z);

}

/** 四种小算法 */

// 加法运算

public static int add(int a, int b) {

int c;

c = a + b;

return c;

}

// 减法运算

public static int jian(int d, int v) {

int m;

m = d - v;

return m;

}

// 乘积运算

public static int addAdd(int q, int w) {

int e;

e = q * w;

return e;

}

// 除法运算

public static int chu(int p, int k) {

int f;

f = p / k;

return f;

}

}

JAVA作业求助。

在Java中,依赖关系通常表示为一个类依赖于另一个类,因为它需要调用另一个类的方法或构造函数来完成它的工作。例如,假设我们有一个名为Car的类,它拥有一个名为startEngine的方法,用于启动汽车的发动机。我们还有一个名为Driver的类,它有一个名为drive的方法,用于驾驶汽车。那么Driver类就依赖于Car类,因为Driver类需要调用Car类的startEngine方法来启动汽车。

下面是一个示例代码,实现了一个依赖关系的场景:

=================

public class Car {

public void startEngine() {

System.out.println("Engine started.");

}

}

public class Driver {

private Car car;

public Driver(Car car) {

this.car = car;

}

public void drive() {

car.startEngine();

System.out.println("Car is being driven.");

}

}

public class Main {

public static void main(String[] args) {

Car car = new Car();

Driver driver = new Driver(car);

driver.drive();

}

}

=================

在这段代码中,Driver类的构造函数接收一个Car类的实例作为参数,并将它保存在私有字段car中。在Driver类的drive方法中,我们首先调用了car实例的startEngine方法,然后打印一条消息,表示汽车正在被驾驶。

关联关系通常表示为两个类之间的关系,它们之间的关系可能是一对一,一对多或多对多。例如,假设我们有一个名为Student的类,它有一个名为enroll的方法,用于选课。我们还有一个名为Course的类,它有一个名为addStudent的方法,用于添加学生。那么Student类和Course类之间就存在一对多的关联关系,因为一个学生可以选择多个课程,而一个课程也可以被多个学生选择。

下面是一个示例代码,实现了一个关联关系的场景:

=================

public class Student {

private ListCourse courses = new ArrayList();

public void enroll(Course course) {

courses.add(course);

course.addStudent(this);

}

}

public class Course {

private ListStudent students = new ArrayList();

public void addStudent(Student student) {

students.add(student);

}

}

public class Main {

public static void main(String[] args) {

Student student = new Student();

Course course1 = new Course();

Course course2 = new Course();

student.enroll(course1);

student.enroll(course2);

}

}

=================

在这段代码中,Student类拥有一个私有字段courses,表示学生选择的课程。Student类的enroll方法用于选课,它接收一个Course类的实例作为参数,并将它添加到courses列表中。同时,enroll方法还会调用课程实例的addStudent方法,将学生添加到课程的学生列表中。

在Main类的main方法中,我们创建了一个学生实例和两个课程实例。我们调用学生实例的enroll方法,将两个课程实例添加到学生的选课列表中,同时将学生添加到两个课程的学生列表中。这就实现了一对多的关联关系。

总之,依赖关系和关联关系都是表示两个类之间的关系,但是它们之间的关系不同。依赖关系表示一个类依赖于另一个类,因为它需要调用另一个类的方法或构造函数来完成它的工作;关联关系表示两个类之间的关系,它们之间可能是一对一,一对多或多对多。

java中的单例模式的代码怎么写

我从我的博客里把我的文章粘贴过来吧,对于单例模式模式应该有比较清楚的解释:

单例模式在我们日常的项目中十分常见,当我们在项目中需要一个这样的一个对象,这个对象在内存中只能有一个实例,这时我们就需要用到单例。

一般说来,单例模式通常有以下几种:

1.饥汉式单例

public class Singleton {

private Singleton(){};

private static Singleton instance = new Singleton();

public static Singleton getInstance(){

return instance;

}

}

这是最简单的单例,这种单例最常见,也很可靠!它有个唯一的缺点就是无法完成延迟加载——即当系统还没有用到此单例时,单例就会被加载到内存中。

在这里我们可以做个这样的测试:

将上述代码修改为:

public class Singleton {

private Singleton(){

System.out.println("createSingleton");

};

private static Singleton instance = new Singleton();

public static Singleton getInstance(){

return instance;

}

public static void testSingleton(){

System.out.println("CreateString");

}

}

而我们在另外一个测试类中对它进行测试(本例所有测试都通过Junit进行测试)

public class TestSingleton {

@Test

public void test(){

Singleton.testSingleton();

}

}

输出结果:

createSingleton

CreateString

我们可以注意到,在这个单例中,即使我们没有使用单例类,它还是被创建出来了,这当然是我们所不愿意看到的,所以也就有了以下一种单例。

2.懒汉式单例

public class Singleton1 {

private Singleton1(){

System.out.println("createSingleton");

}

private static Singleton1 instance = null;

public static synchronized Singleton1 getInstance(){

return instance==null?new Singleton1():instance;

}

public static void testSingleton(){

System.out.println("CreateString");

}

}

上面的单例获取实例时,是需要加上同步的,如果不加上同步,在多线程的环境中,当线程1完成新建单例操作,而在完成赋值操作之前,线程2就可能判

断instance为空,此时,线程2也将启动新建单例的操作,那么多个就出现了多个实例被新建,也就违反了我们使用单例模式的初衷了。

我们在这里也通过一个测试类,对它进行测试,最后面输出是

CreateString

可以看出,在未使用到单例类时,单例类并不会加载到内存中,只有我们需要使用到他的时候,才会进行实例化。

这种单例解决了单例的延迟加载,但是由于引入了同步的关键字,因此在多线程的环境下,所需的消耗的时间要远远大于第一种单例。我们可以通过一段测试代码来说明这个问题。

public class TestSingleton {

@Test

public void test(){

long beginTime1 = System.currentTimeMillis();

for(int i=0;i100000;i++){

Singleton.getInstance();

}

System.out.println("单例1花费时间:"+(System.currentTimeMillis()-beginTime1));

long beginTime2 = System.currentTimeMillis();

for(int i=0;i100000;i++){

Singleton1.getInstance();

}

System.out.println("单例2花费时间:"+(System.currentTimeMillis()-beginTime2));

}

}

最后输出的是:

单例1花费时间:0

单例2花费时间:10

可以看到,使用第一种单例耗时0ms,第二种单例耗时10ms,性能上存在明显的差异。为了使用延迟加载的功能,而导致单例的性能上存在明显差异,

是不是会得不偿失呢?是否可以找到一种更好的解决的办法呢?既可以解决延迟加载,又不至于性能损耗过多,所以,也就有了第三种单例:

3.内部类托管单例

public class Singleton2 {

private Singleton2(){}

private static class SingletonHolder{

private static Singleton2 instance=new Singleton2();

}

private static Singleton2 getInstance(){

return SingletonHolder.instance;

}

}

在这个单例中,我们通过静态内部类来托管单例,当这个单例被加载时,不会初始化单例类,只有当getInstance方法被调用的时候,才会去加载

SingletonHolder,从而才会去初始化instance。并且,单例的加载是在内部类的加载的时候完成的,所以天生对线程友好,而且也不需要

synchnoized关键字,可以说是兼具了以上的两个优点。

4.总结

一般来说,上述的单例已经基本可以保证在一个系统中只会存在一个实例了,但是,仍然可能会有其他的情况,导致系统生成多个单例,请看以下情况:

public class Singleton3 implements Serializable{

private Singleton3(){}

private static class SingletonHolder{

private static Singleton3 instance = new Singleton3();

}

public static Singleton3 getInstance(){

return SingletonHolder.instance;

}

}

通过一段代码来测试:

@Test

public void test() throws Exception{

Singleton3 s1 = null;

Singleton3 s2 = Singleton3.getInstance();

//1.将实例串行话到文件

FileOutputStream fos = new FileOutputStream("singleton.txt");

ObjectOutputStream oos =new ObjectOutputStream(fos);

oos.writeObject(s2);

oos.flush();

oos.close();

//2.从文件中读取出单例

FileInputStream fis = new FileInputStream("singleton.txt");

ObjectInputStream ois = new ObjectInputStream(fis);

s1 = (Singleton3) ois.readObject();

if(s1==s2){

System.out.println("同一个实例");

}else{

System.out.println("不是同一个实例");

}

}

输出:

不是同一个实例

可以看到当我们把单例反序列化后,生成了多个不同的单例类,此时,我们必须在原来的代码中加入readResolve()函数,来阻止它生成新的单例

public class Singleton3 implements Serializable{

private Singleton3(){}

private static class SingletonHolder{

private static Singleton3 instance = new Singleton3();

}

public static Singleton3 getInstance(){

return SingletonHolder.instance;

}

//阻止生成新的实例

public Object readResolve(){

return SingletonHolder.instance;

}

}

再次测试时,就可以发现他们生成的是同一个实例了。

求JAVA小项目的完整代码

给你个做好了的Java的源程序的记事本,自己看看就行了的,不怎么难的···

import java.awt.*;

import java.awt.event.*;

import java.io.*;

import javax.swing.*;

public class MyNotepad implements ActionListener{

private JFrame frame=new JFrame("新记事本");

private JTextArea jta=new JTextArea();

private String result="";

private boolean flag=true;

private File f;

private JButton jb=new JButton("开始");

private JTextField jtf=new JTextField(15);

private JTextField jt=new JTextField(15);

private JButton jbt=new JButton("替换为");

private JButton jba=new JButton("全部替换");

private Icon ic=new ImageIcon("D:\\java课堂笔记\\GUI\\11.gif");

private String value;

private int start=0;

private JFrame jf=new JFrame("查找");

private JFrame jfc=new JFrame("替换");

@Override

public void actionPerformed(ActionEvent e) {

String comm=e.getActionCommand();

if("新建".equals(comm)){

if(!(frame.getTitle().equals("新记事本"))){

if(!flag){

write();

newNew();

}else{

JFileChooser jfc=new JFileChooser("D:\\java课堂笔记");

int returnVal = jfc.showDialog(null,"保存为");

if(returnVal == JFileChooser.APPROVE_OPTION) {//选择文件后再执行下面的语句,保证了程序的健壮性

f=jfc.getSelectedFile();

flag=false;

write();

}

}

}else if(!(jta.getText().isEmpty())){

JFileChooser jfc=new JFileChooser("D:\\java课堂笔记");

int returnVal = jfc.showDialog(null,"保存为");

if(returnVal == JFileChooser.APPROVE_OPTION) {//选择文件后再执行下面的语句,保证了程序的健壮性

f=jfc.getSelectedFile();

flag=false;

write();

newNew();

}

}else{

newNew();

}

}else if("打开".equals(comm)){

JFileChooser jfc=new JFileChooser("D:\\java课堂笔记");

jfc.setDialogType(JFileChooser.OPEN_DIALOG);

int returnVal = jfc.showOpenDialog(null);

if(returnVal == JFileChooser.APPROVE_OPTION) {//选择文件后再执行下面的语句,保证了程序的健壮性

f=jfc.getSelectedFile();

frame.setTitle(f.getName());

result=read();

flag=false;

value=result;

jta.setText(result);

}

}else if("保存".equals(comm)){

JFileChooser jfc=new JFileChooser("D:\\java课堂笔记");

if(flag){

int returnVal = jfc.showDialog(null,"保存为");

if(returnVal == JFileChooser.APPROVE_OPTION) {//选择文件后再执行下面的语句,保证了程序的健壮性

f=jfc.getSelectedFile();

flag=false;

write();

}

}else{

write();

}

}else if("另存".equals(comm)){

JFileChooser jfc=new JFileChooser("D:\\java课堂笔记");

int returnVal = jfc.showDialog(null,"另存");

if(returnVal == JFileChooser.APPROVE_OPTION) {//选择文件后再执行下面的语句,保证了程序的健壮性

f=jfc.getSelectedFile();

write();

}

}else if("退出".equals(comm)){

System.exit(0);

}else if("撤销".equals(comm)){

jta.setText(value);

}else if("剪切".equals(comm)){

value=jta.getText();

jta.cut();

}else if("复制".equals(comm)){

jta.copy();

}else if("粘贴".equals(comm)){

value=jta.getText();

jta.paste();

}else if("删除".equals(comm)){

value=jta.getText();

jta.replaceSelection(null);

}else if("全选".equals(comm)){

jta.selectAll();

}else if("查找".equals(comm)){

value=jta.getText();

jf.add(jtf,BorderLayout.CENTER);

jf.add(jb,BorderLayout.SOUTH);

jf.setLocation(300,300);

jf.pack();

jf.setVisible(true);

jf.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

}else if("替换".equals(comm)){

value=jta.getText();

GridLayout gl=new GridLayout(3,3);

JLabel jl1=new JLabel("查找内容:");

JLabel jl2=new JLabel("替换为:");

jfc.setLayout(gl);

jfc.add(jl1);

jfc.add(jtf);

jfc.add(jb);

jfc.add(jl2);

jfc.add(jt);

jfc.add(jbt);

JLabel jl3=new JLabel();

JLabel jl4=new JLabel();

jfc.add(jl3);

jfc.add(jl4);

jfc.add(jba);

jfc.setLocation(300,300);

jfc.pack();

jfc.setVisible(true);

jfc.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

}else if("版本".equals(comm)){

JDialog jd=new JDialog(frame,"关于对话框");

jd.setSize(200,200);

JLabel l=new JLabel("哈哈哈哈哈哈哈哈哈哈呵呵呵呵呵呵呵呵呵呵呵呵呵");

jd.add(l,BorderLayout.CENTER);

jd.setLocation(100,200);

jd.setSize(300,300);

jd.setVisible(true);

// jd.pack();

jd.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);

}else if("开始".equals(comm)||"下一个".equals(comm)){

String temp=jtf.getText();

int s=value.indexOf(temp,start);

if(value.indexOf(temp,start)!=-1){

jta.setSelectionStart(s);

jta.setSelectionEnd(s+temp.length());

jta.setSelectedTextColor(Color.GREEN);

start=s+1;

jb.setText("下一个");

// value=value.substring(s+temp.length());//不能截取字串

}else {

JOptionPane.showMessageDialog(jf, "查找完毕!", "提示", 0, ic);

jf.dispose();

}

}else if("替换为".equals(comm)){

String temp=jtf.getText();

int s=value.indexOf(temp,start);

if(value.indexOf(temp,start)!=-1){

jta.setSelectionStart(s);

jta.setSelectionEnd(s+temp.length());

jta.setSelectedTextColor(Color.GREEN);

start=s+1;

jta.replaceSelection(jt.getText());

}else {

JOptionPane.showMessageDialog(jf, "查找完毕!", "提示", 0, ic);

jf.dispose();

}

}else if("全部替换".equals(comm)){

String temp=jta.getText();

temp=temp.replaceAll(jtf.getText(), jt.getText());

jta.setText(temp);

}

}

public String read(){

String temp="";

try {

FileInputStream fis = new FileInputStream(f.getAbsolutePath());

byte[] b=new byte[1024];

while(true){

int num=fis.read(b);

if(num==-1)break;

temp=temp+new String(b,0,num);

}

fis.close();

} catch (Exception e1) {

e1.printStackTrace();

}

return temp;

}

public void write(){

try {

FileOutputStream fos=new FileOutputStream(f);

fos.write(jta.getText().getBytes());

fos.close();

} catch (Exception e) {

e.printStackTrace();

}

}

public void newNew(){

frame.dispose();

new MyNotepad();

flag=true;

}

public MyNotepad(){

JMenuBar jmb=new JMenuBar();

String[] menuLab={"文件","编辑","帮助"};

String[][] menuItemLab={{"新建","打开","保存","另存","退出"},

{"撤销","剪切","复制","粘贴","删除","全选","查找","替换"},

{"版本"}};

for(int i=0;imenuLab.length;i++){

JMenu menu=new JMenu(menuLab[i]);

jmb.add(menu);

for(int j=0;jmenuItemLab[i].length;j++){

JMenuItem jmi=new JMenuItem(menuItemLab[i][j]);

menu.add(jmi);

jmi.addActionListener(this);

}

}

frame.setJMenuBar(jmb);

jta.setLineWrap(true);//自动换行

JScrollPane jsp=new JScrollPane(jta);//滚动窗口面板

frame.add(jsp);

jb.addActionListener(this);

jbt.addActionListener(this);

jba.addActionListener(this);

frame.setLocation(200,50);

frame.setSize(620,660);

frame.setVisible(true);

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

public static void main(String[] args) {

new MyNotepad();

}

}

求基础级java代码,150-200行,自己写的

我有计算器程序

import javax.swing.*;

import javax.swing.border.Border;

import java.awt.*;

import java.awt.event.ActionListener;

import java.awt.event.ActionEvent;

import java.math.BigDecimal;

import java.math.RoundingMode;

import java.util.HashMap;

/**

* 我的计算器。MyCalculator 继承于 JFrame,是计算器的界面

*/

public class Calculator extends JFrame {

/**

*

*/

private static final long serialVersionUID = 1L;

private Border border = BorderFactory.createEmptyBorder(5, 5, 5, 5);

private JTextField textbox = new JTextField("0");

private CalculatorCore core = new CalculatorCore();

private ActionListener listener = new ActionListener() {

public void actionPerformed(ActionEvent e) {

JButton b = (JButton) e.getSource();

String label = b.getText();

String result = core.process(label);

textbox.setText(result);

}

};

public Calculator(String title) throws HeadlessException {

super(title); // 调用父类构造方法

setupFrame(); // 调整窗体属性

setupControls(); // 创建控件

}

private void setupControls() {

setupDisplayPanel(); // 创建文本面板

setupButtonsPanel(); // 创建按钮面板

}

// 创建按钮面板并添加按钮

private void setupButtonsPanel() {

JPanel panel = new JPanel();

panel.setBorder(border);

panel.setLayout(new GridLayout(4, 5, 3, 3));

createButtons(panel, new String[]{

"7", "8", "9", "+", "C",

"4", "5", "6", "-", "CE",

"1", "2", "3", "*", "", // 空字符串表示这个位置没有按钮

"0", ".", "=", "/", ""

});

this.add(panel, BorderLayout.CENTER);

}

/**

* 在指定的面板上创建按钮

*

* @param panel 要创建按钮的面板

* @param labels 按钮文字

*/

private void createButtons(JPanel panel, String[] labels) {

for (String label : labels) {

// 如果 label 为空,则表示创建一个空面板。否则创建一个按钮。

if (label.equals("")) {

panel.add(new JPanel());

} else {

JButton b = new JButton(label);

b.addActionListener(listener); // 为按钮添加侦听器

panel.add(b);

}

}

}

// 设置显示面板,用一个文本框来作为计算器的显示部分。

private void setupDisplayPanel() {

JPanel panel = new JPanel();

panel.setLayout(new BorderLayout());

panel.setBorder(border);

setupTextbox();

panel.add(textbox, BorderLayout.CENTER);

this.add(panel, BorderLayout.NORTH);

}

// 调整文本框

private void setupTextbox() {

textbox.setHorizontalAlignment(JTextField.RIGHT); // 文本右对齐

textbox.setEditable(false); // 文本框只读

textbox.setBackground(Color.white); // 文本框背景色为白色

}

// 调整窗体

private void setupFrame() {

this.setDefaultCloseOperation(EXIT_ON_CLOSE); // 当窗体关闭时程序结束

this.setLocation(100, 50); // 设置窗体显示在桌面上的位置

this.setSize(300, 200); // 设置窗体大小

this.setResizable(false); // 窗体大小固定

}

// 程序入口

public static void main(String[] args) throws Exception {

UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

Calculator frame = new Calculator("我的计算器");

frame.setVisible(true); // 在桌面上显示窗体

}

}

/**

* 计算器核心逻辑。这个逻辑只能处理 1~2 个数的运算。

*/

class CalculatorCore {

private String displayText = "0"; // 要显示的文本

boolean reset = true;

int MaxLen = 30;

private BigDecimal number1, number2;

private String operator;

private HashMapString, Operator operators = new HashMapString, Operator();

private HashMapString, Processor processors = new HashMapString, Processor();

CalculatorCore() {

setupOperators();

setupProcessors();

}

// 为每种命令添加处理方式

private void setupProcessors() {

processors.put("[0-9]", new Processor() {

public void calculate(String command) {

numberClicked(command);

}

});

processors.put("\\.", new Processor() {

public void calculate(String command) {

dotClicked();

}

});

processors.put("=", new Processor() {

public void calculate(String command) {

equalsClicked();

}

});

processors.put("[+\\-*/]", new Processor() {

public void calculate(String command) {

operatorClicked(command);

}

});

processors.put("C", new Processor() {

public void calculate(String command) {

clearClicked();

}

});

processors.put("CE", new Processor() {

public void calculate(String command) {

clearErrorClicked();

}

});

}

// 为每种 operator 添加处理方式

private void setupOperators() {

operators.put("+", new Operator() {

public BigDecimal process(BigDecimal number1, BigDecimal number2) {

return number1.add(number2);

}

});

operators.put("-", new Operator() {

public BigDecimal process(BigDecimal number1, BigDecimal number2) {

return number1.subtract(number2);

}

});

operators.put("*", new Operator() {

public BigDecimal process(BigDecimal number1, BigDecimal number2) {

return number1.multiply(number2);

}

});

operators.put("/", new Operator() {

public BigDecimal process(BigDecimal number1, BigDecimal number2) {

return number1.divide(number2, 30, RoundingMode.HALF_UP);

}

});

}

// 根据命令处理。这里的命令实际上就是按钮文本。

public String process(String command) {

for (String pattern : processors.keySet()) {

if (command.matches(pattern)) {

processors.get(pattern).calculate(command);

break;

}

}

return displayText;

}

// 当按下 CE 时

private void clearErrorClicked() {

if (operator == null) {

number1 = null;

} else {

number2 = null;

}

displayText = "0";

reset = true;

}

// 当按下 C 时,将计算器置为初始状态。

private void clearClicked() {

number1 = null;

number2 = null;

operator = null;

displayText = "0";

reset = true;

}

// 当按下 = 时

private void equalsClicked() {

calculateResult();

number1 = null;

number2 = null;

operator = null;

reset = true;

}

// 计算结果

/**

*

*/

private void calculateResult() {

number2 = new BigDecimal(displayText);

Operator oper = operators.get(operator);

if (oper != null) {

try {

BigDecimal result = oper.process(number1, number2);

displayText = result.toString();

} catch (RuntimeException e) {

clearClicked();//将计算器置为初始状态

JOptionPane.showMessageDialog(null,"不能用零作除数","出错了",JOptionPane.OK_OPTION);

//e.printStackTrace();

}

}

}

// 当按下 +-*/ 时(这里也可以扩展成其他中间操作符)

private void operatorClicked(String command) {

if (operator != null) {

calculateResult();

}

number1 = new BigDecimal(displayText);

operator = command;

reset = true;

}

// 当按下 . 时

private void dotClicked() {

if (displayText.indexOf(".") == -1) {

displayText += ".";

} else if (reset) {

displayText = "0.";

}

reset = false;

}

// 当按下 0-9 时

private void numberClicked(String command) {

if (reset) {

displayText = command;

} else {

if(displayText.length() MaxLen)

displayText += command;

else

JOptionPane.showMessageDialog(null,"输入的数字太长了","出错了",JOptionPane.OK_OPTION);

}

reset = false;

}

// 运算符处理接口

interface Operator {

BigDecimal process(BigDecimal number1, BigDecimal number2);

}

// 按钮处理接口

interface Processor {

void calculate(String command);

}

}

利用java编程编写代码,实现如下功能:

package example;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JFrame;

import javax.swing.JMenu;

import javax.swing.JMenuBar;

import javax.swing.JMenuItem;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.border.EmptyBorder;

public class demo extends JFrame{

private JMenuBar menu = new JMenuBar();

private JPanel contentPane = new JPanel();

public demo()

{

setTitle("compiler");

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

setJMenuBar(menu);

//JMenu correct = new JMenu("正确用例");

//JMenu wrong = new JMenu("错误用例");

////JMenuItem WP = wrong.add("语法错误");

//JMenuItem WL = wrong.add("词法错误");

JMenu edit = new JMenu("编辑");

JMenu help  = new JMenu("帮助");

JMenu document = new JMenu("文件");

JMenuItem copy = edit.add("复制");

JMenu color = new JMenu("颜色");

JMenuItem p = color.add("前景色");

p.addActionListener(new ActionListener()

{

@Override

public void actionPerformed(ActionEvent e) {

JOptionPane.showMessageDialog(null,

"该项目正在建设中", "信息",

JOptionPane.INFORMATION_MESSAGE);

}

});

JMenuItem b = color.add("背景色");

b.addActionListener(new ActionListener()

{

@Override

public void actionPerformed(ActionEvent e) {

JOptionPane.showMessageDialog(null,

"该项目正在建设中", "信息",

JOptionPane.INFORMATION_MESSAGE);

}

});

edit.add(color);

JMenuItem select = edit.add("全选");

menu.add(document);

menu.add(edit);

menu.add(help);

setLocation(400,200);

setSize(300, 300);

contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));

setContentPane(contentPane);

}

public static void main(String[]args)

{

demo browser = new demo();

browser.setVisible(true);

}

}


当前标题:华为项目java代码示例 华为java 百度文库
标题来源:http://pwwzsj.com/article/hgpccj.html