【JAVA 基础学习总结】

JAVA全栈 基础

---

前言

很快近一个月的Java基础学习快结束了，我们在这个月里详细的学习了Java基础语法、数组集合、函数、面向对象基础及其三大特征特征（封装、继承和多态）、常用类及常见算法、异常、IO输入输出流、多线程等。
声明: 文章部分代码及描述来自于Java技能树收录文章，感谢各位优质文章贡献者。

---

Java基础语法

Java标识符命名

标识符： 用来标识类名、对象名、变量名、方法名、类型名、数组名、文件名等有效字符序列。
合法的标识符：

1. Java语言中，标识符都以字母、下划线"_"美元符号$开始的一个字符序列，后面可以跟英文字母、下划线_、美元符号$和数字。
2. 不能把java关键字和保留字符作为标识符。
3. 标识符对大小写敏感。
   JAVA 中常见的关键字：
   备注:不必死记硬背，如果使用关键字作为标识符，编译器能够提示错误。
   
   

Java开发命名规范

• 包名 多个单词组成时所有字母小写（package.com.cn）
• 类名和接口 多个单词组成时所有单词的首字母大写（HelloWorld）
• 变量名和函数名 多个单词组成时第一个单词首字母小写，其它单词首字母大写（lastAccessTime）遵守驼峰标识法。
• 常量名 通常全大写字母标识 （PI圆周率） 遵守：见名知意 即可

变量的使用

• 变量的声明:数据类型变量名;
• 变量的赋值:变量名=数据;
• 变量的操作:放入打印语句进行输出或者进行运算

注释

1、注释的作用
通过注释提高程序的可读性。
2、注释的种类

• (1）单行注释（line comment):用/表示，编译器看到/会忽略该行//后的所文本
• (2）多行注释（blockcomment):用/**/ 表示，编译器看到/*时会搜索接下来的*/，忽略掉 /**/之间的文本。
• (3）文档注释(Javadoc):用/***/表示，是Java特有的注释。注释内容可以被JDK工具
  Javadoc解析，生成一套该程序的网页形式的说明文档。

数据类型

基本数据类型

基本数据类型只有8种，可按照如下分类
①整数类型：long、int、short、byte
②浮点类型：float、double
③字符类型：char
④布尔类型：boolean

基本类型	大小（字节）	默认值	封装类
byte	1	（byte）0	Byte
short	2	（short）0	Short
int	4	0	Integer
long	8	0L	Long
float	4	0.0F	Float
double	8	0.0d	Double
boolean	-	false	Boolean
char	2	\u000(null)	Char

常用的转义字符

转义字符	名称	Unicode	意义
\b	Backspace(退格)	\u0008	退格键，相当于BackSpace
\t	Tab(Tab 键盘)	\u0009	制表符，相当于Tab键
\n	Linefeed（换行）	\u000A	表示换行
\r	Carriage Return（回车）	\u000D	表示接受键盘输入，相当于按下回车
\	Backslash（反斜杠）	\u005C	表示一个斜线字符
\‘	Single Quote	\u0027	单引号
\“	Double Quote	\u0022	双引导

引用数据类型

数组
这是连续分配的一个内存区域块。例如:
int[] a = new int[2];
这里a就是引用了一个长度为2的整数数组。
类、接口
用于引用基于类或接口创建的对象。例如:
Customer customer = new Customer()
这里变量customer就是引用了一个使用Customer类创建的对象。

类型转换

（1）自动类型转换，也叫隐式转换：

要实现自动类型的转换，需要满足两个条件:

• 1、两种类型彼此兼容(比如，数字之间相互转换)
• 2、目标类型取值范围必须大于源类型
  （2）强制类型转换，也叫显式转换

//案例
double num1=123.456;
int num2=(int)num1;

Java内部不支持将一个数值赋给范围更小数值范围的变量，除非进行强制类型转换。但是，请注意:强制类型转换可能导致溢出或者数据精度丢失甚至发生错误。而且，boolean类型数据不参与强制转换。

运算符

类型	运算符
算数运算符	+、-、*、/、%、++、–
关系运算符	>、<、>=、<=、==、!=
逻辑运算符	!、&&、逻辑OR（因表格无法显示）
位运算符	>>、<<、>>>、&、^、~、OR
赋值运算符	=、及其扩展复制算符如+=、-=、*=、/=等
条件运算符	?:
对象运算符	.
下标运算符	[]
实例运算符	instanceof
内存分配运算符	new
强制类型转换运算符	(类型)
方法调用运算符	()

三元运算符
条件表达式:b?x:y，先计算条件b ，然后进行判断，true结果为x，false结果为y

int num = 2>3?2+2:4+4;
//num=8

---

Java流程控制语句

if语句

• 简单的if语句

if(判断条件){
		如果符合条件执行的代码
	}

• if…else语句

if(判断条件){
		满足判断条件时执行的代码块;
	}else{
		不满足判断条件时执行的代码块;
	}

• 多分支

if(判断条件1){
	满足判断条件1时执行的代码块;
	}else if(判断条件2){
		满足判断条件2时执行语句;
	}else if(判断条件3)
		满足判断条件3时执行语句;
	}else{
	
	}

switch语句

switch…case提供多路分支，用于选择的数据类型可以时整数、Char、枚举类型、String

switch(表达式){
	case 取值1:
		执行语句;
		break;
	case取值2:
		执行语句;
		break;
	default:
		执行语句;
		break;
}

for循环语句

for循环语句:

	for (初始化表达式;条件表达式;迭代语句){
		循环体语句
		}

循环语句while

while循环语句:

while(条件表达式）{
	语句或语句块
	}

do…while循环语句:

do{
	语句或语句块
	}while(条件表达式）;

流程跳转
流程跳转语句:break,continue

• break:在switch中结束case条件判断，在循环体中结束循环
• continue:作用在循环体中，结束循环体的本次循环，而进入下次循环
  详细描述:
  break 会强制终止循环并跳出循环体。break 语句用于终止最近的循环或它所在的switch
  语句，适用于for循环、switch两种循环语句。
  continue并不会强制终止循环，只是忽略了本次循环剩下的语句。continue语句将控制权
  传递给它所在的封闭迭代语句的下一次迭代(即跳出本循环，执行下一次循环)，适用于while、
  do while、for循环语句。

---

数组

数组
数组是数据的集合，一个容器，用来存储任何类型的数据，包括原始数据类型和引用数据类型，但是一旦指定了数组的类型之后，就只能用来存储指定类型的数据。

一维数组

数组声明的三种方式：

数据类型[] 数组名 = new 数据类型[长度];
数据类型[] 数组名 = {数据,数据,…,数据};
数据类型[] 数组名 = new 数据类型长度[] {数据,数据,…,数据};

一维数组：
数组变量的声明：
语法：数据类型[] 数组名;，如：int[] num;、double[] d;、String[] str;

数组对象的创建：
语法：数组名 = new 数据类型[长度];，如：num = new int[4];，数组声明其长度后不可改变

赋值：
语法：数组名[下标] = 数据;，如：num[0] = 3;

数组元素的使用及遍历：
语法：数组名[下标]，获取指定下标是数据。

//方法①
for(int i = 0; i < 数组名.length;i ++){
	System.out.println(arr[i]);
	}
//方法②
for(int num:数组名){
		System.out.println(num);
	}

二维数组：

数组变量的声明：
语法：数据类型[][] 数组名;，如：int[][] num;、double[][] d;、String[][] str;

数组对象的创建：
语法：数组名 = new 数据类型[外长度][内长度];，如：num = new int[4][3];，数组声明其长度后不可改变

赋值：
语法：数组名[外下标][内下标] = 数据;，如：num[0][0]= 3;

数组元素的使用及遍历：
语法：数组名[外下标][内下标]，获取指定下标是数据。

//方法①
for(int i=0 ;i<数组名.length;i++){
	for	(int j=0;j<数组名[i].lenght;j++){
		System.out.println(数组名[i][j]);
		}
	}
//方法②
for(int（数据类型） [] a :数组名){
		for(int b:a ){
			a.sout
			}
		sout
	}
	

---

函数

函数的概念：
函数是定义在类中的一段独立的代码块，用来实现某个功能。Java中，函数又被称为方法。

函数的主要作用是为了提高代码的复用性。

函数都是在栈内存中运行；运行的函数处在栈顶。

函数格式：

修饰符  返回值类型  函数名 （ [  参数类型1 参数名1,参数类型2 参数名2.... ] ）{
             //   [ ]    里面表示可选项，即参数不是必须的
             执行语句...
             return  返回值； //返回值的类型必须与返回值类型一致
              }

说明:

• 修饰符：可以是访问修饰符，也可以说是函数修饰符（abstract、final、 static、synchronized）还可以是两者的组合。
• 返回值类型：用于限定函数返回值的数据类型。
• 参数类型：用于限定调用函数时传递的数据类型。
• 参数名：是一个变量，用来接收调用方法时传递的数据。
• return：用来接收方法以及返回函数指定类型的值。 返回值：这个值会返回给函数的调用者。

代码示例：

public class method {
    /*
     * 程序入口,主函数 .
     * 
     * @ 方法 <==> 函数,指的是同一个东西.
     */
    public static void main(String[] args) {
	    // 通过函数名调用
	    method01();

	    method02(9, 3);
	    System.out.println("5+6=" + add(5, 6));
    }

    /*
     * @ 函数的格式为：
     * 
     * @ 访问修饰符 返回值类型 函数名(参数类型1 参数名1,参数类型2 参数名2....){
     * 
     * @ 执行语句
     * 
     * @ return 返回值;//返回值的类型必须与返回值类型一致
     * 
     * @ }
     */
    /*
     * @ 声明一个静态函数method01() 无参数无返回值
     */
    static void method01() {
	    System.out.println("这是method01方法,可以通过method01();调用.");
	    // 这个return可以省略.每个函数都是以return结束,返回到函数调用处
	    return;
    }

    /*
     * 有参数无返回值
     */
    static void method02(int num1, int num2) {
	    method01();
	    System.out.println("这是method02方法,第一个参数是" + num1 + "第二个参数是" + num2);
    }

    /*
     * 有返回值的返回值类型要和要返回的数据类型一致
     * 
     * @ 例如：计算两个整数的和,结果仍然是整型,返回值类型为int.返回值类型可以说基本数据类型，也可是自定义的数据类型
     */
    static int add(int num1, int num2) {
	    int sum = 0; // 声明一个整形变量并初始化为0
	    sum = num1 + num2;// 将num1和num2的和赋值给sum
	    return sum;// 将sum的值返回到调用处
    }

}

函数的重载：
函数的重载是指，在同一个类中，可以定义多个函数名相同、参数列表不同的函数。

参数名相同，参数个数不同，参数列表不同均属于函数重载的情况。注意，函数的重载和返回值类型无关。

调用时通过函数名和参数列表来确定一个函数。

代码示例：

public class Overloading {

    public static void main(String[] args) {

	    //函数同名,发生重载,调用时通过函数名和参数列表来确定一个函数。
	    name(5);
	    name(3, 4);
	    name(1, 'A');
	    name('Z', 26);
    }

    public static void name(int i) {
	    System.out.println("void name(int i)的函数被调用！");
    }
    // 与返回值无关,同名函数会发生错误
    // public static int name(int i) {
    //     System.out.println("int name(int i)的函数被调用！");
    //     return i-1;
    // }

    private static void name(int i, int j) {
	    System.out.println("name(int i, int j)的函数被调用！");
    }

    // private static void name(int j,int i) {} //于 name(int i, int
    // j)是一样的,是同一个函数,会发生错误

    private static void name(int i, char j) {
	    System.out.println("name(int i, char j)的函数被调用！");
    }

    private static void name(char j, int i) {
	    System.out.println("name(char j, int i)的函数被调用！");
    }
}

函数的递归：
函数的递归是指在一个函数的内部调用自身的过程。

递归必须要有结束条件，不然就是陷入无限递归的状态，永远无法结束函数的调用。

代码示例：

public class Recursion {

    public static void main(String[] args) {

	    int sum = sum(50);// 利用递归求1~50的和
	    System.out.println("1+2+3+4+....+47+38+49+50=" + sum);
    }

    // 利用递归求累加值
    private static int sum(int i) {

	    if (i == 1) {
	        return 1;
	    }

	    return i + sum(i - 1);
    }
}

---

面向对象

它将对象视为一种奇特的变量，它除了可以存储数据之外还可以对它自身进行操作。它能够直接反映现实生活中的事物，例如人、车、小鸟等，将其表示为程序中的对象。每个对象都具有各自的状态特征（也可以称为属性).及行为特征.(方法). java就是通过对象之间行为的交互来解决问题的。
面向对象就是把构成问题的事物分解成一个个对象，建立对象不是为了实现一个步骤，而是为了描述某个事物在解决间题中的行为。

三大特征

• 封装:核心思想就是“隐藏细节”、“数据安全”，将对象不需要让外界访问的成员变量和方法私有化，只提供符合开发者意愿的公有方法来访问这些数据和逻辑，保证了数据的安全和程序的稳定。所有的内容对外部不可见。
• 继承:子类可以继承父类的属性和方法，并对其进行拓展。将其他的功能继承下来继续发展。
• 多态:同一种类型的对象执行同一个方法时可以表现出不同的行为特征。通过继承的上下转型、接口的回调以及方法的重写和重载可以实现多态。方法的重载本身就是一个多态性的体现。

---

常用类

java语言中所有的类都默认继承于Object类
我们在学习JAVA过程中常用类包括: Scanner类，System类，String类，
StringBuffer类 Arrays类, Integer类, Long类， Short类， Boolean类，Byte类Character类，Double类，Float类，Math类，Random类，BigDecimal类，Date类。

其中我们在学习中比较常用的方法有:

• equals();比较两个对象的地址值，必须重写equals，重写hashcode
• toString();打印对象信息，默认打印地址，重写后按重写规则打印
• length():获取字符串的长度,其实也就是字符个数 isEmptx():判断是否为空
• contains(): .判断是否含有指定元素
• replace()替换某个元素，replaceAll()以某个新内容替换全部旧内容
• indexQf(Stringstr):获取str在字符串对象中第一次出现的索引 substring(int start.int end):从start开始，到end结束截取字符串。包括start，不包括end

常见算法

排序算法

---

集合

• ArraxList:底层数据结构是数组,查询快，增删慢，线程不安全，效率高，可以存储重复元素
• HashSet:底层数据结构采用哈希表实现，元素无序且唯一，线程不安全，效率高，可以存情cul元素，元素的唯一性是靠所存储元素类型是否重写hashCode()和equals()方法来保证的，如果没有重写这两个方法，则无法保证元素的唯一性。
• TreeSet:底层数据结构采用二叉树来实现，元素唯一且已经排好序:唯一性同样需要重写hashCade和Ecquals)方法，二叉树结构保证了元素的有序性排序要求元素必须实现Compareable接口，并重写里面的comareTo()方法，元素通过比较返回的int值来判断排序序列，返回0说明两个对象相同,不需要存储。
• Map用于保存具有映射关系的数据，Map里保存着两组数据：key和value，它们都可以使任何引用类型的数据，但key不能重复。所以通过指定的key就可以取出对应的value。
• HashMap：基于哈希表实现。使用HashMap要求添加的键类明确定义了hashCode()和equals()[可以重写hashCode()和equals()]。
• TreeMap：非线程安全基于红黑树实现。TreeMap没有调优选项，因为该树总处于平衡状态。

---

异常

Error
Error错误代表了程序运行时Java系统内部的错误，与程序设计者的操作无关。 Error是不可查的 。

Exception
是程序本身可以处理的异常，程序设计者应尽量加以处理的部分。

Exception分为两类，一类是：运行时异常（RuntimeException）另一类是编译时异常（书上写的可称非运行时异常或已检查异常，是因为在Exception类中的子类只有RuntimeException是运行时异常。）
RuntimeException也是不可查异常。
对于不可查异常，编译器不会强制要求处理的异常，而编译时异常（非运行时异常），编译器会强制要求进行处理。

常见的运行时异常	异常描述信息
ArrayIndexOutBoundsException	访问数组时使用了无效索引值 ）
NullPointException	尝试访问null对象成员，空指针异常
ClassCastException	类型转换异常
ArithmeticException	非法算数运算，如以0做除数
NumberFotmatException	数字转化格式异常
IllegalArgumentException	方法接受到非法参数

常见编译时异常	异常描述信息
IOException	输入/输出异常
FileNotFoundException	文件未找到异常
ClassNotFoundException	没有找到class文件

try - catch -finally的学习

try {
    //可能出现异常的代码
}catch(异常类型1 变量名1) {
    //处理异常的方式1
}catch(异常类型2 变量名2) {
    //处理异常的方式2
}
....
finally {
    //一定会执行的代码
}

getMessage()：返回该异常的详细字符串。

printStackTrace():将异常事件的跟踪栈信息输出。建议在捕获到异常时总使用该方法将跟踪栈信息打印输出到控制台。

还有抛出异常，对于多重异常的学习（内外层异常的捕获和处理）。
和throw之后怎么样才能让语句正常执行，有时是编译都不能通过，有时又是语句不能正常输出。

小结

1. try 里面的代码越少越好
2. catch里面必须有内容，哪怕是给出一个简单的提示
3. catch可有多个。但是多个catch中的异常类型如果是“互斥关系（没有继承关系)”，则它们的顺序随意;如果是“包含关系(继承关系)"，则它们的顺序必须小上大下/子上父下。
4. catch 块如果有多个，那么异常对象将从上到下依次匹配类型，一旦某个catch的异常类型匹配成功，其他的catch 将不再执行;即一个异常只能进入一个catch 块。
5. 在 catch 块代码执行完成后，执行try/catch 块后面的代码
6. 除去退出虚拟机的极端情况，不论是否发生异常都会执行finally

throws 和 throw

throws：
利用throws可将异常抛出本函数。如果不想在函数内部处理，或者是处理不了，这可将异常抛出到函数外部。即表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。
throws关键字用在方法的声明中用来指明方法可能抛出一个或多个异常。
语法格式:

throws +异常类名

throw：
除了可使用throws关键字抛出异常外，还可使用throw关键字抛出异常。与 throws不同的是throw用于在方法体内抛出异常对象。
语法如下:

throw异常对象

throw和throws区别
相同点：
两者都是用于做异常的抛出处理的。
不同点：
1、使用的位置不同:
在函数上使用throws声明被抛出的异常类型，在函数内使用throw抛出异常对象。
2、后面接受的内容不同:
throws后是抛出的异常类型，可以有多个，使用逗号隔开。例如:public int read() throws lOException, FileNotFoundException {… }throw后是一个被抛出的异常对象。

IO

I : Input
往内存中去：叫做输入(Input)。或者叫做读(Read)。
O : Output
从内存中出来：叫做输出(Output)。或者叫做写(Write)。
文件专属：

java.io.FileInputStream（掌握）
java.io.FileOutputStream（掌握）
java.io.FileReader
java.io.FileWriter

对象专属流：

java.io.ObjectInputStream（掌握）
java.io.ObjectOutputStream（掌握）

转换流：（将字节流转换成字符流）

java.io.InputStreamReader
java.io.OutputStreamWriter

缓冲流专属：

java.io.BufferedReader
java.io.BufferedWriter
java.io.BufferedInputStream
java.io.BufferedOutputStream

线程

• 进程：可以看做是现实生活当中的公司。
• 线程：可以看做是公司当中的某个员工。
在Java中创建线程的常用方式如下:

1. 继承Thread并重写run()方法
2. 实现 Runnable接口
3. 利用Callable接口