Java基础知识总结（全）_java 基础概念常用类型-优快云博客

本文链接：https://blog.youkuaiyun.com/null_equals/article/details/105318503

本文详细介绍了Java中的基本数据类型，包括数值型、浮点型、字符型和布尔型，以及引用数据类型如类、接口和数组。同时，深入讲解了关键字、类型名称、占用内存、取值范围、默认值、二进制位数和封装类等内容。此外，还探讨了类型转换、修饰符、运算符等核心概念。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

java基本类型

基本数据类型
数值型：byte、short、int、long
浮点类型：float、double
字符型：char
布尔型：boolean
引用数据类型
类：class
接口：interface
数组：[]

关键字	类型名称	占用内存	取值范围	默认值	二进制位数	封装类
byte	字节型	1字节	-128(-2^7)~ 127(2^7-1)	0	8位	Byte
shot	短整型	2字节	-32768(-2^15)~ 32767(2^15-1)	0	16位	Shot
int	整型	4字节	-2147483648(-2^31)~ 2147483647(2^31-1)	0	32位	Integer
long	长整型	8字节	-2^63~ 2^63-1	0L	64位	Long
flot	单精度浮点型	4字节	-3.403E38~3.403E38	0.0F	32位	Flot
double	双精度浮点型	8字节	-1.798E308~1.798E308	0.0D	64位	Double
char	字符型	2字节	一个字符如：‘A’,‘家’	‘\u0000’	16位	Character
boolean	布尔型	1字节	true/false	false	1位	Boolean

对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。如：

基本类型byte 二进制位数：Byte.SIZE最小值：Byte.MIN_VALUE最大值：Byte.MAX_VALUE

基本类型short二进制位数：Short.SIZE最小值：Short.MIN_VALUE最大值：Short.MAX_VALUE

基本类型char二进制位数：Character.SIZE最小值：Character.MIN_VALUE最大值：Character.MAX_VALUE

基本类型double 二进制位数：Double.SIZE最小值：Double.MIN_VALUE最大值：Double.MAX_VALUE

Java基本类型存储在栈中，因此它们的存取速度要快于存储在堆中的对应包装类的实例对象。从Java5.0（1.5）开始，JAVA虚拟机（JavaVirtual Machine）可以完成基本类型和它们对应包装类之间的自动转换。因此我们在赋值、参数传递以及数学运算的时候像使用基本类型一样使用它们的包装类，但这并不意味着你可以通过基本类型调用它们的包装类才具有的方法。另外，所有基本类型（包括void）的包装类都使用了final修饰，因此我们无法继承它们扩展新的类，也无法重写它们的任何方法。

基本类型的优势：数据存储相对简单，运算效率比较高

包装类的优势：有的容易，比如集合的元素必须是对象类型（在创建List时泛型指定必须是Integer而不能是int），满足了java一切皆是对象的思想

注意： double和flot浮点型容易丢失精度，在做银行或其它金钱业务时，切记不要使用这两个基本数据类型，要用BigDecimal ！！

类型转换

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。
转换从低级到高级。

低  ------------------------------------>  高

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

数据类型转换必须满足如下规则：

不能对boolean类型进行类型转换。
不能把对象类型转换成不相关类的对象。会报错
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
转换过程中可能导致溢出或损失精度，例如：

    int i =128;   
    byte b = (byte)i;  //-128

因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。

浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：

    (int)23.7 == 23;        
    (int)-45.89f == -45

1）自动类型转换

            char c1='a';//定义一个char类型
            int i1 = c1;//char自动类型转换为int
            System.out.println("char自动类型转换为int后的值等于"+i1);  //97
            char c2 = 'A';//定义一个char类型
            int i2 = c2+1;//char 类型和 int 类型计算
            System.out.println("char类型和int计算后的值等于"+i2);  //66

解析：c1 的值为字符 a ,查 ASCII 码表可知对应的 int 类型值为 97， A 对应值为 65，所以 i2=65+1=66。

扩展：在一些算法里，可以利用这种转换规则，让代码变得更易懂
2）强制类型转换
把容量大的类型转换为容量小的类型时必须使用强制类型

        int i1 = 123;
        byte b = (byte)i1;//强制类型转换为byte
        System.out.println("int强制类型转换为byte后的值等于"+b);  //123

对象之间也可以使用强制类型转换，但必须要有父子关系，否则不能进行转换

修饰符

Java的修饰符根据修饰的对象不同，分为类修饰符、方法修饰符、变量修饰符，其中每种修饰符又分为访问控制修饰符和非访问控制修饰符。
访问控制存在的原因：
a：让客户端程序员无法触及他们不应该触及的部分
b：允许库设计者可以改变类内部的工作方式而不用担心影响到客户端程序员

修饰符访问权限：

修饰符	当前类	同一包内	子孙类，同一包	子孙类，不同包	其他包
public	Y	Y	Y	Y	Y
protect	Y	Y	Y	Y	N
default	Y	Y	Y	N	N
private	Y	Y	N	N	N

类修饰符

public abstract final
被public修饰的类可以被任何类访问，一个类的内部类可以被其他访问控制修饰符protected、default、private修饰，相当于类的成员。
被abstract修饰的类是抽象类，可以被继承，并实现父类中的抽象方法。
被final修饰的类不可以被其它任何类继承重写其中的方法

方法修饰符

public protect default private static final abstract native synchronized

用static修饰的方法称为静态方法。静态方法是属于整个类的类方法；而不使用static 修饰、限定
的方法是属于某个具体类对象的方法。static方法的调用不需要new一个对象，直接通过类.方法名(参数)即可调用
被final修饰的方法不能被子类方法重写，为了保护方法的安全性和正确性。
用修饰符 native 修饰的方法称为本地方法。为了提高程序的运行速度，需要用其它的高级语言书写程序的
方法体，那么该方法可定义为本地方法用修饰符 native 来修饰。
用synchronized修饰符修饰方法，是用来对多线程编程加锁的一种方法，不太常用，一般锁的粒度为了保证尽量小，一般会对对象加锁。

变量修饰符

public protect default private static final volatile transient

被static修饰的变量为静态变量，静态变量一般不要修改，如果修改，并且通过程序读取静态变量的值可能会引发很难查找的bug，博主当年刚开发时就因为修改了static变量的值，并且在集群环境中获取该值，引发了严重的bug，导致该值偶尔不正确，这种问题不好查找，所以后来被static修饰的变量一定要记着严禁修改。
final修饰的变量是不允许修改的，一般final会配合static共同使用，定义一个永远不变的常量

用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最新值。volatile很容易被误用，用来进行原子性操作。
简单来说，就是计算机有多个核，每个核上都有自己的内存，线程A运行时读取的核A的内存中的变量a=0，写数据的时候也是写到核A上a=1，假如有个线程B在核B上运行，读取核B的内存，同样的变量a在核B上读到的数据还是a=0，因为核A内存的修改不会立即刷新到计算机的内存上，所有多核处理器在处理时就会有数据不同步的情况发生。使用volatile关键字修饰a就会让a=1立即刷新到计算机内存上，并且所有核读取变量a的值都是直接从计算机内存上读取的。这样就避免了多线程时变量的值读取到的不一致情况。但这并不能解决原子性问题

被transient修饰的变量，当对象存储时，它的值不需要维持。换句话来说就是，用transient关键字标记的成员变量不参与序列化过程。transient只作用于实现 Serializable 接口。不管有没有 transient 修饰，静态变量都不能被序列化。

运算符

+ - * /
+：整形的计算；字符串的拼接；任何类型的数据与字符串使用连接符连接时，结果都是字符串的数据类型
-：负号、减
*：乘号
/：除号，除法运算时，结果取整，如5/2=2
%（取余/取模）：所求出的结果取余数
++（自增）：自增就是操作数加1
--（自减）：自减就是操作数减1
=（赋值）
+=（加等于）
-+（减等于）
*=（乘等于）
/=（除等于）
%=（模等于）
==（等于）==用于比较两个基本数据类型的时候，比较的是两个变量存储的值是否相等
         ==用于比较两个引用数据类型的时候，比较的是两个引用类型变量所记录的内存地址是否相等
         字符串的对比一般用Objects.equals(o1,o2);
!=（不等于）
>（大于）
<（小于）
>=（大于等于）
<=（小于等于）

逻辑运算符：

&（与）
&&（短路与）
|（或）
||（短路或）
^(异或)
!(非)

逻辑运算符用代码来说明：

class Demo11 
{
    public static void main(String[] args) 
    {
                //&（与）
        System.out.println(true&true); //结果是:true
        System.out.println(true&false); //结果是: false
        System.out.println(false&true); //结果是:false
        System.out.println(false&false); //结果是:false
        
                //&&（短路与）
                System.out.println(true&&true); //结果是:true
        System.out.println(true&&false); //结果是:false
        System.out.println(false&&true); //结果是: false
        System.out.println(false&&false); //结果是: false

                //|（或）
        System.out.println(true|true);  //结果是: true
        System.out.println(true|false); //结果是:true
        System.out.println(false|true); // 结果是:true
        System.out.println(false|false); //结果是: false

                //||（短路或）
        System.out.println(true||true);  //结果是:true
        System.out.println(true||false); //结果是:true
        System.out.println(false||true); //结果是: true
        System.out.println(false||false); //结果是: false
        
               //^（异或）
        System.out.println(true^true);  //结果是: false
        System.out.println(true^false); //结果是:true
        System.out.println(false^true); //结果是: true
        System.out.println(false^false); //结果是: false
        
                //!（非）
        System.out.println(!true); //结果是: false
        System.out.println(!false); //结果是:true
    }
}

位运算符：

&（与）
|（或）
^（异或）
　　规律：如果操作数A连续异或同一个操作数两次，那么结果还是操作数A　　　
~（取反）

class Demo12{
    public static void main(String[] args){
        System.out.println(6&3); //结果是:2；6的二进制为00000110，3的二进制为00000011，&操作之后的结果是00000010=2
        System.out.println(6|3); //结果是:7；同理|操作之后结果是00000111=7
        System.out.println(6^3); //结果是:5；^操作结果是000000101=5
        System.out.println(~7);  // 结果是:-8；7的二进制位00000111，取反之后是11111000=-8
    }
}

移位运算符：

>>右移
<<左移
>>>（无符号右移）

三目运算符：

布尔表达式?值1:值2；

关键字

java关键字共53个（其中包含两个保留字const，goto）

abstract	interface	implements	this	try
catch	assert	boolean	double	if
else	break	continue	for	switch
case	do	default	finally	int
short	long	float	char	byte
import	instanceof	package	public	private
protect	static	synchronized	goto	native
void	volatile	transient	throws	throw
while	true	false	null	strictfp
const	return	new	super	final
extends	enum	class