Java基础知识总结（一）

一、Java 概述

1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器；1994年将Oak语言更名为Java；

Java的三种技术架构:
JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发；
JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础；
JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序；

开发环境的搭建

JDK、JRE、JVM的关系

1、JDK

Java Development Kit，java的开发和运行环境，java的开发工具和jre。

2、JRE

Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。

3、配置环境变量

让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。
环境变量的配置：
1） 永久配置方式：JAVA_HOME=%安装路径%\Java\jdk
path=%JAVA_HOME%\bin
2） 临时配置方式：set path=%path%;C:\Program Files\Java\jdk\bin
特点：系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。
classpath的配置:
1） 永久配置方式：classpath=.;c:;e:
2） 临时配置方式：set classpath=.;c:;e:\

注意：在定义classpath环境变量时，需要注意的情况如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件；
如果指定了classpath，那么会在指定的目录下查找要运行的类文件。
还会在当前目录找吗？两种情况：
1）如果classpath的值结尾处有分号，在具体路径中没有找到运行的类，会默认在当前目录再找一次。
2）如果classpath的值结果出没有分号，在具体的路径中没有找到运行的类，不会再当前目录找。
一般不指定分号，如果没有在指定目录下找到要运行的类文件，就报错，这样可以调试程序。

4、javac命令和java命令做什么事情呢？

要知道java是分两部分的：一个是编译，一个是运行。
javac：负责的是编译的部分，当执行javac时，会启动java的编译器程序。对指定扩展名的.java文件进行编译。 生成了jvm可以识别的字节码文件。也就是class文件，也就是java的运行程序。
java：负责运行的部分.会启动jvm.加载运行时所需的类库,并对class文件进行执行。
一个文件要被执行,必须要有一个执行的起始点,这个起始点就是main函数。

二、Java 基础语法

1、输入：从键盘上获取输入。

1）、标准输入

byte[] buf=new byte[512];//准备数组用来存放输入的内容
System.out.println(“请输入内容：”);
System.in.read(buf); //从键盘读入 存入byte数组中 此语句会有IOException，此方法是阻塞式的

2）、通过main方法String[]

System.out.print(Integer.parseInt(args[0]));//注意：数字格式化异常

3），通过Scanner类型象调用函数

Scanner scan = new Scanner(System.in);
String str = scan.next();
int num = scan.nextInt(); //注意：类型输入错误，抛异常

2、关键字和标识符

关键字：其实就是某种语言赋予了特殊含义的单词。

保留字：其实就是还没有赋予特殊含义，但是准备日后要使用过的单词。
现Java版本尚未使用，但以后版本可能会作为关键字使用。
具体哪些保留字：goto 、const
注意：自己命名标识符时要避免使用这些保留字
标识符：其实就是在程序中自定义的名词。比如类名，变量名，函数名。包含 0-9、a-z、$、_ ；
规则：

规范

3、常量和变量

常量：是在程序中的不会变化的数据。final 类型 常量名=值；
变量：类的成员属性(也就是全局变量)和局部变量，局部变量在使用之前要赋初始值，全局变量会赋默认值。
变量的作用域：作用域从变量定义的位置开始，到该变量所在的那对大括号结束；
生命周期：
变量从定义的位置开始就在内存中活了；
变量到达它所在的作用域的时候就在内存中消失了；

4、数据类型

取值范围：

1）基本数据类型：

byte、short、int、long、float、double、char、boolean

2）引用数据类型:

数组、类、接口。

级别从低到高为：byte,char,short(这三个平级) --> Int --> float --> long --> double

3)数据类型转换

自动类型转换：从低级别到高级别，系统自动转的；
强制类型转换：什么情况下使用?把一个高级别的数赋给一个别该数的级别低的变量。

1、整数类型之间的相互转换:

		//小范围的赋给大范围的 可以直接赋值
		//大范围的赋给小范围的 可能损失精度  需要强转（有可能出现数据的溢出）
		int num1=129;
		byte b1=2;
		b1=(byte)num1;//强转	
		//short s1=3;
		//s1=b1;

2、实数类型之间的相互转换:

		//小范围的赋给大范围的 可以直接赋值
		//大范围的赋给小范围的 可能损失精度  需要强转
		float f1=12;
		double d1=23;
		f1=(float)d1;

3、实数类型与整数类型之间转换:

	
		//整数类型赋给实数类型可以直接赋值
		//实数类型赋给整数类型  可能损失精度  需要强转  小数部分会被截掉
		double d2=12.23;
		int num2=20;
		num2=(int)d2;

4、字符型与整数之间:

		//char类型可以直接赋值给int long
		//char与short、byte 相互赋值需要强转 short需要强转成byte，而byte可以直接赋值给short
		//整数类型赋值给char类型  需要强转
		//ch=100;  //注意 常量可以直接赋给char

5、字符型与实数之间:

		//字符型可以直接赋值给实数类型
		//实数类型赋值给字符类型  需要强转
		char ch2='a';
		double d3=98.23;
		ch2=(char)d3;

6、布尔类型与其他类型: 不能和其他数据类型进行转换 不兼容

4)基本数据类型注意事项：

int lon=23423432545353L;  //1.注意：若数值过大需加L或l表明是long类型
	//2.小数字面常量默认是double类型
	double d1=1.23D;  //可以加d或D  默认就是double 
	d1=2;
	float f1=2.32f;//注意：float类型存小数时需要加f或F
	f1=12;
	//3.字符型char  2个字节  默认\u0000
	char c1='好';//一个字符（中文、字母、数字、符号）
	c1=97;		//可以赋一个数值(正整数) 而且不能超过char的取值范围
	c1='\n';   //转义字符
	c1='\u0008';
	//4.布尔类型boolean  值：true false  默认值false 字节数没有提供

5)转义字符表：

5、运算符

1）、算术运算符。

/ - + * % %:任何整数模2不是0就是1，所以只要改变被模数就可以实现开关运算。
+:字符串连接符。
++,–

2）、赋值运算符。

= += -= *= /= %=

3）、比较运算符。

特点：该运算符的特点是：运算完的结果，要么是true，要么是false。

4）、逻辑运算符。

& | ^ ! &&(短路) ||(短路)
逻辑运算符除了 ! 外都是用于连接两个boolean类型表达式。
&: 只有两边都为true结果是true。否则就是false。
|:只要两边都为false结果是false，否则就是true
^:异或：和或有点不一样。两边结果一样，就为false。两边结果不一样，就为true.
& 和 &&区别： & ：无论左边结果是什么，右边都参与运算。
&&:短路与，如果左边为false，那么右边不参数与运算。
| 和|| 区别：|：两边都运算。
||：短路或，如果左边为true，那么右边不参与运算。

5）、位运算符:

用于操作二进制位的运算符。
& | ^
<< >> >>>(无符号右移)

练习：对两个变量的数据进行互换。不需要第三方变量。

int a  = 3,b = 5;-->b = 3,a = 5;
			a = a + b; a = 8;
			b = a - b; b = 3;
			a = a - b; a = 5;
			a = a ^ b;//
			b = a ^ b;//b = a ^ b ^ b = a
			a = a ^ b;//a = a ^ b ^ a = b;

	练习：高效的算出 2*8 = 2<<3;

6）、三目运算符: （）？：

表达式1？表达式2：表达式3；
例如，x=2 y=3
int salary=(x ==y)?2000:200;

6、语句和表达式

1）、表达式

//补充：表达式的自动提升
		//1、char byte short会自动转换为int类型进行计算
		byte b1=10;
		byte b2=23;
		//b2=(byte)(b2+b1);//需要强转
		b2+=b1;	//推荐使用这种形式
		//2、优先级低的数据类型与优先级高的数据类型进行计算会自动转换为优先级高的数据类型
		int n1=12;
		double d=12;
		//n1=d+n1;//会出错，需要强转
		//3、字符串与其他类型进行+运算  会自动转换为连接运算 结果会变成字符串类型
		String str=d+"";

2）、if switch do while while for

a）、当判断固定个数的值时，可以使用if，也可以使用switch。但是建议使用switch，效率相对较高。
switch(变量){
case 值:要执行的语句;break;
…
default:要执行的语句;
}

例：

  switch (a){
            case 1:
                System.out.println(1);
                break;
            case 2:
                System.out.println(2);
                break;
            default:
                System.out.println("一定执行的语句");
        }

工作原理：用小括号中的变量的值依次和case后面的值进行对比，和哪个case后面的值相同了就执行
哪个case后面的语句，如果没有相同的则执行default后面的语句。
b）、switch(表达式){case 值：语句;break;…default:语句}

注意：
1、表达式：char byte short int 枚举类型 String(JDK1.7之后)
2、break不能省略
细节：
1）：break是可以省略的，如果省略了就一直执行到遇到break为止；
2）：default可以写在switch结构中的任意位置；如果将default语句放在了第一行，则不管expression与case中的value是否匹配，程序会从default开始执行直到第一个break出现。
3）、当判断数据范围，获取判断运算结果boolean类型时，需要使用if。
4）、当某些语句需要执行很多次时，就用循环结构。
while和for可以进行互换。
区别在于：如果需要定义变量控制循环次数。建议使用for。因为for循环完毕，变量在内存中释放。

break:作用于switch ，和循环语句，用于跳出，或者称为结束。
break语句单独存在时，下面不要定义其他语句，因为执行不到，编译会失败。当循环嵌套时，break只跳出当前所在循环。要跳出嵌套中的外部循环，只要给循环起名字即可，这个名字称之为标号。
continue:只作用于循环结构，继续循环用的。
作用：结束本次循环，继续下次循环。该语句单独存在时，下面不可以定义语句，执行不到。
return:退出方法或结束程序。

7、方 法（函数）：

为了提高代码的复用性，可以将其定义成一个单独的功能，该功能的体现就是java中的方法。
java中的方法的定义格式：
修饰符 返回值类型 方法名(参数类型 形式参数1，参数类型 形式参数1，…){
执行语句；
return 返回值；
}
当函数没有具体的返回值时，返回的返回值类型用void关键字表示。
如果函数的返回值类型是void时，return语句可以省略不写的，系统会帮你自动加上。
return的作用：结束函数。结束功能。

如何定义一个函数？
函数其实就是一个功能，定义函数就是实现功能，通过两个明确来完成：
1）、明确该功能的运算完的结果，其实是在明确这个函数的返回值类型。
2）、在实现该功能的过程中是否有未知内容参与了运算，其实就是在明确这个函数的参数列表(参数类型&参数个数)。

函数的作用：
1）、用于定义功能。
2）、用于封装代码提高代码的复用性。
注意：函数中只能调用函数，不能定义函数。

主函数：
1）、保证该类的独立运行。
2）、因为它是程序的入口。
3）、因为它在被jvm调用。

函数定义名称是为什么呢？
答：1）、为了对该功能进行标示，方便于调用。
2）、为了通过名称就可以明确函数的功能，为了增加代码的阅读性。

重载的定义是：在一个类中，如果出现了两个或者两个以上的同名函数，只要它们的参数的个数，或者参数的类型不同，即可称之为该函数重载了。也叫静态多态
如何区分重载：当函数同名时，只看参数列表。和返回值类型没关系。

8、字符串

		String str="asdaasczc";       //字符串定义的第一种形式  直接用字符串常量赋值
		String str1=new String("asd"); //第二种形式 用构造方法
		int length=str.length();//获取字符串的长度
		char c=str.charAt(1);	//拿到指定位置的字符
		String s=str.concat("nnnnnn");//将指定字符串连接到此字符串str的结尾，得到新的字符串
		int index=str.indexOf("c");// 返回指定子字符串在此字符串中第一次出现处的索引。
		String[] strs=str.split("s");//分割字符串
		boolean flag=true;
		String flag_s=String.valueOf(flag);//将参数转换成String类型
		//字符串的比较:==  比较地址  equals方法 比较内容
		String s1="abc";
		String s2=new String("abc");
		String s3="abc";
		String s4=new String("abc");
 		System.out.println(s1 == s2);//false
		System.out.println(s1 == s3);//true
		System.out.println(s2==s4);//false
		System.out.println(s1.equals(s2));//true
		//String的长度不能改变  StringBuffer长度能改变

9、数 组：

1.数组的理解：

数组(Array)，是多个相同类型数据一定顺序排列的集合，并使用一个名字命名，
并通过编号的方式对这些数据进行统一管理。

2.数组相关的概念：

数组名
元素
角标、下标、索引
数组的长度：元素的个数

3.数组的特点：

• 1.数组是序排列的
• 2.数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
• 3.创建数组对象会在内存中开辟一整块连续的空间
• 4.数组的长度一旦确定，就不能修改。

4. 数组的分类：

① 照维数：一维数组、二维数组、。。。
② 照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组

5.一维数组

一维数组的声名与初始化：
正确的方式：

int num;//声明
		num = 10;//初始化
		int id = 1001;//声明 + 初始化
		int[] ids;//声明
		//1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
		ids = new int[]{1001,1002,1003,1004};
		//1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
		String[] names = new String[5];
	int[] arr4 = {1,2,3,4,5};//类型推断

错误的方式：

//		int[] arr1 = new int[];
//		int[5] arr2 = new int[5];
//		int[] arr3 = new int[3]{1,2,3};

一维数组元素的引用：
通过角标的方式调用。

//数组的角标（或索引从0开始的，到数组的长度-1结束。
		String[] names= new String[5];
		names[0] = "王铭";
		names[1] = "王赫";
		names[2] = "张学良";
		names[3] = "孙居龙";
		names[4] = "王宏志";//charAt(0)

数组的属性：length

System.out.println(names.length);//5
System.out.println(ids.length);

说明：
数组一旦初始化，其长度就是确定的。arr.length
数组长度一旦确定，就不可修改。

一维数组的遍历

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

一维数组元素的默认初始化值

数组元素是整型：0
数组元素是浮点型：0.0
数组元素是char型：0或’\u0000’，而非’0’
数组元素是boolean型：false
数组元素是引用数据类型：null

6.二维数组

如何理解二维数组？

数组属于引用数据类型
数组的元素也可以是引用数据类型
一个一维数组A的元素如果还是一个一维数组类型的，则，此数组A称为二维数组。

二维数组的声明与初始化
正确的方式：

int[] arr = new int[]{1,2,3};//一维数组
		//静态初始化
		int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
		//动态初始化1
		String[][] arr2 = new String[3][2];
		//动态初始化2
		String[][] arr3 = new String[3][];
	//也是正确的写法：
		int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
		int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};//类型推断

错误的方式：

//		String[][] arr4 = new String[][4];
//		String[4][3] arr5 = new String[][];
//		int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};

如何调用二维数组元素:

	System.out.println(arr1[0][1]);//2
	System.out.println(arr2[1][1]);//null
	arr3[1] = new String[4];
	System.out.println(arr3[1][0]);
	System.out.println(arr3[0]);//

二维数组的属性：

		System.out.println(arr4.length);//3
		System.out.println(arr4[0].length);//3
		System.out.println(arr4[1].length);//4

遍历二维数组元素

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

二维数组元素的默认初始化值

规定：二维数组分为外层数组的元素，内层数组的元素
int[][] arr = new int[4][3];
外层元素：arr[0],arr[1]等
内层元素：arr[0][0],arr[1][2]等

数组元素的默认初始化值
针对于初始化方式一：比如：int[][] arr = new int[4][3];
外层元素的初始化值为：地址值
内层元素的初始化值为：与一维数组初始化情况相同

针对于初始化方式二：比如：int[][] arr = new int[4][];
外层元素的初始化值为：null
内层元素的初始化值为：不能调用，否则报错。

7.数组的常见算法

1.数组的创建与元素赋值：

杨辉三角（二维数组）、回形数（二维数组）、6个数，1-30之间随机生成且不重复。

2.针对于数值型的数组：

最大值、最小值、总和、平均数等

3.数组的赋值与复制

int[] array1,array2;
array1 = new int[]{1,2,3,4};

3.1 赋值：

array2 = array1;
如何理解：将array1保存的数组的地址值赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体。

3.2 复制：

array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++){
	array2[i] = array1[i];
}

如何理解：我们通过new的方式，给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。

4.数组元素的反转

//方法一：
//		for(int i = 0;i < arr.length / 2;i++){
//			String temp = arr[i];
//			arr[i] = arr[arr.length - i -1];
//			arr[arr.length - i -1] = temp;
//		}
		
		//方法二：
//		for(int i = 0,j = arr.length - 1;i < j;i++,j--){
//			String temp = arr[i];
//			arr[i] = arr[j];
//			arr[j] = temp;
//		}

5.数组中指定元素的查找：搜索、检索

5.1 线性查找：

实现思路：通过遍历的方式，一个一个的数据进行比较、查找。
适用性：（前提：数组必须有序）

6.数组的排序算法

理解：

1）衡量排序算法的优劣：
时间复杂度、空间复杂度、稳定性
2）排序的分类：内部排序 与 外部排序（需要借助于磁盘）
3）不同排序算法的时间复杂度

4）手写冒泡排序

int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
		//冒泡排序
		for(int i = 0;i < arr.length - 1;i++){
			for(int j = 0;j < arr.length - 1 - i;j++){
				if(arr[j] > arr[j + 1]){
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}	
			}
		}		

8、数组的操作类 Arrays工具类的使用

1.理解：

① 定义在java.util包下。
② Arrays:提供了很多操作数组的方法。

2.使用：

//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
		int[] arr1 = new int[]{1,2,3,4};
		int[] arr2 = new int[]{1,3,2,4};
		boolean isEquals = Arrays.equals(arr1, arr2);
		System.out.println(isEquals);
		
		//2.String toString(int[] a):输出数组信息。
		System.out.println(Arrays.toString(arr1));
		
			
		//3.void fill(int[] a,int val):将指定值填充到数组之中。
		Arrays.fill(arr1,10);
		System.out.println(Arrays.toString(arr1));
		

		//4.void sort(int[] a):对数组进行排序。
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		
		//5.int binarySearch(int[] a,int key)
		int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
		int index = Arrays.binarySearch(arr3, 210);
		if(index >= 0){
			System.out.println(index);
		}else{
			System.out.println("未找到");
		}

10、java分了5片内存。

1：寄存器。2：本地方法区。3：方法区。4：栈。5：堆。
栈：存储的都是局部变量 ( 函数中定义的变量，函数上的参数，语句中的变量 )；
只要数据运算完成所在的区域结束，该数据就会被释放。
堆：用于存储数组和对象，也就是实体。啥是实体啊？就是用于封装多个数据的。
1：每一个实体都有内存首地址值。
2：堆内存中的变量都有默认初始化值。因为数据类型不同，值也不一样。
3：垃圾回收机制。