Java组件设计

1. java的Swing组件使用了哪种设计模式

Java中的Swing组件使用了MVC(视图-模型-控制器)设计模式。
布局管理器是策略模式；
swing组件式MVC模式、观察者模式；
边框是修饰模式；
设计模式是不限定某种开发语言的就是把解决某一类问题的方法抽象成一种固定的模式。

2. 使用Java swing组件设计如下图像界面程序

packageutils1;
importjava.awt.Container;
importjava.awt.event.ActionEvent;
importjava.awt.event.ActionListener;
importjavax.swing.JButton;
importjavax.swing.JFrame;
importjavax.swing.JLabel;
importjavax.swing.JPasswordField;
importjavax.swing.JTextField;


publicclassAAAextendsJFrame{
privateJTextFielsername;
//密码
privateJPasswordFieldpassword;
//小容器
privateJLabeljl1;
privateJLabeljl2;
privateJLabeljl3;
privateJLabeljl4;
//小按钮
privateJButtonbu1;
privateJButtonbu2;
/*
*构造方法
*/
publicAAA(){
//设置窗口标题
this.setTitle("登录练习");
//窗体组件初始化
init();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//设置布局方式为绝对定位
this.setLayout(null);
this.setBounds(0,0,355,265);
//窗体大小不能改变
this.setResizable(false);
//居中显示
this.setLocationRelativeTo(null);
//窗体可见
this.setVisible(true);
}
/*
*初始化方法
*/
publicvoidinit(){
//创建一个容器
Containercon=this.getContentPane();
jl4=newJLabel("",JLabel.CENTER);
jl4.setBounds(15,200,300,20);
jl4.setVisible(false);
jl1=newJLabel();
jl1.setBounds(0,0,355,265);
jl2=newJLabel("姓名：");
jl2.setBounds(40,80,60,20);
//用户号码登录输入框
username=newJTextField();
username.setBounds(100,80,150,20);
jl3=newJLabel("密码：");
jl3.setBounds(40,110,60,20);
//密码输入框
password=newJPasswordField();
password.setBounds(100,110,150,20);


//按钮设定
bu1=newJButton("登录");
bu1.setBounds(112,150,65,20);
//给按钮添加1个事件
bu1.addActionListener(newActionListener(){
@Override
publicvoidactionPerformed(ActionEvente){
Stringstr=e.getActionCommand();
if("登录".equals(str)){
StringgetName=username.getText();
Stringpwd=password.getText();
//StringgetPwd=password.getText();
if(getName.equals("user")&&pwd.equals("psd")){
jl4.setText("姓名和密码正确！");

}else{
jl4.setText("姓名和密码错误！");

}
jl4.setVisible(true);
}
}
});
bu2=newJButton("取消");
bu2.setBounds(177,150,65,20);
bu2.addActionListener(newActionListener(){

@Override
publicvoidactionPerformed(ActionEvente){
//TODOAuto-generatedmethodstub
username.setText("");
password.setText("");
jl4.setText("");
jl4.setVisible(false);
}
});
//所有组件用容器装载
jl1.add(jl2);
jl1.add(jl3);
jl1.add(bu1);
jl1.add(bu2);
con.add(jl1);
con.add(username);
con.add(password);
con.add(jl4);
}
publicstaticvoidmain(String[]args){
//实例化对象
AAAqq=newAAA();
}
}

3. java中如何用AWT组件来设计实现计算器程序

package book.gui;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;
/**
* 一个计算器，与Windows附件自带计算器的标准版功能、界面相仿。
* 但还不支持键盘操作。
*/
public class Calculator extends JFrame implements ActionListener {
/** 计算器上的键的显示名字 */
private final String[] KEYS = { "7", "8", "9", "/", "sqrt", "4", "5", "6",
"*", "%", "1", "2", "3", "-", "1/x", "0", "+/-", ".", "+", "=" };
/** 计算器上的功能键的显示名字 */
private final String[] COMMAND = { "Backspace", "CE", "C" };
/** 计算器左边的M的显示名字 */
private final String[] M = { " ", "MC", "MR", "MS", "M+" };
/** 计算器上键的按钮 */
private JButton keys[] = new JButton[KEYS.length];
/** 计算器上的功能键的按钮 */
private JButton commands[] = new JButton[COMMAND.length];
/** 计算器左边的M的按钮 */
private JButton m[] = new JButton[M.length];
/** 计算结果文本框 */
private JTextField resultText = new JTextField("0");

// 标志用户按的是否是整个表达式的第一个数字,或者是运算符后的第一个数字
private boolean firstDigit = true;
// 计算的中间结果。
private double resultNum = 0.0;
// 当前运算的运算符
private String operator = "=";
// 操作是否合法
private boolean operateValidFlag = true;
/**
* 构造函数
*/
public Calculator(){
super();
//初始化计算器
init();
//设置计算器的背景颜色
this.setBackground(Color.LIGHT_GRAY);
this.setTitle("计算器");
//在屏幕(500, 300)坐标处显示计算器
this.setLocation(500, 300);
//不许修改计算器的大小
this.setResizable(false);
//使计算器中各组件大小合适
this.pack();
}
/**
* 初始化计算器
*/
private void init() {
// 文本框中的内容采用右对齐方式
resultText.setHorizontalAlignment(JTextField.RIGHT);
// 不允许修改结果文本框
resultText.setEditable(false);
// 设置文本框背景颜色为白色
resultText.setBackground(Color.WHITE);

//初始化计算器上键的按钮，将键放在一个画板内
JPanel calckeysPanel = new JPanel();
//用网格布局器，4行，5列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
calckeysPanel.setLayout(new GridLayout(4, 5, 3, 3));
for (int i = 0; i < KEYS.length; i++) {
keys[i] = new JButton(KEYS[i]);
calckeysPanel.add(keys[i]);
keys[i].setForeground(Color.blue);
}
//运算符键用红色标示，其他键用蓝色表示
keys[3].setForeground(Color.red);
keys[8].setForeground(Color.red);
keys[13].setForeground(Color.red);
keys[18].setForeground(Color.red);
keys[19].setForeground(Color.red);

//初始化功能键，都用红色标示。将功能键放在一个画板内
JPanel commandsPanel = new JPanel();
//用网格布局器，1行，3列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
commandsPanel.setLayout(new GridLayout(1, 3, 3, 3));
for (int i = 0; i < COMMAND.length; i++) {
commands[i] = new JButton(COMMAND[i]);
commandsPanel.add(commands[i]);
commands[i].setForeground(Color.red);
}

//初始化M键，用红色标示，将M键放在一个画板内
JPanel calmsPanel = new JPanel();
//用网格布局管理器，5行，1列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
calmsPanel.setLayout(new GridLayout(5, 1, 3, 3));
for (int i = 0; i < M.length; i++) {
m[i] = new JButton(M[i]);
calmsPanel.add(m[i]);
m[i].setForeground(Color.red);
}

//下面进行计算器的整体布局，将calckeys和command画板放在计算器的中部，
//将文本框放在北部，将calms画板放在计算器的西部。

//新建一个大的画板，将上面建立的command和calckeys画板放在该画板内
JPanel panel1 = new JPanel();
//画板采用边界布局管理器，画板里组件之间的水平和垂直方向上间隔都为3象素
panel1.setLayout(new BorderLayout(3, 3));
panel1.add("North", commandsPanel);
panel1.add("Center", calckeysPanel);

//建立一个画板放文本框
JPanel top = new JPanel();
top.setLayout(new BorderLayout());
top.add("Center", resultText);

//整体布局
getContentPane().setLayout(new BorderLayout(3, 5));
getContentPane().add("North", top);
getContentPane().add("Center", panel1);
getContentPane().add("West", calmsPanel);
//为各按钮添加事件侦听器
//都使用同一个事件侦听器，即本对象。本类的声明中有implements ActionListener
for (int i = 0; i < KEYS.length; i++) {
keys[i].addActionListener(this);
}
for (int i = 0; i < COMMAND.length; i++) {
commands[i].addActionListener(this);
}
for (int i = 0; i < M.length; i++) {
m[i].addActionListener(this);
}
}

/**
* 处理事件
*/
public void actionPerformed(ActionEvent e) {
//获取事件源的标签
String label = e.getActionCommand();
if (label.equals(COMMAND[0])){
//用户按了"Backspace"键
handleBackspace();
} else if (label.equals(COMMAND[1])) {
//用户按了"CE"键
resultText.setText("0");
} else if (label.equals(COMMAND[2])){
//用户按了"C"键
handleC();
} else if ("0123456789.".indexOf(label) >= 0) {
//用户按了数字键或者小数点键
handleNumber(label);
// handlezero(zero);
} else {
//用户按了运算符键
handleOperator(label);
}
}
/**
* 处理Backspace键被按下的事件
*/
private void handleBackspace() {
String text = resultText.getText();
int i = text.length();
if (i > 0) {
//退格，将文本最后一个字符去掉
text = text.substring(0, i - 1);
if (text.length() == 0) {
//如果文本没有了内容，则初始化计算器的各种值
resultText.setText("0");
firstDigit = true;
operator = "=";
} else {
//显示新的文本
resultText.setText(text);
}
}
}

/**
* 处理数字键被按下的事件
* @param key
*/
private void handleNumber(String key) {
if (firstDigit) {
//输入的第一个数字
resultText.setText(key);
} else if ((key.equals(".")) && (resultText.getText().indexOf(".") < 0)){
//输入的是小数点，并且之前没有小数点，则将小数点附在结果文本框的后面
resultText.setText(resultText.getText() + ".");
} else if (!key.equals(".")) {
//如果输入的不是小数点，则将数字附在结果文本框的后面
resultText.setText(resultText.getText() + key);
}
//以后输入的肯定不是第一个数字了
firstDigit = false;
}
/**
* 处理C键被按下的事件
*/
private void handleC() {
//初始化计算器的各种值
resultText.setText("0");
firstDigit = true;
operator = "=";
}

/**
* 处理运算符键被按下的事件
* @param key
*/
private void handleOperator(String key) {
if (operator.equals("/")) {
//除法运算
//如果当前结果文本框中的值等于0
if (getNumberFromText() == 0.0){
//操作不合法
operateValidFlag = false;
resultText.setText("除数不能为零");
} else {
resultNum /= getNumberFromText();
}
} else if (operator.equals("1/x")) {
//倒数运算
if (resultNum == 0.0){
//操作不合法
operateValidFlag = false;
resultText.setText("零没有倒数");
} else {
resultNum = 1 / resultNum;
}
} else if (operator.equals("+")){
//加法运算
resultNum += getNumberFromText();
} else if (operator.equals("-")){
//减法运算
resultNum -= getNumberFromText();
} else if (operator.equals("*")){
//乘法运算
resultNum *= getNumberFromText();
} else if (operator.equals("sqrt")) {
//平方根运算
resultNum = Math.sqrt(resultNum);
} else if (operator.equals("%")){
//百分号运算，除以100
resultNum = resultNum / 100;
} else if (operator.equals("+/-")){
//正数负数运算
resultNum = resultNum * (-1);
} else if (operator.equals("=")){
//赋值运算
resultNum = getNumberFromText();
}
if (operateValidFlag) {
//双精度浮点数的运算
long t1;
double t2;
t1 = (long) resultNum;
t2 = resultNum - t1;
if (t2 == 0) {
resultText.setText(String.valueOf(t1));
} else {
resultText.setText(String.valueOf(resultNum));
}
}
//运算符等于用户按的按钮
operator = key;
firstDigit = true;
operateValidFlag = true;
}

/**
* 从结果文本框中获取数字
* @return
*/
private double getNumberFromText() {
double result = 0;
try {
result = Double.valueOf(resultText.getText()).doubleValue();
} catch (NumberFormatException e){
}
return result;
}

public static void main(String args[]) {
Calculator calculator1 = new Calculator();
calculator1.setVisible(true);
calculator1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

package book.gui;

import javax.swing.JFrame;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.;
import javax.swing.plaf.metal.MetalLookAndFeel;

import com.sun.java.swing.plaf.motif.MotifLookAndFeel;
import com.sun.java.swing.plaf.windows.WindowsLookAndFeel;
/**
* 更改窗体、组件的外观
*/
public class LookAndFeel {

public static void main(String[] args) {
/**
* Metal风格——"javax.swing.plaf.metal.MetalLookAndFeel"
* Motif风格——"com.sun.java.swing.plaf.motif.MotifLookAndFeel"
* Windows风格——"com.sun.java.swing.plaf.windows.WindowsLookAndFeel"
*/
Calculator calculator1 = new Calculator();
calculator1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//3个不同的风格
/**
* LookAndFeel是一个抽象类，除了提供了一些static方法，还定义了一些抽象的个性化设置方法来由子类实现。
从JDK1.1.3开始，Sun提供了三个LookAndFeel的子类
*/
String lnfName = "javax.swing.plaf.metal.MetalLookAndFeel";
// String lnfName = "com.sun.java.swing.plaf.motif.MotifLookAndFeel";
// String lnfName = "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
try {
// UIManager负责跟踪当前的外观及其默认设置，setLookAndFeel方法将设置它的LookAndFeel的类全名
UIManager.setLookAndFeel(lnfName);
// setLookAndFeel还可以直接设置设置对象
UIManager.setLookAndFeel(new MetalLookAndFeel());
// UIManager.setLookAndFeel(new MotifLookAndFeel());
// UIManager.setLookAndFeel(new WindowsLookAndFeel());

//SwingUtilities是一个Swing的工具类，提供了很多静态方法。
//updateComponentTreeUI将更新calculator1中所有组件的外观
SwingUtilities.updateComponentTreeUI(calculator1);
}
catch ( ex1) {
System.err.println("Unsupported LookAndFeel: " + lnfName);
}
catch (ClassNotFoundException ex2) {
System.err.println("LookAndFeel class not found: " + lnfName);
}
catch (InstantiationException ex3) {
System.err.println("Could not load LookAndFeel: " + lnfName);
}
catch (IllegalAccessException ex4) {
System.err.println("Cannot use LookAndFeel: " + lnfName);
}
calculator1.setVisible(true);
}
}

4. Java组件设计的内容简介

设计，决定了软件质量！
组件化设计和构建软件系统，是实现快速发布高质量软件产品之梦的最佳实践！
组件设计，凝聚了需求分析、面向对象、设计模式、数据结构、多线程等一系列高阶领域的核心精髓！
Java语言，是互联网上的卓越语言，从诞生的那一天开始，就被很多软件工程师所青睐，不断在世界的每个角落开花结果，应用日益广泛。
Java开源世界，如火如荼地发展，无数的框架、组件如雨后春笋般涌现，极大地推进了Java技术在各个领域的商业应用。
然而，由于设计者的眼界、经验和水平等的限制，Java开源框架、组件参差不齐，优秀者并不多见。在企业软件开发中，Java往往成了臃肿、笨拙、低效等的代名词。功能最简单的Java组件也要几十、上百个类文件，使用组件需要引入的Jar文件少则几兆字节，多则几十兆、上百兆字节。因此，所谓鼓吹的轻量级组件，不过是个噱头而已。
笔者从事企业软件开发十余载，专注平台和组件开发领域，深知组件设计与开发过程的“高处不胜寒”。因此，在本书中，笔者将自己对组件技术的认识和心得进行总结和提炼，为读者奉上一份Java组件设计领域的精彩技术大餐。
本书定位
本书面向软件架构师、设计师、高级开发人员，讲解企业应用中核心组件的设计原则与最佳实践。
本书将澄清设计模式、数据结构、多线程、接口设计等多个高阶技术领域中“流行”的认知误区，通过大量的组件实例分析，为读者精彩讲解组件设计这一最具技术含量的领域需要考虑的核心问题、设计方案与最佳实践。
本书的内容
这本书主要涵盖三部分的内容：
第1篇，主要讲解了应用程序的架构、组件的定义和组件核心设计原则。这些原则，都是在大量的企业软件实践中浓缩提炼的精华。
第2篇，对Java语言的高级主题进行了详尽的阐述，作为组件实战的必需必备基础功力。
第3篇，对企业应用的核心组件，进行需求分析、设计和实现。核心组件包括：
? 第4章，配置组件 ? 第7章，数据库访问组件
? 第5章，Socket 通信组件 ? 第8章，JSON转换器
? 第6章，日志组件 ? 第9章，权限组件
特别致谢
衷心感谢周坚先生，在华为公司期间对我无私的指导，使我有幸步入设计领域的高级殿堂！
衷心感谢我的父亲、母亲和兄弟姐妹，是你们的关怀照顾和言传身教，让我懂得人生的意义！
衷心感谢我的妻子，默默忍受我长期的熬夜，不断给我关心、支持和鼓励！
衷心感谢我的儿子，给我带来无尽的欢乐！
衷心感谢在我的生活、工作中，帮助过我的每一个人！
孔德生
2008年12月

5. java 设计一个用户注册页面,页面内包含各类组件,组件的布局采用布局管理器类

/*
* 这是客户端的界面层
*/
package Client_View;

import java.awt.*;
import java.awt.event.*;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.*;

import Client_Model.*;
import Common.QQ_Message;
import Common.QQ_UserInformation;

public class Client_Login extends JFrame implements ActionListener {

JPanel jp1, jp2, jp3, jp4;
JLabel jl1;
JButton jb1, jb2, jb3;
ImageIcon image_icon1;

// 选项卡
JTabbedPane jtp1 = null;

// 定义中间的控件
JLabel jp2_jl1, jp2_jl2, jp2_jl3, jp2_jl4;
JTextField jp2_jtf1;
JPasswordField jp2_jpf1;
JCheckBox jp2_jcb1, jp2_jcb2;
JButton jp2_jb1;

public static void main(String[] args) {
Client_Login qqcv = new Client_Login();
}

// 构造函数，用来做界面
public Client_Login()
{
this.showNorth();
this.showCenter();
this.showSouth();

this.showJFrame();
}

// 这是做北面的布局
public void showNorth()
{
image_icon1 = new ImageIcon("image/tou.gif");
jl1 = new JLabel(image_icon1);
this.add(jl1, "North");
}

// 这是中间的布局
public void showCenter()
{
jtp1 = new JTabbedPane();
this.add(jtp1);

// 中间有三个JPanel,它们由一个JTabbedPane管理
jp2 = new JPanel();
jp2.setLayout(new GridLayout(3, 3));
jp3 = new JPanel();
jp4 = new JPanel();
jtp1.add(jp2, "QQ号码");
jtp1.add(jp3, "手机号码");// jp3和jp4分别代表另外两个面板，这两个面板没有去实现
jtp1.add(jp4, "电子邮件");// jp3和jp4分别代表另外两个面板，这两个面板没有去实现
// //////////////////////////////////////////////////////////////////
jp2_jl1 = new JLabel("QQ号码", JLabel.CENTER);
jp2_jl2 = new JLabel("QQ密码", JLabel.CENTER);
jp2_jl3 = new JLabel("忘记密码", JLabel.CENTER);
jp2_jl4 = new JLabel("申请密码保护", JLabel.CENTER);

jp2_jtf1 = new JTextField("1");//登陆框
jp2_jpf1 = new JPasswordField("111111");//密码框

jp2_jcb1 = new JCheckBox("隐身登陆");
jp2_jcb2 = new JCheckBox("记住密码");

jp2_jb1 = new JButton(new ImageIcon("image/clear.gif"));//清除号码按钮
jp2_jb1.addActionListener(this);

jp2.add(jp2_jl1);
jp2.add(jp2_jtf1);
jp2.add(jp2_jb1);
jp2.add(jp2_jl2);
jp2.add(jp2_jpf1);
jp2.add(jp2_jl3);
jp2.add(jp2_jcb1);
jp2.add(jp2_jcb2);
jp2.add(jp2_jl4);
}

// 这是南边的布局
public void showSouth()
{
jp1 = new JPanel();
this.add(jp1, "South");

jb1 = new JButton(new ImageIcon("image/denglu.gif"));//登陆按钮
jb1.addActionListener(this);
jb2 = new JButton(new ImageIcon("image/quxiao.gif"));//取消按钮
jb2.addActionListener(this);
jb3 = new JButton(new ImageIcon("image/xiang.gif"));//注册向导按钮
jb3.addActionListener(this);
jp1.add(jb1);
jp1.add(jb2);
jp1.add(jb3);
}

// 这是显示总体的窗体
public void showJFrame()
{
int hight=Toolkit.getDefaultToolkit().getScreenSize().height;
int width=Toolkit.getDefaultToolkit().getScreenSize().width;
this.setSize(350, 240);
this.setLocation((width-this.getWidth())/2,(hight-this.getHeight())/2);
this.setTitle("QQ登陆");

this.setResizable(false);
this.setVisible(true);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}

// 发送登陆信息到客户端的Model层的函数
public boolean send_Login_Message_To_Model(QQ_UserInformation userinfo)
{
boolean b=false;
Client_Model cm=new Client_Model();
b=cm.send_Login_info_to_Client_net(userinfo);

return b;
}

@Override
public void actionPerformed(ActionEvent arg0)
{
if (arg0.getSource() == jp2_jb1)
{
// 点击清除号码按钮
jp2_jtf1.setText("");
jp2_jpf1.setText("");
}
if (arg0.getSource() == jb1)
{
// 点击登录按钮
QQ_UserInformation userinfo=new QQ_UserInformation();
userinfo.setUserID(jp2_jtf1.getText() );
userinfo.setPassword(new String (jp2_jpf1.getPassword()));
System.out.println("登陆界面。用户名： "+userinfo.getUserID()+", 密码: "+userinfo.getPassword());

boolean b=send_Login_Message_To_Model(userinfo);
System.out.println("客户端login界面，得到的登陆的信息： b = "+ b);
if(b==false)
{
//用户名密码错误，登陆失败
JOptionPane.showMessageDialog(null,"用户名或密码错误","登陆失败...",JOptionPane.ERROR_MESSAGE);

}else if(b==true)
{
Client_FriendsList cf=new Client_FriendsList(userinfo);
this.dispose();
}
}
if (arg0.getSource() == jb2)
{
// 点击取消按钮，关闭该窗口
this.dispose();
}
if (arg0.getSource() == jb3)
{
// 点击注册向导按钮，暂时没有去实现该功能
}
}
}

6. java 常用组件设计问题

import javax.swing.*;
import java.awt.*;
public class Calculator extends JFrame {
private static final long serialVersionUID = 8199443193151152362L;
private JButton bto_s=new JButton("sqrt"),bto_zf=new JButton("+/-"),bto_ce=new JButton("CE"),bto_c=new JButton("C"),bto_7=new JButton("7"),
bto_8=new JButton("8"),bto_9=new JButton("9"),bto_chu=new JButton("/"),bto_4=new JButton("4"),bto_5=new JButton("5"),
bto_6=new JButton("6"),bto_cheng=new JButton("*"),bto_1=new JButton("1"),bto_2=new JButton("2"),bto_3=new JButton("3"),
bto_jian=new JButton("-"),bto_0=new JButton("0"),bto_dian=new JButton("."),bto_deng=new JButton("="),bto_jia=new JButton("+");
JButton button[]={bto_s,bto_zf,bto_ce,bto_c,bto_7,bto_8,bto_9,bto_chu,bto_4,bto_5,bto_6,bto_cheng,bto_1,bto_2,bto_3,bto_jian,
bto_0,bto_dian,bto_deng,bto_jia};
private JTextField text_double;// = new JTextField("0");
public Calculator()
{
super("Calculator");
this.setBounds(300, 300, 300, 300);
this.setResizable(false);
this.setBackground(Color.orange);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.getContentPane().setLayout(new BorderLayout());//设置布局
text_double=new JTextField("0",20);//设置文本区
text_double.setHorizontalAlignment(JTextField.RIGHT);//设置水平对齐方式未右对齐
this.getContentPane().add(text_double,BorderLayout.NORTH);//将文本区添加到Content北部
JPanel panel=new JPanel(new GridLayout(5,4));//在内容窗口添加一个网格布局
this.getContentPane().add(panel);//添加panel面板
for(int i=0;i<button.length;i++)//在面板上添加按钮
panel.add(button[i]);

for(int i=0;i<button.length;i++)
text_double.setEditable(false);//文本框不可编辑
this.setVisible(true);
}

public static void main(final String[] args) {
new Calculator();
}
}
//想要有计算功能的到 参考地址中去看

7. 什么是JAVA组件

例如：javabean是一个类，但是如果您的类想要成为beajavabean，您必须向类中的变量（比如XXX）添加两个内部函数getXxx（）和setXxx（），并且您必须在类中有一个无参数的构造函数。这些就是javabean，组件之间必须有一个相互使用的规范。

Java实际上是所有的类。组件是一个抽象，是符合规范的类的集合。要知道它可以提供某些功能。以J2EE为例，servlet，jsp，javabean，ejb都是组件。

但在使用上，都会分阶级，有自己的特殊规则。

(7)Java组件设计扩展阅读：

首先，轻量级组件是用Java代码绘制的，因此具有平台可移植性，重量级组件是由调用系统的函数（如主窗体）绘制的组件，一般来说，尽量使用轻量级组件，这有利于可移植性。

java中的大多数组件。swing包是轻量级的，而java包则是轻量级的，awt很重。

Swing是用100％纯Java实现的，而Swing组件是用Java实现的轻量级组件，没有本地代码独立于操作系统支持之外，这是拥有AWT组件的最大组。当AWT组件通过特定的平台时

对等类（Peer）实现，因此Swing比AWT组件更实用。Swing不能回答相同的问题平台上的一致性能和提供本地窗口系统不支持的附加功能的能力。

重量级组件：特定平台必须有相应的组件。

轻量级组件：在一个虚拟的画布上绘制组件（swing非常慢），所有的轻量级组件应该“最终”属于重量级组件（jframe、jdialog）。

因为它是这样绘制的，所以可以在各种平台上实现一致的性能。同样，如果混合重量级组件和轻量级组件容易在重叠上引起冲突。

8. JAVA 如何给组件绘制边框

调用组件的
setBorder(new LineBorder(Color color))
可以绘制组件的边框，边框为像素为1，颜色为color的直线
具体可以参考组件setBorder()方法和LineBorder边框类的API
还有其他的边框类

9. java中什么是组件,它和类有什么区别

组件（Component）是对数据和方法的简单封装。C++ Builder中，一个组件就是一个从TComponent派生出来的特定对象。组件可以有自己的属性和方法。属性是组件数据的简单访问者。方法则是组件的一些简单而可见的功能。
组件是C++ Builder环境中最令人激动的部分。使用组件可以实现拖放式编程、快速的属性处理以及真正的面向对象的设计。VCL和CLX组件是C++ Builder系统的核心。
http://www.itise.com/phrase/200603302222545.html

10. 用java组件设计一个登陆界面用户名和密码验证的程序,要求当输入用户名或密码为空时,弹出警告对话框：

登陆Button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {

String name = nameText.getText();
String password =passwordText.getText();

if("".equals(name) || "".equals(password)){
JOptionPane.showMessageDialog(null, "用户名或密码为空！");

}else{
登陆验证......
}
}
});