icewing

【第一篇】java基本语法
前面只是对java的一次初见,本篇将是对java一次较为全面的认识与使用。都是一些需要注意,容易遗忘的坑。了解一下。
扫描右侧二维码阅读全文
09
2018/09

【第一篇】java基本语法

前面只是对java的一次初见,本篇将是对java一次较为全面的认识与使用。都是一些需要注意,容易遗忘的坑。了解一下。

关键字 & 标识符

  • 关键字:被Java语言赋予了特殊含义,用做专门用途的字符串(单词)
  • 保留字:被java语言提前定义下,现在没有使用,之后可能会占用
  • 标识符:凡是自己可以起名字的地方都叫标识符

命名的规则

一定要遵守,不遵守就会报编译的错误

  • 由26个英文字母大小写,0-9 ,_或 $ 组成
  • 数字不可以开头。
  • 不可以使用关键字和保留字,但能包含关键字和保留字。
  • Java中严格区分大小写,长度无限制。
  • 标识符不能包含空格。

Java中的名称命名规范

不遵守,也不会出现编译的错误

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

变量

  • java中变量按照数据类型来分类:基本数据类型 vs 引用数据类型(数组 类 接口)

基本数据类型:

  • 整型:byte(8 bit) short int(默认类型) long
  • 浮点型:float double (默认类型)
  • 字符型:char(‘ ’)
  • 布尔类型: boolean(只能取值为true 或false,不能取null)

补充:按照在类中存在的位置的不同:成员变量 vs 局部变量

进制(了解)

  • 十进制、二进制、八进制、十六进制

二进制:计算机底层都是用二进制来存储、运算。

二进制在底层存储:正数、负数都是以补码的形式存储的。(原码、反码、补码)

变量的运算

①自动类型转换:容量小的数据类型自动转换为容量大的数据类型。

short s = 12;
int i = s + 2;
//注意:byte  short char之间做运算,结果为int型!

②强制类型转换:是①的逆过程。使用“()”实现强转。


运算符

  • 运算符是一种特殊的符号,用以表示数据的运算、赋值和比较等。

算术运算符

+  -  + - * / % ++ -- +

注意:1) /:   int i = 12;  i = i / 5;
     2) %:最后的符号只跟被模数相同
     3)前++:先+1,后运算     后++:先运算,后+1
     4)+:String字符串与其他数据类型只能做连接运算,且结果为String类型。sysout('*' + '\t' + '*'); vs  sysout("*" + '\t' + '*');

赋值运算符

=    +=   -=  *=    /=   %=
int i= 12;
i  = i * 5;
i *= 5;//与上一行代码同样的意思

【特别地】
short s = 10;
s = s + 5;//报编译的异常
s = (short)(s + 5);
s += 5;//s = s + 5,但是结果不会改变s的数据类型。

比较运算符

  • 关系运算符
==  >   <  >=   <=    instanceof  

【注意】区分==  与 =  区别。
进行比较运算操作以后,返回一个boolean类型的值
4>=3  表达的是4 > 3或者 4 = 3.结果是true。

if(i > 1 && i < 10){  }   
不能写为:if(1 < i < 10){}

逻辑运算符

  • 运算符的两端是boolean值
&   &&  |  ||  ^ !

【注意】区分 &  与 && 的区别,以及 |  与 || 的区别
我们使用的时候,选择&& , ||

位运算符

  • 两端是数值类型的数据
<<   >>    >>>  &  |   ^  ~

【例子】1.如何交换m = 12和n = 5的值
       2.将60转换为十六进制输出。

三元运算符

  • (条件表达式)? 表达式1 : 表达式2;

1)既然是运算符,一定会返回一个结果,并且结果的数据类型与表达式1,2的类型一致
2)表达式1与表达式2 的数据类型一致。
3)使用三元运算符的,一定可以转换为if-else。反之不一定成立。

例子:获取两个数的较大值;获取三个数的最大值。


流程控制

顺序结构

  • 程序从上往下的顺序执行

分支结构

  • 条件判断
1. if(条件表达式){   }

2. if(条件表达式){
    //执行的语句1;
  }else{
    //执行的语句2;
  }

3. if(条件表达式1){
    //执行的语句1;
  }else if(条件表达式2){
    //执行的语句2;
  }else if( 条件表达式3){
    //执行的语句3;
  }...
  }else{
    //执行的语句;
  }

【注意】

  1. 一旦满足某个条件表达式,则进入其执行语句块执行,执行完毕,跳出当前的条件判断结构,不会执行其以下的条件结构语句。
  2. 如果诸多个条件表达式之间为“互斥”关系,多个结构可以上下调换顺序
  3. 如果诸多个条件表达式之间为“包含”关系,要求条件表达式范围小的写在范围大的上面。

  • 选择判断
switch(变量){
    case 值1:
    
    //break;
    case 值2:
    
    //break;
    ...
    default:
    
    break;
}

【注意】

  1. 变量可以为如下的数据类型:byte short int char 枚举 String
  2. case后只能填写变量的值,不能写范围。
  3. default是可以省略的。并且其位置也是灵活的,但是通常将其放在case语句之后。
  4. 一旦满足某个case语句,则进入执行其操作。直至遇到break或者程序终止。
  5. 若要判断的语句的条件满足switch变量的数据类型,且值不多的情况下,建议选择switch-case . 除此之外,选择if-else.

循环结构

格式:
1. 初始化条件
2. 循环条件
3. 迭代部分
4. 循环体

for(1;2;3){
    4
}
//--------分割----------
1
while(2){
    4
    3
}
//--------分割----------
1
do{
    4
    3
}while(2);

//注: 1.不同的循环结构之间可以相互转换
//    2.while和do-while的区别:do-while程序至少会执行一次
  • 嵌套循环

循环结构还可以声明循环。让内层循环结构整体充当外层循环的循环体。若外层循环执行m次,内层循环执行n次,整个程序执行m*n次。

for(int i = 0;i < 3;i++){
    for(int j = 0;j < 6;j++){
        System.out.print("*");
    }
    System.out.println();
}
//说明:外层循环控制行数,内层循环控制列数
  • 无限循环结构
for(;;){
   ...
   if(  ){
    break;
   }
   ...
}
或者
while(true){
   ...
   if(  ){
    break;
   }
   ...
}

往往我们在无限循环结构内部提供循环的终止条件,使用break关键字。否则,此循环将无限制的执行下去,形成死循环!

死循环是我们要避免的。

break&continue

break:使用switch-case结构或者循环结构中

在循环结构中,一旦执行到break,就跳出当前循环。

continue:使用在循环结构中

一旦执行到continue,就跳出当次循环。

for(int i = 1;i <= 10;i++){
    if(i % 4 == 0){
        //break; //123
        continue;  //123567910
    }
System.out.print(i);

}

在嵌套循环中,使用带标签的break和continue。

label:for(int i = 1;i < 5;i++){
    for(int j = 1;j <= 10;j++){
        if(j % 4 == 0){
            //break;  ---- NO
            //continue;---- NO
            //break label; ----- YES
            //continue label;----- YES
        }
        System.out.print(j);
    }
    System.out.println();
}

数组

相同数据类型的数据的组合。

如: int score1 = 72;

int score2 = 90;

int score3 = 59;

数组的初始化

int[] scores1 = new int[]{72,90,59};//静态初始化:在声明并初始化数组与给数组相应的元素赋值操作同时进行。
int scores2[] = new int[3];//动态初始化:在声明并初始化数组与给数组相应的元素赋值操作分开进行。
scores2[0] = 72;
scores2[1] = 90;
scores2[2] = 59;

//声明数组的错误写法:
    // 1)String[] names = new String[5]{"AA","BB","CC"};
    // 2)int i[10];
    // 3)int i = new int[];
//注:不管是动态还是静态初始化数组,一定在创建的时候,就指明了数组的长度!

数组的引用

  • 通过数组的下角标的方式。下角标从0开始,到n-1结束。其中n为数组的长度。

数组的长度

  • 通过数组的属性length来调用。
System.out.println(scores2.length);//输出3

数组的遍历

for(int i = 0;i < scores1.length;i++){
    System.out.println(scores1[i]);
}

数组的始化值

  • 关于数组元素的默认初始化值

1) byte short int long 而言:0
2) float double 而言:0.0
3) char而言:空格
4) boolean而言:false
5) 引用类型变量而言:null

二维数组

  • 声明并初始化
//一维:
int[] i = new int[12];
i[0] = 12;

int[] j = new int[]{12,3};

//二维:
1) String[][] str = new String[4][3]; //4行3列

2) String[][] str1 = new String[4][];
   str1[0] = new String[3];
   ...
   str1[3] = new String[5];

3) int[][] arr = new int[][]{{1,2,3},{4,5},{6}};
  • 引用二维数组的元素
arr[1][0] = 12;
  • 二维数组的长度
arr.length;//3
arr[1].length;//2
  • 遍历二维数组
for(int i = 0;i < arr.length;i++){
    for(int j = 0;j < arr[i].length;j++){
        System.out.print(arr[i][j] + "\t");    
    }
    System.out.println();
 }

数组的常见异常

//1.数组下标越界的异常:java.lang.ArrayIndexOutOfBoundsException
        int[] i = new int[10];
//        i[0] = 90;
//        i[10] = 99;
        
//        for(int m = 0;m <= i.length;m++){
//            System.out.println(i[m]);
//        }
//2.空指针的异常:NullPointerException
        //第一种:
//        boolean[] b = new boolean[3];
//        b = null;
//        System.out.println(b[0]);

        //第二种:
//        String[] str = new String[4];
//        //str[3] = new String("AA");//str[3] = "AA";
//        System.out.println(str[3].toString());
        
        //第三种:
        int[][] j = new int[3][];
        j[2][0] = 12;

数组的排序

  • 插入排序 -- 直接插入排序、折半插入排序、Shell排序
  • 交换排序 -- 冒泡排序、快速排序(或分区交换排序)
  • 选择排序 -- 简单选择排序、堆排序
  • 归并排序
  • 基数排序
// 使用冒泡排序使数组元素从小到大排列
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
//        //使用直接选择排序使数组元素从小到大排列
        for(int i = 0; i < arr.length - 1; i++){
            int t = i;//默认i处是最小的
            for(int j = i;j < arr.length;j++){
                //一旦在i后发现存在比其小的元素,就记录那个元素的下角标
                if(arr[t] > arr[j]){
                    t = j;
                }
            }
            if(t != i){
                int temp = arr[t];
                arr[t] = arr[i];
                arr[i] = temp;
            }
        }

到此先休息一下,后面还有好多的内容。下一篇主要是面向对象的超多内容。

最后修改:2018 年 09 月 09 日 06 : 14 PM
生活需要一些仪式感,比如手冲一杯咖啡:)

发表评论