首页 > 工作范文 > 范文大全 >

java线程知识点总结 java线程写法5篇

网友发表时间 2041774

【请您参阅】下面供您参考的“java线程知识点总结 java线程写法5篇”是由阿拉网友精心整理分享的,供您阅读参考之用,希望此例范文对您有所帮助,喜欢就复制下载支持一下小编了!

java线程知识点总结 java线程写法篇1

in the following code, which is the earliest statement, where the object originally held in e, may be garbage collected:

class test {

static void main(string args []){

ee e = new employee(“bob”, 48);

atepay();

n(etails());

= null;

= new employee(“denise”, 36);

atepay();

n(etails());

10.}

11.}

only one:

in the following code, which is the earliest statement, where the object originally held in e, may be garbage collected:

class test {

static void main(string args []){

ee e = new employee(“bob”, 48);

atepay();

n(etails());

= null;

= new employee(“denise”, 36);

atepay();

n(etails());

10.}

11.}

only one:

10

11

7

8

2:exhibit :

class test(e static int j = 0;

e static boolean methodb(int k)( += k;

true;

6.)

static void methoda(int i){

n b:

= i < 10 | methodb(4);

= i < 10 || methodb(8);

12.)

static void main(string args[] }(a(0);

n(j);

17.)

18.)

what is the result?

program prints “0”

program prints “4”

program prints “8”

program prints “12”

3:what is written to the standard output given the following statement:n(4|7);

select the right answer:

4:

select valid identifier of java:

select valid identifier of java:

a.%passwd

_game

c.$charge

5:设有变量说明语句int a=1,b=0;

则执行以下程序段的输出结果为()。

switch(a)

{

case 1:

switch(b)

{

case 0:printf(“**0**”);break;

case 1:printf(“**1**”);break;

}

case 2:printf(“**2**”);break;

}

printf(“ ”);

a.**0**

b.**0****2**

c.**0****1****2**

d.有语法错误

6:in the following pieces of code, which one will compile without any error?

buffer sb1 = “abcd”;

n b = new boolean(“abcd”);

: byte b = 255;

fl = ;

7:

what is the result when you compile and run the following code?

public class throwsdemo

{

static void throwmethod()

{

n(“inside throwmethod.”);

throw new illegalaccessexception(“demo”);

}

public static void main(string args[])

{

try

{

throwmethod();

}

catch(illegalaccessexception e)

{

n(“caught ” + e);

}

}

}

choices:

what is the result when you compile and run the following code?

public class throwsdemo

{

static void throwmethod()

{

n(“inside throwmethod.”);

throw new illegalaccessexception(“demo”);

}

public static void main(string args[])

{

try

{

throwmethod();

}

catch(illegalaccessexception e)

{

n(“caught ” + e);

}

}

}

choices:

ation error

e error

e successfully, nothing is ed by caught:laccessexcption: demo

8:which of the following statements are not legal?

l = 4990;

i = 4l;

d = ;

t = :

give the following java class:

public class example{

public static void main(string args[]){

static int x[] = new int[15];

n(x[5]);

}

}

which statement is corrected?

give the following java class:

public class example{

public static void main(string args[]){

static int x[] = new int[15];

n(x[5]);

}

}

which statement is corrected?

compile, some error will run, some error will is is :下面关于变量及其范围的陈述哪些是错的。

a.实例变量是类的成员变量。

b.实例变量用关键字static声明。

c.在方法中定义的局部变量在该方法被执行时创建

d.局部变量在使用前必须被初始化。

11:

public class x{

public object m(){

object o = new float();//line 3

object [] oa = new object[1];//line 4

oa[0] = o;//line 5

o=null;//line 6

return oa[0];//line 7

}

}

when is the float object, created in line 3,eligible for garbage collection?

public class x{

public object m(){

object o = new float();//line 3

object [] oa = new object[1];//line 4

oa[0] = o;//line 5

o=null;//line 6

return oa[0];//line 7

}

}

when is the float object, created in line 3,eligible for garbage collection?

after line after line 6

after line 7(that is,as the method returns)

in this method

12:

which is the most appropriate code snippet that can be inserted at line 18 in the following code?

(assume that the code is compiled and run with assertions enabled)

.*;

class asserttest

4.{

e hashmap cctld;

asserttest()

8.{

= new hashmap();

(“in”, “india”);

(“uk”, “united kingdom”);

(“au”, “australia”);

13.// more code...14.}

15.// other methods.... string getcountry(string countrycode)

17.{

18.// what should be inserted here?

country =(string)(countrycode);

country;

21.}

22.}

which is the most appropriate code snippet that can be inserted at line 18 in the following code?

(assume that the code is compiled and run with assertions enabled)

.*;

class asserttest

4.{

e hashmap cctld;

asserttest()

8.{

= new hashmap();

(“in”, “india”);

(“uk”, “united kingdom”);

(“au”, “australia”);

13.// more code...14.}

15.// other methods.... string getcountry(string countrycode)

17.{

18.// what should be inserted here?

country =(string)(countrycode);

country;

21.}

22.}

countrycode!= null;

countrycode!= null : “country code can not be null”;

cctld!= null : “no country code data is available”;

cctld : “no country code data is available”;

13:

give the following code:

public class example{

public static void main(string args[]){

int l=0;

do{

n(“doing it for l is:”+l);

}while(—l>0)

n(“finish”);

}

}

which well be output:

give the following code:

public class example{

public static void main(string args[]){

int l=0;

do{

n(“doing it for l is:”+l);

}while(—l>0)

n(“finish”);

}

}

which well be output:

it for l is 3

it for l is 1

it for l is 2

it for l is 0

14:which statements about java code security are not true?

bytecode verifier loads all classes needed for the execution of a ing code is performed by the runtime runtime the bytecodes are loaded, checked and run in an interpreter. class loader adds security by separating the namespaces for the classes of the local file system from those imported from network :a class design requires that a member variable should be accessible only by same package, which modifer word should be used?

ted

modifer

e

16:character流与byte流的区别是

a.每次读入的字节数不同

b.前者带有缓冲,后者没有

c.前者是块读写,后者是字节读写

d.二者没有区别,可以互换使用

简答题

17:找出两个字符串中最大子字符串,如“abractyeyt”,“dgdsaeactyey”的最大子串为“actyet”

18:假设你有一个用1001个整数组成的数组,这些整数是任意排列的,但是你知道所有的整数都在1到1000(包括1000)之间。此外,除一个数字出现两次外,其他所有数字只出现一次。假设你只能对这个数组做一次处理,用一种算法找出重复的那个数字。如果你在运算中使用了辅助的存储方式,那么你能找到不用这种方式的算法吗?

19:到底在哪里使用cascade=“...”?

20:使用tomcat部署应用程序 emoryerror 吗?如何解决的。

21:请写一个java程序实现数据库缓冲池的功能?

22:有200个正整数,且每个数均在1000至9999之间。请编制函数,其函数的功能是:要求按每个数的后三位的大小进行升序排列,然后取出满足此条件的前10个数依次存入数组bb中,如果后三位的数值相等,则按原先的数值进行降序排列。

23:anonymous inner class(匿名内部类)是否可以extends(继承)其它类,是否可以implements(实现)interface(接口)?

24:找出字符串a中包含的字符可以进行的所有不同组合。例如:abccd中,ab,ac,bc,cc,abd等都是可能的组合。

25:下面的代码在绝大部分时间内都运行得很正常,请问在什么情况下会出现问题?问题的根源在哪里?

import .linkedlist;

public class stack {

linkedlist list = new linkedlist();

public synchronized void push(object x){

synchronized(list){

t(x);

notify();

}

}

public synchronized object pop()

throws exception {

synchronized(list){

if(()<= 0){

wait();

}

return last();

}

}

}

本文地址:http:///zuowen/

java线程知识点总结 java线程写法篇2

线程编程方面

60、java中有几种方法可以实现一个线程?用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用?

答:有两种实现方法,分别是继承thread类与实现runnable接口 用synchronized关键字修饰同步方法

反对使用stop(),是因为它不安全。它会解除由线程获取的所有锁定,而且如果对象处于一种不连贯状态,那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候,目标线程会停下来,但却仍然持有在这之前获得的锁定。此时,其他任何线程都不能访问锁定的资源,除非被“挂起”的线程恢复运行。对任何线程来说,如果它们想恢复目标线程,同时又试图使用任何一个锁定的资源,就会造成死锁。所以不应该使用suspend(),而应在自己的thread类中置入一个标志,指出线程应该活动还是挂起。若标志指出线程应该挂起,便用wait()命其进入等待状态。若标志指出线程应当恢复,则用一个notify()重新启动线程。61、sleep()和 wait()有什么区别? 答:sleep是线程类(thread)的方法,导致此线程暂停执行指定时间,给执行机会给其他线程,但是监控状态依然保持,到时后会自动恢复。调用sleep不会释放对象锁。

wait是object类的方法,对此对象调用wait方法导致本线程放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象发出notify方法(或notifyall)后本线程才进入对象锁定池准备获得对象锁进入运行状态。

62、同步和异步有何异同,在什么情况下分别使用他们?举例说明。

答:如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到,或者正在读的数据可能已经被另一个线程写过了,那么这些数据就是共享数据,必须进行同步存取。

当应用程序在对象上调用了一个需要花费很长时间来执行的方法,并且不希望让程序等待方法的返回时,就应该使用异步编程,在很多情况下采用异步途径往往更有效率。63、启动一个线程是用run()还是start()? 答:启动一个线程是调用start()方法,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由jvm调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。

64、当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法? 答:不能,一个对象的一个synchronized方法只能由一个线程访问。

我认为:其他线程可以进入非synchronized方法,但不能进入这个对象的synchronized方法。65、请说出你所知道的线程同步的方法。

答:wait():使一个线程处于等待状态,并且释放所持有的对象的lock。

sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法,调用此方法要捕捉interruptedexception异常。

notify():唤醒一个处于等待状态的线程,注意的是在调用此方法的时候,并不能确切的唤醒某一个等待状态的线程,而是由jvm确定唤醒哪个线程,而且不是按优先级。

allnotity():唤醒所有处入等待状态的线程,注意并不是给所有唤醒线程一个对象的锁,而是让它们竞争。

66、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么? 答:多线程有两种实现方法,分别是继承thread类与实现runnable接口 同步的实现方面有两种,分别是synchronized,wait与notify 67、线程的基本概念、线程的基本状态以及状态之间的关系

答:线程指在程序执行过程中,能够执行程序代码的一个执行单位,每个程序至少都有一个线程,也就是程序本身。

java中的线程有四种状态分别是:运行、就绪、挂起、结束

68、的异同 ? 答:主要相同点:lock能完成synchronized所实现的所有功能

主要不同点:lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁,而lock一定要求程序员手工释放,并且必须在finally从句中释放。

jsp方面

69、forward 和redirect的区别

答:forward是服务器请求资源,服务器直接访问目标地址的url,把那个url的响应内容读取过来,然后把这些内容再发给浏览器,浏览器根本不知道服务器发送的内容是从哪儿来的,所以它的地址栏中还是原来的地址。

redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址,一般来说浏览器会用刚才请求的所有参数重新请求,所以session,request参数都可以获取。70、jsp有哪些内置对象?作用分别是什么?

答:jsp共有以下9种基本内置组件(可与asp的6种内部组件相对应):

request 用户端请求,此请求会包含来自get/post请求的参数

response 网页传回用户端的回应

pagecontext 网页的属性是在这里管理

session 与请求有关的会话期

application servlet 正在执行的内容

out 用来传送回应的输出 config servlet的构架部件

page jsp网页本身

exception 针对错误网页,未捕捉的例外

71、jsp有哪些动作?作用分别是什么? 答:jsp共有以下6种基本动作

jsp:include:在页面被请求的时候引入一个文件。

jsp:usebean:寻找或者实例化一个javabean。

jsp:setproperty:设置javabean的属性。

jsp:getproperty:输出某个javabean的属性。

jsp:forward:把请求转到一个新的页面。

jsp:plugin:根据浏览器类型为java插件生成object或embed标记 72、jsp中动态include与静态include的区别?

答:动态include用jsp:include动作实现

它总是会检查所含文件中的变化,适合用于包含动态页面,并且可以带参数

静态include用include伪码实现,定不会检查所含文件的变化,适用于包含静态页面

<%@ include file=“” %> 73、两种跳转方式分别是什么?有什么区别? 答:有两种,分别为:

前者页面不会转向include所指的页面,只是显示该页的结果,主页面还是原来的页面。执行完后还会回来,相当于函数调用。并且可以带参数.后者完全转向新页面,不会再回来。相当于go to 语句。

74、jsp的内置对象及方法。

答:request表示httpservletrequest对象。它包含了有关浏览器请求的信息,并且提供了几个用于获取cookie, header, 和session数据的有用的方法。

response表示httpservletresponse对象,并提供了几个用于设置送回 浏览器的响应的方法(如cookies,头信息等)

ter的一个实例,并提供了几个方法使你能用于向浏览器回送输出结果。

ntext对象。它是用于方便存取各种范围的名字空间、servlet相关的对象的api,并且包装了通用的servlet相关功能的方法。

ssion对象。session可以存贮用户的状态信息

applicaton tcontext对象。这有助于查找有关servlet引擎和servlet环境的信息

tconfig对象。该对象用于存取servlet实例的初始化参数。page表示从该页面产生的一个servlet实例

servlet方面

75、说一说servlet的生命周期?

答:servlet有良好的生存期的定义,包括加载和实例化、初始化、处理请求以及服务结束。t接口的init,service和destroy方法表达。servlet被服务器实例化后,容器运行其init方法,请求到达时运行其service方法,service方法自动派遣运行与请求对应的doxxx方法(doget,dopost)等,当服务器决定将实例销毁的时候调用其destroy方法。

与cgi的区别在于servlet处于服务器进程中,它通过多线程方式运行其service方法,一个实例可以服务于多个请求,并且其实例一般不会销毁,而cgi对每个请求都产生新的进程,服务完成后就销毁,所以效率上低于servlet。

76、java servlet api中forward()与redirect()的区别?

答:前者仅是容器中控制权的转向,在客户端浏览器地址栏中不会显示出转向后的地址;后者则是完全的跳转,浏览器将会得到跳转的地址,并重新发送请求链接。这样,从浏览器的地址栏中可以看到跳转后的链接地址。所以,前者更加高效,在前者可以满足需要时,尽量使用forward()方法,并且,这样也有助于隐藏实际的链接。在有些情况下,比如,需要跳转到一个其它服务器上的资源,则必须使用sendredirect()方法。77、servlet的基本架构 答:

public class servletname extends httpservlet { public void dopost(httpservletrequest request, httpservletresponse response)throws servletexception, ioexception { } public void doget(httpservletrequest request, httpservletresponse response)throws servletexception, ioexception { } }

78、什么情况下调用doget()和dopost()?

答:jsp页面中的form标签里的method属性为get时调用doget(),为post时调用dopost()。79、servlet的生命周期

答:web容器加载servlet,生命周期开始。通过调用servlet的init()方法进行servlet的初始化。通过调用service()方法实现,根据请求的不同调用不同的do***()方法。结束服务,web容器调用servlet的destroy()方法。

80、如何现实servlet的单线程模式 答:<%@ page isthreadsafe=“false”%> 81、页面间对象传递的方法

答:request,session,application,cookie等

82、jsp和servlet有哪些相同点和不同点,他们之间的联系是什么?

答:jsp是servlet技术的扩展,本质上是servlet的简易方式,更强调应用的外表表达。jsp编译后是“类servlet”。servlet和jsp最主要的不同点在于,servlet的应用逻辑是在java文件中,并且完全从表示层中的html里分离开来。的文件。jsp侧重于视图,servlet主要用于控制逻辑。83、四种会话跟踪技术

答:会话作用域servletsjsp 页面描述

page否是代表与一个页面相关的对象和属性。一个页面由一个编译好的 java servlet 类(可以带有任何的 include 指令,但是没有 include 动作)表示。这既包括 servlet 又包括被编译成 servlet 的 jsp 页面

request是是代表与 web 客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面,涉及多个 web 组件(由于 forward 指令和 include 动作的关系)

session是是代表与用于某个 web 客户机的一个用户体验相关的对象和属性。一个 web 会话可以也经常会跨越多个客户机请求

application是是代表与整个 web 应用程序相关的对象和属性。这实质上是跨越整个 web 应用程序,包括多个页面、请求和会话的一个全局作用域 84、request对象的主要方法 答:

setattribute(string name,object):设置名字为name的request的参数值 getattribute(string name):返回由name指定的属性值

getattributenames():返回request对象所有属性的名字集合,结果是一个枚举的实例 getcookies():返回客户端的所有cookie对象,结果是一个cookie数组 getcharacterencoding():返回请求中的字符编码方式 getcontentlength():返回请求的body的长度

getheader(string name):获得http协议定义的文件头信息 getheaders(string name):返回指定名字的request header的所有值,结果是一个枚举的实例 getheadernames():返回所以request header的名字,结果是一个枚举的实例 getinputstream():返回请求的输入流,用于获得请求中的数据 getmethod():获得客户端向服务器端传送数据的方法

getparameter(string name):获得客户端传送给服务器端的有name指定的参数值

getparameternames():获得客户端传送给服务器端的所有参数的名字,结果是一个枚举的实例 getparametervalues(string name):获得有name指定的参数的所有值 getprotocol():获取客户端向服务器端传送数据所依据的协议名称 getquerystring():获得查询字符串

getrequesturi():获取发出请求字符串的客户端地址 getremoteaddr():获取客户端的ip地址 getremotehost():获取客户端的名字

getsession([boolean create]):返回和请求相关session getservername():获取服务器的名字

getservletpath():获取客户端所请求的脚本文件的路径 getserverport():获取服务器的端口号

removeattribute(string name):删除请求中的一个属性

85、我们在web应用开发过程中经常遇到输出某种编码的字符,如iso8859-1等,如何输出一个某种编码的字符串? 答:

public string translate(string str){ string tempstr = “";try { tempstr = new string(es(”iso-8859-1“), ”gbk");tempstr = ();} catch(exception e){ n(sage());} return tempstr;} 86、servlet执行时一般实现哪几个方法? 答:

public void init(servletconfig config)public servletconfig getservletconfig()public string getservletinfo()public void service(servletrequest request,servletresponse response)public void destroy()

jdbc、jdo方面88、jdo是什么?

87、e的作用?为什么要用?

答:调用该访问返回一个以字符串指定类名的类的对象。答:jdo是java对象持久化的新的规范,为java data object的简称,也是一个用于存取某种数据仓库中的对象的标准化api。jdo提供了透明的对象存储,因此对开发人员来说,存储数据对象完全不需要额外的代码(如jdbc api的使用)。这些繁琐的例行工作已经转移到jdo产品提供商身上,使开发人员解脱出来,从而集中时间和精力在业务逻辑上。另外,jdo很灵活,因为它可以在任何数据底层上运行。jdbc只是面向关系数据库(rdbms)jdo更通用,提供到任何数据底层的存储功能,比如关系数据库、文件、xml以及对象数据库(odbms)等等,使得应用可移植性更强。89、说出数据连接池的工作机制是什么? 答:j2ee服务器启动时会建立一定数量的池连接,并一直维持不少于此数目的池连接。客户端程序需要连接时,池驱动程序会返回一个未使用的池连接并将其表记为忙。如果当前没有空闲连接,池驱动程序就新建一定数量的连接,新建连接的数量有配置参数决定。当使用的池连接调用完成后,池驱动程序将此连接表记为空闲,其他调用就可以使用这个连接。90、jdo是什么? 答:jdo是java对象持久化的新的规范,为java data object的简称,也是一个用于存取某种数据仓库中的对象的标准化api。jdo提供了透明的对象存储,因此对开发人员来说,存储数据对象完全不需要额外的代码(如jdbc api的使用)。这些繁琐的例行工作已经转移到jdo产品提供商身上,使开发人员解脱出来,从而集中时间和精力在业务逻辑上。另外,jdo很灵活,因为它可以在任何数据底层上运行。jdbc只是面向关系数据库(rdbms)jdo更通用,提供到任何数据底层的存储功能,比如关系数据库、文件、xml以及对象数据库(odbms)等等,使得应用可移植性更强。

xml方面

91、xml有哪些解析技术?区别是什么? 答:有dom,sax,stax等

dom:处理大型文件时其性能下降的非常厉害。这个问题是由dom的树结构所造成的,这种结构占用的内存较多,而且dom必须在解析文件之前把整个文档装入内存,适合对xml的随机访问。

sax:不现于dom,sax是事件驱动型的xml解析方式。它顺序读取xml文件,不需要一次全部装载整个文件。当遇到像文件开头,文档结束,或者标签开头与标签结束时,它会触发一个事件,用户通过在其回调事件中写入处理代码来处理xml文件,适合对xml的顺序访问 stax:streaming api for xml(stax)92、你在项目中用到了xml技术的哪些方面?如何实现的?

答:用到了数据存贮,信息配置两方面。在做数据交换平台时,将不能数据源的数据组装成xml文件,然后将xml文件压缩打包加密后通过网络传送给接收者,接收解密与解压缩后再同xml文件中还原相关信息进行处理。在做软件配置时,利用xml可以很方便的进行,软件的各种配置参数都存贮在xml文件中。

93、xml文档定义有几种形式?它们之间有何本质区别?解析xml文档有哪几种方式? 答:a: 两种形式 dtd schema,b: 本质区别:schema本身是xml的,可以被xml解析器解析(这也是从dtd上发展schema的根本目的),c:有dom,sax,stax等

dom:处理大型文件时其性能下降的非常厉害。这个问题是由dom的树结构所造成的,这种结构占用的内存较多,而且dom必须在解析文件之前把整个文档装入内存,适合对xml的随机访问

sax:不现于dom,sax是事件驱动型的xml解析方式。它顺序读取xml文件,不需要一次全部装载整个文件。当遇到像文件开头,文档结束,或者标签开头与标签结束时,它会触发一个事件,用户通过在其回调事件中写入处理代码来处理xml文件,适合对xml的顺序访问 stax:streaming api for xml(stax)

java线程知识点总结 java线程写法篇3

java线程总结

首先要理解线程首先需要了解一些基本的东西,我们现在所使用的大多数操作系统都属于多任务,分时操作系统。正是由于这种操作系统的出现才有了多线程这个概念。我们使用的windows,linux就属于此列。什么是分时操作系统呢,通俗一点与就是可以同一时间执行多个程序的操作系统,在自己的电脑上面,你是不是一边听歌,一边聊天还一边看网页呢?但实际上,并不上cpu在同时执行这些程序,cpu只是将时间切割为时间片,然后将时间片分配给这些程序,获得时间片的程序开始执行,不等执行完毕,下个程序又获得时间片开始执行,这样多个程序轮流执行一段时间,由于现在cpu的高速计算能力,给人的感觉就像是多个程序在同时执行一样。

一般可以在同一时间内执行多个程序的操作系统都有进程的概念.一个进程就是一个执行中的程序,而每一个进程都有自己独立的一块内存空间,一组系统资源.在进程概念中,每一个进程的内部数据和状态都是完全独立的.因此可以想像创建并执行一个进程的系统开像是比较大的,所以线程出现了。在java中,程序通过流控制来执行程序流,程序中单个顺序的流控制称为线程,多线程则指的是在单个程序中可以同时运行多个不同的线程,执行不同的任务.多线程意味着一个程序的多行语句可以看上去几乎在同一时间内同时运行.(你可以将前面一句话的程序换成进程,进程是程序的一次执行过程,是系统运行程序的基本单位)

线程与进程相似,是一段完成某个特定功能的代码,是程序中单个顺序的流控制;但与进程不同的是,同类的多个线程是共享一块内存空间和一组系统资源,而线程本身的数据通常只有微处理器的寄存器数据,以及一个供程序执行时使用的堆栈.所以系统在产生一个线程,或者在各个线程之间切换时,负担要比进程小的多,正因如此,线程也被称为轻负荷进程(light-weight process).一个进程中可以包含多个线程.多任务是指在一个系统中可以同时运行多个程序,即有多个独立运行的任务,每个任务对应一个进程,同进程一样,一个线程也有从创建,运行到消亡的过程,称为线程的生命周期.用线程的状态(state)表明线程处在生命周期的哪个阶段.线程有创建,可运行,运行中,阻塞,死亡五中状态.通过线程的控制与调度可使线程在这几种状态间转化每个程序至少自动拥有一个线程,称为主线程.当程序加载到内存时,启动主线程.[线程的运行机制以及调度模型]

java中多线程就是一个类或一个程序执行或管理多个线程执行任务的能力,每个线程可以独立于其他线程而独立运行,当然也可以和其他线程协同运行,一个类控制着它的所有线程,可以决定哪个线程得到优先级,哪个线程可以访问其他类的资源,哪个线程开始执行,哪个保持休眠状态。下面是线程的机制图:

page 1 of 16

线程的状态表示线程正在进行的活动以及在此时间段内所能完成的任务.线程有创建,可运行,运行中,阻塞,死亡五中状态.一个具有生命的线程,总是处于这五种状态之一: 1.创建状态

使用new运算符创建一个线程后,该线程仅仅是一个空对象,系统没有分配资源,称该线程处于创建状态(new thread)2.可运行状态

使用start()方法启动一个线程后,系统为该线程分配了除cpu外的所需资源,使该线程处于可运行状态(runnable)3.运行中状态

java运行系统通过调度选中一个runnable的线程,使其占有cpu并转为运行中状态(running).此时,系统真正执行线程的run()方法.4.阻塞状态

一个正在运行的线程因某种原因不能继续运行时,进入阻塞状态(blocked)5.死亡状态

线程结束后是死亡状态(dead)

同一时刻如果有多个线程处于可运行状态,则他们需要排队等待cpu资源.此时每个线程自动获得一个线程的优先级(priority),优先级的高低反映线程的重要或紧急程度.可运行状态的线程按优先级排队,线程调度依据优先级基础上的“先到先服务”原则.线程调度管理器负责线程排队和cpu在线程间的分配,并由线程调度算法进行调度.当线程调度管理器选种某个线程时,该线程获得cpu资源而进入运行状态.线程调度是先占式调度,即如果在当前线程执行过程中一个更高优先级的线程进入可运行状态,则这个线程立即被调度执行.先占式调度分为:独占式和分时方式.独占方式下,当前执行线程将一直执行下去,直 到执行完毕或由于某种原因主动放弃cpu,或cpu被一个更高优先级的线程抢占

分时方式下,当前运行线程获得一个时间片,时间到时,即使没有执行完也要让出

page 2 of 16

cpu,进入可运行状态,等待下一个时间片的调度.系统选中其他可运行状态的线程执行

分时方式的系统使每个线程工作若干步,实现多线程同时运行

另外请注意下面的线程调度规则(如果有不理解,不急,往下看): ①如果两个或是两个以上的线程都修改一个对象,那么把执行修改的方法定义为被同步的(synchronized),如果对象更新影响到只读方法,那么只度方法也应该定义为同步的

②如果一个线程必须等待一个对象状态发生变化,那么它应该在对象内部等待,而不是在外部等待,它可以调用一个被同步的方法,并让这个方法调用wait()③每当一个方法改变某个对象的状态的时候,它应该调用notifyall()方法,这给等待队列的线程提供机会来看一看执行环境是否已发生改变

④记住wait(),notify(),notifyall()方法属于object类,而不是thread类,仔细检查看是否每次执行wait()方法都有相应的notify()或notifyall()方法,且它们作用与相同的对象 在java中每个类都有一个主线程,要执行一个程序,那么这个类当中一定要有main方法,这个man方法也就是java class中的主线程。你可以自己创建线程,有两种方法,一是继承thread类,或是实现runnable接口。一般情况下,最好避免继承,因为java中是单根继承,如果你选用继承,那么你的类就失去了弹性,当然也不能全然否定继承thread,该方法编写简单,可以直接操作线程,适用于单重继承情况。至于选用那一种,具体情况具体分析。

eg.继承thread

public class mythread_1 extends thread{ public void run(){ //some code } }

eg.实现runnable接口

public class mythread_2 implements runnable { public void run(){ //some code } }

page 3 of 16

当使用继承创建线程,这样启动线程:

new mythread_1().start()

当使用实现接口创建线程,这样启动线程:

new thread(new mythread_2()).start()

注意,其实是创建一个线程实例,并以实现了runnable接口的类为参数传入这个实例,当执行这个线程的时候,mythread_2中run里面的代码将被执行。下面是完成的例子:

public class mythread implements runnable { public void run(){ n(“my name is ”+tthread().getname());} public static void main(string[] args){ new thread(new mythread()).start();} }

执行后将打印出: my name is thread-0

你也可以创建多个线程,像下面这样

new thread(new mythread()).start();new thread(new mythread()).start();new thread(new mythread()).start();

那么会打印出:

my name is thread-0 my name is thread-1

page 4 of 16

my name is thread-2

看了上面的结果,你可能会认为线程的执行顺序是依次执行的,但是那只是一般情况,千万不要用以为是线程的执行机制;影响线程执行顺序的因素有几点:首先看看前面提到的优先级别

public class mythread implements runnable { public void run(){ n(“my name is ”+tthread().getname());} public static void main(string[] args){ thread t1=new thread(new mythread());thread t2=new thread(new mythread());thread t3=new thread(new mythread());

ority(_priority);//赋予最高优先级

();();();} }

再看看结果:

my name is thread-1 my name is thread-0 my name is thread-2

page 5 of 16

线程的优先级分为10级,分别用1到10的整数代表,默认情况是5。上面的ority(_priority)ority(10)

然后是线程程序本身的设计,比如使用sleep,yield,join,wait等方法(详情请看jdkdocument)

public class mythread implements runnable { public void run(){

try {

int sleeptime =(int)(()* 100);// 产生随机数字,tthread().sleep(sleeptime);// 让其休眠一定时间,时间又上面sleeptime决定

// public static void sleep(long millis)throw interruptedexception

//(api)

n(tthread().getname()+ “ 睡了 ”

+ sleeptime);

} catch(interruptedexception ie)

// 由于线程在休眠可能被中断,所以调用sleep方法的时候需要捕捉异常

page 6 of 16

{

tacktrace();

} }

public static void main(string[] args){

thread t1 = new thread(new mythread());

thread t2 = new thread(new mythread());

thread t3 = new thread(new mythread());

();

();

();} }

执行后观察其输出: thread-0 睡了 11 thread-2 睡了 48 thread-1 睡了 69

上面的执行结果是随机的,再执行很可能出现不同的结果。由于上面我在run中添加了休眠语句,当线程休眠的时候就会让出cpu,cpu将会选择执行处于runnable状态中的其他线程,当然也可能出现这种情况,休眠的thread立即进入了runnable状态,cpu再次执行它。[线程组概念] 线程是可以被组织的,java中存在线程组的概念,每个线程都是一个线程组的成员,线程组把多个线程集成为一个对象,通过线程组可以同时对其中的多个线程进行操作,包中的thread——group类用来管理一组线程,包括:线程的数目,线程间的关系,线程正在执行的操作,以及线程将要启动或终止时间等.线程组还可以包含线程组.在java的应用程序中,最高层的线程组是名位main的线程组,在main中还可以加入线程或

page 7 of 16

线程组,在mian的子线程组中也可以加入线程和线程组,形成线程组和线程之间的树状继承关系。像上面创建的线程都是属于main这个线程组的。借用上面的例子,main里面可以这样写:

public static void main(string[] args){

/***************************************

* threadgroup(string name)threadgroup(threadgroup parent, string name)

***********************************/

threadgroup group1 = new threadgroup(“group1”);

threadgroup group2 = new threadgroup(group1, “group2”);

thread t1 = new thread(group2, new mythread());

thread t2 = new thread(group2, new mythread());

thread t3 = new thread(group2, new mythread());

();

();

();} 线程组的嵌套,t1,t2,t3被加入group2,group2加入group1。

page 8 of 16

另外一个比较多就是关于线程同步方面的,试想这样一种情况,你有一笔存款在银行,你在一家银行为你的账户存款,而你的妻子在另一家银行从这个账户提款,现在你有1000块在你的账户里面。你存入了1000,但是由于另一方也在对这笔存款进行操作,人家开始执行的时候只看到账户里面原来的1000元,当你的妻子提款1000元后,你妻子所在的银行就认为你的账户里面没有钱了,而你所在的银行却认为你还有2000元。看看下面的例子:

class blanksaving // 储蓄账户 { private static int money = 10000;

public void add(int i){

money = money + i;

n(“husband 向银行存入了 [¥” + i + “]”);}

public void get(int i){

money = money-i;

n(“wife 向银行取走了 [¥” + i + “]”);

if(money < 0)

n(“余额不足!”);}

page 9 of 16

public int showmoney(){

return money;} }

class operater implements runnable { string name;blanksaving bs;

public operater(blanksaving b, string s){

name = s;

bs = b;

}

public static void oper(string name, blanksaving bs){

if((“husband”)){

try {

for(int i = 0;i < 10;i++){

page 10 of 16

tthread().sleep((int)(()* 300));

(1000);

}

} catch(interruptedexception e){

}

} else {

try {

for(int i = 0;i < 10;i++){

tthread().sleep((int)(()* 300));

(1000);

}

} catch(interruptedexception e){

}

} }

public void run(){

oper(name, bs);}

page 11 of 16

}

public class banktest { public static void main(string[] args)throws interruptedexception {

blanksaving bs = new blanksaving();

operater o1 = new operater(bs, “husband”);

operater o2 = new operater(bs, “wife”);

thread t1 = new thread(o1);

thread t2 = new thread(o2);

();

();

tthread().sleep(500);} }

下面是其中一次的执行结果:

---------first--------------husband 向银行存入了 [¥1000] wife 向银行取走了 [¥1000] wife 向银行取走了 [¥1000] husband 向银行存入了 [¥1000] wife 向银行取走了 [¥1000] husband 向银行存入了 [¥1000] wife 向银行取走了 [¥1000] husband 向银行存入了 [¥1000] wife 向银行取走了 [¥1000] husband 向银行存入了 [¥1000] husband 向银行存入了 [¥1000]

page 12 of 16

wife 向银行取走了 [¥1000] husband 向银行存入了 [¥1000] husband 向银行存入了 [¥1000] wife 向银行取走了 [¥1000] wife 向银行取走了 [¥1000] husband 向银行存入了 [¥1000] wife 向银行取走了 [¥1000] wife 向银行取走了 [¥1000] husband 向银行存入了 [¥1000]

看到了吗,这可不是正确的需求,在husband还没有结束操作的时候,wife就插了进来,这样很可能导致意外的结果。解决办法很简单,就是将对数据进行操作方法声明为synchronized,当方法被该关键字声明后,也就意味着,如果这个数据被加锁,只有一个对象得到这个数据的锁的时候该对象才能对这个数据进行操作。也就是当你存款的时候,这笔账户在其他地方是不能进行操作的,只有你存款完毕,银行管理人员将账户解锁,其他人才能对这个账户进行操作。

修改public static void oper(string name,blanksaving bs)为public static void oper(string name,blanksaving bs),再看看结果:

husband 向银行存入了 [¥1000] husband 向银行存入了 [¥1000] husband 向银行存入了 [¥1000] husband 向银行存入了 [¥1000] husband 向银行存入了 [¥1000] husband 向银行存入了 [¥1000] husband 向银行存入了 [¥1000] husband 向银行存入了 [¥1000] husband 向银行存入了 [¥1000] husband 向银行存入了 [¥1000] wife 向银行取走了 [¥1000] wife 向银行取走了 [¥1000] wife 向银行取走了 [¥1000] wife 向银行取走了 [¥1000] wife 向银行取走了 [¥1000] wife 向银行取走了 [¥1000] wife 向银行取走了 [¥1000] wife 向银行取走了 [¥1000] wife 向银行取走了 [¥1000] wife 向银行取走了 [¥1000]

当丈夫完成操作后,妻子才开始执行操作,这样的话,对共享对象的操作就不会有问题了。

[wait and notify] 你可以利用这两个方法很好的控制线程的执行流程,当线程调用wait方法后,线

page 13 of 16

程将被挂起,直到被另一线程唤醒(notify)或则是如果wait方法指定有时间得话,在没有被唤醒的情况下,指定时间时间过后也将自动被唤醒。但是要注意一定,被唤醒并不是指马上执行,而是从组塞状态变为可运行状态,其是否运行还要看cpu的调度。事例代码:

class mythread_1 extends thread {

object lock;

public mythread_1(object o){

lock = o;}

public void run(){

try {

synchronized(lock){

n(“enter thread_1 and wait”);

();

n(“be notified”);

}

} catch(interruptedexception e){

} }

page 14 of 16

}

class mythread_2 extends thread { object lock;

public mythread_2(object o){

lock = o;}

public void run(){

synchronized(lock){

n(“enter thread_2 and notify”);

();

} } }

public class mythread { public static void main(string[] args){

int[] in = new int[0];// notice

mythread_1 t1 = new mythread_1(in);

page 15 of 16

mythread_2 t2 = new mythread_2(in);

();

();} }

执行结果如下:

enter thread_1 and wait enter thread_2 and notify thread_1 be notified

可能你注意到了在使用wait and notify方法得时候我使用了synchronized块来包装这两个方法,这是由于调用这两个方法的时候线程必须获得锁,也就是上面代码中的lock[],如果你不用synchronized包装这两个方法的得话,又或则锁不一是同一把,比如在mythread_2中synchronized(lock)改为synchronized(this),lmonitorstateexception执行期异常。另外wait and notify方法是object中的,并不在thread这个类中。最后你可能注意到了这点:int[] in=new int[0];为什么不是创建new object而是一个0长度的数组,那是因为在java中创建一个0长度的数组来充当锁更加高效。

page 16 of 16

java线程知识点总结 java线程写法篇4

1.什么是gui?

a)gui是graphics user interface的全称,意思是图形用户界面.2.为什么需要gui?

a)图形用户界面能够让最终用户通过鼠标拖动、单击等动作就可以操作整个应用,从而提高应用的用户体验效果,

a)awt是sun公司提供的一个基本的gui类库,被称为抽象工具集(abstract

window-toolkit),它为java应用程序提供了基本的组件.b)awt组件需要调用运行平台的图形界面来创建和平台一致的对等体,所以awt只

能使用所有平台都支持的公共组件,因此awt只能够提供一些 的主要组成部分

a)component,代表一个具体图形表示能力的对象,可以在屏幕上显示,并与用户交互.通常我们把它称为”组件”.b)menucomponent,r,,em,代表一个菜单项.c)container,代表一个awt组件容器,可以盛装其他commponent组件,它继承自

component抽象类,,,,代表一个对话框

a)filedialog代表一个文件对话框,,可容纳其他组件,但不能独立存在,必须被添加到其他容器中.,带滚动条的容器.d)layoutmanager,布局管理器,yout,流式布局,layout,边框布局,只能盛装5个组件,yout,网格布局,glayout,网格包布局,一种较为复杂的布局管理器,yout,卡片布局,以时间来管理容器内的组件,将组件看作是一张张卡片,每次显示最外面一张卡片(组件).boxlayou,箱式布局, 的事件

a)应用程序响应用户的某个动作或请求,如用户单击了一下鼠标,用户请求关闭应用

程序窗口等.b)awt编程中,所有事件的处理都必须交给特定的对象来完成,我们将这个特定的对

象称为事件监听器.c)awt的事件处理机制是一种委派式的事件处理方式,通过将某个事件监听器注册

到用户指定的组件,当用户进行某个操作并触发指定事件时,应用程序会自动产生一个事件(event)对象并作为参数传给事件监听器中的事件处理器,然后由事件监

听器通知事件处理器来响应用户,完成用户的请求.d)不同的事件需要不同的事件监听器,不同的监听器需要实现不同的监听器接口.e)事件监听器接口:为某个特定事件定义了响应用户请求的方法,当用户将某个事件

监听器注册到指定组件上以响应特定的事件时,则该事件监听器必须实现对应的事件监听器接口才能对用户的请求进行有效处理.例如,用户点击了鼠标右键,希望打开某个应用程序的右键菜单,则注册到该应用程序上的事件监听器必须实现鼠标事件监听器接口,并实现该接口内部某些方法来完成用户的请求.f)事件适配器,很多时候,我们只需要实现某个事件监听器接口中个别方法就能完成应用程序的实际需求,但实现该事件监听器接口的类必须实现该接口中所有的抽象方法,这会造成代码的冗余.而事件适配器可以帮我们解决这个问题,事件适配器实现了所有的拥有多个抽象方法的事件监听器接口,并空实现了这些接口中所有的抽象方法,所谓空实现,就是方法中没有任何实现代码,因此,我们可以通过继承对应事件监听器接口的事件适配器抽象类,并实现我们感兴趣的方法来完成应用需求即可.g)java事件处理过程中主要涉及的三类对象

i.事件源,.事件,通常指用户的某个操作,如单击了一下鼠标,.事件监听器,负责监听事件源上所发生的事件,并作出响应.h)awt事件监听器的实现形式

.内部类形式 顶级类形式

iii.类本身作为事件监听器

iv.匿名内部类形式

v.注:绘图

a)awt绘图的实现过程.i.重写画布类的paint方法,.调用component类的repaint方法绘制图形.b)awt实现绘图主要涉及的对象

.c)component类的子类canvas类,cs,代表一个画笔,类代表了位图,它的一个主要的实现类bufferedimage是可以访问图形数据

缓冲区,并可以返回一个graphics对象来绘制该)的优缺点

a)awt在许多非桌面环境,如嵌入式设备中有着自己的优势,它的主要优点如下:.iv.更少的内存:对运行在有限环境中的gui程序的开发,是合适的。2.更少的启动事件:由于awt组件是本地由操作系统实现的。绝大多数的二进制代码已经在如系统启动的时候被预装载了,这降低了它的启动事件。3.更好的响应:由于本地组件由操作系统渲染。4.成熟稳定的:能够正常工作并很少使你的程序崩溃。

b)同样它也有不少的缺点

.更少组件类型:表和树这些重要的组件缺失了。它们是桌面应用程序中普遍使用的。2.缺乏丰富的组件特征:按钮不支持图片。3.无扩展性:awt的组件是本地组件。jvm中的awt类实例实际只是包含本地

组件的引用。唯一的扩展点是awt的canvas组件,可以从零开始创建自定义组

件。然而无法继承和重用一个已有的awt组件

总结:awt是sun不推荐使用的工具集,实际开发中很少使用awt而是使用sun公司

和netscape公司共同开发的一个新的用户界面库-swing来开发gui应用程序,awt是图形用户界面编程的基础,它的布局管理、事件机制、剪贴板操作等内容仍然适用于swing gui编程.

java线程知识点总结 java线程写法篇5

计算器

班级:****** 姓名:******

学号: ******* 指导老师:******

实验名称:java计算器

1实验目的: java编程语言在编程方面的具体应用,以及使用面向对象方法,对小应用程序进行需求分

析、概要设计、详细设计,最后使用java编程实现的全过程。

2实验意义:

在编程我们使用的java语言,是目前比较流行的编程语言。在当今这个时代,java语言在编程方面的优势使得编程有了更好的选择。java语言最大的特点是具有跨平台性,使其不受平台不同的影响,得到了广泛的应用。实训性质

本课程是计算机信息管理专业的一门实践性课程,是《java编程》课程的实践性教学环节。实训目标

⑴综合应用java程序设计的知识解决实际问题。

⑵学会在应用程序的设计过程中,应用面向对象的程序设计方法。⑶学会应用jdbc创建数据库应用程序。

⑷学会开发基于swing的应用程序及多文档应用程序的设计。实训任务

用java语言开发工具(例如jdk、jcreator、netbeans等)制作一个简单的可运行的完整的应用程序或小型系统,并编制出各阶段必要的文档。

将创建一个计算器,可以进行常用的加减乘除算术运算。本实例的知识点有:窗口布局器gridlayout的应用,对按钮消息的监听和响应。

6实训条件

<软件:>windows xp,netbeans ide 7开发背景: java是由sun microsystems公司于1995年5月推出的java程序设计语言(以下简称java语言)和java平台的总称。java语言是一个支持网络计算的面向对象程序设计语言。java语言吸收了smalltalk语言和c++语言的优点,并增加了其它特性,如支持并发程序设计、网络通信、和多媒体数据控制等。

8系统部分分析:

1)java语言是简单的。java语言的语法与c语言和c++语言很接近,使得大多数程序员很容易学习和使用java。另一方面,java丢弃了c++ 中很少使用的、很难理解的、令人迷惑的那些特性,如操作符重载、多继承、自动的强制类型转换。

2)java语言是一个面向对象的。java语言提供类、接口和继承等原语,为了简单起见,只支持类之间的单继承,但支持接口之间的多继承,并支持类与接口之间的实现机制(关键字为implements)。java语言全面支持动态绑定,而c++ 语言只对虚函数使用动态绑定

3)java语言是分布式的。java语言支持internet应用的开发,在基本的java应用编程接口中有一个网络应用编程接口(),它提供了用于网络应用编程的类库,包括url、urlconnection、socket、serversocket等。java的rmi(远程方法激活)机制也是开发分布式应用的重要手段。

4)java语言是健壮的。java的强类型机制、异常处理、废料的自动收集等是java程序健壮性的重要保证。对指针的丢弃是java的明智选择。java的安全检查机制使得java更具健壮性。

5)java语言是安全的。java通常被用在网络环境中,为此,java提供了一个安全机制以防恶意代码的攻击。除了java语言具有的许多安全特性以外,java对通过网络下载的类具有一个安全防范机制(类classloader),如分配不同的名字空间以防替代本地的同名类、字节代码检查,并提供安全管理机制.6)java语言是体系结构中立的。java程序(后缀为java的文件)在java平台上被编译为体系结构中立的字节码格式(后缀为class的文件), 然后可以在实现这个java平台的任何系统中运行。

7)java语言是可移植的。这种可移植性来源于体系结构中立性,另外,java还严格规定了各个基本数据类型的长度。java系统本身也具有很强的可移植性,java编译器是用java实现的.8)java语言是解释型的。如前所述,java程序在java平台上被编译为字节码格式,然后可以在实现这个java平台的任何系统中运行。

9)java是高性能的。与那些解释型的高级脚本语言相比,java的确是高性能的。事实上,java的运行速度随着jit(just-in-time)编译器技术的发展越来越接近于c++。

10)java语言是多线程的。在java语言中,线程是一种特殊的对象,它必须由thread类或其子(孙)类来创建。

11)java语言是动态的。java语言的设计目标之一是适应于动态变化的环境。

目录

课程设计题目 ……………………………… p1

课程设计简介 ……………………………… p2

课程设计源代码…………………………… p5

课程设计运行结果 ……………………… p15 课程设计心得体会 ………………………

p16

package computerpad;import .*;import .event.*;import .*;import .*;import list;import format;public class computerpad extends frame implements actionlistener {

numberbutton numberbutton[];

operationbutton oprationbutton[];

button 小数点按钮,正负号按钮,退格按钮,求倒数按钮,等号按钮,清零按钮;

panel panel;

jtextfield resultshow;

string 运算符号[]={“+”,“-”,“*”,“/”};

linkedlist 链表;

boolean 是否按下等号=false;

public computerpad()

{

super(“计算器”);

链表=new linkedlist();

numberbutton=new numberbutton[10];

for(int i=0;i<=9;i++)

{

numberbutton[i]=new numberbutton(i);

numberbutton[i].addactionlistener(this);

}

oprationbutton=new operationbutton[4];

for(int i=0;i<4;i++)

{

oprationbutton[i]=new operationbutton(运算符号[i]);

oprationbutton[i].addactionlistener(this);

}

小数点按钮=new button(“.”);

正负号按钮

=new button(“+/-”);

等号按钮=new button(“=”);

求倒数按钮=new button(“1/x”);

退格按钮=new button(“退格”);

清零按钮=new button(“c”);

eground();

eground();

eground();

eground();

eground();

eground();

ionlistener(this);

ionlistener(this);

ionlistener(this);

ionlistener(this);

ionlistener(this);

ionlistener(this);

resultshow=new jtextfield(10);

izontalalignment();

eground();

t(new font(“timesroman”,,14));

der(new softbevelborder(d));

kground();

table(false);

panel=new panel();

out(new gridlayout(4,5));

(numberbutton[1]);

(numberbutton[2]);

(numberbutton[3]);

(oprationbutton[0]);

(清零按钮);

(numberbutton[4]);

(numberbutton[5]);

(numberbutton[6]);

(oprationbutton[1]);

(退格按钮);

(numberbutton[7]);

(numberbutton[8]);

(numberbutton[9]);

(oprationbutton[2]);

(求倒数按钮);

(numberbutton[0]);

(正负号按钮);

(小数点按钮);

(oprationbutton[3]);

(等号按钮);

add(panel,);

add(resultshow,);

addwindowlistener(new windowadapter()

{ public void windowclosing(windowevent e)

{

(0);

}

});

setvisible(true);

setbounds(100,50,240,180);

setresizable(false);

validate();

} public void actionperformed(actionevent e)

{

if(rce()instanceof numberbutton)

{

numberbutton b=(numberbutton)rce();

if(()==0)

{

int number=ber();

(“"+number);

t(”“+number);

是否按下等号=false;

}

else if(()==1&&是否按下等号==false)

{

int number=ber();

string num=(string)first();

string s=(”“+number);

(0,s);

t(s);

}

else if(()==1&&是否按下等号==true)

{

int number=ber();

first();

(”“+number);

是否按下等号=false;

t(”“+number);

}

else if(()==2)

{

int number=ber();

(”“+number);

t(”“+number);

}

else if(()==3)

{

int number=ber();

string num=(string)t();

string s=(”“+number);

(2,s);

t(s);

}

}

else if(rce()instanceof operationbutton)

{

operationbutton b=(operationbutton)rce();

if(()==1)

{

string fuhao=运算符号();

(fuhao);

}

else if(()==2)

{

string fuhao=运算符号();

(1,fuhao);

}

else if(()==3)

{

string fuhao=运算符号();

string number1=(string)first();

string number2=(string)t();

string 运算符号=(string)(1);

try

{

double n1=ouble(number1);

double n2=ouble(number2);

double n=0;

if((”+“))

{

n=n1+n2;

}

else if((”-“))

{

n=n1-n2;

}

else if((”*“))

{

n=n1*n2;

}

else if((”/“))

{

n=n1/n2;

}

();

(”“+n);

(fuhao);

t(”“+n);

}

catch(exception ee)

{

}

}

}

else if(rce()==等号按钮)

{

是否按下等号=true;

if(()==1||()==2)

{

string num=(string)first();

t(”“+num);

}

else if(()==3)

{

string number1=(string)first();

string number2=(string)t();

string 运算符号=(string)(1);

try

{

double n1=ouble(number1);

double n2=ouble(number2);

double n=0;

if((”+“))

{

n=n1+n2;

}

else if((”-“))

{

n=n1-n2;

}

else if((”*“))

{

n=n1*n2;

}

else if((”/“))

{

n=n1/n2;

}

t(”“+n);

(0,”“+n);

last();

last();

}

catch(exception ee)

{

}

}

}

else if(rce()==小数点按钮)

{

if(()==0)

{

是否按下等号=false;

}

else if(()==1)

{

string dot=el();

string num=(string)first();

string s=null;

if(f(dot)==-1)

{

s=(dot);

(0,s);

}

else

{

s=num;

}

(0,s);

t(s);

}

else if(()==3)

{

string dot=el();

string num=(string)t();

string s=null;

if(f(dot)==-1)

{

s=(dot);

(2,s);

}

else

{

s=num;

}

t(s);

}

}

else if(rce()==退格按钮)

{

if(()==1)

{

string num=(string)first();

if(()>=1)

{

num=ing(0,()-1);

(0,num);

t(num);

}

else

{

last();

t(”0“);

}

}

else if(()==3)

{

string num=(string)t();

if(()>=1)

{ num=ing(0,()-1);

(2,num);

t(num);

}

else

{

last();

t(”0“);

}

}

}

else if(rce()==正负号按钮)

{

if(()==1)

{

string number1=(string)first();

try

{

double d=ouble(number1);

d=-1*d;

string str=f(d);

(0,str);

t(str);

}

catch(exception ee)

{

}

}

else if(()==3)

{

string number2=(string)t();

try

{

double d=ouble(number2);

d=-1*d;

string str=f(d);

(2,str);

t(str);

}

catch(exception ee){

}

}

}

else if(rce()==求倒数按钮)

{

if(()==1||()==2)

{

string number1=(string)first();

try

{

double d=ouble(number1);

d=/d;

string str=f(d);

(0,str);

t(str);

}

catch(exception ee){

}

}

else if(()==3)

{

string number2=(string)t();

try

{

double d=ouble(number2);

d=/d;

string str=f(d);

(0,str);

t(str);

}

catch(exception ee){

}

}

}

else if(rce()==清零按钮)

{

是否按下等号=false;

t(”0“);

();

}

} public static void main(string args[])

{

new computerpad();

}

}

package computerpad;import .*;import .event.*;import .*;public class numberbutton extends button {

int number;

public numberbutton(int number)

{

super(”"+number);

=number;

setforeground();

}

public int getnumber()

{

return number;

} }

import .*;import .event.*;import .*;public class operationbutton extends button {

string 运算符号;

public operationbutton(string s)

{

super(s);

运算符号=s;

setforeground();

}

public string get运算符号()

{

return 运算符号;

} } 14 java实训心得:

未接触java之前,听人说java这门语言如何的强大和难以入门,但学习之后,给我的感觉却是语言没有所谓的难于不难,关键是自己有没有真正投入去学,有没有花时间去学。java是一门很好的语言,经过周围人对java的宣传,我一开始不敢去学习这门语言,因为一门高级语言总是让人想到一开始的学习会很难,但是后来在自己的努力和老师同学的帮助下,我加入了java学习者的行列。

老师把我们带进了门,那么,以后漫长的深入学习还是要靠自己。经常性的编写一些程序,或则去看懂、研究透别人编写的程序对于我们打好基础是非常有利的。让我们怀着对java的一腔热情,用自己的刻苦努力去把java学好。将来,用自己的成绩去回报有恩于我们的社会、家人和朋友。

相关推荐

热门文档

48 2041774