Java基础知识

一、Java背景知识

1、Java语言平台版本

1. J2SE/JAVASE — Standard Edition—标准版/基础版
2. J2EE/JAVAEE — Enterprise Edition— 企业版/商务版
3. J2ME/JAVAME — Micro Edition — 微型版/移动版

2、Java语言特性

​​​​​​

3、JDK JRE JVM解释

1. JDK(Java Development Kit) — Java开发工具包
2. JRE(Java Runtime Environment) — Java运行时环境
3. JVM(Java Virtual Machine) —JAVA虚拟机 负责加载.class并运行.class文件
   

二、变量

1、标识符

合法：字母、数字、下划线_、美元$
不合法：

• @、%、特殊字符
• 不能以数字开头
• Java关键字、true、false、null

变量名严格区分大小写

2、关键字

50个，包含两个保留字(const、goto)

3、变量定义

定义变量的语法：变量类型 变量名字 = 变量值;

int a = 10；

支持一行声明多个变量

int i, j;

4、常量

一旦被赋值之后，就不能再更改，常量名通常使用大写
声明方式：

final double CM_PER_INCH = 2.54;

类常量声明：

public static final double CM_PER_INCH = 2.54;

5、变量的默认值

• 引用类型的默认值都是null
• byte、short、int、long默认值0
• float、double 默认值0.0
• boolean默认值false
• char默认值是 ‘\u0000’，表现为一个空格

6、局部变量

位置：在方法里/局部代码块中
使用范围：在哪里定义就在哪里使用，当对应的方法/局部代码块结束以后，对应的局部变量也会被释放
注意事项：局部变量必须手动初始化 – 自己赋值

7、成员变量

位置：类里方法外
使用范围：在整个类中都生效，类消失，变量才会释放
注意事项：无需手动初始化，会自动赋予对应类型的默认值

变量就近原则

public class TestVariable {
	static int sum;
	public static void main(String[] args) {
		System.out.println(sum);		//output:0
		int sum = 100;
		System.out.println(sum);		//output:100
	}
}

三、注释

1、单行注释

//这里是单行注释

2、多行注释

/*
*	这里是多行注释
*/

3、Doc注释

/**
 * 这里是文档注释
 * @author
 *
 */

四、Java数据类型

1、数据类型

Java包括两类数据类型：引用类型和8大基本类型

1.1、引用类型：类 数组 接口 …

1.2、Java的8大基本类型

char

char类型的数据需要使用单引号包裹
char类型保存的是单个字符
如果char类型保存的是数字，那么会去ASCII码表中查询这个数字对应的字符打印出来128-65535范围内的字符，eclipse以?处理

特殊字符的转义序列符

转义序列	名称	Unicode值
\b	退格	\u0008
\t	制表	\u0009
\n	换行	\u000a
\r	回车	\u000d
"	双引号	\u0022
’	单引号	\u0027
|反斜杠	\u005c

1.3 基本类型的包装器

基本类型	包装器类型
boolean	Boolean
char	Character
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
void	Void

1.4 字符串String

String s1 = "Hello";
String s2 = "World";
Stirng s3 = s1 + " " + s2;

1.5 枚举enum

enum Size {SMALL, MEDIUM, LARGE, EXTRA_LARGE};
Size s = Size.MEDUIM;

2、基本类型字面值规则

• 整数字面值是int类型
• byte，short，char三种比int小的整数可以用范围内的值直接赋值
• 浮点数的字面值是double类型
• 字面值后缀L D F

long a = 99999999999999L;
float f = 3.14f;
double d = 3.14d;

• 进制前缀

0b - 标识这是2进制 ,如:0b0101
0 - 标识这是8进制, 8进制是三位,如: 023
0x - 标识这是16进制,如: 0x0001
\u -标识这是char类型，属于16进制

3、基本类型的类型转换

箭头方向对应类型的取值范围由“小”到“大”,不是字节数

3.1 小到大隐式转换

byte a = 127;
int b = a;

3.2 大到小强制转换

int a = 128;
byte b = (byte) a;

3.3 浮点转整丢失小数

float f = 3.14f;
int i = (int) f; // i值为3

3.4 不能对boolean类型进行类型转换

4、数据类型的运算规则

4.1 计算结果的数据类型，与最大类型保持一致

System.out.println(3/2);
System.out.println(3d/2);
System.out.println(3d/2d);
System.out.println(3/2d);
System.out.println(3.0/2);

4.2 byte short char 类型进行运算时先提升到int再运算

byte a1 = 10;
short b1 = 20;
byte c1 = (byte) (a1 + b1);

对于+=、-=、*=、/=不需要强转

short s1 = 3;
short s2 = 5;
s1 *= s2;

4.3 整数运算的溢出问题

System.out.println(300000000*60*60*24*365); //659193856
System.out.println(300000000L*60*60*24*365); //9460800000000000
System.out.println(300000000*60L*60*24*365); //9460800000000000
System.out.println(300000000*60*60*24*365L); //-4658544640

4.4 浮点数运算不精确的问题

System.out.println(1-0.8); //0.19999999999999996

4.5 浮点数的特殊值

System.out.println(10.0 / 0); //Infinity – 正无穷
System.out.println(-10.0 / 0); //-Infinity – 负无穷
System.out.println(0.0 / 0.0); //NaN – Not A Number

五、运算符

1、比较运算符

结果是布尔类型

< >= <= == !=

2、自增自减

int a = 1;
System.out.println(a++);	//1		先调用后自增
System.out.println(a);		//2
int b = 1;
System.out.println(++b);	//2		先自增后调用
int c = 1;
System.out.println(--c);	//0
int d = 1;
System.out.println(d--);	//1
System.out.println(--c-c-c--);	//-2

3、逻辑运算符

&&
短路与，有一个假则假，后面代码不执行
||
短路或，有一个真则真，后面代码不执行

4、位运算符

&（与）、|（或）、^（异或）、~（非）
>>（右移位操作符）、<<（左移位操作符）
>>> Java特有的一种（无符号右移位操作符），它使用“零扩展”，无论正负，都在高位插入0

六、控制流程

1、条件语句

• 单分支结构

if(){}

• 多分支结构

if(){}else{}

• 嵌套分支结构

if(){}else if(){}else{}

2、多重选择switch语句

switch(a){
   case 0: syso(0);break;
   case 1: syso(1);break;
   default: syso(2);
}

变量a支持的类型：byte short char int String
执行顺序：会拿着变量a的值依次与每个case后的值做比较，如果不加break会向后穿透所有case，包括default
如果设置了“保底选项default”，并且没有任何case被匹配到的话会执行保底选项的内容
break和default是可选的，根据自己的业务来决定加不加

注意事项：

case后面value的类型必须与变量的类型一致(byte short char int String）
String 是JDK1.7新增
如果case后面没有break，可能会发生穿透的现象
如果添加了保底选项，并且在这之前没有遇到break，或者没有任何选项被匹配到，那就执行default的内容

3、循环结构

3.1 for

for(开始条件;循环条件;更改条件){循环体}
for(int i = 1; i <= 10; i++){}

3.2 while

while(true){
//TODO
}

3.3 do…while…

do{
//TODO
}while(true);

3.4 foreach

public class ForeachFloat {

	public static void main(String[] args) {
		Random rand = new Random(47);
		float f[] = new float[10];
		for(int i = 0; i < 10; i++)
			f[i] = rand.nextFloat();
		for(float x : f)
			System.out.println(x);
	}
	/*Output
	0.72711575
	0.39982635
	0.5309454
	0.0534122
	0.16020656
	0.57799757
	0.18847865
	0.4170137
	0.51660204
	0.73734957
	 *///:~
}

3.5 中断

• break
  直接跳出当前循环
• continue
  跳出当前循环进入下一次循环

3.6 三种循环的区别

for：知道循环次数优先选
while/do while：当循环次数不确定时
while：先判断，不符合规则，不执行代码
do while：代码最少被执行一次，再去判断，符合规则，再次执行代码

3.7 嵌套循环结构

外层循环执行一次，内层循环执行多次

七、方法

1、定义

2、参数

1）方法设置了参数，调用方法时必须按照定义的类型来传参，否则报错
2）如果有多个参数，可以用逗号隔开
3）定义方式：类型 + 参数名

3、调用

1）通过方法名+参数列表调用
2）函数调用顺序

4、修饰符

• public: 公有的
• (default): 不添加修饰符，Java默认为包权限
• protected：继承访问权限
• private： 私有的，只能在本类中使用

5、return

如果一个方法的返回值类型不是void，那么这个方法必须通过return关键字将对应类型的值作为方法的结果返回，返回到调用位置。
返回值可以选择接受，也可以选择不接受

八、数组

概念

数组是相同类型的，用一个标识符名称封装到一起的一个对象序列或基本类型数据序列。数组通过下标操作符[]来定义和使用。

创建

1. 定义
   int[] a1;
   int a1[];
2. 动态初始化
   char[] c = new char[10];
3. 静态初始化
   byte[] b = new byte[]{1,2,3,4,5};
   byte[] c = {1,2,3,4,5};

• Tips1：不论静态和动态初始化，底层都会先给数组元素分配默认值
• Tips2: 数组的长度可以为0

创建过程分析

创建数组 int[] a = new int[5]; JAVA处理过程如下：

1. 在内存中开辟长度是5的连续空间,用来存放数据
2. 给数组完成初始化过程,给每个元素赋予默认值
3. 将数组初始化后的地址引用赋值给变量a
4. 通过下标操作数组中的元素

数组打印

char[] c2 = new char[] {'h', 'e', 'l', 'l', 'o'};
System.out.println(c1);		//output:hello
String[] s = {"a", "b", "c"};
System.out.println(s);		//打印地址值[Ljava.lang.String;@15db9742
System.out.println(Arrays.toString(s));		//output:[a, b, c]

• s是引用类型的变量，保存的是数组的地址值，由于Java对char类型做了底层处理，所以char[]可以直接打印具体内容。但除了char类型以外，其他任何类型的数组想要查看数组中的具体元素，需要使用数组的工具类Arrays.toString()来完成

数组遍历

//创建数组，依次存入数据1-10
int[] a = new int[10];
for(int i = 0; i < a.length; i++) {
	a[i] = i + 1;
}
System.out.println(Arrays.toString(a));
//optput  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

//创建数组，数组元素为100以内的随机数
int length = new Random().nextInt(10);
int[] a = new int[length];
for(int i = 0; i < a.length; i++) {
	a[i] = new Random().nextInt(100);
}
System.out.println(Arrays.toString(a));
//output [66, 56, 90, 48, 27, 68, 2, 85, 85]

数组工具类

1、排序

int[] a = {21, 96, 76, 23, 25};
Arrays.sort(a);
System.out.println(Arrays.toString(a));
//output	[21, 23, 25, 76, 96]

2、数组复制

//复制
int[] from = {1,2,3,4,5};
int[] to = Arrays.copyOf(from, 5);
System.out.println(Arrays.toString(to));	//output  [1, 2, 3, 4, 5]
//缩容
int[] to2 = Arrays.copyOf(from, 3);
System.out.println(Arrays.toString(to2));	//output  [1, 2, 3]
//扩容
int[] to3 = Arrays.copyOf(from, 10);
System.out.println(Arrays.toString(to3));	//output  [1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
//截取
int[] to4 = Arrays.copyOfRange(from, 2, 4);
System.out.println(Arrays.toString(to4));	//output  [3, 4]

数组应用：冒泡排序

public static void main(String[] args) {
	int i[] = {37, 89, 21, 16, 88};
	method(i);
}

private static void method(int[] a) {
	for(int i = 1; i <= a.length - 1; i++) {
		for(int j = 0; j < a.length - i; j++) {
			if(a[j] > a[j + 1]) {
				int t;
				t = a[j];
				a[j] = a[j + 1];
				a[j + 1] = t;
			}
		}
		System.out.println("第" + i + "轮：" + Arrays.toString(a));
	}
	System.out.println(Arrays.toString(a));
}
/* Output:
第1轮：[37, 21, 16, 88, 89]
第2轮：[21, 16, 37, 88, 89]
第3轮：[16, 21, 37, 88, 89]
第4轮：[16, 21, 37, 88, 89]
[16, 21, 37, 88, 89]
 *///:~

二维数组

创建二维数组

int[][] a = {{22,33},{33,99},{66,88}};

遍历二维数组

for (int i = 0; i < a.length; i++) {
	for (int j = 0; j < a[i].length; j++) {
		System.out.println(a[i][j]);
	}
}