【JAVA学习之路】（二）基本语法与数据类型-CSDN博客

本文链接：https://blog.csdn.net/QH_laozai/article/details/117683917

本文详细介绍了JAVA的运行机制，包括编译与解释过程，关键字与数据类型的使用，如基本类型、引用类型，以及浮点数比较的不准确性及其解决方案。此外，还讲解了变量的声明、作用域、类型转换、运算符、逻辑运算以及包和导入的使用。最后提到了文档注释JavaDoc的生成。文章强调了JAVA中浮点数运算的不精确性，推荐使用BigDecimal进行精确计算，并给出了代码示例。

摘要由CSDN通过智能技术生成

JAVA运行机制

在这里插入图片描述
JAVA你可以说它是编译型的，也可以说它是解释型的。因为先通过编译生成字节码文件，再将字节码文件放入JVM中去执行，在JVM中，java的运行模式就是解释型。

在这里插入图片描述

JAVA中的关键字

在这里插入图片描述

标识符

和C一样，首字符只能数字下划线$和字母，不能和关键字重合，且标识符大小写敏感

另外，看视频发现个小trick，ctrl+D，可以复制输出光标所在的一行，很好用哦(～￣▽￣)～

JAVA数据类型

众所周知，JAVA是一门强类型语言，和python、JS不一样，必须先严格定义变量的数据类型才能使用，数据类型主要分为基本类型和引用类型
在这里插入图片描述

基本类型

public class DemoData {
    public static void main(String[] args) {
        //八大基本数据类型

        int num=10;     //21亿以下
        byte num2=20;   //-128~127
        short num3=30; //可以表示16位，一共65536个数
        long num4=40L;     //long类型要在数字后面加L

        float num5=50.1F;   //小数需要加F
        double num6=1.113;  //不需要加F

        char name='A';  //只能输一个字符，可以是一个汉字，也可以是一个字母
        String name2="AA";   //String不是关键字，是一个类，要双引号

        boolean judge=true;     //跟py不一样，True不要大写
        boolean judgement=false;
    }
}

同类数据比较

public class DemoData {
    public static void main(String[] args) {
        //八大基本数据类型
	float f=0.1f;
	double d=0.1;
	System.out.println(f==d);       //false

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

	String sb=new String("Jr");
	String sa=new String("Jr");        //sb==sa false
	String saa="Jr";
	String sbb="Jr";                  	//sbb=saa true
    }
}

从第一个输出可以看到，两个浮点数比较并不准确，原因是什么呢？
它和浮点数的存储有关。
首先我们要了解浮点数在计算机中怎么存放的。《深入理解计算机系统》中这样说过，浮点数普遍的作为实数运算的近似值的计算，是很有用的。这里说的是实数的近似值的计算，所以浮点数在计算机中其实是一种不精确的表示。它存在舍入误差。浮点标准用符号，尾数和阶码将浮点数的位表示划分为三个字段，单精度为32位，双精度为64位，因为表示方法限制了浮点数的范围和精度，浮点运算只能近似的表示实数运算。而 == 表示的是在计算机中的内存表示完全一样，这样使用 == 来表示两个浮点数的相等就会出现问题了。
因此，不能使用浮点数进行比较

但是一些实际应用中，小数比较也是很重要的，怎么解决呢？
解决方案：
java中提供了BigDecimal类

import java.math.BigDecimal;

public class DemoBD {
    public static void main(String[] args) {
        BigDecimal one = new BigDecimal(1.0);
        BigDecimal bigDecimal = new BigDecimal(0.9);
        System.out.println(one);
        System.out.println(bigDecimal);
    }
}

result:
1
0.90000000000000002220446049250313080847263336181640625

结果验证了double的0.9并不等于0.9

所以这时调用另一个构造方法public BigDecimal(String val)

String 构造方法是完全可预知的：
写入 newBigDecimal(“0.9”) 将创建一个 BigDecimal，它正好等于预期的 0.9。
因此，通常建议优先使用String构造方法。当double必须用作BigDecimal的源时，使用Double.toString(double)转成String。

import java.math.BigDecimal;

public class DemoBD {
    public static void main(String[] args) {
        double a = 1.0;
        double b = 0.9;
        BigDecimal aDouble = new BigDecimal(Double.toString(a));
        BigDecimal bDouble = new BigDecimal(Double.toString(b));
        System.out.println(aDouble.subtract(bDouble));
    }
}

result:
0.1

回到刚才的比较，下面String的为什么会出现这种现象呢？
因为上面的写法是两个类，两个类的内存地址是不一样的，但是下面的写法是把String赋相同值，两个同值变量的内存地址是一样的。

类型转换

在这里插入图片描述
低到高是自动转换，高到低需要强制转换。
需要注意的三点：
1.像bool这种不相关的数据类型不能转。
2.转换的数据要注意内存溢出和精度问题
3.然后，任意字符转化成int时，其对应的是Unicode编码

char a ='a';
char A='\u0061';
System.out.println((int)a);

"C:\Program Files\Java\jdk1.8.0_221\bin\java.exe" ...
result:97

溢出情况

public class DemoOverflow {
    public static void main(String[] args) {
        int sals=10_0000_0000; //JDK7新特性，下划线分割数字
        int years=20;
        long total=sals*years;
        long total2=sals*(long)years;
        System.out.println(total2);//这里total在转换前就溢出了，因为其结果已经超出了int表示的最大数字.但total2的year已经转换成了long
    }
}

变量

JAVA变量三要素：变量名、变量类型、作用域

注意事项：
1.每个变量必须有类型
2.变量名必须是合法的标识符
3.变量声明也是一个完整的语句，需要用分号结尾

变量作用域

根据变量的作用域，可以分为：
类变量
实例变量
局部变量

public class DemoVarDo {
    //Static类变量
    static double sal=2500;

    String name;
    int age=20;
    //实例变量,如果不初始化，会自动这个类型的默认值
    // int 0 double 0.0 char u0000 boolean false
    // 其他都是默认null,包括string

    //main方法
    public static void main(String[] args) {
        //局部变量：必须声明初始化值，作用域仅这个方法
        int i=10;
        DemoVarDo demo=new DemoVarDo();
        System.out.println(demo.age+"+"+demo.name);
    }

    //其他方法
    public void add(){
//        System.out.println(i);
    }
}

关于实例变量和类变量的区别，
这个狂神后面再说，以我python的面向对象基础我是这么理解的：
类变量可以被类和对象调用，而实例变量只能被对象调用
在一个对象中改变类变量，同步到所有对象中，即类中变量发生改变
在一个对象中改变实例变量，并不会影响其他对象，即类中的那个实例变量并没有被改变
而局部变量的定义域仅仅限于定义他的方法，类和对象均不能访问他

变量命名规范

在这里插入图片描述
变量和方法名：首字母小写和驼峰原则：lastName
类名：首字母大写和驼峰：HelloWorld
常量：大写和下划线：EM_SAL

Java运算符

public class DemoOperator {
    public static void main(String[] args) {
//        二元运算符
        int a = 10;
        int b = 20;
        int c = 30;
        int d = 40;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);
		//0.5 如果是两个整数相“/”,取整数部分

        double u=99.999;
        long y=123714618474010L;
        byte i=1;
        short l=127;
        int f=1131311231;
        System.out.println(y+i);    //long
        System.out.println(u+i);    //double
        System.out.println(f+i);    //int
        System.out.println(l+i);    //int
		//System.out.println(a+b);

    }
}

基础运算符没啥好讲的，注意不同变量类型搭配后的类型。
先将运算级统一成最高级的数据类型后运算。
有double和long会自动转换为double和long，short+byte会转换为int

比较符

public class DemoCmp {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        int c=21;
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        //模运算
        System.out.println(c%a==1);
    }
}

自加自减

和C一致

public class DemoSlf {
    public static void main(String[] args) {
        //++ --
        int a=3;
        System.out.println(a++);
        System.out.println(++a);
        System.out.println((int)Math.pow(2,3));
    }
}

result：
3
5
8

逻辑运算符

public class DemoLO {
    public static void main(String[] args) {
        //and->&& or->|| not->!
        boolean a=true;
        boolean b=false;
        System.out.println(a&&b);
        System.out.println(a||b);
        System.out.println(!(a||b));
        //&&运行机制，【短路运算】
        //发现第一个值为false，则不继续执行后面的
        int c=5;
        boolean d=(c<4)&&(c++<4);
        System.out.println(d);
        System.out.println(c);//c++<4没有被执行
        /*
            A=0011 1100
            B=0000 1101
          A&B=0000 1100
          A|B=0011 1101
          A^B=0011 0001
           ~B=1111 0010

           2*8=16
           << *2
           >> /2

            0000 0000 0
            0000 0001 1
            0000 0010 2
            0000 0100 4
            0000 1000 8
            0001 0000 16
         */
        System.out.println(2<<3);
        System.out.println(16>>3);

    }
}

三元运算符

public class DemoTri {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        boolean x=true;
        String result="";
        //字符串连接符  +   只要前面为String，就会把所有参数转化成String类型连接
        System.out.println(""+a+b); //1020
        System.out.println(a+b+""); //30
        //三元运算符
        result=x?"及格":"不及格";
        System.out.println("该考生考试成绩"+result);
    }

字符串连接符这里有处细节："+"只要前面为String，就会把所有参数转化成String类型连接

?三元运算也和C中一样

优先级

括号>一元>二元>三元
多写点括号不会吃亏的

包机制

包的本质就是文件夹
在这里插入图片描述
创建Package com.L4k1d

如果不把小齿轮中的Compact Middle Packages选项只能创建单个文件夹

import

package com.L4k1d.Operator;
//import 一定要在包名下
import com.L4k1d.*;//导入所有class

文档注释JavaDoc

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

在指定Package目录下执行命令行
生成一堆文档，index.html就是JavaDoc

狂神布置的作业：学会使用IDEA生产JavaDoc文档。
在这里插入图片描述
如此设置即可

最后，附上JAVA的开发手册和官方api

参考文章：
Java中浮点数运算不准确的原因及解决方案
 Java 类变量, 实例变量,局部变量的区别
 阿里巴巴JAVA开发手册
 JAVA8官方文档