javaSE数据类型(打开java世界的大门)

前言：
在上两篇文章讲述了java语言的特点以及用记事本(搭配命令行)演示了java程序执行的过程，相信大家已经对java有了一个大概初步的认识，那从这篇文章文章开始，跟随着干饭人的步伐，正式开始java语言的学习吧，好的我已经迫不及待了，家人们上口号！

1.常量

常量，顾名思义，就是固定不变的量，例如：一周有七天，一年有12个月，我们形如这种固定不变的量叫做常量

常量：即程序运行期间，固定不变的量称为常量

1.1常量的分类

1. 字符串常量：由""括起来的，比如“12345”、“hello”、“你好”。 2. 整形常量：程序中直接写的数字(注意没有小数点)，比如：100、1000
2. 浮点数常量：程序中直接写的小数，比如：3.14、0.49
3. 字符常量：由 单引号 括起来的当个字符，比如：‘A’、‘1’
4. 布尔常量：只有两种true和false
5. 空常量：null(后面了讲)

具体如下

public class javademo {
    public static void main(String[] args) {
        System.out.println("hello java");//字符串常量
        System.out.println(3.14);//浮点型常量
        System.out.println('A');//字符常量
        System.out.println(true);//布尔常量
    }
}

2.数据类型

java中数据类型分为两大类：即我们在经常使用的基本数据类型，和java中的引用数据类型

基本数据类型表

2.1java数据类型要点

注意：
这里需要格外注意的就是，java的数据类型一定不要和c语言的搞混淆了，比方说多了字节型和布尔型，而且在java中整型类型int内存占用有4字节

注意：
1.不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节
2.整形和浮点型都是带有符号的
3.整型默认为int型，浮点型默认为double
4.字符串属于引用类型，该中类型后序介绍。

2.2字节知识扩展

什么是字节?
字节是计算机中表示空间大小的基本单位.
计算机使用二进制表示数据. 我们认为 8 个二进制位(bit) 为一个字节(Byte).
我们平时的计算机为 8GB 内存, 意思是 8G 个字节.
其中 1KB = 1024 Byte, 1MB = 1024 KB, 1GB = 1024 MB.
所以 8GB 相当于 80 多亿个字节

3.变量

在了解什么是是常量之后，我们知道常量是不能够被改变的，但实际写代码时肯定要对数据进行修改，所以就不得不引入变量的的概念。

3.1变量概念

1.在程序中，除了有始终不变的常量外，有些内容可能会经常改变，比如：人的年龄、身高、成绩分数、数学函数的计
算结果等，对于这些经常改变的内容，在Java程序中，称为变量。而数据类型就是用来定义不同种类变量的。
2.定义变量前一定要对变量进行初始化，如果定义时没进行初始化，那在使用变量之前一定要对变量进行赋值，不然会发生错误(一定要与c语言中变量使用区别开，即不初始化不再有随机值)

3.2语法格式

定义变量的语法格式为：数据类型 变量名 = 初始值;
int a=1;//定义整形变量 char ch='a';//定义字符变量 double f=2.3;//定义双精度浮点型

整型变量

整型变量

首先整型变量的关键字是int,内存占用大小4字节，可表示的数据范围见代码

public class javademo {
    public static void main(String[] args) {
        System.out.println(Integer.MIN_VALUE);//打印最小值
        System.out.println(Integer.MAX_VALUE);//打印最大值
        //最小值为-2147483648
        //最大值为2147483647
        //这里的Integer是整形的的包装类(后面章节会介绍)
        //暂且理解为整形的加强版吧
    }`

使用整形的注意事项

1. int不论在何种系统下都是4个字节
2. 推荐使用方式一定义，如果没有合适的初始值，可以设置为0
3. 在给变量设置初始值时，值不能超过int的表示范围，则会导致溢出
4. 变量在使用之前必须要赋初值，否则编译报错
5. int的包装类型为 Integer

// 方式一：在定义时给出初始值
 int a = 10; 
 System.Out.println(a); 
 // 方式二：在定义时没有给初始值，但使用前必须设置初值 
 int b;
  b = 10;
  System.Out.println(b); 
 // 使用方式二定义后，在使用前如果没有赋值，则编译期间会报错 
 int c;
  System.Out.println(c); 

7.在定义int性变量时，所赋值不能超过int的范围

int a=66666666666;
//编译时会报错，因为超过了最大储存数值范围

长整型变量

首先长整型变量的关键字是long,内存占用大小8字节，可表示的数据范围见下

public class javademo {

    public static void main(String[] args) {

        System.out.println(Long.MAX_VALUE);//打印最大值
        System.out.println(Long.MIN_VALUE);//打印最小值
        //最大值9223372036854775807
        //最小值-9223372036854775808
    }

使用长整型的注意事项

1. 长整型变量的初始值后加L或者l，推荐加L (建议用大写，小写的容易看错)
2. 长整型不论在那个系统下都占8个字节
3. long的包装类型为Long

短整型变量

首先短整型变量的关键字是short,内存占用大小2字节

public class javademo {

    public static void main(String[] args) {

        System.out.println(short.MAX_VALUE);//打印最大值
        System.out.println(short.MIN_VALUE);//打印最小值
        //最大值32767
        //最小值-32768
    }

使用短整形的注意事项

1. short在任何系统下都占2个字节
2. 使用时注意不要超过范围(一般使用比较少)
3. short的包装类型为Short

字节型变量

首先字节型变量的关键字是byte,内存占用大小1字节

public class javademo {

    public static void main(String[] args) {

        System.out.println(Byte.MAX_VALUE);//打印最大值
        System.out.println(Byte.MIN_VALUE);//打印最小值
        //最大值127
        //最小值-128
    }

使用字节型的注意事项

1. byte在任何系统下都占1个字节
2. 字节的包装类型为Byte

单精度浮点型

首先单精度浮点型型变量的关键字是float,内存占用大小4字节

例如

// 写作 1.0F 也可以
float num = 1.0f; 
 System.out.println(num);

注意事项

1.float 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准.数据储存方式与c语言中相同
2. 由于表示的数据精度范围较小, 一般在工程上用到浮点数都优先考虑 double, 不太推荐使用 float.
3.给初始化的值后加上F或f
4.float的包装类型为Float。

双精度浮点型

首先双精度浮点型型变量的关键字是double,内存占用大小8字节

例如

double d = 3.14; 
System.Out.println(d);

双精度浮点型中几个值得推敲的问题
1.下方代码输出 0.5 吗？

int a = 1; 
int b = 2; 
System.out.println(a / b);  

答案是并不会，因为a和b两个数据类型都为整形，所以输出结果也为整形，即在 Java 中, int 除以 int 的值仍然是 int(会直接舍弃小数部分)。如果想得到 0.5, 需要使用 double 类型计算.

2.下方代码会输出1.21吗？

double num = 1.1;
 System.out.println(num * num); 
 // 执行结果 1.2100000000000002

在浮点型数据中，数据永远不是完全精确的，而是只能精确到某一位，比如说float只可以精确到小数点6到7位，而double只能精确到小数点15位

注意点

1. double在任何系统下都占8个字节
2. 浮点数与整数在内存中的存储方式不同
3.double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在定的精度误差，因此浮点数是个近似值，并不是精确值。
4. double的包装类型为Double

字符型变量

首先字符型型变量的关键字是char,内存占用大小2字节（注意与c语言中的不同）

char c1 = 'A'; 
// 大写字母 char c2 = '1'; 
// 数字字符 
System.out.println(c1);
 System.out.println(c2);
  // 注意：java中的字符可以存放整形
  char c3 = '帅';
   System.out.println(c3);

注意事项

1. Java 中使用 单引号 + 单个字母 的形式表示字符字面值.
2. 计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文关于字符编码方式的讨论, 参见

布尔类型变量

简单来说就是就是表示真或假两种情况的变量，关键字是boolean,内存占用大小1字节

**使用**
boolean b = true; 
System.out.println(b);
 b = false; 
 System.out.println(b);

注意事项

1. boolean 类型的变量只有两种取值, true 表示真, false 表示假.
2. Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法.(注意与c语言区分)

错误示范

boolean value = true; 
System.out.println(value + 1); 
// 代码编译会出现如下错误 Test.java:4: 错误: 二元运算符 '+' 的操作数类型错误
 System.out.println(value + 1); 
 // 第一个类型: boolean
 // 第二个类型: int

数据类型转换

Java 作为一个强类型编程语言, 当不同类型之间的变量相互赋值的时候, 会有教严格的校验，在Java中，当参与运算数据类型不一致时，就会进行类型转换。Java中类型转换主要分为两类：自动类型转换(隐式) 和 强制类型转换(显式)。

自动类型转换(隐式)

自动类型转换即：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。
特点：数据范围小的转为数据范围大的时会自动进行。

例如

int a = 100;
 long b = 10L;
  b = a; 
  // a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值 a = b; 
  // 编译报错，long的范围比int范围大，会有数据丢失，不安全

float f = 3.14F;
 double d = 5.12;
 d = f; 
 // 编译器会将f转换为double，然后进行赋值 f = d; 
 // double表示数据范围大，直接将float交给double会有数据丢失，不安全

byte b1 = 100; 
// 编译通过，100没有超过byte的范围，编译器隐式将100转换为byte byte b2 = 257;
 // 编译失败，257超过了byte的数据范围，有数据丢失

强制类型转换(显式)

强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成。
特点：数据范围大的到数据范围小的。

注意事项

1. 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型
2. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失
3. 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查
4. 强制类型转换不一定能成功，不相干的类型不能互相转换

类型提升

1.不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的。
2.在java中在进行运算时，如果该变量类型小于4字节，那会被先提升为4字节。例(字节型=字节型+字节型)

int与long之间：int会被提升为long

int a = 10; 
long b = 20;
 int c = a + b; 
 // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据 long d = a + b; 
 // 编译成功：a + b==>int + long--->long + long 赋值给long

byte与byte的运算

错误示例

byte a = 10; byte b = 20; 
byte c = a + b; 
//这里的a+b已经转化为了整形，所以左右数据类型不相同
System.out.println(c);
 // 编译报错 Test.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失 byte c = a + b;

正确示例

byte a = 10;
 byte b = 20;
  byte c = (byte)(a + b); 
  //将右侧整形数据类型强制类型转换为字节型
  System.out.println(c);

小结

1. byte 和 byte 都是相同类型, 但是出现编译报错. 原因是, 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a 和b 都提升成 int, 再进行计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误.
   2.由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short 这种低于 4 个字节的类型, 会先提升成 int, 再参与计算.

字符串类型

首先字符串类型，是一个较新颖的类型，回想一下我们在学习c语言时，并没有字符串这样的类型，都是以一个字符数组对一个字符串进行储存，但在java中就有了字符串类型，即在Java中使用String类定义字符串类型

例如

public static void main(String[] args) { 
	String s1 = "hello";
	 String s2 = " world"; 
	System.out.println(s1);
	 System.out.println(s2);
	 System.out.println(s1+s2); // s1+s2表示：将s1和s2进行拼接 }

这里的+号代表的是两个字符串进行拼接，实际上当其他部分其他类型与字符串类型之间存在’+‘号时，也是代表拼接,但如果相邻的数据类型相同’+'就会表示相加运算符如下

public class javademo {

    public static void main(String[] args) {
        String str="a==";
        String str2="好家伙";
        int a=10;
        System.out.println(str+a+str2);
    }
    //输出结果为a==2好家伙

//那这个代码会输出1030a==好家伙吗
public class javademo {
    public static void main(String[] args) {
        String str="a==";
        String str2="好家伙";
        int a=10;
        int b=30;
        System.out.println(a+b+str+str2);
    }
    //其实不然，实际输出结果为40a==好家伙
    //这也证实了相邻的数据类型相同'+'就会表示相加运算符

int 转成 String

1. 方法1 String str1 = num + “”;
2. 方法2 使用字符串的包装类String

int num = 10; 
// 方法1 String str1 = num + ""; 
// 方法2 使用字符串的包装类String 
str2 = String.valueOf(num);

String 转成 int

使用整型数据类型的包装类Integer

String str = "100";
 int num = Integer.parseInt(str);

好哒以上就是你学习java的钥匙，学好它，你才能正真跨进java世界的大门，加油，我们共同努力
三连支持一下吧谢谢家人们