Java语言基本语法

admin
2021-08-23 / 0 评论 / 95 阅读 / 正在检测是否收录...

一、标识符和关键字

  1. 标识符
    ①在java语言中,用来标志类名、对象名、变量名、方法名、类型名、数组名、包名的有效字符序列,称为“标识符”;

②标识符由字母、数字、下划线、美元符号组成,且第一个字符不能是数字;
③ java语言区分大小写;
④标志符命名规则:类名首字
母大写,变量名和方法名采用驼峰标志法,常量全大写,多个单词之间用“_”隔开,包名全小写;

  1. 关键字
    ①在java语言中,有一些专门的词汇已经被赋予了特殊的含义,不能再使用这些词汇来命名标识符,这些专有词汇,称为“关键字”;

②java有50个关键字和3个保留字,均不能用来命名标识符(abstract,assert,boolean,break,byte,case,catch,char,class,const,continue,default,do,double,else,enum,extends,final,finally,float,for,goto,if,implements,import,instanceof,int,interface,long,native,new,package,private,protected,public,return,short,static,strictfp,super,switch,synchronized,this,throw,throws,transient,try,void,volatile,while)
③true、false、null不是关键字,是保留字,但是仍不能用来命名标识符,保留字是java预留的关键字,在以后的升级版本中可能会作为关键字;

二、基本数据类型
Test

  1. 整数类型(int为默认类型)
    Test
  2. 浮点类型(double为默认类型)
    Test

注:在给float类型的变量赋值时,如果赋的值有小数部分则一定要在末尾加上“F”或“f”;

  1. 字符类型(2字节)
    ①char ch = 'a';

②有些字符不能通过键盘输入到程序当中,这时就需要使用到转义字符;
Test

  1. 布尔类型(1字节)
    boolean flag = true;
  2. 默认值
    数值变量:0;

字符变量:‘0’;
布尔变量:false;
引用数据类型:null;

  1. 不同数据类型之间的转换
    ①自动类型转换(低 到 高)

Test
②强制类型转换(高 到 低)

public class Test003 {
    public static void main(String[] args) {
        byte b = 100;
        int i = 22;
        float f = 78.98f;
        int res = b + i + (int)f;    //此处对f使用了强制类型转换(int)f,转换后的值为78
        System.out.println("res: "+res);    //res: 200
    }
}

三、运算符与表达式

  1. 算术运算符
    Test
public class Test003 {
    public static void main(String[] args) {
        int i = 5;
        System.out.println(0/i);    //0
        System.out.println(0%i);    //0
        System.out.println(i/0);    //除数不能为零,报异常java.lang.ArithmeticException
        System.out.println(i%0);    //除数不能为零,报异常java.lang.ArithmeticException
    }
}
  1. 赋值运算符
    Test

3 自增自减运算符(++,--)

public class Test003 {
    public static void main(String[] args) {
        int i = 5;
        System.out.println(i++);    //5
        System.out.println(++i);    //7
        System.out.println(i);    //7
        System.out.println(--i);    //6
        System.out.println(i--);    //6
        System.out.println(i);    //5
    }
}
  1. 关系运算符
    Test

5.逻辑运算符

public class Test003 {
    public static void main(String[] args) {
        boolean t = true;
        boolean f = false;
        System.out.println(t && f);    //false,短路与运算符,若运算符左侧为false则不计算右侧的表达式
        System.out.println(t || f);    //true,短路或运算符,若运算符左侧为true则不计算右侧的表达式
        System.out.println(t & f);    //false,与运算符,不管左侧是否为false都要计算右侧的表达式
        System.out.println(t | f);    //true,或运算符,不管左侧是否为true都要计算右侧的表达式
        System.out.println(t ^ f);    //true,异或运算符,只要左右两侧不相同则为true,反之为false
        System.out.println(!f);    //true,取反运算符
    }
}
  1. 位运算符
public class Test003 {
    public static void main(String[] args) {
        //在位运算符中1相当于true,0相当于false
        int b1 = 6;    //二进制为00000000 00000000 00000000 00000110
        int b2 = 11;    //二进制为00000000 00000000 00000000 00001011
        System.out.println(b1 & b2);    //按位与运算符,二进制为00000000 00000000 00000000 00000010,结果为2
        System.out.println(b1 | b2);    //按位或运算符,二进制为00000000 00000000 00000000 00001111,结果为15
        System.out.println(b1 ^ b2);    //按位异或运算符,二进制为00000000 00000000 00000000 00001101,结果为13
        System.out.println(~b1);    //按位取反运算符,二进制为11111111 11111111 11111111 11111001,结果为-7
        System.out.println(b1 << 2);    //左移位运算符,二进制为00000000 00000000 00000000 00011000,结果为24
        int b3 = -14;    //二进制为11111111 11111111 11111111 11110010
        System.out.println(b3 >> 2);    //带符号右移位运算符,二进制为11111111 11111111 11111111 11111100,结果为-4
        System.out.println(b3 >>> 2);    //无符号右移位运算符,二进制为00111111 11111111 11111111 11111100,结果为1073741820
    }
}
  1. 三元运算符
public class Test003 {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        int c = 4;
        int res = c==a+b?++a:c>a+b?++b:++c;    //三元运算符 (表达式)?(值1):(值2),若表达式为true则取值1,反之取值2
        System.out.println(res);    //++b,结果为3
    }
}
  1. 运算符优先级
    Test

四、数组

  1. 一维数组
public class Test003 {
    public static void main(String[] args) {
        int[] i;    //声明一个整型的一维数组变量
        int ii[];    //声明一个整型的一维数组变量
        i = new int[5]; //创建一个长度为5的一维数组对象,并将变量i指向该对象
        float[] f = new float[5];    //直接创建一个长度为5的单精度浮点型一维数组对象,并将变量f指向该对象
        double[] d = {1, 2, 3.4, 4.5};    //直接初始化一个一维数组元素
        System.out.println(d[3]);    //通过数组下标来获取数组内的元素,数组下标从0开始,结果为4.5
        System.out.println(f[0]);    //当创建出一个数组对象时,该对象内的数组元素为该数据类型的默认值,所以此处结果为0.0
        //System.out.println(i[5]);    //当通过数组下标来获取数组内元素时,[]内的值>=数组长度则报异常java.lang.ArrayIndexOutOfBoundsException(数组下标越界)
        //System.out.println(ii[0]);    //若一个数组变量只声明而未指向某一个具体的数组对象时,编译出错
        System.out.println(d.length);    //得到该数组的长度,结果为4
    }
}
  1. 二维数组
public class Test003 {
    public static void main(String[] args) {
        int[][] i;    //声明一个整型的二维数组变量
        int ii[][];    //声明一个整型的二维数组变量
        int[] iii[];    //声明一个整型的二维数组变量
        i = new int[5][2]; //创建一个长度为5的二维数组对象,并将变量i指向该对象
        float[][] f = new float[5][2];    //直接创建一个长度为5的单精度浮点型二维数组对象,并将变量f指向该对象
        double[][] d = {{1}, {2,3}, {4,5,6}, {7,8,9,10}};    //直接初始化一个二维数组元素
        
        System.out.println(d[3][1]);    //通过数组下标来获取数组内的元素,数组下标从0开始,结果为8
        System.out.println(f[0][0]);    //当创建出二个数组对象时,该对象内的数组元素为该数据类型的默认值,所以此处结果为0.0
        //System.out.println(i[5][0]);    //当通过数组下标来获取数组内元素时,[]内的值>=数组长度则报异常java.lang.ArrayIndexOutOfBoundsException(数组下标越界)
        //System.out.println(ii[0][0]);    //若一个数组变量只声明而未指向某一个具体的数组对象时,编译出错
        System.out.println(d.length);    //得到该数组的长度,结果为4
        System.out.println(d[2].length);    //得到二位数组内的下标为2的那个一维数组的长度
    }
}

五、流程控制语句(if,switch,for,while,do...while)

  1. 条件分支语句
public class Test003 {
    public static void main(String[] args) {
        int[] score = new int[5];
        score[0] = -7;
        score[1] = 65;
        score[2] = 80;
        score[3] = 90;
        score[4] = 59;
        for(int i=0; i<score.length; i++) {
            if(score[i]>=0 && score[i]<60) {
                System.out.println("不及格");
            }else if(score[i]>=60 && score[i]<80) {
                System.out.println("及格");
            }else if(score[i]>=80 && score[i]<90) {
                System.out.println("良");
            }else if(score[i]>=90 && score[i]<100) {
                System.out.println("优");
            }else {
                System.out.println("成绩异常");
            }
        }
        
        char ch = 'a';
        switch(ch) {    //switch括号内只支持 byte,short,int,char,enum五种数据类型,但是JDK1.7版本增加了String类型,所以相对于JDK1.7而言就是六种了
            case 'A':    //case为switch语句的入口,break为出口,从入口开始执行,直到遇到出口或代码执行完毕才结束
            case 'a':
                System.out.println("优");
                break;
            case 'B':
            case 'b':
                System.out.println("良");
                break;
            case 'C':
            case 'c':
                System.out.println("及格");
                break;
            default:    //若上述条件均不匹配,则进default开始执行语句
                System.out.println("不及格");
        }
    }
}
  1. 循环语句
public class Test003 {
    public static void main(String[] args) {
        int res = 0;
        out:    //out是一个标号,告诉java从哪里开始执行程序
        for(int i=1; i<=10; i++) {
            if(i==3) continue out;    //continue终止本次循环,执行下次循环
            if(i==5) break out;    //break跳出循环
            res = res + i;
        }
        System.out.println(res);    //结果为1+2+4=7
        
        int res2 = 0;
        int i = 1;
        in:
        do{
            if(i==3) continue in;    //continue终止本次循环,执行下次循环
            if(i==5) break in;    //break跳出循环
            res2 = res2 + i;
            i++;
        }while(i<=10);
        System.out.println(res2);
    }
}
2

评论 (0)

取消