Java基础知识总结(超详细整理)

Java基础知识总结（超详细整理）
Java语⾔的特点
1.⾯向对象
⾯向对象(OOP)就是Java语⾔的基础，也是Java语⾔的重要特性。

⾯向对象的概念：⽣活中的⼀切事物都可以被称之为对象，⽣活中随处可见的事物就是⼀个对象，我们可以将这些事物的状态特征（属性）以及⾏为特征（⽅法）提取并出来，并以固定的形式表⽰。

2.简单好⽤
Java语⾔是由C和C++演变⽽来的，它省略了C语⾔中所有的难以理解、容易混淆的特性（⽐如指针），变得更加严谨、简洁、易使⽤。

3.健壮性
Java的安全检查机制，将许多程序中的错误扼杀在摇蓝之中。

另外，在Java语⾔中还具备了许多保证程序稳定、健壮的特性（强类型机制、异常处理、垃圾的⾃动收集等），有效地减少了错误，使得Java应⽤程序更加健壮。

4.安全性
Java通常被⽤在⽹络环境中，为此，Java提供了⼀个安全机制以防恶意代码的攻击，从⽽可以提⾼系统的安全性。

5.平台⽆关性
Java平台⽆关性由Java 虚拟机实现，Java软件可以不受计算机硬件和操作系统的约束⽽在任意计算机环境下正常运⾏。

6.⽀持多线程
在C++ 语⾔没有内置的多线程机制，因此必须调⽤操作系统的多线程功能来进⾏多线程程序设计，⽽ Java 语⾔却提供了多线程⽀持。

多线程机制使应⽤程序在同⼀时间并⾏执⾏多项任务，该机制使得程序能够具有更好的交互性、实时性。

7.分布式（⽀持⽹络编程）
Java语⾔具有强⼤的、易于使⽤的⽹络能⼒，⾮常适合开发分布式计算的程序。

java中提供了⽹络应⽤编程接⼝()，使得我们可以通过URL、Socket等远程访问对象。

8.编译与解释共存
Java语法基础
标识符： ⽤来标识类名、对象名、变量名、⽅法名、类型名、数组名、⽂件名的有效字符序列。

合法的标识符：
由字母、数字、下划线“_”、美元符号“$”或者“￥”组成，并且⾸字符不能是数字。

不能把java关键字和保留字作为标识符。

标识符对⼤⼩写敏感。

关键字：Java语⾔中已经赋予了特定含义的
保留字： const、goto，Java版本中尚未使⽤，但以后版本可能会作为关键字使⽤
变量：程序运⾏期间可以被改变的量。

在程序中使⽤变量，必须先创建它并为它取⼀个名字，并且指明它能够存储信息的类型，这称为“变量声明”，也叫容器的创建。

变量的使⽤：
变量的声明：数据类型 变量名;
变量的赋值：变量名 = 数据;
变量的操作：放⼊打印语句进⾏输出或者进⾏运算
Java 中的注释有三种：
单⾏注释
多⾏注释
⽂档注释
数据类型
基本数据类型（8个），也称原始数据类型：
引⽤数据类型（3种）：数组、类、接⼝
类型转换：
⾃动类型转换，也叫隐式转换
强制类型转换，也叫显式转换
运算符
运算符：⼀种特殊符号，⽤以表⽰数据的运算、赋值和⽐较数与整数
运算符分类：算术运算符、赋值运算符、⽐较运算符、逻辑运算符、三元运算符
1.算术运算符
2.赋值运算符
3.⽐较运算符
4.逻辑运算符
5.三元运算符
条件表达式b?x:y;，先计算条件b，然后进⾏判断。

如果b的值为true，计算x的值，运算结果为x的值；否则，计算y的值，运算结果为y的值。

Java流程控制语句
选择结构
if语句： if(条件表达式){ ⼀条或多条语句 };
if else语句： if(条件表达式) {语句块1} else {语句块2}
if多分⽀语句：
switch开关语句：
循环结构
在程序中当要重复性的做某项⼯作时可以使⽤循环语句，包括：for循环、while循环、do…while循环。

for循环语句：
while循环语句：
do…while循环语句：
流程跳转
流程跳转语句：break,continue
break：在switch中结束case条件判断，在循环体中结束循环
continue：作⽤在循环体中，结束循环体的本次循环，⽽进⼊下次循环
数组
数组是数据的集合，⼀个容器，⽤来存储任何类型的数据，包括原始数据类型和引⽤数据类型，但是⼀旦指定了数组的类型之后，就只能⽤来存储指定类型的数据。

数组声明的三种⽅式：
数据类型[] 数组名 = new 数据类型[长度];
数据类型[] 数组名 = {数据,数据,…,数据};
数据类型[] 数组名 = new 数据类型长度[] {数据,数据,…,数据};
⼀维数组：
数组变量的声明：
语法：数据类型[] 数组名;，如：int[] num;、double[] d;、String[] str;
数组对象的创建：
语法：数组名 = new 数据类型[长度];，如：num = new int[4];，数组声明其长度后不可改变
赋值：
语法：数组名[下标] = 数据;，如：num[0] = 3;
数组元素的使⽤及遍历：
语法：数组名[下标]，获取指定下标是数据。

⼆维数组：
数组变量的声明：
语法：数据类型[][] 数组名;，如：int[][] num;、double[][] d;、String[][] str;
数组对象的创建：
语法：数组名 = new 数据类型[外长度][内长度];，如：num = new int[4][3];，数组声明其长度后不可改变
赋值：
语法：数组名[外下标][内下标] = 数据;，如：num[0][0]= 3;
数组元素的使⽤及遍历：
语法：数组名[外下标][内下标]，获取指定下标是数据。

对象与类
对象：客观存在能够相互区分的个体，⽐如这辆汽车、这个⼈、这间房⼦、这张桌⼦、这株植物、这张⽀票、这件⾬⾐。

概括来说就是：万物皆对象。

类：若⼲具有相同属性和⾏为的对象的群体或者抽象，类是创建对象的模板，由属性和⾏为两部分组成
类是对象的概括或者抽象，对象是类的实例化。

类的声明
[修饰符] class 类名{//类的声明部分
[成员变量]
[成员⽅法]
}
成员变量的声明： [修饰符] 数据类型变量名 [= 初始值];
成员⽅法的声明：
[修饰符] 返回值类型⽅法名([数据类型参数名,……]){
//⽅法体，该⽅法完成的功能代码
}
构造器的声明：
[修饰符] 构造器名([数据类型参数名,……]){
//构造器完成的功能代码
}
注意：
①构造器名必须和类名⼀致
②构造器没有返回值类型
③任何类都含有构造器。

如果没有显式地定义类的构造器，
④则系统会为该类提供⼀个默认的⽆参的构造器。

⼀旦在类中显式地定义了构造器，系统就不会再为这个类提供默认的构造器了。

类的使⽤
类变量的声明：类名对象名;
类对象的创建，赋值给变量：对象名 = new 构造器([参数列表]);
对象属性的赋值：属性：对象名.属性名、对象名.属性名 = 数据;
属性和⽅法的调⽤：属性：System.out.println(对象名.属性名);⽅法：对象名.⽅法名();
成员变量与局部变量：
成员变量：声明在类中⽅法体之外、可以有缺省值、可以使⽤修饰符。

作⽤域：整个类
局部变量：声明在⽅法体或代码块中、没有缺省值、只能使⽤final修饰。

作⽤域：当前⽅法体
参数：参数的本质是特殊的局部变量，只能定义在⽅法的⼩括号中
重载
⽅法的重载OverLoading： 同⼀个类中定义了多个⽅法名相同⽽参数不同的⽅法
重载在同⼀个类中，⽅法名相同，参数不同（参数的个数、顺序、类型不同）
构造器的重载：
⽅法的返回值类型：
⽆返回值类型：void，return;//结束⽅法体
有返回值类型为：数据类型(基本数据类型、引⽤数据类型)，return 数据;//结束⽅法体，并且返回⼀条数据关键字
this关键字：
this是⼀种特殊的引⽤，指向当前对象
this的两种使⽤⽅法：
如果发⽣局部变量和成员变量命名冲突时，可以通过this.成员变量名的⽅式区分成员变量和局部变量。

⼀个构造⽅法中需要调⽤本类的另⼀个构造⽅法，可以通过this()的⽅式调⽤，但this()必须要书写在第⼀⾏。

static关键字：
静态变量： 使⽤static修饰的成员变量叫做静态变量，静态变量和⾮静态变量的区别是：静态变量被所有的对象所共享，在内存中只有⼀个副本，它当且仅当在类初次加载时会被初始化。

⽽⾮静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

static成员变量的初始化顺序按照定义的顺序进⾏初始化。

静态⽅法： 使⽤static修饰的成员⽅法叫做静态⽅法，静态⽅法可以不依赖于任何对象进⾏访问（对于静态⽅法来说，是没有this的），由于这个特性，在静态⽅法中不能访问类的⾮静态成员变量和⾮静态成员⽅法，因为⾮静态成员⽅法/变量都是必须依赖具体的对象才能够被调⽤。

调⽤格式：类名.静态变量名，类名.静态⽅法名()
静态内部类（static 修饰类的话只能修饰内部类）： 静态内部类与⾮静态内部类之间存在⼀个最⼤的区别: ⾮静态内部类在编译完成之后会隐含地保存着⼀个引⽤，该引⽤是指向创建它的外围类，但是静态内部类却没有。

没有这个引⽤就意味着：1. 它的创建是不需要依赖外围类的创建。

2. 它不能使⽤任何外围类的⾮ static 成员变量和⽅法。

静态代码块：
是⼀个以static为前导的代码块，⼀般⽤于为类的⼯作做⼀些初始化⼯作，如初始化⼀些静态变量。

⼀个类中可以有许多静态初始化块，并且它们可以出现在类体的任何地⽅。

运⾏时系统会保证静态初始化块会按照它们在源代码中出现的顺序被调⽤
static块可以⽤来优化程序性能：因为它只会在类加载的时候执⾏⼀次
super关键字：
super代表的是⽗类对象，
使⽤⽅式：
super.属性名、super.⽅法名();⽤于在⼦类中调⽤⽗类被隐藏的同名实例变量
super([参数列表])⽤于在⼦类的构造⽅法中调⽤⽗类的构造⽅法
每⼀个⼦类的构造⽅法在没有显⽰调⽤super()系统都会提供⼀个默认的super()，super()必须是构造器的第⼀条语句
final关键字:
final 关键字，意思是最终的、不可修改的，最见不得变化 ，⽤来修饰类、⽅法和变量，具有以下特点：
修饰类：类不能继承，final 类中的所有成员⽅法都会被隐式的指定为 final ⽅法；
修饰符变量：该变量为常量，，如果是基本数据类型的变量，则其数值⼀旦在初始化之后便不能更改；如果是引⽤类型的变量，则在对其初始化之后便不能让其指向另⼀个对象。

修饰符⽅法：⽅法不能重写
说明：使⽤ final ⽅法的原因有两个。

第⼀个原因是把⽅法锁定，以防任何继承类修改它的含义；第⼆个原因是效率。

在早期的 Java 实现版本中，会将 final ⽅法转为内嵌调⽤。

但是如果⽅法过于庞⼤，可能看不到内嵌调⽤带来的任何性能提升（现在的 Java 版本已经不需要使⽤ final ⽅法进⾏这些优化了）。

类中所有的 private ⽅法都隐式地指定为 final。

访问修饰符
访问修饰符对成员变量和成员⽅法的访问限定
Java的三⼤特性
封装
封装指隐藏对象的状态信息（属性），不允许外部对象直接访问对象的内部信息（private实现）。

但是可以提供⼀些可以被外界访问的⽅法来操作属性。

将类中成员变量private，提供public的get和set⽅法来控制属性的存取动作，以保证对私有属性操作的安全性：
继承
继承extends：多个类中存在相同属性和⾏为时，将这些内容抽取到单独⼀个类中，那么多个类⽆需再定义这些属性和⾏为，只要继承单独的那个类即可。

多个类可以称为⼦类，单独这个类称为⽗类或者超类。

基本语法：
[修饰符] class ⼦类名 extends ⽗类名{
类体部分
}
继承是使⽤已存在的类的定义作为基础建⽴新类的技术，新类的定义可以增加新的属性或⽅法（对⽗类进⾏扩展），也可以拥有⽗类的属性和⽅法，并且通过⾃⼰的⽅法再次实现⽗类的⽅法（重写）。

通过使⽤继承，可以快速地创建新的类，可以提⾼代码的重⽤，程序的可维护性，节省⼤量创建新类的时间 ，提⾼我们的开发效率。

Java只⽀持单继承，不⽀持多继承。

⼀个类只能有⼀个⽗类，不可以有多个⽗类。

Java⽀持多层继承(继承体系)。

Java继承了⽗类⾮私有的成员变量和成员⽅法，但是请注意：⼦类是⽆法继承⽗类的构造⽅法的。

注意：不要仅为了获取其他类中某个功能⽽去继承 ，类与类之间要有所属(“is a” )关系
⽅法的重写：
⼦类从⽗类继承的某个实例⽅法⽆法满⾜⼦类的功能需要时，需要在⼦类中对该实例⽅法进⾏重新实现，这样的过程称为重写，也叫做覆写、覆盖。

⽅法重写的前提：继承，⼦类的修饰符⼤于等于⽗类，⽅法名、参数列表、返回值类型必须相同
多态
多态：⼀种事物的多种形态（多态的前提：继承、重写、向上转型）
通过多态可以提⾼代码的可重⽤性，降低模块之间的耦合度。

抽象类
抽象类的概念：
Java中可以定义没有⽅法体的⽅法，该⽅法的具体实现由⼦类完成，该⽅法称为抽象⽅法，包含抽象⽅法的类就是抽象类。

如：Shape类计算周长和⾯积的⽅法⽆法确定，那么就可以将这样的⽅法声明为抽象的，以便在具体的⼦类中进⾏实现。

抽象类的声明： [修饰符] abstract class 类名 [extends ⽗类名]{类体}
抽象⽅法的声明： [修饰符] abstract 返回值类型⽅法名([参数列表]);
因为抽象⽅法⽆法确定具体执⾏的功能，所有抽象⽅法没有⽅法体，需要在⼩括号后加上分号
抽象类和普通类除了使⽤abstract修饰外和普通的类相似，抽象类中可以没有抽象⽅法，但是⼀旦某个有抽象⽅法，那么这个类必须被声明为抽象类。

抽象类的使⽤：
因为抽象类不是⼀个具体的类，所以⽆法实例化，但是抽象类可以⽤于声明变量
抽象类可以被继承，在⼦类中实现抽象类的所有抽象⽅法，以达到抽象类的具体化
接⼝
在Java中接⼝不仅仅是程序开发过程中“约定”，更是更加抽象化的抽象类。

接⼝的声明语法： [修饰符] interface 接⼝名{[常量];[抽象⽅法];}
接⼝实现的语法： [修饰符] class 类名 [extends ⽗类名] [implements 接⼝1,接⼝2,……]{类体部分}
⼀个类可以实现多个接⼝，从⽽解决了Java单继承的缺点。

接⼝的作⽤：
提⾼程序的重⽤性提⾼程序的可扩展性降低程序的耦合度实现了多继承。