java

类外可见

首先说一下int 和public int的区别：这个问题是作用域的问题，就是说这个变量的作用范围是多大。public class Text{int a ;public void toString(){......}对于这个int，他是该类的成员属性，因为没有访问修饰符，所以java默认认为他是default，也就是只有在该类中能访问，其他地方不能访问。和private相似，区别不太清楚。public class Text{public int a;.....对于这个int，由于有public修饰，所以这个变量对于所有类都是可见的，没有访问的限制。static，其实就是一个静态变量的意思。用static修饰的变量又叫类变量，他有很多特性，现在列出来。public static int a，对于这个变量，首先他不需要一个实例化对象，也就是说不需要new 对象就可以用类名+变量名来访问这个变量，当然要看访问修饰符的限制。其次，这个变量是一个全局的变量，就是这个对象被该类的其他所有对象共有。比如：public class Text {public static int a = 1;public static void main(String[] args){Text.a = 2; //这个就是static的作用，不需要new对象就可以访问。Text aa = new Text();Text bb = new Text();//new两个不同的对象aa.a = 3; //这个就是public的作用，说明该成员变量为对外可见。其实这么做 并不好//现在我们想想，bb.a是多少呢？System.out.println(bb.a);结果就是3，因为static修饰的变量时类变量，是被该类所有对象共有，所以你在aa中修改的a的值，而aa和bb是共用这个a变量的。所以bb的a值也再变化。Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

aled to show runners

public：公共属性，类内类外子类均可调用private：私有属性，只能类内调用protected：受保护属性，类内子类可调用

public 是权限访问修饰符中的一个，不是什么全局变量。请你仔细看一下这个资料：http://wenku.baidu.com/view/3cba2d0d7cd184254b3535b5.html

公共变量？ 公共函数？ public后缀是什么？

这个简单，主要就是几个类，本人专业就是JAVA编程，把手教你邮件联系

学Java还有发展前途吗?市场是不是饱和了?学Java能找到好工作么?你是不是也有或者也听见过这样的疑问?然而，通过所有外部表现来看，Java仍活着，并且正在发展。一起来看看屹立不倒的Java具备哪些独特的魅力。尽管许多新语言各领风骚，开发语言排行榜(TIOBE)上Java在2017年仍居榜首，远远超过其他语言。另一方面，PYPLindex根据Google搜索频率为编程语言排名，展示Java以总搜索量的23.9%遥遥领先。近两年有很多Java死灰复燃的原因(Android开发的爆炸式增长，Java8的发布，Spring社区的活跃，尤其是SpringBoot)，市场优势来自于伟大的产品。这就是为什么我们认为Java并不会消亡的原因。Java虚拟机和Java生态环境Java虚拟机，或称JVM，将程序编译成字节码，稍后被JVM解析执行。因为JVM根植于你的特定硬件和系统，它允许Java在各处运行，Windows、Mac或各种Linux。JVM带来的巨大优势就是它提供的强大兼容性和稳定性。因为你的应用运行在虚拟机上而不是直接运行在硬件上，你可以编写一次应用并运行在每个有Java虚拟机的设备上。这也是Java核心原则：“一次编写，到处运行”。这也让Java应用面对环境变化时有更大弹性。安全性和互操作性Android环境就是Java安全性和互操作性的典型代表。Android占全球手机市场89%，运行基于Java。因为Java允许操作系统运行在虚拟机中，并不需要在每台设备上编译，提高了系统的稳定性和易用性。Android展现出的Java另一个优点就是与其他基于JVM语言的互操作，比如Scala、Groovy、Clojure、JRuby等等。你可以选择使用这些“更加动态”的语言来构建你的应用，并在需要更多性能的时候重拾Java。巨大的Android市场在内部开发中也存在危险。Android+Java允许用户运行不受信任的应用，并通过虚拟机来运行所有应用来缓解这种危险。因此，应用充分利用操作系统核心的唯一方式就是放弃虚拟机的实现，也就是那个非常小的、被安全层紧紧保护的虚拟机。Java的实际应用规模Amazon、Google、eBay和许多其他大型电商使用Java作为它们的后台。它们使用Java是因为Java久经考验并且可伸缩。任何语言的后台只能支撑少量用户，但Java可以处理200m或等多。让我们看几个典型例子：HadoopApacheHadoop是支持在大规模硬件集群上运行应用的的Java框架。它被设计用来为那些操作和处理大数据的应用提供高吞吐量。如今Hadoop被许多公司，如Facebook、Amazon、IBM、Joost和Yahoo来处理数据、分析或生成记录。Hadoop的创造者DougCutting说过：”Java协调了开发者开发效率和程序执行效率。开发者受益于这种简单、强大、类型安全的语言和丰富的高质量库。”简而言之：大数据离不开Hadoop，Hadoop离不开Java。Twitter对于Oracle团队和Java来说，Twitter是近几年众人皆知的巨大成功。最初由RubyonRails构建，Twitter流行度急速上升，同时RoR框架可伸缩性的缺陷也清晰暴露出来。“FailWhales(失败鲸)”(Twitter宕机时的标志画面)也频繁出现，直到Twitter在2012年转向Java。如今Twitter运行在Java+Scala之上，FailWhales(失败鲸)也不复存在。MinecraftMinecraft是款不可思议的成功游戏。开发团队通过它赚了上百万美元，然后以25亿美元价格卖给微软。Minecraft运行在Java之上。庞大的的Java社区帮助Minecraft蔓延到成千上万的游戏mod。同时Minecraft向新一代开发者推荐Java。Google上搜索”Minecraftmod制作”会返回65.3万的结果，其中大多是教12岁以下人群如何编程。其中一款开源工具是Eureka，人们用它来跟踪用户登录Netflix所使用的设备，并交叉校验动作和最近活动，来确保当前账户是安全的。Java的未来Java9的到来把语言中众多函数拆分成许多小组件，意在让Java更加快速和易用。Oracle的巨大投入(虽然总被黑)帮助Java一方面可以继续支持企业依赖，另一方面也可以有所新的发展。Java和物联网(Internetofthings)“我认为Java的未来就在物联网(IoT)之中。我很想看到Oracle和合作伙伴致力于完善Java端对端的存储解决方案，从设备通过网关到达企业后台。如果能梦想成真并取得成功，将巩固Java在未来20年中的地位。这对于行业来说是巨大的挑战，我相信Java能够胜任。”Eclipse基金会执行董事MikeMilinkovich这样说。Oracle赞同这点。DevelopmentGeorgesSaab副总裁说：“Java对于物联网(IoT)来说是很棒的技术。物联网很多挑战是桌面和客户端的挑战，上世纪90年代Java已经解决。现在有很多不同的硬件设备。你想让开发者关注系统的各个层面，理解并运用。Java是少数能让你这样做的技术之一。”Java+stormpath有不少批评Java的人，他们部分争论的焦点或许有一些说服力，但这也是好事，比如优秀的部署工具、性能分析、Java虚拟机、庞大的库等等。在Stormpath，我们的后端完全用Java开发，并且我们升级到了SpringBoot。Java万岁。感谢大家阅读由java问答栏目分享的“现在学Java还有发展前途吗?”希望对大家有所帮助，更多精彩内容请关注Java培训官网免责声明：本文由小编转载自网络，旨在分享提供阅读，版权归原作者所有，如有侵权请联系我们进行删除

找不到说明导入的包不对，记住是导入import java.awt.event.*;public void addActionListener(ActionListener l)添加指定的动作侦听器，以接收发自此按钮的动作事件。当用户在此按钮上按下或释放鼠标时，发生动作事件。如果 l 为 null，则不抛出任何异常，也不执行任何动作。参数：l - 动作侦听器 addActionListener这个方法的形参也可以是实现了ActionListener接口类的对象。这个方法可以绑定到text或者button上。

父类的构造函数是protected属性，受保护的

第一个错误，public 你写成pubic少了个"l"；第二个错误源于第一个错误，修改之后应该就好了；第三个错误，setSize你写成了setsize，"s"应该大写；你可以在对照一下源码，看是不是。Best wishes！

因为你调用方法是在main方法中调用的，main方法是静态的，静态方法调用静态的，不能直接调用非静态的，想要调用非静态的方法只能先new一个对象再调用，你把pubic 去掉一样不能调用这和public没关，而是和static有关系

应该是翻译问题，抽象数据类型在这里应该是指 泛型。

分类: 电脑/网络 >> 程序设计 >> 其他编程语言 问题描述: import java.applet.Applet; import java.awt.*; public class splash extends Applet implements Runnable { int XMAX=112; float[] m_Height=new float[MAX]; float[] m_G=new float[XMAX]; float b=1.01f; float fWeight=3; private Thread m_NAMI2D=null; public boolean mouseDown(Event event, int i, int j) { m_Height[i/4-1]+=j/2; m_Height[i/4]+=j; m_Height[i/4+1]+=j/2; return false; } public void paint(Graphics g) { g.setColor(Color.blue); float f1=3F*fWeight; float f2=f1-2.0F; m_Height[0]=m_Height[1]; m_Height[XMAX-1]=m_Height[XMAX-2]; float f=m_Height[0]; for(int i=1; i<XMAX-1;i++) { float f3=((f+f2*m_Height[i]+m_Height[i+1])/f1 +m_G[i]/b; f=m_Height[i]; m_G[i]=f3-f; m_Height[i]=f3; g.clearRect((i-1)*4, (int)f3-30, 4, 60); g.fillRect((i-1)*4, (int)f3+30, 4, 60); } } public void run() { do try { repaint(); Thread.sleep(50L); } catch(InterruptedException_ex); { stop(); } while(true); } public void start() { if(m_NAMI2D==null) { m_NAMI2D=new Thread(this); m_NAMI2D.start(); } } public void stop() { if (m_NAMI2D !=null) { m_NANI2D.stop(); m_NAMI2D=null; } } public void update(Graphics g) { pain(g); } } 到底哪里错了？我都是照着书打的啊！ splash.java:31: ")" expected +m_G[i]/b; ^ splash.java:47: <identifier> expected catch(InterruptedException_ex); ^ splash.java:47: ")" expected catch(InterruptedException_ex); ^ splash.java:53: while expected public void start() ^ splash.java:73: "(" expected } ^ splash.java:74: "}" expected ^ 6 errors 为什么出现了那么多的错误。 解析: 我发现你的错误都是语法错误，目前情况有二： 1。符号的中英文状态问题； 2。变量、函数符号的书写错误； 建议你使用高亮显示变量、函数名和关键字的编译工具：如NetBeans，JBuilder，eclipse等。 代码修改如下，修改处有注释： package baidu.zhidao; import java.applet.Applet; import java.awt.*; public class Splash extends Applet implements Runnable { int XMAX=112; float[] m_Height=new float[XMAX]; 此处写成了MAX float[] m_G=new float[XMAX]; float b=1.01f; float fWeight=3; private Thread m_NAMI2D=null; public boolean mouseDown(Event event, int i, int j) { m_Height[i/4-1]+=j/2; m_Height[i/4]+=j; m_Height[i/4+1]+=j/2; return false; } public void paint(Graphics g) { g.setColor(Color.blue); float f1=3F*fWeight; float f2=f1-2.0F; m_Height[0]=m_Height[1]; m_Height[XMAX-1]=m_Height[XMAX-2]; float f=m_Height[0]; for(int i=1; i<XMAX-1;i++) { float f3=(f + f2*m_Height[i] + m_Height[i+1])/f1 + m_G[i]/b; 原始的空格有中文状态的，括号不匹配 f=m_Height[i]; m_G[i]=f3-f; m_Height[i]=f3; g.clearRect((i-1)*4, (int)f3-30, 4, 60); g.fillRect((i-1)*4, (int)f3+30, 4, 60); } } public void run() { do try { repaint(); Thread.sleep(50L); } catch (InterruptedException ex) 此处多了“;” ，“_” { stop(); } while(true); } public void start() { if(m_NAMI2D==null) { m_NAMI2D=new Thread(this); m_NAMI2D.start(); } } public void stop() { if (m_NAMI2D !=null) { m_NAMI2D.stop(); 此处m_NA M I2D写成了m_NA N I2D m_NAMI2D=null; } } public void update(Graphics g) { paint(g); 此处paint写成了pain } } 欢迎到我的学习日志一起学习，讨论问题。 jink2005.blog.sohu/

public class ChangeNum{ private String ch_Char; private String [] ch_Chars = new String[]{"一","二","三","四","五","六","七","八","九","十"}; void setNum(int num){ if(num<=0 || num>=11){ // Err Info......... } ch_Char = ch_Chars[num-1]; } public String getNum(){ return ch_Char; }}main方法就不用给出了

query

他是hibernate中的一个查询对象的方法

试了半天，终于可以啦。你测试一下吧<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"><HTML> <HEAD> <TITLE> New Document </TITLE> <META NAME="Generator" CONTENT="EditPlus"> <META NAME="Author" CONTENT=""> <META NAME="Keywords" CONTENT=""> <META NAME="Description" CONTENT=""> </HEAD> <script language="javascript" type="text/javascript"> function expandIt(el) { var obj = eval("sub" + el); var ocj = eval("main" + el); if (obj.style.display == "none") { obj.style.display = "block";//显示子菜单 ocj.style.backgroundImage = "url(/user/skin/fold_2.gif)";//替换样式 }else { obj.style.display = "none"; ocj.style.backgroundImage = "url(/user/skin/fold_1.gif)";//替换样式 } }</script> <BODY><img src="1.gif"><div class="main1" id="main1" onclick="expandIt(1)">menu1</div><ul class="sub" id="sub1" style="display:none"><li><a href="1" target="Main">sub1</a></li><li><a href="1" target="Main">sub2</a></li><li><a href="1" target="Main">sub3</a></li></ul><div class="main2" id="main2" onclick="expandIt(2)">menu1</div><ul class="sub" id="sub2" style="display:none"><li><a href="1" target="Main">sub1</a></li><li><a href="1" target="Main">sub2</a></li><li><a href="1" target="Main">sub3</a></li></ul> </BODY></HTML>

可以，请参考如下网站的方法：http://blog.csdn.net/luoshengsha/archive/2008/04/22/2314490.aspx

您应该检查启动器的设置，看看Java的路径有没有选对

bind，是绑定一个本地的端口，listen是侦听一个远程的连接端口

可以使用父类的信息,因为有些方法子类被重写...

<!DOCTYPE html><html><head><meta charset="utf-8" /><title>testing</title><script type="text/javascript"> function addLoadEvent (func) { var ool = window.onload; if (typeof window.onload != "function") { window.onload = func; }

F盘下面有隐藏的自动运行文件，双击打开F盘的时候就会运行，感觉有点儿像是病毒。 显示所有F盘下的文件，将该文件删除，应该就可以了。 最好杀个毒。

redis不支持php的多维数组的存取。解决办法是：如有要用redis存多维数组，可以把数组json_encode转换成json各式数据，以string类型的方式存储。读取的时候再json_decode回来。这样就可以直接关闭了。

RadioButton 单选按钮

这个貌似是 windows media player吧=，你下一个最新的装上试试呢。

将字符串转换成byte数组String.getBytes()，然后放进一个ByteArrayInputStream输入流中即可存入BLOB字段中PreparedStatement.setBlob(int parameterIndex, InputStream inputStream)

要看写的Blob类型是什么是不是只的boolean类型还是声明为Boolean的类jdk1.4情况下java里有基本类型的boolean和Boolean的包装类。两者是有区别的。至于什么区别，我想楼主应该多看看书。Blooean的声明的变量是引用类型。这个引用将指向一个对象。该对象可以为空。例如：Boolean b = null;System.out.println(b)；打印的结果是 null；当然如果声明为基本类型,打印结果默认是false的，例如：boolean b ;System.out.println(b);打印的结果是falsejdk5.0的情况没做测试结果不清楚。估计结果和上面是一样的。但是因为在jdk5.0的情况下包装类对象和基本类型似乎可以互相直接转化例如：int i = new Integer(5);这种语句在1.4情况下编译不过的，似乎5.0就可以。所以5.0以后的情况不确定

Blob...好像不是常用类型，是自定义的吧。好吧，最简单的方法。假设已知File类型的file1。List testList=new ArrayList();testList.add(file1);Blob blob=(Blob)testList.get(0);如果可以强转的话，以上代码均有效。换句话说只要Blob是File类型的子类以上代码就有效，否则报错，无法强转。

java基本类型中没有blob类型，应该是自定义的一个类。

java基本类型中没有blob类型，应该是自定义的一个类。

用byte类型

Blob...好像不是常用类型，是自定义的吧。好吧，最简单的方法。假设已知File类型的file1。List testList=new ArrayList();testList.add(file1);Blob blob=(Blob)testList.get(0);如果可以强转的话，以上代码均有效。换句话说只要Blob是File类型的子类以上代码就有效，否则报错，无法强转。

/** * Title: BlobPros.java * Project: test * Description: 把图片存入mysql中的blob字段，并取出 * Call Module: mtools数据库中的tmp表 * File: C:downloadsluozsh.jpg * Copyright: Copyright (c) 2003-2003 * Company: uniware * Create Date: 2002.12.5 * @Author: ChenQH * @version 1.0 版本* * * Revision history * Name Date Description * ---- ---- ----------- * Chenqh 2003.12.5 对图片进行存取 * * note: 要把数据库中的Blob字段设为longblob * */ //package com.uniware; import java.io.*; import java.util.*; import java.sql.*; public class BlobPros { private static final String URL = "jdbc:mysql://10.144.123.63:3306/mtools?user=wind&password=123&useUnicode=true"; private Connection conn = null; private PreparedStatement pstmt = null; private ResultSet rs = null; private File file = null; public BlobPros() { } /** * 向数据库中插入一个新的BLOB对象(图片) * @param infile 要输入的数据文件 * @throws java.lang.Exception */ public void blobInsert(String infile) throws Exception { FileInputStream fis = null; try { Class.forName("org.gjt.mm.mysql.Driver").newInstance(); conn = DriverManager.getConnection(URL); file = new File(infile); fis = new FileInputStream(file); //InputStream fis = new FileInputStream(infile); pstmt = conn.prepareStatement("insert into tmp(descs,pic) values(?,?)"); pstmt.setString(1,file.getName()); //把传过来的第一个参数设为文件名 //pstmt.setBinaryStream(2,fis,(int)file.length()); //这种方法原理上会丢数据，因为file.length()返回的是long型 pstmt.setBinaryStream(2,fis,fis.available()); //第二个参数为文件的内容 pstmt.executeUpdate(); } catch(Exception ex) { System.out.println("[blobInsert error : ]" + ex.toString()); } finally { //关闭所打开的对像// pstmt.close(); fis.close(); conn.close(); } } /** * 从数据库中读出BLOB对象 * @param outfile 输出的数据文件 * @param picID 要取的图片在数据库中的ID * @throws java.lang.Exception */ public void blobRead(String outfile,int picID) throws Exception { FileOutputStream fos = null; InputStream is = null; byte[] Buffer = new byte[4096]; try { Class.forName("org.gjt.mm.mysql.Driver").newInstance(); conn = DriverManager.getConnection(URL); pstmt = conn.prepareStatement("select pic from tmp where id=?"); pstmt.setInt(1,picID); //传入要取的图片的ID rs = pstmt.executeQuery(); rs.next(); file = new File(outfile); if(!file.exists()) { file.createNewFile(); //如果文件不存在，则创建 } fos = new FileOutputStream(file); is = rs.getBinaryStream("pic"); int size = 0; /* while(size != -1) { size = is.read(Buffer); //从数据库中一段一段的读出数据 //System.out.println(size); if(size != -1) //-1表示读到了文件末 fos.write(Buffer,0,size); } */ while((size = is.read(Buffer)) != -1) { //System.out.println(size); fos.write(Buffer,0,size); } } catch(Exception e) { System.out.println("[OutPutFile error : ]" + e.getMessage()); } finally { //关闭用到的资源 fos.close(); rs.close(); pstmt.close(); conn.close(); } } public static void main(String[] args) { try { BlobPros blob = new BlobPros(); //blob.blobInsert("C:Downloadsluozsh1.jpg"); blob.blobRead("c:/downloads/1.jpg",47); } catch(Exception e) { System.out.println("[Main func error: ]" + e.getMessage()); } } }

spark map flatMap flatMapToPair mapPartitions 的区别和用途 map: 对RDD每个元素转换 flatMap: 对RDD每个元素转换,

spark map flatMap flatMapToPair mapPartitions 的区别和用途 map: 对RDD每个元素转换 flatMap: 对RDD每个元素转换,

spark map flatMap flatMapToPair mapPartitions 的区别和用途 map: 对RDD每个元素转换 flatMap: 对RDD每个元素转换,

spark map flatMap flatMapToPair mapPartitions 的区别和用途 map: 对RDD每个元素转换 flatMap: 对RDD每个元素转换,

map使用在一对一的转换，flatMap使用在一对多的转换，比如学生和学号是一对一，我们就用map，学生和所选课程是一对多，我们就用flatMap

BLOCKED是指线程正在等待获取锁；WAITING是指线程正在等待其他线程发来的通知（notify），收到通知后，可能会顺序向后执行（RUNNABLE），也可能会再次获取锁，进而被阻塞住（BLOCKED）

那个啥，你确定你的程序没有问题。 你的employee.id在employe里边都没有给他赋值。还有就是第二个类中间的括起来的那段代码是什么意思的，不是方法来的。

http://zhidao.baidu.com/question/217432296.html参考一下吧~

Java程序向数据库中插入数据，代码如下：//首先创建数据库，(aess,oracle,mysql,sqlsever)其中之一，其中aess,sqlsever需要配置数据源(odbc);//然后再eclipse中创建类(ConnDb,Test，TestBean)ConnDb功能为连接数据库，查询，插入，删除，修改数据的类，Test为含有main方法的测试类，TestBean为数据表中的字段属性及set,get方法//以下是ConnDb代码：packagedb;importjava.sql.Connection;importjava.sql.;importjava.sql.ResultSet;importjava.sql.;importjava.sql.Statement;importjava.util.ArrayList;publicclassConnDb{publicConnectionstartConn(Connectionconn){try{Class.forName("sun.jdbc.odbc.");conn=.("jdbc:odbc:数据库","用户名","密码");}catch(Exceptione){System.out.println("连接数据库时出现错误");}returnconn;}publicArrayList(Stringsql){Connectionconn=null;Statementstmt=null;ResultSetrs=null;ArrayListlist=newArrayList();try{conn=startConn(conn);stmt=conn.();rs=stmt.(sql);//sql为sql语句例如"select*from表名"，从main方法中传进来，这里用的是ArrayList类将查询结果存储起来while(rs.next()){TestBeantb=newTestBean();tb.setTid(rs.getString("tid"));tb.setTname(rs.getString("tname"));tb.setTinfo(rs.getString("tinfo"));list.add(tb);}}catch(e){//TODOAuto-generatedcatchblocke.();}finally{closeConn(rs,stmt,conn);}returnlist;}publicvoid(Stringsql){Connectionconn=null;Statementstmt=null;try{conn=startConn(conn);stmt=conn.();stmt.(sql);}catch(e){System.out.println("修改，插入或者删除数据库数据时发生错误!");}finally{closeConn(stmt,conn);}}publicvoidcloseConn(ResultSetrs,Statementstmt,Connectionconn){try{if(rs!=null){rs.close();}if(stmt!=null){stmt.close();}if(conn!=null){conn.close();}}catch(e){//TODOAuto-generatedcatchblockSystem.out.println("关闭数据库的时候发生错误!");}}publicvoidcloseConn(Statementstmt,Connectionconn){try{if(stmt!=null){stmt.close();}if(conn!=null){conn.close();}}catch(e){//TODOAuto-generatedcatchblockSystem.out.println("关闭数据库的时候发生错误!");}}}

产生随机数,没有限制范围Randomrand=newRandom();取出指定范围数据intnum=rand.nextInt();打印值System.out.Println(num);依次类推

Random类在java.util.Random而random方法在java.lang.Math.random();java.long不用引用，用Math.random();可以引用

random随机数的范围是类似于数学上的这种[ )左包含右不包含的区间，要达到满足于题意的数字自然要加一

本质上其实没什么区别，Math类的random方法其实也是调用了Random类的nextDouble方法。

此类的实例用于生成伪随机数流.如果用相同的种子创建两个 Random 实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。为了保证此属性的实现，为类 Random 指定了特定的算法。为了 Java 代码的完全可移植性，Java 实现必须让类 Random 使用此处所示的所有算法。但是允许 Random 类的子类使用其他算法，只要其符合所有方法的常规协定即可。 Random 类实现的算法使用一个 protected 实用工具方法，每次调用它最多可提供 32 个伪随机生成的位。很多应用程序会发现 Math.random() 方法更易于使用方法摘要 protected int next(int bits) 生成下一个伪随机数。 boolean nextBoolean() 返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 boolean 值。 void nextBytes(byte[] bytes) 生成随机字节并将其置于用户提供的 byte 数组中。 double nextDouble() 返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 double 值。 float nextFloat() 返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 float 值。 double nextGaussian() 返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的 double 值，其平均值是 0.0，标准差是 1.0。 int nextInt() 返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。 int nextInt(int n) 返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。 long nextLong() 返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值。 void setSeed(long seed) 使用单个 long 种子设置此随机数生成器的种子。

int num=(int)(Math.random()*4);PS:Math.radom()*4;返回的是0~3，不包括4。

　　Random()函数能够返回带正号的double值，该值大于等于0.0且小于1.0，即取值范围是[0.0,1.0)的左闭右开区间，返回值是一个伪随机选择的数，在该范围内（近似）均匀分布。

Random类中实现的随机算法是伪随机，也就是有规则的随机。在进行随机时，随机算法的起源数字称为种子数(seed)，在种子数的基础上进行一定的变换，从而产生需要的随机数字。相同种子数的Random对象，相同次数生成的随机数字是完全相同的。也就是说，两个种子数相同的Random对象，第一次生成的随机数字完全相同，第二次生成的随机数字也完全相同。这点在生成多个随机数字时需要特别注意。下面介绍一下Random类的使用，以及如何生成指定区间的随机数组以及实现程序中要求的几率。1、Random对象的生成 Random类包含两个构造方法，下面依次进行介绍： a、public Random()该构造方法使用一个和当前系统时间对应的相对时间有关的数字作为种子数，然后使用这个种子数构造Random对象。 b、public Random(long seed)该构造方法可以通过制定一个种子数进行创建。示例代码：Random r = new Random();Random r1 = new Random(10);再次强调：种子数只是随机算法的起源数字，和生成的随机数字的区间无关。2、Random类中的常用方法Random类中的方法比较简单，每个方法的功能也很容易理解。需要说明的是，Random类中各方法生成的随机数字都是均匀分布的，也就是说区间内部的数字生成的几率是均等的。下面对这些方法做一下基本的介绍：a、public boolean nextBoolean()该方法的作用是生成一个随机的boolean值，生成true和false的值几率相等，也就是都是50%的几率。b、public double nextDouble()该方法的作用是生成一个随机的double值，数值介于[0,1.0)之间。c、public int nextInt()该方法的作用是生成一个随机的int值，该值介于int的区间，也就是-231到231-1之间。如果需要生成指定区间的int值，则需要进行一定的数学变换，具体可以参看下面的使用示例中的代码。d、public int nextInt(int n)该方法的作用是生成一个随机的int值，该值介于[0,n)的区间，也就是0到n之间的随机int值，包含0而不包含n。如果想生成指定区间的int值，也需要进行一定的数学变换，具体可以参看下面的使用示例中的代码。e、public void setSeed(long seed)该方法的作用是重新设置Random对象中的种子数。设置完种子数以后的Random对象和相同种子数使用new关键字创建出的Random对象相同。3、Random类使用示例使用Random类，一般是生成指定区间的随机数字，下面就一一介绍如何生成对应区间的随机数字。以下生成随机数的代码均使用以下Random对象r进行生成：Random r = new Random();a、生成[0,1.0)区间的小数 double d1 = r.nextDouble();直接使用nextDouble方法获得。b、生成[0,5.0)区间的小数double d2 = r.nextDouble() * 5;因为nextDouble方法生成的数字区间是[0,1.0)，将该区间扩大5倍即是要求的区间。同理，生成[0,d)区间的随机小数，d为任意正的小数，则只需要将nextDouble方法的返回值乘以d即可。c、生成[1,2.5)区间的小数 double d3 = r.nextDouble() * 1.5 + 1;生成[1,2.5)区间的随机小数，则只需要首先生成[0,1.5)区间的随机数字，然后将生成的随机数区间加1即可。同理，生成任意非从0开始的小数区间[d1,d2)范围的随机数字(其中d1不等于0)，则只需要首先生成[0,d2-d1)区间的随机数字，然后将生成的随机数字区间加上d1即可。d、生成任意整数int n1 = r.nextInt();直接使用nextInt方法即可。e、生成[0,10)区间的整数int n2 = r.nextInt(10);n2 = Math.abs(r.nextInt() % 10);以上两行代码均可生成[0,10)区间的整数。第一种实现使用Random类中的nextInt(int n)方法直接实现。第二种实现中，首先调用nextInt()方法生成一个任意的int数字，该数字和10取余以后生成的数字区间为(-10,10)，然后再对该区间求绝对值，则得到的区间就是[0,10)了。同理，生成任意[0,n)区间的随机整数，都可以使用如下代码：int n2 = r.nextInt(n);n2 = Math.abs(r.nextInt() % n);f、生成[0,10]区间的整数int n3 = r.nextInt(11);n3 = Math.abs(r.nextInt() % 11);相对于整数区间，[0,10]区间和[0,11)区间等价，所以即生成[0,11)区间的整数。g、生成[-3,15)区间的整数int n4 = r.nextInt(18) - 3;n4 = Math.abs(r.nextInt() % 18) - 3;生成非从0开始区间的随机整数，可以参看上面非从0开始的小数区间实现原理的说明。

Random()默认的seed为当前系统时间即：System.currentTimeMillis区别：Random()调用nextXXX()方法产生的随机数，随着每次运行都不同；Random(longseed)不变

在Java的API帮助文档中，Random函数功能的描述：1、java.util.Random类中实现的随机算法是伪随机，也就是有规则的随机，所谓有规则的就是在给定种(seed)的区间内随机生成数字；2、相同种子数的Random对象，相同次数生成的随机数字是完全相同的；3、Random类中各方法生成的随机数字都是均匀分布的，也就是说区间内部的数字生成的几率均等。扩展资料：Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等语言特点：1.简单性：Java看起来设计得很像C++，但是为了使语言小和容易熟悉，设计者们把C++语言中许多可用的特征去掉了，这些特征是一般程序员很少使用的。例如，Java不支持go to语句，代之以提供break和continue语句以及异常处理。Java还剔除了C++的操作符过载（overload）和多继承特征，并且不使用主文件，免去了预处理程序。因为Java没有结构，数组和串都是对象，所以不需要指针。Java能够自动处理对象的引用和间接引用，实现自动的无用单元收集，使用户不必为存储管理问题烦恼，能更多的时间和精力花在研发上。2.面向对象：Java是一个面向对象的语言。对程序员来说，这意味着要注意应中的数据和操纵数据的方法（method），而不是严格地用过程来思考。在一个面向对象的系统中，类（class）是数据和操作数据的方法的集合。数据和方法一起描述对象（object）的状态和行为。每一对象是其状态和行为的封装。类是按一定体系和层次安排的，使得子类可以从超类继承行为。在这个类层次体系中有一个根类，它是具有一般行为的类。Java程序是用类来组织的。Java还包括一个类的扩展集合，分别组成各种程序包（Package），用户可以在自己的程序中使用。例如，Java提供产生图形用户接口部件的类（java.awt包），这里awt是抽象窗口工具集（abstract windowing toolkit）的缩写，处理输入输出的类（java.io包）和支持网络功能的类（java.net包）。3.分布性：Java设计成支持在网络上应用，它是分布式语言。Java既支持各种层次的网络连接，又以Socket类支持可靠的流（stream）网络连接，所以用户可以产生分布式的客户机和服务器。网络变成软件应用的分布运载工具。Java程序只要编写一次，就可到处运行。4.编译和解释性：Java编译程序生成字节码（byte-code），而不是通常的机器码。Java字节码提供对体系结构中性的目标文件格式，代码设计成可有效地传送程序到多个平台。Java程序可以在任何实现了Java解释程序和运行系统（run-time system）的系统上运行。在一个解释性的环境中，程序开发的标准“链接”阶段大大消失了。如果说Java还有一个链接阶段，它只是把新类装进环境的过程，它是增量式的、轻量级的过程。因此，Java支持快速原型和容易试验，它将导致快速程序开发。这是一个与传统的、耗时的“编译、链接和测试”形成鲜明对比的精巧的开发过程。参考资料：百度百科-java

你会被鄙视的 又到一年答辩论文时 不会你就拿这东西当论文吧！？？？

这是控制元素失去焦点的方法

当你按下键盘的键时，如果控件具有焦点，那么键盘动作就会触发这个控件的相应动作；如果没有焦点呢，你再怎么操作，这个控件也不会相应动作。

不好意思帮不上你了

用VC做吧

http://www.oschina.net/code/snippet_105887_8300

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class three extends JFrame implements ActionListener{ private JPanel jPanel1,jPanel2; private JTextField resultField; private JButton s1,s2,s3,s4,s5,s6,s7,s8,s9,s0,b1,b2,b3,b4,f1,f2; private boolean end,add,sub,mul,div; private String str; private double num1,num2;public three(){ super("计算器"); setSize(300,240); Container con=getContentPane(); con.setLayout(new BorderLayout()); jPanel1=new JPanel(); jPanel1.setLayout(new GridLayout(1,1)); jPanel2=new JPanel(); jPanel2.setLayout(new GridLayout(4,4)); resultField=new JTextField("0"); jPanel1.add(resultField); con.add(jPanel1,BorderLayout.NORTH); s1=new JButton(" 1 "); s1.addActionListener(this); s2=new JButton(" 2 "); s2.addActionListener(this); s3=new JButton(" 3 "); s3.addActionListener(this); s4=new JButton(" 4 "); s4.addActionListener(this); s5=new JButton(" 5 "); s5.addActionListener(this); s6=new JButton(" 6 "); s6.addActionListener(this); s7=new JButton(" 7 "); s7.addActionListener(this); s8=new JButton(" 8 "); s8.addActionListener(this); s9=new JButton(" 9 "); s9.addActionListener(this); s0=new JButton(" 0 "); s0.addActionListener(this); b1=new JButton(" + "); b1.addActionListener(this); b2=new JButton(" - "); b2.addActionListener(this); b3=new JButton(" * "); b3.addActionListener(this); b4=new JButton(" / "); b4.addActionListener(this); f1=new JButton(" . "); f1.addActionListener(this); f2=new JButton(" = "); f2.addActionListener(this); jPanel2.add(s1); jPanel2.add(s2); jPanel2.add(s3); jPanel2.add(b1); jPanel2.add(s4); jPanel2.add(s5); jPanel2.add(s6); jPanel2.add(b2); jPanel2.add(s7); jPanel2.add(s8); jPanel2.add(s9); jPanel2.add(b3); jPanel2.add(s0); jPanel2.add(f1); jPanel2.add(f2); jPanel2.add(b4); con.add(jPanel2,BorderLayout.CENTER); }public void num(int i){ String s = null; s=String.valueOf(i); if(end){ //如果数字输入结束，则将文本框置零，重新输入 resultField.setText("0"); end=false; } if((resultField.getText()).equals("0")){ //如果文本框的内容为零，则覆盖文本框的内容 resultField.setText(s); } else{ //如果文本框的内容不为零，则在内容后面添加数字 str = resultField.getText() + s; resultField.setText(str); } }public void actionPerformed(ActionEvent e){ //数字事件 if(e.getSource()==s1) num(1); else if(e.getSource()==s2) num(2); else if(e.getSource()==s3) num(3); else if(e.getSource()==s4) num(4); else if(e.getSource()==s5) num(5); else if(e.getSource()==s6) num(6); else if(e.getSource()==s7) num(7); else if(e.getSource()==s8) num(8); else if(e.getSource()==s9) num(9); else if(e.getSource()==s0) num(0); //符号事件 else if(e.getSource()==b1) sign(1); else if(e.getSource()==b2) sign(2); else if(e.getSource()==b3) sign(3); else if(e.getSource()==b4) sign(4); //等号 else if(e.getSource()==f1){ str=resultField.getText(); if(str.indexOf(".")<=1){ str+="."; resultField.setText(str); } } else if(e.getSource()==f2){ num2=Double.parseDouble(resultField.getText()); if(add){ num1=num1 + num2;} else if(sub){ num1=num1 - num2;} else if(mul){ num1=num1 * num2;} else if(div){ num1=num1 / num2;} resultField.setText(String.valueOf(num1)); end=true; } }public void sign(int s){ if(s==1){ add=true; sub=false; mul=false; div=false; } else if(s==2){ add=false; sub=true; mul=false; div=false; } else if(s==3){ add=false; sub=false; mul=true; div=false; } else if(s==4){ add=false; sub=false; mul=false; div=true; } num1=Double.parseDouble(resultField.getText()); end=true; } public static void main(String[] args){ three th1=new three(); th1.show(); } }

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; /** * 我的计算器。Cheshi 继承于 JFrame，是计算器的界面 c*/ public class Cheshi extends JFrame { 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 Cheshi(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()); Cheshi frame = new Cheshi("我的计算器"); frame.setVisible(true); // 在桌面上显示窗体 } } /** * 计算器核心逻辑。这个逻辑只能处理 1~2 个数的运算。 */ class CalculatorCore { private String displayText = "0"; // 要显示的文本 boolean reset = true; private BigDecimal number1, number2; private String operator; private HashMap<String, Operator> operators = new HashMap<String, Operator>(); private HashMap<String, Processor> processors = new HashMap<String, 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) { BigDecimal result = oper.process(number1, number2); displayText = result.toString(); } } // 当按下 +-*/ 时（这里也可以扩展成其他中间操作符） 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 { displayText += command; } reset = false; } // 运算符处理接口 interface Operator { BigDecimal process(BigDecimal number1, BigDecimal number2); } // 按钮处理接口 interface Processor { void calculate(String command); } }

\表示转义反斜杠，常用在正则表达式。"\."表示转义点号，将.视为正常的标点符号.而不是正则表达式的.(正则表达式.表示任意字符)能不能去掉得看你自己的代码了。

package boom;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 MyCalculator 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 MyCalculator(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()); MyCalculator frame = new MyCalculator("我的计算器"); frame.setVisible(true); // 在桌面上显示窗体 }}/** * 计算器核心逻辑。这个逻辑只能处理 1~2 个数的运算。 */class CalculatorCore { private String displayText = "0"; // 要显示的文本 boolean reset = true; private BigDecimal number1, number2; private String operator; private HashMap<String, Operator> operators = new HashMap<String, Operator>();private HashMap<String, Processor> processors = new HashMap<String, 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) { BigDecimal result = oper.process(number1, number2); displayText = result.toString(); } } // 当按下 +-*/ 时（这里也可以扩展成其他中间操作符） 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 { displayText += command; } reset = false; } // 运算符处理接口 interface Operator { BigDecimal process(BigDecimal number1, BigDecimal number2); } // 按钮处理接口 interface Processor { void calculate(String command); }}

用e.printStackTrace();如果你是说你程序中的用到的堆栈，可以在finally｛｝块中把堆栈的内容输出来。StackTrace ss = new StackTrace(true);String flName = ss.GetFrame(1).GetFileName();// GetMethod().DeclaringType;int lineNo = ss.GetFrame(1).GetFileLineNumber();String methodName = ss.GetFrame(1).GetMethod().Name;这是 C# 的调用栈上的内容java 中也有一个，StackTraceElement calledSte = getCallStackTraceElement();int lineNo = calledSte.getLineNumber();String className = calledSte.getClassName();String methodName = calledSte.getMethodName();

这要从操作系统里进程的内存结构说起了。。。下图是linux 中一个进程的虚拟内存分布：gt;图中0号地址在最下边，越往上内存地址越大。以32位地址操作系统为例，一个进程可拥有的虚拟内存地址范围为0-2^32。分为两部分，一部分留给kernel使用(kernel virtual memory)，剩下的是进程本身使用， 即图中的process virtual memory。普通Java 程序使用的就是process virtual memory.上图中最顶端的一部分内存叫做user stack. 这就是题目问的 stack. 中间有个 runtime heap。就是题目中的heap. 他们的名字和数据结构里的stack 和 heap 几乎每啥关系。注意在上图中，stack 是向下生长的; heap是向上生长的。当程序进行函数调用时，每个函数都在stack上有一个 call frame。比如对于以下程序，public void foo(){//do something...println("haha"); // <<<=== 在这儿设置breakpoint 1}public void bar(){foo();}main(){bar();println("hahaha"); // <<<=== 在这儿设置 breakpoint 2}当程序运行到breakponit1时，user stack 里会有三个frame|| main 函数的 frame－－－－－－－－－－－－－－－－－－－|| bar 函数的 frame－－－－－－－－－－－－－－－－－－－<<<=== %ebp|| foo 函数的 frame－－－－－－－－－－－－－－－－－－－ <<<===%esp其中 esp 和 ebp 都是寄存器。 esp 指向stack 的顶（因为stack 向下生长，esp会向下走）; ebp 指向当前frame的边界。当程序继续执行到brekapoing 2的时候stack 大概是这样的:

提供思路：1： 用Java对这些方法重写2： 使用JNI，调用C++代码

对于进程最直观的感受应该就是“windows任务管理器”中的进程管理：（计算机原理课上的记忆已经快要模糊了，简单理解一下）：一个进程就是一个“执行中的程序”，是程序在计算机上的一次运行活动。程序要运行，系统就在内存中为该程序分配一块独立的内存空间，载入程序代码和资源进行执行。程序运行期间该内存空间不能被其他进程直接访问。系统以进程为基本单位进行系统资源的调度和分配。何为线程?线程是进程内一次具体的执行任务。程序的执行具体是通过线程来完成的，所以一个进程中至少有一个线程。回忆一下 HelloWrold 程序中main方法的执行，其实这时候，Java虚拟机会开启一个名为“main”的线程来执行程序代码。一个进程可以包含多个线程，这些线程共享数据空间和资源，但又分别拥有各自的执行堆栈和程序计数器。线程是CPU调度的基本单位。多线程一个进程包含了多个线程，自然就叫做多线程。拥有多个线程就可以让程序看起来可以“同时”处理多个任务，为什么是看起来呢?因为CPU也分身乏术，只能让你这个线程执行一会儿，好了你歇着，再让另一个线程执行一会儿，下次轮到你的时候你再继续执行。这里的“一会儿”实际上时间非常短，感觉上就是多个任务“同时”在执行。CPU就这样不停的切来切去…既然CPU一次也只能执行一个线程，为什么要使用多线程呢?当然是为了充分利用CPU资源。一个线程执行过程中不可能每时每刻都在占用CPU，CPU歇着的时候我们就可以让它切过来执行其他的线程。Java中的多线程Java中启用多线程有两种方式：①继承Thread类；②实现Runnable接口。There are two ways to create a new thread of execution. One is to declare a class to be a subclass of Thread. This subclass should override the run method of class Thread. An instance of the subclass can then be allocated and started.The other way to create a thread is to declare a class that implements the Runnable interface. That class then implements the run method. An instance of the class can then be allocated, passed as an argument when creating Thread, and started. 继承Thread类创建一个类，继承java.lang.Thread，并覆写Thread类的run()方法，该类的实例就可以作为一个线程对象被开启。/*** Dog类，继承了Thread类* @author lt*/class Dog extends Thread {/** 覆写run()方法，定义该线程需要执行的代码*/@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(i);}}}线程创建好了，怎么让它作为程序的一个独立的线程被执行呢?创建一个该类的实例，并调用start()方法，将开启一个线程，并执行线程类中覆写的run()方法。public class ThreadDemo {public static void main(String[] args) {Dog dog = new Dog();dog.start();}}看不出什么端倪，如果我们直接调用实例的run()方法，执行效果是完全一样的，见上图。public class ThreadDemo {public static void main(String[] args) {Dog dog = new Dog();dog.run();}}如果一切正常，这时候程序中应该有两个线程：一个主线程main，一个新开启的线程。run()方法中的代码究竟是哪个线程执行的呢?Java程序中，一个线程开启会被分配一个线程名：Thread-x，x从0开始。我们可以打印当前线程的线程名，来看看究竟是谁在执行代码。class Dog extends Thread {@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println("当前线程：" + Thread.currentThread().getName() + "---" + i);}}}public class ThreadDemo {public static void main(String[] args) {System.out.println("当前线程：" + Thread.currentThread().getName());Dog dog = new Dog();dog.start();}}可以看到，确实开启了一个新的线程：Thread-0，main()方法的线程名就叫main。同一个实例只能调用一次start()方法开启一次，多次开启，将报java.lang.IllegalThreadStateException异常：我们再创建一个实例，开启第三个线程：public class ThreadDemo {public static void main(String[] args) {System.out.println("当前线程：" + Thread.currentThread().getName());Dog dog = new Dog();Dog dog2 = new Dog();dog.start();dog2.start();}}这时候我们已经能够看到多线程的底层实现原理：CPU切换处理、交替执行的效果了。run和start上面我们直接调用run()方法和调用start()方法的结果一样，现在我们在打印线程名的情况下再来看看：public class ThreadDemo {public static void main(String[] args) {System.out.println("当前线程：" + Thread.currentThread().getName());Dog dog = new Dog();Dog dog2 = new Dog();dog.run();dog2.run();}}可以看到，这时候并没有开启新的线程，main线程直接调用执行了run()方法中的代码。所以start()方法会开启新的线程并在新的线程中执行run()方法中的代码，而run()方法不会开启线程。查看start()的源代码，该方法调用了本地方法 private native void start0();即调用的是操作系统的底层函数：public synchronized void start() {if (threadStatus != 0)throw new IllegalThreadStateException();group.add(this);boolean started = false;try {start0();started = true;} finally {try {if (!started) {group.threadStartFailed(this);}} catch (Throwable ignore) {/* do nothing. If start0 threw a Throwable thenit will be passed up the call stack */}}}private native void start0();实现Runnable接口第二种方式，实现Runnable接口，并覆写接口中的run()方法，这是推荐的也是最常用的方式。Runnable接口定义非常简单，就只有一个抽象的run()方法。//Runnable接口源码public interface Runnable {public abstract void run();}class Dog implements Runnable {@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println("当前线程：" + Thread.currentThread().getName() + "---" + i);}}}这时候的Dog类看起来跟线程什么的毫无关系，也没有了start()方法，怎么样开启一个新的线程呢?直接调用run()方法?想想也不行。这时候我们需要将一个Dog类的实例，作为Thread类的构造函数的参数传入，来创建一个Thread类的实例，并通过该Thread类的实例来调用start()方法从而开启线程。public class ThreadDemo {public static void main(String[] args) {System.out.println("当前线程：" + Thread.currentThread().getName());Dog dog = new Dog();Thread thread = new Thread(dog);thread.start();}}这时候如果要开启第三个线程，需要创建一个新的Thread类的实例，同时传入刚才的Dog类的实例（当然也可以创建一个新的Dog实例）。这时候我们就可以看到跟继承Thread类的方式的区别：多个线程可以共享同一个Dog类的实例。public class ThreadDemo {public static void main(String[] args) {System.out.println("当前线程：" + Thread.currentThread().getName());Dog dog = new Dog();Thread thread = new Thread(dog);Thread thread2 = new Thread(dog);thread.start();thread2.start();}}两种方式的比较继承Thread类的方式有它固有的弊端，因为Java中继承的单一性，继承了Thread类就不能继承其他类了；同时也不符合继承的语义，Dog跟Thread没有直接的父子关系，继承Thread只是为了能拥有一些功能特性。而实现Runnable接口，①避免了单一继承的局限性，②同时更符合面向对象的编程方式，即将线程对象进行单独的封装，③而且实现接口的方式降低了线程对象(Dog)和线程任务(run方法中的代码)的耦合性，④如上面所述，可以使用同一个Dog类的实例来创建并开启多个线程，非常方便的实现资源的共享。实际上Thread类也是实现了Runnable接口。实际开发中多是使用实现Runnable接口的方式。

在JavaScript中，“Uncaught RangeError: Maximum call stack size exceeded”如何解决？而回看二战以来历史，立陶宛明明曾经加入苏联。其成为苏联的一个加盟共和国后，苏联领土包括立陶宛一事，获得了联合国和国际社会的普遍认可。中国科学院院士、中国科学院古脊椎动物与古人类研究所研究员周忠和负责的“克拉通破坏与陆地生物演化”成为2016年首批获得该项资助的三个项目之一。他对《中国新闻周刊》说，该项目经费管理比较宽松，但问题是这种项目太稀缺了，这虽然是一种稳定支持的模式，但本质上仍是一类竞争性很强的项目。庄辞也认为，这类项目支持的比例非常小，仍是面向极少数人，目前竞争已趋白热化。

这个简单，

您好 请问这个问题您解决了吗？我现在也遇到这个问题了

调用时n=50;double s(int n){ int temp=1; dobule sum=0; for(int i=1;i<=n;i++){ sum+=temp*(1/i); temp*=-1; } return sum;}

这个你参考一下。import javax.swing.*; //import javax.swing.event.*; import java.awt.*; import java.awt.event.*; //计算器显示结果的窗体 class Result extends JPanel { JTextField text = new JTextField("0"); //text先是输入和结果 Result() { text.setHorizontalAlignment(SwingConstants.RIGHT); //讲输入的数字或得到的结果在text的右边显示 text.setEnabled(false); //文本框不能编辑 setLayout(new BorderLayout()); //设定布局管理器边框布局 add(text, BorderLayout.CENTER); //text放置在窗体的中间 } } //计算器数字按钮定义面板 class Number_Key extends JPanel { JButton zero = new JButton("0");//数字键0 JButton one = new JButton("1");//数字键1 JButton two = new JButton("2");//数字键2 JButton three = new JButton("3");//数字键3 JButton four = new JButton("4");//数字键4 JButton five = new JButton("5");//数字键5 JButton six = new JButton("6");//数字键6 JButton seven = new JButton("7");//数字键7 JButton eight = new JButton("8");//数字键8 JButton nine = new JButton("9");//数字键9 JButton plus = new JButton("+"); JButton sub = new JButton("-"); JButton mul = new JButton("*"); JButton div = new JButton("/"); JButton equal = new JButton("="); JButton ce = new JButton("ce");//置零键 JButton point = new JButton("."); JButton tzero = new JButton("00"); Number_Key() { setLayout(new GridLayout(6, 3, 10, 10));//定义布局管理器为网格布局 //添加各个按钮键 add(seven); add(eight); add(nine); add(four); add(five); add(six); add(one); add(two); add(three); add(zero); add(tzero); add(plus); add(sub); add(mul); add(div); add(point); add(equal); add(ce); } } //计算器主类 class sakura extends JFrame implements ActionListener { Result result = new Result();//定义text的面板 Number_Key number_key = new Number_Key();//定义按钮面板 //当点击按钮+、-、*、/时，com = true boolean com = false; //当i=0时说明是我们第一次输入，字符串sum不会累加 int i = 0; //存放text的内容 String sum = ""; //存放点击按钮+、-、*、/之前的数值 double total = 0; //+、-、*、/的代号分别为1，2，3，4 int symbol = 0; sakura() { super("Calculator");//设定标题 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设定关闭窗体时退出程序 JPanel pane = new JPanel();//定义主面板 pane.setLayout(new BorderLayout()); pane.add(result, BorderLayout.NORTH); pane.add(number_key, BorderLayout.SOUTH); number_key.one.addActionListener(this);//对1按钮添加监听事件 number_key.two.addActionListener(this);//对2按钮添加监听事件 number_key.three.addActionListener(this);//对3按钮添加监听事件 number_key.four.addActionListener(this);//对4按钮添加监听事件 number_key.five.addActionListener(this);//对5按钮添加监听事件 number_key.six.addActionListener(this);//对6按钮添加监听事件 number_key.seven.addActionListener(this);//对7按钮添加监听事件 number_key.eight.addActionListener(this);//对8按钮添加监听事件 number_key.nine.addActionListener(this);//对9按钮添加监听事件 number_key.zero.addActionListener(this);//对0按钮添加监听事件 number_key.ce.addActionListener(this);//对置零按钮添加监听事件 number_key.plus.addActionListener(this);//对+按钮添加监听事件 number_key.equal.addActionListener(this);//对=按钮添加监听事件 number_key.sub.addActionListener(this);//对-按钮添加监听事件 number_key.mul.addActionListener(this);//对*按钮添加监听事件 number_key.div.addActionListener(this);//对/按钮添加监听事件 number_key.tzero.addActionListener(this);//对00按钮添加监听事件 number_key.point.addActionListener(this);//对.按钮添加监听事件 setContentPane(pane); pack();//初始化窗体大小为正好盛放所有按钮 } //各个按钮触发的事件 public void actionPerformed(ActionEvent e) { /*如果是点击数字按钮那么先要判断是否在此之前点击了+、-、*、/、=，如果是那么com=true * 如果没有com= false;或者是否点击数字键，如果是i = 1,如果没有 i = 0; **/ if (e.getSource() == number_key.one) { if (com || i == 0) { result.text.setText("1"); com = false; i = 1; } else { sum = result.text.getText(); result.text.setText(sum + "1"); } } else if (e.getSource() == number_key.two) { if (com || i == 0) { result.text.setText("2"); com = false; i = 1; } else { sum = result.text.getText(); result.text.setText(sum + "2"); } } else if (e.getSource() == number_key.three) { if (com || i == 0) { result.text.setText("3"); com = false; i = 1; } else { sum = result.text.getText(); result.text.setText(sum + "3"); } } else if (e.getSource() == number_key.four) { if (com || i == 0) { result.text.setText("4"); com = false; i = 1; } else { sum = result.text.getText(); result.text.setText(sum + "4"); } } else if (e.getSource() == number_key.five) { if (com || i == 0) { result.text.setText("5"); com = false; i = 1; } else { sum = result.text.getText(); result.text.setText(sum + "5"); } } else if (e.getSource() == number_key.six) { if (com || i == 0) { result.text.setText("6"); com = false; i = 1; } else { sum = result.text.getText(); result.text.setText(sum + "6"); } } else if (e.getSource() == number_key.seven) { if (com || i == 0) { result.text.setText("7"); com = false; i = 1; } else { sum = result.text.getText(); result.text.setText(sum + "7"); } } else if (e.getSource() == number_key.eight) { if (com || i == 0) { result.text.setText("8"); com = false; i = 1; } else { sum = result.text.getText(); result.text.setText(sum + "8"); } } else if (e.getSource() == number_key.nine) { if (com || i == 0) { result.text.setText("9"); com = false; i = 1; } else { sum = result.text.getText(); result.text.setText(sum + "9"); } } /*对于0这个按钮有一定的说法，在我的程序里不会出现如00000这样的情况，我加了判断条件就是 * 如果text中的数值=0就要判断在这个数值中是否有.存在?如果有那么就在原来数值基础之上添 * 加0;否则保持原来的数值不变 */ else if (e.getSource() == number_key.zero) { if (com || i == 0) { result.text.setText("0"); com = false; i = 1; } else { sum = result.text.getText(); if (Float.parseFloat(sum) > 0 || Float.parseFloat(sum) < 0) { result.text.setText(sum + "0"); } else { if (sum.trim().indexOf(".") == -1) { result.text.setText(sum); } else { result.text.setText(sum + "0"); } } } } else if (e.getSource() == number_key.ce) { result.text.setText("0"); i = 0; com = true; } else if (e.getSource() == number_key.tzero) { if (com || i == 0) { result.text.setText("0"); com = false; i = 1; } else { sum = result.text.getText(); if (Float.parseFloat(sum) > 0 || Float.parseFloat(sum) < 0) { result.text.setText(sum + "00"); } else { if (sum.trim().indexOf(".") == -1) { result.text.setText(sum); } else { result.text.setText(sum + "00"); } } } } /*本程序不会让一个数值中出现2个以上的小数点.具体做法是:判断是否已经存在.存在就不添加, * 不存在就添加. */ else if (e.getSource() == number_key.point) { if (com || i == 0) { result.text.setText("0."); com = false; i = 1; } else { sum = result.text.getText(); if (sum.trim().indexOf(".") == -1) { result.text.setText(sum + "."); } else { result.text.setText(sum); } } } //获得点击+之前的数值 else if (e.getSource() == number_key.plus) { com = true; i = 0; total = Double.parseDouble(result.text.getText()); symbol = 1; }//获得点击-之前的数值 else if (e.getSource() == number_key.sub) { com = true; i = 0; total = Double.parseDouble(result.text.getText()); symbol = 2; }//获得点击*之前的数值 else if (e.getSource() == number_key.mul) { com = true; i = 0; total = Double.parseDouble(result.text.getText()); System.out.println(total); symbol = 3; }//获得点击/之前的数值 else if (e.getSource() == number_key.div) { com = true; i = 0; total = Double.parseDouble(result.text.getText()); symbol = 4; } else if (e.getSource() == number_key.equal) { switch (symbol) { case 1 ://计算加法 { double ad = total + Double.parseDouble(result.text.getText()); result.text.setText(ad + ""); i = 0; sum = ""; break; } case 2 ://计算减法 { double ad = total - Double.parseDouble(result.text.getText()); result.text.setText(String.valueOf(ad)); i = 0; sum = ""; break; } case 3 ://计算乘法 { double ad = total * Double.parseDouble(result.text.getText()); result.text.setText(ad + ""); i = 0; sum = ""; break; } case 4 ://计算除法 { double ad = total / Double.parseDouble(result.text.getText()); result.text.setText(ad + ""); i = 0; sum = ""; break; } } System.out.println(com); } } public static void main(String[] args) { sakura ww = new sakura(); ww.setVisible(true) ; } }

helloVoice.speak("（此处应加入要朗读的单词即可读出）");不停调用这个方法，，，，只是换不同的参数去调用

先编译成class文件，然后在你的批处理中使用java命令，注意路径问题java Send_mailjava Send_main_out_excel

先用工具把项目编译了，然后写个bat启动要启动的类java apauseok了。简单实用，注意。要把所用到的jar包放到JDK的jre的lib里的ext中，不然你连接数据库会出错的。C:Program FilesJavajdk1.6.0_04jrelibext

异常类:public class AgeException extends Exception { public AgeException() { super(); } public AgeException(String arg0, Throwable arg1) { super(arg0, arg1); } public AgeException(String arg0) { super(arg0); } public AgeException(Throwable arg0) { super(arg0); }}测试类:public class Test{ public static void main(String[] args) throws Exception{ int age = 20; if(age<18||age>80) throw new AgeException("年龄不在18到80的范围内"); }}

要去重复 请改写equals方法

int age=0;age=newAge;这里错了。这里的age重新定义了一个，相当于把成员变量的age覆盖了。去掉int age=0;

没编译错误?