[Java知识库]java语言基础

IDE(集成开发环境)：

包括代码编辑器，编译器，调试器，和图形界面等工具。

常用的集成开发环境：

IDEA

eslipse

java语言注释：

注释：对代码的功能进行说明，使用特定的符号进行标注

1.单行注释（快捷键：ctrl+/）：//对某一行代码进行说明

2.多行注释（快捷键：ctrl+shift+/）：/* */注释多行代码

3.文档注释：对类，属性（成员变量），方法进行标注，调用的时候就可以看到你注释的文档信息

注释的附加作用：调试代码

直接用类名调用成员方法和成员变量时成员方法和成员变量必须要用static（静态的）修饰符修饰

关键字

被java语言富裕特定含义的单词，主要是来修饰包，类，方法，变量（小写字母）

保留字

java现版本中并未使用的关键字，后面可能会用

有 goto ，const

标识符

定义：对包，类，方法，变量等进行命名的字符序列（也就是我们可以自己命名的东西）

命名规范

1.语法强制：

一.可以使用的内容：大小写的字母，数字，下划线，美元符号$

二.数字不能开头，不能有空格

三.不能是关键字

四.严格区分大小写

2.约定俗成：

一.见名知意

二.驼峰规则

三.类名，接口名全部单词首字母大写（大驼峰）

四.方法名，变量名：第一个单词首字母小写，从第二个单词开始首字母大写（小驼峰）

五.常量名：全部字母大写，单词之间以下划线分割

变量

变量的定义

变量是程序的最基本的存储单位，运行时值可变。

变量的本质

变量的本质是内存中的一小块区域。

变量的使用

变量需要先声明后赋值。

int x;
x=10;

或者

int x=10;

变量的声明语法（java是强类型语言）

【修饰符】 数据类型 变量名 = 值;

大致分为以下类型：

int y;
y=10;

或

int y=10;

或

int x,y,z;
x=10;
y=20;
z=30;

或

int x=10,y=20,c=30;

数据类型

功能

数据类型可以指导程序中的数据如何存储，以及如何计算

分类

数据类型可分为基本数据类型，引用类型

基本数据类型可以分为数值型，字符型（char），布尔型（）boolean。

数值型又可以分为整形，浮点型。

引用类型中可以分为类（class），接口，数组（[]）。

String（字符串）就是一个类（所以首字母大写），表示字符串类型

eg：例如这里声明字符串a，并给其赋值中国

String a="中国";

String是java核心类库中定义好的一个类，表示字符串类型

整形

整形又可以分为，byte（一字节），short（二字节），int（四字节），long（八字节）。

注意:整形字面量默认是int，表示long类型需要字面值后面加L（大写的L和小写的l都可以，但是为了区分与字面值，我们一般用L）

例如：

long a=333L;

java中各整数类型有固定的表述范围和字段长度，其不受具体操作系统的影响以保证java程序的可移植性

对于整形字面值

二进制表示：整形字面值前面加0（零）b

例如：

int x=0b11;

这里的x打印出来就是十进制的3

八进制表示：整形字面值前面加0（零）

int y=011;

这里的y打印出来是十进制的9

十六进制表示：前面加0（零）x

int z=0x11;

这里的z打印出来是十进制的17

具体函数分析如下：

package day1;

public class demo1 {
    public static void main(String[] args){
        int y=2;
        byte x=24;
        short c=59;
        /*
        在声明长整形变量时，由于整型变量默认类型为int，所以就需要在字面值77之后加L
        （这里的L可以为大写的L也可以是小写的l，但我们一般用大写的L（容易区分））
         */
        long z=77L;
        //0b表示二进制
        int b=0b11;
        //0表示八进制
        int i=011;
        //0x表示十六进制
        int g=0x11;
        System.out.println(x+"\n"+y+"\n"+z+"\n"+c+"\n"+b+"\n"+i+"\n"+g+"\n");
        //int中存储最大值的类为Interger
        System.out.println(Integer.MAX_VALUE);
        //其余的存储最大值得类为其本身的单词，只不过首字母大写
        System.out.println(Short.MAX_VALUE);
        System.out.println(Byte.MAX_VALUE);
        System.out.println(Long.MAX_VALUE);
    }
}

运行结果：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-api88mSC-1634382662452)(C:\Users\赚钱养敏敏\AppData\Roaming\Typora\typora-user-images\1634380048216.png)]

浮点型

浮点型可以分为，float，double。

浮点型：表示小数

浮点型字面量的默认是double

浮点型字面值有两种表示方式：

1.十进制表示

2.科学记数法

float（单精度）

float类型的变量占四个字节

浮点型字面值默认类型时double，如果要表示float类型的字面值，那么就需要在字面值的前面加F或者小写的f（习惯用F（大写的F））

例如：

float a=1.23F;

float a=10.0001;这个语句是错的，因为浮点型字面值的默认类型为double，而double的范围比float的范围大，所以不能进行隐式转换，也就是要强制类型转换所以上面语句会报错

float a=10.0001;  //这个语句是错误的

float a=10.0001F 这个语句是对的

float a=10.0001F;  //这个语句是对的

package day1;

public class demo2 {
    public static void main(String[] args) {
        //布尔型的变量a只能存储true或者false
        boolean a=true;
        //char型的变量存储的其实是这个字符所对应的十进制编码
        char b='a';
        char c='b';
        //由于char类型存储的是字符的十进制编码，那么也就说明了char类型的变量可以参与运算，
        // 所以h的值为char型变量b也就是实际的字符a的编码97+0，也就是97
        int h=b+0;
        /*
        这里要注意，这时候的0.001后面，也就是字面值后面必须要加F或者f，不然就会出错，
        因为浮点型的字面值的默认类型时double，而由于double类型的范围比float大，
        也就无法进行隐式转换，所以必须加F或者f，不然就会报错
         */
        float d=0.001F;
        /*
        这里给单精度浮点类型变量g赋了一个整形的数值10，那么这个时候由于整形数值的范围比float的范围小
        所以就会触发隐式转换，所以不会报错
         */
        float g=10;
        //同上，这个也可以进行隐式转换
        double e=10;
        double f=10.13;
        System.out.println(a+"\n"+b+"\n"+c+"\n"+d+"\n"+e+"\n"+f+"\n"+g+"\n");
        System.out.println("\n"+h);
    }
}

运行结果为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bkZn1beI-1634382662454)(C:\Users\赚钱养敏敏\AppData\Roaming\Typora\typora-user-images\1634380342550.png)]

double（双精度）

double类型占8个字节，它是双精度，精度更高

布尔型

boolean 布尔型 （逻辑值）

boolean类型的变量值可以使true或者是false，不可以是其他值

字符型

char ，可以表示单个字符 ，占两个字节的内存

eg char a=“a”; 这里的char类型的变量a存储的不是字符a，而是存储的字符a在Unicode编码表中的编码（十进制编码，也就是97），只是在电脑显示的时候，就会通过UTF-8字符集对应转换为字符a

package day1;

public class demo2 {
    public static void main(String[] args) {
        //布尔型的变量a只能存储true或者false
        boolean a=true;
        //char型的变量存储的其实是这个字符所对应的十进制编码
        char b='a';
        char c='b';
        //由于char类型存储的是字符的十进制编码，那么也就说明了char类型的变量可以参与运算，
        // 所以h的值为char型变量b也就是实际的字符a的编码97+0，也就是97
        int h=b+0;
        /*
        这里要注意，这时候的0.001后面，也就是字面值后面必须要加F或者f，不然就会出错，
        因为浮点型的字面值的默认类型时double，而由于double类型的范围比float大，
        也就无法进行隐式转换，所以必须加F或者f，不然就会报错
         */
        float d=0.001F;
        /*
        这里给单精度浮点类型变量g赋了一个整形的数值10，那么这个时候由于整形数值的范围比float的范围小
        所以就会触发隐式转换，所以不会报错
         */
        float g=10;
        //同上，这个也可以进行隐式转换
        double e=10;
        double f=10.13;
        System.out.println(a+"\n"+b+"\n"+c+"\n"+d+"\n"+e+"\n"+f+"\n"+g+"\n");
        System.out.println("\n"+h);
    }
}

运行结果为：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nMc7bVvF-1634382662455)(C:\Users\赚钱养敏敏\AppData\Roaming\Typora\typora-user-images\1634380462959.png)]

char型的变量可以参与算数运算，运算时采用的是Unicode字符集中的十进制编码值参与运算

java中的字符表示使用的是Unicode编码表

Unicode字符集可以表示世界上所有的语言

Unicode主要是存储对照字符(只是存储十进制编码)

UTF-8字符集是Unicode编码表的具体的一种表示方式

UTF-8是一种变长的的字符集（长度可以变化，可以在1-4字节之间转换，当所存储的字符不同时，存储的空间也不一样大，例如：英文字母一个字节就可以存储，中文字母需要三个字节才可以存储）

（英文字符少， 一个字节可以存储，所以一个英文字母在UTF-8字符集中只占一个字节）

（中文多，一个字节表示不了，UTF-8中一个中文占三个字节）

Unicode（给每个国家的字符进行编码，可以理解为其中只有编码）

UTF-8（其中有编码和字符的对应，IDEA中显示时为UTF-8）

基本数据类型转换

package day1;

public class demo3 {
    public static void main(String[] args) {
        /*
        进行了默认转换（隐式转换）因为byte的容量小于int的容量
         */
        byte a=127;
        int b=a;
        /*
        进行了隐式转换，虽然double型的变量占八个字节，而float类型的变量只占了四个字节，
        但是由于浮点型变量在内存中存储的时候的存储方式是类似于科学记数法的方式，
        即使只占了四个字节但是也比long类型的变量的8个字节所占得容量更加大
         */
        long c=123456L;
        float d=c;
        /*
        强制类型转换，由于这个int类型变量e的值为127，也在byte类型的存储范围之内，
        所以不会引起数据溢出，也不会引起数值的精度损失
         */
        int e=127;
        byte f=(byte)e;
        /*
        这里也是强制类型转换，但是由于这里int型的变量g的值为258，超出了byte类型的范围，
        所以就会引起数据溢出，而数据溢出之后，就会把超出byte类型范围的字节去掉，也就造成了变量值的变化
        这里的h就会变成2，也就是输出的h为2
         */
        int g=258;
        byte h=(byte)g;
        /*
        这里也是强制类型转换，只不过这里将float类型的变量i的值赋给了long类型的变量j，
        而由于long类型只能存取整数，那么就会将小数点后的数字删去，也就是会引起进度损失
         */
        float i=10.35F;
        long j=(long)i;
        /*
        这里也是强制类型转换，只不过后面的值是混合类型，最终后面的值为double型，
        因为混合类型的字面值的计算是在向大容量转换，最后再进行强制类型转换转为int类型之后，
        就会造成数据的精度损失
         */
        int n=(int)(10*3.5+i);
        System.out.println(b+"\n"+d+"\n"+f+"\n"+h+"\n"+j+"\n"+n+"\n");
    }
}

运行结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FtBhCa8i-1634382662457)(C:\Users\赚钱养敏敏\AppData\Roaming\Typora\typora-user-images\1634380566426.png)]

除了boolean类型以外，其它7种基本类型之间可以相互转换

基本数据转换的分类

基本数据类型转换分为默认转换（隐式转换）和强制类型转换

默认转换

由容量小的基本数据类型转换为容量大的基本数据类型

强制转换

由容量大的基本数据类型转换为容量小的基本数据类型

强制类型转换可能会带来的问题

1.数据溢出

当数据溢出时，把超出的字节去掉（也就是把溢出部分去掉）（最高位为符号位）

2.精度损失

在浮点型向整形转换时，由于整形只能存储数值的整数部分，所以会损失掉小数部分，也就造成了精度损失

在混合运算中，小容量类型会默认自动上升为大容量类型

七中基本数据类型之间的容量大小排序（因为布尔类型的变量不能进行类型转换，其它七种都可以互相之间转换）

byte=short=char—>int—>long—>float—>double

虽然long类型的变量占八个字节，而float类型的变量占四个字节，但是由于在计算机的内部，存储浮点型变量和整形变量的方式不同，虽然long只有4个字节但是long类型的变量的容量更加大，所以可以由long类型的变量向float类型的变量进行类型转换