java语法基础

java语法基础

1. java注释
   Java的注释分三种：单行、多行以及文档注释。单行：//后面的内容就是单行注释；多行：/* 中间部分 就是多行注释 */；至于文档注释，javadoc命令可直接提取文档注释， 并根据文档注释来生成API文档 。

/**
  此处为文档注释，我们可以用
  javadoc命令直接提取文档注释，
  并根据文档注释来生成API文档
 */
public class Comments
{
    //此处为单行注释。
    public static void main(String[] args) 
    {
        System.out.println("这里没被注释");
    }

    /*
    public void info(){
        System.out.println("这里被多行注释了。。");
    }
    */
}

2.Java标识符
标识符(合法的名字)：类名、方法名、变量名、常量名等。可以以中文、美元$开头，但不能以数字开头，且不能是Java的关键字和保留字(都必须小写)。直接量：true,false,null。共53个关键字，其中有2个保留字：const、goto，它们在Java中目前没有被使用，因此不具有意义。类名应取尽量有意义，当别人看的时候也能一目了然。
3.基本数据类型
Java语言是一门强类型语言，所有变量(计算机内存里的数据就需要通过变量来访问它，变量就是一块内存的访问方式) 必须先声明类型，再使用。Java有8种基本类型：
整数取值范围： -128~127 -32768~32767 -2G~2G-1 -2的63次方~2的63次方-1
4个整型（不支持小数）： byte(1字节)，、 short(2字节)、 int(4字节)、 long(8字节)
2个浮点型（支持小数）： float(4字节)、 double(8字节)
1个字符型：char(2字节)
1个布尔型：boolean(1字节) 只能有两种取值：true、false
当我们直接使用一个整数时，整数默认是int类型。如果想使用一个long型，应该在正数后加L或l。Java的整型常数有三种形式：
1.十进制整数,如123,-456,0。
2.八进制整数,以0开头,如0123表示十进制数83,-011表示十进制数-9。
当我们直接使用浮点数时，浮点数默认是double类型。如果想使用一个float型，应该在正数后加F或f，如：浮点数表示：.512f(整数0部分可以省略，10十进制表示)；0.12e4F(0.12乘以10的4次方，科学计数法)。实际编程时，尽量使用double(范围大，精度高)。字符型：每个字符型的变量只能装一个字符。可以是英文或中文。字符型的表示方式如：1. ‘q’、’中’ ；转义字符：’\n’，’\t’、’\r’、’\b’等。所以我们在给变量赋值时，一定要注意变量的取值范围。需要补充的是：所有的正无穷大和负无穷大都分别相等，非数(NaN)就是用0.0/0，非数连自己都不相等。
实例说明：
1、byte b = 385;//由于变量b超过了byte类型的取值范围，所以此时编译器此时会报错(可能损失精度)。—-由于byte只占一个字节，所以要注意值溢出的问题。
2、如果我们在385这个数值进行强制类型(下面会讲到)，结果会是多少呢？byte b = (byte)385;思考一下。
计算过程如下：

我们知道数据的存储要遵循两条原则：
1.最高位是符号位。最高位是0代表整数，最高位是1代表负数。
2.所有的数值在计算机中都是以补码(在计算机内，有符号数有3种表示法：原码、反码和补码。
原码：直接换算出的二进制码。
反码：负数时除符号位不变之外，其它位都取反；正数反码=原码。
补码：负数补码=反码+1；正数补码=原码)的形式保存的。在控制台输出给我们的是在转换成原码后再计算返回给我们的十进制数值。我们可以看到转换成的原码后7位1，符号位(最高位)也为1，所以我们可以算出结果为-127。
类型转换：byte–>short–>int–>long–>float–>double （—> 表示类型之间可以转换，由于char可以转化为int类型(也就是说字符型变量，可直接作为“正整数”使用)，所以这7种基本类型之间是相互可以转化的），还有一个布尔型，由于它只支持两种取值(true/false)，所以数值类型只有7种。在数据类型进行转换时要注意：范围小的可以自动转化为范围大的。范围大的可以强制转化(可能丢失精度)为范围小的。如果直接写一个整数，默认是int型，但如果它的范围在byte、short表示范围内，而且程序【直接将该值】(直接在源代码中指定的值)赋给byte、short类型变量，系统会自动强转。

表达式类型的自动提升

规则：整个表达式的数据类型，与表达式中最高等级的运算数的类型相同。int it=10/4;//这里最高为int,所以整个表达式的数据类型为int，it结果为2。但如果写成：int i = 10/0.2;就会报错，因为等式右边的最高等级的运算数的类型为double，而左边类型为int，所以编译器此时会报“可能损失精度”的错误。

4.运算符
算术运算符： +,-,*,/,%,++,– 。对于++ – 只能操作一个变量。++既可以放在变量前(先把变量+1，然后再拿来用)，也可以放在变量后(先拿来用，再把变量+1)，–也是也是如此。这是比较容易出错的地方。

赋值运算符：【= += -= *= /= %= >>= <<= &= |= ^=】 赋值运算符优先级别低于其他的运算符，所以对该运算符往往最后读取。注意等号左边只能是变量，赋值运算符可以与所有的双目运算符结合，就形成了扩展后的赋值运算符。需要注意的：a+=b相当于a=(a的类型)(a+b);//隐式类型转换。注意+=之间不能有空格。赋值表达式的值就是等号右边被赋的值。

位运算符(基于2进制码运算)：&、|、~、^(按位异或)、<<、>>、>>>。注意运算时要用补码去算，最终结果要转换为原码。>>：当右移除不尽的情况下，实际得到的整数总是比实际运算的结果值略小。>>>：无符号右移，在左边补0。^：同0异1。

关系运算符：等于运算符【==】、不等于运算符【!=】 、关系运算符【< > <= >= 】

按运算所需变量的个数来分：运算所需变量为一个的运算符叫单目运算符,例如【!,~,()】；运算所需变量为两个的运算符叫做双目运算符；算所需变量为三个的运算符叫三目运算符：【?:】

逻辑运算符(操作数要求只能是boolean值)：&&、&(不会短路)、||、|(不会短路)、!、^(只有当两个操作数不同时，才返回true)。【自加的陷进】：int c=1;c=c++;//a).先拿出c来值为1，b).c自加成2，c).把刚取出的1赋给c，c又变回1。

5.流程控制语句
流程控制语句一共有3种结构：1.顺序结构 如果没有流程控制，计算机总是从上到下，一次执行每一行。2.分支 满足某个条件时，才去执行代码。3, 循环 重复执行一段代码。

分支控制：if/switch 如果省略了花括号，if条件只控制到第一个分号前面。else本身就是条件(在if条件上取反)。建议：即使条件执行体只有一行代码，也保留花括号。当有多个else if语句块时，建议先处理范围小的条件。switch：当等于某个值时，才执行一段代码。每次写完case,在写其它代码之前立即写break; 循环控制：while/do..while/for while

do{

//do something...

 }while(返回boolean值的表达式) 

这个循环与while相比，把循环放前面，先执行一次循环体，如果条件为true，将执行下一次循环。while使用规则：如果省略了花括号，while条件只控制到第一个分号前面。注意只要是循环体，就永远跳到循环条件。

int i = 1;  
while(i++<5);  
{  
    System.out.println("i="+i);  
}  

for(初始化语句;返回boolean值得表达式;每次循环体执行完后执行的代码)

{

//do something...
}

初始化语句：可以省略；如果有“初始化语句”，则只有在循环开始之前，会执行一次“初始化语句”。返回boolean值得表达式：可以省略；如果省略，意味着它的值永远是true。每次循环体执行完后执行的代码：可以省略。如果有，将在每次循环体执行之后，开始下一次循环之前执行。【注意】只要两个分号中间的表达式返回true，程序将执行循环体。循环嵌套：把内存循环当成外层循环的一条语句即可。控制循环的关键词：break(完全结束一个循环本身)、continue(停止当前循环体的执行【忽略continue后面的语句】，开始下一次循环体)、return(结束整个方法)。【注意】break、continue后面可以跟一个标号。带标号的break用于结束标号所标识的循环。带标号的continue忽略标号所标识的循环后面的剩下语句。另外注意Java里面没有goto(当做保留字)。

for(int i=1;i <10;i+=2){  
    System.out.println("i的值为："+ (i*=1.2));   
} 

上面的例子包括一个隐式类型转换，原型为a*=b相当于a=(a的类型)(a*b);这样我想不难得出结果为：1、3、6、9。

还有一种foreach循环：如使用foreach循环对数组进行遍历
for(元素类型 变量名:数组|集合)
{
//此处即可通过“变量名”依次访问每个数组|集合中的元素。
}
/注意：在foreach中对循环变量赋值并不会改变原数组元素的值/

6.数组

数组类型(引用类型)（说明：如int[] a 则变量a的数据类型为int[]，注意是int[]，而不是int）。数组里的每个元素，就相当于一个普通的变量。这里补充一下，引用类型的本质其实就是指针，只是Java对它做了一些封装和异常等检查。定义数组时，不能指定数组的长度。【数组的初始化】：数组变量只是一个引用，必须让它指向有效的内存之后才能使用。数组的初始化分为两种：1.静态初始化：int[] a = new int[]{1,2,3} //只指定数组的元素，让系统来决定数组的长度,推荐使用这种。还有一种写法：int[] a={1,2,3}; //直接指定数组元素。2,动态初始化：int[] a=new int[3];//只指定数组的长度，让系统来决定数组的元素值，注意如果数组元素是基本类型，那么所有数组元素的默认值都是0/0.0/false/u0000；如果数组元素是引用类型，那么所有数组元素的默认值都是null。

7.方法栈(所有在方法中声明的变量，都放在相应的方法栈中)

每个方法运行时，系统都会为之建立一个方法栈。栈内存是临时性的内存，方法结束时，方法栈会被立即释放，所以栈不适合存放长有效的数据。java中的所有的对象都放在”堆”内存中，每个JVM只有一个”堆”内存。java不允许直接操作堆内存，只能通过引用来访问，只要JVM不退出，堆内存一直存在。这里补充一下：JVM有一条后台进程：垃圾回收器，它会用一种机制记录 堆内存中“每个对象”是否有引用变量(指针)引用它。如果有，垃圾回收器就不会管它；如果没有，垃圾回收器就会在合适的时候去回收该对象所占的内存。注意：当数组对象的引用变量被销毁之后，数组并不一定会回收(它在堆内存)，它不会随着数组变量被回收，数组变量只是一个引用，它只是暂时指向了某块堆内存的地址而已。再说一下二维数组：Java允许初始化数组时只初始化左边的维数(如：int[][] a = new int[5][];)。二维数组的元素(引用变量,必须要有指向)是一维数组。

public static void main(String[] args)   
    {  
        //定义二维数组a  
        int[][] a;  
        //动态初始化二维数组a  
        a= new int[5][];  
        //静态初始化一维数组a[1]  
        a[1]=new int[]{1,2,3,4,5,6,7,8,9,10};  
        for(int i=0;i <10;i++){  
            System.out.print(a[1][i]+"\t");   
        }  
    }