【Java知识点整理】数据类型以及类型转换

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

1、注释

当结构复杂时我们就需要用到注释

• 书写注释是一种非常好的习惯。
• 注释并不会被执行
• 平时写代码一定要注意规范
• Java中有三种注释：单行注释、多行注释、文档注释

#准备，在IDEA中建立一个新的空白项目

1. 新建一个empty project项目
2. 下面状态栏显示“Indexing”表示正在加载项目……
3. 进入Project Structure（数据结构
4. 将SDK设置为Java 1.8

#准备，修改IDEA中的注释的格式

1. Setting——Editor——Color Scheme/ skiːm /（配色方案）
2. language Defaults （语言预设）——Comments（注解）
3. Block Comments 多行注释
4. Line Comments 单行注释
5. Doc Comments 文档注释

单行注释

用法两个“//”

多行注释

用法，前面用“/*”开始，结尾用“*/”

文档注释

用法 用“/**”开始，结尾用“*/”

• 文档注释更多是JavaDoc联合使用，目前较少用，大公司更多会用

搜有趣的代码注释

2、标识符

学习时间2022年4月1日

· 关键词

系统定义好的单词（无法在用下列单词命名）

	关键词	专业释义
1	abstract	抽象的；抽象化；表明类或者成员方法具有抽象属性
2	assert	断言；判断提示，用来进行程序调试
3	Boolean	布尔型；基本数据类型之一[1]
4	break	打破（循环）。提前跳出一个块
5	byte	字节。基本数据类型之一，字节类型
6	case	情况；用在switch语句之中，表示其中的一个分支
7	catch	捕捉；用在异常处理中，用来捕捉异常
8	char	字符型；基本数据类型之一，字符类型
9	class	n.类* 声明一个类
10	const	常数。（保留关键字，没有具体含义）
11	continue	继续。回到一个块的开始处
12	default	默认 n. adj. 用在switch语句中，表明一个默认的分支
13	do	做；执行。 用在do-while循环结构中
14	double	双精度浮点数 基本数据类型之一
15	else	否则 ； 用在条件语句中，表明当条件不成立时的分支
161	enum	枚举；电话号码映射；ENUM标准
17	extends	继承。表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
18	final	最终的。用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常
19	finally	终于 adv. 用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
20	float	单精度浮点数（本意：v.使漂浮；）基本数据类型之一，
21	for	为了 （一种循环结构的引导词
22	goto	跳转。保留关键字，没有具体含义
23	if	如果。条件语句的引导词
24	implements	(l不发音）工具；vt. 执行、履行的意思。表明一个类实现了给定的接口
25	import	导入。表明要访问指定的类或包
26	instanceof	运算符 （instance 例子、举例的意思）用来测试一个对象是否是指定类型的实例对象
27	int	整数类型。基本数据类型之一
28	interface	界面；接口
29	long	长整型。基本数据类型之一
30	native	本机的（语言）（同根词nation国家）。用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
31	new	新的；v.新建，新增，加入 用来创建新实例对象
32	package	包；封装；（数据）加密
33	private	私有的；私有；一种访问控制方式：私用模式
34	protected	被保护的，受保护的。一种访问控制方式：保护模式
35	public	公共的；v. 公开；一种访问控制方式：共用模式
36	return	返回，回传；从成员方法中返回数据
37	strictfp	精确浮点（Java 关键字，strict float point）(strict 严格的)[2]
38	short	短的；短整数类型，基本数据类型之一
39	static	静态；静态的；静止的；表明具有静态属性
40	super	超级的（专业释义：表明当前对象的父类型的引用或者父类型的构造方法
41	switch	转换，切换；分支语句结构的引导词
42	synchronized	adj. 同步的。 表明一段代码需要同步执行
43	this	这个。指向当前实例对象的引用
44	throw	扔；抛出一个异常
45	throws	抛出（异常） 声明在当前定义的成员方法中所有需要抛出的异常
46	transient	过渡过程；瞬态的；瞬时；暂时的 声明不用序列化的成员域
47	try	尝试。尝试一个可能抛出异常的程序块
48	void	空白的。声明当前成员方法没有返回值
49	volatile	易变的。 （表明两个或者多个变量必须同步地发生变化（用于并发编程）
50	while	循环，当时候
51	true	真
52	false	假
53	null	无

1. `布尔型：有函数或布尔表达式返回的条件匹配值，与一般语言中的布尔型相同， 有true和FALSE两个值。`

2. `strictfp 用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范`

详细可以参考：CSDN【java基础】java关键字总结及详解

· 标识符注意点

1. 标识符是大小写敏感的。
2. 所有标识符应该以**字母（A-Z a-z）、美元符（$）、下划线（_）**开头；
3. 首字符后的标识符可以用字母（A-Z a-z）、美元符（$）、下划线（_）以及数字命名。
4. 不能用关键字命名；
5. 可以用中文，但是不推荐这样使用。

二、数据类型

1、分类：

1）按强弱类型语言分类

分为：

• 强类型语言：要求变量的使用要严格符合规定，所有变量都必须要先定义后才能使用。

  （Java、C、C++都是强类型语言)

  优点：安全性高！但速度慢。

• 弱类型语言：不要求变量的使用要符合规定。

2）Java中的分类

分为：

• 基本类型(primitive type):八大类
• 引用类型（reference type)：类、接口、数组

2、基本类型（八大类）

（1）数值类型：

• 整数类型：
  • byte：占1个字节 -128~127
  • short：占2个字节 -32768~32767
  • int ：占4个字节 约-21亿~21亿
  • long：占8个字节 更大
• 浮点类型（小数点
  • float ：占4个字节
  • double：占8个字节
• 字符类型
  • char：占两个字节

（2）boolean类型（布尔型）

• boolean：占一个位，只有ture和false

插入一个知识点什么的字节

什么是字节？

位（bit）是计算机内部 数据储存 的最小单位。（二进制）

字节（byte）是计算机中 数据处理 的基本单位，习惯用大写B来表示。

1B=8bit （1字节=8位）

1KB=1024B

1M=1024KB

1G=1024M

3、注意事项

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

        //整数
        int a1=100;
        byte a2=100;
        short a3=300;
        long a4=4000000000000000l;
        //使用long长整型时要在后面加“l”，否则会报错
        System.out.println(a4);
        //浮点型
        float a5=199.1f;
        //使用float长整型时要在后面加“f”，否则会报错
        double a6=8000.1241;
        System.out.println(a5);
        System.out.println(a6);
        // 字符 只占一位（bit）
        char  a7='是';
        System.out.println("字符型char="+a7);
        //字符串  String 不是关键字
        String b="打算打打";//多个字符S是大写！！
        //布尔型 boolean
        boolean flag=false;
    }
}

• 使用long长整型时要在后面加**英文字母“L”，大小写都行。**L都推荐大写，小写l与数字1做出区分，增强代码规范性。
• 使用float长整型时要在后面加英文字母“F”，大小写都行。
• 字符串 String 不是关键字；String可以容纳多个字符。

· 拓展知识

1.整数拓展 进制：

• 二进制 0b开头

• 十进制

• 八进制 0开头

• 十六进制：0~9 A~F 对应0~16 0x开头

public class Demo {
    public static void main(String[] args) {
        int a1=10;
        int a2=0b10;//二进制
        int a8=010;//八进制
        int a16=0x10;//十六进制
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a8);
        System.out.println(a16);
    }
}

---

2.浮点数拓展

• 银行业务要怎么表示钱？

  • 浮点数 表达的数字的有限的，离散的，并且存在舍入误差的情况。只能表示接近但不等于的结果。

  • 最好完全避免使用浮点数进行比较。

  • 银行业务可以用类（class）表示BigDecimal （数学工具类）表示。

  • 测试：为什么不能用浮点数表示？float、double

    public class Demo {
        public static void main(String[] args) {
            float a1=10.011f;
            double a2=10.011;
            System.out.println(a1==a2);//输出false,a1不等于a2，为什么？
            float b1=123214141312f;
            float b2=b1+1;
            System.out.println(b1==b2);//输出ture b1还是等于b2
        }
    }
    
    

    进入调试模式，可以发现显示的结果。

    ---

调试模式

1、在代码左侧单机打上红点；2、点运行旁边的甲虫按钮即可

3.字符拓展 char

• char的所有字符的本质还是数字；

• 采用的Unicode编码，是一种编码表，用数字对应字符。因为含有2个字节16bit，所有最高有65536（2^16)个不同的字符。

• 如何反向用数字表示字符？用u0000~uFFFF。前面小写u加 16进制的四位数。

public class Demo {
    public static void main(String[] args) {
        char c1='a';
        char c2='我';
        System.out.println(c1);
        System.out.println((int)c1);//输出97
        //(int)强制转换
        System.out.println(c2);
        System.out.println((int)c2);//输出25105
        char c3='\u0068';//反向编码 前面小写u加 16进制的四位数
        System.out.println(c3);//输出字母h
    }
}

4.转义字符，注意用法

转义字符	含义
\n	换行
\t制表符	制表符
……	……

####需要补充

5.思考题 new？

public class Demo {
    public static void main(String[] args) {
        String a1=new String("hello");
        String a2=new String("hello");
        System.out.println(a1==a2);
        //输出false 为什么？
    }
}

---

三、类型转换

学习时间2022年4月4日

1、转换优先级

由于Java是强类型语言，不同类型的数据需要先转换成同一类型，在进行运算。

优先级：低--------------------------------------->高

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

少字节------------------------------------------>多字节

整型--------------------------------------------->浮点型

2、注意事项

（1）用法

（目标转换类型）变量名

（2）强制转换&自动转换

• 强制转换：优先级高——>低时
• 自动转换： 优先级低——>高时

（3）注意点

1. 对象的数值注意不能溢出（多字节类型转换成低字节类型时注意）

2. 布尔值boolean不能转换；

3. 不能把对象类型转换为不相干的类型；

4. 优先级高转低时注意用“强制转换”。

5. 转换时要注意内存溢出和精度问题

   （内存溢出：多字节---->少字节；

   精度问题：浮点型---->整型）

6. 操作比较大的数时，注意溢出问题。

7. long长整型后面的“l”最好使用大写的"L"和数字1做出区分。

（4）思考：如何计算比较大的数值?

结论：在运算的结果超过数据类型的数值上限时，需要提前将其中一个数转换成更多字节的数据类型，即可进行计算。

public class Demo {
    public static void main(String[] args) {
        /* 要测试
        1、用int类型测试 10亿*20 的输出结果？
        2、如何输出正确的结果？
         */
        int a=10_0000_0000;
        //jdk7新特质：数字之间可以用下划线隔开，且不加入计算
        int b=20;
        System.out.println("test1:\t"+a*b);
        //测试1 直接输出结果  -1474836480 失败
        System.out.println("test2:\t"+(long)a*b);
        //测试2 ：将a转换成long 长整型后输出 20000000000 成功！
        long c=a*b;
        System.out.println("test3:\t"+c);
        //测试3 用long先定义结果c再输出c 失败
        long d=a*(long)b;
        System.out.println("test4:\t"+d);
        //测试4 ：将b转换成long 长整型后输出结果d 20000000000 成功！
    }
}
//结论：在运算的结果超过数据类型的数值上限时，需要提前将其中一个数转换成更多字节的数据类型，即可进行计算。

JDK7新特性，数字之间可以用下划线“_”分割。

四、变量

2022年4月5日

1、变量

• 变量，顾名思义，可以变化的量。

• 在Java中，由于Java是强类型语言，每个变量都必须声明类型。

• 变量是Java中最基本的储存单元，其中的要素包括：变量名，变量类型，还有作用域。

     typ   varName [=  value] [{,varName[=value]}];
  //数据类型   变量名 =    值
  //可以使用“,”都好隔开来声明多个变量。但是不推荐
  

  • 注意
    • 每一个变量类型，可以是基本类型（八大类），也可以是引用类型。
    • 变量名，必须是合法的标识符。
    • 变量声明是一条完整的语句，声明的结尾必须加**“;”分号**以结束。
    • 不推荐用","来一次性多个变量，不易读。

  ---

2、变量作用域

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

（1）类变量

• 需要在赋值前加“static”。
• 作用域是整个类里面。并且随着这个类出现和消失。
• 最常用的方法。
• 在目前的学习阶段可以用类变量取代实例函数。

（2）实例变量

• 从属于对象（类class）。直接在类里、方法外进行赋值。

• 无需初始化。

• 如果不初始化，会变成这个变量的默认值。

  • 所有的数值类的默认值： 0 0.0
  • 布尔值默认值： flase
  • 除了基本类型，其他的默认值都是：null

• 需要用new来“引入”，才能在某个方法内使用。

  public class Demo {
      int a;
      String str;//实例变量
  
      public static void main(String[] args) {
          //System.out.println(a);
          // 直接输出无法使用
          demo0405 demo = new demo0405();
          /*要在这个方法内使用实例变量：
          需要使用“new”函数调用demo0405这个类里的变量.
          并且在接下来的使用中，要注意加上前缀和点“.”。
           */
          System.out.println(demo.a);    //输出0
          System.out.println(demo.str);  // 输出null
          //输出的都是默认值
      }
  }
  

（3）局部变量

• 局部变量作用于在某个方法内。使用前必须声明和初始化值。

---

3、常量

• 在初始化后，不能在改变值，即不会变动的值。

  常量（constant）。初始化（initialize /ɪˈnɪʃəlaɪz/ )

• 所谓常量，是一种特殊的变量，它的值在被设定后，在程序的运行当中是不允许被改变的。

• 用法：final 常量名=常量值

• 常量名一般使用大写字母。

• 在开发程序过程中，可以把一些固定的数值设定为“常量”进行引用。

public class Demo {
    static final double PI=3.14;//设定“类常量”PI为3.14。
    /*
    测试：static 、final、double的前后顺序是否有要求？
    测试结果：double为数据类型，是赋值变量过程的固定顺序
    static和final都是修饰符，顺序并不固定，可以随意颠倒
    后续还会学到更多修饰符，例如private,protected,public等
    */
    public static void main(String[] args) {
        System.out.println(PI);//使用常量，正常输出
    }
}

4、变量的命名规范

• 原则上，所有的变量、方法、类名要做到：见名知意。避免使用拼音，多用英文单词代替。

1-类成员变量：首字母小写和驼峰原则。

出了第一个单词以外，后面的单词首字母大写。例如monthSalary。

2-局部变量：首字母小写和驼峰原则。

3-方法名：首字母小写和驼峰原则。

类变量和局部变量、方法名，参考首字母小写和驼峰原则。

4-常量：所有字母大写，用下划线“_”隔开

MAX_VALUE

5-类名：首字母大写和驼峰原则。

GoodMan

• 类名单词的首字母大写，常量都是大写，其他可以用首字幕小写后续大写。

五、运算符

1、运算符（operator)

• Java全运算符：

  • 算数运算符：+, -, *, /, %, ++, --（%取模、++和–：数值+1或-1）

  • 赋值运算符 ：“=”

  • 关系运算符：>, <, >=, <=, ==(等于), !=(不等于), instanceof(后续)

    （instanceof:用来测试一个对象是否是指定类型的实例对象）

  • 逻辑运算符：&&，||, ! 与或非

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

  • 条件运算符：?, :

  • 拓展赋值运算符：+=, -=, *=, /=

    上课有说过：“a+=b”相当于“a=a+b”其他同理。

2、注意事项

1-小技巧：快速复制粘贴快捷键：ctrl+D

2-注意：在运算时注意小数，遇到结果可能是小数的记得转换类型。

3- 计算的结果转换问题

1. 当数据类型不足int时，结果会自动转换为int。
2. 当数据类型超过int时，结果会采用这几个变量中最高优先级的数据类型。
   • 复习变量优先级：byte,short,char–>int–>long–>float–>double。

4- 关系运算符返回的结果：false true

返回的结果为布尔值。

5-自增自减运算符：++ 和–

特殊运算符：一元运算符：只要一个数参与即可运算。

##思考1：++a与a++的区别

结论：赋值的时机有区别：++在变量前时，先赋值，在自增；++在变量后时，先自增，再赋值。

例子：

public class Demo {
    public static void main(String[] args) {
          //思考，在不同的节点分别输出abc会是多少？
        //试答：3；a=2,b=3;a=1,b=3,c=1;  代码如下
        int a=3;
        System.out.println(a);
        int b=a--;
        /* b=a-- 相当于：
        b=a;
        a=a-1;*/
        System.out.println("a="+a);
        System.out.println("b="+b);
        int c=--a;
         /* c=--a 相当于：
        a=a-1;
        c=a;*/
        System.out.println("a="+a);
        System.out.println("b="+b);
        System.out.println("c="+c);
        //结果正确。     
   }
}

3、Math

算数运算符无法进行的运算，使用“工具类”来操作！

• 比如幂运算 2^3 Math.pow(2,3)

4、逻辑运算符

• 与(and)、 或（or）、 非（取反）

• 结果为布尔值，只有true 和 false；

• 且逻辑运算符只能作用于布尔值。

  a&&b的a和b都必须是布尔值，才能算出结果

1、与 “&&”：逻辑与运算

两个变量都为真，结果才为true

2、或“||”：逻辑或运算

两个变量有一个为真，则结果就是真

3、非“!”：逻辑非运算

如果判断的目标是真，则结果为假；反之亦然。

4、###短路运算

当“与”运算符在执行时，测得第一个变量为false时，则会停止运算。举例：

        int g=5;
        boolean flag=(g>100)&&(g++>5);
        //测试：当&&与运算时，第一个变量为false时，是否还会继续运算？
        System.out.println("测试结果="+flag);
        System.out.println("g="+g);
        //输出的结果为flase；g=5（g没变，说明没有执行g++了）
（简略类和方法）

5、位运算（拓展

• 位运算是二进制的运算，使用2进制运算，计算机的效率极高。
• 复习备用链接：精准空降
• 二进制的位运算是逐位比较。
• 因为比较容易出错，所以实际使用不多。

突发奇想：假如在电路中，1为开，0为关。

1、&——与：两位都为1，则为1，否则为0；

与电路：开关都打开，电路才通，有一个关闭则不通。（串联开关）

2 、|——或：两位都为0，则为0，否则为1；

或电路:开关必须都关闭，电路才不通，否则只要打开一个，电路就通（并联开关）

3 、^——亦或：两位相同，则为0，否则为1；

亦或电路：同时都开或关时，电路不通，反之只有一开一关时电路才通。

4、 ~——非（取反）:逐位取反，0为1,1为0//不够准确哦；

非电路：切换开关状态。

• 注意，描述不够准确，详见下面的思考和博客。

举例:

A=0110 1100

B=0010 1001

试做：

A&B=0010 1000

A|B=0110 1101

A^B=0100 0101

~B =1101 0110 //思考运算测试有误 这个指令是否准确?

public class Demo {
    public static void main(String[] args) {
        int A = 0b0110_1100;
        int B = 0b0010_1001;
        int key1 = 0b0010_1000;//输入手算的答案
        int key2 = 0b0110_1101;
        int key3 = 0b0100_0101;
        int key4 = 0b1101_0110;
        //输出答案对比
        System.out.println(A);
        System.out.println(B);
        System.out.println("结果1对比" + (A & B) + "\n" + key1);
        System.out.println("结果2对比" + (A | B) + "\n" + key2);
        System.out.println("结果3对比" + (A ^ B) + "\n" + key3);
        System.out.println("结果4对比" + (~B) + "\n" + key4);
    }
}

输出结果：

108
41
结果1对比40
40
结果2对比109
109
结果3对比69
69
结果4对比-42
214

显然~的取反答案不对，引发了下面的思考

##思考2：关于“~”位运算中的取反的疑问？

• 关于解答太过复杂没搞懂，涉及二进制的反码、补码、取反。详细看CSDN的解答：按位取反‘~’是啥？
• 简单一个小窍门：

正数的按位取反为本身加一再取负（如~6=-7）；

负数的按位取反为本身加一再取绝对值（如~-6=5）。

5、>> 和 <<移位运算符：把位按指定的值向左或向右移动

可以用于乘法和除法运算(在不考虑溢出和符号位的情况下)

 举几个例子:
     2<<1 =4；  //2向左位移1位  ==  2*2
     3<<2 =12；  //3向左位移2位  == 3*2*2
     5<<5 =160； //5向左位移5位  == 5*（2^5) ==  5*32
     40>>2 = 10  //40向右位移2位 == 40/(2*2) ==  40/4
————————————————————————————————————————————————————————————————     
举个反例：问计算“2*8”怎么样才是最快的？  //据说还是面试题
     已知在计算机中位运算符是最快的，所以我们本体就是要求2*8的位运算怎么表达。
     2*8  == 2*（2^3） 
  即 2<<3 //2向左位移3位 

6、赋值拓展运算符

a+=b; == a=a+b; 以此类推

• 偷懒神技

##思考3：什么是字符串连接符？

• 在Java中字符串是一个常用的东西，而其一个常用的操作是字符串的拼接，Java对此提供了一种非常直观的操作方式——即 + 操作符。by《Java的字符串连接符（+）》

• 我们发现：《字符串连接符》和《相加的算数运算符》的表示均为“+”。

• 在实操中要注意：当输出（print）内容有涉及算数运算符“+”时，当“+”左端链接一个字符串(String)时，会按顺序输出后面的内容，而不是相加。

例题：输出（“”+a+b）和（a+b+“”）会有什么不同？

答：前者按顺序输出a和b的数值，后者则会输出（a+b）的数值。

//测试：                                 据说也是一道面试题。。。
public class Demo {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        System.out.println("前者：");
        System.out.println(""+a+b);//1020
        System.out.println("后者：");
        System.out.println(a+b+"");//30
    }
}
//注意，这里的""两个引号的内容默认就是String类型的字符串，只是内容为空

7、三元运算符（条件运算符 “？” 和“：”）

• 举例：X ? Y : Z

  相当于 if X== true ,Y;else Z；

  相当于 如果X为“真”，则表示为Y，否则表示为Z。

• 常用于 ：精简代码。 便于理解。

• ！！必须掌握！！

##思考4 运算符的优先级是什么样的？动手测试一下

• 首先，括号“（）”的优先级最高，多使用括号可以确保程序正确，并且提高代码的可读性。
• 优先级的总结参考大佬的总结
• 大佬一样提到 “有一个比较好的技巧，当你不清楚优先级的地方就使用小括号去进行代替，帮你解决一切问题，一般人我不告诉他哟”

六、Java中的包 机制 (package)

1、package包

• 语法：package 地址（地址之间用小数点“.”来间隔）

  • package pkg1[.pkg2[.pkg3…]];

• 科学命名：用公司域名倒置作为包的地址。

  • 比如:www.baidu.com 倒置 com.baidu.www
  • 相当于在com包的baidu包的www包

2、import导入

为了能够使用某个包的成员，我们要在Java程序中明确导入该包。使用“import”即可实现。

• import package1[.package2…].(classname|*);

  import 包地址.类名;

  • 其中一种特殊用法：import 包地址.*； （类名改成星号/通配符）

    效果：导入这个包地址下的所有类。

##阅读 《阿里巴巴开发手册》学习规范

七、JavaDoc

1、用JavaDoc生成帮助文档。

用JavaDoc生成自己的API文档。

• 用法：输入"/**"再回车

2、可用的参数信息

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

3、加在类上面就是类的注释；加在方法上面就是方法注释；

部分数据类型还可以自动带出，十分智能。。只是目前还不懂那么多

4、用CMD命令生成API文档

在java目录打开cmd，输入：javadoc -encoding UTF-8 -charset UTF-8 ***.java

• 实验成功可行

##思考5 用IDEA生成JavaDoc文档！

工具—生成javadoc–>设置地区zh_CN–设置参数-encoding UTF-8 -charset UTF-8等，选择好输出内容和输出目录，即可生成

参考