Java编程——标识符、关键字和注释
Java编程——标识符、关键字和注释
Taotao无尽
这一节中主要介绍Java中的标识符的命名规则、Java中关键字和保留字以及注释的使用。4.1 标识符标识符就是在写Java程序时，自定义的一些名称，例如类的名称、变量的名称、方法的名称。例如，在上一节中，我们写一个HelloWorld程序：public class HelloWorld {public static void main(String[] args) {System.out.println(&我的第一个Java程序：Hello World。&);}}其中HelloWorld就是类的名称，那么HelloWorld就是一个标识符。 注意：在Java程序中，是区分大小写的，就是说明HelloWorld跟helloworld是两个不同的标识符。4.1.1 标识符的命名规范在Java语言中，对标识符的命名是要遵循以下规范的： （1）、由26个英文字母大小写（a~zA~Z）、数字(0~9)、下划线(_)和美元符号($)组成； （2）、不能以数字开头，只能以字母、下划线或者美元符号开头； （3）、严格区分大小写； （4）、标识符的长度不做限制，最好要做到见名知意； （5）、不能与Java的关键字和保留字一样。 例如： num，num9，num_1，$num，_num这样的标识符命名是正确的； 9num，num#，#num这样的标识符命名就是错误的。4.2 关键字和保留字（1）、Java中的关键字是对java的编译器有特殊的意义，它们用来表示一种数据类型，或者表示程序的结构等。 （2）、Java中的保留字是为java预留的关键字，他们虽然现在没有作为关键字，但在以后的升级版本中有可能作为关键字。 常见的关键字和保留字如下列表：（这些都不需要记，以后慢慢会学到。）在写HelloWorld程序时，我们就已经用到了public、class、static这样的关键字，同时在标识符的命名规范中有一条就是不能与关键字和保留字一样。4.3 注释注释是用来解释程序中某些代码的，利于理解程序。同时好的代码注释，也利于代码的维护，因为有时候程序是由以前的同事写的，现在需要你去维护，如果之前的同事写代码时，在关键的代码模块都加上了注释的话，这样对于你去维护代码就会有很大的帮助，如果去维护没有注释的代码，那是相当痛苦的。注释分成3种，分别是单行注释、多行注释和文档注释。4.3.1 单行注释单行注释，就是注释内容写在一行当中，用法如下：// 注释内容前面是2个“/”，后面是写注释内容。4.3.2 多行注释有时候注释内容比较多，写在一行，不要好看，所以此时就有了多行注释，就是注释的内容可以写多行，用法如下：/*注释内容…*/是以“/*”开头，以”*/”结尾，里面是写注释内容，而且注释内容可以写多行。4.3.3 文档注释文档注释有2个地方需要用到，一个是在类的上面，用于解释类的作用；另一个是在方法的上面，用于解释方法的作用，语法如下：/**文档注释内容是以”/**”开头，以”*/”结尾的，里面是写注释内容，同时注释内容也可以是多行的。 注意：形成API文档时，文档注释的内容会在API文档里面。下面还是以HelloWorld程序为例，将注释演示一下：该类是第1个Java程序类，作为入门演示用*/public class HelloWorld {程序的入口方法，也称为主方法向控制台输出一段话只是作为演示用System.out.println(&我的第一个Java程序：Hello World。&); // 输出内容注意：当Java程序编译成字节码时，注释内容会去除的，也就是说在字节码中是没有注释的，道理也很好理解，因为字节码是给JVM用的，JVM是不需要注释的，Java程序员才需要看注释，所以注释只在Java代码中。本文链接/archives/5773.html
本文仅代表作者观点，不代表百度立场。系作者授权百家号发表，未经许可不得转载。
Taotao无尽
百家号 最近更新：
简介: 科普机械原理，机械发明！
作者最新文章在此可输入您对该资料的评论~
(window.slotbydup=window.slotbydup || []).push({
id: '4540180',
container: s,
size: '250,200',
display: 'inlay-fix'
资料评价：
所需积分：2& & 在Java中，提供了3种注释方式：短（单行）注释、块（多行）注释及文档注释。单行和多行注释很容易理解，将注释符之间的内容当做注释，在编译和运行时将这部分内容忽略。下面介绍单行注释和多行注释的方法。
&&&&（1）单行注释：单行注释就是在程序中注释一行代码。
&&&&注释规则：在代码中单起一行注释， 注释前最好有一行空行，并与其后的代码具有一样的缩进层级。如果单行无法完成，则应采用块注释。
&&&&注释格式：：
&&&&// 注释内容
&&&&（2）多行注释：一次将程序中的多行注释掉。
&&&&注释规则：注释若干行，通常用于提供文件、方法、数据结构等的意义与用途的说明，或者算法的描述。一般位于一个文件或者一个方法的前面，起到引导的作用，也可以根据需要放在合适的位置。
&&&&注释格式：
&&&&/*&&&&&注释内容&&&&&*/
&&&&来看一个单行注释和多行注释的例子。
&&&&源文件：MessageComment.java
&&&&//这是一个单行注释&&&&/*&&&&这是一个&&&&多行注释&&&&*/&&&&public class MessageComment {&&&&&&&&public static void main(String[] args) {&&&&&&&&&&&&System.out.println("发信息");&&&&&&&&&&&&// System.out.println("此条信息不会显示");&&&&&&&&}&&&&}
&&&&在Java中，比较特殊的是javadoc注释，包含在这部分中的注释可以通过javadoc命令来自动生成API文档。通过javadoc工具，可以保证程序代码和技术文档的同步。在修改了程序中的注释后，只需要通过javadoc，就可以方便地生成相应的技术文档。
&&&&我们知道，在软件开发过程中，文档编写的重要性不亚于程序代码本身。如果代码与文档是分离的，那么在每次修改代码时，都需要修改相应的文档就会是一件很麻烦的事情。 所以通过javadoc将代码同文档&连接&起来。在Java中，还有一种特别的注释方式：文档注释。利用这种注释，可以从Java源文件中提取这些注释的内容，来产生HTML格式的API文档。
&&&&文档注释的基本格式如下：
&&&&/**&&&&文档注释内容&&&&*/
&&&&注意把文档注释和多行注释区分清楚，文档注释的开始标记是&/**&，而多行注释标记的开始标记是&/*&。
&&&&由于文档注释最重要的一个功能就是用它来生成HTML格式的API文档，因此，很多用于HTML格式化的HTML标记也可以用在文档注释中，在从这些注释中提取注释生成HTML文件的时候，在生成的HTML文件中，将使用这些HTML标记来格式化HTML文件内容。常用的HTML标记有&b&&&/b&、&code&&&/code&等。关于这些HTML标记及其他的HTML标记，请读者参考相关的HTML资料。
&&&&和多行注释不同的另一个地方是，文档注释并不是可以放在Java代码的任何地方，javadoc工具在从Java代码中提取注释生成API文档时，主要从以下几项内容中提取信息。
&&&&&包。&&&&&公有（public）类与接口。&&&&&公有方法和受保护（protected）方法。&&&&&公有属性和受保护属性。
&&&&因此，文档注释也应该放到相应的位置中。
&&&&1．文档注释位置
&&&&（1）类注释。类注释用于说明整个类的功能、特性等，它应该放在所有的&import&语句之后，在class定义之前。
&&&&这个规则也适用于接口（interface）注释。
&&&&（2）方法注释。方法注释用来说明方法的定义，比如，方法的参数、返回值及说明方法的作用等。方法注释应该放在它所描述的方法定义前面。
&&&&（3）属性注释。默认情况下，javadoc只对公有（public）属性和受保护属性（protected）产生文档&&通常是静态常量。
&&&&（4）包注释。类、方法、属性的注释都直接放到Java的源文件中，而对于包的注释，无法放到Java文件中去，只能通过在包对应的目录中添加一个package.html的文件来达到这个目的。当生成HTML文件时，package.html文件的&BODY&和&/BODY&部分的内容将会被提取出来当做包的说明。关于包注释，后面还会有更进一步的解释。
&&&&（5）概要注释。除了包注释外，还有一种类型的文档无法从Java源文件中提取，就是对所有类文件提供概要说明的文件。同样的，也可以为这类注释单独新建一个HTML文件，这个文件的名字为&overview.html&，它的&BODY&和&/BODY&标记之间的内容都会被提取。
&&&&2．javadoc标记
&&&&在javadoc注释中，常用@来表示一个javadoc标记，常用的javadoc标记如下：
&&&&&@author：作者。&&&&&@version：版本。&&&&&@docroot：表示产生文档的根路径。&&&&&@deprecated：不推荐使用的方法。&&&&&@param：方法的参数类型。&&&&&@return：方法的返回类型。&&&&&@see：用于指定参考的内容。&&&&&@exception：抛出的异常。&&&&&@throws：抛出的异常，和exception同义。
&&&&需要注意这些标记的使用是有位置限制的。其中可以出现在类或者接口文档注释中的标记有：@see、@deprecated、@author、@version等。可以出现在方法或者构造器文档注释中的标记有：@see、@deprecated、@param、@return、@throws、@exception等。可以出现在属性文档注释中的有：@see、@deprecated等。
&&&&3．javadoc命令语法
&&&&javadoc的命令行语法如下：
&&&&javadoc [ options ] [ packagenames ] [ sourcefiles ] [ @files ]
&&&&参数可以按照任意顺序排列。下面对这些参数作一些说明。
&&&&（1）packagenames 包列表：这个选项可以是一系列的包名（用空格隔开），例如，java.lang java.lang.reflect java.awt。因为javadoc不递归作用于子包，不允许对包名使用通配符；所以必须显式地列出希望建立文档的每一个包。
&&&&（2）sourcefiles 源文件列表。这个选项可以是一系列的源文件名（用空格隔开），可以使用通配符。javadoc允许4种源文件：类源代码文件、包描述文件、总体概述文件、其他杂文件。
&&&&&类源代码文件：类或者接口的源代码文件。
&&&&&包描述文件：每一个包都可以有自己的包描述文件。包描述文件的名称必须是 &package.html&，与包的.java文件放置在一起。包描述文件的内容通常是使用HTML标记写的文档。javadoc执行时将自动寻找包描述文件。如果找到，javadoc将首先对描述文件中&body&&/body&之间的内容进行处理，然后把处理结果放到该包的Package Summary页面中，最后把包描述文件的第一句（紧靠&body&）放到输出的Overview Summary页面中，并在语句前面加上该包的包名。
&&&&总体概述文件：javadoc可以创建一个总体概述文件描述整个应用或者所有包。总体概述文件可以被任意命名，也可以放置到任意位置。-overview选项可以指示总体概述文件的路径和名称。总体概述文件的内容是使用HTML标记写的文档。javadoc在执行的时候，如果发现-overview选项，那么它将首先对文件中&body&&/body&之间的内容进行处理；然后把处理后的结果放到输出的Overview Summary 页面的底部；最后把总体概述文件中的第一句放到输出的Overview Summary页面的顶部。
&&&&其他杂文件：这些文件通常是指与javadoc输出的HTML文件相关的一些图片文件、Java源代码文件（.java）、Java程序（.class）、Java小程序（Applets）、HTML文件。这些文件必须放在doc-files目录中。每一个包都可以有自己的doc-files目录。例如，你希望在java.awt.Button的HTML文档中使用一幅按钮的图片（Button.gif）。首先，必须把图片文件放到java\awt\doc-files\中；然后在Button.java文件中加入以下注释：
&&&&/**&&&&* This button looks like this:&&&&* &img src="doc-files/Button.gif"&&&&&*/
&&&&files 包含文件。为了简化javadoc命令，可以把需要建立文档的文件名和包名放在一个或多个文本文件中。例如，为了简化以下命令：
&&&&javadoc -d apidoc com.oristand.college com.oristand.school
&&&&可以建立一个名称为mypackage.txt的文件，其内容如下：
&&&&com.oristand.college&&&&com.oristand.school
&&&&然后执行以下命令即可：
&&&&javadoc -d apidoc @mypackage.txt
&&&&&options 命令行选项。
&&&&① public 只显示公共类及成员。&&&&② protected 只显示受保护的和公共的类及成员。默认选项。&&&&③ package只显示包、受保护的和公共的类及成员。&&&&④ private 显示所有类和成员。
&&&&-classpath classpathlist 指定javadoc查找&引用类&的路径。引用类是指带文档的类加上它们引用的任何类。javadoc将搜索指定路径的所有子目录，classpathlist可以包含多个路径（使用&;&隔开）。
&&&&一切就绪后，就可以使用JDK中的&javadoc&工具来生成相关的API文档了。
& &转自：华清远见网，原文地址：
阅读(...) 评论()您所在位置： &
&nbsp&&nbsp&nbsp&&nbsp
第2章Java编程基础—教学设计讲解.doc 16页
本文档一共被下载：
次 ,您可全文免费在线阅读后下载本文档。
下载提示
1.本站不保证该用户上传的文档完整性，不预览、不比对内容而直接下载产生的反悔问题本站不予受理。
2.该文档所得收入(下载+内容+预览三)归上传者、原创者。
3.登录后可充值，立即自动返金币，充值渠道很便利
需要金币：300 &&
你可能关注的文档：
··········
··········
《Java基础入门》
课程名称： Java基础教程
授课年级： 2014年级
授课学期： 2014学年第一学期
教师姓名：
2014年月日
Java语言是严格区分大小写的。
在编写程序代码时，尽量做到整齐、美观、层次清晰，使用代码保持一种良好的格式，提高可读性。
Java中的注释
单行注释是对程序中的某一行代码进行解释，用符号“//”表示。“//”后面为被注释的内容，具体示例如下：
int c = 10;
// 定义一个整型变量
多行注释以符号“/*”开头，以符号“*/”结尾，具体示例如下：
int c = 10;
int x = 5; */
以“/**”开头，并在注释内容末尾以“*/”结束。文档注释是对代码的解释说明，可以使用javadoc命令将文档注释提取出来生成帮助文档。
Java中的标识符
什么是标识符
在编程过程中，经常需要在程序中定义一些符号来标记一些名称，如，包名、类名、方法名、参数名、变量名等，这些符号被称为标识符。
定义标识符的规则
包名所有字母一律小写。例如：cn.itcast.test。
类名和接口名每个单词的首字母都要大写。
例如：ArrayList、Iterator
常量名字母都大写，单词之间用下划线连接。
例如：DAY_OF_MONTH
变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写。
例如：lineNumber、getLineNumber
在程序中，应该尽量使用有意义的英文单词来定义标识符，使得程序便于阅读。例如使用userame表示用户名，passord表示密码
Java中的常量
整型常量是整数类型的数据，有二进制、八进制、十进制和十六进制4种表示形式，具体表示形式如下：
二进制：由数字0 和1 组成的数字序列。例如：
八进制：以0开头并且其后由0 ~7范围的整数组成的数字序列。
十进制：由数字0~9范围的整数组成的数字序列。如：198。
十六进制：以0x或0X开头并其后由0~9、A~F组成的数字序列。
浮点数常量
浮点数常量就是在数学中用到的小数，分为float单精度浮点数和double双精度浮点数两种类型。单精度浮点数后面以F或f结尾，双精度浮点数则以D或d结尾。具体示例如下：
5.022e+23f
字符常量用于表示一个字符，字符常量要用一对英文半角格式的单引号（' '）引起来，具体示例如下：
'\r' '\u0000'
注意：'\u0000'表示一个空白字符，即在单引号之间没有任何字符。
字符串常量
字符串常量用于表示一串连续的字符，一个字符串常量要用一对英文半角格式的双引号（& &）引起来，具体示例如下：
&HelloWorld&
&Welcome \n XXX& &&
布尔常量即布尔型的两个值true和false，用于区分一个事物的真与假。
null常量只有一个值null，表示对象的引用为空。
（变量的定义、变量的数据类型、变量的类型转换、变量的作用域）
变量的定义
在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在一些内存单元中，每个内存单元都用一个标识符来标识。这些内存单元我们称之为变量，具体示例如下：
int x = 0,y;
第一行代码的作用是定义了两个变量x和y，相当于分配了两块内存单元，变量x和y在内存中的状态如图：
第二行代码的作用是为变量赋值，在执行第二行代码时，程序首先取出变量x的值，与3相加后，将结果赋值给变量y，此时变量x和y在内存中的状态如图：
变量的数据类型
数据类型分类
整数类型变量
整数类型变量用来存储整数数值，即没有小数部分的值。整数类型分
为4种不同的类型，所占存储空间的大小以及取值范围如下表所示：
8位（1个字节）
16位（2个字节）
正在加载中，请稍后...【尘★原创整理】 经典50题JAVA版程序(含详细注释)【java吧】_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：649,804贴子：
【尘★原创整理】 经典50题JAVA版程序(含详细注释)收藏
在自己的帖子里说了好多天了，想把这些题目整理出来供大家交流。
请先看完本吧精品贴
Java学习之路：不走弯路，就是捷径 这里vajoy写的帖子（当然我不认识他），希望在学习前大家可以仔细看看，而且每过些天就重新体会下 。
车型齐全,品牌齐全,现车供应!
一．首先要声明几点： ***本人也是新人，请抱着怀疑的角度看代码，这不是答案，质量高不高，请自行判断 1. 原创性完全可以保证，相信网上答案多了去了，可是作为一个新人，也许详细的注释说明对理解别人的代码很有帮助，这里的代码有很多我认为要注释出来的地方都做了说明。 2.
3. 请确保您自己已经做了至少25道以上再来看我写的程序，前面给的链接，其实是想让看官知道自学能力的重要性，如果您有哪一道程序没想明白，看别人的代码，至少要带着自己的疑问。请不要为了完成作业，来分析我的代码。 4.
5. 对于大神级的看官，小弟代码有不少地发可能有不妥之处，或者有更简洁的思路，在闲暇之余，望不吝指教~ 二．写在前面： 对于老手，可能都在忙工作了，很少有大神愿意在贴吧给我们这些菜鸟细细分析一些经验，后者技巧。 所以，作为菜鸟的我们应该多多交流。但是，交流之前，请明确一点，不明白的地方最好自己想办法弄清楚，有些问题很明显是由于自己没有去搜索相关资料和思考就问出来，这种问题经常问的自己都不明白，别人也不好讲解，所以要学会问问题。学会问自己，前面vajoy的帖子已经写了很多，不多说了。 分析这50到题目的时候，我在每一道之前都会问自己，这个程序我是想用户输入哪些参数，怎么输入，得到什么结果，或者程序直接经过处理数据输出一个什么结果。我需要定义一些什么变量，（有时候可能在实现的过程中才发觉）我需不需要定义一个方法让其能处理一些数据，到达我调用就能返回给自己满意的结果的效果。 然后不要怕时间不够，自己学的慢，如果这是你的理想，那就迎难而上，坚信只要自己好好付出了，在这个过程，总会有各种各样的收获。有些路一直走下去就是了~~~ 废话不多说，请勿在50题中间插楼~~~~~感谢花时间看到这里！！！
import java.util.S public class Test1 { /**
* 【程序1】 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一
* 对兔子，假如兔子都不死，问每个月的兔子总数为多少？ 1.程序分析： 兔子的规律为数列1,1,2,3,5,8,13,21....
* 分析：这是一个斐波那契数列问题，做完可以去百度一下此数列相关问题
* 这里是第一个题目，用到了递归，我想了一下要不要用更通俗的办法， 递归并不是什么高深的东西，只要花几分钟查阅下，
* 就能懂个大概，万事开头都只能了解到皮毛 ，并不推荐用递归，因为LZ个人兴趣用了这种方法，以后就会知道用递归会增加
* 程序很多负担，而且对较大的参数会发生堆栈溢出或者运行时间增长，但是它的优点就是思想很简洁。
* 在下面会提供另一种方法。
* */ public static int fibonacci(int n) {
//前两个月都是1，所以设置递归出口为n&=2
if (n &= 2) {
//如果你查询了相关递归的用法，也就很容易理解下面只是很常见的调用方法罢了
//因为从第三项开始每一项是前两项的和
return fibonacci(n - 1) + fibonacci(n - 2);
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("您想知道第几个月份的兔子总和? 请输入月份：");
int n = input.nextInt();
System.out.println("第" + n + "个月将会有" + fibonacci(n) + "对兔子"); }}
import java.util.S public class Test1_1 {
* 方法2：循环。
public int summationRabbit(int month) {
//将每个月拥有的兔子存在数组arrRabbit里面，方便后来的相加前两个月的兔子数
int[] arrRabbit = new int[month];
//要知道第month个月的数，就要知道他前面的月份兔子数，所以用循环求前面每个月的兔子数
for (int i = 1; i &= i++) {
//当月份是1，2的时候让数组里的元素为1，因为第一月、第二个月都是1对兔子
if (i == 1 || i == 2) {
arrRabbit[i - 1] = 1;
//往后的月份，每个月的兔子数是前面两个月的和
arrRabbit[i - 1] = arrRabbit[i - 2] + arrRabbit[i - 3];
//返回用户想知道的数据， 最后一个月的兔子数
return arrRabbit[month - 1]; }
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入月份：");
int month = input.nextInt();
Test1_1 t1_1 = new Test1_1();
int sum = t1_1.summationRabbit(month);
System.out.println("第" + month + "个月将有" + sum + "对兔子"); }}
public class Test2 { /**
* 题目：判断101-200之间有多少个素数，并输出所有素数。
* 1.程序分析：判断素数（质数）的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，
*则表明此数不是素数，反之是素数。
public static void main(String[] args) {
int number = 0;
//count是素数的个数，当判断一个数位素数后就执行cout++；
int count = 0;
int i = 0;
//外层循环控制101到200之间的数依次给内层循环判断，（不包括101和200）
for (number = 102; number & 200; number++) {
//通过让number除以因数i，这个因数的范围是从1到number之间，不包括1和number
for (i = 2; i & i++) {
//如果在i的变化范围内，有number的因数，当然number就不是素数
if (number % i == 0) {
//若在i的范围内没有number的因数(i执行完内层循环到这里值已经是等于number)，
//说明number只能被1和他本身整除，即素数
if (i == number) {
//这里可以把每个素数打印出来
System.out.print(number + " ");
System.out.println();
System.out.println("101到200间有" + count + "个素数。"); }}
public class Test2 { public static void main(String[] args) {
int count = 0;
//控制数的范围
for (int number = 102; number & 200; number++) {
//定义一个布尔型isSuS含义不言而喻
boolean isSuShu =
for (int i = 2; i & i++) {
if (number % i == 0) {
//如果没有执行上面if语句，那isSuShu还是
if (isSuShu) {
System.out.print(number + " ");
System.out.println();
System.out.println("101到200间有" + count + "个素数。"); }}
public class Test3 {
* 【程序3】
*题目：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：
*153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。
*1.程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。
*水仙花数当然不光指一个三位数，这里出题人为了不复杂化，只需要三位数的水仙花数
public static void main(String[] args) {
//定义一个三位数number先
int number = 0;
System.out.println("三位数中水仙花数为：");
//for循环条件控制三位数，条件控制number的取值范围
for(number = 100; number & 1000; number++){
//a是三位数百位上的数字，b是十位，c为各位
int a = number / 100;
int b = number % 100 / 10;
int c = number % 10;
//当然要定义一个变量sum为a,b,c的立方和
int sum = (a*a*a) + (b*b*b) + (c*c*c);
//判断该数满不满足提示所给水仙花数的条件
if(sum == number){
System.out.print(sum + " ");
//如果没有执行上面if语句，那isSuShu还是
if (isSuShu) {
System.out.print(number + " ");
System.out.println();
System.out.println("101到200间有" + count + "个素数。"); }}
不好意思，
浏览器故障 test3后面半段是test2后面的 请注意！！！
import java.util.*; class FenJie { /**
* 题目：将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。
* 程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：
* (1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。
* (2)如果n≠k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数n,重复执行第一步。
* (3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。
*/ // changeYinShu()方法想达到的效果是调用一次该方法就判断一次调用的参数是不是质数 如果是质数, // 就返回该数， 如果不是，就自行返回该数后面一个相邻质数 比如参数为4，就自行返回5 public static int changeYinShu(int number) {
int i = 2;
for (i = 2; i & i++) {
if (number % i == 0) {
// 如果传入的参数不是一个质数，那就自动寻找比这个参数大的而且最靠近它的质数
// 其实这个方法，是为了满足下面fenJie()方法里质因数k的需要，找出比k大的一个质数。
// 这里将i重新赋值为1，因为continue执行后i会自增，想达到的目的是再次让for循环
// 里面的变量i在下次循环是初始为2；
// k为因数，初始值为2. 这是最小的质因数 int k = 2;/** * 关于这个递归方法，如果数过大，比如90001会引起堆栈溢出引发错误，有兴趣可以探究一下 *
* */ public int fenJie(int n) {
// 递归的出口
if (n == k) {
System.out.print(k);
// 当k是n的一个质因数时，就打印出k,并且将n赋值为 n /
if (n % k == 0) {
System.out.print(k + "*");
return fenJie(n);
// 若n不能被k整除时，就换下一个质因数，这时调用改变因数changeYinShu()的方法，
// 传入的参数为 k + 1,换下一个因数去试
k = FenJie.changeYinShu(k + 1);
return fenJie(n);
} }} public class Test4 { public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入一个正整数：");
int num = input.nextInt();
FenJie fenJieNumber = new FenJie();
// 定义好方法后，要想分解一个数，只需要调用fenJie()方法了
fenJieNumber.fenJie(num);
import java.util.S public class Test4_1 { /**
* 由于Test4可能由于质因数过大引发递归太深，导致堆栈溢出，可以在重新定义分解的方法
//judgePrime()方法判断参数是不是质数 public static boolean judgePrime(int number) {
int i = 0;
for (i = 2; i & i++) {
if (number % i == 0) {
//如果是质数，那么经过上面的循环，没有一个i使number能被i整除，最后循环执行完i会增加到值等于number
//返回true说明number是质数
if (i == number) {
public void fenJieNumber(int number) {
//如果number已经是质数，那就不用分解了，直接输出number就好了
if (Test4_1.judgePrime(number)) {
System.out.println(number);
//如果不是质数，就要分解因数了
int k = 0;
//分解的思想基本和前面一样，从最小的质数2开始找
for (k = 2; k & k++) {
if (number % k == 0) {
System.out.print(k + "*");
number = number /
//这里number变为(number / k)后，要重新从最小的质数2开始找
//所以将k重新赋值为1，因为执行完语句后，k还会自增
//如果number不能被k整除，那么就continue执行k++，继续下一轮循环
//经过上述分解后，最后当然剩下最后的一个不能在被分解的质数，它就作为最后一个质因数
System.out.print(number);
public static void main(String[] args) {
Test4_1 t4 = new Test4_1();
Scanner input = new Scanner(System.in);
System.out.println("请输入一个整数：");
int number = input.nextInt();
t4.fenJieNumber(number); }}
想买澳洲奶粉？这里有一条包税专线
import java.util.S public class Test4_3 {
* 题目：将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。
* 程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：
* (1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。
* (2)如果n≠k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数n,重复执行第一步。
* (3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。
*/ //PS：这一题做了很多遍，这个是第三个（从类名就看出来了），待会把最开始做的发出来，从中可以体现一些思路 //也许你在思考的时候也有过LZ这样的想法吧
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入一个正整数:");
int number = input.nextInt();
//定义因数k，初始化为最小的因数2，待会找质因数的时候就要从最小的开始找
int k = 2;
//程序分析中第二条，如果不相等，就要重复进行找质因数的过程
while (k &= number) {
//循环结束的条件，程序分析第一条
if (k == number) {
System.out.println(number);
//如果k是number的一个质因数，就打印出来。这里k是从2开始判断的
else if (number % k == 0) {
System.out.print(k + "*");
number = number /
//如果上面的两个条件都不满足，说明k不是number的一个质因数， 那么就自增k,从下一个数开始找，如此循环
//分解质因数，最小的因数是在前面的，这个可以想象以前用数学方法分解因数的过程
import java.util.S public class Test5 { /**
* 【程序5】
*题目：利用条件运算符的嵌套来完成此题：学习成绩&=90分的同学用A表示，60-89分之间的用B表示，60分以下
*的用C表示。
*1.程序分析：(a&b)?a:b这是条件运算符的基本例子。
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入学员的个数：");
int number = input.nextInt();
//将每个学员的成绩值保存到数组arr中。
double[] arr = new double[number];
//获取学员的成绩
for (int i = 0; i & i++) {
System.out.println("请输入第" + (i + 1) + "个学员的成绩：");
arr[i] = input.nextDouble();
//判断学员成绩的等级
for(int i = 0; i & i++){
//嵌套三目运算符进行判断
String chengji = (arr[i] &= 90) ? "A" :
((arr[i] &= 60 && arr[i] &= 89) ? "B" : "C");
System.out.println("第" + (i + 1) + "个学员的成绩为：" + chengji);
import java.util.S /** * 【程序6】 题目：输入两个正整数m和n，求其最大公约数和最小公倍数。 1.程序分析：利用辗除法。 *
* */public class Test6 {
// 最大公约数highest common factor，方法取名叫getHcf() // 为什么向下面这样求最大公约数，请百度辗除法，哈哈~~有详细算法介绍 public static int getHcf(int a, int b) {
// temp为了在交换数值的时候做中间量
int temp = 0;
// 循环执行条件为a不能被b整除，如果a被b整除的时候就不在执行循环。
while (a % b != 0) {
// 方法getLCM() LCM 最小公倍数 lowest common multiple public static int getLcm(int a, int b) {
// 求得最大公约数再来求最小公倍数就很简单了，直接将a和b的乘积除以他们的最大公约数就OK了
int lcm = (a * b) / Test6.getHcf(a, b); }
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入第一个整数a：");
int a = input.nextInt();
System.out.println("请输入第二个整数b:");
int b = input.nextInt();
Test6.getHcf(a, b);
System.out
.println("整数" + a + "和" + b + "的最大公约数为：" + Test6.getHcf(a, b));
System.out
.println("整数" + a + "和" + b + "的最小公倍数为：" + Test6.getLcm(a, b));
import java.util.*; /** * 【程序7】 题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
* 1.程序分析：利用while语句,条件为输入的字符不为'\n'. *
* 这里调用了一些方法，也许还没有接触到，后面有不需要调用这些方法的程序 * */public class Test7 {
public static void main(String[] args) {
//要求得各种字符的个数，当然需要几个变量来储存他们的数量。
int word = 0;
int number = 0;
int space = 0;
int others = 0;
Scanner input = new Scanner(System.in);
System.out.println("请输入一行字符:");
String s = input.nextLine();
//将字符串内容转换为char类型，方便存到数组中，调用String类的toCharArray()方法
char[] n = s.toCharArray();
for (int i = 0; i & n. i++) {
// 调用Character类的方法isLetter(char ch)方法判断是否为字母
if (Character.isLetter(n[i])) {
// 调用Character类的方法isDigit(char ch)方法判断是否为数字
else if (Character.isDigit(n[i])) {
// 调用Character类的方法isSpaceChar(char ch)判断是否为空格键
else if (Character.isSpaceChar(n[i])) {
// 以上都不是则认为是其他字符
System.out.println("字母个数：" + word);
System.out.println("数字个数：" + number);
System.out.println("空格个数：" + space);
System.out.println("其他字符个数：" + others); }}
import java.util.*; public class Test7_2 {
public static void main(String[] args) {
int word = 0;
int number = 0;
int space = 0;
int others = 0;
Scanner input = new Scanner(System.in);
System.out.println("请输入字符串：");
String str = input.nextLine();
char[] ch = str.toCharArray();
for (int i = 0; i & ch. i++) {
while (ch[i] != '\n') {
//相信在大学学过C语言的都很熟悉这个写法吧，哈~~
//通过关系运算符判断元素属于哪一类
if (ch[i] &= 'a' && ch[i] &= 'z' || ch[i] &= 'A'
&& ch[i] &= 'Z')
else if (ch[i] &= '0' && ch[i] &= '9')
else if (ch[i] == ' ')
System.out.println("字母字符的个数" + word);
System.out.println("数字字符的个数" + number);
System.out.println("空格的个数" + space);
System.out.println("其他字符的个数" + others); }}
import java.util.*;public class Test8 {/** * 【程序8】
题目：求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+(此时共有5个数相加)， * */ //power方法
计算a的b次方，这里自己定义了一个简单的power方法，在Math类里面已经有一个pow(double a, double b)方法 //其实直接调用就好了. public static int power(int a, int b){
int p = 1;
for(int i = 0; i & i++){
} /**JiSuan方法计算形如aaaa的数的数值,算法如下，例如aaaa这个数的算法：
*aaaa = a*10000+a*1000+a*100+a*10+a,这里大可放心的用递归方法，
* 他的优势凸显出来了，简单的思想，优雅的形式，不必担心递归过深的问题
* */ //参数j表示位数，getNumber()方法返回的其实是一个各位都是1的数(如：1111) public static int getNumber(int j){
int i = Test8.power(10, j);
if(j == 0){
return i+getNumber(j - 1);
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("输入要相加数字的个数：");
int count = input.nextInt();
System.out.println("输入这些数字各位的数：");
int a = input.nextInt();
int sum = 0;
//循环得到一组aaa的值（a,aa,aaa,aaaa）存到数组里
int[] arr = new int[count];
for(int i = 0; i & arr. i++){
//得到各个数字
arr[i] = a*Test8.getNumber(i);
//计算他们的和
for(int i = 0; i & arr. i++){
sum += arr[i];
//打印出结果
for(int i = 0; i & arr.length-1; i++){
System.out.print(arr[i] + "+");
//由于最后会多一个
+ 号，所以我想到将最后一项单独打印出来
System.out.print(arr[arr.length-1]);
System.out.println("=" + sum); }}
public class Test9 { /**
* 【程序9】 题目：一个数如果恰好等于它的因子之和，这个数就称为"完数"。
例如6=1＋2＋3. 编程 找出1000以内的所有完 数。
* */ // 定义一个方法，求一个数的所有因数的和，命名为getSumFactor(); public static int getSumFactor(int number) {
// sum的值是number这个数所有因数的和
int sum = 0;
// 找number的所有因数，除去factor本身,从1开始找起,然后让各个因数相加
for (int i = 1; i & i++) {
if (number % i == 0) {
} else {// 继续循环
public static void main(String[] args) {
int number = 0;
System.out.println("1000以内所有的完数：");
for (number = 1; number & 1000; number++) {
// 如果通过调用getSumFactor()方法求到的和与数字本身相等，就是完数了
if (number == Test9.getSumFactor(number)) {
System.out.print(number + " ");
import java.util.S public class Test10 {
* 【程序10】
*题目：一球从100米高度自由落下，每次落地后反跳回原高度的一半；
*再落下，求它在 第10次落地时，共经过多 少米？第10次反弹多高？
* 改动下题目是求出第N次落地共经过多少米，第n次反弹多高
* 注意区分第几次反弹的高度 和 第几次落地经过的距离这两个概念
* */ //定义方法getReboundHeight()求得第n次反弹的高度,传入的参数为整型（次数），返回double型（高度） public static double getReboundHeight(int n){
//初始为100
double reboundHeight = 100;
for(int i = 1; i &= i++){
//reboundHeight为double型：/ 为除法
reboundHeight /= 2;
return reboundH }
//定义方法getDistance()求的第n次落地是经过的距离 public static double getDistance(int n){
int distance = 100;
//第一次落地经过100米
if(n == 1){
//从第二次开始落地经过的总距离为上一次经过的距离加上一次反弹高度的2倍
//比如第二次落地经过的总距离为第一次经过的距离加第一次反弹高度*2
for(int i = 2; i &= i++){
distance +=
(Test10.getReboundHeight(i - 1) * 2);
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("您想知道第几次落地后经过的总距离和反弹的高度？请输入数值：");
int n = input.nextInt();
System.out.println("第" + n + "次落地后共经过" + Test10.getDistance(n) + "米");
System.out.println("第" + n + "次反弹的高度为" + Test10.getReboundHeight(n) + "米");
public class Test11 {
* 【程序11】
*题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？
*1.程序分析：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去 掉不满足条件的排列。
* PS:还想达到输出格式为每行6个数字的效果~~~可以将百位是1的几个数字放一行
百位是2的放下一行·········
public static void main(String[] args) {
//可以将变量a看成百位上的数字；b：十位上的数字；c:个位的数字
int a = 0;
int b = 0;
int c = 0;
//符合条件的数的个数count
int count = 0;
//三重for循环~~知道for循环的执行机制，应该不难理解吧
for(a = 1; a &=4; a++){
for(b = 1; b &= 4; b++){
for(c = 1; c &= 4; c++){
//因为各个位上的数字不能重复，所以判断语句如下
if(a != b && a != c && b != c){
System.out.print(a + "" + b + "" + c + "
//在外层for循环里面打印转行，可以实现可以将百位是1的几个数字放一行，
百位是2的放下一行····
System.out.println();
System.out.println("能组成" + count + "个互不相同且无重复的数字"); } }
import java.util.S public class Test12 {
* 【程序12】 题目：企业发放的奖金根据利润提成。
* 1.利润(I)低于或等于10万元时，奖金可提10%;
* 2.利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可提成7.5%;
* 3.20万到40万之间时，高于20万元的部分，可提成5%;
* 4.40万到60万之间时高于40万元的部分，可提成3%;
* 5.60万到100万之间时，高于60万元的部分，可提成1.5%;
* 6.高于100万元时，超过100万元的部分按1%提成.从键盘输入当月利润I，求应发放奖金总数？
* */ public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入您获得的利润：");
// 利润定义成long型，万一您是亿万富翁捏~~~~~~~~~~
//这里可以直接认为是单位是万元 ，将利润定义为double型就好了
double profit = input.nextLong();
double bonus = 0;
//无非是一些if-else判断语句~~
if (profit & 0 && profit &= 10) {
bonus = profit * 0.1;
System.out.println("可以获得奖金" + bonus + "万元");
else if (profit & 10 && profit &= 20) {
bonus = ((10* 0.1) + (profit - 10) * 0.075);
System.out.println("可以获得奖金" + bonus + "万元");
else if (profit &= 20 && profit &= 40) {
bonus = ((10 * 0.1) + 10* 0.075) + (profit - 20) * 0.05;
System.out.println("可以获得奖金" + bonus + "万元");
else if (profit &= 40 && profit &= 60) {
bonus = ((10 * 0.1) + 10 * 0.075) + 20 * 0.05 + (profit - 40)
System.out.println("可以获得奖金" + bonus + "万元");
//为了简化，做了一些化简运算
else if (profit & 60 && profit &= 100) {
bonus = 10 * 0.175 + 20* 0.08 + (profit - 60) * 0.015;
System.out.println("可以获得奖金" + bonus + "万元");
else if (profit & 100) {
bonus = 10 * 0.175 + 20 * 0.08 + 40 * 0.015 + (profit - 100) * 0.01;
System.out.println("可以获得奖金" + bonus + "万元");
public class Test13 {
* 【程序13】 题目：一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？
* 1.程序分析：在10万以内判断，先将该数加上100后再开方，再将该数加上268后再开方，如果开方后的结果满足 如下条件，即是结果。请看具体分析：
* 蛋疼的题 说好的分析呢~~~~~~~~~~
* 分析：只有自己分析了，这里有两种想法
* 1.有一个类里面都是完全平方数，再在一个范围内寻找，如果一个数+100后在那个类里面，而且+168也在那个类里，就说明满足条件
* 2.直接用相反的方法，求平方根，如果一个数加上100和168后的平方根都是整数，那么就满足条件
* 这里都在-0000判断
public static void main(String[] args) {
int number = 0;
for(number = -100000; number & 100000; number++){
boolean a = completeSquareNumber.getCSNumber(number + 100);
boolean b = completeSquareNumber.getCSNumber(number + 268);
//如果传入的两个参数都是属于arr[]数组； 也就是说number+100 和 number+268都是完全平方数
那就打印次数number
//这里a和b都是布尔型，可以直接做判断语句的条件
if(a && b){
System.out.println(number);
} }} //定义一个类 里面包含一个数组，数组里面存储的都是完全平方数//完全平方数：complete square numberclass completeSquareNumber { //暂且存1000个完全平方数 static int[] arr = new int[1000];
//判断传入的数字是不是完全平方数 public static boolean getCSNumber(int number) {
for (int i = 1; i &= 1000; i++) {
arr[i - 1] = i *
//如果number等于数组里面某个元素就返回
if(number == arr[i - 1]){
//如果数组里面所有的元素都不和参数number相等，就返回false }}
public class Test13_2 {
//2.直接用相反的方法，求平方根，如果一个数加上100和168后的平方根都是整数，那么就满足条件 public static void main(String[] args) {
int number = -100000;
//在100000以内寻找~~~~
while(number & 100000){
//调用Math类的sqrt()求平方根，注意它返回double型数值
double num1 = Math.sqrt(number + 100);
double num2 = Math.sqrt(number + 268);
//如果num1和num2在数值上都是等于一个整数，那么就找到符合条件的数了
if(num1 % 1 == 0.0 && num2 % 1 == 0.0){
System.out.println(number);
import java.util.S public class Test14 { /**
* 【程序14】 题目：输入某年某月某日，判断这一天是这一年的第几天？
* 1.程序分析：以3月5日为例，应该先把前两个月的加起来，然后再加上5天即本年的第几天，特殊情况，闰年且 输入月份大于3时需考虑多加一天。
* 这题目真蛋疼 一看就要考虑12种不同的情况~~~我开始怎么没想到switch语句~~~不知道有没有更简单的方法
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入年份：");
int year = input.nextInt();
System.out.println("请输入月份：");
int month = input.nextInt();
System.out.println("请输入日期：");
int day = input.nextInt();
int result = 0;
int february = 28;
// 判断是不是闰年，如果是就执行 february = 29;
if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)) {
february = 29;
switch (month) {
result = 31 +
result = 31 + february +
result = 31 + february + 31 +
result = 31 + february + 31 + 30 +
result = 31 + february + 31 + 30 + 31 +
result = 31 + february + 31 + 30 + 31 + 30 +
result = 31 + february + 31 + 30 + 31 + 30 + 31 +
result = 31 + february + 31 + 30 + 31 + 30 + 31 + 31 +
result = 31 + february + 31 + 30 + 31 + 30 + 31 + 31 + 30 +
result = 31 + february + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31
result = 31 + february + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30
System.out.println(year + "年" + month + "月" + day + "号是这一年第" + result
+ "天"); }}
import java.util.S public class Test15 { /**
* 题目：输入三个整数x,y,z，请把这三个数由小到大输出。
* 1.程序分析：我们想办法把最小的数放到x上，先将x与y进行比较，如果x&y则将x与y的值进行交换，然后再用x
* 与z进行比较，如果x&z则将x与z的值进行交换，这样能使x最小
* 这个题目就不用多讲了~~学到排序的方法后，都会··当然排序有很多种方法，也是一门学问，今后还会考虑更多
* 排序的东西，比如排序所需的时间~~
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int[] arr = new int[3];
for (int i = 0; i & arr. i++) {
System.out.println("请输入第" + (i + 1) + "个数字");
arr[i] = input.nextInt();
//用一个冒泡
for (int i = 0; i & arr.length - 1; i++) {
for (int j = 0; j & arr.length - 1 - j++) {
if (arr[j] & arr[j + 1]) {
int temp = 0;
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] =
for (int i = 0; i & arr. i++) {
System.out.print(arr[i] + " ");
public class Test16 {/** * 题目：输出9*9口诀。 *
* 分析： * */ public static void main(String[] args) {
//i为行，j为列
int i = 1;
int j = 1;
//记住二重循环外层控制行，内层控制列
for(i = 1; i &= 9; i++){
for(j = 1; j &= j++){
//输出格式
System.out.print(i+"X"+j+"="+(i*j)+"\t");
//每行打印完过后记得转行
System.out.println();
public class Test17 { /**
* 【程序17】 题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个 第二天早上又将剩
* 下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下 的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
* 1.程序分析：采取逆向思维的方法，从后往前推断。
主要是要采用逆向思维推断前一天所剩下的桃子,首先知道第9天吃完后剩下一个，由次推断第8天剩下的桃子~~
推断如下：
假如第9天没有多吃一个（那第10天就剩下2个桃子），也就是正好吃上次剩下的一半：x个，那么所剩下的桃子就是2个，而这2个是第9天没吃之前的
也就是说第9天本来有4个
觉得主要还是要想通啊~~~
public static void main(String[] args) {
int taozi = 1;
//从第九天的桃子开始推算
int day = 9;
for (day = 9; day &= 1; day--) {
taozi = (taozi + 1) * 2;
System.out.println("第一天共摘了" + taozi + "个桃子");
//写好了不忘倒过来测试一下//
int t = 1534;//
for(int i = 1; i & 10; i++){//
t = ((t/2) - 1);//
System.out.println(t); }}
public class Test18 { /**
* 【程序18】 题目：两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。已抽签决定比赛名单。有人向
* 队员打听比赛的名单。a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。
* 分析：c当然和y比赛，那么a就和z,b和x比赛
* 一开始看这个题目不知道要干什么~~再后来发现要找出赛手名单，可以理解成编程实现打印正确的赛手对决名单~~ 如：a VS z 这样···
* */ // 总结：for()语句保证对手可以在x,y,z中选取，if()语句保证对手的唯一性和题目的约定条件
public static void main(String[] args) {
// 定义变量 matchA是a的对手，matchB是b的对手，matchC是c的对手
char matchA, matchB, matchC;
// 要打印正确的名单，就意味着a后面要跟正确的人，由于i,j,k是char类型，用作for语句的条件也很方便
// i，j,k在条件还没有执行的条件下当然有可能是x,y,z中的任一个
for (matchA = 'x'; matchA &= 'z'; matchA++) {
for (matchB = 'x'; matchB &= 'z'; matchB++) {
// 保证对手的唯一性，就是说a的对手不能和b的对手是一个人
if (matchA != matchB) {
for (matchC = 'x'; matchC & 'z'; matchC++) {
// 保证对手的唯一性！！
if (matchC != matchA && matchC != matchB) {
// 这是题目给我们的最重要的判断信息
if (matchA != 'x' && matchC != 'x' && matchC != 'z') {
// 以上条件都满足，就可以输出了
System.out.println("a
" + matchA);
System.out.println("b
" + matchB);
System.out.println("c
" + matchC);
public class Test19 { /**
* 打印出菱形 ，* 号表示
* * * * * * * * * * * *
* 分析：打印这种图形，主要是判断好每一行打印多少空格和多少*，
不难看出*号的个数前4行随行数增加呈现出奇数的规律，后三行也呈现规律性
* */ public static void main(String[] args) {
//循环外层控制行，这里分成两部分，先打印上面四行，
for (int i = 1; i &= 4; i++) {
//内层控制列，也就是每一行的内容了。先打印空格，空格是随行数变化而变化的
//要算第一行*号前面有多少空格，先对照第四行的，明显，*号前面有6个空格
//(第四行中间一个*前面有3颗*加3个空格)
for (int j = 1; j &= (8 - 2 * i); j++) {
System.out.print(" ");
for (int j = 1; j &= (2 * i - 1); j++) {
//同一行打印*的同时要打印一个空格
System.out.print("* ");
//一行打印完要转到下一行打印
System.out.println();
//后面三行思路和前面类似，不过*号和空格的规律稍变
for (int i = 1; i &= 3; i++) {
for (int j = 1; j &= 2 * j++) {
System.out.print(" ");
for (int j = 1; j &= (7 - 2 * i); j++) {
System.out.print("* ");
System.out.println();
import java.util.S public class Test20 { /**
* 【程序20】 题目：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。
* 1.程序分析：请抓住分子与分母的变化规律。
* 求前N项的和~~ 以小数形式输出结果
* */ // 得到该规律的第n项 的分母，做过第一题，解决这一题分子分母的规律应该不成问题
//这里由于想得到的项数并不需要太大，再次利用递归的优秀思想 static double FenMu(double n) {
if (n == 1) {
} else if (n == 2) {
return FenMu(n - 1) + FenMu(n - 2);
} } // 得到该规律的第n项 的分子 static double FenZi(double n) {
if (n == 1) {
} else if (n == 2) {
return FenZi(n - 1) + FenZi(n - 2);
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入数列的长度：");
int n = input.nextInt();
double sum = 0;
//还是将所有得到的分数存在一个数组里面
double[] fenShu = new double[n];
for (int i = 1; i &= fenShu. i++) {
//由于都是double型数值，可以直接进行除法运算得到等值的小数
fenShu[i - 1] = Test20.FenZi(i) / Test20.FenMu(i);
//求数组各项的和
for (int i = 1; i &= fenShu. i++) {
sum += fenShu[i - 1];
System.out.println("数列前" + n + "项和为：" + sum); }}
import java.util.S public class Test20_1 { /**
* 【程序20】 题目：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。
* 1.程序分析：请抓住分子与分母的变化规律。 想以分数形式输出
* 分析：思路是先得到每一个分数的分子和分母~~然后求和就简单了
static int FenMu(int n) {
if (n == 1) {
} else if (n == 2) {
return FenMu(n - 1) + FenMu(n - 2);
static int FenZi(int n) {
if (n == 1) {
} else if (n == 2) {
return FenZi(n - 1) + FenZi(n - 2);
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入数列的长度：");
int n = input.nextInt();
int[] fenZi = new int[n];
int[] fenMu = new int[n];
// 得到数列各项的 分子，保存在数组fenZi里
for (int i = 1; i &= fenZi. i++) {
fenZi[i - 1] = Test20_1.FenZi(i);
// 得到数列各项的分母，保存在数组fenMu里
for (int i = 1; i &= fenMu. i++) {
fenMu[i - 1] = Test20_1.FenMu(i);
// resultFenZi变量是最后相加完结果的分子，resultFenMu是相加完结果的分母
// 分数的加法：b/a+n/m =(b*m+n*a)/a*m;
int resultFenZi = 0;
int resultFenMu = 0;
// 初始值为0； 赋值为数列长度为2的时候的结果
resultFenZi = Test20_1.FenZi(2) * Test20_1.FenMu(1) + Test20_1.FenZi(1)
* FenMu(2);
resultFenMu = Test20_1.FenMu(1) * Test20_1.FenMu(2);
// 分三种情况 分别是数列有1项、 两项 和大于两项的时候
if (n == 1) {
resultFenZi = Test20_1.FenZi(1);
resultFenMu = Test20_1.FenMu(1);
else if (n == 2) {
resultFenZi = Test20_1.FenZi(2) * Test20_1.FenMu(1)
+ Test20_1.FenZi(1) * FenMu(2);
resultFenMu = Test20_1.FenMu(1) * Test20_1.FenMu(2);
else if (n & 2) {
for (int i = 3; i &= i++) {
resultFenZi = resultFenZi * Test20_1.FenMu(i)
+ Test20_1.FenZi(i) * resultFenMu;
resultFenMu = resultFenMu * Test20_1.FenMu(i);
// 结果未约分的时候
System.out.println(resultFenZi + "/" + resultFenMu);
// 约分后的结果，找到分子分母的最大公约数； 我想到前面的做的一个题目有实现该功能的方法,这里我就直接
// 引用那个方法了····这里姑且用Hcf表示最大公约数
int Hcf = Test6.getHcf(resultFenZi, resultFenMu);
// 因为是公约数 所以两个整型数字用 / 法运算求的结果和实际除法是相等的
System.out.println((resultFenZi / Hcf) + "/" + (resultFenMu / Hcf));
登录百度帐号推荐应用}