Java 语法基础

星姮十织

发布于 2021-12-25 06:46:57

2440

发布于 2021-12-25 06:46:57

文章被收录于专栏：技术-汇集区技术-汇集区

注释

在Java语言中，注释有以下三种方法：

单行注释：// 注释内容
多行注释：/* 注释内容 */
文档注释：/** 注释内容 */

示例：

/**
 * （文档注释）
 * @Description HelloWorld
 * @Author 惟妙惟霄
 */
public class HelloWorld {
    public static void main(String[] args) {
        //（单行注释）这个程序的作用是输出Hello, world!
        System.out.println("Hello, world!");
        /*
        （多行注释）
        这个程序的作用是输出Hello, world!
        */
    }
}

标识符

定义：Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

注意：

所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
关键字不能用作标识符
标识符是大小写敏感的
可以用中文命名，但是极不推荐
合法标识符举例：age、$salary、_value、__1_value
非法标识符举例：123abc、-salary

示例：

public class Demo01 {
    public static void main(String[] args) {
        String hello = "Hello, world!";     //小写字母开头，正确
        String Hello = "Hello, world!";     //大写字母开头，正确
        String $Hello = "Hello, world!";    //美元符开头，正确
        String _Hello = "Hello, world!";    //下划线开头，正确
        String Hello123 = "Hello, world!";  //非开头位置使用数字，正确

        //String 123Hello = "Hello, world!";    //数字开头，错误
        //String #Hello = "Hello, world!";      //井号开头，错误
        //String *Hello = "Hello, world!";      //星号开头，错误

        String 道德经 = "道可道，非常道。";      //使用中文，可以通过，但极不推荐
    }
}

数据类型

Java是强类型语言。Java中的数据类型分为两种：

基本类型
引用类型

其中，基本数据类型分为以下四种：

整数型：byte（占1个字节）、short（占2个字节）、int（占4个字节）、long（占8个字节）
浮点型：float（占4个字节）、double（占8个字节）
字符型：char（占2个字节）
布尔型：boolean（占1位）

而引用数据类型分为以下三种：

类
接口
数组

示例：

public class Demo02 {
    public static void main(String[] args) {
        //八大基本数据类型
        //整数
        int num1 = 10;      //最常用
        byte num2 = 20;
        short num3 = 30;
        long num4 = 30L;    //long类型在数字的最后加大写字母L
        //浮点数
        float num5 = 3.14159F;      //float类型要在数字最后加F
        double num6 = 3.14159;
        //字符
        char a = 'A';
        //布尔值
        boolean flag1 = true;
        boolean flag2 = false;
    }
}

其中，整数还可以使用不同的进制来表示：

二进制：0b开头
八进制：0开头
十进制
十六进制：0x开头

示例：

public class Demo03 {
    public static void main(String[] args) {
        int num1 = 10;      //十进制
        int num2 = 0b10;    //二进制以0b开头
        int num3 = 010;     //八进制以0开头
        int num4 = 0x10;    //十六进制以0x开头
        System.out.println(num1);   //输出10
        System.out.println(num2);   //输出2
        System.out.println(num3);   //输出8
        System.out.println(num4);   //输出16
    }
}

另外，浮点型因为精度和溢出的问题，尽量不要作为比较对象。

示例：

public class Demo03 {
    public static void main(String[] args) {
        float f1 = 2313467468515648F;
        float f2 = f1 + 1;
        System.out.println(f1==f2);     //明明f2=f1+1，但仍然输出true，即f1与f2相等
    }
}

而字符类型本质仍是整数。

示例：

public class Demo03 {
    public static void main(String[] args) {
        char c1 = 'a';                  //赋值为a
        System.out.println(c1);         //输出a
        System.out.println((int)c1);    //输出97
        char c2 = '中';                 //赋值为中
        System.out.println(c2);         //输出中
        System.out.println((int)c2);    //输出20013
        char c3 = 97;                   //直接用整数赋值
        System.out.println(c3);         //输出a
        char c4 = '\u0061';             //转义为unicode编码
        System.out.println(c4);         //输出a
    }
}

类型转换

由于Java是强类型语言，因而在进行某些整型、浮点型、字符型数据的混合运算中需要进行类型转换。不同类型的数据先转化为同一类型，然后进行运算。

低  --------------------------------------->  高
byte/short/char —> int —> long—> float —> double

数据类型在进行转换时需注意以下几点：

不能对布尔型进行类型转换。
不能把对象类型转换成不相关的类型。
在把容量小的类型转换为容量大的类型时会进行自动类型转换。
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
转换过程中可能导致溢出或损失精度。

示例：

public class Demo04 {
    public static void main(String[] args) {
        //高->低 强制类型转换 (类型)变量名
        int num1 = 128;
        byte num2 = (byte)num1;
        System.out.println(num2);   //内存溢出，输出-128

        //低->高 自动类型转换
        double num3 = num1;
        System.out.println(num3);   //输出128.0

        //精度丢失
        float f = 3.5F;
        double d = 3.5;
        System.out.println((int)f);      //输出3
        System.out.println((int)d);      //输出3

        //计算中的类型转型，应先转型，再计算
        int money = 10_0000_0000;       //整数中可以任意使用下划线分割
        int years = 20;
        int total1 = money*years;
        System.out.println(total1);     //输出-1474836480，即结果溢出
        long total2 = money*years;
        System.out.println(total2);     //输出-1474836480，即结果溢出
        long total3 = money*((long)years);
        System.out.println(total3);     //输出20000000000，即结果正确
    }
}

变量

在Java语言中，所有的变量在使用前必须声明。声明变量的基本格式如下：

type varname [ = value] [, varname[= value] ...];
//类型 变量名 = 值; 可以使用逗号隔开来同时声明多个同类型变量，但不推荐这么做

注意事项：

每个变量都有类型，可以是基本类型，也可以是引用类型。
变量名必须是合法的标识符。
变量声明是一条完整的语句，因此每一个声明都必须以分号结束。
变量名尽量遵守首字母小写的驼峰原则，例如：num、lastName、redApple、studentsNameList。

示例：

public class Demo05 {
    public static void main(String[] args) {
        int num = 123;
        String name = "惟妙惟霄";
        char x = 'X';
        double pi = 3.14159;
    }
}

Java语言支持的变量类型有：

类变量：独立于方法之外，且用 static 修饰的变量。
实例变量：独立于方法之外，不用 static 修饰的变量。
局部变量：位于方法之中的变量。

示例：

public class Demo06 {
    //实例变量：从属于对象。可以不进行初始化，会赋默认值。
    int a;          //整数类型的默认值为0
    boolean b;      //布尔型的默认值为false
    String c;       //引用类型的默认值为null

    //类变量：从属于类。使用static修饰。可以不进行初始化，会赋默认值。
    static int d;

    //main方法
    public static void main(String[] args) {
        //局部变量：必须声明且必须初始化值
        int i = 10;
        System.out.println(i);

        //实例变量
        Demo06 demo06 = new Demo06();   //需创建实例
        System.out.println(demo06.a);   //输出0
        System.out.println(demo06.b);   //输出false
        System.out.println(demo06.c);   //输出null
        demo06.a = 10;
        System.out.println(demo06.a);   //输出10
        demo06.b = true;
        System.out.println(demo06.c);   //输出true
        demo06.c = "惟妙惟霄";
        System.out.println(demo06.c);   //输出惟妙惟霄

        //类变量
        System.out.println(d);          //输出0
        d = 12;
        System.out.println(d);          //输出12
    }
}

常量

定义：常量是初始化后无法再次改动的值。常量名一般使用大写字符和下划线。其基本的声明格式如下：

final 类型 常量名 = 值;
//例如： final double PI = 3.14;

示例：

public class Demo07 {

    //static与final都是修饰符，不存在先后顺序
    static final double PI = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);     //输出3.14
    }
}

运算符

Java语言支持以下运算符：

算术运算符：+、-、*、/、%、++、--
关系运算符：>、<、>=、<=、==、!=、instanceof
位运算符：&、|、^、~、>>、<<、>>>
逻辑运算符：&&、||、!
赋值运算符：=、+=、-=、*=、/=
条件运算符： ?:
其他运算符

算数运算符

示例：

package operator;

public class Demo01 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        int d = 40;

        //二元运算符
        System.out.println(a+b);            //加法运算，输出30
        System.out.println(b-c);            //减法运算，输出-10
        System.out.println(c*d);            //乘法运算，输出1200
        System.out.println(a/(double)d);    //除法运算，输出0.25
        System.out.println(d%c);            //取余运算，输出10

        //一元运算符
        System.out.println(a);      //输出10
        System.out.println(a++);    //输出10。当++在后时，先运算，后自增。
        System.out.println(a);      //输出11
        System.out.println(++a);    //输出12。当++在前时，先自增，后运算。

        //利用Math类进行运算
        double e = Math.pow(2, 3);
        System.out.println(e);      //输出8，即2的3次方
        int f = Math.abs(-5);
        System.out.println(f);      //输出5，即-5的绝对值
    }
}

关系运算符

示例：

package operator;

public class Demo02 {
    public static void main(String[] args) {
        //关系运算的返回结果是布尔类型，即结果只有true或false
        int a = 10;
        int b = 20;
        System.out.println(a>b);    //输出false
        System.out.println(a<b);    //输出true
        System.out.println(a==b);   //输出false
        System.out.println(a!=b);   //输出true
    }
}

逻辑运算符

示例：

package operator;

public class Demo03 {
    public static void main(String[] args) {
        //逻辑运算符
        //与(and) 或(or) 非(not)
        boolean a = false;
        boolean b = true;
        System.out.println(a&&b);   //输出false。逻辑与运算：两个都为真，结果才为真。
        System.out.println(a||b);   //输出true。逻辑或运算：两个有一个为真，结果就为真。
        System.out.println(!a);     //输出true。逻辑非运算：真变为假，假变为真。

        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4);
        System.out.println(d);      //输出false
        System.out.println(c);      //输出5，说明c++<4并没有被执行，该语句被“短路”了
    }
}

位运算符

示例：

package operator;

public class Demo04 {
    public static void main(String[] args) {
        //位运算
        /*
         * 设
         * A = 1101 0001
         * B = 0110 1000
         * 则
         * A&B = 0100 0000   按位与运算
         * A|B = 1111 1001   按位或运算
         * A^B = 1011 1001   按位异或运算，即不相等为1，相等为0
         * ~B = 1001 0111    按位取反运算
         * */

        /*
        题目：2*8如何运算才最快？
        思路：2*8 = 2*2*2*2
        0000 0000       0
        0000 0001       1
        0000 0010       2
        0000 0011       3
        0000 0100       4
        0000 1000       8
        0001 0000       16
        <<为左移，每次左移等同于数值*2，但效率极高
        >>为右移，每次右移等同于数值/2，但效率极高
         */
        System.out.println(2<<3);       //输出16
    }
}

赋值运算符

示例：

package operator;

public class Demo05 {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        a += b;                     //等同于a = a + b;
        System.out.println(a);      //输出20
        a -= b;                     //等同于a = a - b;
        System.out.println(a);      //输出10
        a *= b;                     //等同于a = a * b;
        System.out.println(a);      //输出100
        a /= b;                     //等同于a = a / b;
        System.out.println(a);      //输出10
    }
}

条件运算符

示例：

package operator;

public class Demo06 {
    public static void main(String[] args) {
        //条件运算符  a ? b : c
        //如果a为true，则执行b，否则执行c
        int score = 50;
        String mark = score>=60 ? "及格" : "不及格";
        System.out.println(mark);       //输出"不及格"
    }
}

本文系转载，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

java

本文系转载，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

java

登录后参与评论

0 条评论

热度