02-Java基本语法

一、注释、标识符、关键字

1.1 注释

  • 被注释的内容不会被执行

  • 注释可以帮助我们在读取别人的代码的同时更快的理解代码的逻辑

  • 要养成写注释的好习惯

  • JAVA中的注释有三种：

    • 单行注释
    • 多行注释
    • 文档注释
  • 单行注释：
public class HelloWorld {
    public static void main(String[] args) {
        //单行注释使用“//”
        //输出hello world
        System.out.println("Hello world!");
    }
}
  • 多行注释
public class HelloWorld {
    public static void main(String[] args) {
        //多行注释使用“/* 注释 */”
        /*
        	输出hello world
        */
        System.out.println("Hello world!");
    }
}
  • 文档注释
public class HelloWorld {
    public static void main(String[] args) {
        //JavaDoc:文档注释 /***/
        /**
         * @Description Hello world
         * @Author 从不喝奶茶
         */
        System.out.println("Hello world!");
    }
}

1.2 标识符

  • 关键字

  • 关于 Java 标识符，有以下几点需要注意：

    • 所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（）开始
    • 首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（）或数字的任何字符组合
    • 不能使用关键字作为变量名或方法名。
    • 标识符是大小写敏感的
    • 合法标识符举例：age、$salary、_value、__1_value
    • 非法标识符举例：123abc、-salary、#abc

二、数据类型

​ Java是一种强类型语言，每个变量都必须声明器类型

​ Java的数据类型分为两大类：基本类（primitive type）和引用类型（reference type）。

​ 各种类型的取值范围在JDK中类型对应的包装类都帮忙写好了，需要的时候可以直接查询到

public class DataType {
    public static void main(String[] args) {

        //Byte 是byte的包装类
        System.out.println("基本类型：byte二进制位数：" + Byte.SIZE);
        System.out.println("包装类： java.lang.Byte");
        System.out.println("最小值： Byte.MIN_VALUE = " + Byte.MIN_VALUE);
        System.out.println("最大值： Byte.MAX_VALUE = " + Byte.MAX_VALUE);

        //Short 是short的包装类
        System.out.println("基本类型：short 二进制位数：" + Short.SIZE);
        System.out.println("包装类：java.lang.Short");
        System.out.println("最小值：Short.MIN_VALUE = " + Short.MIN_VALUE);
        System.out.println("最大值：Short.MAX_VALUE = " + Short.MAX_VALUE);

        //Integer 是int的包装类
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);
        System.out.println("包装类：java.lang.Integer");
        System.out.println("最小值：Integer.MIN_VALUE = " + Integer.MIN_VALUE);
        System.out.println("最大值：Integer.MAX_VALUE = " + Integer.MAX_VALUE);

        //Long 是long的包装类
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);
        System.out.println("包装类：java.lang.Long");
        System.out.println("最小值：Long.MIN_VALUE = " + Long.MIN_VALUE);
        System.out.println("最大值：Long.MAX_VALUE = " + Long.MAX_VALUE);

        //Float 是float的包装类
        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);
        System.out.println("包装类：java.lang.Float");
        System.out.println("最小值：Float.MIN_VALUE = " + Float.MIN_VALUE);
        System.out.println("最大值：Float.MAX_VALUE = " + Float.MAX_VALUE);

        //Double 是Double的包装类
        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);
        System.out.println("包装类：java.lang.Double");
        System.out.println("最小值：Double.MIN_VALUE = " + Double.MIN_VALUE);
        System.out.println("最大值：Double.MAX_VALUE = " + Double.MAX_VALUE);

        //Character 是char的包装类
        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);
        System.out.println("包装类：java.lang.Character");
        System.out.println("最小值：Character.MIN_VALUE = " + (int)Character.MIN_VALUE);
        System.out.println("最大值：Character.MAX_VALUE = " + (int)Character.MAX_VALUE);
    }
}

不同编码格式中字符占用的位数拓展：

ASCIIS码：
1个英文字母（不分大小写）= 1个字节的空间
1个中文汉字 = 2个字节的空间
1个ASCII码 = 一个字节

UTF-8编码：
1个英文字符 = 1个字节
英文标点 = 1个字节
1个中文（含繁体） = 3个字节
中文标点 = 3个字节

Unicode编码：
1个英文字符 = 2个字节
英文标点 = 2个字节
1个中文（含繁体） = 2个字节
中文标点 = 2个字节

1bit表示1位，
1Byte表示1个字节 1B=8b。
1024B=1KB
1024KB=1M
1024M=1G

​ 这些数据类型进行赋值。

public class DataType {
    public static void main(String[] args) {
        //整数
        int num1 = 10;
        byte num2 = 20;
        short num3 = 30;
        long num4 = 40L; //long类型要在数字后面加个L

        //浮点数
        float num5 = 20.1F;  //float类型要在数字后面加个F
        double num6 = 3.1415926;
        //字符
        char name = '国';  //单引号
        //String是类，不是java的关键字
        //String namea = "abc"

        //boolean
        boolean flag = true;
    }
}

2.1 整数拓展

十进制、八进制、十六进制在计算机中的表达方式

十进制整数，如：99，-500,0

八进制整数，要求以0开头，如：015

十六进制整数，要求0x或0X开头，如：0x15

举例：

int i = 10;
int i2 = 010;
int i3 = 0x10;
System.out.println(i); //10
System.out.println(i2); //8
System.out.println(i3); //16

2.2 浮点型拓展

  • 【面试题】
    • 银行金融业务用什么类型表示？

浮点型float和double存在舍入的特点，而金融行业不允许舍入误差，在不允许舍入的情况下，需要使用BigDecimal类。

public class Demo01 {
    public static void main(String[] args) {
        float f = 0.1f;
        double d = 1.0 / 10;

        System.out.println(f == d); //false

        float d1 = 213231321312f;
        float d2 = d1 + 1;
        if (d1 == d2){
            System.out.println("d1 == d2");
        }else{
            System.out.println("d1 != d2");
        }
    }
}

【原因】：

​ 字长有限，浮点数能够精确表示的数有限，因而也是离散的，浮点数一般都存在舍入误差，很多数字无法精确表示；二进制浮点数不能精确表示0.1,0.001，这种10的负次幂。

最好完全避免使用浮点数进行比较

  • 大数值
    • Java.math下面的两个有用的类：BigInteger和BigDecimal，这两个类可以处理任意长度的数值。BigInteger实现了任意精度的整数运算。BigDecimal实现了任意精度的浮点运算。

2.3 字符型拓展

单引号用来表示字符常量。例如'A'与"A"是不同的，"A"表示的是一个字符串。

char类型用来表示Unicode编码表中的字符。

Unicode编码被设计用来处理各种语言的所有文字，占用2个字节，65536个字符

将字符转换成int的变量，可以查看到相应的字符在unicode中对应关系

public static void main(String[] args) {
    char c1 = 'a';
    char c2 = '中';
    System.out.println(c1);
    System.out.println((int) c1); //97
    System.out.println(c2);
    System.out.println((int) c2); //20013
}

使用Unicode表示字符：

char c3 = '\u0061';
System.out.println(c3)
  • 转义符
符号 描述 对应的Unicode
\b 退格（Backspace） \u0008
\n 换行 \u000a
\r 回车 \u000d
\t 制表符 \u0009
\" 双引号 \u0022
\' 单引号 \u0027
\\ 反斜杠 \u005c
  • 思考
//代码1
String sa=new String("Hello world");
String sb=new String("Hello world");
System.out.println(sa==sb); // false
//代码2
String sc="Hello world";
String sd="Hello world";
System.out.println(sc==sd); // true

2.4 布尔类型拓展

布尔类型中不可以使用0和 非0数字来替换true和false

boolean flag = false;
if(flag){
// true分支
}else{
// false分支
}

三、类型转换

运算中，不同类型的数据先转换成相同类型的数据，然后再进行运算

转换从低级--->高级（根据容量排序）

低 ---------------------------------------------> 高
byte,short,char -> int -> long -> float -> double

数据类型转换必须满足如下规则：

  • 不能对boolean类型进行类型转换

  • 不能把对象类型转换成不相关类的对象

  • 在把容量大的类型转换为容量小的类型时必须使用强制类型转换

  • 转换过程中可能导致溢出或损失精度，例如：

    • int i = 128;
byte b = (byte)i;
System.out.println(b); //-128  byte的容量范围是-128-127，大容量转换成小容量发生了内存溢出

  • 浮点数到整数的过程是通过舍弃小数得到的，不是四舍五入

    • (int)23.7 == 23;
(int)-45.7 == -45;

3.1 自动类型转换

容量小的数据类型可以自动转换成容量大的数据类型

public class Demo02 {
    public static void main(String[] args) {
        int i = 128;
        double d = i;
        System.out.println(d);
    }
}

3.2 强制类型转换

强制类型转换，又被称为造型，用于显式的转换一个数值的类型

这种转换方式有可能造成精度的降低或者溢出的情况。

语法格式：(type)var

public class Demo02 {
    public static void main(String[] args) {
        double d = 128;
        int i = (int)d;
        System.out.println(i);
    }
}

3.3 常见错误

  1. 操作比较大的数的时候，要注意是否溢出
public class Demo02 {
    public static void main(String[] args) {
        int money = 10_0000_0000;
        int years = 20;
        int total = money * years;
        System.out.println(total); //发生了溢出  -1474836480

        long total1 = money * years;
        System.out.println(total1); //-1474836480  money和years都是int  进行运算的时候先通过int进行运算，计算出来的结果是int类型然后再将结果转换成long

        long total2 = money * ((long)years);
        System.out.println(total2);  //20000000000 正确
    }
}
  1. L和l的问题：
  • 不要命名名字为l的变量
  • long类型使用大写L不要用小写

3.4 JDK新增特性

  • JDK新特性：二进制整数

    • 用ob开头表示的就是二进制整数类型

  • JDK新特性：下划线分隔符

    • int b = 10_0000_0000

    • 这样可以方便我们阅读比较大的数值

四、变量、常量

4.1 变量

​ 通过变量控制存储空间中的数据，变量就是指代这个存储空间，空间位置确定，但是里面存放的内容不确定。

​ Java是强类型语言，每个变量都必须声明其类型

​ 变量在使用前必须对其声明，只有在声明变量名称后，才能为其分配相应长度的存储单元。

type varName [= value];
//数据类型  变量名称  = 值; 可以使用逗号隔开来声明多个同类型变量（不建议在一行中同时声明多个变量）

注意事项：

  • 每个变量都有类型，类型可以是基本类型，也可以是引用类型
  • 变量名称必须合法
  • 变量声明是一个完整的语句，每一个声明都必须用分号结尾
int a;
int b = 1, c = 2, d = 3; //不推荐
byte z = 22;
String s = "java";
char ch = 'J';
double pi = 3.1415;

4.2 变量的作用域

  • 类变量（静态变量：static variable）：独立于方法之外的变量，用static修饰。可以直接在类中调用
  • 实例变量（成员变量：member variable）：独立于方法之外的变量，不过没有static修饰。通过实例调用
  • 局部变量（local variable）：类的方法中的变量。
public class Variable{
    
    static int salary = 2000; //类变量
    
    int age;  //实例变量
    String name = "java"
    
    public static void main(String args){
        int a = 100; //局部变量
    }
}

4.2.1 局部变量

​ 方法或语句块内部定义的变量，生命周期是从声明位置开始到“}”结束。

​ 局部变量没有默认值，所以在使用前必须声明和初始化才可以使用

public class Demo01{
    public static void main(String[] args){
        int i = 10;
        int j = i + 5;
        System.out.println(j);
    }
}

4.2.2 实例变量

​ 方法外部，类内部定义的变量

​ 从属于实例，生命周期伴随对象始终。

​ 如果不自行初始化，他会自动初始化成该类型的默认初始值。（数值类型的初始值为0或0.0，字符型变量的初始化值是16位的0，string的初始值为null，布尔型默认为false）

public class Test{
    
    int age;
    String name;
    
    public static void main(String[] args){
        // 只能通过声明实例来调用实例变量中的值
        Test test = new Test();
        System.out.println(test.age);
        System.out.println(test.name);
    }
}

4.2.3 静态变量

​ 使用static定义，从属于类，生命周期伴随类始终，从类加载到卸载。

public class Test{
    static salary = 2000;
    public static void main(String[] args){
        System.out.println(salary);//可以在类中直接调用
    }
}

4.3 常量

​ 常量（Constant）：初始化（initialize）后不能再改变值！

public class Test{
    
    //static 和 final 是修饰符，不存在先后顺序
    static final double PI = 3.14;
    
    public static void main(String[] args){
        System.out.println(PI);
    }
}

4.4 变量命名规则

  1. 所有变量、方法、类名：见名知意
  2. 类成员变量：首字母小写和驼峰原则 : monthSalary
  3. 局部变量：首字母小写和驼峰原则
  4. 常量：大写字母和下划线：MAX_VALUE
  5. 类名：首字母大写和驼峰原则: Man, GoodMan
  6. 方法名：首字母小写和驼峰原则: run(), runRun()

五、运算符

Java 语言支持如下运算符：

  • 算术运算符: +，-，*，/，%，++，--
  • 赋值运算符 =
  • 关系运算符: >，<，>=，<=，==，!= instanceof
  • 逻辑运算符: &&，||，!
  • 位运算符: &，|，^，~ ， >>，<<，>>> (了解！！！)
  • 条件运算符 ？：
  • 扩展赋值运算符:+=，-=，*=，/=

5.1 二元运算符

public class Demo01 {
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        int c = 30;
        System.out.println("a + b = " + (a + b));
    }
}
  • 整数运算，如果两个操作数中有一个是Long类型，那么结果也是long类型，没有long均为int。
public class Demo01 {
    public static void main(String[] args) {
        long a = 1231321311231231L;
        int b = 1213;
        short c = 10;
        byte d = 8;
        System.out.println((a+b+c+d)); //Long类型
        System.out.println((b + c + d));//Int类型
        System.out.println((c + d));//Int类型
    }
}
  • 浮点运算，如果两个操作数有一个为double类型，那么结果为double，两个都是float类型，结果才是float类型
public class Demo01{
    public static void main(String[] args) {
        float a = 3.14565F;
        double b = 3.194546464;
        float c = 1.3123123F;
        System.out.println(a+b); //double类型
        System.out.println(b+c); //double类型
        System.out.println(a+c); //float类型
    }
}
  • 关系运算符
运算符 描述 例子
== 检查如果两个操作数的值是否相等，如果相等返回true A == B
!= 检查如果两个操作数的值是否不相等，不相等的话返回true A != B
> 检查左操作数的值是否大于右操作数，如果大于返回true A > B
< 检查左操作数的值是否小于右操作数，如果小于返回true A < B
>= 检查左操作数的值是否大于等于右操作数，如果大于等于返回true A >= B
<= 检查左操作数的值是否小于等于右操作数，如果小于等于返回true A <= B

5.2 取模运算

%此符号是取模的符号，代表两个操作数相除取余。

public class Demo01{
    public static void main(String[] args) {
        System.out.println(9 % 4); //1
        System.out.println(-9 % -4); //-1
        System.out.println(-10 % 4); //-2
        System.out.println(9 % -4); //1
    }
}

5.3 一元运算符

​ 自增（++），自减（--）运算符，是一种特殊的运算符，这两种方式分为前缀和后缀两种。

public class Demo01{
    public static void main(String[] args[]){
        int a = 3;
        int b = a++; //先将a的值赋值给了b，然后再进行+1操作
        int c = ++a; //a先进行+1操作，然后将结果赋值给c
        
        System.out.println(a); //5
        System.out.println(b); //3
        System.out.println(c); //5
    }
}
  • java中乘幂的操作
public class Demo01{
    public static void main(String[] args){
        int a = 3^2;//报错，java中不支持这种操作
        double b = Math.pow(2, 3); 
    }
}

5.4 逻辑运算符

操作符 描述 例子
&& 称为逻辑与运算符，当且仅当两个操作数都为真，条件才为真 A && B
|| 称为逻辑或操作符，当且仅当两个操作数都为假，条件才为假 A || B
！ 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。 !(A && B) 
public static void main(String[] args) {
    boolean a = true;
    boolean b = false;
    System.out.println("a && b = " + (a&&b));
    System.out.println("a || b = " + (a||b) );
    System.out.println("!(a && b) = " + !(a && b));
}
  • 短路方式

​ 逻辑与和逻辑或采用的时短路方式。

​ 逻辑与一旦发现第一个值为false，该表达式返回的值就是false，不再对第二个操作数进行判断。

​ 逻辑或一旦发现第一个值为true，该表达式返回的值就是true，不再对第二个操作数进行判断。

public static void main(String[] args){
    int a = 5;//定义一个变量；
    boolean b = (a<4)&&(a++<10);
    System.out.println("使用短路逻辑运算符的结果为"+b); //false
    System.out.println("a的结果为"+a); //5
}

5.5 位运算

操作符 描述 例子
& 如果相对应位都是1，则结果为1，否则为0 (A&B)，得到12，即0000 1100
| 如果相对应位都是0，则结果为0，否则为1 (A I B) 得到61，即0011 1101
^ 按位取反运算符，翻转操作数的每一位，即0变成1，1变成0 (-A)得到-61，即1100 0011
<< 按位左移运算符，左操作数接位左移右操作数指定的位数 2 << 3 等于 16
>> 按位右移运算符，左操作数按位右移右操作数指定的位教 2 >> 1 等于 1
>>> 按位右移补零操作符。左操作数的值按右操作数指定的位做右移，移动得到的空位以零填充 A>>>2得到15即0000 1111

右移一位相当于除2取商。

【面试题】

​ int a=2*8怎样运算效率最快？

public static void main(String[] args) {
	System.out.println(2 << 3);
}

5.6 扩展运算符

运算符 用法举例 等效的表达式
+= a += b a = a + b
-= a -= b a = a - b
*= a *= b a = a * b
/= a /= b a = a / b
%/ a %= b a = a % b

5.7 字符串连接符

“+” 运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串然后再进行连接

String s1 = "hello java!";
int a = 1;
int b = 2;
System.out.println((s1+a+b)); //hello java!12
System.out.println((a+b)+s1); //3hello java!

5.8 三元运算符

x ? y : z

​ 如果x为true的话，返回y，x为false的话返回z

public static void main(String[] args) {
    int score = 80;
    String type = score < 60 ? "不及格" : "及格";
    System.out.println("type= " + type); //不及格
}

5.9 运算优先级

​ 表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。

	public static void main(String[] args) {
        boolean flag = 1<4*5&&122>3||'q'+3<5;
        System.out.println(flag); // true
    }

六、包机制

​ 解决了在开发阶段类名出现重复的问题。

包的作用：

  1. 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
  2. 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类
    的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可
    以避免名字冲突。
  3. 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

  • 包语句的语法格式：

    • package pkg1[.pkg2[.pkg3]]

    • package net.java.util;
public class something{
    ....
}

    • 如果有类要调用上面文件中的something类，import net.java.util.something

  • 创建包

    • 包的声明应该放在源文件的第一行，每个源文件只能有一个包声明，这个文件中的每个类型都应用于它。
    • 如果一个源文件中没有使用包的声明，那么其中的类，函数，枚举，注释等将被放在一个无名的包（unnamed package）中。
    • 一般利用公司域名倒置作为包名：
      • www.baidu.com的包名com.baidu.www
      • bbs.baidu.com的包名com.baidu.bbs

  • import关键字

    • 为了能够使用某一个包的成员，我们需要在java程序中明确导入该包。
    • 语法格式：import package1[.package2[...]].(classname|*)
    • 调用本包中的类，包名可以省略
    • 如果有两个重名的类需要导入：com.base.Hello hello = new com.base.Hello()
    • *通配符，这样代表导入相应包中的所有类
    • 【注意】：类文件中可以包含任意数量的 import 声明。import 声明必须在包声明之后，类声明之前。

【编码规范】：https://files-cdn.cnblogs.com/files/han-1034683568/阿里巴巴Java开发手册终极版v1.3.0.pdf

七、JavaDoc

​ javadoc是Sun公司提供的一个技术，它从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档。也就是说，只要在编写程序时以一套特定的标签作注释，在程序编写完成后，通过Javadoc就可以同时形成程序的开发文档了。javadoc命令是用来生成自己API文档的，使用方式：使用命令行在目标文件所在目录输入javadoc +文件名.java。

package com.haining.base;

/**
 * @author java
 * @since jdk 1.8
 * @version 1.0
 */
public class Doc {
    
    public String name;

    /**
     * 
     * @param name 姓名
     * @return 返回name姓名
     * @throws Exception 无异常抛出
     */
    public String function(String name) throws Exception{
        return name;
    }
    
}

以 /* 开始，以 / 结束。
@author 作者名
@version 版本号
@since 指明需要最早使用的jdk版本
@param 参数名
@return 返回值情况
@throws 异常抛出情况

  • 命令行生成Doc
//-encoding 和 -charset 解决GBK乱码的问题，在中间添加编码设置
javadoc -encoding UTF-8 -charset UTF-8 Doc.java
posted @   Coilin  阅读(25)  评论(0)  编辑  收藏  举报
相关博文：
·  03-Java流程控制
·  06-JavaSE：面向对象编程
·  Java基础语法
·  3.Java基础语法
·  Java基础语法
阅读排行：
· 阿里巴巴 QwQ-32B真的超越了 DeepSeek R-1吗？
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
· 【设计模式】告别冗长if-else语句：使用策略模式优化代码结构
· 字符编码：从基础到乱码解决
· 提示词工程——AI应用必不可少的技术
点击右上角即可分享
微信分享提示
AI IDE Trae