java基础知识简介

1、路径

     1.1、相对路径：文件或目录相对于当前工作目录的位置。

                 "."  :表示当前目录

                  ".." ：表示上一级目录

     1.2、绝对路径：文件或目录相对于根目录的位置，从"/"开始。

2、java开发环境

    2.1、java编译运行过程：

                  程序员所编写的是以.java为后缀的文件，此文件操作系统不能正确识别，因此，首先要经过编译，生成所谓的字节码文件（.class），  而              字节码文件需要JVM来提供运行环境的支持。
                 JVM是一个软件，安装在操作系统中，是建立在操作系统之上的，为字节码文件提供运行环境。

    2.2、JDK、JRE、JVM的关系：

              JDK(Java Development Kit)java开发工具包。包含编写java程序所必须的编译、运行等开发工具及JRE。
                     开发工具如：编译java程序的javac命令，启动JVM运行java程序的java命令，生成文档的javadoc命令，打包的jar命等。
             JRE(Java Runtime Environment)java运行环境。提供了运行java应用程序所必须的软件环境，包含了丰富的系统类库和JVM。

             JVM(Java Virtual Machines)java虚拟机。提供了字节码文件（.class）的运行环境支持。

3、变量（变量的声明、命名、初始化以及变量的访问）

3.1、变量的命名：

以字母、数字、"_"、"$"组成，且首字符不能以数字开头，不能使用java关键字（如：int、if、for等），java大小写敏感。

4、java的8种基本类型

4.1、8种基本类型：

byte(1字节(8位))、short(2字节(16位))、int(4字节(32位))、long(8字节(64位))(如果表示 long 直接量，要以L或l结尾)、float(4字节(32位))(如果表示float直接量，要以F或f结尾)、double(8字节(64位))、char(2字节(16位))、boolean(1字节(8位))

例：int：范围为：-2^31~2^31-1即：-2147483648~2147483647

       int d = 10000000000//编译错误，因为整数直接量超出了的int的范围。

4.2、基本类型之间的转换：

4.2.1、自动转：（从小类型到大类型）

byte——>short——>int——>long——>float——>double

                char

4.2.2、强转：（从大类型到小类型）

（需要转换成的类型）变量：如（int）a；有可能造成精度的损失或益处。

4.2.3、byte、char、short转换为int：

int直接量可以直接赋值给byte、char、short，只要不超过其表示的范围。

byte、char、short参与运算时、先一律转换成int型再进行运算。

4.2.4、转义字符：

"\n"：回车符、"\r"：换行符。

5、运算符和表达式

5.1、算数运算符：+、-、*、/、(取模)%、(自增)++、(自减)--；

(自增)++、(自减)--：若写在变量之前，表示在使用这个变量之前加1或减1；若写在变量之后，表示在使用变量之后加1或减1。

5.2、关系运算符：>,<,>=,<=,==,!=      ——>关系运算结果为boolean型true/false

5.3、逻辑运算符：&&(与),||(或),!(非)    ——>逻辑运算结果为boolean型true/false

5.3.1短路逻辑问题：

"&&"：两个操作数都为真时结果为真，——>若第一个操作数为false，此时无论第二个操作数结果为何，最后的结果都为false，这样，第二个操作数就不会运行。

"||"：两个操作数都为假时结果为假， ——>若第一个操作数为true，此时无论第二个操作数结果为何，最后的结果都为true，这样，第二个操作数就不会运行。

"&"与"&&"的区别：相同点：逻辑与，两个都为true才为true。

                                 不同点："&&"短路，"&"不短路，"&"：还有按位与的含义。

"|"与"||"的区别：相同点：逻辑或，两个都为假才为假。

                            不同点："||"短路，"|"不短路，"|"：还有按位或的含义。

"^"：按位异或的意思。

5.4、赋值运算符：=,+=,-=,*=,/=,%=

5.5、字符串连接：+

5.6、三目运算符：boolean?数1:数2 ——>boolean的结果为true时，表达式的结果为数1，否则为数2。

任何复杂的程序逻辑都可以通过“顺序”、“分支”、“循环”三种基本的程序结构实现。

6、分支结构

6.1、if语句：1条路。

当条件满足时执行某些语句，不满足则不执行这些语句。

6.2、if~else语句：两条路。

当条件满足时执行某些语句，不满足时执行另外的某些语句。

6.3、if~else if语句：多条路。(比较灵活)

6.4、switch~case语句：多条路。(用于整数、相等的情况，——>优点是效率高、结构清晰)

switch~case通常和break结合使用，用于退出switch~case语句。 (从JDK7.0开始，switch~case支持字符串表达式)

7、循环结构

break和continue用于循环语句，break用于退出当前循环，continue用于跳过循环体中剩余的语句进行下一次循环。
break可以用于循环语句，也可以用于switch~case语句中，而continue只能用于循环语句中。
可以使用break语句退出循环(break只能退出一重循环)

循环三要素：循环变量的初始化，循环条件(以循环变量为基础)，循环变量的改变(向着循环结束变)

7.1、while语句：

“当”循环

while(boolean表达式){语句块}//先判断再执行

先计算boolean表达式的值，若为true，则执行语句块，然后再计算boolean表达式的值，若为true则继续执行语句块，如此循环，直到boolean表达式的值为false则退出循环。

7.2、do~while语句：

“直到”循环

第一要素与第三要素相同时首选

do{语句块}while(boolean表达式)//先执行再判断，无论boolean表达式的值是否为true，都先执行一次语句块。

先执行语句块，再计算表达式是值，若为true，再次执行语句块，如此循环，直到boolean表达式的值为false时退出循环。

7.3、for语句：

一般用于实现固定次数的循环

for(表达式1;表达式2;表达式3){语句块(循环体)}//表达式1、表达式2、表达式3的值皆可以省略，要注意死循环。

先计算表达式1的值，再计算表达式2的值，若为true则执行循环体否则退出循环，然后再执行表达式3，再计算表达式2的值若为true则执行循环体否则退出循环，如此循环，直到表达式2的值为false时，退出循环。

8、数组

程序=算法+数据结构

算法：顺序结构、分支结构、循环结构解决的都是流程问题，即算法问题。

数据结构：就是把数据按照某种特定的结构来保存，设计合理的数据结构时解决问题的前提。

数组就是最基本的一种数据结构。

数组：相同类型的元素组成的集合。

基本类型数组的每个元素都是基本类型，给基本类型数组元素赋值------直接给值就可以
引用类型数组的每个元素都是引用类型，给引用类型数组元素赋值------new来创建对象

8.1、数组的定义、初始化

8.2、数组的访问：

获取的数组的长度：调用数组的length属性可以获取数组的长度。//数组没有length()方法。

通过下标访问数组的元素，数组的下标从0开始。

遍历数组元素用for循环

8.3、数组的复制：

8.3.1、使用System.arraycopy方法：

System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

src——>原数组  srcPos——>原数组的起始位置  dest——>目标数组  destPos——>目标数组的起始位置  length——>要复制的数组元素的数量

8.3.2、使用Arrays.copyOf方法：

复制：类型[] newArray = Arrays.copyOf(类型[] original,ing newLength)

            生成的新数组时原数组的副本，newLength小于原数组则进行截取，大于原数组则用0或null填充。

扩容：int[] a = new int[5];

            a = Arrays.copyOf(a,a.length+1);

8.4、数组的排序：

常用的排序算法有插入排序、冒泡排序、快速排序等。

8.4.1、可以使用Arrays.sort()方法：

8.4.2、冒泡排序算法：

原则：比较相邻的元素，如果违反最后的顺序准则则交换。

方法：第一次找到所有的元素的最大放到最后的位置上不再变动，第二次找到剩余所有元素的最大放到倒数第二个位置上不再变动，以此类推，直到排序完成。

8.5、引用类型数组：

在java中，数组属于引用类型数据；数组对象在堆中存储，数组变量属于引用类型，存放数组对象的地址信息，指向数组对象；数组元素可以看成是数组对象的成员变量(只不过类型都相同)

数组的类型是基本类型数组：(数组的数组)   例：int[][] arr = new int[3][];arr[0] = new int[1];arr[1] = new int[2];arr[2] = new int[3];

                                                                     arr指向一个数组，该数组有三个元素，每个元素都是int型数组，长度分别为1，2，3。

------------------------------------------------------------------------------------------------------------------

9、对象和类

抽象数据类型：将不同类型的数据的集合组成一个整体用于描述一种新的事物；

类：类定义了一种抽象数据类型；类不但定义了抽象数据类型的组成(成员变量)，还定义了可以对该类型实施的操作(方法)。

9.1、定义类：

类的定义包括成员变量的定义和方法的定义，成员变量用于描述该类型对象共同的数据结构；方法用于描述对象的行为，封装对象的功能。

修饰词 class 类名{

成员变量类型 变量名称;

修饰词 返回值类型 方法名称([参数列表]){

方法体

}

}

成员变量的类型可以是基本数据类型：若为数值类型(即byte、short、int、long、float、double)则默认值为0；若为boolean型则默认值为false；若为char则默认值为/uoooo;

若成员变量的类型为引用类型，则默认值为null；

修饰类的修饰词只能是public或默认；修饰方法的修饰词可以是public、protected、private、默认的；

9.2、创建并使用对象：

9.2.1、使用new关键字创建对象，创建对象的过程通常称为实例化。

new  类名();

9.2.2、引用类型变量：

可以使用引用类型变量访问对象以及该对象的成员变量和调用方法。(除了8种基本类型之外，用类、接口、数组等声明的变量都为引用类型变量，简称“引用”。)

引用类型变量存放的是该类对象的地址的信息，指向该类的对象。

引用类型变量的赋值：相同类型的引用类型变量之间可以相互赋值，这样不会创建新的对象，但有可能使两个以上引用指向同一个对象。(也可以赋值为null，若引用的值为null，通过引用访问对象的成员变量和调用方法是不合逻辑的，会产生NullPointerException异常)

10、方法

10.1、方法的签名：

方法的签名包括方法名和参数列表。(一个类中不可以有两个方法的签名完全相同)

10.2、方法的重载及其意义：

方法的重载(overload)：在java语言中，允许多个方法的方法名相同，但是参数列表不同，即为方法的重载(overload)。

编译器在编译时会根据签名的不同调用不同方法。

10.3、构造方法：

构造方法在类中定义，不同于其他的方法。构造方法通常用于对象成员变量的初始化。

构造方法的名称必须和类名相同；构造方法没有返回值，但也不能写void。

修饰词   类名(){构造方法体}

默认的构造方法：任何一个类都必须有构造方法，若源程序没有定义，编译器会在编译时为其添加一个无参的构造方法即默认的构造方法，若定义了构造方法，则不再添加。

构造方法的重载：为了使用方便，可以在一个类中定义多个构造方法，这些方法的方法名相同，但参数不同，即为构造方法的重载。一个构造方法中可以使用this调用其他的构造方法。

10.4、this关键字的使用：

this关键字用在方法体中，用于指向调用该方法的当前对象，即：哪个对象调用方法，this就指向哪个对象。(一般没有歧义的情况下this可以省略)

this与super：

this：   this.成员变量——>访问本类的成员变量

this.方法名()——>调用本类的方法

this()——>调用本类的其它构造方法

super：super.成员变量——>访问父类的成员变量

super.方法名()——>调用父类的方法

super()——>调用父类的构造方法

11、对象内存管理

编译好的java程序需要运行在JVM中。程序，无论代码还是数据都需要存储在内存中，JVM为java程序提供并管理所需要的内存空间。JVM内存分为“堆”、“栈”、“方法区”三个区域，分别用于存储不同的数据。

11.1、堆内存：

对象存储在堆内存中。访问对象需要依靠引用，当一个对象没有任何引用指向时，被视为废弃的对象，属于被回收的范围，该对象中的所有的成员变量也随之被回收。

成员变量的生命周期：从对象在堆中创建开始，到对象从堆中被回收结束。

11.2、垃圾回收机制：

垃圾回收器(Garbage Collection，GC)，是JVM自带的一个线程，用于回收没有任何引用指向的对象。(java程序员不用担心内存问题，因为垃圾回收器会自动进行回收管理。)

11.2.1、内存泄露问题：

内存泄露是指不再使用的内存没有被及时的回收，严重的内存泄露会因过对的内存占用而导致程序的崩溃。

GC线程判断对象是否可以被回收的依据是该对象是否有引用指向，因此，当确定该对象不再使用时，应当及时将其引用设置为null。

11.2.2、System.gc()方法：

GC的回收对程序员来说是透明的，并不一定一发现有无引用指向的对象就立即回收。一般情况下，当我们希望GC线程即刻回收无用对象时，可以调用System.gc()方法。System.gc()方法用于建议虚拟机马上调度GC线程回收资源，具体的实现策略取决于不同的JVM系统。

11.3、非堆——栈：

栈：用于存储程序运行时在方法中声明的所有局部变量。

局部变量的生命周期：一个运行的java程序从开始到结束会有多次方法的调用，JVM会为每一个方法的调用在栈中分配一个对应的空间，这个空间称为该方法的栈帧。一个栈帧对应一个正在调用中的方法，该栈帧中存储着该方法中的参数、局部变量等数据，当某一个方法调用完成后，其对应的栈帧将被清除，局部变量失效。

成员变量和局部变量的区别：

成员变量：定义在类中，方法之外；有默认初始值，可以不显示初始化；所在类被实例化后，存在堆中，对象被回收后，成员变量失效。

局部变量：定义在方法之中；没有默认值，必须自行设定初始值；方法被调用时，存在栈中，方法调用结束后，从栈中清除。

11.4、非堆——方法区：

方法区用于存放类的信息，java程序运行时，首先会通过类装载器载入类文件的字节码信息，经过解析后将其装入方法区，类的各种信息(包括方法)都存储在方法区。(方法只有一份：类在实例化时，多个对象会拥有各自在堆中的空间，但所有实例对象是共用在方法区中的一份方法定义的。)

12、继承

通过extends关键字可以实现类的继承。

子类(Sub class)可以继承父类(Super class)成员变量和成员方法，同时也可以定义自己成员变量和成员方法。

java语言不支持多重继承，一个子类只能继承一个父类，但一个父类可以有多个子类。

12.1、继承中的构造方法：

子类的构造方法中必须通过super关键字调用父类的构造方法以妥善的初始化继承自父类的成员变量。如果子类构造方法中没有调用父类的构造方法，那么编译器会自动加入对父类无参构造方法的调用(如果该父类没有无参构造方法，会出现编译错误)。

12.2、向上造型：

一个子类的对象可以向上造型为父类的类型。即，定义父类型的引用可以指向子类的对象。

父类的引用可以指向子类的对象，但通过父类的引用只能访问父类所定义的成员，不能访问子类的扩展部分。

12.3、方法的重写(override)：

子类可以重写(覆盖)继承自父类的方法，即方法的名称和参数列表与父类的相同，但方法的实现不同。

当子类对象重写后的方法被调用时(无论是通过父类的引用调用还是通过子类的引用调用)，运行的都是子类重写后的版本。

当子类在重写父类的方法时，可以通过super关键字调用父类的版本。

重载与重写的区别：

重载(overload)：在一个类中定义多个方法名相同但参数列表不同的方法。重载遵循“编译期绑定”，即在编译时根据参数的个数和参数的类型来决定绑定哪个方法。

重载是否可以改变返回值类型：如果几个重载的方法的参数列表不一样时，返回值类型也可以不一样；如果两个方法的参数列表完全一样，那就不能通过改变返回值来实现重载，因为如果两个方法的方法名和参数列表完全相同，仅仅返回值类型不同，java就无法确定编程者到底想调用哪个方法了，因为它无法通过返回值类型来判断。

不能通过访问权限、返回值类型、抛出的异常进行重载；方法的异常类型和数目不会影响重载；

重写(override)：在子类中定义和父类完全相同的方法，重写遵循“运行期绑定”；即在运行时根据引用变量指向的实际对象类型调用方法。

重写表示子类中的方法可以与父类中的某个方法的方法名和参数完全相同，当通过子类创建的实例对象调用这个方法时，调用的是子类中定义的方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。

子类覆盖父类的方法时，只能比父类抛出更少的异常，或者是抛出父类抛出异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。

子类的访问权限只能比父类更大，不能更小。

如果父类的方法是private类型，那么子类不存在覆盖限制，相当于子类增加了一个全新的方法。

重写方法的返回值类型必须和被重写的方法的返回值类型一致。

13、访问控制

13.1、包(package)：

定义类时要指定类的名称，如果仅仅将类名作为类的唯一标识，会出现命名冲突的问题，会给组件的复用以及团队的合作带来困难。在java语言中使用包的概念来解决命名冲突的问题。

package  包名;//一旦使用package指定了包名，类的全称为：包名.类名；

包名的命名规范一般为：公司(或组织)的域名反写.项目名.模块名.类名；

访问一个类时使用该类的全称，或者使用import对类的全称声明(包名+类名)，然后直接使用类名。

13.2、访问控制修饰符：

封装的意义：对外提供可调用的、稳定的功能；封装容易变化的、具体的实现细节，这样可以降低代码的出错的可能性，便于维护，而且当内部的实现细节改变时，只要保证对外的功能定义不变，其它的模块就不会因此而收到牵连。

public修饰的成员变量和方法可以在任何地方调用；

protected修饰的成员变量和方法可以在本类、子类和同包中的类中调用；

默认访问控制的成员变量和方法可以在本类和同包类中使用；

private修饰的成员变量和方法只能在本类中调用。

public修饰的内容是对外提供可以被调用的功能，需要相对稳定；private修饰的内容是对内实现的封装，如果“公开”，会增加维护的成本。

对于类的修饰可以使用public和默认方式，public修饰的类可以被任何类使用，默认访问控制修饰的类只能被同包中的类使用。protected和private可以修饰内部类。

14、static和final

14.1、static：

static修饰的成员变量不属于对象的数据结构；static变量是属于类的变量，通常可以通过类名点来访问；static成员变量和类的信息一起存储在方法区中，而不是在堆中，一个类的static成员变量只有“一份”，无论该类创建了多少对象。

static方法不能对非static成员(对象成员)进行访问；

static快：属于类的代码块，在类加载期间执行的代码块，只执行一次，常用来加载静态资源(图片、视频等)

14.2、final：

final修饰的成员变量是不可改变的，可以声明的同时初始化，也可以在构造方法中初始化；final修饰的局部变量，在使用之前初始化即可。

final修饰方法不可以被重写，防止子类在定义方法时造成“不经意”的重写。

final修饰类不可以被继承，可以保护类不被继承修改，可以控制滥用继承对系统造成的伤害。

14.3、static  final修饰的成员变量即为常量，必须声明的同时初始化；static  final常量会在编译期被替换。

15、抽象类、接口和内部类

15.1、抽象类和抽象方法：

有abstract修饰的方法为抽象方法，抽象方法只有方法的定义，没有方法体的实现，用一个分号结尾；

包含抽象方法的类应该用abstract声明为抽象类；如果一个类继承了抽象类，就必须重写其抽象方法(除非该类也声明为抽象类)，不同的子类可以有不同的实现；即使一个类中没有抽象方法也可以声明为抽象类；

抽象类不可以实例化；

abstract和final不可以同时修饰一个类，因为final修饰的类不可以被继承，而abstract修饰的抽象类如果不被继承就没有意义了。

抽象类的意义在于：为其子类提供了一个公共的类型；封装了子类中的重复内容(成员变量和方法)；定义有抽象方法，子类虽然有不同的实现，但该方法的定义是一致的。

15.2、接口：

通过interface定义接口；接口可以看成是特殊的抽象类，即只包含抽象方法的抽象类；接口只包含抽象方法和常量；

通过inplements实现接口；与继承不同，一个类可以实现多个接口，实现的接口直接用逗号分隔开，该类要实现接口中的所有的抽象方法；

接口可以作为一种类型声明变量，一个接口类型的变量可以引用实现了该接口的类的对象，通过该变量可以调用该接口中定义的方法(具体的实现类提供了方法的实现)；

接口间存在继承关系，一个接口可以通过extends继承另一个接口，子接口继承了父接口中定义的所有方法；

15.3、多态：

多态的意义：一个类型的引用在指向不同的对象时会有不同的实现；同样一个对象，造型成不同的类型时会有不同的功能。

向上造型：一个类的对象可以向上造型为父类的类型或其实现的接口的类型；java编译器根据类型检查调用方法是否匹配。

强制转型：可以通过强转将父类型变量转换为子类型变量，前提是该变量指向的对象确实时该子类类型；也可以通过强制转换将变量转换为某种接口类型，前提是该变量指向的对象确实实现了该接口；如果违背上述的两个前提，会抛出ClassCastException异常。

instanceof关键字：在强制转型中，为了避免出现ClassCastException，可以通过instanceof关键字判断某个引用指向的对象是否为指定类型。(变量A  instanceof  类型B；变量A是否可以强转成类型B)。

15.4、内部类：

一个类可以定义在一个类的内部，定义在内部的类为内部类(Inner)，其所在类为外部类(Outer)；内部类通常只服务外部类，对外不具备可见性；内部类可以直接调用外部类的成员及方法(包括私有的)。

一般情况下，内部类对象会在外部类对象中创建(构造方法或其它方法)；内部类对象中会有一个隐式的引用指向创建它外部类对象。

定义匿名内部类：如果在一段程序中需要创建一个类的对象(通常这个类实现了某个接口或继承了某个类)，而且对象创建后，这个类的价值就不存在了，这个类可以不用命名，称之为匿名内部类。(匿名内部类所实现的接口或继承的类    引用变量 = new 匿名内部类所实现的接口或继承的类(参数){匿名内部类中定义的成员变量或方法};)

面向对象的特征：

抽象：抽象就是忽略一个主题中与与当前目标无关的那些方面，以便充分的注意到与当前目标有关的方面；抽象并不打算了解全部问题，而只是选择其中的一部分；过程抽象，数据抽象；

封装：封装就是把过程和数据包围起来，对数据的访问只能通过已定义好的界面，

封装的意义：对外提供可调用的、稳定的功能；封装容易变化的、具体的实现细节，这样可以降低代码的出错的可能性，便于维护，而且当内部的实现细节改变时，只要保证对外的功能定义不变，其它的模块就不会因此而收到牵连。

继承：对象的一个新类可以从现有的类中派生，这个过程称为类继承；新类继承了原始类的特性，新类称为原始类的派生类(子类)，而原始类称为新类的基类(父类)；派生类可以从它的基类那里继承方法和实例变量，并且派生类可以修改或增加新的方法使之更适合特殊的需要。

多态：实现多态的机制：父类或接口定义的引用变量可以指向子类或或具体实现类的实例对象。

方法的重写(overload)和重载(overload)是java多态性的表现：重写是父类与子类之间多态性的一种表现；重载是一个类中多态性的一种表现。

多态的意义：一个类型的引用在指向不同的对象时会有不同的实现；同样一个对象，造型成不同的类型时会有不同的功能。