若有不正之处，请多多谅解并欢迎批评指正，不甚感激。
请尊重作者劳动成果：

本文原创作者：pipi-changing
本文原创出处：http://www.cnblogs.com/pipi-changing/

本文版权归作者和博客园共有，未经作者同意必须保留此段声明，
且在文章页面明显位置给出原文连接 ，否则保留追究法律责任的权利。

关键字

　　关键字的定义和特点

定义：被Java语言赋予了特殊含义的单词

特点：关键字中所有字母都为小写

 标识符

　　　　在程序中自定义的一些名称。   　　　　由26个英文字母大小写，数字：0-9 符号：_ $ 组成   　　定义合法标识符规则：

1，数字不可以开头。

2，不可以使用关键字。

Java中严格区分大小写。   注意：在起名字的时，为了提高阅读性，要尽量有意义。  

Java中的名称规范：

包名：多单词组成时所有字母都小写。   •xxxyyyzzz   类名接口名：多单词组成时，所有单词的首字母大写。   •XxxYyyZzz   变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。    •xxxYyyZzz   常量名：所有字母都大写。多单词时每个单词用下划线连接。   •XXX_YYY_ZZZ       

Java语言中常用的转义字符见下表：

      注释

用于注解说明解释程序的文字就是注释。   提高了代码的阅读性。   Java中的注释格式：   •单行注释   •格式： //注释文字   •多行注释   •格式： /*  注释文字  */   •文档注释   •格式：/** 注释文字 */

对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行   对于文档注释，是java特有的注释，其中注释内容可以被JDK提供的工具 javadoc 所解析，   生成一套以网页文件形式体现的该程序的说明文档。

注释是一个程序员必须要具有的良好编程习惯。   初学者编写程序可以养成习惯：先写注释再写代码。   将自己的思想通过注释先整理出来，在用代码去体现。   因为代码仅仅是思想的一种体现形式而已。       常量与变量   常量表示不能改变的数值。   Java中常量的分类：

1，整数常量。所有整数

2，小数常量。所有小数

3，布尔(boolean)型常量。较为特有，只有两个数值。true false。

4，字符常量。将一个数字字母或者符号用单引号( ‘ ‘ )标识。

5，字符串常量。将一个或者多个字符用双引号(“ ”)标识。

6，null常量。只有一个数值就是:null.

对于整数：有四种表现形式。   •二进制：0,1 ，满2进1.   •八进制：0-7 ，满8进1. 用0开头表示。   •十进制：0-9 ，满10进1.   •十六进制：0-9，A-F，满16进1. 用0x开头表示。     进制的基本转换   •十进制  二进制 互转   •十进制转成二进制  除以2取余数   •二进制转成十进制  乘以2的幂数   •十进制 八进制 互转   •十进制 十六进制 互转   •负数的二进制表现形式   　　对应的正数二进制取反加1

变量的概念：   •内存中的一个存储区域   •该区域有自己的名称（变量名）和类型（数据类型）   •该区域的数据可以在同一类型范围内不断变化   为什么要定义变量：   •用来不断的存放同一类型的常量，并可以重复使用   使用变量注意：   •变量的作用范围（一对{}之间有效）    •初始化值   定义变量的格式：   •数据类型    变量名  =  初始化值；   •注：格式是固定的，记住格式，以不变应万变。   理解：变量就如同数学中的未知数。     变量字节大小及有效取值范围 byte占用一个字节，数字大小为-2⁷—2⁷-1   short占用两个字节，数字大小为-2¹⁵ —2¹⁵-1   int占用四个字节，数字大小为-2³¹—2³¹-1   long占用八个字节，数字大小为-2⁶³—2⁶³-1   float占用四个字节，数字大小为1.4E-45~3.4E+38 , -1.4E-45~-3.4E+38 。   　　用二进制的指数形式表示一个浮点数的格式，如：101*2²  , 101*2^-3   double占用八个字节，数字大小为4.9E-324~1.7E+308, -4.9E-324~-1.7E+308 。   char占两个字节，数字大小为0———2¹⁶-1，是unicode编码。   　　字符的本来面目，我们为什么可以直接将一个数字赋给字符变量。   Boolean占一个字节，其取值只有两个，true和false。              

Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间

整数默认：int    小数默认：double

  自动类型转换（也叫隐式类型转换）    强制类型转换（也叫显式类型转换）   类型转换的原理   什么时候要用强制类型转换?   表达式的数据类型自动提升   •所有的byte型、short型和char的值将被提升到int型。   •如果一个操作数是long型，计算结果就是long型；   •如果一个操作数是float型，计算结果就是float型；   •如果一个操作数是double型，计算结果就是double型。

自动类型提升

byte b = 3;

int x = 4;

x = x + b;//b会自动提升为int类型进行运算。

强制类型转换

byte b = 3;

b = b + 4;//报错

b = (byte)b+4;//强制类型转换，强制将b+4的结果转换为byte类型，再赋值给b。

  算术运算符       算术运算符的注意问题   •如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。但被模数是负数就另当别论。   •对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。     •“+”除字符串相加功能外，还能把非字符串转换成字符串      赋值运算符

符号：

  = , +=, -=, *=, /=, %=

示例：

  int a,b,c;  a=b=c =3;

  int a = 3;   a+=5;等同运算a=a+5;

思考：

  short s = 3;

s=s+2;

s+=2;    

有什么区别？     

s=s+2//编译失败，因为s会被提升为int类型，运算后的结果还是int类型。无法赋值给short类型。

s+=2//编译通过，因为+=运算符在给s赋值时，自动完成了强转操作。

本文原创作者：pipi-changing

本文原创出处：http://www.cnblogs.com/pipi-changing/

比较运算符

注1：比较运算符的结果都是boolean型，也就是要么是true，要么是false。   注2：比较运算符“==”不能误写成“=” 。

逻辑运算符

逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。   　　“&”和“&&”的区别：   •单&时，左边无论真假，右边都进行运算；   •双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

  “|”和“||”的区别同理，双或时，左边为真，右边不参与运算。

异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。       位运算符

 位运算是直接对二进制进行运算

<<：相当于乘与2的倍数

>>：相当于除以2的倍数

移n位，就是对乘以或者除以2的n次幂。

技巧：二进制1就是true，0就是false。

1.最有效率的方式算出2乘以8等于几？

2*8

     0001

* 1000

  ——–

   10000 

2.对两个整数变量的值进行互换(不需要第三方变量)

三元运算符

格式

•(条件表达式)?表达式1：表达式2；

•如果条件为true，运算后的结果是表达式1；

•如果条件为false，运算后的结果是表达式2；

示例：

•获取两个数中大数。

•int x=3,y=4,z;

•z = (x>y)?x:y;//z变量存储的就是两个数的大数。     程序流程控制

判断结构

if语句

三种格式：

1.if(true)

  {

  执行语句；

  }

2.if(条件表达式)

  {

  执行语句；

  }

  else

  {

  执行语句；

  }

3.if(条件表达式)

  {

  执行语句；

  }

  else if (条件表达式)

  {

  执行语句；

  }

  ……

  else

  {

  执行语句；

  }

if语句特点：

  a,每一种格式都是单条语句。

  b,第二种格式与三元运算符的区别：三元运算符运算完要有值出现。好处是：可以写在其他表达式中。

  c,条件表达式无论写成什么样子，只看最终的结构是否是true 或者 false;

 选择结构

switch语句

格式：

switch(表达式)

{

  case 取值1:

  执行语句；

  break；

  case 取值2:

  执行语句；

  break；

  ……

  default:

  执行语句；

  break；

}

switch语句特点：

      a, switch语句选择的类型只有四种：byte，short，int ， char。

  　 b, case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。

  　 c, 结束switch语句的两种情况：    遇到break，执行到switch语句结束。

      d, 如果匹配的case或者default没有对应的break，那么程序会继续向下执行，

　　　　运行可以执行的语句，直到遇到break或者switch结尾结束。

循环结构

代表语句：while ， do while ， for

while语句格式：

while(条件表达式)

{

  执行语句；

}

do while语句格式：

do

{

  执行语句；

}while(条件表达式);

do while特点：

是条件无论是否满足，

循环体至少执行一次。

格式：

for(初始化表达式；循环条件表达式；循环后的操作表达式)

{

  执行语句；(循环体)

}

注：

     a, for里面的两个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，

　　　　然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。

     b, while与for可以互换，区别在于for为了循环而定义的变量在for循环结束时就在内存中释放。

　　　　而while循环使用的变量在循环结束后还可以继续使用。

     c, 最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。

其他流程控制语句

break(跳出)，  continue(继续)

break语句：应用范围：选择结构和循环结构。

continue语句：应用于循环结构。

注：

a,这两个语句离开应用范围，存在是没有意义的。

b,这个两个语句单独存在下面都不可以有语句，因为执行不到。

c,continue语句是结束本次循环继续下次循环。

d,标号的出现，可以让这两个语句作用于指定的范围。

a++;先用后加 ++a;先加后用

b=a++;先把a的值赋给b,然后a自增1.
b=++a;a先加1,然后把自增后的值赋给b.
++运算优先级要高于算术运算
b*a++ b*a , a=a+1
b*++a a=a+1,b*a

无论是a++还是++a 运算一次后 a的值是一样的,受影响的是赋值对象.

package com.pi.test;

/**
 * @author pipi 打印从0到9 while和do...while
 */
public class TestWhile {
    public static void main(String[] args) {
        int i = 0;
        while (i < 10) {
            System.out.println(i);
            i++;
        }
        System.out.println("***************");
        
        
        i = 0;
        do {
            i++;
            System.out.println(i);

        } while (i < 10);
    }
}

package com.pi.test;

/**
 * @author pipi break使用方法
 */
public class TestBreak {
    public static void main(String[] args) {
        int stop = 4;
        for (int i = 1; i <= 10; i++) {
            // 当i=4时，退出循环
            if (i == 4) {
                break;
            }
            
            System.out.println("i=" + i);
        }
    }

}

package com.pi.test;
/**
 * continue  使用方法
 * @author pipi
 *
 */
public class TestContinue {
    public static void main(String[] args) {
        int skip = 4;
        for (int i = 1; i <= 10; i++) {
            // continue 跳过本次循环，继续执行下一次循环
            if (i == skip) {
                continue;
            }
            System.out.println("i=" + i);
        }
    }

}

package com.pi.test;

/**
 * 输出101~200内的质数。
 */
public class TestContinue2 {
    public static void main(String[] args) {
        for (int i = 101; i < 200; i += 2) {// i+=2表示：偶数肯定不是质数
            // 假设为质数
            boolean f = true;
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                    f = false;
                    break;// 只能中止跳出一层for循环
                }
            }

            if (!f) {// 如果f为false时，继续下一次循环
                continue;
            }
            System.out.println("" + i);
        }
    }

}

package com.pi.test;

/*
 * 注意：break必须写，小心case穿透的问题
　　switch括号中的内容只能是int类型，char byte short都能自动转为int,所以也都可以
 */
public class TestSwitch {
    public static void main(String[] args) {
        int i = 0;
        switch (i) {
        case 8:// 当i的值为8时，执行下面的语句
            System.out.println("A");
            break;
        case 3:
            System.out.println("B");
            break;
        case 5:
            System.out.println("C");
            break;
        default:
            System.out.println("error");
        }
    }

}

package com.pi.test;

/**
 * 形式参数：在方法被调用时用于接收外界输入的参数 
 * 实参：调用方法时实际传给方法的参数 
 * 返回值：方法在执行完毕后返还给调用它的环境的数据
 * 返回值类型：事先约定的返回值的数据类型，如无返回值，则必须给出返回值类型void
 * 
 * return 语句终止方法的运行并指定要返回的数据
 * 
 * Java中经行函数调用传递参数时，遵循值传递的原则 基本类型传递的是该数据值本身。
 * 引用类型传递的是对对象的引用，而不是对象本身。
 *
 */
public class TestMethod {
    public static void main(String[] args) {
        // m1();
        // m2(8);
        // m3(7, 3);
        m4(2, 5);
        int i = m4(2, 5);
        System.out.println(i);
    }

    public static void m1() {
        System.out.println("不带参数的方法");
    }

    public static void m2(int i) {
        System.out.println("带有形参的方法");
    }

    public static void m3(int a, int b) {
        if (a > b) {
            return;// 结束方法的运行，并返回
        }
        System.out.println("a<b");
    }

    public static int m4(int a, int b) {
        return a > b ? a : b;
    }

}

package com.pi.test;

/**
 * 递归调用
 */
public class Test4 {
    public static void main(String[] args) {
        System.out.println(method(5));
    }

    public static int method(int a) {
        if (a == 1) {
            return 1;
        } else {
            return a * method(a - 1);
        }
    }

}

package com.pi.test;

/**
 * 求Fibonacci数列：1，1，2，3，5，8...第40个数的值。数列满足递推公式： F1=1,F2=1
 *
 */
public class Fab {
    public static void main(String[] args) {
        System.out.println(f(5));
    }

    public static int f(int a) {
        if (a == 1 || a == 2) {
            return 1;
        } else {
            return f(a - 1) + f(a - 2);
        }
    }

}

package com.pi.test;

/*
 * 用非递归的方法实现如下功能
 * 求Fibonacci数列：1，1，2，3，5，8,13...第40个数的值。数列满足递推公式： F1=1,F2=1
 */
public class Fab2 {
    public static void main(String[] args) {
        System.out.println(f(5));
    }

    public static long f(int index) {
        if (index == 1 || index == 2) {
            return 1;
        }

        long f1 = 1L;// 第一个数
        long f2 = 1L;// 第二个数
        long f = 0;// 第三个数
        for (int i = 0; i < index-2; i++) {//第一个数和第二个数是1，计算是从第三个数
            f = f1 + f2;// 第三个数
            f1 = f2;// 第二个数变为第一个数
            f2 = f;// 第三个数变为第二个数
        }
        return f;
    }

}