Java语言基础

一、数据类型

基本数据类型

1. 整型
   • byte
   • short
   • int
   • long
2. 浮点型
   • float
   • double
3. 字符型
   • char
4. 布尔型
   • boolean

基本数据类型	位数	默认值	取值范围	示例
byte	8	0	-2^7 ~ 2^7-1	byte b = 10
short	16	0	-2^15 ~ 2^15-1	short s = 10
int	32	0	-2^31 ~ 2^31-1	int i = 10
long	64	0	-2^63 ~ 2^63-1	long l = 10l / long l =10L
float	32	0.0	1.4E-45 ～3.4E+38	float f = 0.3f
double	64	0.0	4.9E-324 ～1.7E308	double d = 0.3d
char	16	‘\u0000’	0～65535	char c = ‘a’
boolean	1	false	true / false	boolean b = true

public class Test {
    public static void main(String[] args) {
        System.out.println("Byte.MAX_VALUE=" + Byte.MAX_VALUE);
        System.out.println("Byte.MIN_VALUE=" + Byte.MIN_VALUE);

        System.out.println("Short.MAX_VALUE=" + Short.MAX_VALUE);
        System.out.println("Short.MIN_VALUE=" + Short.MIN_VALUE);
        
        System.out.println("Integer.MAX_VALUE=" + Integer.MAX_VALUE);
        System.out.println("Integer.MIN_VALUE=" + Integer.MIN_VALUE);

        System.out.println("Long.MAX_VALUE=" + Long.MAX_VALUE);
        System.out.println("Long.MIN_VALUE=" + Long.MIN_VALUE);

        System.out.println("Float.MAX_VALUE=" + Float.MAX_VALUE);
        System.out.println("Float.MIN_VALUE=" + Float.MIN_VALUE);

        System.out.println("Double.MAX_VALUE=" + Double.MAX_VALUE);
        System.out.println("Double.MIN_VALUE=" + Double.MIN_VALUE);

        System.out.println("Character.MAX_VALUE=" + (int)Character.MAX_VALUE);
        System.out.println("Character.MIN_VALUE=" + (int)Character.MIN_VALUE);
    }
}
/**
    Byte.MAX_VALUE=127
    Byte.MIN_VALUE=-128
    
    Short.MAX_VALUE=32767
    Short.MIN_VALUE=-32768
    
    Integer.MAX_VALUE=2147483647
    Integer.MIN_VALUE=-2147483648
    
    Long.MAX_VALUE=9223372036854775807
    Long.MIN_VALUE=-9223372036854775808
    
    Float.MAX_VALUE=3.4028235E38
    Float.MIN_VALUE=1.4E-45
    
    Double.MAX_VALUE=1.7976931348623157E308
    Double.MIN_VALUE=4.9E-324
    
    Character.MAX_VALUE=65535
    Character.MIN_VALUE=0
*/

引用数据类型

1. 类

   • 基类：System.Object
   • 字符串：String
   • 自定义类：class

2. 接口

   • interface

3. 数组

   • int[]
   • string[]

二、整型溢出

原因

• Java中的基本数据类型都有自己的取值范围，且在Java中数值是“有符号”的，即在二进制存储中最高位表示正负。

• 以int类型为例。Java中int为32位，即最大值为 2^31-1，最高位为0表正数。当数值过大超出int范围，计算机会将最高位变为1，但仍旧按之前方式处理，导致结果为负，造成整型溢出。

示例

/** 
	* 一个人每分钟心跳100次，60年的心跳数
*/
public class Test {
    public static void main(String[] args) {
        int heartBeatNum = 100 * 60 * 24 * 365 * 60; 
        System.out.println(heartBeatNum); // -1141367296 
    }
} 

说明：60年的心跳数已经超出了int的取值范围，导致整型溢出。

解决方法

​ 强制类型转换

/** 
	* 解决方案
*/
public class Test {
    public static void main(String[] args) {
        long heartBeatNum = 100l * 60 * 24 * 365 * 60; 
        System.out.println(heartBeatNum); // 3153600000
    }
} 

说明：因为导致溢出的是 100 * 60 * 24 * 365 * 60 这一表达式计算之后的结果，所以heartBeatNum使用long类型是不够的，需要使其中一个数，如100，在计算时强转为long类型。

三、基本数据类型的包装类

基本数据类型	包装类	高频区间数据缓存
byte	Byte	-128 ~ 127
short	Short	-128 ~ 127
int	Integer	-128 ~ 127
long	Long	-128 ~ 127
float	Float	无
double	Double	无
char	Character	0 ~ 127
boolean	Boolean	[true, false]

高频区间缓存区示例验证

​ 以 int 类型为例

public class Test {
    public static void main(String[] args) {
        Integer varInteger1 = 127 ; // 自动装箱
        Integer varInteger2 = Integer.valueOf(127);
        System.out.println(varInteger1 == varInteger2); // ture

        Integer varInteger3 = -129 ; // 自动装箱
        Integer varInteger4 = Integer.valueOf(-129);
        System.out.println(varInteger3 == varInteger4); // false
    }
}

说明：

1. 127处于高频区间缓存区，varInteger2 会复用之前对象而不会创建新对象，地址相同，所以为true
2. -129已经超出高频区间缓存区，所以会创建新对象，地址不同，所以为false

四、自动装箱/拆箱

自动装箱

自动将基本数据类型转换为包装器类型

Integer i = 10

​ 原理：

• 通过调用包装器的 valueOf() 方法实现
• 返回该整数值的Integer对象

自动拆箱

自动将包装器类型转换为基本数据类型

int i = 10

​ 原理：

• 通过调用包装器的 *xxxValue() *方法实现
• 返回该Integer对象中的整数值

五、Integer VS int

区别

1. 概念：int 是基本数据类型，Integer 是int的包装类
2. 默认值： int 为 0 ，Integer为 null
3. 使用：int 需声明后才可以使用，Integer 需实例化后使用
4. 实质：int 是存储数值，Integer 是对象引用，存储地址

转化

​ 使用自动装箱和自动拆箱的方法

六、逻辑运算符&和&&的区别以及和位运算符&的区别

逻辑运算符&和&&的区别

​ 逻辑运算符&&具有短路特性

public class Test {
    public static void main(String[] args) {
        int out = 10;
        boolean b1 = false;
        if ((b1 == true) && (out += 10) ==20){
            System.out.println("相等，out="+out);
        } else {
            System.out.println("不等，out="+out);
        }
    }
} // 不等, out=10

public class Test {
    public static void main(String[] args) {
        int out = 10;
        boolean b1 = false;
        if ((b1 == true) & (out += 10) ==20){
            System.out.println("相等，out="+out);
        } else {
            System.out.println("不等，out="+out);
        }
    }
} // 不等, out=20

逻辑运算符&和位运算符&的区别

• 逻辑运算符两侧必须是结果为布尔值的表达式
• 位运算符两侧是数值

七、跳出循环语句

break

• break：跳出本层循环
• beak lab：跳出多重循环的外层循环（lab为自己定义的标识）

public class Test {
    public static void main(String[] args) {
        A:
        for(int i =0; i<2; i++) {
            for(int j=0; j<10; j++) {
                if (j >1)  {
                    break A;
                }
                System.out.println("break");
            }
        }
    }
}
/**
	break
	break
*/

continue

• continue：跳出本层的本次循环，继续本层的下一次循环
• continue lab：跳出外层的本次循环，继续外层的下一次循环

public class Test {
    public static void main(String[] args) {
        A:
        for(int i =0; i<2; i++) {
            for(int j=0; j<10; j++) {
                if (j >1)  {
                    System.out.println("###########");
                    continue A;
                }
                System.out.println("continue");
            }
            System.out.println("************");
        }
    }
}
/**
	continue
	continue
	###########
	continue
	continue
	###########
*/

总结

​ 内容涉及Java的入门知识，通过拆分知识点的方式对Java这一语言的基础语法有了认识，并能够较为熟练的运用。但涉及到包装类或是较为底层的机制时还需要研读源码做到真正的理解与掌握。

​ 在整理博客的过程中参考了一些资料以及许多他人优秀的文章，就不一一列举，在此表示感谢。