初识Java之入门学习（扫盲）

一，开发环境的配置

1. jdk1.8的安装

2. 环境变量的配置

3.MyEclipse8.5的安装

jdk是什么：

JDK 是Java开发工具包 (Java Development Kit ) 的缩写。它是一种用于构建在 Java 平台上发布的应用程序、applet 和组件的开发环境。其中包括了Java编译器、JVM、大量的Java工具以及Java基础API里面是Java类库和Java的语言规范，同时Java 语言的任何改进都应当加到其中，作为后续版本发布。要成为一名程序员，JDK是一种最基本的工具。

具体解释：http://baike.baidu.com/link?url=YYe0f9384qHk51sgXVFp1TZDviQDLqndNbnEX4iYV6-bYfR3EEfjD6Oh0WuV-WOM8uMNmapl3cmxbFXdH07o6-_-RzZ_1jYc6eiG5hNnbv3

MyEclipse是什么：

MyEclipse企业级工作平台（MyEclipseEnterprise Workbench ，简称MyEclipse）是对EclipseIDE的扩展，利用它我们可以在数据库和JavaEE的开发、发布以及应用程序服务器的整合方面极大的提高 工作效率。它是功能丰富的JavaEE集成开发环境，包括了完备的编码、调试、测试和发布功能，完整支持 HTML，Struts，JSP，CSS，Javascript，Spring，SQL，Hibernate[1] 。

MyEclipse
是一个十分优秀的用于开发Java, J2EE的 Eclipse
插件集合，MyEclipse的功能非常强大，支持也十分广泛，尤其是对各种开源产品的支持十分不错。MyEclipse可以支持
JavaServlet，AJAX，JSP，JSF，Struts，Spring，Hibernate，EJB3，JDBC数据库链接工具等多项功能。可
以说MyEclipse是几乎囊括了目前所有主流开源产品的专属eclipse开发工具。[1]

具体解释：http://wenku.baidu.com/link?url=vEyWiT-_8IZPahI_awQ6OBLAwSCUpGZPmDCJvuZOMpTy47pniaAq0P_vXdrSVgBKbn0zIiYa2bOQ4Ab6-ht2UbxtqFNQ53NtpedgGsKW_8S

【jdk1.8的下载】

http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

注意事项：

安装前先选择“Accept License Agreement”后再下载，不然会提示“Sorry, you must accept the License Agreement before downloading.”的报错。

点击'jdk-8u101-windows-x64.exe' 准备安装

点击‘下一步’ 继续安装：

【jdk1.8的安装及环境变量的配置】

1. 选择JDK的安装目录，选择默认安装：

   

2. 安装中：

   

3. 选择JRE安装目录：

   单击'下一步'

    

4. 安装中

    

5. 安装完成，接下来配置环境变量

   

6. 打开控制面板，点击‘高级系统设置---环境变量’

   

    

   先创建JAVA_HOME变量名称

   变量名：JAVA_HOME

   变量值：安装路径（C:\Program Files\Java\jdk1.8.0_101）

   

7. 配置path变量

   选择jdk8的安装目录：比如我安装在C盘下

   输入变量值：;%JAVA_HOME%\jre\bin;C:\Program Files\Java\jdk1.8.0_101\bin;

   

8. 在配置classpath变量 需要配置tools.jar，dt.jar

   输入变量值为: ;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;

   

9. 测试 

   点击‘开始-运行’

   输入cmd 命令 打开DOS窗口

   再输入javac

   出现以下内容说明配置是成功的

   

【MyEclipse8.5的安装】

关于下载：

百度网盘：http://pan.baidu.com/s/1c08a61U

关于安装：

因为整个安装过程非常简单，因此在此不一一图片列举，安装过程请参考下面的Link。

http://wenku.baidu.com/link?url=rZ0pxFxYZxQ3HgV3eImbhb7RcZ-2T3IeWumaneoaGZlcT8oQYsEEe_M1Ck9PXSEWVll2SkCObjwWHeHY_gSSJBC9q7OOWvn-_126jBtUmQq

【MyEclipse8.5基本使用】

1.从开始-运行-所有应用-打开MyEclipse8.5

然后点击File-New-Java-Project

2. Projectname这边给起一个名字

　Create new project in workspace : 如果是第一个Projectworkspace的创建直接点击此处。如果是已有的Projectworkspace可以选择Creat projectfrom existing source选项。

然后通过Browse...来选中之前创建好的projectworkspace文件打开即可。

　Use an execution environment JRE: 选择我们安装的JDK版本

　Projeck layout保持默认设置

3. 点击Finish后如下图所示，我们已经创建好了一个Projectworkspace框架了。但是要想编写代码我们还必须添加class（类），把代码写到class里面。

4. src上右键-New-Class 来创建类

5. 然后对Source folder,Name,Which method stubs would you like to create?选项进行如图编辑。

Soutce folder里保持默认，是代表来源于哪里

Name：里任意起名这里代表代码的文件名

Which method stubs would you like to create?:里一定要把下面两项勾选(这里代表创建一个所支持代码的模板)

（◯）public static void main(String[]arg)

（◯）Inherited abstract methods

6. 这样第一个.java的脚本框架就已经准备好了。所有的java脚本后缀都是以.java的格式创建的。

　要注意的是创建的脚本名称（javaday1）跟右边框架中public class 后面的名称一定要一致。不然会报错（默认一致）。

　public static void main(String[]args)代表这是一个方法。关于方法的讲解在后续会更新。这里需要强调的是所有的代码都是写到方法中去的，而main是代码的入口点。

　而//在java中代表注释的意思

7. 如下图所示，我们的代码是写在了class里的方法中.而我们的第一句代码就是直接在屏幕上打印一句话“你好！”

　在java中打印方法是通过System.out.print（“ 字符串！”）;的方式打印的。这里要注意的是每个指令后面都跟着一个 .  这里代表命令中方法连接的意思（因为方法实在太多），最后选择了print这个打印方法。而（）中“ ” 代表打印的是个字符串，内容随意添加打印。但是最后结束一定要以 ; 结尾，代表这行代码结束。

8. 如果我们想看输出的结果，点击图中按键后在下方console处会显示结果。

　或者右键-Run As - java Aplication来运行，其结果是一样的。

9. 如果我们再添加一行代码，显示的结果如下图。两行代码之间是连接打印的。如果想换行显示需要添加换行符如图10

10. 如下图所示要想让2行代码分行显示，需要在上一行代码后面加上换行符 \n

11. 如果想要在字符串中打印空格效果，除了直接空格外还有一个\t的参数。

　一个\t代表8位，相当于8个空格。但是第一个\t是从前面的内容开始算起8位的。如果前面有内容会按照前内容开始算，而后\t是按照8个空格开始算起。

12. 关于代码中字体的显示，可以通过下图的操作来变更。

菜单栏windows - Preferences - General - Appearance - Colors and Fonts - TextCompare - Edit 即可

13. 也可以给编写的代码加行号。在图中代码左放的空白处右键，然后选中"Show Line Numbers"即可。

14. 在打印文字中，我们使用了System.out.print(" 字符串");的方法，另外还可以通过System.out.printIn(" 字符串");来打印输出内容。那么print跟printIn的区别是什么呢。

　这两个都是System.out对象的方法，区别在于：print将它的参数显示在命令窗口，并将输出光标定位在所显示的最后一个字符之后。println 将它的参数显示在命令窗口，并在结尾加上换行符，将输出光标定位在下一行的开始。也就是说printIn会带有自动换行的作用。那么我们在打印一个需要换行的字符串时候如果选用printIn的话就不用在字符串后再加 \n 来进行换行了。

15. 另外补充一点左上角的“Package”代表包资源管理器，如果不小心X掉了的话，可以通过下图中来找回。

　Window-Show View - Package Explorer

　那么Hierarch也是一样。如果不小心关闭掉了也是同样的方法在Show View中点击 Hierarchy来找回。

16.  接下来是通过相同的方法来添加“Navigator”，中文叫导航器。为什么要添加Navigator呢顾名思义就是为了导航。。哈哈。具体内容参照17中的内容。

17.  添加完成“Navigator”后，我们把它展开可以看到3个目录。这里先来说说bin跟src这2个目录。首先src下可以看到我们创建的.java脚本。这个中的内容，简单来讲可以说是代表我们人可以看懂的文字及代码。而bin中的文件是对应.java中的内容编译成2进制文件，也就是说机器可以读懂的文字。而计算机在读取我们脚本内容时实际上是通过bin下的文件内容来读取数据的。

18.  注释的作用。在java中的注释是通过//或者/*的方式来注释的。注释掉一句普通代码往往习惯于用//来注释。如果是对一段代码添加注释的话，就需要用到下面图中的这种方式。

　/*然后按Enter键，会发现自动形成了/* * */纵列依次排序的注释符。我们只需要在*号后面添加我们的注释即可。这种注释方式也称为多行注释。而//的方式相反就被称为单行注释。

二，变量，数据类型及运算符

【什么叫变量】

很多人都说变量是可变化的量，这句话没错但是个人认为这种回答简直2到家了.简单一句话来概括，所谓的变量是指1个变量就代表内存中的一块地址。变量最基本的功能就是用来存放东西（数据）的。而我们内存的作用就是用来记忆数据然后传给CPU来处理数据的(这里强调一点内存是存放记忆当软件运行时的数据的)。所以每1个变量在内存中都占用一块地址。另外我们在声明变量后还需要找到这个地址中的变量来使用，所以在创建变量时要给变量取一个变量名，就像给变量起一个编号一样。在我们调用变量的时候通过声明的变量名来调用内存中变量所存放的地址。

【什么叫变量类型】

在变量中分多种不同的类型，一般我们是按照变量的量（数据的多少）来定义变量类型的。比如说如果我们只需要存一个数字，我们用的变量类型就是 "int",如果我们需要存一个小数我们的变量类型就是"double",如果要存一句话那么我们要使用的变量类型就得是“string”,如果要存放一个字符那么就要用“char”.

【声明变量以及变量的使用】

1. int代表整形，当我们要声明一个整数的数字变量时前面加“int“，来定义这个变量是个整形。而我们在调用这个变量的时候直接在printIn的（）中引入这个变量打印即可。(如下图)

　那么举个例子，如果是这条语句的话,变量被引用了吗？ System.out.printIn("money")

答案是没有。原因在于这个money是用“”包含的。而“”中的输入代表输入的是一个字符串所以并为打印。

2. 上述讲了变量的赋值，并且我们赋值了一个int的整形变量并调用了变量。而下面这个例子是把变量的赋值分了2步来做。第一步是先声明一个变量例如 String str;这代表声明一个变量为str的字符串。但是这个声明的变量未被使用。当第二步str = " 今天你吃了吗？"的时候 = 代表赋值的意思。等于把“今天你吃了吗？”这串字符串赋值给了str这个变量中来。最后我们在打印的时候直接调用str这个变量即可。

通常情况，同时也建议把2行代码变成一行代码来赋值使用。至于为什么就不用多说了吧。

3. 说完赋值后，再来说说数据类型。这边有一张图很好的解释了java中的数据类型。如果是单个字符的情况下用char，超出单个字符就成了串那么在使用时就要用string类型。int整形用来声明整数，相反浮点型呢我们在Java中称作double类型，就是带小数点的非整形数字。

4. int跟string在上述的描述中其实已经有做过例子了。那接下来来看看char跟double的例子。例子如图

重要：要强调的是对于char而言在声明变量的时候要使用单引号，而不能用双引号来声明变量。另外''中只能包含一个字符。

double声明中我们赋值的变量为99.00虽然小数点后面是00但是因为它有小数点所以Java同样认为这种类型是double类型（非整形）。

5. OK我们了解了Java中的变量类型了，并且对于各个变量类型都举了相应的例子。那么我们来灵活应用一下各个变量类型的串联使用，例如下例。

　下例中分别运用了double,String，char这三种类型。而我们在打印的时候可以把赋值的变量跟我们要输出的字符串用“+”的方式连接起来。这样打印在屏幕上的效果就会把变量值跟字符串值同时输出。

6.  对于变量的命令其实是有规则的。这里来简单说说变量命名的规则都有那些。

　　首先对于变量命名时首字母可以是途中的3中情况，但是不允许是数字开头。另外对于其余部分，可以是任意多的图中列举出来的规则。比如虽然允许用$符来命名，但是除$以外的其他符号是不允许来作为变量的命名的（包括空格也不被允许）。这是硬性规定没有为什么。

7. 我们来做一个案例，比如说有个需求是说a同学的考试成绩为90分，而b同学的考试成绩跟a相同。我们要打印b同学的分数的话。这样我们在打印b同学的分数时因为跟a相同，所以我们大可把a同学的成绩直接赋值给b同学，然后打印b同学的成绩即可。b = a，因为我们用int定义了 b 这个变量，但未曾给b赋值所以我们用b来接收a里面的值然后打印出b的成绩。

8.  另外要强调一点的是变量跟变量之间的赋值一定要搞清楚是谁接收谁。下图例子可以看出a已经等于90了。所以再用a = b的话，那么b是个空值并没有给他赋值只是声明了而已。所以这时候用a=b，java会识别不到b因而报错。

9.  再来举一个例子某学生的三门成绩分别是：

（1）python: 80分

（2）java：90分

（3）PHP：60分

需求：1.计算出PHP跟java的得分差

　　　2.计算出python,java,PHP3门分数的平均分

结果：结果如下图所示。我们来分析一下结果内容。首先对于需求1我们先声明3个变量分别是python,java跟PHP。因为成绩都是整数所以声明变量都是用的int。而需求是算出java同PHP分数的差。所以我们打印的时候变量间用java-PHP即可。对于第二个需求当然也可以声明一个int vrg的变量然后让之前声明的3个变量相加，算平均分的时候再/3即可。但是下图来看我们并没用使用int去声明vrg而是用的double。为什么。是因为如果直接/3是有一定的不准确性的，得出的结果是直接整除不包含小数部分。为此我们为了更精确算出平均值所以我们在定义vrg的时候是用double来声明的。因此double是代表非整形。所以我们在做乘除的时候也要在/后面以小数的呈现方式显示。/3.0而不是/3。这样得出的结果才会精确到小数。

三，变量的类型转换

（1） 自动类型转换

1. 讲自动类型转换之前先看一个例子。下面这个例子是一个简单的数字计算，算出第二次成绩分。代码虽然很简单但是里面涉及到了一个知识点，double跟int数据类型之间自动互相转换的一个过程。那么计算机是如何对于两个不同类型的变量来自动做类型转换的呢？自动转换是按照

变量的大小来进行自动转换的。下面的案例int的数据类型小于double的数据类型，因此在2个类型进行相加时rise自动转换为double，最终生成的

secondAvg的类型也会是double类型。

2.说到变量自动类型转换的大小，那么在什么情况下才能进行自动类型转换呢？首先要满足下面图表中的几点条件。

第一点：2种类型必须兼容。比如说int,double都同属于数据类型。包括float，long都属于数据类型，所以如果2者类型是兼容的情况下是可以自动类型转换的。

第二点：目标类型大于源类型。例如double型大于int型。int型大于char型等等。总体归纳是从小的类型往大的类型转。另外表达式是指有运算符参与的情况下才称之为表达式例如+ - * /等。对于表达式的转换也是按照变量类型的大小来判定的。以大的类型为最终结果的表达类型。

那么我们通过几个例子来看一下分别是如何自动转换以及哪些类型是不可以进行自动类型转换的。

实例1：

(char result 不能接收age+sex的赋值。原因是因为char的变量类型小于int的类型。自动转换是由大到小来定义的所以出现报错。那么如果我们把result的数据类型的char变成int或者double的话是否可以被成功打印呢？结果是可以的。只不过age是数字，sex是char类型而且是汉字。两者相加计算机要先把汉字转为2进制然后再相加。这么写代码也没有什么实际的意义，不过实现还是可以实现的。由此证明变量的自动转换是由变量的类型大小来定义主次最终按照大的变量类型来自动进行转换的)

实例2：

（从图中已经可以看出错误有2处了。第一:b=10.2的赋值是错误的，10.2有小数点因此属于double类型。第二：int d = c，首先先看c，c虽然等于10但是它的数据类型是double，而即便10没写成10.0但是double类型大于int所以这种赋值方式是正确的被允许的。所以c首先是属于double类型。那么d属于int类型,int小于double所以不允许赋值。那么再看c=a这行。是c=a而不是a=c所以double大于int所以是成立的。如果是a=c的话就会报错了。）

（2）强制类型转换

1. 强制转换的语法是（）加上目标类型。详情请看下图。

2. 为了加深印象我们做个简单的例子。下面图中我们分别声明了2个变量然后再声明result变量来算2个变量中数值的合。但是因为result是int类型

而我们之前声明的b是double类型，所以int小于doulbe最终result是不能计算a跟b的合的。那么我们再来看第二张图片。

第二张图片中我们照样还是把result声明为int，但是我们把b的前面用()加入了int。强制类型转换中我们有说过（）中加入对方类型后就代表把原来的变量类型，强制转换为括号中被加入的变量类型。那么如图所示这里的b就不再是double类型了。我们强制指定b为int。所以a+b最终是可以算出和来。但是要注意的是合的结果中省略的小数。那也是因为我们把b强制转换成int的结果。因为int是不会识别到小数的会自动舍去小数这点要注意。

3. 上面的例子会缺失精度。那么要保证精度的情况下该怎么做呢，很简单把int转换为double就解决了。特别是金融相关的行业在数据运算时一定要保证数据的精度。

四，运算符于条件结构

1. Boolean 类型的用法

Boolean['bʊlɪən]：布尔

布尔类型分2种 (1) True (2) False 是用来做判断真假以及条件是否成立而使用的。

实例：

（需求是来判断小王的成绩是否比小李高，并且给了小李的成绩是80分。但是并没有给出小王的成绩，因为是做对比所以小王必须要有值不然无法做对比。所以我们的做法有2种，一种是直接给小王的成绩赋一个指定的值。然后用Boolean来判断真假。当然还有另外一种做法，就是通过输出的方式任意输出一个值然后跟小李的成绩做对比。这样做的好处是我们可以自由的定义小王的值而不是第一种方法直接指定。）

下例就是通过输出的方式自由指定小王的分数。在这里要提前导入java.util.*，意思是要用到java.util.*这个包中的类，要用里面的东西。这里我们用到的是Scanner这个方法。

另外再说一下这句代码的意思：Scanner input=new Scanner(System.in)

Scanner -是java类库的一个基础类,一个可以使用正则表达式来解析基本类型和字符串的简单文本扫描器。

input   -声明的变量名

new Scanner() -给变量input分配空间,初始化,实例化

System.in -参数, 这里就是获取输入流的意思

另外再解释一下下面这句话的意思。

int xiaowangScore = input.nextInt();

scaner类从控制台得到一个整形类的值。input是接受值的

Boolean是用来做真假判断使用的。后面可以直接指定一个变量赋值。这里是任意指定了n来作为对比xiaowang跟xiaoli的变量。

import java.util.*;
public class javaday2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*
         * 用Boolean的方式来判断小王比小李的成绩高吗，小李的成绩是80分。
         */
        //1.先声明变量
        int xiaoliScore = 80;
        //2.定义小王的成绩
        System.out.println("请输入小王的成绩：");
        //创建一个Scanner对象，方便从控制台接收内容
        Scanner input = new Scanner(System.in);
        //从控制台接收一个整型值
        int xiaowangScore = input.nextInt();

        //3.通过Boolean的方式来判断
        Boolean n = xiaowangScore > xiaoliScore;
        //4.打印结果
        System.out.println("小王的成绩比小李高吗？结果是："+n);
        System.out.println("他们之间的分差为："+ (xiaowangScore-xiaoliScore));

//result:
请输入小王的成绩：
100
小王的成绩比小李高吗？结果是：true
他们之间的分差为：20

2. 关系运算符

关系运算符也叫做比较运算符，是用来比较两者关系的长短，高低，大小关系的。

一句话来概括关系运算符的作用就是用来做比较运算，比较后的结果是boolean类型。

>,<,==,!=,>=,<=等这些都是关系运算符

实例：

（令狐冲java成绩大于90分，且PHP成绩大于80分，师父奖励他。或者java成绩等于100分，PHP成绩大于70分，师父也可以奖励他）

来看这个需求，首先这里要满足2个条件第一个是要java>90 and PHP >80，另一个条件是 java =100 and PHP>70的情况下师父才可以奖励令狐冲。那么我们在java中如何实现呢？首先Scanner类的用法在上述说明中已经讲过了。在这个例子中因为涉及两处成绩。所以我们在输出的时候要输出2次。那么分别对java的成绩以及PHP的成绩做两次输出，用2次Scanner用法即可。接收也是一样用2个变量.nextInt();的方式来接收传入值。OK这块应该没有问题。那么接下来就是条件的判断了。条件判断语句是if ,else在java中if，else的使用方法分别是if(条件){//代码} else{//代码}的方式来实现的。那么我们在对条件做判断时就要用到关系运算符（>,<,>=,<=,!=,==）的用法。我们结合要求来分别把指定的变量按照需求添加到条件中去就可以实现了如下图。

import java.util.*;
public class javaday1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //先定义令狐冲的java成绩
        System.out.println("请输入令狐冲的java成绩：");
        Scanner input1 = new Scanner(System.in);
        int javaScore = input1.nextInt();
        //再定义一个令狐冲PHP的成绩输出
        System.out.println("请输入令狐冲的PHP成绩：");
        Scanner input2 = new Scanner(System.in);
        int yinyueScore = input2.nextInt();

        //用if , else作判断并打印
        if ((javaScore > 90 && yinyueScore >=80)||(javaScore ==100 && yinyueScore>70)){
            System.out.println("表现不错。师父送你一本独孤九剑拿去修练去吧！");

        }
        else{
            System.out.println("你学的是什么玩意儿。。。赶紧去思过崖思过去。");
        }

        }
}

//result:
请输入令狐冲的java成绩：
100
请输入令狐冲的PHP成绩：
91
表现不错。师父送你一本独孤九剑拿去修练去吧！
 

上面是满足条件语句的例子。下图是不满足条件的输出结果。

import java.util.*;
public class javaday1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //先定义令狐冲的java成绩
        System.out.println("请输入令狐冲的java成绩：");
        Scanner input1 = new Scanner(System.in);
        int javaScore = input1.nextInt();
        //再定义一个令狐冲PHP的成绩输出
        System.out.println("请输入令狐冲的PHP成绩：");
        Scanner input2 = new Scanner(System.in);
        int yinyueScore = input2.nextInt();

        //用if , else作判断并打印

        boolean result = (javaScore > 90 && yinyueScore >=80)||(javaScore ==100 && yinyueScore>70);
        if (result){
            System.out.println("表现不错。师父送你一本独孤九剑拿去修练去吧！");

        }
        else{
            System.out.println("你学的是什么玩意儿。。。赶紧去思过崖思过去。");
        }

        }
}

//result:
请输入令狐冲的java成绩：
9
请输入令狐冲的PHP成绩：
70
你学的是什么玩意儿。。。赶紧去思过崖思过去。

3.   运算符的优先级

如上例所示，我们在条件语句中指定的条件包含了多种运算符。那么计算机对于这么多的运算符是如何判断先执行什么后执行什么的呢？

Score1 >90 && Score2>80 || Score1 == 100 && Score2 >70

(1)最高优先级：小括号，即（）

（2）最低优先级：赋值运算符，即=

（3）优先级顺序：！>算术运算符>比较运算符>&&>||

4. 多重判断

我们之前学过if else来判断条件是否成立。而我们上例中只用if else针对单个条件做了判断。如果出现多重条件需要判断的时候我们该如何做呢？

这里当然可以用if else多重做判断的方法来实现。也可以用switch,case,break,default来实现。那么我们分别来看那下这2种不同的用法。

【if else方式的多重判断】

import java.util.*;
public class javaday3 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        //考试成绩>= 90
        //考试成绩>= 80
        //考试成绩>= 60
        //考试成绩< 60

        Scanner input = new Scanner(System.in);
        System.out.println("请速入考试成绩：");
        double n = input.nextDouble();

        if(n>= 90){
            System.out.println("考得不错，奖励你一个笔记本电脑！");}
        else
        if(n>= 80){
            System.out.println("还可以，老师奖励你一个手机！");}
        else
        if(n>= 60){
            System.out.println("考得一般，需继续努力！");}
        else
        if(n<60){
            System.out.println("你天天学习学到肚子里面去了吗？怎么这么差，回家等挨揍吧。");
                }
    }
}

//result
请速入考试成绩：
55.5
你天天学习学到肚子里面去了吗？怎么这么差，回家等挨揍吧。

这里要强调一点的是每个if语句之间都添加了else语句。如果不添加else语句的话每个if语句之间不是相互关联的都是分别独立的而中途没有条件的隔断，拿上例来说如果输入的数字是100.那么打印出来的就不单纯是“考得不错，奖励你一个笔记本电脑！”了。条件还满足>=80,>=60.因此会把这2句的输出也一并显示到屏幕上。如果加上else，那么else是只针对上面条件来做判断的，这样就把每个条件单独隔离来判断并输出结果。

【switch,case,break,default方式的多重判断】

在 switch 的语法里，我们要学到4个关键字：switch、case 、break、default。

在　switch ( 变量 )　这一行里，变量只能是整型或字符型。程序先读出这个变量的值，然后在各个"case"里查找哪个值和这个变量相等，如果相等，就算条件成立，程序执行相应的分支，直到碰上break或者switch语句结束。

了解一下switch,case,break，default的意思，对理解前面的一切也会有帮助，它们分别是：开关，情况，中断，默认（值）。那么用一 句话套起来的说法就是：根据开关值的不同，执行不同的情况，直到遇上中断；如果所有的情况都不符合开关值，那么就执行默认的分支。

更详细的内容请参照下面link:

http://blog.sina.com.cn/s/blog_4a2061060100b9cu.html

import java.util.*;
public class javaday3_1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        //令狐冲参加比武大会
        //如果获得第一名，将出任武林盟主。
        //如果获得第二名，将出任武当掌门。
        //如果获得第三名，将出任峨嵋掌门。
        //否则将被赶出师门。

        Scanner input = new Scanner(System.in);
        System.out.println("请输入令狐冲的名次：");
        int mc= input.nextInt();
        switch(mc){
        case 1:
            System.out.println("武林盟主！");
            break;

        case 2:
            System.out.println("武当掌门！");
            break;
        case 3:
            System.out.println("峨嵋掌门！");
            break;

        default:
            System.out.println("回家抱孩子去吧！");

        }

    }

}
//result
请输入令狐冲的名次：
5
回家抱孩子去吧！

5. 对比switch语句和多重if语句的结构

（1）相同点：

　　　　都可以实现多分支结构

（2）不同点：

　　switch 只能处理等值的条件判断，且条件是整形变量或者字符变量的等值判断

　　多重if  处理在else部分还包含其他if结构，特别适合某个变量处于某个区间时的情况

五，while循环

（1）什么是循环？

　　循环的结构是由循环条件跟循环操作合成的。

（2）while循环的特点：

　　while循环后面的小括号，里面是boolean类型变量或者值。例如下图。while后面（）中的条件只有真跟假，也就是boolean类型，只有在boolean类型判断的时候才会被执行。也可以这么写把i<=1提前用boolean类型来定义一个变量。括号中放入变量即可。boolean n =i<=1; while(n)。

public class javaday4 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        int i= 1;
        while(i<=10){
            System.out.println("第"+i+"次:Yes,I can do this!");

            i++; //这里的意思是i+1,每次循环加1
        }

    }

}
//result
第1次:Yes,I can do this!
第2次:Yes,I can do this!
第3次:Yes,I can do this!
第4次:Yes,I can do this!
第5次:Yes,I can do this!
第6次:Yes,I can do this!
第7次:Yes,I can do this!
第8次:Yes,I can do this!
第9次:Yes,I can do this!
第10次:Yes,I can do this!

让我们再来看一个while循环的案例。下面这个案例中有2点需要讲解一下。.equals是对比2个字符串是否相等的。如果条件成立就执行{}中的代码。！是表示取反，这里的意思是如果条件不是y的情况就执行{}中的代码。另外a = input.next()这里等于再接收一次对方问题的回答。

ort java.util.*;
public class javaday5 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Scanner input =new Scanner(System.in);
        System.out.println("我今天表现如何(y/n)?");
        String a = input.next();

        while(!a.equals("y")){
            System.out.println("不行,回去继续练习去");
            System.out.println("我今天表现如何(y/n)?");
            a = input.next();

        }System.out.println("可以了,收工");

    }

}
//result

我今天表现如何(y/n)?
n
不行,回去继续练习去
我今天表现如何(y/n)?
n
不行,回去继续练习去
我今天表现如何(y/n)?
n
不行,回去继续练习去
我今天表现如何(y/n)?
n
不行,回去继续练习去
我今天表现如何(y/n)?
y
可以了,收工

接下来这个while循环中，只给了一个条件就是“算出班级中成员的平均分“。但是并没有给出具体多少人，每个人大概多少分的详细内容。所以我们在做这种循环时首先要有思路，如何完成这个循环后再写代码。

先定义2个变量count和sum，分别用来计数以及统计总和。然后设定条件范围我们这里假设班级中有5个人。<=5就代表不会大于5只要大于5循环就结束了。好，既然有了这个思路就让我们分别输出这5位同学的成绩。而成绩的输出还是用scanner语法来实现，至于分数嘛随便输出。然后定义一个函数来接收每次输出的结果这里用了变量score。最后我们要求和，那么sum=中的这个sum其实是新sum。而之前我们定义的sum值为0，第一次输出结果后这里的0就变成了输出后的值，然后+score，因此score接收的是每次重复循环后输出的值所以相加后就得出了5位同学的成绩总和。再往后求平均分就很简单了。定义一个变量接收求平均分的值，打印出来即可。（为了对比java跟python的方法，此环节中附上一段简单的python代码方便对比）

import java.util.*;
public class javaday5_1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //算出班级成员的平均分
        Scanner input =new Scanner(System.in);
        int count = 1;
        int sum=0;
        while(count<=5){
            System.out.println("第"+count+"位同学的成绩:");
            int score = input.nextInt();   //score变量来接收输出后的结果
            sum = sum +score;     //初始sum为0,接收输出后值后叠加第二次,第三次..直到循环结束后的结果
            count++;            //这里让循环叠加,相当于每次加1.因为种种原因()中我们给出的条件是count<=5所以一直到>5时才会退出.
        }int vrg = sum/5;        //vrg来接受sum/5的值
        System.out.println("全班成员的平均成绩是:"+vrg);

    }

}
//result
第1位同学的成绩:
100
第2位同学的成绩:
90
第3位同学的成绩:
70
第4位同学的成绩:
65
第5位同学的成绩:
86
全班成员的平均成绩是:82

count = 1 #定义同学的个数为1
sum = 0   #初始值为0

while count<=5:   #规定了同学的数量不会超过5人。也就是说有5名同学
    a = int(input("第%s位同学的成绩:"%(count)))
    #print("第%s位同学的成绩： %（count)")
    count+=1  #每输出一位同学的成绩就加1再输出另一位同学的成绩

    sum = sum+a  # sum初始为0第一次输出后接受第一次的成绩然后每次叠加a的输出。
print(sum)

vrg = sum/5

print(vrg)
//result
第1位同学的成绩:100
第2位同学的成绩:97
第3位同学的成绩:65
第4位同学的成绩:80
第5位同学的成绩:54
396
79.2

python代码

六，do while循环

　　所谓的do while循环就是先做，再判断。一般生产环境中用do while的案例比较少。总之do while循环永远比while循环多一步。还是拿之前的案例来举例子。

　　下列代码中我们先do{}中填写要做的内容，然后再while(){}.

import java.util.*;
public class javaday5_2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        //令狐冲让盈盈评价今日修炼成果,听取盈盈反馈结果.
        Scanner input = new Scanner(System.in);
        String Score;
        do{

        System.out.println("修炼,修炼,修炼,终于修炼完了!!");
        System.out.println("我的独孤九剑今日成效如何?");
        Score=input.next();}
        while((Score.equals("n")));{
            System.out.println("可以出道了!");
        }

    }

}
//result
修炼,修炼,修炼!!
我的独孤九剑今日成效如何?
n
修炼,修炼,修炼!!
我的独孤九剑今日成效如何?
y
可以出道了!

下面这个do while的案例跟上述同例。仅供参考！

import java.util.*;
public class javaday5_3 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        String name;

        do{
        System.out.println("请输入同学的姓名:");
        name = input.next();
        }while(!name.equals("q"));{
            System.out.println("退出了!");
        }

    }

}
//result
请输入同学的姓名:
liupeng
请输入同学的姓名:
q
退出了!

七， while循环于do while循环的区别（1）while循环是先判断再执行。而do while是先执行再判断。

（2）while循环在初始循环时，只要条件不满足就一次都不会循环。而do while是不管任何条件下都至少先执行一次。

八，  for 循环

在java中，我们平时常用到的循环有3种，do while while 以及for循环。而for循环的使用率为最高。for循环中的条件中可以把变量的赋值，条件的判断以及循环的继续于终止和起来指定。

例如下面的例子。还是算出1-100的和。之前我们用while循环来做这个例子的时候是先在循环外声明变量，然后在（）中直接指定判断条件。再然后在()外设定i++，让循环继续再打印。这样就分了3步来完成，

而变成讲究的是高效。能用简短的代码写出来就不用复杂的。所以for循环的话，可以直接在（）中包含上述3向设定。当然你也可以跟while循环一样的使用方法，但是这样就失去了for循环的优势。

import java.util.*;
public class javaday6 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        int sum = 0;
        for(int i =1;i<=100;i++){
            sum = sum+i;

        }System.out.println(sum);

    }

}
//reqult
结果是:5050

所谓代码不是记忆出来的，都是写出来的。所以我们接下来再看几个例子来熟悉一下for循环的用法。

同样是之前while循环写过的代码，只是变成了for循环来实现了。对比之下会感觉这种写法更简洁。

import java.util.*;
public class javaday6 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Scanner input = new Scanner(System.in);
        int sum = 0;

        for(int i = 1;i<=3;i++){
            System.out.println("第"+i+"次输出数字:");
            int score=input.nextInt();
            sum = sum+score;
        }int vrg = sum/5;
        System.out.println("平均成绩是:"+vrg);

    }

}
//result
第1次输出数字:
100
第2次输出数字:
67
第3次输出数字:
55
平均成绩是:44

接下来的这个例子比上例稍微有意思了点。需求请参照代码或者图片注释部分。最终得出一个输出数字后的一个加法运算序列。

这里运用到了二元运算的方法，虽然很简单但是对于初学的Me而言，想要直接按照需求不看任何资料，自己能够完整的制定好思路，以及自己写出代码。起初也花费了不少的时间。

所以我相信很多人同样跟我一样，刚开始学的时候，看代码能够看明白。但是一道让自己写就不知道从何处入手了。这点本人我感同身受。所以我的建议是先想好思路，然后先把能写好的代码写完。然后在写的过程中会发现还缺少那些。再对于缺少的部分，细化。总之思路是很重要的。只要思路对了代码最终肯定会写出来的。（思路>写代码）

import java.util.*;
public class test4 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        import java.util.*;
        public class javaday6 {

            /**
             * @param args
             */
            public static void main(String[] args) {
                // TODO Auto-generated method stub

                Scanner input = new Scanner(System.in);
                /*
                 * 设计一个输入一个数字,输出结果都为5的算法序列.
                 *
                 * 请输入一个数字:
                    1+4=5
                    2+3=5
                    3+2=5
                    4+1=5
                 */

                System.out.println("请输入一个数字:");
                int a = input.nextInt();

                //思路:
                //设计2个变量,分别代表相加的2个数字,因为结果等于输出数字.所以用二次表达式一排数字代表1-5,另一排代表5-1.变量i一直叠加,变量j一直相减.直到条件退出.

                for(int i=0,j=a;i<=a;i++,j--){
                    System.out.println(i+"+"+j+"="+(i+j));
                }
                //来说一下这个代码:i+"+"+j+"="+(i+j)  i后面的第一个+代表连接符."+"代表输出的加号.接下来的+同样代表连接符,连接的是变量j中的值.j后面的+同样代表连接符.
                //以此类推"="号后的加也是连接符.最后得出结果是输出的值.也就是(i+j)

            }

        }
        //result
        请输入一个数字:
        1+4=5
        2+3=5
        3+2=5
        4+1=5

继续看。下面这个需求是求出1-100不能被3整除的数字之和。这里关键是不被3整除如何用代码的方式体现出来。看下图 ()中i%3!=0的意思就是i除3结果不等于0，不等于0当然也就是不能被整除的数字。所以我们在代码中用这种方式来代表不能整除。而i是1-100循环中的每个元素在循环中就对每个元素进行除法运算（i%3）把能被3整除的数字统计出来赋值给sum变量。最终输出sum就是不被3整除的数字之和了。

import java.util.*;
public class javaday6_1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        //求1-100之间不能被3整除的和

        int sum = 0;
        for(int i =1;i<=100;i++){
            if (i%3!=0){
                sum = sum+i;
            } //i%3!=0的意思是:i%3的结果不等于0,不等于0言外之意就是不能被整除.如果是==0就是能被整除的意思.

        }System.out.println(sum);

    }

}
//result
3367

九, for循环中的break域continue

之前在while以及switch循环语句中我们用过break以及continue。其实不管在任何循环中，break都是指跳出当前循环，并循环终止。而continue是指跳出当前循环，继续下一论的循环。

那么我们还拿上面这个例子来看一下break的用法。

本来循环条件是让循环1-100，100次的。但是在if()中我们指定了条件为i==8的时候break。那么我们看输出结果也是8.也就是说循环只执行了8次就退出了。由此可以看出break的作用就是用来中断本次循环并退出的。

import java.util.*;
public class javaday6_2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int sum = 0;
        for(int i =1;i<=100;i++){
            if (i==8){
                sum = sum+i;
                break;
            } 

        }System.out.println(sum);

    }

}
//result
8

再来看一下continue。下图为continue的案例。只是把if（）中的条件变成了i<=8就continue。也就是说只要1-100的数值循环中数值小于等于8的时候就继续循环。如果大于8了就退出循环。所以结果为<=8范围的和也就是36.

import java.util.*;
public class javaday6_2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int sum = 0;
        for(int i =1;i<=100;i++){
            if (i<=8){
                sum = sum+i;
                continue;
            } 

        }System.out.println(sum);

    }

}
//result
36

十, 数组

数组跟变量的区别在于1个变量在内存中只有单独的一快空间。而数组在内存中有一串，或者可以说是一组的存储空间。

变量是轮个，而数组是轮串。可以存放更多的存储空间。

**另外数组是按照不同的类型来定义的。一个数组中存放的数据类型必须是同一类型的数据。

另外我们把数组中存放的数据称为元素。而每个元素在数组中都是有位置的，我们把这些元素的位置称之为下标。下标的编号是从0开始计算的。

1. 如何定义一个数组：（定义数组的方法很多我们一一来看）

（1） int sums [ ] = new int [ ] {元素 }   // int代表我们声明的是一个int型的数组，同变量声明一样声明数组的时候也用new来声明。int[ ]代表指定数组的大小，而传入的数组元素是存放在{}中的。当然如果想要声明其他类型把int换成其他类型即可。

来看下下面这个例子，我们用以上的(1)中的方法定义了一个int类型的数组，并尝试打印数组中的元素。可以发现直接打印的话输出的是一段ASCII码一样的东西，并不是我们能看懂的元素本身。那么我们要想看数组里的元素怎么办。这里要借助一个Java中的Arrays类来打印。一般导入的话用 import java.util.Arrays后才能使用。因为我们直接import java.util.*了。包含了这个类工具。所以我们直接打印的时候，调用这个类来打印即可。（输出方法是System.out.println（Array.toString(变量)）；）

import java.util.*;
public class javaday7 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        //声明数组

        int []summbers = new int []{,,};

        System.out.println(summbers);
        System.out.println(Arrays.toString(summbers));
    }

}
//result
[I@dc8569
[, , ]

(2)定义数组的四步走

这里我们把之前声明数组的步骤才分来解释。看下图声明一个数组其实是按照这4步来完成的。只是我们日常不会对一个数组的声明分4步去做。1条能搞定的东西没必要写4条。但是原理要懂。直接看输出结果，我们定义数组的空间时是指定了10快空间。但是我们赋值的时候只赋值了2个，所以最终打印这个数组的时候不光打印了赋值的这2个值，还把其余未赋值的部分一并打印出来了。而未赋值的部分计算机会以0来表示。

另外数组中的元素如果是int型的话，还可以参与运算，不过我们在调用数组中的元素时，必须知道每个元素的下标才能调用它。所以在使用被要用的元素进行+-*/时，必须通过 数组变量[元素下标 ]*10的方式来使用，如下。

（3）下面这个案例也涉及到了数组的声明以及赋值。这种运用方法更加的简单.int [ ]变量 = {赋值}; 平时这种方法的使用更为频繁，所以推荐以后在声明数组时尽量使用更为简便的方法。

除此之外，我们在下例中做个一个数组中各个元素相加后取平均值的运算。因为要先求和再求平均数所以先定义一个sum变量统计元组中各个元素相加后的值是多少。当然你一个个用+号连接也能算出和来。但是这种方法不高效，而且当我们数据很多的时候也不可能一个个用+相加的方式去求和。所以这里我们要用for循环来循环数组中每个元素取出每个元素的值叠加。i为循环数组中的每个元素的长度（其实这里是为了统计每个元素的下标是多少）然后Score[i]是代表每个元素的值，sum初始值是0当第一次循环后取出了第一个元素是90然后赋值给了sum，这时候的sum就等于了90然后依次类推，每次循环出的值相加后再赋值给sum。此时的sum相当于一个new sum，得出的是所有元素的和。因为我们的条件是i<Score.length，这里是指小于整个数组的长度。这么定义，就等于数组一共开辟了多少空间，直到对比到最后一个为止结束。通过这样的方法我们就不用SB的一个个用+号去统计和了。最后得出结果后还要算平均值，直接除Score.length其实就等于除了到最后一个元素统计总共多少个元素的个数和，就能得出平均值了。但是，要注意了。因为我们直接除的话，即使你定义了double类型得出的值也不是精确的数字，小数点后会为0.为什么呢，原因在于我们求和的时候其实i 指定的数据类型是int而不是double。所以要想精确到小数点后面的数字，必须把sum转换为double类型。当然整个运算也必须统一为double类型后得到的结果才会是精确数字。

import java.util.*;
public class javaday7 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        int [] Score = {90,80,76,100,60};
        System.out.println(Arrays.toString(Score));

        int sum = 0;
        for(int i = 0;i<Score.length;i++){
            sum = sum+Score[i];

        }double vrg = ((double) sum)/Score.length;
        System.out.println(vrg);

    }

}
//result
[90, 80, 76, 100, 60]
81.2

最后关于数组方面的使用方法有很多包括如何在数组中添加删除变更元素等，这里不过多的做解释。（因为之后会做泛型的笔记，泛型的使用更为广泛可以组合不同类型的元素。所以这里数组的使用先告一段落，具体方法可参考下面链接）

http://wenku.baidu.com/link?url=vx5TjosMaQ1prLdqNI8Oh7IVKzUU6O_jHTDRZ6ri3c0BM8urH2RQpMDz6zZLvLxt-gjtjNXylLdpv_o4Ak6QmvC8On0IqNb_nuDql53HSRa

鸡汤：

“今天的努力都是明天别人对你的膜拜，今天的停滞就是明天别人对你的唾弃！“
“做人要靠自己！！”