Java 学习 第一章 java基础语法总结

大二开始，跟着实验室做网页，学框架，慢慢觉得很多东西真的只是了解怎么去用，而不知道原因

作为一个软件工程的小程序猿，我还是抱着要巩固基础的想法，把我的教材看了第六遍，虽然看的很不耐心

但我还是要将基础巩固，总结的文章不全是我的，我也觉得没必要浪费很多时间去完成文档（个人之言）

我根据我自己的侧重点做了一些改变，你要是不喜欢，欢迎访问原网页：

其实学习最根本的还是看书，结合书上的题目敲代码。

在此我推荐我们的教材：《Java 语言程序设计 基础篇 第八版》这本书编者很牛掰，译者也很牛掰，

代码更牛，个人建议边看书边敲代码，学习书上的代码风格（这个非常重要），这本书做得很好，我的良好的代码风格就是在这本书中学会的，书后习题一定耐心做，不懂的在我的资源里也有答案。

好了，废话不多说，上总结：

一、java的命名规则

1、java中定义类名时，必须以字母开头，后者可以跟字母和数字的任意组合。在实际工作中要求类名必须以大写字母开头。

2、java中变量名必须是一个以字母开头的由字母和数字构成的序列。

3、java对大小写敏感，书写时一定要注意区分大小写。如果出现大小写拼写错误（如将main写成Main），那么程序将无法运行。

4、java中方法名首字母小写，第二个单词开始大写且为动词。

5、常量名习惯使用大写，单词之间用下划线连接。

注意 ：

关于命名方式，不得不说，一定要养成良好的代码风格，不要变量都是a,b,c，给别人看特别费劲

关于命名，一定要选择有意义的名字，要让别人看到你的变量就是知道它代表的是什么,可以参考“驼峰命名法”

注意每个单词首字母要大写。在一段函数中不使用同一个变量表示前后意义不同的两个数值。

eg: 当我要表示随机数 ， 那么我命名 int random = (int)(Math.random() * 100);

比如一个查找Id的函数 ， 那么我的函数名 ： public boolean isFindId(int id){}

这里的我谈的很简单，但是很重要。预想了解更多：度娘：java代码风格。

二、注释

在java中有三种写注释的方式：

1、单行注释 

最常用的方式是使用//，其注释内容从//开始到本行末结束。

快捷键 alt +  / (对于快捷键的说明，在我的博客中也有谈到，欢迎围观)

2、多行注释

当需要长篇的注释时，可以使用将一段比较长的注释括起来。使用 /*  ...内容.... */

快捷键 alt + shift + /

3、使用结束，可以用来自动生成文档。

例1：

 

public class FistSample{

public static void mian(String[] arg){

    System.out.println(“Hello World !”)

}

}

三、数据类型

在java中，一共有8种基本类型，其中有4种整型、2种浮点类型、1种用于表示Unicode编码的字符单元的字符类型和1种用于表示真假值的boolean类型。

 

（1）、整型

整型用于表示没有小数部分的数值，它允许是负数。Java提供了4种整型，具体内容如表1。

                          表1 java整型       

 

类型	存储需求	取值类型
int	4字节	-2^31 — 2^31-1
short	2字节	-32768 —32767
long	8字节	-2^63 — 2^63-1
byte	1字节	-128 —127

 

（2）、浮点类型

浮点类型用于表示有小数部分的数值。在java中有两种浮点类型，具体内容见表2。其中double表示这种类型的数值精度是float的两倍。绝大部分应用程序采有double类型。

表2 浮点类型

 

类型	存储需求	取值类型
float	4字节	大约
double	8字节	大约

 

（3）、字符类型

char字符类型是一个16位无符号整数，用于表示单个字符，通常用来表示字符常量。

①、字符类型的值是对应字符的编码，是unicode 编码，java支持国际化，其中英文部分的值与ascll编码一致。Char是定长编码，所以的字符都是16位。例2：‘A’  0X0041

  ‘中’  0x4e2d

   在编码中：’0’ ’9’  ‘a’ ’z’  ‘A’ ’Z’都是连续编码的。

②、字符字面量使用单引号为定界符号：‘中’字面量也是整数常量。

③、最小值：0，最大值：65535 = 2^16-1

（4）boolean类型

Boolean类型有两个值：false和true，用来判定逻辑条件。整型值和布尔值之间不能进相互转换。

注意：

1.数据类型不能乱用，绝对不能给一个int型的变量赋以double型的数据，这是绝对会报错的

eg : int data = 1.0 //wrong 

对于这种问题只有靠强制类型转换才能实现这样的效果

eg : int data = (int)(1.0) //将1.0这个double型数据强制类型转化成int 型，你在以后的学习中会遇到很多强制类型转化

四、变量

1、java是强类型语言，其变量命名必须以字母开头，由字母和数字构成的序列。

2、变量必须声明，并且初始化以后使用。

3、变量必须有明确的类型，且变量不能重复定义。

4、变量的作用域，在声明的地方开始，到块结束为止，离开变量的作用结束时，变量将回收。

5、在java中，利用关键字final声明常量，这个常量只能被赋值一次，一旦赋值之后就不能够再更改了。习惯上，常量名使用大写。

例3        

public class Constants{

public static void main(String[] args){

    final double A=2.54;//常量名习惯用大写

    // a=3.14; 错误

    double b=3.12;

    double c=3.21;

    System.out.println（A+b+c）;

}

}

 

五、运算符           

1、数学运算符：+ - * / %，需注意的问题有：

（1）在作/运算时，只有当参与/运算的两个操作数都是整数时，表示整数除法；否则，表示浮点除法。如：15/2为7，15.0/2为7.5。

 

（2）运算具有封闭性，即同种类型参与运算，返回同种类型。值得注意的是可能发生上溢出和下溢出。如：int i = 1024*1024*1024*4(上溢出)。

 

（3）作%运算时，参与运算的两个操作数必须为整型，否则会报错。

 

（4）+可以作字符串的连接运算，如：“，”+2  “，2”

例4：

public class Yunxuan{

public static void mian(String[] args){

    int a=3;

    double b=3.0;

    int c=2;

    System.out.println(a/c);//1

    System.out.println(b/c);//1.5

    System.out.println(a%c);//1

    //System.out.println(b%c);//出错

   

    int i=1024*1024*1024*4+1;//上溢出

    System.out.println(i);//1

}

}

2、关系运算符

（1）自增、自减运算：++ --

     a、i++:先将i的值作为整个表达的值，然后将i增加1。

     b、i++：先将i增加1，然后将i的值作为整个表达的值。

（2）在java中，用&&、&表示逻辑“与”，用||、|表示逻辑“或”，其中&&、||表示短路的逻辑运算， &、|表示非短路运算，大多数时使用短路运算。

（3） ， 运算符将二进制进行右移或左移操作。

六、数组

（1）数组是一种数据结构，用来存储同一类型值的集合。在声明数组变量时，需要指出数组类型和数组变量的名字。

（2）数组初始化时一定要指定其维数，其初始化形式有以下两种：

     ①动态初始化数组：int[] arry = new int[];

     ②静态初始化数组：int[] arry = {1,2,3,4,5};  arry.length = 5;

七、大数值（稍作了解就好）

如果基本的整数和浮点数精度不能够满足需求，那么可以使用java.math包中的两个很有用的类：BigInteger和BigDecimal，这两个类可以处理包含任意长度数序列的数值。

(1)BigInteger类实现了任意精度的整数运算，BigDecimal类实现了任意精度的浮点数运算。使用静态的ValuOf方法可以将普通的数值转换为大数值。

(2)Java.math.BigInteger中常用的API

①  BigInteger add(BigInteger other)

BigInteger subtract(BigInteger other)

BigInteger multiply(BigInteger other)

BigInteger divide(BigInteger other)

BigInteger mod(BigInteger other)

返回这个大整数与另一个大整数other的和、差、积、商以及余数。

②   int compareTo(BigInteger other)

如果这个大整数与另一个大整数other相等,返回0，如果这个大整数小于另一个大整数other，返回负数，否则，返回正数。

③   static Bigteger valueOf(long x)

返回值等于x的大整数

④  BigDecimal add(BigDecimal other)

BigDecimal subtract(BigDecimal other)

BigDecimal multiply(BigDecimal other)

BigDecimal divide(BigDecimal other)

BigDecimal mod(BigDecimal other)

返回这个大实数与另一个大实数other的和、差、积、商以及余数。

⑤  int compareTo(BigDecimal other)

如果这个大实数与另一个大实数other相等,返回0，如果这个大实数小于另一个大实数other，返回负数，否则，返回正数。

⑥  static BigDecimal valueOf(long x)

static BigDecimal valueOf(long x,int a)

返回值为x或 的一个大实数。

八、控制流程

（1）分支流程控制语名

①if(布尔表达式){

    //...

  }

else if{

    //...

  }

else{

    //...

  }

 

  ②switch(整数表达式){

    case 整数(int)常量:

      // ....

      break;

    case 整数常量:

      // ....

      break;

    default:

      //....

  }

（2）分支循环控制语句

 ① for(初始化表达式;布尔表达式; 递增表达式){

    //循环体

}

 

② While 循环控制

  while(布尔表达式){

  }

③do ... while() 循环控制

  do{

  //循环体

  }while(布尔表达式);

 

（3）For each 循环

Java SE 5.0 增加了一种功能很强的循环结构，可以用来依次处理数组中的每个元素而不必为指定下标值而分必。

这种增强的for循环的语句格式为：

for(vriable : collection) statement

 

（4）break,continue,return,exit()的区别

break:跳出本层循环

continue:跳出本次循环

return:跳出方法

exit():跳出执行的程序

九、三大排序（做到可以手写）

（1） 选择排序

  原理: ① 将数组中的每个元素,与第一个元素比较

          如果这个元素小于第一个元素, 就将这

          两个元素交换.

        ② 每轮使用a的规则, 可以选择出一个最小元素

          放到第一个位置.

        ③ 经过n-1轮比较完成排序

   简单说: 每轮选择最小的放到前面.

      

数组的迭代(Iterate over Array)就是对数组的遍历

就是逐一处理数组元素.

逐一处理==遍历==迭代==Iterate

 

（2） 冒泡排序

  原理: ① 逐一比较数组中相邻的两个元素, 如果后面

         的数字小于前面的数字, 就交换先后元素.

        ② 经过一个轮次的比较, 一定有一个最大的排

         在最后的位置.

        ③ 每次比较剩下的元素, 经过n-1次比较, 可以

         实现排序

  简单说: 比较交换相邻元素,每次最大的漂移到最后

   

3 插入排序

  原理: ① 将数组分为两部分, 将后部分的第一张逐一

         与前部分每一张比较, 如果当前元素小, 就

         一点被比较元素.

        ② 找到合理位置插入.

例5：

public class SortDemo {

  public static void main(String[] args) {

    int[] ary = {8,3,5,1,4,2,7};

    //ary = selectionSort(ary);

    //ary = bubleSort(ary);

    ary = insertSort(ary);

       //输出数组ary内容

    for (int i = 0; i < ary.length; i++) {

      System.out.print(ary[i]+" ");

    }

  }

 

  public static int[] insertSort(int[] ary){

    for(int i=1; i<ary.length; i++){

      int temp = ary[i];

      int j;

      //for(j=i-1; j>=0 && temp<ary[j]; j--){

      for(j=i-1; j>=0; j--){

        if(temp<ary[j]){

          ary[j+1]=ary[j];

        }else{

          break;

        }

      }

      ary[j+1]=temp;//插入

    }

    return ary;

  }

 

  public static int[] bubleSort(int[] ary){

    for(int i=0; i<ary.length-1; i++){

      for(int j=0; j<ary.length-(1+i); j++){

        if(ary[j] > ary[j+1]){

          int temp = ary[j];

          ary[j] = ary[j+1];

          ary[j+1] = temp;

        }

      }

    }

    return ary;

  }

  public static int[] selectionSort(

      int[] ary){

    for(int i=0; i<ary.length-1; i++){

      for(int j=i+1; j<ary.length; j++){

        if(ary[j]<ary[i]){

          int temp = ary[j];

          ary[j] = ary[i];

          ary[i] = temp;

        }

      }

    }

    return ary;

  }

 

}

十、Stiring字符串

我为什么要把它放在最后一个，是因为他最重要。

在java基础中，撇开和对象有关的，继承，多态。

String是最重要的，也是最难记的。方法多，但你做东西的时候多多少少会用到。

所以我特意另做了两个博客：

一个是String的主要方法：http://blog.csdn.net/mon_key_dt/article/details/40084883

另一个是他的一些实例：http://blog.csdn.net/mon_key_dt/article/details/40084987

最后，欢迎大家指出我的错误。

我是在错误和bug夹缝中生长的程序猿。