命名规则

1.名称要求：见名知意，不可以用中文命名 ，要用大小写字母组合，数字下划线进行组合
注意：不能用数字开头，不能是关键字，区分大小写
命名规则
包：
一个单词对应一个层级，一般情况下不会使用多个
单词作为一个层级 层级之间使用.隔开
对应每个层级实际上是一个目录 包名称一般为小写
包只能在source标记的目录下创建
类(或接口)：
在.java文件内部使用class修饰的，称为类名，
类名一般和文件名称一致
一个单词：首字母大写
多个单词：每个单词的首字母大写
方法和变量：
在类中定义的函数或者用于保存数值的变量
一个单词：所有的都小写
多个单词：第一个单词都小写，其他单词首字母
大写
常量：
用于保存一个不变的量
一个单词：所有的单词都大写
多个单词：每个单词大写，并且多个单词间使用
_ 连接

注释方式

// 这是一个单行注释

/*
这是多行注释
这是多行注释
这是多行注释
*/

/**

• 这是一个文档注释
• 这是一个文档注释
• 这是一个文档注释
  */

对HelloWorld代码进行解释

package com.fuahi.day01; // 用于标记当前.java文件所在的包路径 包路径开始的位置为 从source标记的目录下开始

// 解释HelloWorld程序
// public修饰的当前类的权限   class表示类的标记信息  HelloWorld类名称 编译后可以生成类名称.class文件
public class HelloWorld {
    // public 修饰的当前函数的权限  static 用于修饰当前函数是一个静态 void 表示为没有返回值 main函数名称 (String[] args)表示函数的参数以及参数名称
    // {}表示当前函数的代码块区域 或者是称为作用域
    public static void main(String[] args) {
        // 对System类中调用println函数并传入 hello Java 的字符串值 进行打印
        System.out.println("hello java...");

    }
    // 编写代码时，idea提供了快捷方式  main / sout

}

常量，进制转换和机器码展现计算过程

常量：存储的数据不发生改变的量

常量类型

1.字符串常量

定义一个字符串常量，因为是常量所以变量名全部大写

String STR = "this is String";  // 字符串常量

2.整数常量 提供了四种表现形式

定义一个整数常量

int NUM = 10;  // 整数常量

进制的说明：表示某一位置上的数运算时是逢X进一位。二进制就是逢二进一，八进制是逢八进一，十进制是逢十进一，十六进制是逢十六进一。

2.1 二进制

在01前面加上0b代表二进制数据

110 二进制转化为 10进制数字为 6
0b110 =>  0*2^0 + 1*2^1 +1*2^2 => 6

2.2 八进制

八进制在数前面加上一个0则表示八进制

07 => 7

2.3 十进制

2345 =>  5*10^0 + 4*10^1 + 3*10^2 + 2*10^3

2.4 十六进制

在数字前面带上0x则代表十六进制

(0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f)  0x12 => 2*16^0 + 1*16^1 => 18

2.5 进制之间的转化

2.5.1 其他进制转化为十进制

系数：就是每一位上的数据。
基数：X进制，基数就是X。
权：在右边，从0开始编号，对应位上的编号即为该位的权。
结果：把系数*基数的权次幂相加即可。
十六进制12转化为十进制为18
例如：0x12 => 2*16^0 + 1*16^1 => 18

2.5.2 十进制转化为其他进制

把52分别表示成二进制，八进制，十六进制: 对52进行除以相应的进制基数进行不断取余，得到的除得的结果加上最后的一个余数进行反转就可以得到对应的进制的结果

即可得到二进制为110100，转化为其他进制类似

十进制和二进制的快速转换
         1    1   1  1  1  1   1
         64   32 16  8  4  2   1
 二进制： 1000100  64 + 4 => 68

2.5.3 二进制和八进制之间的转换

方式1：
         以十进制作为桥梁 先将二进制转换成 十进制
         ，再由十进制转换成 八进制
          1000100 =十进制> 68 =八进制> 104
方式2：
          将二进制数据三个分为一组 分别计算组内的
          十进制数值再将计算后的结果拼接到一起，
          分组时如果不满足三个，那么对其进行左边补0
          1 000 100 => 001 000 100 => 104

2.5.4 二进制和十六进制之间的转换

方式1：
          以十进制作为桥梁 先将二进制转换成 十进制，
          再由十进制转换成 十六进制
          1000100 =十进制> 68 =十六进制> 44
方式2：
           将二进制数据4个作为一组 ，分别计算组内数据的
           十进制，再将计算结果拼接到一起，如果组内数据
           不满足4个左边补0
            1 000 100 => 0100 0100 => 44

2.6 机器码解释运算过程

对于数据在计算过程中都是以二进制的机器码进行计算的

以正整数为例：
          7+1 =>  000111 + 000001 => 001000
以负整数为例：
          对于负数要想表示成二进制的形式，需要使用
          原码 反码 补码

原码： 
    就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”     
    表示负，其余位表示数值的大小
反码： 
    正数的反码与其原码相同；负数的反码是对其原码逐位取反，但  
    符号位除外。
补码:  
    正数的补码与其原码相同；负数的补码是在其反码的末位加1。

正整数相加即源码相加，
负整数相加即先展开为补码进行相加在转换成为源码获得数值

-7+1 =>
原码：
       符号位     数值位
 -7的   1        0000111
  1的   0        0000001
反码:
       符号位     数值位
 -7的   1        1111000
  1的   0        0000001
补码:
       符号位     数值位
 -7的   1        1111001
  1的   0        0000001

相加的结果：
result 补码:
       符号位     数值位
        1       1111010
由于符号位为1 那么补码和反码不同 原先反码=> 补码 要求加1  所以 补码 => 反码 要求 -1
result 反码:
       符号位     数值位
        1       1111001
由于符号位为1 反码转原码是将数值位中的数据进行取反
源码:
       符号位     数值位
        1       0000110
由二进制转成10进制
result = -6

展示 -13 + 5 的计算过程

-13 + 5 => 
原码：
          符号位      数值位
    -13     1       0001101
      5     0       0000101
反码：
          符号位      数值位
    -13     1       1110010
      5     0       0000101
补码：
          符号位      数值位
    -13     1       1110011
      5     0       0000101

补码相加：
          符号位      数值位
 result     1       1111000
转为反码：
          符号位      数值位
 result     1       1110111
转为原码：
          符号位      数值位
 result     1       0001000

转为十进制
result =   -8

3.小数常量

后面要带f或F标识其为float类型，默认为int

float FloatNum = 3.14F; // 小数常量

4.字符常量

char CH = 'a'; // 字符常量

5.布尔常量

boolean BOOL = true; // 布尔常量

6.空常量

String 首字母要大写

String NULL = null; // 空常量 表示字符串中的常量值为空

变量

变量：程序执行的过程中，在某个范围内其值可以发生改变的量 Java是一个静态类型语言（编写代码时需要指定当前变量中的数据类型，并且定义后不能改变类型）
而Python是动态类型语言（在代码执行过程中，根据数据的类型来进行推断）
变量定义格式： 变量类型 变量名 = 值;

数据类型

基本数据类型

数值类型

byte short int long 整数
float double 小数
对于不同类型的数据类型，保存数据的长度范围不一样
为什么需要用不同类型，如果使用Python的方式，所有整数都在int中，对于python是做科学计算，对于计算结果得到后，整个代码结束
对于Java语言来说，通常用于编写应用程序，而应用程序需要长时间运行，并且对于内存会做大量的管理

字节占用：
byte(1字节) short(2字节)  int (4字节)  long(8字节)
float(4字节) double(8字节)

字符类型，布尔类型

字符类型：
    char
布尔类型：
    boolean 对应值 true false
注意：
    ①对于浮点类型数据，默认类型为double
    ②对于float类型数据的值可以在末尾使用 F或 f进行标记
    ③对于double类型数据的值可以在末尾使用 d或D 进行标记
    ④对于整数数值Java中默认为int类型
    ⑤对于Long类型数据其值要求在末尾添加 L或者l进行标记

对于浮点类型数据，默认类型为double
对于整数数值Java中默认为int类型

byte b = 10;
short shortVariable = 1000;
int intVariable = 1000000;
long longVariable = 1000000000L;
float floatVariable = 3.14f;
double doubleVariable = 3.14;

强制类型转换

类型转换：
byte,short,char—int—long—float—double
强制类型转换
    转换的类型 变量名 = (转换的类型)变量
    注意：从高精度向低精度转换时会丢失部分信息导致数据错误
向上类型转换：
    向上类型转换时不会发生精度丢失，并且不需要强制类型转换

int intVar = 129;
byte byteVar = (byte) intVar; // 强制类型转换：将int类型转成byte 
System.out.println("byteVar:" + byteVar); 
// 输出的值为-127  因为高精度转为低精度会有损耗

// 低精度转为高精度 不用强制类型转换
byte byteVar2 = 10;
int intVar2 = byteVar2;

// 将char转为int 也不用强制类型转换
char charVariable = 'a';
int intChar = charVariable;
System.out.println(intChar);  // 97
// 并且输出的值为该字符的ASCII码所对应的值

扩展一下排序：

 /*
            拓展：
                SQL语言中对数据可以进行排序操作，通常情况下对于数值进行排序，但是有时也会对字符串进行做排序
                那么对于字符串进行排序的规则？
                    字典序:
                        如果是字符串，将对应位置的字符取出,再找到对应ASC码表中位置的int值，再按位置比较其大小
                                    如果第一个位置相同，那么会再比较第二个位置，直到其能比较出来前后顺序

"abc"  => 'a' | "abc" => 'a' 比较第二个位置数据 => 'b'
"bc"   => 'b' |  "ac"   => 'a'               => 'c'
         */
boolean bool = true; // 注意为小写
// 布尔类型的值不能转化为int

+ 法在数值运算中的表现

public class DemoVariable3 {
    public static void main(String[] args) {
        // + 数值计算过程中的表现
        //   ① 对于byte类型数据相加 那么会先将其转成 int类型，再做加法运算
        byte byteVariable1 = 10;
        byte byteVariable2 = 4;

        int intVariable = byteVariable1 + byteVariable2;
        System.out.println(intVariable);

        byte resVariable = (byte)(byteVariable1 + byteVariable2); // 强制类型转换
        System.out.println(resVariable);


    }

代码总结

package com.fuhai.day01;
public class MySelef {
    public static void main(String[] args) {
        // 定义一些变量
        byte a = 123; // 范围在-127-127之间 占1字节
        short b = 1000; // 占2字节
        int c = 100000; // 占4字节
        long d = 1000000000000L; // 占8字节 需要l或L来标识

        float e = 3.14f; // 占4字节   且后面需要f或F来标识
        double f = 3.14; //占8字节

        // 强制类型转换
        //高精度转为低精度
        int g = 129;
        byte h = (byte) g;

        // 低精度转为高精度
        long y = g;
        System.out.println("原本数值为："+g);
        System.out.println("高精度转为低精度"+h+"\n低精度转为高精度"+y);

        // char 转为 int
        char x = 'a'; // 字符用单引号
        String z = "sddc"; // 字符串用双引号
        int aa = x;
        System.out.println("char a 转为int 为 ASCII 码  "+aa);

        // + 号在运算时的表现形式
        byte oneNumber = 3;
        byte twoNumber = 4;
        int resultOne = oneNumber+twoNumber;
        System.out.println("用int变量值进行接收："+resultOne);

        byte resultTwo = (byte)(oneNumber + twoNumber);
        System.out.println("用byte变量接收报错，必须进行一次强制类型转换："+resultTwo);
        System.out.println("说明+运算默认的返回类型为int，会强制将数值转化为int进行计算");
        
    }
}