技术改变世界 阅读塑造人生! - shaogx.com

This string was altered by TechBlog\Plugins\Example.; This is an example to show the potential of an offcanvas layout pattern in Bootstrap. Try some responsive-range viewport sizes to see it in action.

Java线程系列实用教程

Java线程是一个庞大的话题,本专题的三十多篇文章,将Java多线程的方方面面讲了一遍,对博主来说是一个学习和提高的过程,也为Java线程系列的学习者带来了便利。... 全文

教程 Java java教程 java线程

【经典】传智播客韩顺平Java和javaEE视频教程完整版 [30.16G]倾情奉献

(1)自己网盘珍藏的:韩顺平Java和javaEE视频教程完整版 [30.16G]分享给大家!以供学习交流!网盘分享地址:http://yunpan.cn/cgk5UbH6nLHL2   (提取码:1e07)... 全文

经典传智播客韩顺平Java和javaEE 韩顺平Java和javaEE视频教程完整 韩顺平Java和javaEE视频教程 韩顺平

Java并没没落:最新Java 8简明教程译文(1)

“Java并没有没落,人们很快就会发现这一点”... 全文

Java8 Java8教程

Java NIO系列教程(十二) Java NIO与IO

原文地址:http://tutorials.jenkov.com/java-nio/nio-vs-io.html作者:Jakob Jenkov   译者:郭蕾    校对:方腾飞当学习了Java NIO和IO的API后,一个问题马上涌入脑海:... 全文

Java NIO系列教程(十二) Java NIO与IO

JAVA教程 第六讲 Java的线程和Java Applet

 6.1.3 线程的调度    Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程。线程调度器按照线程的优先级决定应调度哪些线程来执行。   线程调度器按线程的优先级高低选择高优先级线程(进入运行中状态)执行,同时线程调度是抢先式调度,即如果在当前线程执行过程中,一个更高优先级的线程进入可运行状态,则这个线程立即被调度执行。... 全文

设计 休闲 JAVA 职场 处理程序

java视频教程不同阶段看哪些

 第一个阶段(基础阶段)  1、你要掌握HTML语言,认为常用的HTML一些标签。我推荐大家学习孙鑫老师视频的《HTML语言速成》  2、掌握JAVA基础,也就是J2SE,我推荐大家学习马士兵老师的J2SE视频。当时我学习J2SE主要学习的张孝祥和孙鑫老师的视频(当时还不知道马士兵老师呢!呵呵)不过我认为孙鑫老师前面几讲还是值得初学者看的,主要讲了一些二进制的内容,我认为这些内容对初学者很有帮助。我还是建议大家先看看孙鑫老师的视频,然后再看马士兵老师的,如果有空余时间可以看看张孝祥老师的(不过张孝祥老师普通话不是很好,而且语速很慢,不过技术是不用说的啦!呵呵)。光学习视频是不够的,身边当然要有本参考书了。我推荐大家是(孙卫琴)《JAVA面向对象编程》,这本书我看过,很不错的这个阶段我还要强调一下,因张孝祥和孙鑫出的视频比较早,用的是JDK1.4。而现在市面上早就用1.5 (即JDK5.0)JDK5.0里面有很多新的特性,张孝祥和孙鑫的视频都还没有讲。关于JDK5.0新特性的视频,我建议大家观看风中叶老师的JAVA5.0新特性系列视频  第二个阶段(数据库阶段)一般情况下PHP对应MySQL数据库;ASP对应SQL数据库;JSP对应ORACLE数据库。所以大家会经常看到市场上JAVA培训都是用的ORACLE数据库,其实你学会了ORACLE数据库,再去学习MySQL、SQL数据库,你会觉得有很多相似的之处,学起来也容易上手了。就如同你会了J2EE,然后再学习.NET就很容易上手一样。最后强调一点的是JAVA可以使用任何数据库的,因项目的不同需求而选择相应合适的数据库。我推荐大家学习视频是(唐远东)企业级数据库ORACLE,不过相应的ORACLE参考学习书籍,我并没有发现一本较好的。如果大家认为有比较好的ORACLE,可以留帖推荐,在此先说声谢谢  2、掌握基础的XML知识。用于J2EE中的JSP、Servlet的服务器配置。不要求精通,起码要看得懂常用XML代码。我推荐的视频是孙鑫的XML视频,不过现在张孝祥老师好象也推出了XML视频。参考书籍是(孙鑫)JAVA WEB 开发详解  第三个阶段(高级阶段)  首先是学习Servlet、JSP然后再去学习框架Struts、Hibernate、Spring等最前沿的最流行的网络编程必备的软件技能。  学习Servlet我建议大家去学习韩顺平老师的J2EE系列实战视频之Servlet。  学习JSP我建议大家学习李兴华老师的JSP视频教程吧!推荐的参考书籍是美河图书提供《Servlet与JSP核心编程》  框架的基础就是Servlet、JSP。首先大家应该学习的是Struts框架,典型的MVC模型。推荐学习视频是张小静的Struts视频,张小静老师讲的非常详细,我认为很适合初学者。(现在网上不是有孙鑫的J2EE视频嘛,主要就是讲的Struts、Hibernate、Spring这三个框架,我建议初学者不要观看,这是学员偷偷录制的,有些地方衔接得不是很好,初学者也许很难看懂的,等有了三个框假的基础再去看,你会受益匪浅的)推荐书籍孙卫琴编著《精通Struts基于MVC的Java.Web设计与开发》  然后就是Hibernate框架,大家可以观看李兴华老师的Hibernate视频,参考书籍孙卫琴《精通Hibernate:Java对象持久化技术详解》最后关于Spring框架的视频虽然很多,但我还没有发现比较好的,书籍嘛也挺多的。(因为我没有深入看过Spring的书籍,所以我不敢乱下结论,这是美河负责,也是对初学者负责)  学完上述三个阶段的内容,还可以看看JSF、Ajax、EJB吧!现在的Ajax用得非常火,随便在这里提一下,学习Ajax之前一定要有JavaScript的基础,推荐视频张孝祥JavaScript网页开发,这套视频有相应的配套书籍《JavaScript网页开发》最后我需要说明一下:我所推荐的视频都是网上可以免费下载的,推荐的书籍都是可以从网上下载的电子书。我个人一向推崇将免费进行到底!如果你有什么意见,或者我总结的不足,或者你有什么更好的视频、书籍,可以留帖,我们共同学习,共同进步。  附上视频链接魔乐在线:主讲:李兴华:推荐度:五星 http://www.mldn.cn/articlelist/article_59_AddDate_Desc_2.htm#  尚学堂:主讲:马士兵推荐度:四星半  http://www.verycd.com/files/c11154b560ed64f5a48d859027da9e8a437357789  中国IT实验室  比较杂,当然相对资料也比较多 推荐度:三星半http://download.chinaitlab.com/video.html非常学生网里面视频相对较少,但有孙鑫的全部J2SE视频,及相关数据库视频推荐度:三星半http://www.verystu.com/class/Class_95_1.shtml  编程园 J2EE视频较多有关美河培训机构的资料也相对较多更多的电子书推荐度:三星半http://www.oksonic.cn/soft/list.asp?page=2&classid=2&order=  JAVA中文站 下载各类API 非常方便至于是否有其他视频不清楚 推荐度:三星半 http://www.java-cn.com/  JAVA初学者园地 页面较乱但仍有不少资源  推荐度:两星半  http://www.matrix.org.cn/resourceList.shtml?kid=19&sid=44源码下载 问题求解 首推 赛迪社区里面有各类软件专家高手解答你的问题推荐度:四星半 http://bbs.java.ccidnet.com/read.php?tid=561274&u=843733  计算机应用,病毒排除,系统安装等疑难杂症首推雨林木风  推荐度 四星半 http://bbs.ylmf.com/... 全文

java 教程 视频 数据库 休闲

JAVA教程 第八讲 Java网络编程

8.1 网络编程的基本概念,TCP/IP协议简介8.1.1 网络基础知识   计算机网络形式多样,内容繁杂。网络上的计算机要互相通信,必须遵循一定的协议。目前使用最广泛的网络协议是Internet上所使用的TCP/IP协议  网络编程的目的就是指直接或间接地通过网络协议与其他计算机进行通讯。网络编程中有两个主要的问题,一个是如何准确的定位网络上一台或多台主机,另一个就是找到主机后如何可靠高效的进行数据传输。在TCP/IP协议中IP层主要负责网络主机的定位,数据传输的路由,由IP地址可以唯一地确定Internet上的一台主机。而TCP层则提供面向应用的可靠的或非可靠的数据传输机制,这是网络编程的主要对象,一般不需要关心IP层是如何处理数据的。     目前较为流行的网络编程模型是客户机/服务器(C/S)结构。即通信双方一方作为服务器等待客户提出请求并予以响应。客户则在需要服务时向服务器提出申请。服务器一般作为守护进程始终运行,监听网络端口,一旦有客户请求,就会启动一个服务进程来响应该客户,同时自己继续监听服务端口,使后来的客户也能及时得到服务。... 全文

网络编程 JAVA 职场 休闲

JAVA教程 第三讲 Java语言中的面向对象特性

3.1 面向对象技术基础3.1.1 面向对象的基本概念  面向对象的基本思想  面向对象是一种新兴的程序设计方法,或者是一种新的程序设计规范(paradigm),其基本思想是使用对象、类、继承、封装、消息等基本概念来进行程序设计。从现实世界中客观存在的事物(即对象)出发来构造软件系统,并且在系统构造中尽可能运用人类的自然思维方式。开发一个软件是为了解决某些问题,这些问题所涉及的业务范围称作该软件的问题域。其应用领域不仅仅是软件,还有计算机体系结构和人工智能等。  1. 对象的基本概念  对象是系统中用来描述客观事物的一个实体,它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。从更抽象的角度来说,对象是问题域或实现域中某些事物的一个抽象,它反映该事物在系统中需要保存的信息和发挥的作用;它是一组属性和有权对这些属性进行操作的一组服务的封装体。客观世界是由对象和对象之间的联系组成的。  主动对象是一组属性和一组服务的封装体,其中至少有一个服务不需要接收消息就能主动执行(称作主动服务)。   2. 类的基本概念  把众多的事物归纳、划分成一些类是人类在认识客观世界时经常采用的思维方法。分类的原则是抽象。类是具有相同属性和服务的一组对象的集合,它为属于该类的所有对象提供了统一的抽象描述,其内部包括属性和服务两个主要部分。在面向对象的编程语言中,类是一个独立的程序单位,它应该有一个类名并包括属性说明和服务说明两个主要部分。类与对象的关系就如模具和铸件的关系,类的实例化结果就是对象,而对一类对象的抽象就是类。   3. 消息  消息就是向对象发出的服务请求,它应该包含下述信息:提供服务的对象标识、服务标识、输入信息和回答信息。服务通常被称为方法或函数。3.1.2 面向对象的基本特征 1.封装性  封装性就是把对象的属性和服务结合成一个独立的相同单位,并尽可能隐蔽对象的内部细节,包含两个含义:  ◇ 把对象的全部属性和全部服务结合在一起,形成一个不可分割的独立单位(即对象)。  ◇ 信息隐蔽,即尽可能隐蔽对象的内部细节,对外形成一个边界〔或者说形成一道屏障〕,只保留有限的对外接口使之与外部发生联系。  封装的原则在软件上的反映是:要求使对象以外的部分不能随意存取对象的内部数据(属性),从而有效的避免了外部错误对它的"交叉感染",使软件错误能够局部化,大大减少查错和排错的难度。   2.继承性  特殊类的对象拥有其一般类的全部属性与服务,称作特殊类对一般类的继承。例如,轮船、客轮;人、大人。一个类可以是多个一般类的特殊类,它从多个一般类中继承了属性与服务,这称为多继承。例如,客轮是轮船和客运工具的特殊类。在java语言中,通常我们称一般类为父类(superclass,超类),特殊类为子类(subclass)。 3.多态性  对象的多态性是指在一般类中定义的属性或服务被特殊类继承之后,可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或服务在一般类及其各个特殊类中具有不同的语义。例如:"几何图形"的"绘图"方法,"椭圆"和"多边形"都是"几何图"的子类,其"绘图"方法功能不同。3.1.3 面向对象程序设计方法    OOA-Object Oriented Analysis     面向对象的分析    OOD-Object Oriented Design      面向对象的设计    OOI-Object Oriented Implementation  面向对象的实现3.2 Java语言的面向对象特性3.2.1 类  类是java中的一种重要的复合数据类型,是组成java程序的基本要素。它封装了一类对象的状态和方法,是这一类对象的原形。一个类的实现包括两个部分:类声明和类体。 1.类声明:  [public][abstract|final] class className [extends superclassName] [implements interfaceNameList]  {……}  其中,修饰符public,abstract,final 说明了类的属性,className为类名,superclassName为类的父类的名字,interfaceNameList为类所实现的接口列表。 2.类体  类体定义如下:  class className  {[public | protected | private ] [static]   [final] [transient] [volatile] type  variableName;                 //成员变量  [public | protected | private ] [static]  [final | abstract] [native] [synchronized]  returnType methodName([paramList]) [throws exceptionList]   {statements}                 //成员方法  } 3.成员变量  成员变量的声明方式如下:  [public | protected | private ] [static]   [final] [transient] [volatile] type  variableName;                 //成员变量  其中,  static: 静态变量(类变量);相对于实例变量  final: 常量  transient: 暂时性变量,用于对象存档  volatile: 贡献变量,用于并发线程的共享 4.成员方法  方法的实现包括两部分内容:方法声明和方法体。  [public | protected | private ] [static]  [final | abstract] [native] [synchronized]  returnType methodName([paramList])  [throws exceptionList]            //方法声明   {statements}                //方法体  方法声明中的限定词的含义:  static: 类方法,可通过类名直接调用  abstract: 抽象方法,没有方法体  final: 方法不能被重写  native: 集成其它语言的代码  synchronized: 控制多个并发线程的访问  ◇ 方法声明  方法声明包括方法名、返回类型和外部参数。其中参数的类型可以是简单数据类型,也可以是复合数据类型(又称引用数据类型)。  对于简单数据类型来说,java实现的是值传递,方法接收参数的值,但不能改变这些参数的值。如果要改变参数的值,则用引用数据类型,因为引用数据类型传递给方法的是数据在内存中的地址,方法中对数据的操作可以改变数据的值。  例3-1说明了简单数据类型与引用数据的区别。【例3-1】  import java.io.*;  public class PassTest{  float ptValue;  public static void main(String args[]) {  int val;  PassTest pt=new PassTest();  val=11;  System.out.println("Original Int Value is:"+val);   pt.changeInt(val);                   //值参数  System.out.println("Int Value after Change is:" +val); /*值参数                    值的修改,没有影响值参数的值*/  pt.ptValue=101f;  System.out.println("Original ptValue is:"+pt.ptValue);  pt.changeObjValue(pt); //引用类型的参数  System.out.println("ptValue after Change is:"+pt.ptValue);/* 引用参数值的修改,改变了引用参数的值*/   }  public void changeInt(int value){  value=55;            //在方法内部对值参数进行了修改  }  public void changeObjValue(PassTest ref){  ref.ptValue=99f;        //在方法内部对引用参数进行了修改    }  }   运行结果 c:\>java PassTestOriginal Int Value is : 11Int Value after Change is: 11Original ptValue is: 101.0ptValue after Change is : 99.0  ◇ 方法体  方法体是对方法的实现,它包括局部变量的声明以及所有合法的Java指令。方法体中声明的局部变量的作用域在该方法内部。若局部变量与类的成员变量同名,则类的成员变量被隐藏。  例3-2 说明了局部变量z和类成员变量z的作用域是不同的。【例3-2】  import java.io.*;  class Variable{  int x=0,y=0,z=0;              //类的成员变量  void init(int x,int y) {  this.x=x; this.y=y;   int z=5;                 //局部变量  System.out.println("** in init**");  System.out.println("x="+x+" y="+y+" z="+z);    }   }  public class VariableTest{  public static void main(String args[]){  Variable v=new Variable();  System.out.println("**before init**");  System.out.println("x="+v.x+" y="+ v.y+" z="+v.z);  v.init(20,30);  System.out.println("**after init**");  System.out.println("x="+v.x+ " y="+ v.y+" z="+v.z);    }  }   运行结果 c:\>java VariableTest**before init**x=0 y=0 z=0** in init **x=20 y=30 z=5**after init**x=20 y=30 z=0  上例中我们用到了this,这是因为init()方法的参数名与类的成员变量x,y的名字相同,而参数名会隐藏成员变量,所以在方法中,为了区别参数和类的成员变量,我们必须使用this。this-----用在一个方法中引用当前对象,它的值是调用该方法的对象。返回值须与返回类型一致,或者完全相同,或是其子类。当返回类型是接口时,返回值必须实现该接口。 5.方法重载   方法重载是指多个方法享有相同的名字,但是这些方法的参数必须不同,或者是参数的个数不同,或者是参数类型不同。返回类型不能用来区分重载的方法。  参数类型的区分度一定要足够,例如不能是同一简单类型的参数,如int与long。【例3-3】  import java.io.*;  class MethodOverloading{  void receive(int i) {  System.out.println("Receive one int data");  System.out.println("i="+i);  }  void receive(int x, int y) {  System.out.println("Receive two int datas");  System.out.println("x="+x+" y="+y);    }   }  public class MethodOverloadingTest{  public static void main(String args[]) {  MethodOverloading mo=new MethodOverloading();  mo.receive(1);  mo.receive(2,3);    }   }  运行结果(编译器会根据参数的个数和类型来决定当前所使用的方法) c:\>java MethodOverloadingTestReceive one int datai=1Receive two int datasx=2 y=3 6. 构造方法   构造方法是一个特殊的方法。Java 中的每个类都有构造方法,用来初始化该类的一个对象。   构造方法具有和类名相同的名称,而且不返回任何数据类型。   重载经常用于构造方法。   构造方法只能由new运算符调用【例3-4】  class Point{  int x,y;  Point(){  x=0; y=0;  }  Point(int x, int y){  this.x=x;   this.y=y;    }  }3.2.2 对象  类实例化可生成对象,对象通过消息传递来进行交互。消息传递即激活指定的某个对象的方法以改变其状态或让它产生一定的行为。一个对象的生命周期包括三个阶段:生成、使用和消除。 1. 对象的生成  对象的生成包括声明、实例化和初始化。  格式为:  type objectName=new type([paramlist]);  ◇ 声明:type objectName   声明并不为对象分配内存空间,而只是分配一个引用空间;对象的引用类似于指针,是32位的地址空间,它的值指向一个中间的数据结构,它存储有关数据类型的信息以及当前对象所在的堆的地址,而对于对象所在的实际的内存地址是不可操作的,这就保证了安全性。    ◇ 实例化:运算符new为对象分配内存空间,它调用对象的构造方法,返回引用;一个类的不同对象分别占据不同的内存空间。  ◇ 生成:执行构造方法,进行初始化;根据参数不同调用相应的构造方法。 2. 对象的使用  通过运算符"."可以实现对变量的访问和方法的调用。变量和方法可以通过设定访问权限来限制其它对象对它的访问。  ◇调用对象的变量  格式:objectReference.variable  objectReference是一个已生成的对象,也可以是能生成对象的表达式  例: p.x= 10;     tx=new Point( ).x;  ◇调用对象的方法  格式:objectReference.methodName([paramlist]);  例如:p.move(30,20);     new Point( ).move(30,20); 3. 对象的清除  当不存在对一个对象的引用时,该对象成为一个无用对象。Java的垃圾收集器自动扫描对象的动态内存区,把没有引用的对象作为垃圾收集起来并释放。  System.gc( );    当系统内存用尽或调用System.gc( )要求垃圾回收时,垃圾回收线程与系统同步运行。3.2.3 面向对象特性  java语言中有三个典型的面向对象的特性:封装性、继承性和多态性,下面将详细阐述。 1. 封装性  java语言中,对象就是对一组变量和相关方法的封装,其中变量表明了对象的状态,方法表明了对象具有的行为。通过对象的封装,实现了模块化和信息隐藏。通过对类的成员施以一定的访问权限,实现了类中成员的信息隐藏。  ◇ 类体定义的一般格式:  class className  {   [public | protected | private ] [static]      [final] [transient] [volatile] type     variableName;            //成员变量     [public | protected | private ] [static]     [final | abstract] [native] [synchronized]     returnType methodName([paramList])     [throws exceptionList]     {statements} //成员方法  }  ◇ java类中的限定词  java语言中有四种不同的限定词,提供了四种不同的访问权限。  1) private   类中限定为private的成员,只能被这个类本身访问。  如果一个类的构造方法声明为private,则其它类不能生成该类的一个实例。  2) default  类中不加任何访问权限限定的成员属于缺省的(default)访问状态,可以被这个类本身和同一个包中的类所访问。  3) protected  类中限定为protected的成员,可以被这个类本身、它的子类(包括同一个包中以及不同包中的子类)和同一个包中的所有其他的类访问。  4) public  类中限定为public的成员,可以被所有的类访问。  表3-1列出了这些限定词的作用范围。【表3-1】 java中类的限定词的作用范围比较同一个类同一个包 不同包的子类 不同包非子类private*default **protected***public****2. 继承性  通过继承实现代码复用。Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。继承而得到的类称为子类,被继承的类称为父类。子类不能继承父类中访问权限为private的成员变量和方法。子类可以重写父类的方法,及命名与父类同名的成员变量。但Java不支持多重继承,即一个类从多个超类派生的能力。  创建子类  格式:  class SubClass extends SuperClass {  …  }  成员变量的隐藏和方法的重写  子类通过隐藏父类的成员变量和重写父类的方法,可以把父类的状态和行为改变为自身的状态和行为。  例如:  class SuperClass{    int x; …    void setX( ){ x=0; } …  }  class SubClass extends SuperClass{    int x;   //隐藏了父类的变量x    …    void setX( ) { //重写了父类的方法 setX()    x=5; } ….  }  注意:子类中重写的方法和父类中被重写的方法要具有相同的名字,相同的参数表和相同的返回类型,只是函数体不同。  ◇ super  java中通过super来实现对父类成员的访问,super用来引用当前对象的父类。Super 的使用有三种情况:  1)访问父类被隐藏的成员变量,如:    super.variable;   2)调用父类中被重写的方法,如:    super.Method([paramlist]);  3)调用父类的构造函数,如:    super([paramlist]);【例3-5】  import java.io.*;  class SuperClass{    int x;    SuperClass( ) {     x=3;     System.out.println("in SuperClass : x=" +x);    }     void doSomething( ) {     System.out.println("in SuperClass.doSomething()");    }  }  class SubClass extends SuperClass {    int x;    SubClass( ) {     super( );    //调用父类的构造方法     x=5;      //super( ) 要放在方法中的第一句     System.out.println("in SubClass :x="+x);    }     void doSomething( ) {     super.doSomething( ); //调用父类的方法     System.out.println("in SubClass.doSomething()");     System.out.println("super.x="+super.x+" sub.x="+x);    }  }  public class Inheritance {     public static void main(String args[]) {     SubClass subC=new SubClass();     subC.doSomething();    }  }    运行结果c:\> java Inheritancein SuperClass: x=3in SubClass: x=5in SuperClass.doSomething()in SubClass.doSomething()super.x=3 sub.x=5 3. 多态性  在java语言中,多态性体现在两个方面:由方法重载实现的静态多态性(编译时多态)和方法重写实现的动态多态性(运行时多态)。  1) 编译时多态  在编译阶段,具体调用哪个被重载的方法,编译器会根据参数的不同来静态确定调用相应的方法。  2) 运行时多态  由于子类继承了父类所有的属性(私有的除外),所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方,都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。  重写方法的调用原则:java运行时系统根据调用该方法的实例,来决定调用哪个方法。对子类的一个实例,如果子类重写了父类的方法,则运行时系统调用子类的方法;如果子类继承了父类的方法(未重写),则运行时系统调用父类的方法。  在例3-6中,父类对象a引用的是子类的实例,所以,java运行时调用子类B的callme方法。【例3-6】  import java.io.*;  class A{     void callme( ) {      System.out.println("Inside A's callme()method");      }   }  class B extends A{     void callme( ) {      System.out.println("Inside B's callme() Method");      }  }  public class Dispatch{     public static void main(String args[]) {      A a=new B();      a.callme( );     }  }    运行结果c:\> java DispatchInside B's callme() method  方法重写时应遵循的原则:  1)改写后的方法不能比被重写的方法有更严格的访问权限(可以相同)。  2)改写后的方法不能比重写的方法产生更多的例外。4. 其它  ◇ final 关键字  final 关键字可以修饰类、类的成员变量和成员方法,但final 的作用不同。    1) final 修饰成员变量:  final修饰变量,则成为常量,例如  final type variableName;  修饰成员变量时,定义时同时给出初始值,而修饰局部变量时不做要求。  2) final 修饰成员方法:  final修饰方法,则该方法不能被子类重写  final returnType methodName(paramList){  …  }  3) final 类:   final修饰类,则类不能被继承  final class finalClassName{  …  }  ◇ 实例成员和类成员  用static 关键字可以声明类变量和类方法,其格式如下:  static type classVar;  static returnType classMethod({paramlist}) {  …  }   如果在声明时不用static 关键字修饰,则声明为实例变量和实例方法。  1) 实例变量和类变量  每个对象的实例变量都分配内存,通过该对象来访问这些实例变量,不同的实例变量是不同的。  类变量仅在生成第一个对象时分配内存,所有实例对象共享同一个类变量,每个实例对象对类变量的改变都会影响到其它的实例对象。类变量可通过类名直接访问,无需先生成一个实例对象,也可以通过实例对象访问类变量。  2) 实例方法和类方法  实例方法可以对当前对象的实例变量进行操作,也可以对类变量进行操作,实例方法由实例对象调用。  但类方法不能访问实例变量,只能访问类变量。类方法可以由类名直接调用,也可由实例对象进行调用。类方法中不能使用this或super关键字。  例3-7 是关于实例成员和类成员的例子。【例3-7】  class Member {    static int classVar;    int instanceVar;    static void setClassVar(int i) {     classVar=i;     // instanceVar=i; // 类方法不能访问实例变量    }    static int getClassVar()     { return classVar; }    void setInstanceVar(int i)     { classVar=i; //实例方法不但可以访问类变量,也可以实例变量     instanceVar=i; }     int getInstanceVar( )      { return instanceVar; }    }    public class MemberTest{     public static void main(String args[]) {         Member m1=new member();         Member m2=new member();         m1.setClassVar(1);         m2.setClassVar(2);          System.out.println("m1.classVar="+m1.getClassVar()+"                    m2.ClassVar="+m2.getClassVar());         m1.setInstanceVar(11);          m2.setInstanceVar(22);         System.out.println("m1.InstanceVar="+m1.getInstanceVar              ()+" m2.InstanceVar="+m2.getInstanceVar());     }    }    运行结果c:\> java MemberTestm1.classVar=2 m2.classVar=2m1.InstanceVar=11 m2.InstanceVar=22  类java.lang.Object  类java.lang.Object处于java开发环境的类层次的根部,其它所有的类都是直接或间接地继承了此类。该类定义了一些最基本的状态和行为。下面,我们介绍一些常用的方法。  equals() :比较两个对象(引用)是否相同。  getClass():返回对象运行时所对应的类的表示,从而可得到相应的信息。  toString():用来返回对象的字符串表示。  finalize():用于在垃圾收集前清除对象。  notify(),notifyAll(),wait():用于多线程处理中的同步。3.2.4抽象类和接口 1. 抽象类  java语言中,用abstract 关键字来修饰一个类时,这个类叫做抽象类,用abstract 关键字来修饰一个方法时,这个方法叫做抽象方法。格式如下:  abstract class abstractClass{ …} //抽象类  abstract returnType abstractMethod([paramlist]) //抽象方法  抽象类必须被继承,抽象方法必须被重写。抽象方法只需声明,无需实现;抽象类不能被实例化,抽象类不一定要包含抽象方法。若类中包含了抽象方法,则该类必须被定义为抽象类。 2. 接口  接口是抽象类的一种,只包含常量和方法的定义,而没有变量和方法的实现,且其方法都是抽象方法。它的用处体现在下面几个方面:  ◇ 通过接口实现不相关类的相同行为,而无需考虑这些类之间的关系。  ◇ 通过接口指明多个类需要实现的方法。  ◇ 通过接口了解对象的交互界面,而无需了解对象所对应的类。  1)接口的定义  接口的定义包括接口声明和接口体。  接口声明的格式如下:  [public] interface interfaceName[extends listOfSuperInterface] { … }   extends 子句与类声明的extends子句基本相同,不同的是一个接口可有多个父接口,用逗号隔开,而一个类只能有一个父类。  接口体包括常量定义和方法定义  常量定义格式为:type NAME=value; 该常量被实现该接口的多个类共享; 具有public ,final, static的属性。  方法体定义格式为:(具有 public和abstract属性)  returnType methodName([paramlist]);  2)接口的实现  在类的声明中用implements子句来表示一个类使用某个接口,在类体中可以使用接口中定义的常量,而且必须实现接口中定义的所有方法。一个类可以实现多个接口,在implements子句中用逗号分开。  3) 接口类型的使用  接口作为一种引用类型来使用。任何实现该接口的类的实例都可以存储在该接口类型的变量中,通过这些变量可以访问类所实现的接口中的方法。3.2.5 内部类 1. 内部类的定义和使用:  内部类是在一个类的内部嵌套定义的类,它可以是其它类的成员,也可以在一个语句块的内部定义,还可以在表达式内部匿名定义。  内部类有如下特性:  ◇ 一般用在定义它的类或语句块之内,在外部引用它时必须给出完整的名称.名字不能与包含它的类名相同。  ◇ 可以使用包含它的类的静态和实例成员变量,也可以使用它所在方法的局部变量。  ◇ 可以定义为abstract。  ◇ 可以声明为private或protected。  ◇ 若被声明为static,就变成了顶层类,不能再使用局部变量。  ◇ 若想在Inner Class中声明任何static成员,则该Inner Class必须声明为static。  例3-8 是一个说明内部类如何使用的例子,其中,定义了两个内部类:MouseMotionHandler和MouseEventHandler,分别用来处理鼠标移动事件和鼠标点按事件。【例3-8】  import java.awt.*;  import java.awt.event.*;  public class TwoListenInner {    private Frame f;    private TextField tf;      public static void main(String args[]) {       TwoListenInner that=new TwoListenInner();       that.go();     }      public void go() {       f=new Frame("Two listeners example");       f.add("North",new Label("Click and drag the mouse"));       tf=new TextField(30);       f.add("South",tf);       f.addMouseMotionListener(new MouseMotionHandler());       f.addMouseListener(new MouseEventHandler());       f.setSize(300,300);       f.setVisible(true);    }     public class MouseMotionHandler extends MouseMotionAdapter {       public void mouseDragged(MouseEvent e){       String s="Mouse dragging:X="+e.getX()+"Y="+e.getY();       tf.setText(s);      }    }    public class MouseEventHandler extends MouseAdapter {      public void mouseEntered(MouseEvent e){       String s="The mouse entered";       tf.setText(s);      }      public void mouseExited(MouseEvent e){       String s="The mouse left the building";       tf.setText(s);      }    }  }  同学们可以运行一下这个程序,看一看它的运行结果。当你将鼠标移入frame时,文本框中会出现:"The mouse entered";当你在frame中拖曳鼠标时,文本框中会出现:"Mouse dragging:X=64 Y=117";当鼠标离开文本框时,文本框中出现:"The mouse left the building"。2. 匿名类的定义和使用:  匿名类是一种特殊的内部类,它是在一个表达式内部包含一个完整的类定义。通过对例6-7中go()部分语句的修改,我们可以看到匿名类的使用情况。  public void go() {         f=new Frame("Two listeners example");         f.add("North",new Label("Click and drag the mouse"));         tf=new TextField(30);         f.add("South",tf);         f.addMouseMotionListener(new MouseMotionHandler(){         /*定义了一个匿名类,类名没有显式地给出,只是该类是          MouseMotionHandler类的子类*/           public void mouseDragged(MouseEvent e){             String s="Mouse dragging:X="+e.getX()+"Y             ="+e.getY();             tf.setText(s);           }         });         f.addMouseListener(new MouseEventHandler());         f.setSize(300,300);         f.setVisible(true);         } 3. 内部类的优缺点:  ◇ 优点:节省编译后产生的字节码文件的大小  ◇ 缺点:使程序结构不清楚【本讲小结】  类是Java语言面向对象编程的基本元素,它定义了一个对象的结构和功能。 Java类中包含成员变量和成员方法。成员变量有两种,用static 关键字修饰的变量为类变量,无static 修饰的变量为实例变量。相应地,成员方法也有两种,用static 修饰的为类方法,无static修饰的为实例方法。实例方法不仅可以对当前对象的实例变量进行操作,也可以对类变量进行操作;但类方法只能访问类变量。实例变量和实例方法必须由实例对象来调用,而类变量和类方法不仅可由实例对象来调用,还可由类名直接调用。Java通过在类定义的大括号里声明变量来把数据封装在一个类里,这里的变量称为成员变量。为了解决类名可能相同的问题,java 中提供包来管理类名空间。  封装性、继承性和多态性是java语言中面向对象的三个特性。接口是java 语言中特有的数据类型,由于接口的存在,解决了java语言不支持多重继承的问题。内部类是指在一个类的内部嵌套定义的类。... 全文

Java 休闲 职场

Java 8新特性探究(5):重复注解

 什么是重复注解允许在同一申明类型(类,属性,或方法)的多次使用同一个注解一个简单的例子java 8之前也有重复使用注解的解决方案,但可读性不是很好,比如下面的代码:... 全文

Java8 Java8教程

Java8使用Map中的computeIfAbsent方法构建本地缓存

一、概念及使用介绍在JAVA8的Map接口中,增加了一个方法computeIfAbsent,此方法签名如下:... 全文

Java8 Java8教程

JAVA教程 第四讲 Java的例外处理和I/O流

4.1 什么是例外  例外就是在程序的运行过程中所发生的异常事件,它中断指令的正常执行。Java中提供了一种独特的处理例外的机制,通过例外来处理程序设计中出现的错误。4.1.1 例外示例【例4-1】     import java.io.*;     class ExceptionDemo1{      public static void main( String args[ ] ){       FileInputStream fis = new FileInputStream( "text" );       int b;       while( (b=fis.read())!=-1 ){        System.out.print( b );       }       fis.close( );      }     }    查看编译结果【例4-2】     class ExceptionDemo2{      public static void main( String args[ ] ){       int a = 0;       System.out.println( 5/a );      }     }    运行结果C:\>javac ExceptionDemo2.javaC:\>java ExceptionDemo2  java.lang.ArithmeticException: / by zero at  ExceptionDemo2.main(ExceptionDemo2.java:4)  因为除数不能为0,所以在程序运行的时候出现了除0溢出的异常事件。为什么有的例外在编译时出现,而有的例外是在运行时出现的?让我们继续学习java 的例外处理机制。 4.1.2 例外处理机制  抛弃(throw)例外:  在Java程序的执行过程中,如果出现了异常事件,就会生成一个例外对象。生成的例外对象将传递给Java运行时系统,这一例外的产生和提交过程称为抛弃(throw)例外 两种处理例外的机制:  ◇ 捕获例外:  当Java运行时系统得到一个例外对象时,它将会沿着方法的调用栈逐层回溯,寻找处理这一例外的代码。找到能够处理这种类型的例外的方法后,运行时系统把当前例外对象交给这个方法进行处理,这一过程称为捕获(catch)例外。这是积极的例外处理机制。如果Java运行时系统找不到可以捕获例外的方法,则运行时系统将终止,相应的Java程序也将退出。  ◇ 声明抛弃例外:  如果一个方法并不知道如何处理所出现的例外,则可在方法声明时,声明抛弃(throws)例外。这是一种消极的例外处理机制。4.1.3 例外类的层次  在jdk中,每个包中都定义了例外类,而所有的例外类都直接或间接地继承于Throwable类。图4-1为jdk中例外类的继承关系。  java中的例外类可分为两大类:  Error   动态链接失败,虚拟机错误等,通常Java程序不应该捕获这类例外,也不会抛弃这种例外。  Exception    1)运行时例外:   继承于RuntimeException的类都属于运行时例外,例如算术例外(除零错)、数组下标越界例外等等。由于这些例外产生的位置是未知的,Java 编译器允许程序员在程序中不对它们做出处理。   2)非运行时例外:   除了运行时例外之外的其他由Exception 继承来的例外类都是非运行时的例外,例如FileNotFoundException(文件未找到例外)。Java编译器要求在程序中必须处理这种例外,捕获例外或者声明抛弃例外。4.2 例外的处理  java语言中有两种例外处理机制:捕获例外和声明抛弃例外。下面我们做详细介绍。4.2.1 捕获例外  捕获例外是通过try-catch-finally语句实现的。  try{  ......   }catch( ExceptionName1 e ){   ......   }catch( ExceptionName2 e ){   ......   }   ......   }finally{   ......  }  ◇ try  捕获例外的第一步是用try{…}选定捕获例外的范围,由try所限定的代码块中的语句在执行过程中可能会生成例外对象并抛弃。  ◇ catch  每个try代码块可以伴随一个或多个catch语句,用于处理try代码块中所生成的例外事件。catch语句只需要一个形式参数指明它所能够捕获的例外类型,这个类必须是Throwable的子类,运行时系统通过参数值把被抛弃的例外对象传递给catch块。  在catch块中是对例外对象进行处理的代码,与访问其它对象一样,可以访问一个例外对象的变量或调用它的方法。getMessage( )是类Throwable所提供的方法,用来得到有关异常事件的信息,类Throwable还提供了方法printStackTrace( )用来跟踪异常事件发生时执行堆栈的内容。例如:  try{    ......   }catch( FileNotFoundException e ){    System.out.println( e );    System.out.println( "message: "+e.getMessage() );    e.printStackTrace( System.out );   }catch( IOException e ){    System.out.println( e );   }  catch 语句的顺序:  捕获例外的顺序和catch语句的顺序有关,当捕获到一个例外时,剩下的catch语句就不再进行匹配。因此,在安排catch语句的顺序时,首先应该捕获最特殊的例外,然后再逐渐一般化。也就是一般先安排子类,再安排父类。  ◇ finally  捕获例外的最后一步是通过finally语句为例外处理提供一个统一的出口,使得在控制流转到程序的其它部分以前,能够对程序的状态作统一的管理。不论在try代码块中是否发生了异常事件,finally块中的语句都会被执行。4.2.2 声明抛弃例外 1.声明抛弃例外  如果在一个方法中生成了一个例外,但是这一方法并不确切地知道该如何对这一异常事件进行处理,这时,一个方法就应该声明抛弃例外,使得例外对象可以从调用栈向后传播,直到有合适的方法捕获它为止。  声明抛弃例外是在一个方法声明中的throws子句中指明的。例如:  public int read () throws IOException{        ......  }  throws子句中同时可以指明多个例外,之间由逗号隔开。例如:   public static void main(String args[]) throws   IOException,IndexOutOfBoundsException {…} 2.抛出例外  抛出例外就是产生例外对象的过程,首先要生成例外对象,例外或者由虚拟机生成,或者由某些类的实例生成,也可以在程序中生成。在方法中,抛出例外对象是通过throw语句实现的。  例如:  IOException e=new IOException();  throw e ;  可以抛出的例外必须是Throwable或其子类的实例。下面的语句在编译时将会产生语法错误:  throw new String("want to throw");4.3 自定义例外类的使用  自定义例外类必须是Throwable的直接或间接子类。  注意:一个方法所声明抛弃的例外是作为这个方法与外界交互的一部分而存在的。所以,方法的调用者必须了解这些例外,并确定如何正确的处理他们。4.4 I/O 流概述  输入/输出处理是程序设计中非常重要的一部分,比如从键盘读取数据、从文件中读取数据或向文件中写数据等等。  Java把这些不同类型的输入、输出源抽象为流(stream),用统一接口来表示,从而使程序简单明了。  Jdk 提供了包java.io,其中包括一系列的类来实现输入/输出处理。下面我们对java.io包的内容进行概要的介绍。4.4.1 I/O流的层次  1.字节流:  从InputStream和OutputStream派生出来的一系列类。这类流以字节(byte)为基本处理单位。  ◇ InputStream、OutputStream  ◇ FileInputStream、FileOutputStream  ◇ PipedInputStream、PipedOutputStream  ◇ ByteArrayInputStream、ByteArrayOutputStream  ◇ FilterInputStream、FilterOutputStream  ◇ DataInputStream、DataOutputStream  ◇ BufferedInputStream、BufferedOutputStream 2.字符流:  从Reader和Writer派生出的一系列类,这类流以16位的Unicode码表示的字符为基本处理单位。  ◇ Reader、Writer  ◇ InputStreamReader、OutputStreamWriter  ◇ FileReader、FileWriter  ◇ CharArrayReader、CharArrayWriter  ◇ PipedReader、PipedWriter  ◇ FilterReader、FilterWriter  ◇ BufferedReader、BufferedWriter  ◇ StringReader、StringWriter 3.对象流  ◇ ObjectInputStream、ObjectOutputStream 4.其它  ◇ 文件处理:  File、RandomAccessFile;  ◇ 接口  DataInput、DataOutput、ObjectInput、ObjectOutput;4.4.2 InputStream 和OutputStream 1.InputStream  ◇ 从流中读取数据:  int read( ); //读取一个字节,返回值为所读的字节  int read( byte b[ ] ); //读取多个字节,放置到字节数组b中,通常              //读取的字节数量为b的长度,返回值为实际              //读取的字节的数量  int read( byte b[ ], int off, int len ); //读取len个字节,放置                       //到以下标off开始字节                       //数组b中,返回值为实                       //际读取的字节的数量  int available( );   //返回值为流中尚未读取的字节的数量  long skip( long n ); //读指针跳过n个字节不读,返回值为实际             //跳过的字节数量  ◇ 关闭流:  close( ); //流操作完毕后必须关闭    ◇ 使用输入流中的标记:  void mark( int readlimit ); //记录当前读指针所在位置,readlimit                 //表示读指针读出readlimit个字节后                //所标记的指针位置才失效  void reset( );     //把读指针重新指向用mark方法所记录的位置  boolean markSupported( ); //当前的流是否支持读指针的记录功能  有关每个方法的使用,详见java API。 2.OutputStream  ◇ 输出数据:  void write( int b );   //往流中写一个字节b  void write( byte b[ ] ); //往流中写一个字节数组b  void write( byte b[ ], int off, int len ); //把字节数组b中从              //下标off开始,长度为len的字节写入流中  ◇ flush( )       //刷空输出流,并输出所有被缓存的字节  由于某些流支持缓存功能,该方法将把缓存中所有内容强制输出到流中。  ◇ 关闭流:   close( );       //流操作完毕后必须关闭 4.4.3 I/O中的例外  进行I/O操作时可能会产生I/O例外,属于非运行时例外,应该在程序中处理。如:FileNotFoundException, EOFException, IOException4.5 文件处理  I/O处理中,最常见的是对文件的操作,java.io包中有关文件处理的类有:File、FileInputStream、FileOutputStream、RamdomAccessFile和FileDescriptor;接口有:FilenameFilter。 4.5.1 文件描述  类File提供了一种与机器无关的方式来描述一个文件对象的属性。下面我们介绍类File中提供的各种方法。 ◇ 文件或目录的生成  public File(String path);/*如果path是实际存在的路径,则该File对象    /*表示的是目录;如果path是文件名,则该File对象表示的是文件。*/  public File(String path,String name);//path是路径名,name是文件名  public File(File dir,String name);//dir是路径名,name是文件名 ◇ 文件名的处理  String getName( ); //得到一个文件的名称(不包括路径)  String getPath( ); //得到一个文件的路径名  String getAbsolutePath( );//得到一个文件的绝对路径名  String getParent( ); //得到一个文件的上一级目录名  String renameTo(File newName); //将当前文件名更名为给定文件的                   完整路径 ◇ 文件属性测试  boolean exists( ); //测试当前File对象所指示的文件是否存在  boolean canWrite( );//测试当前文件是否可写  boolean canRead( );//测试当前文件是否可读  boolean isFile( ); //测试当前文件是否是文件(不是目录)  boolean isDirectory( ); //测试当前文件是否是目录 ◇ 普通文件信息和工具  long lastModified( );//得到文件最近一次修改的时间  long length( ); //得到文件的长度,以字节为单位  boolean delete( ); //删除当前文件 ◇ 目录操作  boolean mkdir( ); //根据当前对象生成一个由该对象指定的路径  String list( ); //列出当前目录下的文件 【例4-3】  import java.io.*; //引入java.io包中所有的类  public class FileFilterTest{    public static void main(String args[]){     File dir=new File("d://ex"); //用File 对象表示一个目录     Filter filter=new Filter("java"); //生成一个名为java的过滤器     System.out.println("list java files in directory "+dir);     String files[]=dir.list(filter); //列出目录dir下,文件后缀名                       为java的所有文件     for(int i=0;i<files.length;i++){      File f=new File(dir,files[i]); //为目录dir 下的文件或目录                       创建一个File 对象       if(f.isFile()) //如果该对象为后缀为java的文件,                则打印文件名        System.out.println("file "+f);       else         System.out.println("sub directory "+f ); //如果是目录                             则打印目录名     }    }   }   class Filter implements FilenameFilter{    String extent;    Filter(String extent){     this.extent=extent;    }    public boolean accept(File dir,String name){     return name.endsWith("."+extent); //返回文件的后缀名    }   }4.5.2 文件的顺序处理  类FileInputStream和FileOutputStream用来进行文件I/O处理,由它们所提供的方法可以打开本地主机上的文件,并进行顺序的读/写。例如,下列的语句段是顺序读取文件名为text的文件里的内容,并显示在控制台上面,直到文件结束为止。  FileInputStream fis;    try{    fis = new FileInputStream( "text" );   System.out.print( "content of text is : ");     int b;     while( (b=fis.read())!=-1 ) //顺序读取文件text里的内容并赋值                    给整型变量b,直到文件结束为止。      {                     System.out.print( (char)b );     }   }catch( FileNotFoundException e ){   System.out.println( e );   }catch( IOException e ){   System.out.println( e );   }4.5.3 随机访问文件  对于InputStream 和OutputStream 来说,它们的实例都是顺序访问流,也就是说,只能对文件进行顺序地读/写。随机访问文件则允许对文件内容进行随机读/写。在java中,类RandomAccessFile 提供了随机访问文件的方法。类RandomAccessFile的声明为:public class RandomAccessFile extends Object implements DataInput, DataOutput  接口DataInput 中定义的方法主要包括从流中读取基本类型的数据、读取一行数据、或者读取指定长度的字节数。如:readBoolean( )、readInt( )、readLine( )、readFully( ) 等。   接口DataOutput 中定义的方法主要是向流中写入基本类型的数据、或者写入一定长度的字节数组。如:writeChar( )、writeDouble( )、write( ) 等。 下面详细介绍RandomAccessFile类中的方法。 ◇ 构造方法:  RandomAccessFile(String name,String mode); //name是文件名,mode          //是打开方式,例如"r"表示只读,"rw"表示可读写,"  RandomAccessFile(File file,String mode); //file是文件对象 ◇ 文件指针的操作  long getFilePointer( ); //用于得到当前的文件指针  void seek( long pos ); //用于移动文件指针到指定的位置  int skipBytes( int n ); //使文件指针向前移动指定的n个字节 4.6 过滤流  过滤流在读/写数据的同时可以对数据进行处理,它提供了同步机制,使得某一时刻只有一个线程可以访问一个I/O流,以防止多个线程同时对一个I/O流进行操作所带来的意想不到的结果。类FilterInputStream和FilterOutputStream分别作为所有过滤输入流和输出流的父类  过滤流类层次:          java.lang.Object                |                +----java.io.InputStream                          |                          +----java.io.FilterInputStream  为了使用一个过滤流,必须首先把过滤流连接到某个输入/出流上,通常通过在构造方法的参数中指定所要连接的输入/出流来实现。例如:  FilterInputStream( InputStream in );  FilterOutputStream( OutputStream out );4.6.1 几种常见的过滤流  ◇ BufferedInputStream和BufferedOutputStream    缓冲流,用于提高输入/输出处理的效率。  ◇ DataInputStream 和 DataOutputStream    不仅能读/写数据流,而且能读/写各种的java语言的基本类型,如:boolean,int,float等。  ◇ LineNumberInputStream    除了提供对输入处理的支持外,LineNumberInputStream可以记录当前的行号。  ◇ PushbackInputStream    提供了一个方法可以把刚读过的字节退回到输入流中,以便重新再读一遍。  ◇ PrintStream    打印流的作用是把Java语言的内构类型以其字符表示形式送到相应的输出流。4.7 字符流的处理  java中提供了处理以16位的Unicode码表示的字符流的类,即以Reader和Writer 为基类派生出的一系列类。4.7.1 Reader和Writer    这两个类是抽象类,只是提供了一系列用于字符流处理的接口,不能生成这两个类的实例,只能通过使用由它们派生出来的子类对象来处理字符流。 1.Reader类是处理所有字符流输入类的父类。  ◇ 读取字符   public int read() throws IOException; //读取一个字符,返回值为读取的字符  public int read(char cbuf[]) throws IOException; /*读取一系列字符到数组cbuf[]中,返回值为实际读取的字符的数量*/  public abstract int read(char cbuf[],int off,int len) throws IOException;   /*读取len个字符,从数组cbuf[]的下标off处开始存放,返回值为实际读取的字符数量,该方法必须由子类实现*/  ◇ 标记流  public boolean markSupported(); //判断当前流是否支持做标记  public void mark(int readAheadLimit) throws IOException;    //给当前流作标记,最多支持readAheadLimit个字符的回溯。  public void reset() throws IOException; //将当前流重置到做标记处  ◇ 关闭流  public abstract void close() throws IOException; 2. Writer类是处理所有字符流输出类的父类。  ◇ 向输出流写入字符  public void write(int c) throws IOException;  //将整型值c的低16位写入输出流  public void write(char cbuf[]) throws IOException;  //将字符数组cbuf[]写入输出流  public abstract void write(char cbuf[],int off,int len) throws IOException;  //将字符数组cbuf[]中的从索引为off的位置处开始的len个字符写入输出流  public void write(String str) throws IOException;  //将字符串str中的字符写入输出流  public void write(String str,int off,int len) throws IOException;  //将字符串str 中从索引off开始处的len个字符写入输出流  ◇ flush( )  刷空输出流,并输出所有被缓存的字节。  ◇ 关闭流  public abstract void close() throws IOException;4.7.2 InputStreamReader和OutputStreamWriter  java.io包中用于处理字符流的最基本的类,用来在字节流和字符流之间作为中介。   ◇ 生成流对象  public InputStreamReader(InputStream in);   /*in是字节流,而InputStreamReader是字符流,但是其来源是字节流in,  因此InputStreamReader就可以把字节流in转换成字符流处理。/*  public InputStreamReader(InputStream in,String enc) throws UnsupportedEncodingException;  /*enc是编码方式,就是从字节流到字符流进行转换时所采用的编码方式,   例如 ISO8859-1,UTF-8,UTF-16等等*/  public OutputStreamWriter(OutputStream out);  /*out是字节流,而OutputStreamReader是字符流 */  public OutputStreamWriter(OutputStream out,String enc) throws UnsupportedEncodingException; //enc是编码方式  InputStreamReader和OutputStreamWriter的方法:  ◇ 读入和写出字符  基本同Reader和Writer。  ◇ 获取当前编码方式  public String getEncoding();  ◇ 关闭流  public void close() throws IOException;4.7.3 BufferedReader和BufferedWriter ◇ 生成流对象  public BufferedReader(Reader in); //使用缺省的缓冲区大小  public BufferedReader(Reader in, int sz); //sz为缓冲区的大小  public BufferedWriter(Writer out);  public BufferedWriter(Writer out, int sz); ◇ 读入/写出字符  除了Reader和Writer中提供的基本的读写方法外,增加对整行字符的处理。  public String readLine() throws IOException; //读一行字符  public void newLine() throws IOException; //写一行字符【例4-4】  import java.io.*;  public class NumberInput{   public static void main(String args[]){    try{      InputStreamReader ir;      BufferedReader in;      ir=new InputStreamReader(System.in);       //从键盘接收了一个字符串的输入,并创建了一个字符输入流的对象      in=new BufferedReader(ir);      String s=in.readLine();      //从输入流in中读入一行,并将读取的值赋值给字符串变量s      System.out.println("Input value is: "+s);      int i = Integer.parseInt(s);//转换成int型      i*=2;      System.out.println("Input value changed after doubled: "+i);    }catch(IOException e)    {System.out.println(e);}   }  }    运行结果D:\>java NumberInput123Input value is 123Input value changed after doubled: 246  注意:在读取字符流时,如果不是来自于本地的,比如说来自于网络上某处的与本地编码方式不同的机器,那么我们在构造输入流时就不能简单地使用本地缺省的编码方式,否则读出的字符就不正确;为了正确地读出异种机上的字符,我们应该使用下述方式构造输入流对象:      ir = new InputStreamReader(is, "8859_1");  采用ISO 8859_1编码方式,这是一种映射到ASCII码的编码方式,可以在不同平台之间正确转换字符。 4.8 对象的串行化(Serialization)4.8.1 串行化的定义    1. 什么是串行化  对象的寿命通常随着生成该对象的程序的终止而终止。有时候,可能需要将对象的状态保存下来,在需要时再将对象恢复。我们把对象的这种能记录自己的状态以便将来再生的能力,叫做对象的持续性(persistence)。对象通过写出描述自己状态的数值来记录自己,这个过程叫对象的串行化(Serialization)。   2. 串行化的目的  串行化的目的是为java的运行环境提供一组特性,其主要任务是写出对象实例变量的数值。4.8.2 串行化方法  在java.io包中,接口Serializable用来作为实现对象串行化的工具,只有实现了Serializable的类的对象才可以被串行化。 1. 定义一个可串行化对象  public class Student implements Serializable{    int id; //学号    String name; //姓名    int age; //年龄    String department //系别    public Student(int id,String name,int age,String department){     this.id = id;     this.name = name;     this.age = age;     this.department = department;    }  } 2. 构造对象的输入/输出流  要串行化一个对象,必须与一定的对象输入/输出流联系起来,通过对象输出流将对象状态保存下来,再通过对象输入流将对象状态恢复。  java.io包中,提供了ObjectInputStream和ObjectOutputStream将数据流功能扩展至可读写对象。在ObjectInputStream中用readObject()方法可以直接读取一个对象,ObjectOutputStream中用writeObject()方法可以直接将对象保存到输出流中。  Student stu=new Student(981036,"Liu Ming",18, "CSD");  FileOutputStream fo=new FileOutputStream("data.ser");  //保存对象的状态  ObjectOutputStream so=new ObjectOutputStream(fo);  try{    so.writeObject(stu);    so.close();    }catch(IOException e )      {System.out.println(e);}  FileInputStream fi=new FileInputStream("data.ser");  ObjectInputStream si=new ObjectInputStream(fi);  //恢复对象的状态  try{    stu=(Student)si.readObject();    si.close();    }catch(IOException e )  {System.out.println(e);}  在这个例子中,我们首先定义一个类Student,实现了 Serializable接口,然后通过对象输出流的writeObject()方法将Student对象保存到文件data.ser中。之后,通过对象输入流的readObject()方法从文件data.ser中读出保存下来的Student对象。 4.8.3 串行化的注意事项 1.串行化能保存的元素  只能保存对象的非静态成员变量,不能保存任何的成员方法和静态的成员变量,而且串行化保存的只是变量的值,对于变量的任何修饰符,都不能保存。 2.transient关键字   对于某些类型的对象,其状态是瞬时的,这样的对象是无法保存其状态的,例如一个Thread对象,或一个FileInputStream对象,对于这些字段,我们必须用transient关键字标明 3. 定制串行化  缺省的串行化机制,对象串行化首先写入类数据和类字段的信息,然后按照名称的上升排列顺序写入其数值。如果想自己明确地控制这些数值的写入顺序和写入种类,必须定义自己的读取数据流的方式。就是在类的定义中重写writeObject()和readObject()方法。  例如可在4.8.2的例子中,加入重写的writeObject()和readObject()方法,对Student 类定制其串行化。  private void writeObject(ObjectOutputStream out)throws IOException  {    out.writeInt(id);    out.writeInt(age);    out.writeUTF(name);    out.writeUTF(department);  }  private void readObject(ObjectInputStream in)throws IOException  {    id=in.readInt();    age=in.readInt();    name=in.readUTF();    department=in.readUTF();  }4.9 其它常用的流4.9.1 管道流  管道用来把一个程序、线程或代码块的输出连接到另一个程序、线程或代码块的输入 。    管道输入流作为一个通信管道的接收端,管道输出流作为发送端。在使用管道之前,管道输出流和管道输入流必须进行连接。下面有两种连接的方法: 1. 构造方法中连接  PipedInputStream(PipedOutputStream src);  PipedOutputStream(PipedInputStream snk); 2. connect()方法进行连接  类PipedInputStream中定义为:  void connect(PipedOutputStream src);  类PipedOutputStream中定义为:  void connect(PipedInputStream snk);4.9.2 内存的读/写 1. ByteArrayInputStream和ByteArrayOutputStream   ByteArrayInputStream //从字节数组中读取以字节为单位的数据  ByteArrayOutputStream //向字节数组中写入以字节为单位的数据 2. StringBufferInputStream和StringBufferOutputStream   StringBufferInputStream   //从字符串缓冲区StringBuffer中读取以字符为单位的数据  StringBufferOutputStream   //向字符串缓冲区StringBuffer中写入以字符为单位的数据4.9.3 顺序输入流  SequenceInputStream 把几个输入流顺序连接起来。顺序输入流提供了把若干不同的流统一为同一个流的功能,使得程序变得更加简洁。【本讲小结】  例外处理是java语言中一个独特之处,主要使用捕获例外和声明抛弃例外两种方法来处理程序中可能出现例外的语句块,其中捕获例外的方法是一种积极地处理例外的方法,而声明抛弃例外是一种消极的处理例外的方法。  Java中的输入/输出处理是通过使用流技术,用统一的接口表示而实现的。输入/输出流中,最常见的是对文件的处理。Java语言中提供专门处理文件和目录的类,例如:java.io.File,java.io.FileInputStream,java.io.FileOutputStream,java.io.RandomAccessFile和接口java.io.FilenameFilter。输入/输出流根据处理的内容,分为字符流和字节流两种,其中字节流是以byte为基本处理单位的流;而字符流是以16位的Unicode码为处理单位的流。... 全文

处理程序 JAVA 设计 休闲 职场

Java EE CDI依赖注入教程

1. 简介Java EE CDI 主要使用@Inject注解来实现依赖注入,把受管理的bean注入到由容器管理的其它资源中去。在本教程中,我们将会介绍在CDI环境下几种不同的可选策略来实现依赖注入。本教程基于如下环境:JDK 1.7.0.21Weld 1.1.10Weld 是CDI 的参考实现。... 全文

CDI Java EE

Idea开发Java WEB 应用入门教程

作者:熔岩日期:2007-01-19MSN :leizhimin@126.com背景:Idea作为一个优秀的Java IDE,在国内却被Eclipse、NetBean的潮流所淹没,学习资料也少之又少,这是一篇入门级的Idea学习资料,配有丰富的图片说明。看完这篇文章后,你基本上和可以快速通过Idea来构建你的Java web应用了。图片我就没有发出来,你可以下载附件的doc文档来做详细阅读! 环境: idea-5.1.1Windows 2003 SP1中文版JDK:     1.4.2_11 实践:一、 打开Idea,新建一个项目(File→New Project),如图:  二、 点击“Next”,弹出一个消息框,提示要创建项目文件夹,单击“OK”即可,进入如图:  三、 点击“Next”,  四、 在此选择“single-module”,单击“Next”,如图:  五、 选择“Web Module”,单击“Next”,如图:  六、 按照图中蓝色字体填写,然后单击“Next”,如图:  七、 配置为Tomcat服务器,然后点击“Next”,如图:  八、 按照默认的填写内容,点击“Next”,如图:  九、 按照图中提示的填写后,单击“Next”,如图:  十、 保持默认的路径和文件夹,单击“Next”,如图:  十一、 按照图中蓝色的文字进行填写,然后单击“Next”,如图:  十二、 保持默认设置,单击“Finish”,如图:  十三、 提示将在一个新的idea窗口中打开当前新建的项目,选择“Yes”。将打开这个工程如图:  十四、 在Idea菜单栏里执行:Build→ReBuild Project,然后,再看项目文件夹D:\test\test_project_folder\web_mod_folder下面多出来一个文件夹:exploded,这个是编译项目所产生的。至此,用idea搭建一个WEB开发环境的简单过程就结束了。 这篇文章到此结束了,希望对使用Idea能起到一个抛砖引玉的作用,也希望你把你对Idea,以及本文的看法留下!  http://www.intellij.org.cn/bbs/viewtopic.php?f=3&t=674本文出自 “熔 岩” 博客,转载请与作者联系!... 全文

java web

Java 多玩家 libgdx 教程(1)

我们如何去做?在 libgdx的主页修改libgdx样本“superjumper".使用 AppWarp Cloud将它转化为2个玩家的实时游戏.本游戏将匹配玩家并且用户需要到达城堡来赢得游戏的胜利. 用户将获得其他用户成绩的实时反馈以增加了游戏的刺激性。 ... 全文

Java libgdx

JAVA教程 第七讲 Swing用户界面设计

7.1 Swing简介7.1.1 简介   第五讲中我们学习了AWT,AWT是Swing的基础。Swing的产生主要原因就是AWT不能满足图形化用户界面发展的需要。 AWT设计的初衷是支持开发小应用程序的简单用户界面。例如AWT缺少剪贴板、打印支持、键盘导航等特性,而且原来的AWT甚至不包括弹出式菜单或滚动窗格等基本元素。   此外AWT还存在着严重的缺陷,人们使AWT适应基于继承的、具有很大伸缩性的事件模型,基于同位体的体系结构也成为其致命的弱点。   随着发展的需要,Swing出现了,Swing组件几乎都是轻量组件,与重量组件相比,没有本地的对等组件,不像重量组件要在它们自己的本地不透明窗体中绘制,轻量组件在它们的重量组件的窗口中绘制。   这一讲我们讲一下基本的Swing组件使用方法和使用Swing组件创建用户界面的初步方法。  Swing是由100%纯Java实现的,Swing组件是用Java实现的轻量级( light-weight)组件,没有本地代码,不依赖操作系统的支持,这是它与AWT组件的最大区别。由于AWT组件通过与具体平台相关的对等类(Peer)实现,因此Swing比AWT组件具有更强的实用性。Swing在不同的平台上表现一致,并且有能力提供本地窗口系统不支持的其它特性。   Swing采用了一种MVC的设计范式,即"模型-视图-控制"(Model-View-Controller),其中模型用来保存内容,视图用来显示内容,控制器用来控制用户输入。   Swing外观感觉采用可插入的外观感觉(Pluggable Look and Feel,PL&F)   在AWT组件中,由于控制组件外观的对等类与具体平台相关,使得AWT组件总是只有与本机相关的外观。Swing使得程序在一个平台上运行时能够有不同的外观。用户可以选择自己习惯的外观。以下三幅图是在同一个操作系统下得到不同的外观。Metal风格 Motif风格 Windows风格... 全文

界面设计 JAVA 用户 休闲 职场

JAVA教程 第五讲 AWT图形用户界面设计

5.1 用AWT生成图形化用户界面   抽象窗口工具包AWT (Abstract Window Toolkit) 是 API为Java 程序提供的建立图形用户界面GUI (Graphics User Interface)工具集,AWT可用于Java的applet和applications中。它支持图形用户界面编程的功能包括: 用户界面组件;事件处理模型;图形和图像工具,包括形状、颜色和字体类;布局管理器,可以进行灵活的窗口布局而与特定窗口的尺寸和屏幕分辨率无关;数据传送类,可以通过本地平台的剪贴板来进行剪切和粘贴。5.1.1 java.awt包     java.awt包中提供了GUI设计所使用的类和接口,可从图5.1中看到主要类之间的关系。   java.awt包提供了基本的java程序的GUI设计工具。主要包括下述三个概念:   组件--Component   容器--Container   布局管理器--LayoutManager5.1.2 组件和容器   Java的图形用户界面的最基本组成部分是组件(Component),组件是一个可以以图形化的方式显示在屏幕上并能与用户进行交互的对象,例如一个按钮,一个标签等。组件不能独立地显示出来,必须将组件放在一定的容器中才可以显示出来。... 全文

处理程序 JAVA 设计 休闲 职场

《Java程序设计教程(第7版)》目录

作者简介作者:(美国)约翰刘易斯(John Lewis) (美国)威廉洛夫特斯(William Loftus) 译者:罗省贤 李军 等目录            第1章 计算机系统概述 1.1 计算机处理过程 1.1.1 软件的分类 1.1.2 数字计算机 1.1.3 二进制数 自测题 1.2 硬件组件 1.2.1 计算机结构 1.2.2 输入/输出设备 1.2.3 主存储器和辅助存储器 1.2.4 中央处理器 自测题 1.3 网络 1.3.1 网络连接 1.3.2 局域网和广域网 1.3.3 因特网 1.3.4 万维网 1.3.5 统一资源定位器 自测题 1.4 Java程序设计语言 1.4.1 Java程序 1.4.2 注释 1.4.3 标志符和保留字 ... 全文

程序设计 Java 美国 约翰

《Java程序设计教程(第7版)》John Lewis等

书名:《Java程序设计教程(第7版)》作者:约翰·刘易斯(John Lewis) (作者), 威廉·洛夫特斯(William Loftus) (作者), 罗省贤 (译者), 李军 (译者), 等 (译者) 参考价:¥ 59.00  图书描述出版日期: 2012年2月1日 ... 全文

学习Java 程序设计 刘易斯 练习题 出版社

windowsXP下搭建JAVA环境教程

一、工具准备安装JKD6:传送门:http://www.java.net/download/jdk6/6u10/promoted/b32/binaries/jdk-6u10-rc2-bin-b32-windows-i586-p-12_sep_2008.exe下载完成后默认安装即可!二、配置环境变量右键单击“我的电脑”,选择“属性”,然后点击“高级”,再点击“环境变量”,见下图:然后在下面的“环境变量”中新建变量:变量名:JAVA_HOME变量值:C:\Program Files\Java\jdk1.6.0_10 (因你电脑安装JAVA版本不同会不同)然后点击确定。再新建一个变量:变量名:CLASSPATH变量值:C:\Program Files\Java\jdk1.6.0_10\lib\dt.jar;C:\Program Files\Java\jdk1.6.0_10\lib\tools.jar;.   注意最后面有个小点然后点击确定。再找到Path变量,点击编辑,在它的变量值最后面加上;C:\Program Files\Java\jdk1.6.0_10\bin    注意前面有个分号然后点击确定全部完成后点击两次确定,就OK了。然后你运行cmd回车后看看再输入javac,出来一堆java命令就表示配置成功了。 ... 全文

1 2