美国上市职业教育机构

咨询电话:400-111-8989

2017最新Java课程

15986名师在线答疑

第一节:JAVA开发环境-1

课程描述学好Java,走遍天下,在使用Java之前,必须先搭建开发环境。讲授快速完成最著名的Java程序HelloWorld

主讲老师张东

8653名师在线答疑

第二节:JAVA开发环境-2-Eclipse IDE

课程描述学好Java,走遍天下,在使用Java之前,必须先搭建开发环境。讲授快速完成最著名的Java程序HelloWorld

主讲老师张东

9254名师在线答疑

第三节:JAVA变量-1-变量

课程描述简单来说,变量就是内存中的1个存储数据的空间。在程序中,只要程序用到一个数据,我们都要将它保存在变量中。

主讲老师张东

7841名师在线答疑

第四节:JAVA基础类型-1-整数类型

课程描述Java基本的数据类型以及这些数据类型之间如何转换。

主讲老师张东

9866名师在线答疑

第五节:JAVA基础类型-2-其他类型及类型转换

课程描述Java基本的数据类型以及这些数据类型之间如何转换。

主讲老师张东

8691名师在线答疑

第六节:运算符和表达式-1-算数运算

课程描述运算符:计算机中执行运算活判断的特殊符号,本节课利用生活息息相关的例子讲解运算符和表达式。

主讲老师张东

7852名师在线答疑

第七节:运算符和表达式-2-关系运算、逻辑运算

课程描述运算符:计算机中执行运算活判断的特殊符号,本节课利用生活息息相关的例子讲解运算符和表达式。

主讲老师张东

6986名师在线答疑

第八节:运算符和表达式-3-赋值运算,字符串连接运算

课程描述运算符:计算机中执行运算活判断的特殊符号,本节课利用生活息息相关的例子讲解运算符和表达式。

主讲老师张东

5976名师在线答疑

第九节:运算符和表达式-4-三目运算

课程描述运算符:计算机中执行运算活判断的特殊符号,本节课利用生活息息相关的例子讲解运算符和表达式。

主讲老师张东

7596名师在线答疑

第十节:运算符和表达式-5-收银柜台收款程序V1.0

课程描述运算符:计算机中执行运算活判断的特殊符号,本节课利用生活息息相关的例子讲解运算符和表达式。

主讲老师张东

6983名师在线答疑

第十一节:循环结构-1-while语句

课程描述Java当中实现循环结构有三种语句,三种实现语句的要素却完全相同。

主讲老师张东

9853名师在线答疑

第十二节:循环结构-2-do-while语句

课程描述Java当中实现循环结构有三种语句,三种实现语句的要素却完全相同。

主讲老师张东

6876名师在线答疑

第十三节:循环结构-3-for语句

课程描述Java当中实现循环结构有三种语句,三种实现语句的要素却完全相同。

主讲老师张东

5967名师在线答疑

第十四节:循环结构-4-随机加法运算器

课程描述Java当中实现循环结构有三种语句,三种实现语句的要素却完全相同。

主讲老师张东

7952名师在线答疑

第十五节:循环结构-5-循环嵌套

课程描述Java当中实现循环结构有三种语句,三种实现语句的要素却完全相同。

主讲老师张东

4799名师在线答疑

第十六节:基本正则表达式-1-定义抽象类

课程描述正则表达式即为字符串中中字符出现的规则,当我们想要验证一个字符串的格式或者查找一段文章中的关键字的时候,可以使用正则表达式。

主讲老师张东

6583名师在线答疑

第十七节:基本正则表达式-2-使用抽象类

课程描述正则表达式即为字符串中中字符出现的规则,当我们想要验证一个字符串的格式或者查找一段文章中的关键字的时候,可以使用正则表达式。

主讲老师张东

5761名师在线答疑

第十八节:基本正则表达式-3-使用抽象方法

课程描述正则表达式即为字符串中中字符出现的规则,当我们想要验证一个字符串的格式或者查找一段文章中的关键字的时候,可以使用正则表达式。

主讲老师张东

8653名师在线答疑

第十九节:基本正则表达式-4-接口定义

课程描述正则表达式即为字符串中中字符出现的规则,当我们想要验证一个字符串的格式或者查找一段文章中的关键字的时候,可以使用正则表达式。

主讲老师张东

7825名师在线答疑

第二十节:基本正则表达式-5-实现接口

课程描述正则表达式即为字符串中中字符出现的规则,当我们想要验证一个字符串的格式或者查找一段文章中的关键字的时候,可以使用正则表达式。

主讲老师张东

9542名师在线答疑

第二十一节:基本正则表达式-6-测试银联接口

课程描述正则表达式即为字符串中中字符出现的规则,当我们想要验证一个字符串的格式或者查找一段文章中的关键字的时候,可以使用正则表达式。

主讲老师张东

11534名师在线答疑

第二十二节:继承的意义-1-继承

课程描述继承就是使用一个类的定义,复制并扩展出一个新的类型,新类型可以使用原类型的属性和功能,也可以扩展出个性化的属性和功能。

主讲老师张东

8924名师在线答疑

第二十三节:继承的意义-2-重写

课程描述继承就是使用一个类的定义,复制并扩展出一个新的类型,新类型可以使用原类型的属性和功能,也可以扩展出个性化的属性和功能。

主讲老师张东

6854名师在线答疑

第二十四节:多态-1-多态的意义与向上转型

课程描述多态即为同一个东西在不同的情况下表现出不同的状态。

主讲老师张东

6623名师在线答疑

第二十五节:多态-2-引用类型强制转换

课程描述多态即为同一个东西在不同的情况下表现出不同的状态。

主讲老师张东

6234名师在线答疑

第二十六节:多态-3-instanceof关键字

课程描述多态即为同一个东西在不同的情况下表现出不同的状态。

主讲老师张东

6234名师在线答疑

第二十七节:接口-1-接口定义

课程描述在Java中接口是一组方法定义的集合,但是这些方法仅有定义,均未实现。接口为程序中的合同即设计标准。

主讲老师张东

8621名师在线答疑

第二十八节:接口-2-实现接口

课程描述在Java中接口是一组方法定义的集合,但是这些方法仅有定义,均未实现。接口为程序中的合同即设计标准。

主讲老师张东

6841名师在线答疑

第二十九节:接口-3-测试银联接口

课程描述在Java中接口是一组方法定义的集合,但是这些方法仅有定义,均未实现。接口为程序中的合同即设计标准。

主讲老师张东

6521名师在线答疑

第三十节:接口-4-接口的继承

课程描述在Java中接口是一组方法定义的集合,但是这些方法仅有定义,均未实现。接口为程序中的合同即设计标准。

主讲老师张东

7545名师在线答疑

第三十一节:接口-5-继承父类并实现接口

课程描述在Java中接口是一组方法定义的集合,但是这些方法仅有定义,均未实现。接口为程序中的合同即设计标准。

主讲老师张东

9514名师在线答疑

第三十二节:接口-6-接口多继承与接口方法调用

课程描述在Java中接口是一组方法定义的集合,但是这些方法仅有定义,均未实现。接口为程序中的合同即设计标准。

主讲老师张东

11254名师在线答疑

第三十三节:接口-7-接口与抽象类的差别

课程描述在Java中接口是一组方法定义的集合,但是这些方法仅有定义,均未实现。接口为程序中的合同即设计标准。

主讲老师张东

  • 第一节:JAVA开发环境-1-JAVA开发环境

    总监级名师:张东

    15986

  • 第二节:JAVA开发环境-2-Eclipse IDE

    总监级名师:张东

    8653

  • 第三节:JAVA变量-1-变量

    总监级名师:张东

    9254

  • 第四节:JAVA基础类型-1-整数类型

    总监级名师:张东

    7841

  • 第五节:JAVA基础类型-2-其他类型及类型转换

    总监级名师:张东

    9866

  • 第六节:运算符和表达式-1-算数运算

    总监级名师:张东

    8691

  • 第七节:运算符和表达式-2-关系运算、逻辑运算

    总监级名师:张东

    7852

  • 第八节:运算符和表达式-3-赋值运算,字符串连接运算

    总监级名师:张东

    6986

  • 第九节:运算符和表达式-4-三目运算

    总监级名师:张东

    5976

  • 第十节:运算符和表达式-5-收银柜台收款程序V1.0

    总监级名师:张东

    7596

  • 第十一节:循环结构-1-while语句

    总监级名师:张东

    6983

  • 第十二节:循环结构-2-do-while语句

    总监级名师:张东

    9853

  • 第十三节:循环结构-3-for语句

    总监级名师:张东

    6876

  • 第十四节:循环结构-4-随机加法运算器

    总监级名师:张东

    5967

  • 第十五节:循环结构-5-循环嵌套

    总监级名师:张东

    7952

  • 第十六节:基本正则表达式-1-定义抽象类

    总监级名师:张东

    4799

  • 第十七节:基本正则表达式-2-使用抽象类

    总监级名师:张东

    6583

  • 第十八节:基本正则表达式-3-使用抽象方法

    总监级名师:张东

    5761

  • 第十九节:基本正则表达式-4-接口定义

    总监级名师:张东

    8653

  • 第二十节:基本正则表达式-5-实现接口

    总监级名师:张东

    7825

  • 第二十一节:基本正则表达式-6-测试银联接口

    总监级名师:张东

    9542

  • 第二十二节:继承的意义-1-继承

    总监级名师:张东

    11534

  • 第二十三节:继承的意义-2-重写

    总监级名师:张东

    8924

  • 第二十四节:多态-1-多态的意义与向上转型

    总监级名师:张东

    6854

  • 第二十五节:多态-2-引用类型强制转换

    总监级名师:张东

    6623

  • 第二十六节:多态-3-instanceof关键字

    总监级名师:张东

    6234

  • 第二十七节:接口-1-接口定义

    总监级名师:张东

    7852

  • 第二十八节:接口-2-实现接口

    总监级名师:张东

    8621

  • 第二十九节:接口-3-测试银联接口

    总监级名师:张东

    6841

  • 第三十节:接口-4-接口的继承

    总监级名师:张东

    6521

  • 第三十一节:接口-5-继承父类并实现接口

    总监级名师:张东

    7545

  • 第三十二节:接口-6-接口多继承与接口方法调用

    总监级名师:张东

    9514

  • 第三十三节:接口-7-接口与抽象类的差别

    总监级名师:张东

    11254

更多教程 》

我们不共享单车,我们只共享干货

达内简介

一、达内教育集团简介

达内教育集团【美股交易代码:TEDU】(简称达内集团)成立于2002年9月,2014年4月,达内教育集团成功在美国纳斯达克上市,融资1亿3千万美元,是中国在美国上市的职业教育集团,根据IDC的数据,达内教育集团是目前国内领先的职业教育机构,市场份额超过8.3%。

达内集团以中关村为依托,目前已在北京、上海、广州、深圳、大连、南京、武汉、杭州、西安、苏州、成都、沈阳等42个大中城市成立了160家学习中心,拥有员工超过7000人,2016年培训量已达11万人次。达内集团凭借雄厚的技术研发实力、过硬的教学质量、成熟的就业服务体系,在用人企业中树立了良好的口碑,连续3年复合增长率超过50%。

达内的15年,是互联网快速发展的15年。在互联网发展的不同阶段,达内的课程紧跟互联网发展的步伐,15年不断的创新,打造覆盖IT全产业链的职业课程版图。目前开设Java、Java大数据、Android、iOS、PHP、软件测试、嵌入式、C++、C#、UID、UED、产品经理、Linux云计算、Web前端、VR、网络营销、高级电商、主办会计、Python等21大课程体系,为中国企业提供全面的IT互联网人才服务,并为全行业提供高级应用型人才。达内拥有行业内完善的教研团队,200位知名讲师,1500名教研人员,全方位保障学员来自一线企业的知名技术专家团队担纲教学,并且一线的行业专家组合授课,课程更具较强实操性。

达内教育集团确定了”一站式职业人才培训提供商、一站式人才输送提供商、一站式软件开发提供商”的三大定位。把“缔造年轻人的中国梦”作为所有达内人奋斗的企业使命。

二、达内教育集团与高校、企业合作

达内发展的十五年,就是推动中国高校校企合作、产融结合的十五年,就是推动中国高校职业教育改革的十五年,从达内成立之初,高校一直是达内的亲密合作伙伴,并推出高端教育品牌“英才添翼”,“英才添翼”始终致力于成为中国职业教育改革一站式解决方案提供商,以合作办学,合作育人,合作就业,合作发展为主线,提出了达内高校教学体系解决方案,达内高校全方位实习解决方案,达内高校大学生就业解决方案、企业级师资培训解决方案四大解决方案。达内“英才添翼”与全国800余家高校深度合作、专业共建,把企业的项目搬到学校,把学校的课堂搬到企业,工程师和高校老师共同协作双师教学,实现了产教共融,协同发展,更好的培养高素质人才。从2016年开始,达内集团成为教育部产学合作协同育人单位。

达内发展离不开与企业的密切合作,达内在全国建立5大软件人才中心600人才顾问每天不断与全国上万家企业保持联系和沟通。通过15年达内不断地探索与尝试,达内与国内外知名企业建立人才推荐,人才定制培养、人才租赁与外包、代理校园招聘、IT猎头、企业内训等多样化的合作方式和一站式的服务体系。截止到2016年12月底,达内与全国9万家知名企业建立合作关系,每个月在达内全国中心有近600场的企业双选会,达内还会定期做专场招聘会,正是与企业的紧密合作关系,达内学员保持行业领先的学员就业率,2016年实现了95%以上的就业率。

三、达内荣誉

达内教育集团以良好的教学及经营模式,近年来荣获了各界权威机构的颁奖

2006、2007、2008、2009连续4年入选德勤评选的“中国高科技高成长50强公司”、“亚太地区高科技高成长500强公司”;

中关村管理委员会指定的“软件人才培养示范基地”;

北京市商务委、北京市教委联合评为“首批服务外包人才培训机构”;

荣获《计算机世界》评选的“就业服务杰出贡献奖”;

荣获《中国计算机报》评选的“最具影响力培训机构奖”;

被搜狐评为“中国十大教育集团”;

被腾讯评为“中国大学生心目中最具影响力的IT品牌”;

2010年与百度、搜狐、中兴电子等著名企业一起被欧美同学会评为中国海外归国人员创业“腾飞奖”中国50强优秀企业;

2011年获得中央电视台评选的中国教育行业“领军企业”;

2012年9月获凤凰网、网易财经、影响力峰会组委会评选的“2012年度最具信赖企业”大奖;

2012、2013年 荣获普华永道和高企协颁发“2011中关村高成长企业TOP100”;

2013年荣获智联招聘中国年度雇主“北京30强”企业等大奖;

百度“2014百度数据资产卓越奖”;

新浪网“2015新浪中国品牌影响力教育集团”;

腾讯“2015年度影响力教育集团”;

中国好教育“广受学员好评的职业教育机构”。

更多教程 》

达内与Java

一.达内Java课程企业级应用课程优势

1. 夯实Java 基础:当前的Java 新技术层出不穷,各企业有不同的侧重,根据企业用人需求,只有具备坚实的Java 基础功底的程序员才能快速掌握新技术。达内的Java 基础课程体系的深度在行业内首屈一指,学员会在核心算法、面向对象应用、数据结构及集合 框架、反射、输入输出、多线程、异常处理等方面深入细致地学习,而这些正是企业面试中最常涉及的问题,是学员获得高薪的基础。

2. 熟习Linux 操作系统:Linux 是当前使用最广泛的服务器操作系统。达内的Java 授课过程全程在Linux 环境中完成(学员使用电脑全部为Linux 环境),同时还专门设有Linux 的相关课程。学员在成为合格的Java 工程师的同时还会具备熟练的Linux 操作技巧,这正是在企业面试中获得加分的重要指标之一。

3. 深入学习数据库技术:当前的企业及互联网应用完全离不开数据库技术。在任何一个大中型应用中,数据库设计的好坏、数据库访问的效率直接决定了该项目的成败。达内的数据库技术包括当前最主流的Oracle 和MySQL 两种数据库,内容全面深入。除了数据库体系结构和SQL 语句之外,还在数据库设计、SQL 语句优化方面有很大的加强。

4. 系统的Web 前端技术:伴随着互联网技术由Web2.0 向Web3.0 迈进,Web 前端技术,包括HTML、CSS 特别是JavaScript 语言越来越被企业所看重。很多企业专门为此新增 “Web 前端工程师”岗位。达内的Java 课程体系为此设置充足时间学习JavaScript 及其相关的Ajax、JQuery 框架、Ext-JS 框架。毫不夸张地说,如果完全掌握了达内的Web 前端技术,甚至仅凭借JavaScript 技能就可收获一份不错的工作。

5. 企业级框架: Java 是组件和框架的世界,几乎所有的Java 程序员和Java 应用企业都了解Java 框架的重要性。达内技术专家经过严谨调研,了解Java 企业客户实际应用需求,按照企业需要定制了企业级框架课程。

(1) 在Servlet/JSP 课程中会独立完成一个Struts1 的框架, 这样就既了解了Struts1,又深入学习了MVC 框架的底层原理。

(2) 作为Java 框架的佼佼者,Spring 在企业应用中的地位一路攀升。新课程体系中进一步增加Spring 的课程量,增加对其深入的了解,并且会涉及到由Spring 衍生出的SpringSide 等“脚手架”型框架。

(3) 在深入领悟Spring 核心基础之上,重点加强目前最热的Spring MVC 和Spring JDBC 内容,与企业实际应用接轨。

(4) 数据持久层框架重点学习编码简洁,运行高效的MyBatis 框架,并且也保留经典的轻量级框架Hibernate 课程内容。

(5) 在学习了流行的Spring MVC + MyBatis 框架整体解决方案之后也要学习经典的SSH 整合使用技术,全面且不落伍。

6. 专门的企业开发及部署环境:企业在开发、测试、部署实际项目时需要有特定的软件环境。很多企业和学员不太重视这些环境,导致在工作中出现很多问题和失误甚至被淘汰。达内Java 课程体系中加入了专门的企业开发及部署环境课程,重点讲述Linux 高级命令及脚本编程、远程登录、Ant、单元测试技术、Maven 构建技术、SVN 应用技术等等。

7. 规范的企业开发流程及文档:软件开发是团队合作,因此企业开发流程和文档规范尤为重要。这也是企业区分“草根程序员”和“正规程序员”的重要指标之一。达内Java 课程所有的实践项目,无论规模大小,都严格按照企业开发的流程进行(需求分析、系统设计、编码实现、单元测试、系统测试、部署上线),所有的开发文档完全达到甚至已经超过了大多数企业的要求。

8. 云计算与互联网架构技术:云计算和互联网架构技术已经广泛应用到互联网软件开发与生产过程中,已经成为软件开发不可或缺的一部分。达内与阿里云合作提供了云计算和互联网架构应用课程,从基础的云服务器到完整的互联网架构搭建,从基础Java 环境安装到Redis、Nginx 应用详实完整,全力助力学员的全栈能力。

二.Java大数据课程三大独特优势

1.JAVAEE 深度开发

达内Java 大数据课程不仅要让学生掌握如何使用框架开发系统,而且要深入框架内部源代码,这样的做法为学生后续在企业通往架构师的道路做了很好的铺垫,学生可以更加自信的进入企业工作。

2.互联网架构

在这个互联网的时代,每一个软件公司都在往互联网化的方向发展,所以掌握了互联网架构的内容等于紧跟时代,做公司最出色的程序员。达内Java 大数据课程体系在互联网架构方面涉及比较全面,既有负载均衡Nginx,也有基于搜索Solr,缓存Redis 等。当学习完这些课程以后,已经对互联网架构有一定实操和熟练。

3.大数据开发

达内Java 大数据课程注重底层的学习,在学习hadoop 之前,要通过一个项目学习hadoop 的底层知识点。有NIO,RPC,AVRO 等内容。同时还注重上层应用。既有基于电信的zebra 项目,也有基于电商的大数据分析项目让学生通过大数据阶段的学习,能够快速在公司上手开发。

三.达内Java名师

刘苍松JAVA教研部总监

工作经历:具有10 年的Java 企业应用开发经验。曾经历任德国Software AG 技术顾问,美国Dachieve 系统架构师,美国AngelEngineers Inc. 系统架构师。

授课风格:授课思维严谨灵活,将复杂的业务应用逻辑以直观浅显的方式阐述

程祖红JAVA总监级讲师

工作经历:先后在神州数码、根网科技、托普软件、北大方正春元、国信易博等软件公司从事软件开发、设计及管理工作。

授课风格:讲授以细腻见长,善于以日常生活的例子加以类比、引导学生建立起编程中的逻辑思维能力。

王克晶JAVA总监级讲师

工作经历:浪潮集团前资深项目经理。精通Java与.NET 技术, 熟练的跨平台面向对象开发经验,技术功底深厚。

授课风格:授课风格清新自然、条理清晰、主次分明、重点难点突出、引人入胜。

范传奇JAVA总监级讲师

工作经历:曾任职联想集团,参与开发了新疆省电信公司政企客户管理系统。任职万游在线,先后参与了《斗破苍穹》《 时空之门》等网络游戏的后台服务端开发。

授课风格:授课自然、幽默、生动,教学效果优秀。

李洪鹤JAVA总监级讲师

工作经历:曾任用友公司软件设计师,具有7 年的JAVA 企业应用开发和内训经验。

授课风格:授课幽默风趣、深入浅出。以企业核心应用为导向,教学时引导学员建立起企业开发模式的思维。

刘雪松JAVA总监级讲师

工作经历:十多年金融行业软件的开发和部门管理经验 。曾先后在人大金仓、万得时代和赢时胜担任高级开发工程师职务。在赢时胜研发中心的开发部担任了八年的部门经理。

授课风格:定位教练而非演讲家。课堂上重视实操、案例丰富、可操作性强,贴近真实应用。讲课深入浅出,通俗易懂,能结合鲜活事例增强学员注意力和听课兴趣。

更多教程 》

Java 简介

Java是由Sun Microsystems公司于1995年5月推出的Java面向对象程序设计语言和Java平台的总称。由James Gosling和同事们共同研发,并在1995年正式推出。

Java分为三个体系:

• JavaSE(J2SE)(Java2 Platform Standard Edition,java平台标准版)

• JavaEE(J2EE)(Java 2 Platform,Enterprise Edition,java平台企业版)

• JavaME(J2ME)(Java 2 Platform Micro Edition,java平台微型版)。

主要特性

• Java语言是简单的:

Java语言的语法与C语言和C++语言很接近,使得大多数程序员很容易学习和使用。另一方面,Java丢弃了C++中很少使用的、很难理解的、令人迷惑的那些特性,如操作符重载、多继承、自动的强制类型转换。特别地,Java语言不使用指针,而是引用。并提供了自动的废料收集,使得程序员不必为内存管理而担忧。

• Java语言是面向对象的:

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

• Java语言是分布式的:

Java语言支持Internet应用的开发,在基本的Java应用编程接口中有一个网络应用编程接口(java net),它提供了用于网络应用编程的类库,包括URL、URLConnection、Socket、ServerSocket等。Java的RMI(远程方法激活)机制也是开发分布式应用的重要手段。

• Java语言是健壮的:

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

• Java语言是安全的:

Java通常被用在网络环境中,为此,Java提供了一个安全机制以防恶意代码的攻击。除了Java语言具有的许多安全特性以外,Java对通过网络下载的类具有一个安全防范机制(类ClassLoader),如分配不同的名字空间以防替代本地的同名类、字节代码检查,并提供安全管理机制(类SecurityManager)让Java应用设置安全哨兵。

• Java语言是体系结构中立的:

Java程序(后缀为java的文件)在Java平台上被编译为体系结构中立的字节码格式(后缀为class的文件),然后可以在实现这个Java平台的任何系统中运行。这种途径适合于异构的网络环境和软件的分发。

• Java语言是可移植的:

这种可移植性来源于体系结构中立性,另外,Java还严格规定了各个基本数据类型的长度。Java系统本身也具有很强的可移植性,Java编译器是用Java实现的,Java的运行环境是用ANSI C实现的。

• Java语言是解释型的:

如前所述,Java程序在Java平台上被编译为字节码格式,然后可以在实现这个Java平台的任何系统中运行。在运行时,Java平台中的Java解释器对这些字节码进行解释执行,执行过程中需要的类在联接阶段被载入到运行环境中。

• Java是高性能的:

与那些解释型的高级脚本语言相比,Java的确是高性能的。事实上,Java的运行速度随着JIT(Just-In-Time)编译器技术的发展越来越接近于C++。

• Java语言是多线程的:

在Java语言中,线程是一种特殊的对象,它必须由Thread类或其子(孙)类来创建。通常有两种方法来创建线程:其一,使用型构为Thread(Runnable)的构造子将一个实现了Runnable接口的对象包装成一个线程,其二,从Thread类派生出子类并重写run方法,使用该子类创建的对象即为线程。值得注意的是Thread类已经实现了Runnable接口,因此,任何一个线程均有它的run方法,而run方法中包含了线程所要运行的代码。线程的活动由一组方法来控制。Java语言支持多个线程的同时执行,并提供多线程之间的同步机制(关键字为synchronized)。

• Java语言是动态的:

Java语言的设计目标之一是适应于动态变化的环境。Java程序需要的类能够动态地被载入到运行环境,也可以通过网络来载入所需要的类。这也有利于软件的升级。另外,Java中的类有一个运行时刻的表示,能进行运行时刻的类型检查。

Java开发工具

Java语言尽量保证系统内存在1G以上,其他工具如下所示:

• Linux 系统、Mac OS 系统、Windows 95/98/2000/XP,WIN 7/8系统。

• Java JDK 7、8……

• Notepad 编辑器或者其他编辑器。

• IDE:Eclipse

更多教程 》

Java 开发环境配置

window系统安装java

下载JDK

首先我们需要下载java开发工具包JDK,
下载地址:http://www.oracle.com/technetwork/java/javase/downloads/index.html,
点击如下下载按钮:

在下载页面中你需要选择接受许可,并根据自己的系统选择对应的版本,本文以 Window 64位系统为例:

下载后JDK的安装根据提示进行,还有安装JDK的时候也会安装JRE,一并安装就可以了。

安装JDK,安装过程中可以自定义安装目录等信息,例如我们选择安装目录为 C:\Program Files (x86)\Java\jdk1.8.0_91。

配置环境变量

1.安装完成后,右击"我的电脑",点击"属性",选择"高级系统设置";

2.选择"高级"选项卡,点击"环境变量";

然后就会出现如下图所示的画面:

在"系统变量"中设置3项属性,JAVA_HOME,PATH,CLASSPATH(大小写无所谓),若已存在则点击"编辑",不存在则点击"新建"。变量设置参数如下:

变量名:JAVA_HOME

变量值:C:\Program Files (x86)\Java\jdk1.8.0_91 // 要根据自己的实际路径配置

变量名:CLASSPATH

变量值:.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar; //记得前面有个"."

变量名:Path

变量值:%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;

JAVA_HOME 设置

PATH设置

CLASSPATH 设置

这是 Java 的环境配置,配置完成后,你可以启动 Eclipse 来编写代码,它会自动完成java环境的配置。

注意:如果使用1.5以上版本的JDK,不用设置CLASSPATH环境变量,也可以正常编译和运行Java程序。

测试JDK是否安装成功

1、"开始"->"运行",键入"cmd";

2、键入命令: java -version、java、javac 几个命令,出现以下信息,说明环境变量配置成功;

Linux,UNIX,Solaris,FreeBSD环境变量设置

环境变量PATH应该设定为指向Java二进制文件安装的位置。如果设置遇到困难,请参考shell文档。

例如,假设你使用bash作为shell,你可以把下面的内容添加到你的 .bashrc文件结尾: export PATH=/path/to/java:$PATH

流行JAVA开发工具

正所谓工欲善其事必先利其器,我们在开发java语言过程中同样需要依款不错的开发工具,目前市场上的IDE很多,本文为大家推荐以下下几款java开发工具:

Eclipse(推荐):另一个免费开源的java IDE,下载地址: http://www.eclipse.org/

选择 Eclipse IDE for Java Developers:

Notepad++ : Notepad++ 是在微软视窗环境之下的一个免费的代码编辑器,下载地址: http://notepad-plus-plus.org/

Netbeans:开源免费的java IDE,下载地址: http://www.netbeans.org/index.html

更多教程 》

Java 基础语法

一个Java程序可以认为是一系列对象的集合,而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。

对象:对象是类的一个实例,有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。

类:类是一个模板,它描述一类对象的行为和状态。

方法:方法就是行为,一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。

实例变量:每个对象都有独特的实例变量,对象的状态由这些实例变量的值决定。

第一个Java程序

下面看一个简单的Java程序,它将打印字符串 Hello World

下面将逐步介绍如何保存、编译以及运行这个程序:

打开Notepad,把上面的代码添加进去;

把文件名保存为:HelloWorld.java;

打开cmd命令窗口,进入目标文件所在的位置,假设是C:\

在命令行窗口键入 javac HelloWorld.java 按下enter键编译代码。如果代码没有错误,cmd命令提示符会进入下一行。(假设环境变量都设置好了)。

再键入java HelloWorld 按下Enter键就可以运行程序了

你将会在窗口看到 Hello World

Gif 图演示:

基本语法

编写Java程序时,应注意以下几点:

大小写敏感:Java是大小写敏感的,这就意味着标识符Hello与hello是不同的。

类名:对于所有的类来说,类名的首字母应该大写。如果类名由若干单词组成,那么每个单词的首字母应该大写,例如 MyFirstJavaClass 。

方法名:所有的方法名都应该以小写字母开头。如果方法名含有若干单词,则后面的每个单词首字母大写。

源文件名:源文件名必须和类名相同。当保存文件的时候,你应该使用类名作为文件名保存(切记Java是大小写敏感的),文件名的后缀为.java。(如果文件名和类名不相同则会导致编译错误)。

主方法入口:所有的Java 程序由public static void main(String []args)方法开始执行。

Java标识符

Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

关于Java标识符,有以下几点需要注意:

所有的标识符都应该以字母(A-Z或者a-z),美元符($)、或者下划线(_)开始

首字符之后可以是字母(A-Z或者a-z),美元符($)、下划线(_)或数字的任何字符组合

关键字不能用作标识符

标识符是大小写敏感的

合法标识符举例:age、$salary、_value、__1_value

非法标识符举例:123abc、-salary

Java修饰符

像其他语言一样,Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符:

访问控制修饰符 : default, public , protected, private

非访问控制修饰符 : final, abstract, strictfp

在后面的章节中我们会深入讨论Java修饰符。

Java变量

Java中主要有如下几种类型的变量

局部变量

类变量(静态变量)

成员变量(非静态变量)

Java数组

数组是储存在堆上的对象,可以保存多个同类型变量。在后面的章节中,我们将会学到如何声明、构造以及初始化一个数组。

Java枚举

Java 5.0引入了枚举,枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的bug。

例如,我们为果汁店设计一个程序,它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。

实例

注意:枚举可以单独声明或者声明在类里面。方法、变量、构造函数也可以在枚举中定义。

Java关键字

下面列出了Java保留字。这些保留字不能用于常量、变量、和任何标识符的名称。

关键字 描述
abstract 抽象方法,抽象类的修饰符
assert 断言条件是否满足
boolean 布尔数据类型
break 跳出循环或者label代码段
byte 8-bit 有符号数据类型
case switch语句的一个条件
catch 和try搭配捕捉异常信息
char 16-bit Unicode字符数据类型
class 定义类
const 未使用
continue 不执行循环体剩余部分
default switch语句中的默认分支
do 循环语句,循环体至少会执行一次
double 64-bit双精度浮点数
else if条件不成立时执行的分支
enum 枚举类型
extends 表示一个类是另一个类的子类
final 表示一个值在初始化之后就不能再改变了
表示方法不能被重写,或者一个类不能有子类
finally 为了完成执行的代码而设计的,主要是为了程序的健壮性和完整性,无论有没有异常发生都执行代码。
float 32-bit单精度浮点数
for for循环语句
goto 未使用
if 条件语句
implements 表示一个类实现了接口
import 导入类
instanceof 测试一个对象是否是某个类的实例
int 32位整型数
interface 接口,一种抽象的类型,仅有方法和常量的定义
long 64位整型数
native 表示方法用非java代码实现
new 分配新的类实例
package 一系列相关类组成一个包
private 表示私有字段,或者方法等,只能从类内部访问
protected 表示字段只能通过类或者其子类访问
子类或者在同一个包内的其他类
public 表示共有属性或者方法
return 方法返回值
short 16位数字
static 表示在类级别定义,所有实例共享的
strictfp 浮点数比较使用严格的规则
super 表示基类
switch 选择语句
synchronized 表示同一时间只能由一个线程访问的代码块
this 表示调用当前实例
或者调用另一个构造函数
throw 抛出异常
throws 定义方法可能抛出的异常
transient 修饰不要序列化的字段
try 表示代码块要做异常处理或者和finally配合表示是否抛出异常都执行finally中的代码
void 标记方法不返回任何值
volatile 标记字段可能会被多个线程同时访问,而不做同步
while while循环

Java注释

类似于C/C++,Java也支持单行以及多行注释。注释中的字符将被Java编译器忽略。

Java 空行

空白行,或者有注释的行,Java编译器都会忽略掉。

继承

在Java中,一个类可以由其他类派生。如果你要创建一个类,而且已经存在一个类具有你所需要的属性或方法,那么你可以将新创建的类继承该类。

利用继承的方法,可以重用已存在类的方法和属性,而不用重写这些代码。被继承的类称为超类(super class),派生类称为子类(subclass)。

接口

在Java中,接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。

接口只定义派生要用到的方法,但是方法的具体实现完全取决于派生类。

Java 源程序与编译型运行区别

如下图所示:

更多教程 》

Java 基本数据类型

变量就是申请内存来存储值。也就是说,当创建变量的时候,需要在内存中申请空间。

内存管理系统根据变量的类型为变量分配存储空间,分配的空间只能用来储存该类型数据。

因此,通过定义不同类型的变量,可以在内存中储存整数、小数或者字符。

Java 的两大数据类型:

内置数据类型

引用数据类型

内置数据类型

Java语言提供了八种基本类型。六种数字类型(四个整数型,两个浮点型),一种字符类型,还有一种布尔型。

byte:

byte 数据类型是8位、有符号的,以二进制补码表示的整数;

最小值是 -128(-2^7);

最大值是 127(2^7-1);

默认值是 0;

byte 类型用在大型数组中节约空间,主要代替整数,因为 byte 变量占用的空间只有 int 类型的四分之一;

例子:byte a = 100,byte b = -50。

short:

short 数据类型是 16 位、有符号的以二进制补码表示的整数

最小值是 -32768(-2^15);

最大值是 32767(2^15 - 1);

Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一;

默认值是 0;

例子:short s = 1000,short r = -20000。

int:

int 数据类型是32位、有符号的以二进制补码表示的整数;

最小值是 -2,147,483,648(-2^31);

最大值是 2,147,483,647(2^31 - 1);

一般地整型变量默认为 int 类型;

默认值是 0 ;

例子:int a = 100000, int b = -200000。

long:

long 数据类型是 64 位、有符号的以二进制补码表示的整数;

最小值是 -9,223,372,036,854,775,808(-2^63);

最大值是 9,223,372,036,854,775,807(2^63 -1);

这种类型主要使用在需要比较大整数的系统上;

默认值是 0L;

例子: long a = 100000L,Long b = -200000L。

"L"理论上不分大小写,但是若写成"l"容易与数字"1"混淆,不容易分辩。所以最好大写。

float:

float 数据类型是单精度、32位、符合IEEE 754标准的浮点数;

float 在储存大型浮点数组的时候可节省内存空间;

默认值是 0.0f;

浮点数不能用来表示精确的值,如货币;

例子:float f1 = 234.5f。

double:

double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数;

浮点数的默认类型为double类型;

double类型同样不能表示精确的值,如货币;

默认值是 0.0d;

例子:double d1 = 123.4。

boolean:

boolean数据类型表示一位的信息;

只有两个取值:true 和 false;

这种类型只作为一种标志来记录 true/false 情况;

默认值是 false;

例子:boolean one = true。

char:

char类型是一个单一的 16 位 Unicode 字符;

最小值是 \u0000(即为0);

最大值是 \uffff(即为65,535);

char 数据类型可以储存任何字符;

例子:char letter = 'A';。

实例

对于数值类型的基本类型的取值范围,我们无需强制去记忆,因为它们的值都已经以常量的形式定义在对应的包装类中了。请看下面的例子:

编译以上代码输出结果如下所示:

Float和Double的最小值和最大值都是以科学记数法的形式输出的,结尾的"E+数字"表示E之前的数字要乘以10的多少次方。比如3.14E3就是3.14 × 103 =3140,3.14E-3 就是 3.14 x 10-3 =0.00314。

实际上,JAVA中还存在另外一种基本类型void,它也有对应的包装类 java.lang.Void,不过我们无法直接对它们进行操作。

引用类型

在Java中,引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象,指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型,比如 Employee、Puppy 等。变量一旦声明后,类型就不能被改变了。

对象、数组都是引用数据类型。

所有引用类型的默认值都是null。

一个引用变量可以用来引用与任何与之兼容的类型。

例子:Site site = new Site("Runoob")。

Java常量

常量在程序运行时,不会被修改的量。

在 Java 中使用 final 关键字来修饰常量,声明方式和变量类似:

final double PI = 3.1415927;

虽然常量名也可以用小写,但为了便于识别,通常使用大写字母表示常量。

字面量可以赋给任何内置类型的变量。例如:

byte a = 68;

char a = 'A'

byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。

当使用常量的时候,前缀0表示8进制,而前缀0x代表16进制。例如:

int decimal = 100;

int octal = 0144;

int hexa = 0x64;

和其他语言一样,Java的字符串常量也是包含在两个引号之间的字符序列。下面是字符串型字面量的例子:

"Hello World"

"two\nlines"

"\"This is in quotes\""

字符串常量和字符常量都可以包含任何Unicode字符。例如:

char a = '\u0001';

String a = "\u0001";

Java语言支持一些特殊的转义字符序列。

符号 字符含义
符号 字符含义
\n 换行 (0x0a)
\r 回车 (0x0d)
\f 换页符(0x0c)
\b 退格 (0x08)
\0 空格 (0x20)
\s 字符串
\t 制表符
\" 双引号
\' 单引号
\\ 反斜杠
\ddd 八进制字符 (ddd)
\uxxxx 16进制Unicode字符 (xxxx)

自动类型转换

整型、实型(常量)、字符型数据可以混合运算。运算中,不同类型的数据先转化为同一类型,然后进行运算。

转换从低级到高级。

低 ------------------------------------> 高

byte,short,char—> int —> long—> float —> double

数据类型转换必须满足如下规则:

1. 不能对boolean类型进行类型转换。

2. 不能把对象类型转换成不相关类的对象。

3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

4. 转换过程中可能导致溢出或损失精度,例如:

int i =128;

byte b = (byte)i;

因为byte类型时8位,最大值为127,所以当强制转换为int类型值128时候就会导致溢出。

5. 浮点数到整数的转换是通过舍弃小数得到,而不是四舍五入,例如:

(int)23.7 == 23;

(int)-45.89f == -45

自动类型转换

必须满足转换前的数据类型的位数要低于转换后的数据类型,例如: short数据类型的位数为16位,就可以自动转换位数为32的int类型,同样float数据类型的位数为32,可以自动转换为64位的double类型。

实例

运行结果为:

char自动类型转换为int后的值等于97

char类型和int计算后的值等于66

解析:c1的值为字符'a',查ascii码表可知对应的int类型值为97,'A'对应值为65,所以i2=65+1=66。

强制类型转换

1. 条件是转换的数据类型必须是兼容的。

2. 格式:(type)value type是要强制类型转换后的数据类型 实例:

实例

运行结果:

int强制类型转换为byte后的值等于123

隐含强制类型转换

1. 整数的默认类型是 int。

2. 浮点型不存在这种情况,因为在定义 float 类型时必须在数字后面跟上 F 或者 f。

这一节讲解了 Java 的基本数据类型。下一节将探讨不同的变量类型以及它们的用法。

更多教程 》

Java 变量类型

在Java语言中,所有的变量在使用前必须声明。声明变量的基本格式如下:

type identifier [ = value][, identifier [= value] ...] ;

格式说明:type为Java数据类型。identifier是变量名。可以使用逗号隔开来声明多个同类型变量。

以下列出了一些变量的声明实例。注意有些包含了初始化过程。

int a, b, c; // 声明三个int型整数:a、 b、c

int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值

byte z = 22; // 声明并初始化 z

String s = "runoob"; // 声明并初始化字符串 s

double pi = 3.14159; // 声明了双精度浮点型变量 pi

char x = 'x'; // 声明变量 x 的值是字符 'x'。

Java语言支持的变量类型有:

类变量:独立于方法之外的变量,用 static 修饰。

实例变量:独立于方法之外的变量,不过没有 static 修饰。

局部变量:类的方法中的变量。

Java 局部变量

局部变量声明在方法、构造方法或者语句块中;

局部变量在方法、构造方法、或者语句块被执行的时候创建,当它们执行完成后,变量将会被销毁;

访问修饰符不能用于局部变量;

局部变量只在声明它的方法、构造方法或者语句块中可见;

局部变量是在栈上分配的。

局部变量没有默认值,所以局部变量被声明后,必须经过初始化,才可以使用。

实例 1

在以下实例中age是一个局部变量。定义在pupAge()方法中,它的作用域就限制在这个方法中。

以上实例编译运行结果如下:

小狗的年龄是: 7

实例 2

在下面的例子中 age 变量没有初始化,所以在编译时会出错:

以上实例编译运行结果如下:

实例变量

实例变量声明在一个类中,但在方法、构造方法和语句块之外;

当一个对象被实例化之后,每个实例变量的值就跟着确定;

实例变量在对象创建的时候创建,在对象被销毁的时候销毁;

实例变量的值应该至少被一个方法、构造方法或者语句块引用,使得外部能够通过这些方式获取实例变量信息;

实例变量可以声明在使用前或者使用后;

访问修饰符可以修饰实例变量;

实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见;

实例变量具有默认值。数值型变量的默认值是0,布尔型变量的默认值是false,引用类型变量的默认值是null。变量的值可以在声明时指定,也可以在构造方法中指定;

实例变量可以直接通过变量名访问。但在静态方法以及其他类中,就应该使用完全限定名:ObejectReference.VariableName。

实例

Employee.java 文件代码:

以上实例编译运行结果如下:

$ javac Employee.java

$ java Employee

名字 : RUNOOB

薪水 : 1000.0

类变量(静态变量)

类变量也称为静态变量,在类中以static关键字声明,但必须在方法构造方法和语句块之外。

无论一个类创建了多少个对象,类只拥有类变量的一份拷贝。

静态变量除了被声明为常量外很少使用。常量是指声明为public/private,final和static类型的变量。常量初始化后不可改变。

静态变量储存在静态存储区。经常被声明为常量,很少单独使用static声明变量。

静态变量在程序开始时创建,在程序结束时销毁。

与实例变量具有相似的可见性。但为了对类的使用者可见,大多数静态变量声明为public类型。

默认值和实例变量相似。数值型变量默认值是0,布尔型默认值是false,引用类型默认值是null。变量的值可以在声明的时候指定,也可以在构造方法中指定。此外,静态变量还可以在静态语句块中初始化。

静态变量可以通过:ClassName.VariableName的方式访问。

类变量被声明为public static final类型时,类变量名称一般建议使用大写字母。如果静态变量不是public和final类型,其命名方式与实例变量以及局部变量的命名方式一致。

实例:

Employee.java 文件代码:

以上实例编译运行结果如下:

开发人员平均工资:10000.0

注意:如果其他类想要访问该变量,可以这样访问:Employee.DEPARTMENT。

更多教程 》

Java 运算符

计算机的最基本用途之一就是执行数学运算,作为一门计算机语言,Java也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组:

算术运算符

关系运算符

位运算符

逻辑运算符

赋值运算符

其他运算符

算术运算符

算术运算符用在数学表达式中,它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。

表格中的实例假设整数变量A的值为10,变量B的值为20:

操作符 描述 例子
+ 加法 - 相加运算符两侧的值 A + B 等于 30
- 减法 - 左操作数减去右操作数 A – B 等于 -10
* 乘法 - 相乘操作符两侧的值 A * B等于200
/ 除法 - 左操作数除以右操作数 B / A等于2
取模 - 左操作数除以右操作数的余数 B%A等于0
++ 自增: 操作数的值增加1 B++ 或 ++B 等于 21(区别详见下文)
-- 自减: 操作数的值减少1 B-- 或 --B 等于 19(区别详见下文)

实例

下面的简单示例程序演示了算术运算符。复制并粘贴下面的 Java 程序并保存为 Test.java 文件,然后编译并运行这个程序:

以上实例编译运行结果如下:

a + b = 30

a - b = -10

a * b = 200

b / a = 2

b % a = 0

c % a = 5

a++ = 10

a-- = 11

d++ = 25

++d = 27

自增自减运算符

1、自增(++)自减(--)运算符是一种特殊的算术运算符,在算术运算符中需要两个操作数来进行运算,而自增自减运算符是一个操作数。

实例

运行结果为:

进行自增运算后的值等于4

进行自减运算后的值等于2

解析:

int b = ++a; 拆分运算过程为: a=a+1=4; b=a=4, 最后结果为b=4,a=4

int d = --c; 拆分运算过程为: c=c-1=2; d=c=2, 最后结果为d=2,c=2

2、前缀自增自减法(++a,--a): 先进行自增或者自减运算,再进行表达式运算。

3、后缀自增自减法(a++,a--): 先进行表达式运算,再进行自增或者自减运算 实例:

实例

运行结果为:

自增运算符前缀运算后a=6,x=12

自增运算符后缀运算后b=6,y=10

关系运算符

下表为Java支持的关系运算符

表格中的实例整数变量A的值为10,变量B的值为20:

运算符 描述 例子
== 检查如果两个操作数的值是否相等,如果相等则条件为真。 (A == B)为假(非真)。
!= 检查如果两个操作数的值是否相等,如果值不相等则条件为真。 (A != B) 为真。
> 检查左操作数的值是否大于右操作数的值,如果是那么条件为真。 (A>B)非真。
< 检查左操作数的值是否小于右操作数的值,如果是那么条件为真。 (A < B)为真。
>= 检查左操作数的值是否大于或等于右操作数的值,如果是那么条件为真。 (A > = B)为假。
<= 检查左操作数的值是否小于或等于右操作数的值,如果是那么条件为真。 (A <= B)为真。

实例

下面的简单示例程序演示了关系运算符。复制并粘贴下面的Java程序并保存为Test.java文件,然后编译并运行这个程序:

Test.java 文件代码:

以上实例编译运行结果如下:

a == b = false

a != b = true

a > b = false

a < b = true

b >= a = true

b <= a = false

位运算符

Java定义了位运算符,应用于整数类型(int),长整型(long),短整型(short),字符型(char),和字节型(byte)等类型。

位运算符作用在所有的位上,并且按位运算。假设a = 60,b = 13;它们的二进制格式表示将如下:

A = 0011 1100

B = 0000 1101

-----------------

A&b = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

~A= 1100 0011

下表列出了位运算符的基本运算,假设整数变量A的值为60和变量B的值为13:

操作符 描述 例子
如果相对应位都是1,则结果为1,否则为0 (A&B),得到12,即0000 1100
| 如果相对应位都是0,则结果为0,否则为1 (A | B)得到61,即 0011 1101
^ 如果相对应位值相同,则结果为0,否则为1 (A ^ B)得到49,即 0011 0001
按位补运算符翻转操作数的每一位,即0变成1,1变成0。 (〜A)得到-61,即1100 0011
<< 按位左移运算符。左操作数按位左移右操作数指定的位数。 A << 2得到240,即 1111 0000
>> 按位右移运算符。左操作数按位右移右操作数指定的位数。 A >> 2得到15即 1111
>>> 按位右移补零操作符。左操作数的值按右操作数指定的位数右移,移动得到的空位以零填充。 A>>>2得到15

实例

下面的简单示例程序演示了位运算符。复制并粘贴下面的Java程序并保存为Test.java文件,然后编译并运行这个程序:

Test.java 文件代码:

以上实例编译运行结果如下:

a & b = 12

a | b = 61

a ^ b = 49

~a = -61

a << 2 = 240

a >> 15

a >>> 15

逻辑运算符

下表列出了逻辑运算符的基本运算,假设布尔变量A为真,变量B为假

操作符 描述 例子
&& 称为逻辑与运算符。当且仅当两个操作数都为真,条件才为真。 (A && B)为假。
| | 称为逻辑或操作符。如果任何两个操作数任何一个为真,条件为真。 (A | | B)为真。
称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true,则逻辑非运算符将得到false。 !(A && B)为真。

实例

下面的简单示例程序演示了逻辑运算符。复制并粘贴下面的Java程序并保存为Test.java文件,然后编译并运行这个程序:

以上实例编译运行结果如下:

a && b = false

a || b = true

!(a && b) = true

短路逻辑运算符

当使用与逻辑运算符时,在两个操作数都为true时,结果才为true,但是当得到第一个操作为false时,其结果就必定是false,这时候就不会再判断第二个操作了。

实例

使用短路逻辑运算符的结果为false

a的结果为5

解析: 该程序使用到了短路逻辑运算符(&&),首先判断 a<4 的结果为 false,则 b 的结果必定是 false,所以不再执行第二个操作 a++<10 的判断,所以 a 的值为 5。

赋值运算符

下面是Java语言支持的赋值运算符:

操作符 描述 例子
= 简单的赋值运算符,将右操作数的值赋给左侧操作数 C = A + B将把A + B得到的值赋给C
+ = 加和赋值操作符,它把左操作数和右操作数相加赋值给左操作数 C + = A等价于C = C + A
- = 减和赋值操作符,它把左操作数和右操作数相减赋值给左操作数 C - = A等价于C = C - A
* = 乘和赋值操作符,它把左操作数和右操作数相乘赋值给左操作数 C * = A等价于C = C * A
/ = 除和赋值操作符,它把左操作数和右操作数相除赋值给左操作数 C / = A等价于C = C / A
(%)= 取模和赋值操作符,它把左操作数和右操作数取模后赋值给左操作数 C%= A等价于C = C%A
<<= 左移位赋值运算符 C <<=2 等价于C=C << 2
>> = 右移位赋值运算符 C >> = 2等价于C = C >> 2
&= 按位与赋值运算符 C&= 2等价于C = C&2
^ = 按位异或赋值操作符 C ^ = 2等价于C = C ^ 2
| = 按位或赋值操作符 C | = 2等价于C = C | 2

实例

面的简单示例程序演示了赋值运算符。复制并粘贴下面的Java程序并保存为Test.java文件,然后编译并运行这个程序:

Test.java 文件代码:

以上实例编译运行结果如下:

c = a + b = 30

c += a = 40

c -= a = 30

c *= a = 300

c /= a = 1

c %= a = 5

c <<= 2 = 20

c >>= 2 = 5

c >>= 2 = 1

c &= a = 0

c ^= a = 10

c |= a = 10

条件运算符(?:)

条件运算符也被称为三元运算符。该运算符有3个操作数,并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

variable x = (expression) ? value if true : value if false

实例

Test.java 文件代码:

以上实例编译运行结果如下:

Value of b is : 30

Value of b is : 20

instanceof 运算符

该运算符用于操作对象实例,检查该对象是否是一个特定类型(类类型或接口类型)。

instanceof运算符使用格式如下:

( Object reference variable ) instanceof (class/interface type)

如果运算符左侧变量所指的对象,是操作符右侧类或接口(class/interface)的一个对象,那么结果为真。

下面是一个例子:

String name = "James";

boolean result = name instanceof String; // 由于 name 是 String 类型,所以返回真

如果被比较的对象兼容于右侧类型,该运算符仍然返回true。

看下面的例子:

以上实例编译运行结果如下:

true

Java运算符优先级

当多个运算符出现在一个表达式中,谁先谁后呢?这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中,运算符优先级不同会导致最后得出的结果差别甚大。

例如,(1+3)+(3+2)*2,这个表达式如果按加号最优先计算,答案就是 18,如果按照乘号最优先,答案则是 14。

再如,x = 7 + 3 * 2;这里x得到13,而不是20,因为乘法运算符比加法运算符有较高的优先级,所以先计算3 * 2得到6,然后再加7。

下表中具有最高优先级的运算符在的表的最上面,最低优先级的在表的底部。

类别 操作符 关联性
后缀 () [] . (点操作符) 左到右
一元 + + - !〜 从右到左
乘性 * /% 左到右
加性 + - 左到右
移位 >> >>> << 左到右
关系 >> = <<= 左到右
相等 == != 左到右
按位与 左到右
按位异或 ^ 左到右
按位或 | 左到右
逻辑与 && 左到右
逻辑或 | | 左到右
条件 ?: 从右到左
赋值 = + = - = * = / =%= >> = <<=&=^=|= 从右到左
逗号 左到右
更多教程 》

Java 循环结构 - for, while 及 do...while

顺序结构的程序语句只能被执行一次。如果您想要同样的操作执行多次,,就需要使用循环结构。

Java中有三种主要的循环结构:

while 循环

do…while 循环

for 循环

在Java5中引入了一种主要用于数组的增强型for循环。

while 循环

while是最基本的循环,它的结构为:

只要布尔表达式为 true,循环体会一直执行下去。

实例

Test.java 文件代码:

以上实例编译运行结果如下:

value of x : 10

value of x : 11

value of x : 12

value of x : 13

value of x : 14

value of x : 15

value of x : 16

value of x : 17

value of x : 18

value of x : 19

do…while 循环

对于 while 语句而言,如果不满足条件,则不能进入循环。但有时候我们需要即使不满足条件,也至少执行一次。

do…while 循环和 while 循环相似,不同的是,do…while 循环至少会执行一次。

注意:布尔表达式在循环体的后面,所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true,则语句块一直执行,直到布尔表达式的值为 false。

实例

Test.java 文件代码:

以上实例编译运行结果如下:

value of x : 10

value of x : 11

value of x : 12

value of x : 13

value of x : 14

value of x : 15

value of x : 16

value of x : 17

value of x : 18

value of x : 19

for循环

虽然所有循环结构都可以用 while 或者 do...while表示,但 Java 提供了另一种语句 —— for 循环,使一些循环结构变得更加简单。

for循环执行的次数是在执行前就确定的。语法格式如下:

关于 for 循环有以下几点说明:

最先执行初始化步骤。可以声明一种类型,但可初始化一个或多个循环控制变量,也可以是空语句。

然后,检测布尔表达式的值。如果为 true,循环体被执行。如果为false,循环终止,开始执行循环体后面的语句。

执行一次循环后,更新循环控制变量。

再次检测布尔表达式。循环执行上面的过程。

实例

Test.java 文件代码:

以上实例编译运行结果如下:

value of x : 10

value of x : 11

value of x : 12

value of x : 13

value of x : 14

value of x : 15

value of x : 16

value of x : 17

value of x : 18

value of x : 19

Java 增强 for 循环

Java5 引入了一种主要用于数组的增强型 for 循环。

Java 增强 for 循环语法格式如下:

声明语句:声明新的局部变量,该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块,其值与此时数组元素的值相等。

表达式:表达式是要访问的数组名,或者是返回值为数组的方法。

实例

Test.java 文件代码:

以上实例编译运行结果如下:

10,20,30,40,50,

James,Larry,Tom,Lacy,

break 关键字

break 主要用在循环语句或者 switch 语句中,用来跳出整个语句块。

break 跳出最里层的循环,并且继续执行该循环下面的语句。

语法

break 的用法很简单,就是循环结构中的一条语句:

break;

实例

Test.java 文件代码:

以上实例编译运行结果如下:

10

20

continue 关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

在 for 循环中,continue 语句使程序立即跳转到更新语句。

在 while 或者 do…while 循环中,程序立即跳转到布尔表达式的判断语句。

语法

continue 就是循环体中一条简单的语句:

continue;

实例

Test.java 文件代码:

以上实例编译运行结果如下:

10

20

40

50

更多教程 》

Java 正则表达式

正则表达式定义了字符串的模式。

正则表达式可以用来搜索、编辑或处理文本。

正则表达式并不仅限于某一种语言,但是在每种语言中有细微的差别。

正则表达式实例

一个字符串其实就是一个简单的正则表达式,例如 Hello World 正则表达式匹配 "Hello World" 字符串。

.(点号)也是一个正则表达式,它匹配任何一个字符如:"a" 或 "1"。

下表列出了一些正则表达式的实例及描述:

正则表达式 描述
this is text 匹配字符串 "this is text"
this\s+is\s+text 注意字符串中的 \s+。
匹配单词 "this" 后面的 \s+ 可以匹配多个空格,之后匹配 is 字符串,再之后 \s+ 匹配多个空格然后再跟上 text 字符串。
可以匹配这个实例:this is text
^\d+(\.\d+)? ^ 定义了以什么开始
\d+ 匹配一个或多个数字
? 设置括号内的选项是可选的
\. 匹配 "."
可以匹配的实例:"5", "1.5" 和 "2.21"。

Java 正则表达式和 Perl 的是最为相似的。

java.util.regex 包主要包括以下三个类:

Pattern 类:

pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象,你必须首先调用其公共静态编译方法,它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。

Matcher 类:

Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样,Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。

PatternSyntaxException:

PatternSyntaxException 是一个非强制异常类,它表示一个正则表达式模式中的语法错误。

以下实例中使用了正则表达式 .*runoob.* 用于查找字符串中是否包了 runoob 子串:

实例

实例输出结果为:

字符串中是否包含了 'runoob' 子字符串? true

捕获组

捕获组是把多个字符当一个单独单元进行处理的方法,它通过对括号内的字符分组来创建。

例如,正则表达式 (dog) 创建了单一分组,组里包含"d","o",和"g"。

捕获组是通过从左至右计算其开括号来编号。例如,在表达式((A)(B(C))),有四个这样的组:

((A)(B(C)))

(A)

(B(C))

(C)

可以通过调用 matcher 对象的 groupCount 方法来查看表达式有多少个分组。groupCount 方法返回一个 int 值,表示matcher对象当前有多个捕获组。

还有一个特殊的组(group(0)),它总是代表整个表达式。该组不包括在 groupCount 的返回值中。

实例

下面的例子说明如何从一个给定的字符串中找到数字串:

RegexMatches.java 文件代码:

以上实例编译运行结果如下:

Found value: This order was placed for QT3000! OK?

Found value: This order was placed for QT

Found value: 3000

Found value: ! OK?

正则表达式语法

字符 说明
\ 将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如,"n"匹配字符"n"。"\n"匹配换行符。序列"\\"匹配"\","\("匹配"("。
^ 匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性,^ 还会与"\n"或"\r"之后的位置匹配。
$ 匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性,$ 还会与"\n"或"\r"之前的位置匹配。
* 零次或多次匹配前面的字符或子表达式。例如,zo* 匹配"z"和"zoo"。* 等效于 {0,}。
+ 一次或多次匹配前面的字符或子表达式。例如,"zo+"与"zo"和"zoo"匹配,但与"z"不匹配。+ 等效于 {1,}。
? 零次或一次匹配前面的字符或子表达式。例如,"do(es)?"匹配"do"或"does"中的"do"。? 等效于 {0,1}。
{n} n 是非负整数。正好匹配 n 次。例如,"o{2}"与"Bob"中的"o"不匹配,但与"food"中的两个"o"匹配。
{n,} n 是非负整数。至少匹配 n 次。例如,"o{2,}"不匹配"Bob"中的"o",而匹配"foooood"中的所有 o。"o{1,}"等效于"o+"。"o{0,}"等效于"o*"。
{n,m} M 和 n 是非负整数,其中 n <=m 。匹配至少 n 次,至多 m 次。例如, "o{1,3}"匹配 "fooooood"中的头三个 o。 'o{0,1}' 等效于 'o?'。注意:您不能将空格插入逗号和数字之间。
? 当此字符紧随任何其他限定符(*、+、?、{n}、{n,}、{n,m})之后时,匹配模式是"非贪心的"。"非贪心的"模式匹配搜索到的、尽可能短的字符串,而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。例如,在字符串"oooo"中,"o+?"只匹配单个"o",而"o+"匹配所有"o"。
. 匹配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符,请使用诸如"[\s\S]"之类的模式。
(pattern) 匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果"匹配"集合中检索捕获的匹配。若要匹配括号字符 ( ),请使用"\("或者"\)"。
(?:pattern) 匹配 pattern 但不捕获该匹配的子表达式,即它是一个非捕获匹配,不存储供以后使用的匹配。这对于用"or"字符 (|) 组合模式部件的情况很有用。例如,'industr(?:y|ies) 是比 'industry|industries' 更经济的表达式。
(?=pattern) 执行正向预测先行搜索的子表达式,该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配,即不能捕获供以后使用的匹配。例如,'Windows (?=95|98|NT|2000)' 匹配"Windows 2000"中的"Windows",但不匹配"Windows 3.1"中的"Windows"。预测先行不占用字符,即发生匹配后,下一匹配的搜索紧随上一匹配之后,而不是在组成预测先行的字符后。
(?!pattern) 执行反向预测先行搜索的子表达式,该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配,即不能捕获供以后使用的匹配。例如,'Windows (?!95|98|NT|2000)' 匹配"Windows 3.1"中的 "Windows",但不匹配"Windows 2000"中的"Windows"。预测先行不占用字符,即发生匹配后,下一匹配的搜索紧随上一匹配之后,而不是在组成预测先行的字符后。
x|y 匹配 x 或 y。例如,'z|food' 匹配"z"或"food"。'(z|f)ood' 匹配"zood"或"food"。
[xyz] 字符集。匹配包含的任一字符。例如,"[abc]"匹配"plain"中的"a"。
[^xyz] 反向字符集。匹配未包含的任何字符。例如,"[^abc]"匹配"plain"中"p","l","i","n"。
[a-z] 字符范围。匹配指定范围内的任何字符。例如,"[a-z]"匹配"a"到"z"范围内的任何小写字母。
[^a-z] 反向范围字符。匹配不在指定的范围内的任何字符。例如,"[^a-z]"匹配任何不在"a"到"z"范围内的任何字符。
\b 匹配一个字边界,即字与空格间的位置。例如,"er\b"匹配"never"中的"er",但不匹配"verb"中的"er"。
\B 非字边界匹配。"er\B"匹配"verb"中的"er",但不匹配"never"中的"er"。
\cx 匹配 x 指示的控制字符。例如,\cM 匹配 Control-M 或回车符。x 的值必须在 A-Z 或 a-z 之间。如果不是这样,则假定 c 就是"c"字符本身。
\d 数字字符匹配。等效于 [0-9]。
\D 非数字字符匹配。等效于 [^0-9]。
\f 换页符匹配。等效于 \x0c 和 \cL。
\n 换行符匹配。等效于 \x0a 和 \cJ。
\r 匹配一个回车符。等效于 \x0d 和 \cM。
\s 匹配任何空白字符,包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。
\S 匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。
\t 制表符匹配。与 \x09 和 \cI 等效。
\v 垂直制表符匹配。与 \x0b 和 \cK 等效。
\w 匹配任何字类字符,包括下划线。与"[A-Za-z0-9_]"等效。
\W 与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效。
\xn 匹配 n,此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如,"\x41"匹配"A"。"\x041"与"\x04"&"1"等效。允许在正则表达式中使用 ASCII 代码。
\num 匹配 num,此处的 num 是一个正整数。到捕获匹配的反向引用。例如,"(.)\1"匹配两个连续的相同字符。
\n 标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式,那么 n 是反向引用。否则,如果 n 是八进制数 (0-7),那么 n 是八进制转义码。
\nm 标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式,那么 nm 是反向引用。如果 \nm 前面至少有 n 个捕获,则 n 是反向引用,后面跟有字符 m。如果两种前面的情况都不存在,则 \nm 匹配八进制值 nm,其中 n 和 m 是八进制数字 (0-7)。
\nml 当 n 是八进制数 (0-3),m 和 l 是八进制数 (0-7) 时,匹配八进制转义码 nml。
\un 匹配 n,其中 n 是以四位十六进制数表示的 Unicode 字符。例如,\u00A9 匹配版权符号 (©)。

根据 Java Language Specification 的要求,Java 源代码的字符串中的反斜线被解释为 Unicode 转义或其他字符转义。因此必须在字符串字面值中使用两个反斜线,表示正则表达式受到保护,不被 Java 字节码编译器解释。例如,当解释为正则表达式时,字符串字面值 "\b" 与单个退格字符匹配,而 "\\b" 与单词边界匹配。字符串字面值 "\(hello\)" 是非法的,将导致编译时错误;要与字符串 (hello) 匹配,必须使用字符串字面值 "\\(hello\\)"。

Matcher 类的方法

索引方法

索引方法提供了有用的索引值,精确表明输入字符串中在哪能找到匹配:

序号 方法及说明
1 public int start()
返回以前匹配的初始索引。
2 public int start(int group)
返回在以前的匹配操作期间,由给定组所捕获的子序列的初始索引。
3 public int end()
返回最后匹配字符之后的偏移量。
4 public int end(int group)
返回在以前的匹配操作期间,由给定组所捕获子序列的最后字符之后的偏移量。

研究方法

研究方法用来检查输入字符串并返回一个布尔值,表示是否找到该模式:

序号 方法及说明
1 public boolean lookingAt()
尝试将从区域开头开始的输入序列与该模式匹配。
2 public boolean find()
尝试查找与该模式匹配的输入序列的下一个子序列。
3 public boolean find(int start)
重置此匹配器,然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。
4 public boolean matches()
尝试将整个区域与模式匹配。

替换方法

替换方法是替换输入字符串里文本的方法:

序号 方法及说明
1 public Matcher appendReplacement(StringBuffer sb, String replacement)
实现非终端添加和替换步骤。
2 public StringBuffer appendTail(StringBuffer sb)
实现终端添加和替换步骤。
3 public String replaceAll(String replacement)
替换模式与给定替换字符串相匹配的输入序列的每个子序列。
4 public String replaceFirst(String replacement)
替换模式与给定替换字符串匹配的输入序列的第一个子序列。
5 public static String quoteReplacement(String s)
返回指定字符串的字面替换字符串。这个方法返回一个字符串,就像传递给Matcher类的appendReplacement 方法一个字面字符串一样工作。

start 和 end 方法

下面是一个对单词 "cat" 出现在输入字符串中出现次数进行计数的例子:

RegexMatches.java 文件代码:

以上实例编译运行结果如下:

Match number 1

start(): 0

end(): 3

Match number 2

start(): 4

end(): 7

Match number 3

start(): 8

end(): 11

Match number 4

start(): 19

end(): 22

可以看到这个例子是使用单词边界,以确保字母 "c" "a" "t" 并非仅是一个较长的词的子串。它也提供了一些关于输入字符串中匹配发生位置的有用信息。

Start 方法返回在以前的匹配操作期间,由给定组所捕获的子序列的初始索引,end 方法最后一个匹配字符的索引加 1。

matches 和 lookingAt 方法

matches 和 lookingAt 方法都用来尝试匹配一个输入序列模式。它们的不同是 matcher 要求整个序列都匹配,而lookingAt 不要求。

lookingAt 方法虽然不需要整句都匹配,但是需要从第一个字符开始匹配。

这两个方法经常在输入字符串的开始使用。

我们通过下面这个例子,来解释这个功能:

RegexMatches.java 文件代码:

以上实例编译运行结果如下:

Current REGEX is: foo

Current INPUT is: fooooooooooooooooo

Current INPUT2 is: ooooofoooooooooooo

lookingAt(): true

matches(): false

lookingAt(): false

replaceFirst 和 replaceAll 方法

replaceFirst 和 replaceAll 方法用来替换匹配正则表达式的文本。不同的是,replaceFirst 替换首次匹配,replaceAll 替换所有匹配。

下面的例子来解释这个功能:

RegexMatches.java 文件代码:

以上实例编译运行结果如下:

The cat says meow. All cats say meow.

appendReplacement 和 appendTail 方法

Matcher 类也提供了appendReplacement 和 appendTail 方法用于文本替换:

看下面的例子来解释这个功能:

RegexMatches.java 文件代码:

以上实例编译运行结果如下:

-foo-foo-foo-

PatternSyntaxException 类的方法

PatternSyntaxException 是一个非强制异常类,它指示一个正则表达式模式中的语法错误。

PatternSyntaxException 类提供了下面的方法来帮助我们查看发生了什么错误。

序号 方法及说明
1 public String getDescription()
获取错误的描述。
2 public int getIndex()
获取错误的索引。
3 public String getPattern()
获取错误的正则表达式模式。
4 public String getMessage()
返回多行字符串,包含语法错误及其索引的描述、错误的正则表达式模式和模式中错误索引的可视化指示。
更多教程 》

Java 继承

继承的概念

继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。

继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。

生活中的继承:

兔子和羊属于食草动物类,狮子和豹属于食肉动物类。

食草动物和食肉动物又是属于动物类。

所以继承需要符合的关系是:is-a,父类更通用,子类更具体。

虽然食草动物和食肉动物都是属于动物,但是两者的属性和行为上有差别,所以子类会具有父类的一般特性也会具有自身的特性。

类的继承格式

在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的,一般形式如下:

类的继承格式

为什么需要继承

接下来我们通过实例来说明这个需求。

开发动物类,其中动物分别为企鹅以及老鼠,要求如下:

企鹅:属性(姓名,id),方法(吃,睡,自我介绍)

老鼠:属性(姓名,id),方法(吃,睡,自我介绍)

企鹅类:

老鼠类:

从这两段代码可以看出来,代码存在重复了,导致后果就是代码量大且臃肿,而且维护性不高(维护性主要是后期需要修改的时候,就需要修改很多的代码,容易出错),所以要从根本上解决这两段代码的问题,就需要继承,将两段代码中相同的部分提取出来组成 一个父类:

公共父类:

这个Animal类就可以作为一个父类,然后企鹅类和老鼠类继承这个类之后,就具有父类当中的属性和方法,子类就不会存在重复的代码,维护性也提高,代码也更加简洁,提高代码的复用性(复用性主要是可以多次使用,不用再多次写同样的代码) 继承之后的代码:

企鹅类:

老鼠类:

继承的特性

子类拥有父类非private的属性,方法。

子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。

子类可以用自己的方式实现父类的方法。

Java的继承是单继承,但是可以多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如A类继承B类,B类继承C类,所以按照关系就是C类是B类的父类,B类是A类的父类,这是java继承区别于C++继承的一个特性。

提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系)。

继承关键字

继承可以使用 extends 和 implements 这两个关键字来实现继承,而且所有的类都是继承于 java.lang.Object,当一个类没有继承的两个关键字,则默认继承object(这个类在 java.lang 包中,所以不需要 import)祖先类。

extends关键字

在 Java 中,类的继承是单一继承,也就是说,一个子类只能拥有一个父类,所以 extends 只能继承一个类。

extends 关键字

implements关键字

使用 implements 关键字可以变相的使java具有多继承的特性,使用范围为类继承接口的情况,可以同时继承多个接口(接口跟接口之间采用逗号分隔)。

implements 关键字

super 与 this 关键字

super关键字:我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。

this关键字:指向自己的引用。

实例

输出结果为:

super.i = 50, this.i = 100

final关键字

final 关键字声明类可以把类定义为不能继承的,即最终类;或者用于修饰方法,该方法不能被子类重写:

声明类:

final class 类名 {//类体}

声明方法:

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

注:实例变量也可以被定义为 final,被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final,但是实例变量并不是 final

构造器

子类不能继承父类的构造器(构造方法或者构造函数),但是父类的构造器带有参数的,则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表。

如果父类有无参构造器,则在子类的构造器中用super调用父类构造器不是必须的,如果没有使用super关键字,系统会自动调用父类的无参构造器。

实例

输出结果为:

SuperClass(int n)

SubClass

SuperClass()

SubClass(int n):200

更多教程 》

Java 多态

多态是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口,使用不同的实例而执行不同操作,如图所示:

多态性是对象多种表现形式的体现。

现实中,比如我们按下 F1 键这个动作:

如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档;

如果当前在 Word 下弹出的就是 Word 帮助;

在 Windows 下弹出的就是 Windows 帮助和支持。

同一个事件发生在不同的对象上会产生不同的结果。

多态的优点

1. 消除类型之间的耦合关系

2. 可替换性

3. 可扩充性

4. 接口性

5. 灵活性

6. 简化性

多态存在的三个必要条件

继承

重写

父类引用指向子类对象

比如:

Parent p = new Child();

当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法。

多态的好处:可以使程序有良好的扩展,并可以对所有类的对象进行通用处理。

以下是一个多态实例的演示,详细说明请看注释:

Test.java 文件代码:

执行以上程序,输出结果为:

吃鱼

抓老鼠

吃骨头

看家

吃鱼

抓老鼠

虚方法

我们将介绍在Java中,当设计类时,被重写的方法的行为怎样影响多态性。

我们已经讨论了方法的重写,也就是子类能够重写父类的方法。

当子类对象调用重写的方法时,调用的是子类的方法,而不是父类中被重写的方法。

要想调用父类中被重写的方法,则必须使用关键字super。

Employee.java 文件代码:

假设下面的类继承Employee类:

Salary.java 文件代码:

现在我们仔细阅读下面的代码,尝试给出它的输出结果:

VirtualDemo.java 文件代码:

以上实例编译运行结果如下:

Employee 构造函数

Employee 构造函数

使用 Salary 的引用调用 mailCheck --

Salary 类的 mailCheck 方法

邮寄支票给:员工 A ,工资为:3600.0

使用 Employee 的引用调用 mailCheck--

Salary 类的 mailCheck 方法

邮寄支票给:员工 B ,工资为:2400.0

例子解析

实例中,实例化了两个 Salary 对象:一个使用 Salary 引用 s,另一个使用 Employee 引用 e。

当调用 s.mailCheck() 时,编译器在编译时会在 Salary 类中找到 mailCheck(),执行过程 JVM 就调用 Salary 类的 mailCheck()。

因为 e 是 Employee 的引用,所以调用 e 的 mailCheck() 方法时,编译器会去 Employee 类查找 mailCheck() 方法 。

在编译的时候,编译器使用 Employee 类中的 mailCheck() 方法验证该语句, 但是在运行的时候,Java虚拟机(JVM)调用的是 Salary 类中的 mailCheck() 方法。

以上整个过程被称为虚拟方法调用,该方法被称为虚拟方法。

Java中所有的方法都能以这种方式表现,因此,重写的方法能在运行时调用,不管编译的时候源代码中引用变量是什么数据类型。

多态的实现方式

方式一:重写:

这个内容已经在上一章节详细讲过,就不再阐述,详细可访问:Java 重写(Override)与重载(Overload)。

方式二:接口

1. 生活中的接口最具代表性的就是插座,例如一个三接头的插头都能接在三孔插座中,因为这个是每个国家都有各自规定的接口规则,有可能到国外就不行,那是因为国外自己定义的接口类型。

2. java中的接口类似于生活中的接口,就是一些方法特征的集合,但没有方法的实现。具体可以看 java接口 这一章节的内容。

方式三:抽象类和抽象方法

更多教程 》

Java 接口

接口(英文:Interface),在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。

接口并不是类,编写接口的方式和类很相似,但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类,否则该类要定义接口中的所有方法。

接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类。另外,在 Java 中,接口类型可用来声明一个变量,他们可以成为一个空指针,或是被绑定在一个以此接口实现的对象。

接口与类相似点:

一个接口可以有多个方法。

接口文件保存在 .java 结尾的文件中,文件名使用接口名。

接口的字节码文件保存在 .class 结尾的文件中。

接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别:

接口不能用于实例化对象。

接口没有构造方法。

接口中所有的方法必须是抽象方法。

接口不能包含成员变量,除了 static 和 final 变量。

接口不是被类继承了,而是要被类实现。

接口支持多重继承。

接口特性

接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract(只能是 public abstract,其他修饰符都会报错)。

接口中可以含有变量,但是接口中的变量会被隐式的指定为 public static final 变量(并且只能是 public,用 private 修饰会报编译错误。

接口中的方法是不能在接口中实现的,只能由实现接口的类来实现接口中的方法。

抽象类和接口的区别

1. 抽象类中的方法可以有方法体,就是能实现方法的具体功能,但是接口中的方法不行。

2. 抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是 public static final 类型的。

3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法),而抽象类是可以有静态代码块和静态方法。

4. 一个类只能继承一个抽象类,而一个类却可以实现多个接口。

接口的声明

接口的声明语法格式如下:

Interface关键字用来声明一个接口。下面是接口声明的一个简单例子。

NameOfInterface.java 文件代码:

接口有以下特性:

接口是隐式抽象的,当声明一个接口的时候,不必使用abstract关键字。

接口中每一个方法也是隐式抽象的,声明时同样不需要abstract关键子。

接口中的方法都是公有的。

实例

Animal.java 文件代码:

接口有以下特性:

接口是隐式抽象的,当声明一个接口的时候,不必使用abstract关键字。

接口中每一个方法也是隐式抽象的,声明时同样不需要abstract关键子。

接口中的方法都是公有的。

实例

Animal.java 文件代码:

接口的实现

当类实现接口的时候,类要实现接口中所有的方法。否则,类必须声明为抽象的类。

类使用implements关键字实现接口。在类声明中,Implements关键字放在class声明后面。

实现一个接口的语法,可以使用这个公式:

Animal.java 文件代码:

...implements 接口名称[, 其他接口, 其他接口..., ...] ...

实例

MammalInt.java 文件代码:

以上实例编译运行结果如下:

Mammal eats

Mammal travels

重写接口中声明的方法时,需要注意以下规则:

类在实现接口的方法时,不能抛出强制性异常,只能在接口中,或者继承接口的抽象类中抛出该强制性异常。

类在重写方法时要保持一致的方法名,并且应该保持相同或者相兼容的返回值类型。

如果实现接口的类是抽象类,那么就没必要实现该接口的方法。

在实现接口的时候,也要注意一些规则:

一个类可以同时实现多个接口。

一个类只能继承一个类,但是能实现多个接口。

一个接口能继承另一个接口,这和类之间的继承比较相似。

接口的继承

一个接口能继承另一个接口,和类之间的继承方式比较相似。接口的继承使用extends关键字,子接口继承父接口的方法。

下面的Sports接口被Hockey和Football接口继承:

Hockey接口自己声明了四个方法,从Sports接口继承了两个方法,这样,实现Hockey接口的类需要实现六个方法。

相似的,实现Football接口的类需要实现五个方法,其中两个来自于Sports接口。

接口的多重继承

在Java中,类的多重继承是不合法,但接口允许多重继承,。

在接口的多重继承中extends关键字只需要使用一次,在其后跟着继承接口。 如下所示:

public interface Hockey extends Sports, Event

以上的程序片段是合法定义的子接口,与类不同的是,接口允许多重继承,而 Sports及 Event 可能定义或是继承相同的方法

标记接口

最常用的继承接口是没有包含任何方法的接口。

标识接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。

标识接口作用:简单形象的说就是给某个对象打个标(盖个戳),使对象拥有某个或某些特权。

例如:java.awt.event 包中的 MouseListener 接口继承的 java.util.EventListener 接口定义如下:

package java.util;

public interface EventListener

{}

没有任何方法的接口被称为标记接口。标记接口主要用于以下两种目的:

建立一个公共的父接口:

正如EventListener接口,这是由几十个其他接口扩展的Java API,你可以使用一个标记接口来建立一组接口的父接口。例如:当一个接口继承了EventListener接口,Java虚拟机(JVM)就知道该接口将要被用于一个事件的代理方案。

向一个类添加数据类型:

这种情况是标记接口最初的目的,实现标记接口的类不需要定义任何接口方法(因为标记接口根本就没有方法),但是该类通过多态性变成一个接口类型。

更多教程 》

Java 数据结构

Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类:

枚举(Enumeration)

位集合(BitSet)

向量(Vector)

栈(Stack)

字典(Dictionary)

哈希表(Hashtable)

属性(Properties)

以上这些类是传统遗留的,在Java2中引入了一种新的框架-集合框架(Collection),我们后面再讨论。

枚举(Enumeration)

枚举(Enumeration)接口虽然它本身不属于数据结构,但它在其他数据结构的范畴里应用很广。 枚举(The Enumeration)接口定义了一种从数据结构中取回连续元素的方式。

例如,枚举定义了一个叫nextElement 的方法,该方法用来得到一个包含多元素的数据结构的下一个元素。

关于枚举接口的更多信息,请参见枚举(Enumeration)。

位集合(BitSet)

位集合类实现了一组可以单独设置和清除的位或标志。

该类在处理一组布尔值的时候非常有用,你只需要给每个值赋值一"位",然后对位进行适当的设置或清除,就可以对布尔值进行操作了。

关于该类的更多信息,请参见位集合(BitSet)。

向量(Vector)

向量(Vector)类和传统数组非常相似,但是Vector的大小能根据需要动态的变化。

和数组一样,Vector对象的元素也能通过索引访问。

使用Vector类最主要的好处就是在创建对象的时候不必给对象指定大小,它的大小会根据需要动态的变化。

关于该类的更多信息,请参见向量(Vector)

栈(Stack)

栈(Stack)实现了一个后进先出(LIFO)的数据结构。

你可以把栈理解为对象的垂直分布的栈,当你添加一个新元素时,就将新元素放在其他元素的顶部。

当你从栈中取元素的时候,就从栈顶取一个元素。换句话说,最后进栈的元素最先被取出。

关于该类的更多信息,请参见栈(Stack)。

字典(Dictionary)

字典(Dictionary) 类是一个抽象类,它定义了键映射到值的数据结构。

当你想要通过特定的键而不是整数索引来访问数据的时候,这时候应该使用Dictionary。

由于Dictionary类是抽象类,所以它只提供了键映射到值的数据结构,而没有提供特定的实现。

关于该类的更多信息,请参见字典( Dictionary)。

哈希表(Hashtable)

Hashtable类提供了一种在用户定义键结构的基础上来组织数据的手段。

例如,在地址列表的哈希表中,你可以根据邮政编码作为键来存储和排序数据,而不是通过人名。

哈希表键的具体含义完全取决于哈希表的使用情景和它包含的数据。

关于该类的更多信息,请参见哈希表(HashTable)。

属性(Properties)

Properties 继承于 Hashtable.Properties 类表示了一个持久的属性集.属性列表中每个键及其对应值都是一个字符串。

Properties 类被许多Java类使用。例如,在获取环境变量时它就作为System.getProperties()方法的返回值。

关于该类的更多信息,请参见属性(Properties)。

更多教程 》

Java 集合框架

早在Java 2中之前,Java就提供了特设类。比如:Dictionary, Vector, Stack, 和Properties这些类用来存储和操作对象组。

虽然这些类都非常有用,但是它们缺少一个核心的,统一的主题。由于这个原因,使用Vector类的方式和使用Properties类的方式有着很大不同。

集合框架被设计成要满足以下几个目标。

该框架必须是高性能的。基本集合(动态数组,链表,树,哈希表)的实现也必须是高效的。

该框架允许不同类型的集合,以类似的方式工作,具有高度的互操作性。

对一个集合的扩展和适应必须是简单的。

为此,整个集合框架就围绕一组标准接口而设计。你可以直接使用这些接口的标准实现,诸如: LinkedList, HashSet, 和 TreeSet等,除此之外你也可以通过这些接口实现自己的集合。

集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容:

接口:是代表集合的抽象数据类型。接口允许集合独立操纵其代表的细节。在面向对象的语言,接口通常形成一个层次。

实现(类):是集合接口的具体实现。从本质上讲,它们是可重复使用的数据结构。

算法:是实现集合接口的对象里的方法执行的一些有用的计算,例如:搜索和排序。这些算法被称为多态,那是因为相同的方法可以在相似的接口上有着不同的实现。

除了集合,该框架也定义了几个Map接口和类。Map里存储的是键/值对。尽管Map不是collections,但是它们完全整合在集合中。

集合框架体系如图所示

Java 集合框架提供了一套性能优良,使用方便的接口和类,java集合框架位于java.util包中, 所以当使用集合框架的时候需要进行导包。

集合接口

集合框架定义了一些接口。本节提供了每个接口的概述:

序号 接口描述
1 Collection 接口
Collection 是最基本的集合接口,一个 Collection 代表一组 Object,Java不提供直接继承自Collection的类,只提供继承于的子接口(如List和set)。
2 List 接口
List接口是一个有序的Collection,使用此接口能够精确的控制每个元素插入的位置,能够通过索引(元素在List中位置,类似于数组的小标)来访问List中的元素,而且允许有相同的元素。
3 Set
Set 具有与 Collection 完全一样的接口,只是行为上不同,Set 不保存重复的元素。
4 SortedSet
继承于Set保存有序的集合。
5 Map
将唯一的键映射到值。
6 Map.Entry
描述在一个Map中的一个元素(键/值对)。是一个Map的内部类。
7 SortedMap
继承于Map,使Key保持在升序排列。
8 Enumeration
这是一个传统的接口和定义的方法,通过它可以枚举(一次获得一个)对象集合中的元素。这个传统接口已被迭代器取代。

Set和List的区别

1. Set 接口实例存储的是无序的,不重复的数据。List 接口实例存储的是有序的,可以重复的元素。

2. Set检索效率低下,删除和插入效率高,插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。

3. List和数组类似,可以动态增长,根据实际存储的数据的长度自动增长List的长度。查找元素效率高,插入删除效率低,因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

集合实现类(集合类)

Java提供了一套实现了Collection接口的标准集合类。其中一些是具体类,这些类可以直接拿来使用,而另外一些是抽象类,提供了接口的部分实现。

标准集合类汇总于下表:

序号 类描述
1 AbstractCollection
实现了大部分的集合接口。
2 AbstractList
继承于AbstractCollection 并且实现了大部分List接口。
3 AbstractSequentialList
继承于 AbstractList ,提供了对数据元素的链式访问而不是随机访问。
4 LinkedList
该类实现了List接口,允许有null(空)元素。主要用于创建链表数据结构,该类没有同步方法,如果多个线程同时访问一个List,则必须自己实现访问同步,解决方法就是在创建List时候构造一个同步的List。例如:
Listlist=Collections.synchronizedList(newLinkedList(...));
LinkedList 查找效率低。
5 ArrayList
该类也是实现了List的接口,实现了可变大小的数组,随机访问和遍历元素时,提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%,插入删除效率低。
6 AbstractSet
继承于AbstractCollection 并且实现了大部分Set接口。
7 HashSet
该类实现了Set接口,不允许出现重复元素,不保证集合中元素的顺序,允许包含值为null的元素,但最多只能一个。
8 LinkedHashSet
具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
9 TreeSet
该类实现了Set接口,可以实现排序等功能。
10 AbstractMap
实现了大部分的Map接口。
11 HashMap
HashMap 是一个散列表,它存储的内容是键值对(key-value)映射。
该类实现了Map接口,根据键的HashCode值存储数据,具有很快的访问速度,最多允许一条记录的键为null,不支持线程同步。
12 TreeMap
继承了AbstractMap,并且使用一颗树。
13 WeakHashMap
继承AbstractMap类,使用弱密钥的哈希表。
14 LinkedHashMap
继承于HashMap,使用元素的自然顺序对元素进行排序.
15 IdentityHashMap
继承AbstractMap类,比较文档时使用引用相等。

在前面的教程中已经讨论通过java.util包中定义的类,如下所示:

序号 类描述
1 Vector
该类和ArrayList非常相似,但是该类是同步的,可以用在多线程的情况,该类允许设置默认的增长长度,默认扩容方式为原来的2倍。
2 Stack
栈是Vector的一个子类,它实现了一个标准的后进先出的栈。
3 Dictionary
Dictionary 类是一个抽象类,用来存储键/值对,作用和Map类相似。
4 Hashtable
Hashtable 是 Dictionary(字典) 类的子类,位于 java.util 包中。
5 Properties
Properties 继承于 Hashtable,表示一个持久的属性集,属性列表中每个键及其对应值都是一个字符串。
6 BitSet
一个Bitset类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。

一个Bitset类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。

集合算法

集合框架定义了几种算法,可用于集合和映射。这些算法被定义为集合类的静态方法。

在尝试比较不兼容的类型时,一些方法能够抛出 ClassCastException异常。当试图修改一个不可修改的集合时,抛出UnsupportedOperationException异常。

集合定义三个静态的变量:EMPTY_SET,EMPTY_LIST,EMPTY_MAP的。这些变量都不可改变。

序号 算法描述
1 Collection Algorithms
这里是一个列表中的所有算法实现。

如何使用迭代器

通常情况下,你会希望遍历一个集合中的元素。例如,显示集合中的每个元素。

一般遍历数组都是采用for循环或者增强for,这两个方法也可以用在集合框架,但是还有一种方法是采用迭代器遍历集合框架,它是一个对象,实现了Iterator 接口或ListIterator接口。

迭代器,使你能够通过循环来得到或删除集合的元素。ListIterator 继承了Iterator,以允许双向遍历列表和修改元素。

序号

迭代器方法描述

1 使用 Java Iterator

这里通过实例列出Iterator和listIterator接口提供的所有方法。

遍历 ArrayList

实例

解析:

三种方法都是用来遍历ArrayList集合,第三种方法是采用迭代器的方法,该方法可以不用担心在遍历的过程中会超出集合的长度。

遍历 Map

实例

如何使用比较器

TreeSet和TreeMap的按照排序顺序来存储元素. 然而,这是通过比较器来精确定义按照什么样的排序顺序。

这个接口可以让我们以不同的方式来排序一个集合。

序号 比较器方法描述
1 使用 Java Comparator
这里通过实例列出Comparator接口提供的所有方法

总结

Java集合框架为程序员提供了预先包装的数据结构和算法来操纵他们。

集合是一个对象,可容纳其他对象的引用。集合接口声明对每一种类型的集合可以执行的操作。

集合框架的类和接口均在java.util包中。

任何对象加入集合类后,自动转变为Object类型,所以在取出的时候,需要进行强制类型转换。

更多教程 》

Java 网络编程

网络编程是指编写运行在多个设备(计算机)的程序,这些设备都通过网络连接起来。

java.net 包中 J2SE 的 API 包含有类和接口,它们提供低层次的通信细节。你可以直接使用这些类和接口,来专注于解决问题,而不用关注通信细节。

java.net 包中提供了两种常见的网络协议的支持:

TCP:TCP 是传输控制协议的缩写,它保障了两个应用程序之间的可靠通信。通常用于互联网协议,被称 TCP / IP。

UDP:UDP 是用户数据报协议的缩写,一个无连接的协议。提供了应用程序之间要发送的数据的数据包。

本教程主要讲解以下两个主题。

Socket 编程:这是使用最广泛的网络概念,它已被解释地非常详细。

URL 处理:这部分会在另外的篇幅里讲,点击这里更详细地了解在 Java 语言中的 URL 处理。

Socket 编程

套接字使用TCP提供了两台计算机之间的通信机制。 客户端程序创建一个套接字,并尝试连接服务器的套接字。

当连接建立时,服务器会创建一个 Socket 对象。客户端和服务器现在可以通过对 Socket 对象的写入和读取来进行进行通信。

java.net.Socket 类代表一个套接字,并且 java.net.ServerSocket 类为服务器程序提供了一种来监听客户端,并与他们建立连接的机制。

以下步骤在两台计算机之间使用套接字建立TCP连接时会出现:

服务器实例化一个 ServerSocket 对象,表示通过服务器上的端口通信。

服务器调用 ServerSocket 类的 accept() 方法,该方法将一直等待,直到客户端连接到服务器上给定的端口。

服务器正在等待时,一个客户端实例化一个 Socket 对象,指定服务器名称和端口号来请求连接。

Socket 类的构造函数试图将客户端连接到指定的服务器和端口号。如果通信被建立,则在客户端创建一个 Socket 对象能够与服务器进行通信。

在服务器端,accept() 方法返回服务器上一个新的 socket 引用,该 socket 连接到客户端的 socket。

连接建立后,通过使用 I/O 流在进行通信,每一个socket都有一个输出流和一个输入流,客户端的输出流连接到服务器端的输入流,而客户端的输入流连接到服务器端的输出流。

TCP 是一个双向的通信协议,因此数据可以通过两个数据流在同一时间发送.以下是一些类提供的一套完整的有用的方法来实现 socket。

ServerSocket 类的方法

服务器应用程序通过使用 java.net.ServerSocket 类以获取一个端口,并且侦听客户端请求。

ServerSocket 类有四个构造方法:

序号 方法描述
1 public ServerSocket(int port) throws IOException
创建绑定到特定端口的服务器套接字。
2 public ServerSocket(int port, int backlog) throws IOException
利用指定的 backlog 创建服务器套接字并将其绑定到指定的本地端口号。
3 public ServerSocket(int port, int backlog, InetAddress address) throws IOException
使用指定的端口、侦听 backlog 和要绑定到的本地 IP 地址创建服务器。
4 public ServerSocket() throws IOException
创建非绑定服务器套接字。

创建非绑定服务器套接字。 如果 ServerSocket 构造方法没有抛出异常,就意味着你的应用程序已经成功绑定到指定的端口,并且侦听客户端请求。

这里有一些 ServerSocket 类的常用方法:

序号 方法描述
1 public int getLocalPort()
返回此套接字在其上侦听的端口。
2 public Socket accept() throws IOException
侦听并接受到此套接字的连接。
3 public void setSoTimeout(int timeout)
通过指定超时值启用/禁用 SO_TIMEOUT,以毫秒为单位。
4 public void bind(SocketAddress host, int backlog)
将 ServerSocket 绑定到特定地址(IP 地址和端口号)。

Socket 类的方法

java.net.Socket 类代表客户端和服务器都用来互相沟通的套接字。客户端要获取一个 Socket 对象通过实例化 ,而 服务器获得一个 Socket 对象则通过 accept() 方法的返回值。

Socket 类有五个构造方法.

序号 方法描述
1 public Socket(String host, int port) throws UnknownHostException, IOException.
创建一个流套接字并将其连接到指定主机上的指定端口号。
2 public Socket(InetAddress host, int port) throws IOException
创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
3 public Socket(String host, int port, InetAddress localAddress, int localPort) throws IOException.
创建一个套接字并将其连接到指定远程主机上的指定远程端口。
4 public Socket(InetAddress host, int port, InetAddress localAddress, int localPort) throws IOException.
创建一个套接字并将其连接到指定远程地址上的指定远程端口。
5 public Socket()
通过系统默认类型的 SocketImpl 创建未连接套接字

当 Socket 构造方法返回,并没有简单的实例化了一个 Socket 对象,它实际上会尝试连接到指定的服务器和端口。

下面列出了一些感兴趣的方法,注意客户端和服务器端都有一个 Socket 对象,所以无论客户端还是服务端都能够调用这些方法。

序号 方法描述
1 public void connect(SocketAddress host, int timeout) throws IOException
将此套接字连接到服务器,并指定一个超时值。
2 public InetAddress getInetAddress()
返回套接字连接的地址。
3 public int getPort()
返回此套接字连接到的远程端口。
4 public int getLocalPort()
返回此套接字绑定到的本地端口。
5 public SocketAddress getRemoteSocketAddress()
返回此套接字连接的端点的地址,如果未连接则返回 null。
6 public InputStream getInputStream() throws IOException
返回此套接字的输入流。
7 public OutputStream getOutputStream() throws IOException
返回此套接字的输出流。
8 public void close() throws IOException
关闭此套接字。

InetAddress 类的方法

这个类表示互联网协议(IP)地址。下面列出了 Socket 编程时比较有用的方法:

序号 方法描述
1 static InetAddress getByAddress(byte[] addr)
在给定原始 IP 地址的情况下,返回 InetAddress 对象。
2 static InetAddress getByAddress(String host, byte[] addr)
根据提供的主机名和 IP 地址创建 InetAddress。
3 static InetAddress getByName(String host)
在给定主机名的情况下确定主机的 IP 地址。
4 String getHostAddress()
返回 IP 地址字符串(以文本表现形式)。
5 String getHostName()
获取此 IP 地址的主机名。
6 static InetAddress getLocalHost()
返回本地主机。
7 String toString()
将此 IP 地址转换为 String。

Socket 客户端实例

如下的 GreetingClient 是一个客户端程序,该程序通过 socket 连接到服务器并发送一个请求,然后等待一个响应。

GreetingClient.java 文件代码:

Socket 服务端实例

如下的GreetingServer 程序是一个服务器端应用程序,使用 Socket 来监听一个指定的端口。

GreetingServer.java 文件代码:

编译以上两个 java 文件代码,并执行以下命令来启动服务,使用端口号为 6066:

$ java GreetingServer 6066

Waiting for client on port 6066...

新开一个命令窗口,执行以上命令来开启客户端:

$ java GreetingClient localhost 6066

Connecting to localhost on port 6066

Just connected to localhost/127.0.0.1:6066

Server says Thank you for connecting to /127.0.0.1:6066

Goodbye!

更多教程 》

Java Applet 基础

Applet 是一种 Java 程序。它一般运行在支持 Java 的 Web 浏览器内。因为它有完整的 Java API支持,所以Applet 是一个全功能的 Java 应用程序。

如下所示是独立的 Java 应用程序和 applet 程序之间重要的不同:

Java 中 Applet 类继承了 java.applet.Applet 类。

Applet 类没有定义 main(),所以一个 Applet 程序不会调用 main() 方法。

Applet 被设计为嵌入在一个 HTML 页面。

当用户浏览包含 Applet 的 HTML 页面,Applet 的代码就被下载到用户的机器上。

要查看一个 Applet 需要 JVM。 JVM 可以是 Web 浏览器的一个插件,或一个独立的运行时环境。

用户机器上的 JVM 创建一个 Applet 类的实例,并调用 Applet 生命周期过程中的各种方法。

Applet 有 Web 浏览器强制执行的严格的安全规则,Applet 的安全机制被称为沙箱安全。

Applet 需要的其他类可以用 Java 归档(JAR)文件的形式下载下来。

Applet的生命周期

Applet 类中的四个方法给你提供了一个框架,你可以再该框架上开发小程序:

init: 该方法的目的是为你的 Applet 提供所需的任何初始化。在 Applet 标记内的 param 标签被处理后调用该方法。

start: 浏览器调用 init 方法后,该方法被自动调用。每当用户从其他页面返回到包含 Applet 的页面时,则调用该方法。

stop: 当用户从包含 Applet 的页面移除的时候,该方法自动被调用。因此,可以在相同的 Applet 中反复调用该方法。

destroy: 此方法仅当浏览器正常关闭时调用。因为 Applet 只有在 HTML 网页上有效,所以你不应该在用户离开包含 Applet 的页面后遗漏任何资源。

paint: 该方法在 start() 方法之后立即被调用,或者在 Applet 需要重绘在浏览器的时候调用。paint() 方法实际上继承于 java.awt。

"Hello, World" Applet:

下面是一个简单的 Applet 程序 HelloWorldApplet.java:

HelloWorldApplet.java 文件代码:

这些 import 语句将以下类导入到我们的 Applet 类中:

java.applet.Applet.

java.awt.Graphics.

没有这些 import 语句,Java 编译器就识别不了 Applet 和 Graphics 类。

Applet 类

每一个 Applet 都是 java.applet.Applet 类的子类,基础的 Applet 类提供了供衍生类调用的方法,以此来得到浏览器上下文的信息和服务。

这些方法做了如下事情:

得到 Applet 的参数

得到包含 Applet 的 HTML 文件的网络位置

得到 Applet 类目录的网络位置

打印浏览器的状态信息

获取一张图片

获取一个音频片段

播放一个音频片段

调整此 Applet 的大小

除此之外,Applet 类还提供了一个接口,该接口供 Viewer 或浏览器来获取 Applet 的信息,并且来控制 Applet 的执行。

Viewer 可能是:

请求 Applet 作者、版本和版权的信息

请求 Applet 识别的参数的描述

初始化 Applet

销毁 Applet

开始执行 Applet

结束执行 Applet

Applet 类提供了对这些方法的默认实现,这些方法可以在需要的时候重写。

"Hello,World"applet 都是按标准编写的。唯一被重写的方法是 paint 方法。

Applet 的调用

Applet 是一种 Java 程序。它一般运行在支持 Java 的 Web 浏览器内。因为它有完整的 Java API 支持,所以 Applet 是一个全功能的 Java 应用程序。

<applet> 标签是在HTML文件中嵌入 Applet 的基础。以下是一个调用"Hello World"applet的例子;

HTML 代码:

注意: 你可以参照 HTML Applet 标签来更多的了解从 HTML 中调用 applet 的方法。

<applet> 标签的属性指定了要运行的 Applet 类。width 和 height 用来指定 Applet 运行面板的初始大小。Applet 必须使用 </applet> 标签来关闭。

如果 Applet 接受参数,那么参数的值需要在 <param> 标签里添加,该标签位于 <applet> 和 </applet> 之间。浏览器忽略了 applet 标签之间的文本和其他标签。

不支持 Java 的浏览器不能执行 <applet> 和 </applet>。因此,在标签之间显示并且和 applet 没有关系的任何东西,在不支持的 Java 的浏览器里是可见的。

Viewer 或者浏览器在文档的位置寻找编译过的 Java 代码,要指定文档的路径,得使用 <applet> 标签的 codebase 属性指定。

如下所示:

<applet codebase="http://amrood.com/applets"code="HelloWorldApplet.class" width="320" height="120">

如果 Applet 所在一个包中而不是默认包,那么所在的包必须在 code 属性里指定,例如:

<applet code="mypackage.subpackage.TestApplet.class"width="320" height="120">

获得applet参数

下面的例子演示了如何使用一个 Applet 响应来设置文件中指定的参数。该 Applet 显示了一个黑色棋盘图案和第二种颜色。

第二种颜色和每一列的大小通过文档中的 Applet 的参数指定。

CheckerApplet 在 init() 方法里得到它的参数。也可以在 paint() 方法里得到它的参数。然而,在 Applet 开始得到值并保存了设置,而不是每一次刷新的时候都得到值,这样是很方便,并且高效的。

Applet viewer 或者浏览器在 Applet 每次运行的时候调用 init() 方法。在加载 Applet 之后,Viewer 立即调用 init() 方法(Applet.init()什么也没做),重写该方法的默认实现,添加一些自定义的初始化代码。

Applet.getParameter() 方法通过给出参数名称得到参数值。如果得到的值是数字或者其他非字符数据,那么必须解析为字符串类型。

下例是 CheckerApplet.java 的修改:

CheckerApplet.java 文件代码:

下面是 CheckerApplet 类的 init() 方法和私有的 parseSquareSize() 方法:

该 Applet 调用 parseSquareSize(),来解析 squareSize 参数。parseSquareSize() 调用了库方法 Integer. parseInt() 该方法将一个字符串解析为一个整数,当参数无效的时候,Integer.parseInt() 抛出异常。

因此,parseSquareSize() 方法也是捕获异常的,并不允许 Applet 接受无效的输入。

Applet 调用 parseColor()方法将颜色参数解析为一个 Color 值。parseColor() 方法做了一系列字符串的比较,来匹配参数的值和预定义颜色的名字。你需要实现这些方法来使 Applet 工作。

指定 applet 参数

如下的例子是一个HTML文件,其中嵌入了 CheckerApplet 类。HTML文件通过使用 <param>标签的方法给 applet 指定了两个参数。

注意: 参数名字大小写不敏感。

应用程序转换成 Applet

将图形化的 Java 应用程序(是指,使用AWT的应用程序和使用 java 程序启动器启动的程序)转换成嵌入在web页面里的applet是很简单的。

下面是将应用程序转换成 Applet 的几个步骤:

编写一个 HTML 页面,该页面带有能加载 applet 代码的标签。

编写一个 JApplet 类的子类,将该类设置为 public。否则,Applet 不能被加载。

消除应用程序的 main()方法。不要为应用程序构造框架窗口,因为你的应用程序要显示在浏览器中。

将应用程序中框架窗口的构造方法里的初始化代码移到 Applet 的 init() 方法中,你不必显示的构造 Applet 对象,浏览器将通过调用 init() 方法来实例化一个对象。

移除对 setSize() 方法的调用,对于 Applet 来讲,大小已经通过 HTML 文件里的 width 和 height 参数设定好了。

移除对 setDefaultCloseOperation() 方法的调用。Applet 不能被关闭,它随着浏览器的退出而终止。

如果应用程序调用了 setTitle() 方法,消除对该方法的调用。applet 不能有标题栏。(当然你可以给通过 html 的 title 标签给网页自身命名)

不要调用 setVisible(true),Applet 是自动显示的。

事件处理

Applet 类从 Container 类继承了许多事件处理方法。Container 类定义了几个方法,例如:processKeyEvent() 和processMouseEvent(),用来处理特别类型的事件,还有一个捕获所有事件的方法叫做 processEvent。

为了响应一个事件,Applet 必须重写合适的事件处理方法。

ExampleEventHandling.java 文件代码:

如下调用该 Applet:

最开始运行,Applet 显示 "initializing the applet. Starting the applet.",然后你一点击矩形框,就会显示 "mouse clicked" 。

显示图片

Applet 能显示 GIF,JPEG,BMP 等其他格式的图片。为了在 Applet 中显示图片,你需要使用 java.awt.Graphics 类的drawImage()方法。

如下实例演示了显示图片的所有步骤:

ImageDemo.java 文件代码:

如下调用该applet:

播放音频

Applet 能通过使用 java.applet 包中的 AudioClip 接口播放音频。AudioClip 接口定义了三个方法:

public void play(): 从一开始播放音频片段一次。

public void loop(): 循环播放音频片段

public void stop(): 停止播放音频片段

为了得到 AudioClip 对象,你必须调用 Applet 类的 getAudioClip() 方法。无论 URL 指向的是否是一个真实的音频文件,该方法都会立即返回结果。

直到要播放音频文件时,该文件才会下载下来。

如下实例演示了播放音频的所有步骤:

AudioDemo.java 文件代码:

如下调用applet:

你可以使用你电脑上的 test.wav 来测试上面的实例。

更多教程 》

Java 8 新特性

Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本。 Oracle 公司于 2014 年 3 月 18 日发布 Java 8 ,它支持函数式编程,新的 JavaScript 引擎,新的日期 API,新的Stream API 等。

新特性

Java8 新增了非常多的特性,我们主要讨论以下几个:

Lambda 表达式 − Lambda允许把函数作为一个方法的参数(函数作为参数传递进方法中。

方法引用 − 方法引用提供了非常有用的语法,可以直接引用已有Java类或对象(实例)的方法或构造器。与lambda联合使用,方法引用可以使语言的构造更紧凑简洁,减少冗余代码。

默认方法 − 默认方法就是一个在接口里面有了一个实现的方法。

新工具 − 新的编译工具,如:Nashorn引擎 jjs、 类依赖分析器jdeps。

Stream API −新添加的Stream API(java.util.stream) 把真正的函数式编程风格引入到Java中。

Date Time API − 加强对日期与时间的处理。

Optional 类 − Optional 类已经成为 Java 8 类库的一部分,用来解决空指针异常。

Nashorn, JavaScript 引擎 − Java 8提供了一个新的Nashorn javascript引擎,它允许我们在JVM上运行特定的javascript应用。

更多的新特性可以参阅官网:What's New in JDK 8

在关于 Java 8 文章的实例,我们均使用 jdk 1.8 环境,你可以使用以下命令查看当前 jdk 的版本:

$ java -version

java version "1.8.0_31"

Java(TM) SE Runtime Environment (build 1.8.0_31-b13)

Java HotSpot(TM) 64-Bit Server VM (build 25.31-b07, mixed mode)

编程风格

Java 8 希望有自己的编程风格,并与 Java 7 区别开,以下实例展示了 Java 7 和 Java 8 的编程格式:

Java8Tester.java 文件代码:

执行以上脚本,输出结果为:

$ javac Java8Tester.java

$ java Java8Tester

使用 Java 7 语法:

[Baidu , Google , Runoob , Sina , Taobao ]

使用 Java 8 语法:

[Baidu , Google , Runoob , Sina , Taobao ]

接下来我们总结 Java 8 的新特性:

序号 特性
1 Lambda 表达式
2 方法引用
3 函数式接口
4 默认方法
5 Stream
6 Optional 类
7 Nashorn, JavaScript 引擎
8 新的日期时间 API
9 Base64
更多教程 》

超值特惠限量领取
1元=两周畅学

张**:电话158******** 已领取 /

王** : 电话186******** 已领取 /

王* : 电话186******** 已领取 /

李** : 电话158******** 已领取 /

刘* : 电话186******** 已领取 /

贾** : 电话186******** 已领取 /

程** : 电话158******** 已领取 /

胡* : 电话158******** 已领取 /

郭* : 电话158******** 已领取 /

范* : 电话134******** 已领取 /

徐** : 电话134******** 已领取 /

郑** : 电话186******** 已领取 /

刘** : 电话186******** 已领取 /

温** : 电话158******** 已领取 /

王** : 电话186******** 已领取 /

于** : 电话186******** 已领取 /

肖** : 电话134******** 已领取 /

魏** : 电话158******** 已领取 /

姚* : 电话134******** 已领取 /