java基础知识点整合

面向对象

3.1面向对象介绍

1.什么是面向对象

对象其实就是现实生活中的各种物体，他们有各种各样

的功能，当我们需要借助这些

物体去完成我们的需求时,我们就是在面向这些对象，

使用它们其中的功能，至于他们其中的功能是如何实现

的,我们无需知道，只要能完成需求即可.

2.什么是面向对象编程()：

是一种编程思想，使用对象去进行编程.

它的特点有：封装，继承，多态

3.对象从哪来：

对象是需要先用类来描述，然后使用类来创建.

类是对象的描述，对象是类的实例.

4.面向对象的优点

提高代码复用性.

使用者无需关心对象其中是如何实现的.

让程序员从一个编写者转换成一个使用者.

更加符合人的思维能力，使编程更简单.

3.2定义类

1.成员变量

在类中用变量来描述这一类对象公有的特征.

2.成员函数

在类中用函数来描述这一类对象公有的行为.

3.3创建和使用对象

1.怎么创建

使用"类名()”形式创建一个对象

2.怎么使用

通过".“语法来访问类的成员.

例如：p=()；="张三”;()；

3.4对象的初始化过程

1.加载类

类在第一次使用的时候被加载到内存中

2.初始化成员变量

当创建对象的时候，成员变量会初始化为默认值，基

本数据类型都是0,引用数据类型都是

3.5对象的生命周期

1.开始

关键字创建对象的时候，生命周期开始

2.结束

没有任何引用指向对象，该对象成为垃圾，被虚拟机

回收

3.6匿名对象

1.什么是匿名对象

没有任何引用指向的对象，就叫匿名对象

2.匿名对象有什么特点

匿名对象在创建之后立即被回收，只能使用一次

3.7封装

1.什么是封装

封装就是将一类事物的特征和行为封装在一个类中，

定义成成员变量和成员函数

创建对象之后，这些成员函数可以访问自己的成员变

量

2.对成员变量的封装

使用关键字将成员变量私有化

如果需要对外部提供访问方式，写公有的，方法

3.8构造函数

L什么是构造函数

构造函数是一个特殊的函数.

函数名必须和类名一致.

没有返回值类型.（不等于，不能写任何返回值）.

可以写，但是不能写值（尽量不要写）.

关键字创建对象时自动调用

2.应用场景

如果我们希望一段代码在创建对象的时候执行，就

可以写在构造函数中

通常我们使用构造函数对成员变量进行赋值

3.构造函数和成员变量的执行顺序

成员变量优先于构造函数先执行,因为通常使用构造函

数都是对成员变量进行初始化，所以如果没有成员变量,

构造函数是没有任何意义的.

4.构造函数的重载

和普通函数一样，参数列表不同（类型不同，顺序不同,

个数不同）即可.

重载只与参数列表有关

5.构造函数的调用

在创建对象时自动调用.

在构造函数的第一条语句可以使用”（被调用的构造函

数的实际参数）”的形式调用该类其他构造函数.

6.自动生成构造函数

在一个类中构造函数是一定存在的.

因为在一个类中如果没有写任何的构造函数，编译时

也会自动生成一个无参的构造函数，里面什么代码都

没有.

如果写了任何一个构造函数，那么就不会有自动生

成的了

注意：我们在类中只写了一个有参构造函数的时候，

这个类就不能使用无参的构造函数创建对象了

7.构造函数的访问权限

通常构造函数的访问权限都是公有的，因为构造函数

就是为了让别人创建对象时调用的

个别情况下在定义类时不希望外部创建对象，这时可

以使用修饰构造函数，例如：单例设计模式0

3.9成员代码块（构造代码块）

1.什么是成员代码块

在类中使用”{}“定义一段代码，这段代码在创建对象

的时候会自动运行

2.成员代码块和构造函数的区别

构造函数在创建对象的时候是N个选1个调用

而代码块是一定执行

构造函数可以传入参数

代码块不能传入参数

3.创建对象时内存中的工作顺序

在内存中查找指定的类，如果没有就加载类，有则直

接引用

在内存中开辟一块空间，将成员变量初始化为默认

值,0和

按照类代码从上到下的顺序，执行代码块或者成员

变量赋值

执行构造函数中的代码

4.在方法中也可以写代码块（方法代码块），但是不常用

3.10成员变量和局部变量

1.成员变量

在类中定义的变量,(),在整个类都可以访问(用于描述

着一类事物的共有特征).

成员变量随着对象的建立而建立，存在于对象所在的

堆内存中.

成员变量有默认初始值(0)

2.局部变量

在方法/语句中定义的变量()，

存在于栈内存中.

作用范围一结束,变量的空间会自动释放.

局部变量是没有初始值的.

3.同名问题

在同一个作用域中成员变量不能重复，局部变量也

不能重复

但是成员变量和局部变量可以同名，他们互相不冲

突

4.访问问题

在局部变量和成员变量同名的时候，如果直接用变量

名访问一个变量，那么是先找局部变量，如果不存在

才找成员变量

这时如果不想找局部变量，直接找成员变量，应该用

”•变量名”

3.11关键字

1.构造函数中

”（参数）”形式可以在构造函数的第一条语句中调用其

他的构造函数

”.成员名”形式可以调用当前对象的成员

2.普通函数中

用在普通的函数中，可以代表调用当前函数的对象

哪个对象调用所在的函数就代表那个对象.

3.内部类中

可以使用外部类名•成员来访问外部类的成员.

3.12静态（）变量

1.什么是静态变量

用修饰的成员变量就是静态变量（随着类的加载而加

载）

优先于所有非静态成员及成员代码块.

2.静态变量和普通变量有什么不同

静态变量在类加载后就初始化，不用创建对象可以

直接使用.

静态变量被类的所有对象共享（在共享区），通过一个

对象改变，所有对象都改变.

静态变量可以使用“类名•变量名”形式访问，推荐使用

这种方式，而不是通过对象访问.

3.类在什么时候加载

类在第一次使用的时候加载

例如：创建对象，使用静态变量，使用静态方法

定义变量的时候不加载类.

4.静态变量在什么时候使用

在定义一个类的时候，如果希望这个类的所有对象

共享一个数据时，就可以使用静态成员变量.

3.13静态()方法

L什么是静态方法

用修饰的方法就是静态方法

静态方法类加载后可以直接运行

可以使用”类名.方法名”调用

2.什么时候使用静态方法

如果一个方法没有访问任何外部的非静态成员，那

么就可以定义为.

这样在调用的时候不用创建对象即可使用，给人提

供方便，并且效率更高.

3.静态方法使用的注意事项

1.静态方法不能直接访问方法外非静态成员.因为静

态方法是随着类的加载而加载的,而非静态成员只有在

对象创建才会加载.因此，当静态方法访问方法外非静态

成员，对象不一定被创建，所以不能直接访问，除非在静

态方法中创建本类对象,才可以访问,方法外静态成

员.

2.与静态方法不能直接访问方法外非静态成员相反,

非静态方法是可以访问静态成员的，因为，对象被创建了,

这个类一定被加载到内存中，所以可以访问.

3.因为静态优先于对象存在，所以在静态方法中是不

能出现这两个关键字，道理很简单，静态被加载时还没

有对象，而这两个关键字都和对象有关，所以不能使用.

4.静态的利与弊

静态好处：

1.如果一个类里的某一个成员变量，他的所有需要共

同使用它，没必要每一个对象都存储一份,可以将

成员变量设为，系统将进行单独空间（方法区/静态

区）存储，节省内存空间.

2.静态的成员可以直接被类名调用，使用简单.

静态弊端:

1.因为静态是随着类加载而加载的的，所以其生命周

期是和类同存亡的.所以生命周期很长,比较浪费内存

空间.

2.因为静态只能访问静态，所以访问有一定的局限

性.

3.因为主函数是静态的，所以用主函数调用的方法再

不创建对象的情况下，只能都是静态的.

3.14静态代码块

1.什么是静态代码块

用修饰的代码块

类加载后直接运行，只能执行一次（因为类只会加载

一次），如果在一个类中有主函数,他是优先于主函数运

行的.

不能访问外部非静态成员

2.什么时候用静态代码块

在定义一个类的时候，如果希望某一段代码在别人

使用这个类的时候就执行，那么就可以写在静态代码

块中用于给类初始化.

3.15单例设计模式

设计模式:解决某一类问题最行之有效的方法.

单例设计模式:让一个类只能创建一个对象.

懒汉式和饿汉式

饿汉式步骤：

1.私有化构造函数.

2.创建一个对象,并私有（防止类外改变对象内部内

容）.

3.创建一个公有的，静态的方法，返回本类对象，使类

外获取本类对象.

懒汉式步骤：

1.私有化构造函数.

2.创建一个对象引用，并私有（防止类外改变对象内部

内容）.

3.创建一个公有的，静态的方法，判断是否创建了一个

对象如果创建了，返回本类对象，如果没有创建，创建

一个对象返回，使类外获取本类对象.

3.16继承

1.什么是继承

定义一个类，使用关键字可以继承另一个类，得到父

类的所有非私有属性和方法.

2.继承的特点

只支持单继承，不支持多继承，但可以多重继承.

一个父类可以有多个子类，但一个子类只有一个父

类.

3改良多继承的原因？

提高代码的安全性,如果一个子类继承多个父类，而这

多个父类中有同名的方法，子类要去访问的话,就不知

道要访问哪一个方法了.降低了安全性..

4.子类对象创建的过程

子类对象之所以能调用父类的方法，是因为在创建

子类对象的时候，其内部创建了一个父类对象.

在一个对象时，会先去子类构造函数,中寻找0（如果没

有显示指定父类构造函数）然后创建父类，然后再回到

子类中创建对象.

调用子类的方法时，虚拟机会先在子类中查找是否

包含该方法，如果没有则找父类.

在调用子类构造函数的时候，一定会使用"（参数）”形

式调用父类构造函数创建父类对象.子类中必须要有一

个构造函数含有调用父类构造函数..

和类似，都是必须在构造函数的第一条语句使用

如果构造函数写了，那么则不能写，反之亦然

如果没写也没写，默认会自动调用父类无参的构造

函数

5.方法覆盖（重写）

覆盖可以让子类将从父类继承来的方法进行扩展，提

高代码复用性，减少冗余.

覆盖时子父类的方法名子必须相同，包括返回值，参

数列表，并且子类的权限必须大于或等于父类.只能覆盖

非私有方法.

6.重载（）和重写（）的区别：

重载:名字相同,参数列表不同只与参数列表相同.

重写:子父类的方法名子必须相同，包括返回值，参数

列表，子类的权限必须大于或等于父类.（如果父类返回值

是一个类,子类返回值可以是和父类相同的类或其子类）.

7.向上转型

子类可以当作父类使用，因为父类的功能子类都有

f=()；

如果一个方法要求传入一个父类类型对象，我们也

可以传入一个子类对象

8.强制类型转换

在子类当作父类来用时，不能调用子类特有的成员.

如果一定要调用，需要把父类类型强转回子类类型.

这种转换叫强制类型转换，在编译时不论类型是否

匹配都不会报错，为了程序安全，通常在转换之前使

用进行判断.

3.17类及其中常用方法

1.什么是类

类是中所有类的父类，如果定义一个类不继承任何

类，默认继承

类中的方法会被所有的类继承

2

任何对象在成为垃圾被销毁之前，都会调用方法

类中的方法是空的，什么都没有

当我们希望在对象被销毁之前执行一段代码，就可

以在类中重写方法，把要执行的代码写在方法中.

3

方法可以将一个对象转为字符串表示形式

类中的方法返回的是”类名@内存地址”

当我们希望调用时返回成员变量的值，就可以重写

该方法

调用()方法时会自动打印对象的返回值

4

方法是用来比较两个对象的

类中方法默认比较的是对象的地址

如果我们希望比较两个对象的属性，那么可以重写

方法，在方法内比较所有的属性

在比较字符串时如果希望比较两个字符串的内容，

就需要使用，类是重写了的

3.18组合设计模式

1.什么是组合设计模式

在我们定义一个类的时，如果需要使用另外一个类

的方法，就可以用组合设计模式.

2.组合设计模式的写法

在类中定义一个被组合类型的成员变量

通过构造函数组合一个对象，用成员变量引用

在方法中使用成员变量调用被组合对象的方法

3.组合设计模式和继承的区别

不占用继承的位置，当前类组合一个类之后还能继

承其他类

组合设计模式组合的类不能当作被组合的类使用

3.19多态

1.多态的体现

父类引用指向子类对象.（父类的引用可以接受自己

的子类）.

2.多态的前提

类与类之间必须有关系，要么继承，要么实现.

子类与父类存在覆盖，因为在不强转的情况下,父类,

不能访问子类特有的方法.

3.多态的好处

提高代码扩展性.

4多态的弊端

虽然提高了扩展性，但是只能使用父类父类引用访问

父类成员（共有成员），

为了能访问子类特有方法，父类的引用必须转成子类

类型（向下转型）.

3.20抽象

L什么是抽象类

用修饰的类就是抽象类，抽象类中可以定义抽象方

法

2.什么是抽象方法

用修饰的方法就是抽象方法，抽象方法在子类中必

须全部重写

3.什么时候用抽象类和抽象方法

在我们定义类的时候，如果多个类有相同的方法，那

么就应该把这些方法抽取到父类中定义

完全相同的方法直接在父类中定义并实现，如果只

有方法签名（无方法体）一样而实现不同，那么就可以在

父类中定义抽象方法

这样别人看到父类的时候就知道子类都有什么功能

了，方便他人阅读我们的代码，也更好的支持了多

态.

4.抽象类细节

有抽象方法的类必须声明为抽象类，抽象类可以没

有抽象方法

抽象类不能创建对象

子类继承抽象类时必须重写所有的抽象方法

3.21修饰符

L代表最终的，可以用来修饰类，方法，变量.

2.被修饰后的特点

的类不能被继承

的方法不能被重写

的变量只能赋值一次，在程序运行结束前，会一直存在

与内存中.

如果内部类在局部位置上,只能访问该局部中被修饰

的变量.

被修饰的形参，第一次赋值是在调用它所在的函数时,

不能再次赋值了.

被修饰的引用类型变量，不能在指向其他对象,但是他

第一次指向的对象中的内容是可以改变的只是修饰了

引用.

修饰的变量时全局变量，可以使用类名调用，名字全部

大写

3.22模板设计模式

L什么是模板设计模式

在编程的过程当中，如果经常要做一些类似的事，其

中某些步骤相同，有些步骤不同，这是就可以使用模板

设计模式

2.怎么使用模板设计模式

定义一个抽象类

定义一个的方法

在方法中写出每次相同的步骤，不同的步骤写成抽

象方法，调用抽象方法

每次实现不同的步骤时，定义子类继承抽象类，重写

抽象方法即可，相同的步骤无需重写直接调用方法

3.23接口

1.什么是接口

接口是一种特殊的抽象类

2.接口和抽象类的区别

抽象类用定义，接口用定义

抽象类中可以有不抽象的方法，接口中所有方法都

是抽象的

抽象类用继承，接口用实现

抽象类可以继承抽象类，接口可以继承接口抽象可

以继承接口，接口不能继承抽象

因为抽象类里面有可能会有非抽象方法..

抽象类中的方法没有默认修饰符，接口中的方法默

认是修饰的

抽象类中的成员变量没有默认修饰符，接口中的成

员变量默认是修饰的

一个类只能继承一个抽象类，一个类可以实现多个

接口

3.什么时候用抽象类，什么时候用接口

能用接口的时候就不用抽象类（没有任何不抽象的方

法），因为接口不占用继承位置

如果需要定义不抽象的方法，那么就必须使用抽象

类.

3.24策略设计模式

定义一系列的算法,把它们一个个封装起来,并且使它们可

相互替换。使得算法可独立于使用它的客户而变化。

步骤：

1.定义一个过滤器接口，定义一个抽象方法,用于不同方法

的扩展

2.根据不同用户的需要，实现接口方法.

3.将接口作为参数,传入调用它的方法.

3.25内部类

一类中的内部类

1.什么是类中的内部类

在类级别下定义一个类，这就是类中的内部类

内部类也是外部类的一个成员

内部类必须先创建外部类对象才能创建对象.

语法：外部类0内部类()；

2.内部访问外部类的成员

内部类中可以访问外部类的成员，使用“外部类

名•成员名”形式

“外部类名”就代表调用当前方法的对象的外部

类对象

3.注意

外部类不能访问内部类成员

内部类的文件名是带a’的

4.什么时候使用内部类

在定义一个类的时候，如果需要定义另一个类，

而且这个类需要访问当前类的私有成员，那么这个

新的类就可以定义为内部类.

二.静态内部类

1.什么是静态内部类

使用修饰的类中内部类

不用创建外部类对象，直接创建对象.

语法：外部类.内部类0

2.静态内部类的特点

可以定义静态成员

不能使用“外部类”

不能访问外部非静态成员

3.什么时候使用静态内部类

如果定义一个内部类时，不需要访问外部非静

态成员，就可以定义为静态内部类

如果内部类中需要定义静态成员，只能定义为

静态内部类

三•方法中的内部类

1.什么是方法中的内部类

在一个方法中定义的类就是方法中的内部类

方法中的内部类只能在当前方法中使用

2.方法中内部类的特点

使用方法中内部类和普通的类中内部类相同

都可以通过”外部类名•成员名”访问外部类成员

3.什么时候使用方法中的内部类

如果一个类只在某个方法中使用，就可以定义

为方法中的内部类

4.访问局部变量的问题

方法中内部类如果要访问一个方法中的局部变

量，这个变量必须是的

四.匿名内部类

1.什么是匿名内部类

匿名内部类是方法中内部类的一种

如果一个类只使用一次，那么就可以定义为匿

名内部类

2.定义方式

父类名0｛类定义｝

这样做是声明一个指定类的子类，然后用这个

子类创建一个对象

4.1何为多线程

有多条执行路径的程序，就是多线程程序.（如:迅雷，暴风

影音）

有多条执行路径的进程，就是多线程进程.

4.2进程与线程

线程:就是进程中的一个控制单元，一条执行路径，线程控制

着进程的执行，每个进程里至少有一条线程.

进程:是一个正在执行的程序,每个进程都有一个执行顺序，该

顺序是一个执行路径，或者叫控制单元.其实进程就是一个

应用程序运行时的内存分配空间.

4.3中的线程分配

在启动时会有一个进程.该进程中至少有一个线程负责程

序的运行，而且这个线程运行的代码都存在于函数中，这条

线程被称为主线程.一般情况下在启动时,就只有一个线

程.（其实在启动时，不只有一个线程,因为在主线程中的代

码有可能会产生垃圾需要垃圾回收，如果全部都由主线程来

完成，效率会极低，因此还会有一个线程，来专门负责进行垃

圾回收.）

4.4线程的随机性

因为一个单核的快速切换导致,同一个时间里只有一个线程

在运行.因此哪个线程获取到了执行权，哪个线程就执行.

4.5自定义创建线程

创建线程有两种方式:继承方式和实现方式.

继承方式:创建一个类，继承，由子类覆写方法.

具体步骤：

1.自定义类，继承类.

2.继承类的目的就是要覆写其方法，因为想要让一段代码单

独运行，就需要将这段代码放到方法中.所以要覆写

方法，然后将需要新线程运行的代码写在方法中.

3.创建自定义类的对象，成为新的线程对象.

4.调用新的线程对象的方法，开启线程，并执行方法中的代码.

（方法有开启线程和调用方法两个作用.）

实现方式咱定义一个类，实现接口，覆写方法，创建类对象，将

实现接口的自定义类作为参数传到对象.

具体步骤：

1定义类实现接口。

2覆盖接口中的方法（用于封装线程要运行的代码）。

3通过类创建线程对象；

4将实现了接口的子类对象作为实际参数传递给类中的构

造函数。（因为要让线程对象明确要运行的方法所属的

对象。所以要将实现接口的自定义类对象作为参数传

递给类.

5调用对象的方法。开启线程，并运行接口子类中的方

法.

通常我们都使用实现方式，因为只支持单继承，所以如果一个

类已经继承别的父类，而它其中的代码有需要多线程，就有

了局限性，所以可以使用实现法来避免单继承的局限性.

4.6线程状态：

被创建：()

运行：具备执行资格，同时具备执行权；

冻结：0()—()唤醒；线程释放了执行权，同时释放执行资格；

临时阻塞状态：线程具备的执行资格，没有的执行权；

消亡：方法运行结束.

4.7多线程安全问题及解决方案

当多条语句在操作同一线程共享数据时，一个线程对多条语

句只执行了一部分还没执行完，另一个线程就参与进来执行,

导致共享数据的错误.

如何解决？

只要将操作共享数据的语句在某一时段让一个线程执行完，

在执行过程中，其他线程不能进来执行就可以解决这个问

题。

如何进行多句操作共享数据代码的封装呢？

中提供了一个解决方式：就是同步代码块。

格式：

（对象）任意对象都可以。这个对象就是锁。

（

需要被同步的代码；

）

同步的出现：

好处：解决了线程安全问题。

弊端：相对降低性能。因为判断锁需要消耗资源。产生了死

锁。

定义同步是有前提的：

1,必须要有两个或者两个以上的线程，才需要同步。

2,多个线程必须保证使用的是同一个锁。

同步的第二种表现形式：

同步函数：其实就是将同步关键字定义在函数上，让函数具

备了同步性。

同步函数是用的哪个锁呢?

通过验证，函数都有自己所属的对象，所以同步函数所使用

的锁就是锁。

当同步函数被修饰时，这时的同步用的是哪个锁呢？

静态函数在加载时所属于类，这时有可能还没有该类产生的

对象，但是该类的字节码文件加载进内存就已经被封装成

了对象，这个对象就是该类的字节码文件对象。

所以静态加载时，只有一个对象存在，那么静态同步函数就

使用的这个对象。

这个对象就是类名

同步代码块和同步函数的区别？

同步代码块使用的锁可以是任意对象。

同步函数使用的锁是，静态同步函数的锁是该类的字节码文

件对象。

在一个类中只有一个同步，可以使用同步函数。如果有多同

步，必须使用同步代码块，来确定不同的锁。所以同步代

码块相对灵活一些。

4.8线程间通信

多个线程在操作同一个资源，但是操作的动作却不一样。

1：将资源封装成对象。

2：将线程执行的任务（任务其实就是方法。）也封装成对象。

等待唤醒机制：

涉及的方法：

:将同步中的线程处于冻结状态。释放了执行权，释放了资格。

同时将线程对象存储到线程池中。

:唤醒线程池中某一个等待线程。

:唤醒的是线程池中的所有线程。

汪思：

1:这些方法都需要定义在同步中。

2：因为这些方法必须要标示所属的锁。

你要知道A锁上的线程被了，那这个线程就相当于处于A锁

的线程池中，只能A锁的唤醒。

3：这三个方法都定义在类中。为什么操作线程的方法定义

在类中？

因为这三个方法都需要定义同步内，并标示所属的同步锁，

既然被锁调用，而锁又可以是任意对象，那么能被任

意对象调用的方法一定定义在类中。

和区别：分析这两个方法：从执行权和锁上来分析:

:可以指定时间也可以不指定时间。不指定时间，只能由对

应的或者来唤醒。

:必须指定时间，时间到自动从冻结状态转成运行状态(临时

阻塞状态)。

:线程会释放执行权，而且线程会释放锁。

:线程会释放执行权，但不是不释放锁。

线程的停止：

通过方法就可以停止线程。但是这个方式过时了。

停止线程：原理就是：让线程运行的代码结束，也就是结束

方法。

怎么结束方法？一般方法里肯定定义循环。所以只要结束循

环即可。

第一种方式：定义循环的结束标记。

第二种方式：如果线程处于了冻结状态，是不可能读到标记

的，这时就需要通过类中的方法，将其冻结状态强制清除。

让线程恢复具备执行资格的状态，让线程可以读到标记，

并结束。

4.9多线程中的一些方法

返回当前线程的名称：0()

线程的名称是由：编号定义的。编号从0开始。

()：中断线程。

()：更改线程的优先级。

()：返回线程的优先级。

()：返回该线程的字符串表示形式，包括线程名称、优先级

和线程组。

()：暂停当前正在执行的线程对象，并执行其他线程。

()：将该线程标记为守护线程或用户线程。将该线程标记为

守护线程或用户线程。当正在运行的线程都是守护线程时，

虚拟机退出。该方法必须在启动线程前调用。

:临时加入一个线程的时候可以使用方法。

当A线程执行到了B线程的方式。A线程处于冻结状态，释

放了执行权，B开始执行。A什么时候执行呢？只有当B线

程运行结束后，A才从冻结状态恢复运行状态执行。

4.10接口：

多线程在1.5版本升级时，推出一个接口接口。

解决线程安全问题使用同步的形式。(同步代码块，要么同步

函数)其实最终使用的都是锁机制。

到了后期版本，直接将锁封装成了对象。线程进入同步就是

具备了锁，执行完，离开同步，就是释放了锁。

在后期对锁的分析过程中，发现，获取锁，或者释放锁的动

作应该是锁这个事物更清楚。所以将这些动作定义在了锁当

中，并把锁定义成对象。

所以同步是隐示的锁操作，而对象是显示的锁操作。它的出

现就替代了同步。

在之前的版本中使用类中、、的方式来完成的。那是因为同

步中的锁是任意对象，所以操作锁的等待唤醒的方法都定义

在类中。

而现在锁是指定对象。所以查找等待唤醒机制方式需要通过

接口来完成。而接口中并没有直接操作等待唤醒的方法，而

是将这些方式又单独封装到了一个对象中。这个对象就是，

将中的三个方法进行单独的封装。并提供了功能一致的方法

（）、（）、（）体现新版本对象的好处。

<>接口：（）、（）、。

5.1字符串存储原理

1.字符串是常量

在程序中类的对象都是常量，一旦创建不能被修改.存放在方

法区常量池中.

2.字符串缓冲区

由于字符串是常量，在程序中又会经常使用，所以提供了对

字符串缓冲的功能.

如果使用双引号形式定义一个字符串，这个字符串就会在缓

冲区中.如果再创建一个相同的就不会再重复开辟内存空间

里.

（如”"；）指向内存中只有一个对象.

如果使用构造函数形式定义一个字符串，那么就不会引用缓

冲区中的了，一定会创建一个新的.（如=n；）指向内存中

有两个对象一个字符串一个

一般在定义字符串时，尽量不要.

3.字符串相加

两个字符串相加是通过的方法和方法实现的，返回的是

一个由构造函数创建的字符串

如果在定义字符串的时候直接使用两个字符串常量相加，编

译时会改为一个字符串

如果将一个对象和一个字符串相加，得到的结果是对象的（）

返回值与字符串串联的结果

5.2字符串构造函数

([])

将字节数组解码成字符串

(口,)

用指定码表解码，将字节数组解码成字符串

([],,,)

用指定码表解码，将字节数组中的一部分字节解码成字符串

([])

将字符数组组装成字符串

(口,,)

将字符数组中一部分组装成字符串

0

将转换为

5.3字符串中的常用方法

一获取：

获取字符串的长度。();

获取指定位置的字符。();

获取指定字符的位置。如果不存在返回-1,所以可以通过返

回值-1来判断某一个字符不存在的情况。

()返回第一次找到的字符角标

();返回从指定位置开始第一次找到的角标

()；返回第一次找到的字符串角标

0;

0;

0;

0;

0;

获取子串。

()从位开始，至U0；为止.

()从开始到为止。

包含位，不包含位。

(0())获取整串

二判断：

字符串中包含指定的字符串吗？

0;

字符串是否以指定字符串开头啊？

0;

字符串是否以指定字符串结尾啊?

0;

判断字符串是否相同

()覆盖了中的方法，判断字符串内容是否相同。

判断字符串内容是否相同，忽略大小写。

0;

三转换：

将字符数组转成字符串。

([]);

([]);

([]);

([]);

将基本数据类型或者对象转成字符串。

0;

0;

0;

0;

0;

0;

0;

将字符串转成大小写。

0;

0;

将字符串转成数组。

口()转成字符数组。

口()可以加入编码表。转成字节数组。

将字符串转成字符串数组。切割方法。

口(分割的规则-字符串)；

将字符串进行内容替换。变成新字符串。

0;

0;

()；对字符串进行追加。

()去除字符串两端的空格

()如果参数字符串等于此字符串，则返回值0；如果此字符

串按字典顺序小于字符串参数，则返回一个小于0的值；

如果此字符串按字典顺序大于字符串参数，则返回一个大于

0的值。

5.4

为字符串缓冲区，初始长度16个字符.

特点：

1：可以对字符串内容进行修改。

2：是一个容器。

3：是可变长度的。

4：缓冲区中可以存储任意类型的数据。

5：最终需要变成字符串。

5.5中常用的方法

1,添加。

()：在缓冲区中追加数据。追加到尾部。

():在指定位置插入数据。

2,删除。

()；删除从至1范围的元素

()；删除指定位置的元素

(0())清空缓冲区。

3,修改。

();将至1替换成

()；替换指定位置的字符

()；将原字符串置为指定长度的字符串

4,查找。(查不到返回-1)

0；返回指定子字符串在此字符串中第一次出现处的索引。

()；从指定位置开始查找字符串

0;返回指定子字符串在此字符串中最右边出现处的索引。

0;从指定的索引开始反向搜索

5,获取子串。

();返回到结尾的子串

()；返回至1的子串

6,反转。

();字符串反转

5.6

在1.5后出现的，方法，初始长度和一样，但是因为没有同步，因

此提高了效率.在单线程程序中运用比较广泛.

和的区别：

线程安全。

线程不安全。

单线程操作，使用效率高。

多线程操作，使用安全。

6.1集合概述

用于存储数据的容器。

特点：

1：对象封装数据，对象多了也需要存储。集合用于存储对

象。

2：对象的个数确定可以使用数组，但是不确定怎么办？可

以用集合。因为集合是可变长度的。

集合和数组的区别：

1：数组是固定长度的。集合可变长度的。

2：数组可以存储基本数据类型，也可以存储引用数据类型。

集合只能存储引用数据类型。

3：数组存储的元素必须是同一个数据类型。

集合存储的对象可以是不同数据类型。

对于集合容器，有很多种。因为每一个容器的自身特点不同。

其实原理在于每个容器的内部数据结构不同。

数据结构：就是容器中存储数据的方式。

集合容器在不断向上抽取过程中。出现了集合体系。

在使用一个体系时，原则：参阅顶层内容。建立底层对象。

6.2接口

顶层抽取出来的接口中定义了集合框架的共性功能。

学习共性功能的使用：按照面向对象的思想：容器应该具备

什么功能呢？

1,添加。

()：添加一个元素

()；添加一个集合中的所有元素。

2,册U除。

()：将集合中的元素全删除，清空集合。

():删除集合中指定的对象。

():删除部分元素。部分元素和传入一致。

3,判断。

()：集合中是否包含指定元素。

():集合中是否包含指定的多个元素。

():集合中是否有元素。

4,获取。

()：集合中有几个元素。

5,取交集：

()：对当前集合中保留和指定集合中的相同的元素。

6,获取集合中所有元素：

()：迭代器

7,将集合变成数组。

0;

6.3接口

迭代器：是一个接口。作用：用于取集合中的元素。

每一个集合都有自己的数据结构，都有特定的取出自己内部

元素的方式。为了便于操作所有的容器，取出元素。将容器

内部的取出方式按照一个统一的规则向外提供。这个规则就

是接口。也就说，只要通过该接口就可以取出集合中的元素。

至于每一个具体的容器依据自己的数据结构，如何实现的具

体取出细节，这个不用关心，这样就降低了，取出元素和具

体集合的耦合性。

=()获取容器中的迭代器对象.至于这个对象是是什么不重

要。这对象肯定符合一个规则接口。

集合框架中的两大最为常用的子接口：

:有序(元素存入集合的顺序和取出的顺序一致)，元素都有索

引。元素可以重复。

:无序(存入和取出顺序有可能不一致)，不可以存储重复元

素。必须保证元素唯一性。(其实也是有序的但是它是按照的

顺序进行排序，所以更存入顺序不一致)

6.4

本身是接口的子接口，具备了的所有方法。现在学习体系特

有的共性方法。查阅方法发现的特有方法都有索引，这是该

集合最大的特点。

1,添加

()：在指定的索引位插入元素。

()：在指定的索引位插入一堆元素。

2,删除

()：删除指定索引位的元素。返回被删的元素。

3,获取

():通过索引获取指定元素。

()：获取指定元素第一次出现的索引位，如果该元素不存在返

0-1.

所以，通过-1,可以判断一个元素是否存在。

():反向索引指定元素的位置。

():获取子列表。

4,修改

()：对指定索引位进行元素的修改。

5,获取所有兀素。

()集合特有的迭代器。

集合支持对元素的增、删、改、查。

在进行列表元素迭代的时候，如果想要在迭代过程中，想要

对元素进行操作的时候，比如满足添加新元素。会发生并发

修改异常。

导致的原因是：

集合引用和迭代器引用在同时操作元素，通过集合获取到对

应的迭代器后，在迭代中，进行集合引用的元素添加，迭代

器并不知道。所以会出现异常情况。

如何解决呢?

既然是在迭代中对元素进行操作,找迭代器的方法最为合适.

可是中只有方法.通过查阅的它的子接口，发现该列表迭代器

接口具备了对元素的增、册k改、查的动作。

是集合特有的迭代器。

的具体的容器：

:有序（元素存入集合的顺序和取出的顺序一致），元素都有索

引。元素可以重复。

:底层的数据结构就是数组。线程不同步。替代了。

查询元素的速度非常快。

:底层的数据结构是链表。线程不同步。增删元素的速度非

常快。

:底层的数据结构就是数组。线程同步的。无论查询和增删

都巨慢。

可变长度数组的原理：

当元素超出数组长度，会产生一个新数组，将原数组的数据

复制到新数组中，再将新的元素添加到新数组中。

：是按照原数组的50%延长。

：是按照原数组的100%延长。

：具备了和的方法。

演示的特有方法。

枚举，被迭代，替换。

因为枚举的名称和方法名称过长，郁郁而终！

：的特有方法。

0；

0;

在1.6以后。

0;

0;

():获取链表中的第一个元素。如果链表为空，抛出

0;

在1.6以后。

();获取链表中的第一个元素。如果链表为空，返回。

0;

()：获取链表中的第一个元素，但是会删除链表中的第一个

元素。如果链表为空，抛出

0;

在1.6以后。

();获取链表中的第一个元素，但是会删除链表中的第一个元

素。如果链表为空，返回。

0;

6.5接口

:底层数据结构是哈希表。线程是不同步的。

集合保证元素唯一性：通过元素的方法，和方法完成的。

当元素的值相同时，才继续判断元素的是否为。

如果为，那么视为相同元素不存。

如果为，那么存储。

如果值不同，那么不判断。

:对集合中的元素的进行指定顺序的排序。是不同步的。底层

的数据结构就是二叉树。

哈希表的原理：

1,对对象元素中的关键字(对象中的特有数据)，进行哈希

算法的运算，并得出一个具体的算法值，这个值称为哈希

值。

2,哈希值就是这个元素的位置。

3,如果哈希值出现冲突，再次判断这个关键字对应的对象

是否相同。

如果对象相同，就不存储。因为元素重复。

如果对象不同，就存储，在原来对象的哈希值基础+1顺延。

4,存储哈希值的结构，我们成为哈希表。

5,既然哈希表是根据哈希值存储的，为了提高效率，最好

保证对象的关键字是唯一的。

这样可以尽量少的判断关键字对应的对象是否相同。

提高了哈希表的操作效率。

注意：哈希表在判断元素是否相同依据的条件。

1,对象的哈希值是否相同。

如果不同，不用在判断第二个条件。

如果相同，才判断第二个条件。

2,就是对象是否相等。

在代码体现。

任意对象都具备哈希值算出的功能。就方法。

任意对象判断是否相同，使用的都是方法。

用于对进行元素的指定顺序排序。

排序需要依据元素自身具备的比较性。

如果元素不具备比较性，在运行时会发生异常。

所以需要元素实现接口。强制让元素具备比较性，复写方法。

依据方法的返回值，确定元素在数据结构中的位置。

底层的数据结构就是二叉树。

方法保证元素唯一性的方式：就是参考比较方法的结果是否

为0,如果0,视为两个对象重复。不存。

注意：在进行比较时，如果判断元素不唯一，比如，同姓名，

同年龄，才视为同一个人。

在判断时，需要分主要条件和次要条件，当主要条件相同是,

在判断次要条件，按照次要条件排序。

集合排序有两种方式：

1:让元素自身具备比较性，需要元素对象实现接口，覆盖

方法。

2：让集合自身具备比较性，需要定义一个实现了接口的比

较器，并覆盖方法，并将该类对象作为实际参数传递给集合

的构造函数。

第二种方式较为灵活。

当集合中的元素具备的比较性不是所需要的。或者集合中的

元素根据就不具备比较性时，这时该如何排序呢？

但是元素自身没有比较性时，或者元素自身具备的比较性，

不是需要的。我们可以让集合自身具备比较性。需要集合一

初始化就具备比较功能。必须要在元素添加前具备。需要查

阅、集合的构造函数。可以在创建对象时，指定一个比较器。.

当自然顺序和比较器同时存在时，以比较器为主。所以看到

比较器更为灵活。

6.6集合

存储和有着很大不同。

一次存一个元素。一次存一对元素。

是单列集合。是双列集合。

中的存储的一对元素：一个是键，一个是值，键与值之间有

对应(映射)关系。

特点：要保证集合中键的唯一性。

1,添加。

()：当存储的键相同时，新的值会替换老的值，并将老值返回。

如果键没有重复，返回。

0;

2,删除o

0：

():删除指定键。

3,判断。

0：

0：

0;

4,取出。

0：

():通过指定键获取对应的值。

如果返回，可以判断该键不存在。当然有特殊情况，就是在

集合中，是可以存储键值的。

("06")注意这个细节。

():获取集合中的所有的值。

5,想要获取中的所有元素：

原理：中是没有迭代器的，具备迭代器。只要将集合转成集

合。可以使用迭代器了。之所以转成，是因为集合具备着键

的唯一性。其实集合就来自于，集合底层其实用的就是的方

法。

能把集合转成的方法。

0;

0;

取出集合中所有元素的方式一。：()方法。

():可以将集合中的键都取出存放到集合中。对集合进行迭代。

迭代完成，在通过方法对获取到的键进行值的获取。

=0;

=0;

(0)

(

=0;

=0;

)

=0;

0;

(0)

=0();

)

:底层是哈希表数据结构，是线程同步的。不可以存储键，值。

:底层是哈希表数据结构，是线程不同步的。可以存储键，值。

替代了.

:底层是二叉树结构。可以对集合中的键进行指定顺序的排

序。

6.7使用集合的技巧

1.0出现。1.2才加入到集合框架。

1.0出现。1.2才加入到集合框架。

特点：

只要是1.2版本的对象，通过后缀名就可以知道它是哪个子

体系中的集合。而且常用的这些集合，都是线