java 基础篇知识资料

java基础篇

1.数据类型

整型：intshortlongbyte

浮点型：floatdouble

char类型：表示单个字符，用单引号括起来

Boolean类型:判定逻辑条件，false/true

2.变量与常量

变量：变化的值在java9中不能当做变量名

首先变量声明:每一个变量都有一个类型

变量初始化:用赋值语句对变量进行显示初始化

常量：固定不变的用关键字final指示常量。

Final：表示只能被赋值一次

Staticfinal：设置一个类常量（位于main方法的外部）

3.static与final的区别：

Static作用：方便在没有创建对象的条件下调用变量或方法。可以修

饰成员方法，成员变量，编写static代码优化程序性能（形成静态代码

块优化程序性能，并且只会在类加载的时候执行一次），

Final:final类（最终类）不可以继承，没有子类。

final方法不能被子类的方法覆盖，但可以继承。

Final不能修饰构造方法。

4.静态常量：类中可以共享数据。

5.检测字符串是否相等：s.equals⑴检测s和t是否相等

第1页共130页

equalsIgnoreCase不用区分大小写来检测字符串是否相等。

6.==与equals的区别：

，==，对于基本类型和引用类型是不相同的

基本类型：==表示的是值是否相同

引用类型：==表示的是引用是否相同

Equals:本质上是==但是通过string和Integer对equals方法的重写，

变成了值的比较。

7.数组

声明数组：类型□名字

数组的拷贝：int[]copiedLucky=Arrays.copyof（Lucky,Lucky.lengyh）

8.JDK与JRE的区别：

JDK：java开发工具包，提供java的开发环境和运行环境

JRE：java运行环境，为java运行提供环境

具体的来说JDK包含JRE,还包括编译java编码的编译器javac,以

及java的调试和分析工具。

9.类class类名｛

类体（变量声明）

（方法定义）｝

10.Java里面向对象的三大特征是什么？

封装：将数据和行为组合到一个包中，并对对象的使用者隐藏具体

的实现方式。封装的思想类内部数据结构的完整性，让用户无法轻

易直接的操作内部数据，这样降低对内部数据的影响，提高了程序

第2页共130页

的安全性和可维护性。

类的封装实现：将成员变量声明为private,再通过public的方法对

这个变量进行访问。对于一个变量我们有读取和赋值的操作，

getXxx（读取变量），setXxx（对成员变量进行赋值处理）。

封装的优点：隐藏类的实现细节。

便于修改，增加代码的可维护性。

让使用者使用事先制定好的方法来访问数据，方便加入

控制逻辑，限制对属性的不合理操作。

继承：当两个类具有相同的属性和方法时，可以将相同的部分提取

出

出来作为父类，其他的类继承这个类的方法和属性。

关键字：extends

继承和权限：

Hna

Publiic无修饰PrivateProtectabstractstatic

1

不能

只有同一包不能修饰不能修饰不能修饰

类继承可继承濠生一段可继承

中的可继承类突

拔

可重戢（修蜂

不可重

方法重载不能重蚣司■羲r可・能王函数就不能

H了）

必须鼻个实例

成员变量子类不能直父集虐性

幺英聂性使除墓攵金原性陵随我不能脩饰

（属做（使用sup"R（使用我接访问父类（使用ZP衣技付初共享这个

广一*辛

取父笑厦性）取父划■性）的私有变量取父类JBa）值类变量

多态：同一个行为用不同的表现形式或形态的能力。说具体点就是

同一接口，使用不同的实例而执行的结果。

多态的优点:消除类型之间的耦合关系可替换性可扩充性接口性

第3页共130页

灵活性简化性

实现多态的必要条件：要有继承

要有方法分的重写

父类引用指向子类对象

例子：父类：publicclassHttpServlet{

publicvoidservice(){

System.out.println("HttpServlet-service");

doGet();

)

publicvoiddoGet(){

System.out.print("HttpServlet-doGet");

)

)

子类：publicclassMyServletextendsHttpServlet{

publicvoiddoGet(){

System.out.println("MyServlet-doGet");

)

)

主类：publicclassTest{

publicstaticvoidmain(String[]args){

HttpServlets=newMyServlet();

s.service();

第4页共130页

)

)

结果：HttpServlet-service

MyServlet-doGet

代码分析：HttpServlets=newMyServlet();//s虽然是父类变量

的引用，但是指向的是子类对象。s.serviceO;//子类中没有定

service,因此调用的是继承父类的service方法，然后service方法

中调doGet,这时候也是以子类中优先查找重写的doGet方法。

11.多态的向上转型和向下转型分别指的是什么？

向上转型：简单的说就是子类对象赋值给父类引用(减少代码重复)

格式：父类类型变量名=new子类类型()Fatherf=new

son()

Personp=newStudent。；

向下转型：已经向上转型的子类可以使用强制类型转换格式，将父

类对象赋值给子类引用

格式：子类类型变量名=(子类类型)父类类型变量名

sons=(son)f

Personp=newStudent。；

Studentstu=(Student)p

12.重写和重载的区别？

重写(override)：子类定义一个方法，这个方法的类型和父类的方

法类型一致，并且方法名字，参数个数,参数类型和父类是完全相同

的。

重写的规则：参数列表与被重写方法的参数列表必须完全相同。

第5页共130页

返回类型与被重写方法的返回类型可以不相同，但是必须是父类返

回值的派生类（java5及更早版本返回类型要一样，java7及更高版

本可以不同）。

访问权限不能比父类中被重写的方法的访问权限更低。例如：如果

父类的一个方法被声明为public,那么在子类中重写该方法就不能

声明为protectedo

父类的成员方法只能被它的子类重写。

声明为final的方法不能被重写。

声明为static的方法不能被重写，但是能够被再次声明。

子类和父类在同一个包中，那么子类可以重写父类所有方法，除了

声明为private和final的方法。

子类和父类不在同一个包中，那么子类只能够重写父类的声明为

public和protected的非final方法。

重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出

异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写

方法声明的更广泛的强制性异常，反之则可以。

构造方法不能被重写。

如果不能继承一个方法，则不能重写这个方法。

重载（overload）：一个类中可以有多个方法具有相同的名字，但这

些方法的参数必须不同（参数个数不同。参数个数相同但参数表对

应某个参数的类型不同。）

二者的区别：重写和重载都是java多态性的不同表现。重写是子类

第6页共130页

与父类之间多态性的一种表现，重载是一个类中多态性的表现。

13.super关键字怎么使用？

可以用super操作被隐藏的成员变量和方法。

publicclassAverageextendsSum{//子类继承父类

intn;//成员变量

floatf(){//方法

floatc;

super.n=n;//sup㊀r关键字调用子类继承所隐藏的成员变量

c=super.f();//用对象名调用父类的f方法

returnc/n;

)

floatg(){

floatc;//局部变量声明

c=super，()；//也是调用父类的f方法但是此时没有用到n

returnc/2;

)

}

publicclassSum{

intn;

floatf(){

floatsum=0;

for(inti=1;i〈=n;i++)//for循环先进行判断满足执行循环代码，然后才是加一

n=100执行了100次

sum=sum+i;//循环代码1+2+3+++99=n(al+an)/2

returnsum;

}

}

publicclassExample{

publicstaticvoidmain(Stringargs[]){

Averageaver=newAv㊀rag㊀()；//仓U建对象执行的时候先跳至!JAverag㊀类中

aver.n=100;//赋值n=100

floatresultOne=av㊀r,f();//调用方法

floatresultTwe=aver.g();

System.out.printin(nresultOne=n+resultOne);//输出

System.out.printin(nresultTwe="+resultTwe);

第7页共130页

使用super调用父类的构造方法。

classAnimal{

publicvoidmove(){

System.out.printIn("动物可以移动*;

}

)

classDogextendsAnimal{

publicvoidmove(){

super.move();//应用super类的方法

System.out.printIn("狗可以跑和走；

}

}

publicclassTestDog{

publicstaticvoidmain(Stringargs[]){

Animalb=newDog();//Dog对象

b.move();〃执行Dog类的方法

}

}

14.构造器可以重写吗？

构造器(Constructor):就是和类名相同但无返回类型的方法。它

的作用是创建对象时进行初始化。

构造器是不能被继承的，所以不可以进行。verride的，但可以进行

重载(overload)

如果父类自定义了有参构造函数，则子类无论定义构造函数与否，

定义有参构造函数与否，都会报错，正确的做法是在子类的构造方

法中添上super(参数)，以表明子类构造之前先构造父类，而这

句话必须放在第一句，否则报"Constructorcallmustbethe

firststatementinaconstructor”的错误。

类的加载顺序:

第8页共130页

首先执行父类的静态代码块/初始化静态变量（两者优先级相

同），然后执行子类的静态代码/初始化静态变量（两者优先级相

同，谁写在前面谁先执行），然后初始化父类成员变量/执行代码块

{}（两者优先级相同），接着父类的构造器，然后子类的成员变量/

代码块，最后子类的构造器。

15.什么是正则表达式以及它有什么用途？

在编写处理字符串的程序时，经常会有查找符合某些复杂规则的字

符串的需要。正则表达式就是用于描述这些规则的工具。换句话

说，正则表达式就是记录文本规则的代码。计算机处理的信息更多

的时候不是数值而是字符串，正则表达式就是在进行字符串匹配和

处理的时候最为强大的工具，绝大多数语言都提供了对正则表达式

的支持。

16.int和integer的区别是什么？

Java是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还

是引入了基本数据类型，但是为了能够将这些基本数据类型当成对

象操作，Java为每一个基本数据类型都引入了对应的包装类型

（wrapperclass）,int的包装类就是Integer,从Java5开始引

入了自动装箱/拆箱机制，使得二者可以相互转换。

Java为每个原始类型提供了包装类型：

一原始类型：boolean,char,byte,short,int,long,float,

double

-包装类型：Boolean,Character,Byte,Short,Integer,

第9页共130页

Long,Float,Double

包装类的作用：方便对一些基本类型进行操作，解决基本类解决不

了的问题。

集合不允许存放基本数据类型，只能存放应用数据类型。

add(Objecto)

基本类型可以和包装类型直接相互转换，自动装箱拆箱，(自动装

箱：将基本类型转换为包装器类型，自动拆箱：将包装器类型转换

为基本类型)1〃自动装箱

2Integertotal=99;

3

4//自动拆箱

5inttotalprim=total;

通过包装类型的parse方法可以实现基本数据类型+String类型之间

的相互转换。

函数需要传递进去的参数为Object类型，传入基本数据类型就不可

行。

17.抽象类和接口的区别？

抽象类：在面向对象里，所有的对象是通过类来描绘的，但反过来

并不是所有的类都是用来描绘对象的，通俗一点讲，如果一个类中

没有包含足够的信息来描绘一个对象，那么这个类就是抽象类。通

常使用关键字abstract来修饰。

abstract类的特点：不能实例化对象，必须被继承才能实现。

abstract类不能使用new运算符创建对象。

第10页共130页

abstract类中可以有abstract方法。

一旦一个类里面有abstract方法，那么这个

类必须用abstract修饰。

接口：java编程语言中的一个抽象类型，，是抽象方法的集合，通

常用关键字interface声明。(隐式抽象不需要关键字abstract

所有方法都是公用的)

interface接口名称[extends其他的接口名]{

//声明变量常量声明所有的常量一定都是公共的public而且是static常量

//抽象方法访问权限一定是public

)

接口的实现：当接口要实现时，类要实现接口中所以有的方法。类

使用关键字implements声明该类实现一个或多个接口(多个时用逗

号隔开)。

publicclassMammalintimplementsAnimal{

publicvoideat(){

System.out.println("Mammaleats");

)

publicvoidtravel(){

System.out.printin("Mammaltravels");

)

publicintnoOfLegs(){

return0;

)

publicstaticvoidmain(Stringargs[]){

Mammalintm=newMammalint();

m.eat();

();

)

)

抽象类与接口的区别：

第11页共130页

抽象类中的方法可以有方法体，就可以实现方法的具体功能，但接

口就不行。

抽象类中的成员变量可以是各种类型，但接口中的成员变量只能是

publicstaticfinal类型的。

接口里只有常量，不能有变量；但抽象类中既有常量也有变量。

接口中不能含有静态代码块和静态方法（static修饰），但是抽象

类中就可以有。一个类只能继承一个抽象类，但一个类可以实现一

个或多个接口。abstract类中可以有非abstract方法，但是接口

不行（abstract是可以省略的）。

18.java里什么是构造函数？构造函数重载？复制构造函数？

构造函数：是函数的一种特殊形式，它不需要定义返回类型，而且

构造函数的名称和所在类的名称相同，其余的与函数的特性相同，

可以带有参数列表，可以存在函数重载。

作用：创建函数对象对象初始化

Java中构造函数重载和方法重载很相似。可以为一个类创建多个构

造函数。每一个构造函数必须有它自己唯一的参数列表。

Java不支持像C++中那样的复制构造函数，这个不同点是因为如果

你不自己写构造函数的情况下，Java不会创建默认的复制构造函

数。

19.面向对象的“六原则一法则”目的分别是什么？

1）一职责原则：一个类只做它该做的事情（单一职责原则表达的是

“高内聚”的思想，写代码最终原则“高内聚，低耦合”。高内聚

第12页共130页

通俗的讲就是一个代码能完成一项功能，在面向对象中，如果只让

一个类完成该做的事，而不涉及到其它无关的类就是高内聚。）

2）开闭原则：设计的系统对扩展开放，对修改关闭。怎么理解呢，

开闭原则在做新功能开发的时候经常用到，我的理解是当我们需要

给一个类添加一个新的功能时，最好的办法不是直接修改这个类的

代码，有可能牵一发动全身，应该考虑如何用一个新的类实现一个

新的功能，最终的效果是一系列相关的功能都有自己的类，当然它

们都继承于父类。

3）依赖倒转原则：高层模块不应该依赖于底层模块，二者都应该依

赖于抽象。抽象不应该依赖于具体实现，具体实现应该依赖于抽

象。其核心思想是面向接口编程。怎么理解呐，就比如说我们要把

生产一辆汽车当做一条程序，首先是不是先要建立接口比如车轮，

车身，汽车。每一个接口都有各自固定的方法，比如车轮这个接口

里面就有大小尺寸的方法。比如我们现在要生产一辆轿车，我们就

要写一个实现这个接口的实现类，类名是轿车轮。要是生产卡车呢

就写一个实现这个接口的实现类。这样一来既节省了时间，也便于

我们更好的维护。

4）里氏替换原则：所有引用父类的地方必须能透明的使用其子类的

对象。比如有两个类一个A类，一个B类，并且A是B的父类。现

在有一个方法可以接受A类对象a时，那么这个方法也能接受B类

对象b。

5）接口隔离原则：接口应该小而专，不应该大而全。

第13页共130页

6）合成聚合复用原则：优先使用聚合或合成关系复合代码。

7）迪米特法则：最少知识原则，一个对象应当对其他对象有尽可能

少的了解。

20.java语言如何处理异常，关键字throw,throws,try,finally

分别代表什么？在宜y块可以抛出异常吗？

异常：程序运行时出现的错误，比如试图打开一个根本不存在的文

件夹等。异常大致分为：Error和Exception两类，Error是程序无

法处理的错误，此类错误一般表示代码运行时JVM出现的错误。比

如虚拟机运行错误或者类定义错误。而Exception代表的是程序本

身能够捕获且可以处理的异常。可以分为两类一种是运行时异常

（不受检异常）一种是非运行时异常（受检异常）。前者属于不可

查异常，一般是由逻辑性错误引起的，在程序中可以选择捕获异

常，也可以不处理。而一旦出现后者这种异常，必须对异常进行处

理。比如lOException,要么使用try-catch捕获，要么使用

throws抛出异常，否则编译不过。

Java处理异常机制：通过面向对象的方法进行异常处理，把不同的

异常进行分类，并提供良好的接口。当一个方法出现异常时就会抛

出一个异常对象，这个对象包含异常信息，然后调用这个对象的方

法就会捕获到异常并进行处理。

throw抛出异常对象thrownew异常类名（参数）；

publicclassDemoThrow{

publicstaticvoidmain（String[]args）{

inta=DemoThrow.div（4,0）;

第14页共130页

System.out.println(a);

)

publicstaticintdiv(inta,intb){

if(b==0)

thrownewArithmeticException("异常信息：除数不能为0");

//抛出具体问题,编译时不检测

returna/b;

)

)

throws声明抛出异常

修饰符返回值类型方法名(参数)throws异常类名工，异常类名2...{}

importjava.io.Fileinputstream;

importjava.io.FileNotFoundException;

importjava.io.Inputstream;

publicclassDemoThrows{

publicstaticvoidmain(String[]args)throws

FileNotFoundException{

readFile();

)

publicstaticvoidreadFile()throwsFileNotFoundException{

Inputstreamis=newFileInputStream("E:/iodemo/ch01.txt");

)

)

try：在这个成员函数内部写另一个try语句保护其他代码。每当遇到一

个try语句，”异常"的框架就放到堆栈上面，直到所有的try语句都

完成。如果下一级的宜y语句没有对某种“异常”进行处理，堆栈就会

展开，直到遇到有处理这种“异常”的try语句。

Finally为确保一段代码不管发生什么“异常”都被执行一段代码。

importjava.io.Fileinputstream;

importjava.io.FileNotFoundException;

importjava.io.Inputstream;

publicclassDemoTryCatch{

publicstaticvoidmain(String[]args){

//捕获异常

try(

//可能产生异常的代码

第15页共130页

readFile();

}catch(FileNotFoundExceptione){

//异常的处理逻辑,将异常记录日志,异常封装后显示

System.out.printin("系统找不到指定的路径”);

}

System.out.printIn(“后续代码”)；

}

publicstaticvoidreadFile()throwsFileNotFoundException{

Inputstreamis=newFileInputStream("E:/iodemo/ch01.txt");

)

)

21.说明一下finalfinallyfinalize的区别？

final声明属性、方法、类，分别表示属性不可变、方法不可覆盖、

类不可继承。

finally是异常处理语句的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用

被回收的对象的此方法，可以覆盖此方法提供垃圾回收的其他资源。

22.面向对象的特征？

抽象：：抽象是将一类对象的共同特征总结出来构造类的过程，包括

数据抽象和行为抽象两方面，抽象只关注对象的哪些属性和行为，并

不关注这此行为的细节是什么

封装：将数据和行为组合到一个包中，并对对象的使用者隐藏具体的

实现方式。

继承：当两个类具有相同的属性和方法时，可以将相同的部分提取

出

出来作为父类，其他的类继承这个类的方法和属性。

多态：同一个行为用不同的表现形式或形态的能力。说具体点就是

同一接口，使用不同的实例而执行的结果。

第16页共130页

23.java是否具支持多继承？

Java中类是不支持多继承的。(一个类只能有一个父类)但java中

接口是支持多继承的，即一个接口可以有多个父接口。

24.如何通过反射创建对象？反射：java反射机制是在运行过程中，

对任何一个类，都可以知道这个类的所有方法和属性；对于任何一个

对象，都可以知道这个对象的所有方法和属性。

第一种通过class的newlntance()方法来创建对象。

第二种通过Constructor的newlntance()方法来创建对象。

25.string、stringBuffer、stringBulide的区别？String不可变有

什么好处？

string：是字符串常量string类是final的所以string不可以继

承没有子类。

stringBuffer：是字符变量，是线程安全的，也就是多线程修改同一

个StringBuffer对象的时候，过程是同步的，当然这就导致了

StringBuffer的效率降低。

不可变对象是指一个对象的状态在对象被创建之后就不再变化。不可

改变的意思就是说：不能改变对象内的成员变量，包括基本数据类型

的值不能改变，引用类型的变量不能指向其他的对象，引用类型指向

的对象的状态也不能改变。

String不可变是因为在JDK中String类被声明为一个final类,

且类内部的value字节数组也是final的，只有当字符串是不可

变时字符串池才有可能实现，字符串池的实现可以在运行时节约很多

第17页共130页

heap空间，因为不同的字符串变量都指向池中的同一个字符串；如

果字符串是可变的则会引起很严重的安全问题，譬如数据库的用户名

密码都是以字符串的形式传入来获得数据库的连接，或者在socket

编程中主机名和端口都是以字符串的形式传入，因为字符串是不可变

的，所以它的值是不可改变的，否则黑客们可以钻到空子改变字符串

指向的对象的值造成安全漏洞；因为字符串是不可变的，所以是多线

程安全的，同一个字符串实例可以被多个线程共享，这样便不用因为

线程安全问题而使用同步，字符串自己便是线程安全的；因为字符串

是不可变的所以在它创建的时候hashcode就被缓存了，不变性也保

证了hash码的唯一性，不需要重新计算，这就使得字符串很适合作

为Map的键，字符串的处理速度要快过其它的键对象，这就是

HashMap中的键往往都使用字符串的原因。

26.String类的常用方法？

publicintlength()获取string对象的字符序列长度。

Stringchina="1998年出生”;

intnlrn2£

nl=chian.lenght();

n2="小鸟fly”.lenght();

nl的值是7,n2的值是5

publicintcompareTo(Strings)按字典序与参数指定的string对

象s的字符序列比较大小.如果String对象的字符序列与s相同，该

方法返回0,大于返回正值。

publicintindexOf(Strings)从当前string对象的字符序列的0

索引位置开始检索首次出现S的位置并返回该位置

Stringtom="Iamagoodcat";

第18页共130页

//0123456789从零开始的并且空格也算一个数如果没有返回-1

tom.indexOf("a");//值是2

tom.indexOf("good"A2);//值是7从当前字符串的第二位开始数

tom.indexOf("wn,2);//-I

publicintindexOf(Strings,intstartpoint)

从当前字符串的startpoint位置开始检索字符串s,并返回首次出现s的位置。

没有找到的时候，返回T.

publicintlastlndexOf(Strings)从当前String对象的字符序列

的0索引位置开始检索最后一次出现S的位置并返回该位置

publicbooleanequals(Strings)比较当前string对象的字符

序列是否和参数相等

Stringtom=newString("天道酬勤”)；

Stringboy=newString(“知心朋友”)；

Stringjerry=newString(“天道酬勤”)；

tom.equlas(boy);//false比较对象tom和参数boy是否相等如果相等返回

true否贝!Jfalse

tom.equals(jerry);//true

publicbooleanstartsWith(Strings)string字符前缀是否相等

publicbooleanendWith(Strings)string字符后缀是否相等

publicbooleancontains(Strings)判断当前String对象的

字符序列是否包含参数S的字符序列。

publicStringsubstring(intstartpoint)字符串对象调用该方法

获得一个新的String对象

27.说明Comparator和Comparable接口的区别以及它们的作用？

Comparator接口里面有两种方法一种是compare另一种是equals。

compareO方法用来给输入两个输入的参数排序，返回值负、0、

正分别代表第一个参数小于、等于、大于第二个参数。equalsO

方法需要一个对象作为参数，然后才能决定对象是否和comparator

相等，如果相等返回true,不相等返回false。

第19页共130页

comparable接口里面只有一个compareTo()方法，这个方法用来

给两个对象排序。它返回负数、0、正数表示输入对象小于、等于、

大于已经存在的对象。

28.解释一下类加载机制，什么是双亲委派模型？好处是什么？

类加载机制：将类的.class文件中的二进制数据读入到内存中，将

其放在运行时数据区的方法区内，然后在堆内创建一个

java.lang.Class对象，用来封装类在方法区的数据结构。类加载的最

终结果是堆内的class对象，class对象封装了方法区的数据结

构，并向程序员提供访问方法区数据结构的接口。

双亲委派机制：当一个类加载器收到类加载请求时，它首先不会自

己加载这个类，而是把加载这个类的请求委派给自己的父类加载

器，每一层加载器都是这样，这样一来加载请求就会传送到顶层的

启动加载器中，只有父类加载器无法完成加载请求时(搜索范围没

有要加载的类)，子类加载器才会尝试去完成类的加载。

好处：避免重复加载，提高效率。父类已经加载了，子类就不需要

加载了。

很好的解决了各个类加载器之间基础类的的同一问题，如果不使用

该种方式，那么用户随意定义类加载器来加载核心API,会带来相

关的隐患。

29.请说明static关键字是什么意思?Java中是否可以覆盖

(override)——个private或static的方法？

static:static关键字表示一个成员变量或者成员方法可以在没有

第20页共130页

所属类的实例变量的情况下被访问。

修饰变量：static变量类型变量名

目的：作为共享变量使用减少创建对象保留唯一副本

修饰方法：【访问权限修饰符】static方法返回值方法名(参

数列表)

Java中static方法不能被覆盖，因为方法覆盖是基于运行时动态

绑定的，而static方法是编译时静态绑定的。static方法跟类的

任何实例都不相关，所以概念上不适用。

30.列举object类的方法并简要说明。

object类：所以类的超类(父类)

equals方法：确定两个对象的引用是否相等。

hashCode方法：返回对象的哈希码值。publicinthashCode()

getClass方法：返回object运行时的类。

publicfinalclassgetClass()

toString方法：返回对象值的一个字符串。

publicStringtoString()

StringtoString(){

getClass().getName()+n@n+Integer.toHexString(hashCode())；

getClass().getName()++Integer.toHexString(hashCode())这返

回的是：类的全路径名称+它的哈希码值。

31.类和对象的区别？

定义上的不同：类是现实世界或思维世界在计算机的反映，它将数

据和数据上的操作封装起来。

第21页共130页

对象是具有类类型的变量，两者是面向对象编程最基本的概念。

范畴不同：类是一个抽象概念，它不存在现实世界的时间、空间

里。类知识为所有对象定义了抽象的属性和行为。

对象则是类的一个具体。

状态不同：类是一个静态的概念，类本身不携带任何数据。当没有

为类创建任何数据时，类本身不存在于内存空间。

对象是动态的概念，每一个对象都存在着有别于其他对象的属性和

行为。

二者的联系：类是对象的抽象，对象是类的具体。二者的关系犹如

模板和铸件一样，类的实例化就是对象。

32.类的加载过程？如何保证我的类被指定加载器加载？相同的类被

不同的加载器加载，这两个类相同吗？

类加载机制：

加载一验证—准备—,解析一,初始化

加载：在内存中生成java.long.class对象，作为方法区这个类的

各种数据入口。（注意这个过程并不是一定要去class类中获取，

还可以从zip包或者运行时计算生成）

验证：这个过程主要确保class文件中的字节流中包含的信息是否

满足当前虚拟机的要求。

准备：准备阶段是正式为类变量分配内存，设置变量初始值的阶

段。在方法区中分配这些变量所使用的空间。

解析:虚拟机将常量池中的符号引用替换为直接引用的过程。符号引

第22页共130页

用就是class文件中:

CONSTANT_Class_info

CONSTANT_Field_info

CONSTANT_Method_info

等类型的常量。

初始化：类加载的最后一个阶段，前面的加载阶段可以自定义加载

器以外，其他阶段都是有jvm主导的。这个阶段是执行类构造器

〈client》方法的过程。

一个类，由不同的类加载器实例加载的话，就会在方法区产生两个

不同的类，彼此不可见，并且在堆中生成不同的class实例。

33.什么是集合？它的作用是什么？集合与数组的区别？Java集合

框架体系结构？

集合：是一种java工具类，像是一种容器，用来存储任意数量的具

有相同属性的对象。

作用：在类的内部，对数据进行组织。

简单快速的搜索大量的条目。

有的集合接口，提供一系列排列有序的元素，并且可以在有

序列中快速的插入删除有关元素。

还有一些集合接口，提供映射关系，可通过关键字（key）去

快速查找唯一对应的对象，且这个关键字的类型是任意的。

区别：数组长度固定不变，集合长度改变。

数组只能通过下标去访问元素，类型固定（整型），有的集

第23页共130页

合可以通过任意类型查找所映射的具体对象。

Java集合框架体系结构：

lis厢Queue是有序，可以重复科既U的

list（序列）子接口0实现类ArrayList数组序列

一~一~Queue（队列）子•接口©实现类LinkedList链表

Collectionm接口>-----------------------------------------------

1\set（集）子接口0实现类Headset哈希集

java集合框架体系结构无序，不可重复科既

<key,Value〉Entry（键对值）内音凑

~〜实现类HeadMap哈希表

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

34.什么是迭代器（Iterator）?迭代器的fail-fast机制？主要解

决什么问题？

迭代器：是一种设计模式，是一个对象，它的工作是遍历并选择序

列中的对象。（遍历就是把每一个元素访问一边）（java的迭代器

只能单向移动）

迭代器方法：next。获取序列的下一个元素。

HasNextO检查序列中是否还有元素（如果有返回

true）o

Remove。删除上次调用next（）方法返回的元素。

迭代器的作用：为各种容器提供公共的操作接口，使用java的迭代

器iterator可以使对容器的遍历操作完全与其底层隔离可以很好地

达到解耦效果。（解耦：较为具体的说明就是有的时候程序需要修

改，我只需要改正一部分，单是如果程序的耦合性很强的话就需要

从头再写一遍很不划算，而正常的开发中都是改那部分，重写那部

分，把配置文件一改就成了，java中通过接口（interface）,

第24页共130页

spring技术中的ioc等实现的解耦合，重写覆盖父类的方法也是一

种解耦行为)

迭代器源代码：

importjava.util.*;

publicclassT㊀st工t㊀rator{

publicstaticvoidmain(Stringargs[]){

//创建一个list它是一个序列化的数据

List1ist=newArrayList();

//创建一个map,它是一个非序列化的数据

Mapmap=newHashMap();

for(inti=0;i<10;i++){

//向容器中添加数据

list•add(newString();

map.put(i,newString(”map"+i));

}

//序列化了的数据创建迭代器。

IteratoriterList=list•it㊀rator();//List接口实现了工t㊀rabl㊀接口

//进行遍历如果容器中有下一个数据，就获取下一个数据并打印出来

while(iterList.hasNext()){

StringstrList=(String)iterList.next();

System.out.printIn(strList.toString());

}

//创建非序列化数据的迭代器，要先将其序列化

IteratoriterMap=map.entrySet().iterator();

//进行遍历如果容器中有下一个数据，就获取下一个数据并打印出来

while(iterMap.hasNext()){

Map.EntrystrMap=(Map.Entry)iterMap.next();

System.out.printin(strMap.getValue());

}

)

}

迭代器的fail-fast机制：

Fail-fast是java集合中的一种错误机制，当多个线程对同一

集合的内容同时操作时，就可能会产生fail-fast事件。比如说

35.set、Map、List接口存取元素时，各有什么特点？以及

collection^set>map、list之间的联系和区另U?

第25页共130页

Set(集)接口存取元素时不允许增加重复的元素(用对象的

equals()方法来区分元素是否重复)。

publicstaticvoidmain(String[]args){

HashSet<String>hashSet=newHashSet<>();

LinkedHashSet<String>linkedHashSet=newLinkedHashSet<>();

TreeSet<String>treeSet=newTreeSet<>();

for(Stringdata:Arrays.asListC'afaE","afaE","asfweD",

"hfasfae","aefaeA")){

hashSet.add(data);

linkedHashSet.add(data);

treeSet.add(data);

}

//HashSet:无序,随机输出。底层数据结构是哈希表,依赖hashCode()和

equals()两个方法来保证唯一性。

System.out.printIn("OrderinginHashSet:"+hashSet);

“LinkedHashSet:FIFO插入有序,先进先出。底层结构是链表和哈希表,

由链表保证元素有序,哈希表保证元素唯一。

System.out.println("OrderofelementinLinkedHashSet:"+

linkedHashSet);

//TreeSet：有序,唯一。底层结构是红黑树,排序采用自然排序和比较容器

排序,根据比较的返回值是否为。来判断元素唯一。

System.out.printIn("OrderofobjectsinTreeSet:"+

treeSet);

)

*>rubhr->；•»,OCXXKOW

*terminated•【JavaApp»c«tior]ew(2019^3^195上午

OrdvringinHji>ehS*t：[af«B.MXVMD,hfaufa«,awfawAj

OrderofelenentinLinkedHashSet:[afaE.asfweDhfasf&e,aefaeA]

Ordercfobj«ctsinTr«eS«t：(••fiwA,af«BrasfweD.hfasf40]

Map(映射)接口存取元素时采用键对值(key-value)的方式来存

取。key唯一的，value不唯一可以重复，一个value有一个

key对映。

publicstaticvoidmain(String[]args){

第26页共130页

//HashMap采用键值对存储数据,采用put。方法存放数据

Map<IntegerJString>map=newHashMap<Integer,String)。；

map.put(l?“中国“)；

map.put(2?“小日本”)；

map.put(3,“美国佬”)；

//foreach遍历方法》普遍使用,通过对hey唯一的特性,进行huy遍历

for(Integerkey:map.keySet()){

System.out.println(key+"+map.get(key));

}

System.out.printin("----------------------------------------------------------------");

//因为hey唯一,key重复时会自动覆盖value之前存储的数据

map.put(3?”英国佬”)；

for(Integerkeyl:map.keySet()){

System.out.println(keyl+"+map.get(keyl));

}

System.out.printin("----------------------------------------------------------------");

//Map.Entry遍历hey和value,同样是foreach方法,推荐容量大的时候

使用

for(Map.Entry<IntegerJString>entry:map.entrySet()){

System.out.printin(entry.getKey()++

entry.getValue());

}

)

.*;，«»J>L.OComoU汉

*terminated>Trw&«t1(JwaAppfic«t>on)(2019^3Qi99下*2:16901)

List(列表)接口用特定的索引来存取，可以有重复元素。

publicstaticvoidmain(String[]args){

List<Integer>arraylist=newArrayList<>();

arraylist.add(3);

arraylist.add(22);

arraylist.add(31);

arraylist.add(345);

arraylist.add(63);

arraylist.add(3);

第27页共130页

//ArrayLtst底层是一个数组,输出时需要于oreach遍历,查询快,增删慢,线层安全)

效率高

System.out.print("arraylist:

for(Integertest:arraylist){

System.out.print(test+"");

System.out.printin();//换行

//Vector底层是一个实现自动增长的对象数组,元素会自动添加到数组中,查询快,增

删慢,线层安全,效率低

Vector<Integer>vector=newVector<>();

vector.add(3);

vector.add(5);

vector.add(25);

vector.add(51);

vector.add(5);

System.out.printin("vector:"+vector);

//LtnhedLtst底层是一个链表,查询慢,增删快,线层不安全,效率高

LinkedList<Integer>linkedList=newLinkedList<>();

linkedList.add(30);

linkedList.add(30);

linkedList.add(34);

linkedList.add(55);

System.out.printIn("linkedlist"+linkedList);

•：QComote

«t«rrntna<»d»IrwSHl(JavaApplicalicn]^0^201\bir(2019*3月19m上学11:11:19)

&rraylifii:32231345633

vector：[X5,25,51,5]

linkedlifit[30.30,34,55]

Set、list者B是collection接口的子接口，map接口和

collection接口是同等级的。

36.详细介绍java集合框架结构？

list接口的实现类：

ArrayList:基于数组实现，非线性安全、效率高、增删慢、查找

快。

Vector:基于数组实现，线性安全、效率低、增删慢、查找慢。

LinkedList:基于链表实现，链表内存是散列的、增删快、查找慢。

Map接口的实现类：

第28页共130页

HashMap:基于hash表的map接口实现，非线性安全、高效、支持

null值和null健。

HashTable:线程安全、低效、不支持null值和null健。

sortedMap接口：TreeMap能够把它保留德记录根据健排序，默认升

序排序。

Set接口的实现类：

HashSet：底层是由HashMap实现，不允许集合中有重复的值，使

用该方式时需要重写equals。和hashCode。方法。

第29页共130页

排列有序,可重复

底层使用数坦

ArrayList速磨快，塔珊侵，getter便Gseneq）方法快

送程不安叁倒

当零星不婚时,ArrayList是当前容量*15*1

排列有序，可里昼

底层使用数阻

Vector速，章快.塔珊奥

线朝全融低

当容量慢氏