一、Java概述
Java 语言发展史
Java最早是由Sun公司（2009年已被Oracle收购）的詹姆斯·高斯林（人称高司令，被誉为“Java语言之父”）在上个世纪90年代初(91年)开发的一种编程语言，最初被命名为Oak(橡树，Java的前身），目标是针对小型家电设备的嵌入式应用，结果市场没啥反响。谁料到互联网的崛起，让Oak重新焕发了生机，于是Sun公司改造了Oak，因发现Oak这个商标已经被人注册了，因此Sun公司注册了Java这个商标，在1995年推出了Java测试版，于1996年发布了正式版JDK1.0,之后Java的发展势头突飞猛进，1999年，Java被分成标准版J2SE、企业版J2EE和微型J2ME,JSP/Servlet技术诞生，Java开始向服务端开发发展。后来J2EE更名Java EE,J2SE更名为Java SE,J2ME更名为Java ME。尽管Java SE的版本不断推陈出新，但目前最受欢迎的版本仍为Java SE 8和Java SE 11。随着互联网的高速发展，Java逐渐成为最重要的网络编程语言之一。
Java所分版本
1、Java SE：定位在个人计算机上的应用。
2、Java EE：定位在服务端的应用。
3、Java ME：定位在消费性电子产品的应用。
三者之间关系图
Java 语言的特点
简单性
Java语言克服了C++语言中的所有的难以理解和容易混淆的点，例如头文件、指针、结构、单元、运算符重载和虚拟基础类等。
面向对象
Java是一种完全面向对象的程序语言，它具有抽象，封装，继承和多态等特性，支持类之间的单继承和接口之间的多继承，还支持类与接口之间的实现机制和全面动态绑定。
跨平台性
Java跨平台就是能在不同的环境（主要是操作系统）上运行java程序，Java 不同于一般的编译执行计算机语言和解释执行计算机语言。它首先将源代码编译成二进制字节码(bytecode)，然后依赖各种不同平台上的虚拟机来解释执行字节码，从而实现了“一次编译、到处执行”的跨平台特性。
可移植性
Java提供的JVM是对Java程序可移植性最直接、最有效的支持。Java语言是可移植的，它并不依赖平台，用Java编写的程序可以运用到任何操作系统上。
安全性
Java 严格遵循面向对象的规范。这样封装了数据细节，只提供接口给用户。增加了数据级的安全性。无指针运算。java中的操作，除了基本类型都是引用的操作。引用是不能进行增减运算，不能被直接赋予内存地址的，从而增加了内存级的安全性。数组边界检查。这样就不会出现C/C++中的缓存溢出等安全漏洞。
健壮性
Java设计之初就是为了写高效可靠和稳健的软件，Java语言的类型安全检查机制，异常处理，自动垃圾收集等是Java程序健壮性的重要保证。此外，Java还收集了其他语言的优点，丢弃了其他语言容易出问题的部分，如指针、手动内存释放等。
动态性
Java语言的设计目标之一是适应于动态变化的环境，Java程序需要的类能够动态地被载入运行环境，也可以通过网络载入所需要的类，程序可以自动进行版本升级。
多线程
多线程是指允许一个应用程序同时存在两个或两个以上的线程，用于支持程序中的事务并发和多任务处理。Java除定义了内置的多线程技术外，还定义了一些类、方法的建立和管理用户定义的多线程，提供了线程之间的同步机制，可以很好保证不同线程对共享数据的正确操作。
二、Java编程基础
变量与常量
1、关键字和保留字
关键字是Java中预先定义好的一些有特别意义的单词,赋予了特殊含义，用做专门用途的单词。保留字：现有 Java 版本尚未使用，但以后版本可能会作为关键字使用的特殊标识符。二者通常都为小写的字符串（单词）。需注意在定义类名，变量名，方法名时，不可使用关键字和保留字。
常见的一些关键字和保留字如下图：
2、标识符与命名规范
标识符是给Java中的类、方法、变量等命名的符号。需要遵守以下规则:
1、标识符只能由字母、数字、下划线、美元符号组成，并且不能以数字开头。
2、Java标识符大小写敏感，长度无限制。
3、标识符不可以是Java关键字和保留字。
3、数据类型
Java数据类型分为基本数据类型和引用数据类型。基本数据类型除了字符型和布尔型之外，其余六个都是表示数字的，统称为“数值型”。
如图所示：
4.变量的定义与赋值
变量是可以改变值的量，必须先声明在使用。声明一个变量之后，必须对其赋值才可以使用，它的值就可以被改变任意多次。
//声明一个变量
数据类型 变量名；
如: int i;//声明了一个变量i
//声明多个变量
数据类型 变量名1，变量名2，变量名3；
变量的赋值使用“=” ，赋值的数据类型必须与声明的数值类型一致。语法有以下几种：
// 先声明变量，后赋值
数据类型 变量名；
变量名=变量值；
//声明变量时就赋值
数据类型 变量名=变量值；
//一次声明多个变量并赋值；
数据类型 变量名1=变量值1，变量名2=变量值2，变量名3=变量值3；
5.常量
常量只是在变量声明语法前加上final关键字即可。常量一旦被赋值后，就不可以在改变。
//声明一个常量
final 数据类型 常量名=常量值；
6、变量的类型转换
Java中数据类型转换主要分为两种:自动类型转换（隐式转换）和强制类型转换（显式转换）。自动类型转换，是指占用字节数少的数据类型的值可以直接赋值给占用字节数多的数据类型的变量。如int类型的值可以直接赋值给double类型的变量。强制类型转换则可以强制的将占用字节数多的数据类型转换为占用字节数少的数据类型的数据，但转换过程可能存在数据精度的丢失。
强制类型转换语法：
数据类型 变量名 =（数据类型） 变量值；
运算符与表达式
1、算数运算符
注：使用%求余数时，符号看%左边的数值。
2、赋值运算符
3、关系运算符
| > | 大于 |
| < | 小于 |
| == | 等于，注意，一个“=”是赋值运算符 |
| >= | 大于或等于 |
| <= | 小于或等于 |
| != | 不等于 |
4、逻辑运算符
| & | 与运算，当两边表达式都为“true”时，结果为“true”，否则结果为“false” |
| | | 或运算，当两边表达式都为“false”时，结果为“false”，否则结果“true” |
| ^ | 异或运算，当两边结果不同时，结果为“true”,否则结果为“false” |
| ！ | 非运算，如果表达式结果为“true”，那么计算结果为“false”，反之亦然 |
| && | 短路与运算，计算结果与&运算符一致，但当第一个表达式为"false"时，第二个表达式就不在运算 |
| || | 短路或运算，计算结果与|运算符一致，但当第一个表达式为“true”时，第二个表达式就不在运算 |
5、位运算符
6、三目运算符 ？：
条件表达式？表达式1：表达式2；
当条件表达式为true时，执行表达式1，否则执行表达式2。
7、运算符的优先级
优先级为: ！ > 算术运算符 > 关系运算符 > && > || > 赋值运算符。其中除赋值运算 为从右向左，其余的运算皆为从左向右运算。
选择结构
Java有三种结构，顺序结构，选择结构，循环结构。基本结构是顺序结构，即从上往下一句一句执行。选择结构是在代码中做一些逻辑判断，如通过if语句、switch语句实现各种逻辑判断，满足某些条件时执行某段代码。
1、if语句
if语句的语法格式如下：
if(条件代码表达式1){
//代码块1
}
else if（条件代码表达式2){
//代码块2
}
else if（条件代码表达式3){
//代码块3
}……
else {
//代码块n
}
在使用过程中，如果if选择结构只需执行一条语句，则可以省略{} 。在{}内定义的变量或常量作用域仅限于{}代码块内，在代码块外无法使用。
2、switch语句
switch（变量）{
case 值 1：
代码块 1；
break；
case 值 2：
代码块 2；
break；
case 值 3：
代码块3；
break；
……
default：
代码块n；
break；
}
switch语句会根据表达式的值从第一个case标签处开始执行，一直执行到break语句处或switch语句的末尾。如果case全都不匹配，则进入default语句。
循环结构
循环结构是Java三大结构之一。它可以在满足某些条件下一直执行某一段程序，从而简化代码。
1、for语句
语法格式如下：
for（循环初始化表达式1；循环条件表达式2；循环后的操作表达式3）{
//循环体
}
其中循环初始化表达式1可以写在for语句前，循环条件表达式2和循环后的操作表达式3均可以写在for循环体内部。但for（）中间的分隔符“；”不可以省略。
2、while语句
语法格式如下：
while（条件表达式）{
//循环体
}
只要条件表达式的值为true，就会执行循环体，直到条件表达式的值为false时才退出循环。while循环一般用于不确定循环次数的场景。
3、do…while语句
语法格式如下：
do{
//循环体
}while（条件表达式）；
首先执行循环体（即至少执行一次），之后再判断条件表达式，如果结果为true，重复上述步骤，直到条件表达式的值为false为止。
4、break和continue语句
在任何循环语句的主体部分，均可以用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。而continue则只能终止某次循环，继续下一次循环。
数组
1、什么是数组
数组是一种用于存储多个相同类型数据的有序集合。数组的数据类型可以是任意的基本数据类型和引用类型，如整数、浮点数、字符等。通过使用数组，我们可以更方便地处理大量相似类型的数据。此外，数组也分为一维数组和多维数组（如常见的二维数组）。
2、数组的创建
声明一个数组需要指定数组的类型和名称。数组的类型可以是任何合法的数据类型，例如int、double、String等。在Java中，数组的创建方式常为以下三种：
//方式一，创建出指定长度的数组，数组有多长，就能存放多少数据
数据类型 [ ] 数组名 = new 数据类型 [数组长度]；
//方式二，创建数组的同时向数组中存储数据，此时不需要指定数组长度，
//有多少元素则数组就有多长
数据类型[ ] 数组名 = new 数据类型[ ]{元素1，元素2，元素3，…}；
//方式三，方式二的简写
数据类型[ ] 数组名 = {元素1，元素2，元素3，…}；
二维数组的创建方式如下：
数据类型 [ ][ ] 数组名 = new 数据类型[m][n];
数据类型 数组名[ ][ ] = new 数组类型[m][n];
数组类型[ ]数组名[ ] = new 数组类型[m][n];
其中m表示数组的长度，n表示这个数组中每个元素的长度。创建二维数组时，n可以不指定，通过后续动态创建。
3、Arrays工具类
Arrays是Java中提供的操作数组的工具类，通过Arrays类可以很方便地操作数组。Arrays常见方法如下:
4、数组的常见操作
索引操作元素
public class Demo{
public static void main(String[] args) {
int [ ] arr = new int [3];//根据索引给数组某个位置赋值，索引不能超过数组长度
arr[0]=10;
arr[1]=20;
arr[2]=30;
//根据索引获取元素
int num2=arr[2];
int num1=arr[1];
int num0=arr[0];
System.out.println("num0:"+num0);
System.out.println("num1:"+num1);
System.out.println("num2:"+num2);
}
}
数组翻转
int[] intArray = { 1, 2, 3, 4, 5 };
ArrayUtils.reverse(intArray);
System.out.println(Arrays.toString(intArray));
//[5, 4, 3, 2, 1]
数组的遍历
public class Demo2 {
public static void main(String[] args) {
// 定义int数组,使用静态初始化方式为元素赋值
int [] arr1 = new int [] {1,2,3,4,5};
System.out.println("数组元素如下：");
// 使用for循环对数组进行遍历，逐个打印数组元素
for(int i = 0; i < arr1.length; i++){int str=arr1[i];
System.out.println("索引为"+i+"处的元素为："+str);
}
}
}
数组的排序
public class Demo3 {
public static void main(String[ ] args) {
int[ ] arr= new int[ ]{10, 5, 12, 13, 7, 4, 2, 15, 9};
bubbleSort(arr);
System.out.println("排序后数组为：");
for(int num : arr){
System.out.print(num + " ");}
}
public static void bubbleSort(int[ ] arr) {
//外层循环控制趟数
for(int i= arr.length- 1; i>0; i--) {
//节点比较，只比较到第i个元素即可
for(int j = 0; j < i; j++) {
//交换元素
if(arr[ j ]>arr[ j+ 1]){int temp = arr[ j ];
arr[ j ]= arr[ j + 1];
arr[ j + 1]= temp;
}
}
}
}
}
JAVA面向对象部分知识点总结
问题导入：面向对象是什么？
面向对象程序设计的思维方式是一种更符合人们思考习惯的方式。面向对象将构成问题的事物分解成各个对象，这些对象是为了描述某个事物在整个问题解决步骤中的行为。面向对象以对象为核心，强调事件的角色、主体，在宏观上使用面向对象进行把控，而微观上依然是面向过程。如果说面向过程的思想是执行者，那么面向对象的思想就是指挥者。
下图为关于面向对象部分知识点的简要梳理：
1、类与对象
1.1 类
1.1.1 类的介绍
将现实生活中一类事物抽象化，提取出这一类事物共有的属性和行为，是共同特征的描述。所以，可以认为 Java 类是定义变量和对象的方法的模型。定义物体属性和方法的阶级特征和行为。一个类是定义的，它可以用来创建该类的实例（对象）。
1.1.2 类的定义
类主要有变量（字段）和方法组成。
变量的定义：
修饰符 变量类型 变量名 = [默认值];
方法的定义：
修饰符 返回值类型 方法名（形参列表）{}
1.1.3 注意事项
类名首字母建议大写，需要见名知意，驼峰模式，不能用关键字。
一个Java文件中可以定义多个class类，但最多只能有一个public修饰的类。而且public修饰的类名必须成为代码文件名。
1.2 对象
1.2.1 对象的介绍
对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。
1.2.2 对象的创建
类名称 对象名称 = new 类名称（）；
1.2.3 如何使用对象
访问属性：对象名.成员变量
访问行为：对象名.方法名（…）
2、三大特征
2.1 封装
2.1.1 什么是封装
封装指隐藏对象的属性和实现细节，仅对外提供公共的访问方式。封装能够在一定程度上提高代码的安全性和复用性，使使用时只需要了解使用方式，不需要知道内部细节。原则： 对象代表什么，就得封装对应的数据，并提供数据对应的行为。
2.1.2 get()/set()方法
封装对类中的域变量进行封闭操作，即用private来修饰他们，如此一来其他类则不能对该变量访问。这样我们就将这些变量封闭在了类内部，无法直接使用和操作。需要通过set方法和get方法进行对变量的赋值和获取值。get()方法用于获取值，set()方法用于赋值。
public class People {
private String name;
private int age;
public People(String name,int age){this.name=name;
this.age=age;
}
public String getName(）{
return name;
}
public void setName(String name){
this.name=name;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age=age;
}
}
2.2 继承
2.2.1 什么是继承
对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原有类的特性，新类称为原有类的子类，原有类称为新类的父类。子类可以从它的父类中继承方法和实例变量。其实质是代码的复用。
特性：
-
单一继承：Java中每个类只能继承一个父类，即一个子类只能有一个直接父类。
-
多层继承：一个类可以有多个子类，子类可以再次作为其他类的父类，形成多层继承关系。
-
子类继承父类的属性和方法：子类会继承父类的非私有属性和方法，可以直接使用父类中的属性和方法。
-
Java中的所有类最终都继承自Object类，可以通过重写Object类的方法对所有类的行为进行统一定制。
2.2.2 继承的使用
JAVA中使用extends关键字表示继承。
class 父类类名{
……
}
class 子类类名 extends 父类类名{
…
}
2.2.3 super关键字
super 可以理解为直接父类对象的引用，或者说super 指向子类对象的父类对象存储空间。可以通过super 访问父类中被子类覆盖的方法或属性。除private 修饰的属性和方法外，子类可以通过super 关键字调用父类中的属性和方法，它的作用是解决子类和父类中属性、方法重名问题。使用方式如下：
super.属性-------------访问超类的成员变量
super.方法（）---------------调用超类的方法
super（参数列表）-----------------调用超类的构造方法
查找范围：直接查找父类。调用构造方法时，调用父类构造方法，放在第一条语句。 需要注意的是，super关键字只能在子类中使用，用于指代当前子类对象所属的父类对象。
2.3 多态
2.3.1什么是多态
多态是指同一类型的对象在不同情况下表现出不同的行为。多态性通过方法的重写和重载来实现。多态的前提是必须存在继承，并且子类重写了父类的方法，最重要的一点是父类引用要指向子类对象。
2.3.2重写和重载
重写：根据对象的不同来表现多态。子类可以继承父类的方法，并在子类中重新定义该方法的实现。当子类对象调用这个方法时，将执行子类的方法实现，而不是父类的方法实现。
重载：根据参数的不同来表现多态。Java中的多态性还可以通过方法的重载和重写来实现。重载是指在同一个类中定义多个方法，它们有相同的名字但参数不同。
2.3.3引用类型数据转换
向上转型：父类引用指向子类对象，属于自动类型转换。格式：
父类类型 变量名 = 子类对象；
向下转型：子类引用指向父类对象，属于强制类型转换。格式：
子类类型 变量名 =（子类类型）父类对象；
3、方法
3.1 构造方法
3.1.1什么是构造方法
构造方法也称作构造器（constructor），用于给对象进行初始化操作，即为对象成员变量赋初始值。它与类同名且没有返回值类型。构造方法分为有参构造和无参构造两类。构造方法的调用必须通过 new 关键字调用，语法格式如下所示。
修饰符 类名(形参列表) { }
3.1.2构造方法的特性
- 给成员变量赋初值。
- 构造方法的名称与类名相同，没有返回值类型。
- 构造方法可以有参数，也可以没有参数。
- 构造方法可以重载，但不能被重写。
- 如果没有在类中显式定义构造方法，编译器会为类生成一个默认的无参构造方法。
- 如果在类中显式定义了构造方法，编译器不会生成默认的无参构造方法。
3.1.3注意事项
1.构造方法可以重载，但是不能重写，因为构造方法不能被继承。
2.如果在子类的构造方法中，没有显式的使用关键字super调用父类的某个构造方法，那么会默认隐式的使用super调用父类无参构造方法。
3.如果类里定义一个或多个构造方法，那么java不提供默认的构造方法（不带参数的构造方法)。因此，当在父类中定义多个构造方法时，应当补充一个不带参数的构造方法，以防子类省略super时出现错误。
3.2 方法的重载
在JAVA中，无论是普通方法，还是构造方法，都可以进行重载。我们在调用重载的方法时，会根据传递的参数不同，来执行不同的方法。通过方法的重载，我们就可以把一系列功能相似，但参数不同的方法，用同一个方法名进行定义。
要求：
1、同名不同参（参数类型、个数、顺序不相同）
2、方法重载和返回参数类型无关
3、方法重载和访问修饰符无关
构造方法重载，构造方法没有返回值。
3.3 方法的重写
子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。
重写方法被调用时，看对象的类型
私有方法不能被重写(父类私有成员子类是不能继承的)
重写时子类方法访问权限不能低于父类
父类中的静态方法不能被重写，如果子类也有相同的方法，并不是重写的父类的方法，而是将父类同名的方法隐藏了起来子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
重写与重载的区别：1、重载发生在本类，重写发生在父类与子类之间；2、重载的方法名必须相同，重写的方法名相同且返回值类型必须相同；3、重载的参数列表不同，重写的参数列表必须相同。
3.4 this关键字
this关键字在成员方法或者构造方法中使用，用来调用当前对象的成员变量、成员方法或构造方法，它代表当前对象。
this.成员变量名------------------访问成员变量
this.方法名()-----------------------调用方法
this(参数列表)--------------------------调用构造方法
调用构造方法：调用本类构造方法，放在第一条语句。
查找范围： 先从本类找，若找不到，则查找父类。
4、修饰词
4.1 访问修饰符
JAVA中访问修饰符有四个，分别是private、protected、public、默认（无修饰符）
public（公开的）：被其修饰的方法、变量任何类都可以进行访问。
private（私有的）：被其修饰的方法、变量仅同一个类可以进行访问。
protected（受保护的）：被其修饰的方法、变量可以被本类、同一个包和子类进行访问。
默认的：不写访问修饰符，表示默认的，被其修饰的方法、变量可以被本类、同一个包进行访问。
优先级：public > protected > default （本类、同一包）> private
4.2 其他修饰符
4.2.1 static
在类中，将与成员变量同级的用static修饰的变量称为静态变量或类变量。Static关键字也可以修饰方法，用static修饰的方法称为静态方法或类方法。静态变量和静态方法可以直接通过类名调用，任何的实例也都可以调用。静态成员在整个程序执行过程中只有一份拷贝，因此可以用于共享数据。
注意：静态方法中不能用this和super关键字。
static变量的生命周期取决于类的生命周期。
类初始化顺序：
静态变量、静态代码块初始化
构造函数
自定义构造函数
4.2.2 final关键字
final是一个修饰符，它可用来修饰类、类中的属性和方法以及局部变量，但是不能修饰构造方法。final的特性主要有下面4种。
• final 修饰的类不可以被继承，但是可以继承其他类。
•final 修饰的方法不可以被重写。
•final 修饰的变量是常量，只能被赋值一次。
•final 修饰的引用类型变量不能改变它的引用地址，但是可以改变对象内部属性的值。
4.2.3 abstract
Java中，抽象的关键字是abstract，不管是抽象类还是抽象方法，都用abstract字修饰，用法如下：
权限修饰符 abstract class 类名 { }
权限修饰符 abstract 返回值类型 方法名（参数列表）；
抽象类注意点：不能创建对象，必须有子类继承抽象类。
4.3 包
4.3.1 package
JAVA通过package关键字声明一个包。包名的命名要求遵循标识符规则。
1)作用：避免类名的冲突
2)包名可以有层次结构，类的全称：包名.类名
3)建议：包名所有字母都小写
4）同包中的类不能同名
4.3.2 import
同包中的类可以直接访问，不同包中的类不能直接访问，当要使用一个类时，这个类与当前程序不在一个包中，必须导入包。只能如下两种访问方式：
1.先import声明类再使用类----------建议
2.类的全称-----(java.lang.object )……----------太繁琐、不建议
使用import关键字导入Java中的包，语法格式如下:
import 包名.类名；
5、接口
接口：接口是一种特殊的抽象类，当抽象类中的方法都是抽象方法的时候，该抽象类可以用另一种形式定义和表示，那就是接口interface。接口的特性如下 ：
1)是一种数据类型（引用类型）。
2)由interface定义。
interface 接口名[ extends 父接口1，父接口2，…]{
//常量定义
//方法定义
}
3)只能包含常量和抽象方法。
4)不能被实例化。
5)接口是需要被实现/继承的，实现类/派生类:必须重写接口中的所有抽象方法。
6)一个类可以实现多个接口，用逗号分隔，若又继承又实现时，应先继承后实现。
7)接口可以继承接口。
25万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
