Java的基础知识，包括有①注释、标识符&关键字；②数据类型；③类型转换；④变量、常量；⑤运算符；⑥包机制、JavaDoc。还有一些比较细的知识点，温故而知新，面试的时候可能会问到。基础得扎实！

---

1、注释、标识符&关键字

1.1注释

平时写代码，如果代码量少的时候，还是可以看懂的，但是当项目结构一旦复杂起来，就需要用到注释了。和其他语言一样，注释并不会被执行。写注释可是一个好习惯，提高代码的可读性和移植性。

• 注释有三种

  • 单行注释
  • 多行注释
  • 文档注释

  public class HelloWorld {
      public static void main(String[] args) {
          System.out.println("Hello, World!");
          // 单行注释：只能注释一行
          // 输出一个Hello，World
          
          // 多行注释：能注释多行     /*  注释 */
          /*
          我想玩游戏
          我想玩地平线4
           */
  
          // JavaDoc：文档注释     /**     */
          /**
           * @Description HelloWorld
           * @Author Hammer
           */
      }
  }

1.2标识符&关键字

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

  下图是Java里全部的关键字，在起名字的时候，不能以他们来命名

注意点：

• 所有的标识符都应该以字母，美元符，或者下划线开头
• 首字符之后可以是任意字符组合
• 标识符是大小写敏感的

2、数据类型

• 强类型语言
  • 要求变量的使用要严格符合规定，所有变量都必须先定义以后才能使用，不像python
• Java的数据类型
  • 基本类型（primitive type）
  • 引用类型（reference type）

// 八大数据类型

//整数
int num1 = 10;
byte num2 = 26;
short num3 = 30;
long num4 = 30L;    // long类型要在后面加个“L”

// 浮点数
float num5 = 11F;   // float类型要在后面加个“F”
double num6 = 3.141526;

// 字符
char name = 'A';    // 这个char类型是单引号
String b = "num";

// 布尔值
boolean flag = true;    // true or false

浮点数拓展

思考一个问题，银行业务里的钱是用哪个类型处理的？

public class Demo03 {
    public static void main(String[] args) {
        float f = 0.1f;		// 0.1
        double d = 1.0/10;	// 0.1
        System.out.println(f);
        System.out.println(d);
        
        System.out.println(f==d);	// flase

        float d1 = 23256654411132f;
        float d2 = d1 + 1;
        
        System.out.println(d2==d1);	//true
    }
}

 运行以上的程序，发现很奇怪的事：0.1竟然不等于0.1，存进去的一块钱莫名其妙消失了？！

 原因是float是有限位数据，离散的数据，是大约值，接近但不等于。到后面数据越大，后面的位数就存不进去了。所以最好避免使用浮点数进行比较大小。那回到问题上来，银行使用哪种呢？答案是BigDecimal，这是一个数学工具类。BigDecimal_百度百科 (baidu.com)

字符拓展

public class Demo03 {
    public static void main(String[] args) {
		char c1 = 'a';
        char c2 = '躺';
        System.out.println(c1);
        System.out.println((int)c1);	// 强制转换

        System.out.println(c2);
        System.out.println((int)c2);	// 强制转换
        
        System.out.println("====================================");
        String sa = new String("Hello World");
        String sb = new String("Hello World");
        System.out.println(sa==sb);     // false

        String sc =("Hello World");
        String sd =("Hello World");
        System.out.println(sd==sc);     // true
    }
}

所有的字符本质还是数字

布尔值拓展

      boolean flag = true;
      if (flag) {}
      if (flag==true){}
// 这上面两行意思是一样的

3、类型转换

由于Java是强类型语言，所以有些运算要进行类型转换

低————————————————————>高

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

不擅长，int来反蹲

运算中，不同类型的数据先转换为同一类，然后进行运算

• 强制类型转换
• 自动类型转换

public class Demo04 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i;
        double a = i;

        // 强制转换     (类型)变量名     高-->低
        // 自动转换      不用操作        低-->高

        System.out.println(i);
        System.out.println(b);  // 内存溢出
        System.out.println(a);

        System.out.println("====================================");
        System.out.println((int)23.7);
        System.out.println((int)-23.33f);	// 精度丢失

        System.out.println("====================================");
        char c = 'a';
        int d = c + 1;
        System.out.println(d);
        System.out.println((char)d);
    }
}

注意：

1. 不能对布尔值进行转换
2. 不能把对象类型转换为不相干的类型
3. 在把高容量转换到低容量的时候，强制转换
4. 转换的时候可能存在内存溢出、精度问题

public class Demo05 {
    public static void main(String[] args) {
        // 操作比较大的数的时候，注意溢出问题
        int money = 10_0000_0000;     // 数值之间可以用下划线分割
        int years = 20;
        int total = money * years;
        long total2 = money * years;
        long total3 = money * ((long)years);
        
        System.out.println(total);      // 计算的时候溢出了
        System.out.println(total2);     // 计算的时候是int，计算完以后才转换已经没有用了
        System.out.println(total3);		// 只有提前转换才可以
    }
}

4、变量、常量

4.1变量

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

Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和变量作用域

type varName [=value] [{,varName[]=value}];
// 数据类型 变量名 = 值；可以使用逗号隔开来声明多个同类型变量

变量作用域

• 类变量
• 实例变量
• 局部变量

public class Variable{
    static int allClicks=0;		// 类变量
    String str = "hello world"	// 实例变量
    
    public void method(){
        int i = 0;	// 局部变量
    }
}

public class Demo07 {

    //类变量 static
    static double salary = 2500;

    // 属性：简单理解为变量

    // 实例变量：从属于对象;如果不进行初始化，默认是有值的
    // int型：0   布尔值：false   除了基本类型，其余默认都是null
    String name;
    int age;

    // main方法
    public static void main(String[] args) {

        //局部变量:必须声明和初始化值
        int i = 1;
        System.out.println(i);

        // 变量类型 变量名字 = new Demo07()
        Demo07 demo07 = new Demo07();
        System.out.println(demo07.age);		// 输出默认值
        System.out.println(demo07.name);	// 输出默认值

        System.out.println(salary);
    }
    //其他方法
    public void add(){
//        System.out.println(i);    // main里的局部变量不能在其他方法里使用，须再次声明和初始化
    }
}

变量命名规范：

• 所有变量、方法、类名：见名知意
• 类成员变量：首字母小写和驼峰原则 monthSalary
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线 MAX_VALUE
• 类名：首字母大写和驼峰原则 GoodMan
• 方法名：首字母小写和驼峰原则 runMan()

注意事项：

• 每个变量都有类型，类型可以是基本类型，也可以是引用类型
• 变量名必须是合法的标识符
• 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

4.2常量

初始化以后不能再改变值。所谓常量可以理解是一种特殊的变量，它的值被设定后，在程序运行过程中不允许被更改。

final 常量名=值;
final double PI=3.14;	// 常量名一般使用大写符

public class Demo08 {

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

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

5、运算符

Java语言支持如下运算符：

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

public class Demo02 {
    public static void main(String[] args) {
        long a = 123123123123123123L;
        int b = 123;
        short c = 10;
        byte d = 8;
        double f = 10;

        System.out.println(a+b+c+d);    // 有一个是long，结果是long
        System.out.println(b+c+d);      // int
        System.out.println(c+d);        // int
        System.out.println(a+b+c+d+f);  // 有一个是double，结果是double
    }
}

• 赋值运算符：=
• 关系运算符：>，<，>=，<=，==，!=，instanceof
• 逻辑运算符：&&，||，!

public class Demo05 {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        System.out.println(a && b);
        System.out.println(a || b);
        System.out.println(!(a && b));

        int c = 5;
        boolean d = (c<4)&&(c++<4);		// 会短路，前半部分false，后半部分虽然是true，但是并不会执行了
        System.out.println(d);			// false
        System.out.println(c);			// 5
    }
}

• 位运算符：&，|，^，~，>>，<<，>>>

public class Demo06 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101

        A&B = 0000 1100
        A/B = 0011 1101
        A^B = 0011 0001     // 异或：相同为0，不同为1
        ~B = 1111 0010		// 取反

        2*8 = 16   2*2*2*2
        <<  *2
        >>  /2
        0000 0001   1	// 找规律
        0000 0010   2
        0000 0011   3
        0000 0100   4
        0000 1000   8
        0001 0000   16
         */
        System.out.println(2<<3);   // 16
    }
}

• 条件运算符：?:

public class Demo08 {
    public static void main(String[] args) {
        // x ? y : z
        // 如果x==true,则结果为y,否则结果为z

        int score = 80;
        String type = score<60 ? "不及格" : "及格"; // 必须掌握

        System.out.println(type);
    }
}

• 扩展赋值运算符：+=，-=，*=，/=

public class Demo07 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        a+=b;   // a = a + b
        a-=b;   // a = a - b

        System.out.println(a);

        // 字符串连接符
        System.out.println(""+a+b); // 1020
        System.out.println(a+b+""); // 30
    }
}

重点理解一下++，–

前缀自增自减法(++a,--a)	先进行自增或者自减运算，再进行表达式运算。
后缀自增自减法(a++,a--)	先进行表达式运算，再进行自增或者自减运算。

public class Demo04 {
    public static void main(String[] args) {
        int a = 3;

        int b = a++;    // 执行完这行代码后，先给b赋值，再自增

        int c = ++a;    // 执行完这行代码后，先自增，再给c赋值

        System.out.println(a);	// 输出5
        System.out.println(b);	// 输出3
        System.out.println(c);	// 输出5
    }
}
// 那你也来试试--吧

还有很多其他运算时通过Math类来实现的。

6、包机制、JavaDoc

6.1包机制

为了更好地组织类，Java提供了包机制，用用于区别类名的命名空间。包的本质就是文件夹。

包语句的语法格式为：

package pk1[.pk2[.pk3...]];

一般利用公司域名倒置作为包名；

为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。

import package1[.package2...].(classname *);	// 这个*会导入这个包下所有的类

6.2JavaDoc

Javadoc命令是用来生成自己API文档的

参数信息

• @author 作者名
• @version 版本号
• @since 指明需要最早使用的jdk
• @param 参数名
• @return 返回值情况
• @throws 异常抛出情况

使用命令行生成doc文件

&emsp;控制台中输入如下指令：

javadoc -encoding UTF-8 -charset UTF-8 Doc.java

虽然有警告，但依然能在该目录下生成doc文件。

使用IDEA生成doc文件

1. 首先创建一个存放JavaDoc的文件夹

2. 然后在IDEA中点击如下选项

   

3. 选择创建文件夹的位置，然后在Local行和编码集写下如下代码，即可设置为中文且防止了中文带来的乱码

参考文献

阿里巴巴Java开发手册-在线手册教程-php中文网

阿里巴巴Java开发手册_w3cschool

Overview (Java Platform SE 8 ) (oracle.com)