02 Java 基础语法学习笔记

Java 基础语法

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

1. 注释

【单行注释】：

//单行注释

【多行注释】：

/*
多行注释
 */

【文档注释】：

/**
 * @Description 文档注释
 * @Author 作者
 */

2. 标识符和关键字

【关键字】：由系统定义的字符，用户不能使用
例如：[Hello World] 项目文件中的public class static void ( 注意：' String ' 不是关键字，而是类 )

【标识符】：用户定义的类名、方法名、变量名
例如：[Hello World] 程序中的类名Hello

  • 标识符应该以字母(A-Z 或 a-z)、美元符($)、或下划线( _ )开始
  • 首字符之后，可以有数字
  • 大小写敏感
  • 不能使用关键字
  • 可以使用中文，但不建议，也不建议直接使用中文拼音

二、数据类型

1. 基本数据类型

【整数类型】：
byte 占1个字节：[-128 ~ 127]
short 占2个字节：[-32768 ~ 32767]
int 占4个字节：[-2147483648 ~ 2147483647]
long 占8个字节：[-(2^64/2) ~ 2^64/2-1] （ 数字后面需要加上 ' L ' ）

【浮点类型】：
float 占4个字节 （ 数字后面需要加上 ' F ' 或 ' f ' ）
double 占8个字节

【字符类型】：
char 占2个字节(Byte)

【布尔类型】：
boolean 占1位(bit) [ true | false ]

< ----- 【 示例 】 ----- >

        //整数
        byte num1 = 50;
        short num2 = 100;
        int num3 = 800; //常用
        long num4 = 60L; //在数字后面加上 L

        //浮点数（小数）
        float num5 = 33.3F; //在后面加上 F
        double num6 = 3.1415926;

        //字符
        char sex = '男'; //注意只占2个字节，最多表示一个汉字

        //布尔(是非)
        boolean flag = true;

2. 引用数据类型

  • 类：String
  • 接口：
  • 数组：

3. 数据类型扩展

        // 整数扩展：【进制】，0b 表示二进制, 0 表示八进制，0x 表示十六进制
        int a = 10;
        int b = 010;  // 0 八进制
        int c = 0x10;  // 0x 十六进制
        System.out.println(a);  //输出结果：10
        System.out.println(b);  //输出结果：8
        System.out.println(c);  //输出结果：16

        // 浮点数扩展，【浮点数类型】表示的位数有限，会存在误差，不建议用浮点数进行比较。
        // 数据量太大，需要是用BigDecimal类，比如银行业务
        float f = 0.1f;
        double d = 1.0/10;
        System.out.println(f==d);  //输出结果：false
        System.out.println(f);     //输出结果：0.1
        System.out.println(d);     //输出结果：0.1

        float f1 = 314159265358978f;
        double d1 = f1 + 1;
        System.out.println(f1==d1);  //输出结果：true

        // 字符类型扩展，字符本质是数字，Unicode编码
        char c1 = 'A';
        char c2 = '中';
        char c3 = '\u0061';
        System.out.println(c1);         //输出结果：A
        System.out.println((int)c1);    //输出结果：65
        System.out.println(c2);         //输出结果：中
        System.out.println((int)c2);    //输出结果：20013
        System.out.println(c3);         //输出结果：a

        // 转义字符，\t 表示制表位，\n 表示换行
        System.out.println("Hello\tWorld!");
        System.out.println("Hello\nWorld!");

        // 布尔值扩展，
        boolean flag = true;
        if(flag){}  // 相当于 if(flag==true){}

三、类型转换

1. 运算中，不同类型的数据需要先转换成同一类型，再进行运算

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

  • 强制类型转换：从高到低转换
  • 自动类型转换：从低到高转换
        // 强制转换：由高到低转换。格式：(类型)变量名
        int i = 128;
        byte b = (byte)i;  //内存溢出（-128 ~ 127）
        System.out.println(i);  //输出结果：128
        System.out.println(b);  //输出结果：-128

        // 自动转换：由低到高转换。
        double d = i;
        System.out.println(d);  //输出结果：128.0

        // 字符转换
        char c = 'a';
        int t = c + 1;
        System.out.println(t);          //输出结果：98
        System.out.println((char)t);    //输出结果：b

2. 注意事项

  • 不能对布尔类型 boolean 进行转换
  • 不能转换为不相干的类型
  • 转换的时候可能存在内存溢出，或精度问题
        // 精度问题
        System.out.println((int)23.7);  //输出结果：23
        System.out.println((int)-45.89f);  //输出结果：-45

        // 内存溢出问题
        int money = 10_0000_0000;  //数字之间可以使用下划线分割
        int year = 20;
        int total = money * year;   //内存溢出
        System.out.println(money);  //输出结果：1000000000
        System.out.println(total);  //输出结果：-1474836480

        long sum1 = money * year;    //计算之前是int，结果已经溢出，再赋值给sum1
        System.out.println(sum1);    //输出结果：-1474836480

        long sum2 = money * (long)year; //计算之前进行类型转换
        System.out.println(sum2);   //输出结果：20000000000

四、变量、常量、作用域

1. 变量是什么

  • 变量是可以变化的量，每个变量都必须申明类型。
  • 变量是程序中最基本的存储单元，其要素包括：变量名、变量类型和作用域。
  • 每个变量都有类型，可以是基本类型，也可以是引用类型
  • 变量名必须是合法的标识符
  • 变量申明是一条完整的语句，必须以分号结束

< ----- 示例 ----- >

        int a = 1;
        String name = "admin";  //注意，首字母 'S' 是大写
        char c = 'x';
        double pi = 3.14;

2. 变量的作用域

  • 【类变量】：
    写在类下面，有关键字static申明，在方法中可以直接使用。

  • 【实例变量】：
    写在类下面，没有 'static' 关键字，实例变量从属于对象，可以不初始化值。
    如果不初始化，数值类型默认值：0或0.0，布尔类型默认：flase，其他类型默认值：null。
    要在方法中使用实例变量，需要使用 new 申明，变量类型就是类的名称。

  • 【局部变量】：
    写在方法中，必须申明和初始化值，只能在方法自身里面使用。

public class demo5 {
    // 类变量
    static double salary = 2500;    // 类变量，使用关键字static申明

    // 实例变量：可以不初始化值，数值类型默认值：0或0.0，布尔类型默认：flase，其他类型默认值：null
    int age;
    String name;

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

        // 在方法中使用实例变量
        demo5 demo5 = new demo5();      // 变量类型：demo5，变量名：demo5，值(类自身)：new demo5()

        System.out.println(demo5.age);  // 实例变量不能直接输出，输出结果：0
        System.out.println(demo5.name); // 输出实例变量，输出结果：null

        System.out.println(salary);     // 类变量可以直接输出，输出结果：2500.0
    }

    // 其他方法
    public void add(){

    }
}

3. 常量

使用 final 关键字进行申明，常量的名称使用大写字母表示，常量初始化后，值始终固定不变。

public class demo06 {
    // 常量，使用关键字final，修饰符之间没有顺序区分
    static final double PI = 3.14;  // final可以在static后面
    final static double P = 3.14;   // final也可以在static前面

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

4. 变量的命名规范

  • 所有的变量名、类名、方法名，都要有意义，见名知意
  • 类变量/实例变量/局部变量：首字母小写 + 驼峰原则（monthSalary）
  • 常量：使用大写字母或下划线（MAX_VALUE）
  • 类名：首字母大写 + 驼峰原则（HelloWorld）
  • 方法名：首字母小写 + 驼峰原则（mainPrint）

五、运算符

  • 【算术运算符】： + ，- ，* ，/ ，% ，++ ，--

  • 【赋值运算符】： =

  • 【关系运算符】： > , < , >= , <= , == , != , instanceof

  • 【逻辑运算符】： && ，|| ，！

  • 【位运算符】： & , | , ^ , ~ , >> , << , >>> （了解即可）

  • 【条件运算符】： ? :

  • 【扩展位运算符】： += , -= , *= , /=

1. 基本运算符

        // 二元运算符
        // IDEA 快捷键，ctrl + D 复制当前行到下一行
        int a = 10;
        int b = 25;

        System.out.println(a+b);        // 输出结果：35
        System.out.println(a-b);        // 输出结果：-15
        System.out.println(a*b);        // 输出结果：250
        System.out.println(a/b);        // 输出结果：0，int只保留小数点前面的数
        System.out.println(a/(double)b);    // 转换其中一个为小数类型，正确的输出结果：0.4
        System.out.println(b%a);    // 取余，输出结果：5

        // 运算结果的类型：
        long c = 123456789L;
        int d = 12345;
        short e = 126;
        byte f = 8;
        double g = 3.14;
        // 如果有long类型参与计算，结果为long类型，如果有double参与计算，结果为double类型
        // 其它都为int类型
        System.out.println(c+d+e+f);    // 输出结果：123469268 （long 类型）
        System.out.println(d+e+f);      // 输出结果：12479 （int 类型）
        System.out.println(e+f);        // 输出结果：134 （int 类型）
        System.out.println(c+d+g);        // 输出结果：1.2346913714E8 （double 类型）

        // 关系运算符：返回布尔结果 true false ，主要用于判断语句
        int i = 10;
        int j = 20;
        System.out.println(i>j);    // 输出结果：false
        System.out.println(i<j);    // 输出结果：true
        System.out.println(i==j);   // 输出结果：false
        System.out.println(i!=j);   // 输出结果：true

2. 自增自减运算符和 Math 类

        // 一元运算符：自增自减
        int k = 3;
        int m = k++;    // 先赋值给m，k再加1
        System.out.println(k);  // 输出结果：4
        System.out.println(m);  // 输出结果：3

        int n = ++k;    // k先加1，再赋值给n
        System.out.println(k);  // 输出结果：5
        System.out.println(n);  // 输出结果：5

        // 数学公式：Math类，比如幂运算
        double pow = Math.pow(2,3); // 2^3 2*2*2=8，此处必须用double类型
        System.out.println(pow);    // 输出结果：8.0

3. 逻辑运算符和位运算符

        // 逻辑运算符：与(and)、或(or)、非(取反)
        boolean a = true;
        boolean b = false;
        System.out.println("a&&b="+(a&&b));     // 逻辑与：两个都为真，结果才为真。输出结果a&&b=false
        System.out.println("a||b="+(a||b));     // 逻辑或：两个有一个为真，结果就为真，输出结果a||b=true
        System.out.println("!(a&&b)="+!(a&&b)); // 逻辑非：如果为真，则结果为假，如果为假，则结果为真，输出结果!(a&&b)=true

        // 短路运算，语句前面部分判断为假后，后面部分不再运行
        int c = 5;
        boolean d = (c<4)&&(c++>4); // 前面(c<4)判断为false，短路，不再运行后面(c++>4)
        System.out.println(c);  // 输出结果：5，（没有运行c++，所以c还是5）
        System.out.println(d);  // 输出结果：false

        // 位运算
        /*
        A = 0011 1100
        B = 0000 1101

        A&B = 0000 1100     // 位与：两个位都为1，结果为1，否则为0
        A|B = 0011 1101     // 位或：两个位都为0，结果为0，否则为1
        A^B = 0011 0001     // 位异或：两个位相同则为0，不相同则为1
        ~B = 1111 0010      // 位取反：0变为1，1变为0
         */

        // 位运算效率极高，2*8 = 2*2*2*2 = 16
        System.out.println(2<<3);   // 输出结果：16

        /*
        << 左移：乘以2
        >> 右移：除以2
        0000 0001 = 1
        0000 0010 = 2
        0000 0100 = 4
        0000 1000 = 8
        0001 0000 = 16
         */

4. 三元运算符

        // 三元运算符：x ? y : z ，如果 x 为 true，则结果为 y，否则为 z
        int score = 80;
        String type = score<60 ? "不及格":"及格";
        System.out.println(type);   // 输出结果：及格

5. 其他算符

        // += 和 -= 运算符
        int a = 10;
        int b = 20;
        a+=b;   // a=a+b=30
        a-=b;   // a=a-b=10
        System.out.println(a);  // 输出结果：10

        // 字符串连接符：+
        System.out.println(a+b+""); // 输出结果：30，字符串在后面，前面的+是运算符
        System.out.println(""+a+b); // 输出结果：1020，字符串在前面，后面的+就是连接符

六、包机制、JavaDoc

1. 包机制

  • 包机制是为了更好的组织类，用于区别类名的命名空间 。（和文件夹的功能类似）
  • 语法格式：package pkg1[.pkg2[.pkg...]] ; （一般用公司域名倒置作为包名，com.baidu.www ）
  • 使用 'import' 导入其他包中的文件：import pkg1[.pkg2[.pkg...]].(classname|*) ;

2. 在IDEA中新建一个包：'com.baidu.www'

输入包名：'com.baidu.www'

可以看到文件夹目录结构：'com\baidu\www'

再新建一个包：'com.baidu.wenku'

目录结构如下，'wenku' 和 'www' 都在 'baidu' 中

在包中新建一个java文件，会自动加上包的定义

package com.baidu.www;

public class demo02 {
}

3. 'import' 导入其他的包

package com.baidu.www;

import java.util.Date;  // import 必须在 package 下方

public class demo01 {
    Date    // 要使用Date，必须导入java系统中的Date包
}

package com.baidu.www;

import com.baidu.wenku.*;       // 用星号代表导入包下所有文件
import com.baidu.wenku.demo03;  // 导入包中具体的文件

public class demo02 {
    
}

4. JavaDoc 文档注释

javadoc 用来将注释信息生成自己的 API 帮助文档

【 参数 】：

/**
 * @author      // 作者名
 * @version     // 版本号
 * @since       // 要求最低JDK版本
 * @param       // 参数名
 * @return      // 返回值情况
 * @throws      // 异常抛出情况
 */

< ----- 示例 -- [ operator包下的Doc.java文件 ] ----- >

package operator;

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

    /**
     * 
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
}

5. 通过 CMD 终端命令 'javadoc' 生成 API 文档

  • 在需要生成 API 文档的 java 项目所在目录，打开 CMD 终端

  • 运行命令：'javadoc'，（' -encoding UTF-8 -charset UTF-8 ' 是为了让文档支持中文格式，' Doc.java '是目录中带文档注释的java项目文件）
D:\Java\code\Hello\src\operator>javadoc -encoding UTF-8 -charset UTF-8 Doc.java

  • 在项目目录下，会生成很多 'html' 文件

  • 打开 'index.html' 文件，可以看到和官方API文档类似

  • 当然，也可以使用IDEA生成javadoc文档

打开IDEA上方工具（Tools）,生成JavaDoc文档（Generate JavaDoc）

JavaSE 8 API 帮助文档：https://docs.oracle.com/javase/8/docs/api/
参照学习：https://www.kuangstudy.com
另外，建议Java基础学习可以详细阅读《 阿里巴巴 Java 开发手册 》（主要介绍编程规范，写出高质量的代码）

posted @ 2022-09-12 17:16  红妹妹  阅读(46)  评论(0)    收藏  举报