JAVA _基础篇

Hylenow

已于 2022-05-03 15:25:17 修改

阅读量1.2k

点赞数

分类专栏： Java学习文章标签： java 开发语言后端

于 2022-01-24 14:01:39 首次发布

本文链接：https://blog.csdn.net/qq_45549584/article/details/122637620

版权

Java学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一）Java开发入门

什么是Java

计算机语言是人与计算机之间通信的语言，它主要由一些指令组成，这些指令包括数字、符号和语法等内容，程序员可以通过这些指令来指挥计算机进行各种工作。

Java是一种高级计算机语言，它是由SUN公司（已被Oracle公司收购）于1995年5月推出的一种可以编写跨平台应用软件、完全面向对象的程序设计语言。Java语言简单易用、安全可靠、主要面向Internet编程。

为了使软件开发人员、服务提供商和设备生产商可以针对特定的市场进行开发，SUN公司将Java划分为三个技术平台，它们分别是JavaSE、JavaEE和JavaME。

Java SE标准版，是为开发普通桌面和商务应用程序提供的解决方案。JavaSE是三个平台中最核心的部分，JavaEE和JavaME都是从JavaSE的基础上发展而来的，JavaSE平台中包括了Java最核心的类库，如集合、IO、数据库连接以及网络编程等。
Java EE企业版，是为开发企业级应用程序提供的解决方案。JavaEE可以被看作一个技术平台，该平台用于开发、装配以及部署企业级应用程序，其中主要包括Servlet、JSP、JavaBean、JDBC、EJB、Web Service等技术。
Java ME小型版，是为开发电子消费产品和嵌入式设备提供的解决方案。JavaME主要用于小型数字电子设备上软件程序的开发。Java ME提供了HTTP等高级Internet协议，使移动电话能以Client/Server方式直接访问Internet的全部信息，提供最高效率的无线交流。

JDK的使用

java语言的特点：简单性、面向对象、安全性、跨平台性、支持多线程

（Java丢弃了C++中很难理解的运算符重载、多重继承等模糊概念。且Java语言不使用指针，而是使用引用，一切对内存的访问都必须通过对象的实例变量来实现，并提供了自动的垃圾回收机制。Java语言提供了类、接口和继承等原语，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为implements）。Java语言全面支持动态绑定，而C++语言只对虚函数使用动态绑定。Java语言编写的程序可以运行在各种平台之上，也就是说同一段程序既可以在Windows操作系统上运行，也可以在Linux操作系统上运行。）

Java开发环境，JDK（Java Development Kit），它是整个Java的核心，其中包括Java编译器、Java运行工具、Java文档生成工具、Java打包工具等。

Java运行环境，JRE（Java Runtime Environment），是提供给普通用户使用的。由于用户只需要运行事先编写好的程序，不需要自己动手编写程序，因此JRE工具中只包含Java运行工具，不包含Java编译工具。值得一提的是，为了方便使用，SUN公司在其JDK工具中自带了一个JRE工具，也就是说开发环境中包含运行环境。

Java Downloads | Oraclejdk下载

bin目录：该目录用于存放一些可执行程序，如javac.exe（Java编译器）、java.exe（Java运行工具）、jar.exe（打包工具）和javadoc.exe（文档生成工具）等。
db目录：db目录是一个小型的数据库。从JDK6.0开始，Java中引入了一个新的成员JavaDB，这是一个纯Java实现、开源的数据库管理系统。这个数据库不仅很轻便，而且支持JDBC4.0所有的规范，在学习JDBC时，不再需要额外地安装一个数据库软件，选择直接使用JavaDB口可。
jre目录：“jre”是Java Runtime Environment的缩写，意为Java程序运行时环境。此目录是Java运行时环境的根目录，它包含Java虚拟机，运行时的类包、Java应用启动器以及一个bin目录，但不包含开发环境中的开发工具。
include目录：由于JDK是通过C和C++实现的，因此在启动时需要引入一些C语言的头文件，该目录就是用于存放这些头文件的。
lib目录：lib是ibrary的缩写，意为Java类库或库文件，是开发工具使用的归档包文件。
src.zip文件：src.zip为src文件夹的压缩文件，src中放置的是JDK核心类的源代码，通过该文件可以查看Java基础类的源代码。

系统环境变量

1）在命令行窗口输入set path可以看到当前系统path环境变量，

添加path环境变量，命令：

set path=%path%;C:\program Files\Java\jdk1.7.0_60\bin;

运行”javac”命令，若没有报错则设置成功；也可以运行set path查看path环境变量；

但，以上的方法只能暂时使用，一旦关闭命令行窗口就会失效；想要永久有效则需要到“高级系统设置”的环境变量中设置；；

2）当Java虚拟机需要运行一个类时，会在classpath环境变量中所定义的路径下寻找所需的class文件。

添加classpath环境变量，命令：

set classpath=C:\Program Files\Java\jdk1.7.0_60\bin

运行”java class文件名“命令；运行程序则设置成功；也可以运行set path查看path环境变量；

运行Java程序

打开命令行窗口；进入jdk安装目录的bin目录；
编写一个HelloWorld.java的文件
编译Java源文件：运行命令“javac HelloWorld.java“开启java编译器并进行编译，在该路径下生成同名.class字节码文件；
运行Java程序：运行命令“java HelloWorld“，注意不要加上”.class“否则报错；

Java程序是由虚拟机负责解释执行的，而并非操作系统。这样做可以实现跨平台性，也就是说针对不同的操作系统可以编写相同的程序，只需安装不同版本的虚拟机即可。

Java常用包：
java.util：包含Java中大量工具类、集合类等，例如Arrays、List、Se等。
java.net包含Java网络编程相关的类和接口。
java.io：包含了Java输入、输出有关的类和接口。
java.awt：包含用于构建图形界面（GUI）的相关类和接口。

二）java编程基础

常量、变量

1）类需要用class关键字定义，在class前面可以有修饰符；

修饰符 class 类名{
程序代码
}

2）Java中的程序代码可分为结构定义语句和功能执行语句。结构定义语句用于声明一个类或方法，功能执行语句用于实现具体的功能。每条功能执行语句的最后都必须用分号“;“结束；

3）Java语言严格区分大小写；

4）Java程序中一句连续的字符串不能分开在两行中书写，但可以用加号“+“将分处两行的两个字符串连起来；

5）单行注释：用符号“//“表示；

多行注释：以”/*“开头，以”*/“结尾；

文档注释：以“/**“开头，以”*/“结尾；

6）标识符可以由任意顺序的大小写字母、数字、下划线（_）和美元符号（S）组成，但不能以数字开头，不能是Java中的关键字。

7）包名所有字母一律小写。例如：cn.itcast.test。

8）类名和接口名每个单词的首字母都要大写。如：ArrayList、Iterator。

9）常量名所有字母都大写，单词之间用下划线连接。例如：DAY_OF_MONTH。

10）变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写。

11）在程序中，应该尽量使用有意义的英文单词来定义标识符，使得程序便于阅读。

12）java关键字

abstract	boolean	break	byte	case	catch	Char
const	class	continue	default	do	double	Else
extends	false	final	finally	float	for	goto
if	implement	import	instanceof	int	Infterface	long
native	new	null	packpage	private	protected	Public
return	short	static	strictfp	super	switch	This
throw	throws	transient	true	try	void	volatile
while	synchronized

13）Java中的常量包括

整型常量、二、八、十、十六进制；

浮点数常量、float和double两种类型，指数形式；

字符常量、一个字符常量要用一对英文半角格引起来，可以是英文字母、数字、标点符号、以及由转义序列来表示的特殊字符。Java采用的十Unicode字符集；

字符串常量、一个字符串常量要用一对英文半角格式的双引号（””）引起来;

布尔常量、布尔型的两个值true和false；

null常量、只有一个值null。

14）在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在一些内存单元中，每个内存单元（变量）都用一个标识符（变量名）来标识。

15）整数类型变量，byte、short、int、long；

long num = 2147483648L; //赋值超过int型的取值范围，后面必须加上字母L

浮点数类型变量，float、double，指数值中E表示以10为底的指数；

float f = 64.24f; //赋值float类型时，值后面一定要加上F或f，double随便；

字符类型变量，变量占用2个字节，也可以将整数值转化为对应的字符；

布尔类型变量，

16）自动类型转换和强制类型转换

17）表达式是指由变量和运算符组成的一个算式。

18）作用域

运算符

1）算术运算符

在进行除法运算时，当除数和被除数都为整数时，得到的结果也是一个整数。如果除法运算有小数参与，得到的结果会是一个小数。

在进行取模（%）运算时，运算结果的正负取决于被模数（%左边的数）的符号，与模数（%右边的数）的符号无关。

2）赋值运算符

3）比较运算符

4）逻辑运算

选择结构语句、循环结构语句

1）if条件语句分为三种语法格式：（1）if语句（2）if..else语句（3）if..else if..else语句

2）switch条件语句：

switch（表达式）{  //表达式只能是byte、short、char、int、枚举、String类型的值
        case目标值1：
                执行语句1
        break；
        case目标值2：
                执行语句2
        bxeak；
        case目标值n：
                执行语句n
        bxeak；
        default：
                执行语句n+1
        break；
}

3）while循环语句：

4）do...while循环语句

5）for循环语句：

6）嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语法结构。while、do..while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套。

7）跳转语句：break、continue

方法

修饰符返回值类型方法名（[参数类型参数名1，参数类型参数名2....]）{
执行语句
return 返回值；
}

修饰符：是对访问权限的限定
返回值类型：用于限定方法返回值的数据类型
参数类型：用于限定调用方法时传入参数的数据类型
参数名：是一个变量，用于接收调用方法时传入的数据
return关键字：用于结束方法以及返回方法指定类型的值
返回值：被return语句返回的值，该值会返回调用者

Java允许在一个程序中定义多个名称相同的方法，但是参数的类型或个数必须不同，这就是方法的重载。

数组

数组是指一组数据的集合，数组中的每个元素被称为元素，在数组中可以存放任意类型的元素，但同一个数组中存放的元素类型必须一致。

int [] x = new int[100];

int [] x;
x = new int[100];

当数组被成功创建后，数组中元素会被自动赋予一个默认值。根据元素类型的不同，默认初始化的值也是不一样的。

静态初始化数组：

类型 [] 数组名 = new 类型 []{元素，元素，...};
类型 [] 数组名 = {元素，元素，...};

二维数组的定义：

int [][] arr = new int[3][4]; //数组长度维度确定

int [][] arr = new int[3][]; //数组长度不定

int [][] arr = {{1,2},{3,4,5,6},{7,8,9}};

三）面向对象

面向对象则是把构成问题的事务按照一定规则划分为多个独立的对象，然后通过调用对象的方法来解决问题。

封装性：封装是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节，这就是封装思想。

继承性：描述的是类与类之间的关系，通过继承，可以在无需重新编写原有类的情况下，对原有类的功能进行扩展。继承不仅增强了代码的复用性、提高开发效率，还为程序的维护补充提供了便利。

多态性：指在程序中允许出现重名现象，它指在一个类中定义的属性和方法被其它类继承后，它们可以具有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同的类中具有不同的语义。

类是对象的抽象，它用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法，其中成员变量用于描述对象的特征，也被称作属性，成员方法用于描述对象的行为，可简称为方法。定义在方法中的变量为局部变量。

根据类创建实例对象，创建对象后，可通过对象的引用访问对象所有的成员。

类名对象名 = new 类名();

在实例化对象时，Java虚拟机会自动为成员变量进行初始化，针对不同类型的成员变量，Java虚拟机会赋予不同的初始值：

类的封装是指在定义一个类时，将类中的属性私有化，即使用private关键字来修饰，私有属性只能在它所在类中被访问，如果外界想要访问私有属性，需要提供一些使用public修饰的公有方法，其中包括用于获取属性值的getxxx方法和设置属性值的setXxx方法。

在Java中，定义在类中的变量被称为成员变量，定义在方法中的变量被称为局部变量。允许在某一个方法中定义的局部变量与成员变量同名。

构造方法

方法名与类名相同；
在方法名的前面没有返回值类型的声明；
在方法中不能使用return语句返回一个值，但是可以单独写return语句来作为方法的结束。

在一个类中除了定义无参的构造方法，还可以定义有参的构造方法。与普通方法一样，构造方法也可以重载。在创建对象时，可以通过调用不同的构造方法来为不同的属性进行赋值。

在Java中的每个类都至少有一个构造方法，如果在一个类中没有定义构造方法，系统会自动为这个类创建一个默认的构造方法。当定义了有参的构造方法后，系统不再提供无参的构造方法。

实际上，通过使用命令行 javap -c 反编译后发现，构造方法执行结束时，系统都会默认加上 return 语句。

public class Person{
        String zhangSan;
        public Person（）{
                super();
                return；
        }
        public Person(String zhangSan){
                //this关键字，指代当前Person类的对象，从而可以引用类方法
                this.zhangSan = zhangSan;
        }
}

this关键字

访问成员变量，this.成员变量名；
访问成员方法，this.成员方法名；
构造方法是在实例化对象时被Java虚拟机自动调用的，在程序中不能像调用其他方法一样去调用构造方法，但可以在一个构造方法中使用“this（[参数1.参数2……]）”的形式调用其他构造方法。（只能在构造方法中使用this调用其他的构造方法；
使用this的语句必须放在第一行，且只能出现一次；
不能在一个类的两个构造方法中同时使用 this 相互调用）

Java垃圾回收机制

当内存垃圾堆积到一定程度后，Java虚拟机就会启动垃圾回收器将这些垃圾从内存中释放；

除了等待Java虚拟机进行自动垃圾回收外，还可以通过调用System.gc()方法来通知Java虚拟机立即进行垃圾回收。当一个对象在内存中被释放时，它的finalize()方法会被自动调用，因此可以在类中通过定义finalize()方法来观察对象何时被释放。

在定义一个类时，只是在描述某类事物的特征和行为，并没有产生具体的数据。只有通过new关键字创建该类的实例对象后，系统才会为每个对象分配空间，存储各自的数据。有时候，开发人员会希望某些特定的数据在内存中只有一份，而且能够被一个类的所有实例对象所共享。

静态变量
在一个Java类中，可以使用static关键字来修饰成员变量，该变量被称作静态变量。静态变量被所有实例共享，可以使用“类名.变量名”的形式访问。（static关键字只能用于修饰成员变量，不能用于修饰局部变量，否则编译报错。）

静态方法
为了使该方法不必和对象绑在一起，只需要在类中定义的方法前加上static关键字即可，通常称这种方法为静态方法。同静态变量一样，静态方法可以使用“类名.方法名”的方式来访问，也可以通过类的实例对象来访问。（在一个静态方法中只能访问用static修饰的成员，原因在于没有被static修饰的成员需要先创建对象才能访问，而静态方法在被调用时可以不创建任何对象。）

静态代码块
在Java类中，使用一对大括号包围起来的若干行代码被称为一个代码块，用static关键字修饰的代码块称为静态代码块。当类被加载时，静态代码块会执行，由于类只加载一次，因此静态代码块只执行一次。在程序中，通常会使用静态代码块来对类的成员变量进行初始化。

成员内部类
>在Java中，允许在一个类的内部定义类，这样的类称作内部类，这个内部类所在的类称作外部类。根据内部类的位置、修饰符和定义的方式可分为：成员内部类、静态内部类、方法内部类。
>在一个类中除了可以定义成员变量、成员方法，还可以定义类，这样的类被称作成员内部类。在成员内部类中，可以访问外部类的所有成员。
>如果想通过外部类去访问内部类，则需要通过外部类对象去创建内部类对象：

外部类名.内部类名变量名 = new 外部类名().new 内部类名();

继承
在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。

在Java中，类的继承是指在一个现有类（父类）的基础上去构建一个新的类，构建出来的新类被称作子类，子类会自动拥有父类所有可继承的属性和方法。在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。

类只支持单继承，不允许多重继承；
多个类可以继承一个父类；
可以多层继承，即一个类的父类可以再去继承另外一个父类。

重写
在继承关系中，子类会自动继承父类中定义的方法，但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行重写。（在子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型。不能使用比父类中被重写的方法更严格的访问权限。）

super关键字
当子类重写父类的方法后，子类对象将无法访问父类被重写的方法。在Java中专门提供了一个super关键字用于访问父类的成员。
通过super调用父类构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次。

当隐式的父类构造函数没有被定义，必须显式地调用另一个构造函数。在子类的构造方法中一定会调用父类的某个构造方法。此时可以在子类的构造方法中通过super 指定调用父类0的哪个构造方法，如果没有指定，在实例化子类对象时，会自动调用父类无参的构造方法。

super．成员变量
super．成员方法（[参数１，参数２．．．]）
super（［参数１，参数２．．．］） //访问构造方法

final关键字
可用于修饰类、变量和方法，它有“无法改变”或者“最终”的含义，因此被final修饰的类、变量和方法将具有以下特性：

final修饰的类不能被继承。
final修饰的方法不能被子类重写。
final修饰的变量（成员变量和局部变量）是常量，只能赋值一次。

抽象类
Java允许在定义方法时不写方法体，不包含方法体的方法为抽象方法，抽象方法必须使用abstract关键字来修饰：

abstract void shout（）；//定义抽象方法shout（）

在定义抽象类时需要注意，包含抽象方法的类必须声明为抽象类，但抽象类可以不包含任何抽象方法，只需使用abstract关键字来修饰即可。

抽象类是不可以被实例化的，因为抽象类中有可能包含抽象方法，抽象方法是没有方法体的，不可以被调用。

如果想调用抽象类中定义的方法，则需要创建一个子类在子类中将抽象类中的抽象方法进行实现。

接口
如果一个抽象类中的所有方法都是抽象的，则可以将这个类用另外一种方式来定义，即接口。接口是由常量和抽象方法组成的特殊类，是对抽象类的进一步抽象。
在定义接口时，需要使用interface关键字来声明：

[public] interface 接口名 [extends接口1，接口2...] {
[public] [static] [final] 数据类型常量名 = 常量值；
[public] [abstract] 返回值抽象方法名(参数列表)；
}

一个类只能有一个父类，而一个类可以实现多个接口。接口中的变量默认使用“public static final”来修饰，即全局常量；接口中定义的方法默认使用“public abstract”来修饰，即抽象方法。

如果接口声明为public，则接口中的变量和方法全部为public。由于接口中的方法都是抽象方法，因此不能通过实例化对象的方式来调用接口中的方法。此时需要定义一个类，并使用implements关键字实现接口中所有的方法。

一个类可以在继承的同时实现多个接口，在mplements子句中用逗号隔开：

[<修饰符>] class <类名> [extends <超类名>] [implements <接口1>，<接口2>，...]

接口中的方法都是抽象的，不能实例化对象。
接口中的属性只能是常量。
当一个类实现接口时，如果这个类是抽象类，则实现接口中的部分方法即可，否则需要实现接口中的所有方法。
一个类通过implements关键字实现接口时，可以实现多个接口，用逗号隔开。
一个接口可以通过extends关键字继承多个接口，接口之间用逗号隔开。
·一个类在继承另一个类的同时还可以实现接口，但extends关键字必须位于implement之前

多态
在Java中为了实现多态，允许使用一个父类类型的变量来引用一个子类类型的对象。涉及到将子类对象当作父类类型使用的情况，称之为“向上转型”，但此时不能通过父类变量去调用子类中的特有方法。：

Animalan1=new Cat（）；//将Cat对象当作Anima1类型来使用
Animalan2=new Dog（）；//将Dog对象当作Anima1类型来使用

Object类
在JDK中提供了一个Object类，它是类层次结构的根类，每个类都直接或间接继承自该类，所有对象（包括数组）都实现了这个类的方法。

getClass().getName()代表返回对象所属类的类名;
hashCode()代表返回该对象的哈希值;
Integer.toHexString(hashCode())代表将对象的哈希值用16进制表示。

匿名内部类

异常
在Java语言中，引入了异常，以异常类的形式对这些非正常情况进行封装，通过异常处理机制对程序运行时发生的各种问题进行处理。

查看源图像

Error类称为错误类，它表示Java运行时产生的系统内部错误或资源耗尽的错误，是比较严重的，仅靠修改程序本身是不能恢复执行的。

Exception类称为异常类，它表示程序本身可以处理的错误，在开发Java程序中进行的异常处理，都是针对Exception类及其子类。

异常捕获
当try代码块中的程序发生了异常，系统会将这个异常的信息封装成一个异常对象，并将这个对象传递给catch代码块。catch代码块需要一个参数指明它所能够接收的异常类型，这个参数的类型必须是Exception类或其子类。try...catch语句：

try{
//在try代码块中编写可能发生异常的Java语句
} catch (ExceptionType e) { //ExceptionType指Exception类及其子类
//catch代码块中编写针对异常进行处理的代码
}

throws关键字
Java中允许在方法的后面使用throws关键字对外声明该方法有可能发生的异常。throws关键字声明抛出异常的语法格式如下：

修饰符返回值类型方法名（[参数1，参数2....]）throws ExceptionType1,[ExceptionType2.....]{ }

throws关键字需要写在方法声明的后面，throws后面需要声明方法中发生异常的类型，通常将这种做法称为方法声明抛出一个异常。

编译时异常（checked异常）
在Java中，Exception类中除了RuntimeException类及其子类都是编译时异常。编译时异常的特点是Java编译器会对其进行检查，如果出现异常就必须对异常进行处理，否则程序无法通过编译。处理编译时期的异常有两种方式：

使用try..catch语句对异常进行捕获
使用throws关键字声明抛出异常，调用者对其处理。

运行时异常（unchecked异常）
RuntimeException类及其子类都是运行时异常。运行时异常的特点是Java编译器不会对其进行检查，即当程序中出现这类异常时，即使没有使用try..catch语句捕获或使用throws关键字声明抛出，程序也能编译通过。运行时异常一般是由程序中的逻辑错误引起的，在程序运行时无法恢复。

自定义异常
在实际开发中，如果没有特殊的要求，自定义的异常类只需继承Exception类，在构造方法中使用super（）语句调用Exception的构造方法即可。
throw关键字用于在方法中声明抛出异常的实例对象：