✨你好啊，我是“ 罗师傅”，是一名程序猿哦。
🌍主页链接：楚门的世界 - 一个热爱学习和运动的程序猿
☀️博文主更方向为：分享自己的快乐 briup-jp3-ing
❤️一个“不想让我曾没有做好的也成为你的遗憾”的博主。
💪很高兴与你相遇，一起加油！

前言

目标：Java基础编程，熟练Java开发语法和规则，养成良好编程习惯

注释

Java中的注释，分为三种：

单行注释

多行注释

文档注释
1
2
3
4
5
6
7
// 单行
/*
	多行
*/
/**
	文档注释
*/

思考：Java源代码中如果添加了注释，会不会导致字节码文件会臃肿变大？

回答：不会的。因为源代码文件：Xxxx.Java 通过编译生成字节码文件： Xxxx.class的过程中，编译器会忽略掉源码中的注释部分。

关键字

关键字概述：

被Java语言赋予特定含义的单词

关键字特点：

组成关键字的字母全部小写，常用的代码编辑器对关键字都有高亮显示

Keywords in Java:
instanceof

它的作用是检查一个对象是否是指定类或接口类型的实例，或者是否是该类的子类实例
1
2
3
4
if (obj instanceof MyClass) {
    // obj是MyClass或其子类的实例
    MyClass myObj = (MyClass) obj; // 可以安全地进行类型转换
}
native

是一个修饰符关键字，用于声明一个方法是由非Java代码实现的，通常是由本地代码（如C或C++）实现的。
1
public native void nativeMethod(); // 本地方法声明
synchronized

是一个修饰符关键字，用于控制对共享资源的访问。
1
2
3
4
5
6
7
8
9
10
11
12
public synchronized void synchronizedMethod(){
    // 这里代码在同一时刻只能被一个线程 执行
}
public static synchronized void staticSynchronizedMethod() { // 类对象锁
    // 静态方法的锁是类对象，在同一时刻只能有一个线程执行
}
private Object lock = new Object();
public void someMethod() {
    synchronized(lock) { // 指定对象锁
        // 使用指定的对象作为锁，同一时刻只能有一个线程执行这个代码块
    }
}
transientt

是一个修饰符关键字，用于标记类的成员变量，表示这些变量在序列化过程中将会被忽略，不会被写入对象的持久化存储中。
1
2
3
4
public class MyClass implements Serializable{
    private int normalField; // 这个字段会被序列化
    private transient int tempField; // 这个字段在序列化时会被忽略
}
volatile

它的作用是告诉编译器和虚拟机，被 volatile 修饰的变量在多线程环境下可能会被并发修改，因此需要特殊对待，确保对该变量的读写操作是具有可见性的和按照顺序执行的。
1
2
3
4
5
6
7
8
9
public class SharedData {
    private volatile int count; // 什么声明一个volatile变量
    public void increment() {
        count++; // 对volatile变量进行写入操作
    }
    public void get Count() {
        return count; // 对volatile变量进行读取操作
    }
}

标识符

在Java中，给类、方法、变量起的名字，就是标识符，其可以用来标识这个类、方法、变量

命名规则：

字母、数字、下划线_、美元符号$组成

开头不能是数字

字符大小写敏感

长度没有限制

不能使用Java中的关键字或保留字

命名约定

采用驼峰命名法：
项目名

全部小写。如：workdesk、jobserver。

包名

全部小写，名词。如：java.awt.event。
类和接口

不管是1个还是多个单词，每个单词首字母都大写（大驼峰）
1
2
public class Account{}
public interface AccountBase{}
方法和变量

首字母小写，第二个单词开始每个单词的首字母大写（小驼峰）
1
2
public void getStudentName(){}
int personNum = 1;
常量

全部字符大写，如果是多个单词，单词与单词间使用下划线分隔
1
public static final int MAX_NUM = 10;
尽量使用有意义的名字，尽量做到见名知意
1
2
  int numOfStudent = 10;
String userName = "tom";

常量

概念：在程序运行过车中，其值不可以发生改变的量，称为常量。

分类：字面值常量 和 自定义常量

字面值常量

字符串常量：用双引号括起来的多个字符（可以包含0个、一个或多个）。 ""、"a"、"abc"、"中国"

整数常量：整数 -10、0、88

小数常量：小数 -5.5、1.0.88.88

布尔常量：布尔值，表示真假，只有true和false

空常量：一个特殊的值，空置，值为null

变量

格式1

数据类型变量名；

变量名 = 数据值；

格式2

数据类型变量名 = 数据值；（推荐）

变量一定是要求先声明、再赋值、再使用
1
2
3
int a;
a = 10;
int b = 20; // 声明+赋值
理解：

数据类型：Java是强类型语言，每个常量或变量都有对应的数据类型

变量名：一个标识符，标识内存上的一块空间

数据值：即变量值，该值会存储到变量名标识的那块空间

内存基础知识：

程序执行流程

执行java命令，系统会把编译生成的class文件内容装入内存中的方法区

接下来找到里面的main方法（程序入口）

再在方法栈空间申请一块区域（存储方法中变量）来保证main方法的执行

最后顺序执行main方法中的代码

遇到main方法的“}”或return语句，方法执行结束，main方法函数帧内存释放

变量内存

注意事项

变量名是标识符中的一种，用来标识一块内存区域

变量定义后没有赋初值，不能直接使用，编译报错

变量值的类型应该跟变量的类型一致

数据类型

概述

Java是强类型语言，对于每一种数据都定义了明确的数据类型，不同类型 变量在内存中对应的空间大小不同。

分类：

基本数据类型

整数型 byte short int long

浮点型 float double

字符型 char

布尔型 boolean

引用数据类型

思考：为什么数据类型有这么多种呢？

不同的数据占用的内存空间是不同的

不同的内存空间，所存储的数据的大小范围是不一样

字节

比特位：：bit ，是计算机存储信息的最小单位，存放一位二进制数，即 0 或 1。

字节：byte，是计算机存储容量的最小单位，通常用大写字母“B”表示， **1byte == 8bits**。

计算器存储容量的单位，常见的还有KB、M、G、T，换算过程如下：

1KB (Kilobyte 千字节) = 1024B，其中1024=2^10 ( 2 的10次方)

1MB (Megabyte 兆字节简称“兆”) = 1024KB

1GB (Gigabyte 吉字节又称“千兆”) = 1024MB

1TB (Trillionbyte 万亿字节太字节) = 1024GB

进制

二进制 0b|B开头，由0和1组成

八进制 0开头，0、1…6、7组成

十进制常见整数，0、1…8、9组成

十六进制 0x或0X开头，0、1…8、9、a、b、c、d、e、f组成，大小写不区分

进制转换

任意进制转换为10进制

结果值 = 系数*基数的权次幂相加

0x61：1*16^0 + 6*16^1 = 1 + 96 = 97

变量内存理解：

十进制转换为其他进制

除积倒取余 ，具体计算过程如下：

十进制到二进制的快速转换

上图运算步骤解析：

拆解正整数，将其分解为2的指数倍相加

找出2的指数倍对应的二进制1

根据变量类型确定占用的字节数及比特位，组合得到最终的二进制形式

二进制转换为8、16进制

2进制转化为8进制

从最右边开始，每3位分一组，不足3位的话高位补0

将得到的数字组合到一起，最前面以0开头

2进制转化为16进制

从最右边开始，每4位分一组，不足4位的话高位补0

将得到的数字组合到一起，最前面以0x or 0X开头

原反补码

计算机运算时都是以补码方式进行

原码

就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负。
1
2
 10的原码：0 0(23) 0000 1010
-10的原码：1 0(23) 0000 1010

反码

正数的反码与其原码相同

负数的反码，在原码的基础上，保留了符号位，其他位逐位取反
1
2
3
 10的反码： 跟10的原码相同  0 0(23) 0000 1010
-10的反码： 拿到-10的原码， 1 0(23) 0000 1010
       保留符号位其他位取反 1 1(23) 1111 0101

补码

正数的补码与其原码相同
负数的补码是在其反码的末位加1

1
2
3

 10的补码： 跟10的原码相同  0 0(23) 0000 1010
-10的补码： 拿到-10的反码， 1 1(23) 1111 0101
           在反码基础上加  1 1(23) 1111 0110

//char取值范围推导过程
1.char类型只能表示0或正整数，其最高位不表示符号位
2.char类型占用2个字节，16个比特位
3.最小值 0000 0000 0000 0000 -> 0
4.最大值 1111 1111 1111 1111 -> 65535（大家可借助计算器，也可
以手算）
//byte取值范围推导过程
1.byte类型可以表示正负整数和0
2.byte类型占用1个字节，8个比特位
3.8个比特位 1111 1111 能够表示的数字有 256个
4.最大值 0111 1111 -> 127
5.中间值 0000 0000 -> 0
6.其他值 8个bits能够表示256个数，其中[0,127]占用了128个，剩余的
数都是小于0的，共128个，结果可推理出来为[-128,-1]
7.总结，表示范围[-128,127]

常量补充

注意：整形字面值，不论是二进制、八进制还是十进制、十六进制，默认都是int类型常量。
1
2
3
4
5
// 下面默认都是int类型常量
System.out.println(97);
System.out.println(0x61);
System.out.println(0141);
System.out.println(0b01100001);

类型转换

基本数据类型表示范围大小排序：

隐式类型转换

赋值过程中，小数据类型值或变量可以直接赋值给大类型变量，类型会自动进行转换
1
2
3
4
long = num = 10; // int ---> long
double price = 7.0F; // float ---> double
char c = 'a';
int t = c; // char ---> int
byte、short、char类型的数据在进行算术运算是，会先自动提升为int，然后再进行运算

其他类型相互运算时，表示范围小的会自动提升为范围大的，然后再运算
1
2
3
4
5
6
byte b = 10; 
short s = 5;
int sum = b + s; // 使用变量名进行运算的时候，上升为int
// (byte -> int) + (short -> int)
// 		   int   +  int = int 
short sum2 = b + s; // X int 无法自动转换为 short

显示类型转换

数据类型变量名 = （目标数据类型）（数据值或变量或表达式）
1
2
3
4
5
6
float f1 = (float)3.14;
int size = (int)123L;

// 变量赋值 强制类型转换
double len = 178.5;
int length = (int)len;

特殊情况

1
2
3
4
5
6
7
8
9
10
11
12
byte b = 10; // int --> byte
short s = 20; // int --> short
char c = 97; // int --> char

byte b2 = 127; // [-128, 127]
byte b3 = 128; // x 

short s2 = -32768; //  [-32,768（-2^15）到32,767（2^15 - 1）]
short s3 = -32769; // x

char c2 = 65535; // [0, 65535]
char c3 = 65536; // x 
整形常量优化机制

常量值 > 赋值类型的取值范围 fail

常量值 <= 赋值类型的取值范围 success

注意事项：

常量优化机制只适用于常量，如果是变量，则不可以

该优化机制只针对int类型常量，对于long、float、double等常量，则不可以。