JavaSE基础知识

基础知识

标识符与关键字

变量名的声明有以下规则：

1. 变量名是由字母、特定符号、数字组成的，在一个类中具有唯一性。

2. 变量名的编写不能由数字开头。

3. 如果变量名使用符号开头，那么只能使用_以及**$**符号。使用字母开头则没有限制。

4. 一般情况下，我们使用驼峰法来规范变量的命名。

Java的标识符是大小敏感的，大小写不同也会是两个不同的标识符。

我们同样可以使用中文来进行命名，但是不推荐，因为不是所有的编码都可以识别中文。容易报错出乱码。

输出字符串常量需要用""英文双引号包裹内容。

数据类型

Java是一种强类型语言

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

​ 强类型语言特点：安全性高，速度稍慢。

弱类型语言对变量的使用并不严格，但同样有规范性。

当我们声明一个变量时，想输出之前，必须先对其赋值。

Java中，声明与赋值可以分开进行，但要确保输出时这个变量是有实际值的。

Java的数据类型分为两大类：

• 8大基本类型

  • 整数类型

    • byte 1字节
    • short 2字节
    • int 4字节
    • long 8字节，赋值时在数字后面加一个L，否则默认是int类型。（当前2020版本的idea在声明时如果数字不大于int类型的最大值，则不会报错。超过后仍需添加L）

  • 浮点类型

    • float 4字节，赋值时在数字后面加一个F，小数声明默认是double类型。
    • double 8字节

  • 字符类型

    • char 2字节，可以是任意语言的字符。

  • 布尔类型

    • boolean : true/false

每种基本数据类型所占的空间大小，是随语言以及编译器变化的。

• 引用数据类型

---

字节

位 bit ：计算机内部数据存储的最小单位，11001100是一个八位二进制数。

字节：计算机中 数据处理 的基本单位，习惯上用大写B 来表示，1字节=8位。

字符：计算机中使用的字母、数字、字以及符号。

除了1字节=8位，后面的单位都是按1024来转换。

32位的电脑最高可以达到4G的内存，64位电脑在理论上可以达到128G内存

整数拓展

• 十进制：正常编写；
• 二进制：赋值时用0b开头，如 int = 0b1100；
• 八进制：赋值时用0开头；
• 十六进制：赋值时用0x开头，数值从0-9,A-F

浮点数拓展

float f = 0.1f; // 0.1
double d = 1.0/10; // 0.1

System.out.println(f==d); // false


float d1 = 23131312312312313f;
float d2 = d1 + 1; 

System.out.println(d1==d2); // true

浮点数float是有限的、离散的，存在舍入误差，是一个接近的大约数，接近但不等于。

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

当我们需要使用浮点类进行数学运算，可以使用一个数学工具类BigDecimal。

字符拓展

字符与数字之间是可以进行强制转换的。

char c1 = '中';
char c2 = 'A';

System.out.println(c1); // 中
System.out.println((int) c1); // 强制转换后：20013

System.out.println(c2); // A
System.out.println((int) c2); // 强制转换后：65

char c3 = '\u0061'; // a 

每个字符本质其实都是一个数字。最初使用Unicode编码表将字符与数字一一对应。

转义字符

//	制表符 \t
System.out.println("Hello\nWorld");
//	换行符 \n
// ...

关于字符声明

String sa = new String("hello world");
String sb = new String("hello world");
System.out.println(sa == sb); //false

String sc = "hello world";
String sd = "hello world";
System.out.println(sc == sd); //true

从内存级别分析，这两种声明方式是不同的。具体会在后面的文章中说明（等我学到）。

布尔值扩展

当我们需要使用布尔类型变量a来进行判断时（比如if），不需要写a==true，直接写a就可以了。

记住程序编写中，Less is More！

类型转换

Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。

int i = 128;
byte b = (byte) i; //内存溢出

System.out.println(i); //128
System.out.println(b); //-128

因为byte类型的数据，只能存储**-128~127**的整数，所以当我们给了一个超出范围的数，就会出错。

具体出错后的值，应该和二进制负数取反码有关，并且和byte的位数有关。

强制转换 可以使用(类型)变量名来进行高–低转换。

自动转换 则是由低到高，不需要执行特殊操作。

注意：

• 布尔值不能进行转换。
• 不能把对象类型转换成不相干的类型
• 把高容量转到低容量的时候，需要使用强制转换
• 转换的时候可能存在内存溢出，或者精度问题

System.out.println((int) 23.7); //23
System.out.println((int) -45.89f); //-45

char c = 'a';
int d = c + 1;
System.out.println(d); //98
System.out.println((char) d); //b

int money = 10_0000_0000;
System.out.println(money);//1000000000

在较新版本的JDK环境下，数字之间可以使用下划线进行分割；下划线本身并不会被输出，但可以方便我们浏览。

两个int类型的数据计算后默认是int类型的结果，即使用long类型去接收，这个结果在转换成long之前也可能已经出现问题了。

解决这个问题，可以先把其中一个int类型强转为long类型，再进行计算。

计算结果的类型是各项中的最高存储类型。（int和long计算结果就是long）

表示long类型时要加一个L或者l，但l在某些字体下容易和1混淆，所以尽量使用大写L来标明long类型。

变量

变量就是可以变化的量。

• Java是强类型语言，每个变量都必须声明其类型。
• Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

注意事项：

• 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
• 变量名必须是合法的标识符。
• 变量声明是一条完整的语句，所以每一个声明都必须以分号结束。

int a = 1, b = 2, c = 3; //不推荐这种同一行多声明的写法，注意程序可读性
String name = "qingjiang";
char x = 'X';
double pi = 3.14;

变量作用域

1. 类变量
   • 从属于类，定义后整个类通用。
2. 实例变量
   • 实例变量需要声明，但无需初始化。
3. 局部变量
   • 局部变量在使用之前必须声明和初始化值，生命周期仅存在于方法内部。
   • 当方法结束后，该变量就”消失”

public class Demo08 {

	//属性：变量

	//类变量 static
	static double salary = 2500;

	//实例变量：从属于对象的，归于本类
	//如果不初始化，则等于该类型的默认值  0		0.0		u0000
	//布尔值默认为false
	//除了基本类型，其余的默认值都是NULL
	String name;
	int age;

	// main方法
	public static void main(String[] args) {

		//局部变量：在方法或者语句块内部
		int i = 10;
		System.out.println(i);

		//变量类型	变量名字 = new Demo08();
		Demo08 demo08 = new Demo08();
		System.out.println(demo08.age);

		//类变量		关键词static
		System.out.println(salary);

	}

	//其他方法
	public void add() {

	}
}

常量

常量 Constant：初始化后值不能被改变。

在需要重复使用某些相同的值时，可以使用常量，然后进行引用。

常量名一般使用大写字符。

public class Demo09 {

	//修饰符，不存在先后顺序
	static final double PI = 3.14;
	final static double PI2 = 3.141;

	public static void main(String[] args) {
		System.out.println(PI); //3.14
		System.out.println(PI2); //3.141
	}
}

变量的命名规范

• 所有命名需要见名知意
• 类成员变量：首字母小写和驼峰原则：monthSalary
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首字母大写和驼峰原则：Man, GoodMan
• 方法名：首字母小写和驼峰原则：run()，runRun()

运算符

Java语言支持如下运算符：

• 算数运算符
• 赋值运算符 =
• 关系运算符 instanceof
• 逻辑运算符
• 位运算符
• 条件运算符
• 扩展赋值运算符
• 字符串连接符：只要+项之间有一个字符串，那么运算规则就变成字符串拼接
• 三元运算符

位运算符

A = 0011 1100
B = 0000 1101

A&B = 0000 1100       一一对应，只有A和B的对应位置都是1时，结果才为1
A|B = 0011 1101       同理，但只要有其中一个是1，结果就是1
A^B = 0011 0001       异或运算，同位相同则是0，不同为1
~B = 1111 0010    取反

2*8 = 16 = 2*2*2*2
位运算的效率是极高的！
<<    *2
>>    /2

0000 0000     0
0000 0001     1
0000 0010     2
0000 0011     3
0000 0100     4
0000 1000     8
0001 0000     16

三元运算符

x ? y : z

如果x==true，则结果为y，否则结果为z

int score = 80;
String type = score < 60 ? "不及格" : "及格";
System.out.println(type); //及格

括号内的运算优先级最高。

包机制

包的本质，就是一个文件夹。

一般利用公司域名倒置作为包名。

为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用”import”语句可以完成此功能。

import package1[.package2...].(classname|*); //*为通配符，会导入这个包下所有的类

package语句必须处于整个文档的首行，import在下面。

JavaDoc

此类命令用于生成自己的API文档

/**
 * @author Jie ZHOU
 * @version 1.0				//版本号
 * @since 1.8				//指明需要最早使用的jdk版本
 */
public class Doc {

	String name;

	/**
	 * @author Jie ZHOU
	 * @param name			//参数名
	 * @return				//返回值情况
	 * @throws Exception  	//异常抛出情况
	 */
	public String test(String name) throws Exception {
		return name;
	}

加在类上面就是类注释，方法上就是方法注释。