当前位置：文档之家› 华为面试题目

华为面试题目

面试题目

1、java的基本类型有几种，分别是那些？String是否为基本类型？

Java语言提供了八种基本类型：

六种数字类型（四个整数型，两个浮点型）

字节型byte 8位短整型short 16位整型int 32位长整型long 64位

单精度float 32位双精度double 64位

一种字符类型

字符型char 8位

还有一种布尔型。

布尔型：boolean 8位可存储"True"和"false"

========================================

String一直都是面试的问题，经常会听到有人说“String型”。老师也是这样说。我不知“String型”的意思是什么！但初学者往往都会说“String型”

举一个简单的例子：

String str1 = "x" ;

String str2 = "x" ;

String str3 = ne w String("x") ;

String本身就是一个对象而不是基本数据类型，String的变量名是对String类的引用。

其它那些Stirng Literals P ool就不讲了，我只是简单地讲下上面的过程，希望对大家用少少用

在声名str1的时候，由于还有没等于"x"的对象，所以就创建了一个新的对象；

在声名str2的时候，由于有了等于"x"的对象，所以系统就将其值取出直接返回给str2，所以str1和str2变量名都是作为"x"对象的引用。

当然new String()就实列一个新的对象了。

到了这里大家还会认为"String型"吗？

==============================================

再讲一下“==”和“equals”的用法！（会更理解上面所说的）

== 对象的比较好像也就是地址的比较

equals对象值的比较

==比较的是对象的引用，equal s比较的是对象的值

所以str1 == str2 返回True，str1 == str3 返回False， str1.equals(str3)返回True。

==============================================

2、Integer和int的区别

int 是基本数据类型

Integer是其包装类，注意是一个类。

为什么要提供包装类呢？？？

一是为了在各种类型间转化，通过各种方法的调用。否则你无法直接通过变量转化。比如，现在int要转为String

int a=0;

String result=Integer.toString(a);

在java中包装类，比较多的用途是用在于各种数据类型的转化中。

3、String和StringBuffer的区别

String:

是对象不是原始类型.

为不可变对象,一旦被创建,就不能修改它的值.

对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.

String 是final类,即不能被继承.

StringBuffer:

是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象

它只能通过构造函数来建立,

StringBuffer sb = new StringBuffer();

note:不能通过付值符号对他进行付值.

sb = "welcome to here!";//error

对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.向StringBuffer

中付值的时候可以通过它的append方法.

sb.append("hello");

字符串连接操作中StringBuffer的效率要比String高:

String str = new String("welcome to ");

str += "here";

的处理步骤实际上是通过建立一个StringBuffer,让侯调用append(),最后

再将StringBuffer toSting();

这样的话String的连接操作就比StringBuffer多出了一些附加操作,当然效率上要打折扣.

并且由于String 对象是不可变对象,每次操作Sting 都会重新建立新的对象来保存新的值. 这样原来的对象就没用了,就要被垃圾回收.这也是要影响性能的.

4、简单介绍Servlet的生命周期，Servlet是否会被多次初始化？

图解Servlet生命周期

Servlet的生命周期定义了一个Servlet如何被加载、初始化，以及它怎样接收请求、响应请求、提供服务。在网上找到一张关于Servlet生命周期的图解，我在旁边加标了中文（红色表示正常执行的线路，蓝色表示异常抛出）说到生命周期之前，可能先对于几个Servlet方法有个了解会有助于深刻理解Servlet生命周期：

1）init()方法

在Servlet的生命周期中，仅执行一次init()方法。它是在服务器装入Servlet时执行的，可以配置服务器，以在启动服务器或客户机首次访问Servlet 时装入Servlet。无论有多少客户机访问Servlet，都不会重复执行init();

2）service()方法

它是Servlet的核心。每当一个客户请求一个HttpServlet对象，该对象的Service()方法就要调用，而且传递给这个方法一个“请求”（ServletRequest）对象和一个“响应”（ServletResponse）对象作为参数。在HttpServlet中已存在Service()方法。默认的服务功能是调用与HTTP请求的方法相应的do功能。

3）destroy()方法

仅执行一次，在服务器端停止且卸载Servlet时执行该方法，有点类似于

C++的delete方法。一个Servlet在运行service()方法时可能会产生其他的线程，因此需要确认在调用destroy()方法时，这些线程已经终止或完成。

那么现在开始谈Servlet的生命周期，它始于装入Web服务器的内存时，并在终止或重新装入Servlet时结束。

一、加载和实例化Servlet

Tomcat服务器在如下时刻加载和实例化Servlet:

a) 如果已配置自动装入选项，则在启动服务器时自动载入。

b) 在服务器启动后，客户机首次向Servlet发出请求时。

c) 重新装入Servlet时。

当启动Servlet容器时，容器首先去查找一个配置文件web.xml，这

个文件中记录了可心提供服务的Servlet。每个Servlet被指定一个Servlet名，也就是这个Servlet实际对应的Java的完整class文件名。Servlet容器会为

每个自动装入选项的Servlet创建一个实例。所以，每个Servlet类必须有一个公共的无参数的构造器。

二、初始化

当Servlet被实例化后，Servlet容器将调用每个Servlet的init方法来实例化每个实例，执行完init方法之后，Servlet处于“已初始化”状态。所以说，一旦Servlet被实例化，那么必将调用init方法。通过Servlet在启

动后不立即初始化，而是收到请求后进行。在web.xml文件中用

...... 对Servlet进行预先初始化。如上图所示，初始化失败后，执行init()方法抛出ServletException异常，Servlet 对象将会被垃圾回收器回收，当客户端第一次访问服务器时加载Servlet实现类，创建对象并执行初始化方法；这种情况：如Servlet与一个没有启动的数据库连接时。

三、请求处理

对于到达服务器的客户机请求，服务器创建特定于请求的一个“请求”

对象和一个“响应”对象。调用service方法，这个方法可以调用其他方法来处理请求。Service方法会在服务器被访问时调用，Servlet对象的生命周期中service方法可能被多次调用，由于web-server启动后，服务器中公开的部分

资源将处于网络中，当网络中的不同主机（客户端）并发访问服务器中的同一资源，服务器将开设多个线程处理不同的请求，多线程同时处理同一对象时，有可能出现数据并发访问的错误。

另外注意，多线程难免同时处理同一变量时（如：对同一文件进行写操作），且有读写操作时，必须考虑是否加上同步，同步添加时，不要添加范围过大，有可能使程序变为纯粹的单线程，大大削弱了系统性能；只需要做到多个线程安全的访问相同的对象就可以了；

四、终止Servlet

当服务器不再需要Servlet实例或重新装入时，会调用destroy方法，使用这个方法，Servlet可以释放掉所有在init方法申请的资源。一个Servlet 实例一旦终止，就不允许再次被调用，只能等待被卸载。

五、卸载Servlet

Servlet一旦终止，Servlet实例即可被垃圾回收，处于“卸载”状态，如果Servlet容器被关闭，Servlet也会被卸载，一个Servlet实例只能初始化一次，但可以创建多个相同的Servlet实例。如相同的Servlet可以在根据不同的配置参数连接不同的数据库时创建多个实例。

5、简单介绍ArrayList，LinkedList，Vector的特性及区别

ArrayList和Vector是采用数组方式存储数据，此数组元素总数大于实际存储的数据个数以便增加和插入元素，二者都允许直接序号索引元素，但是插入数据要移动数组元素等内存操作，所以它们索引数据快、插入数据慢。

Vector由于使用了synchronized同步方法（如add、insert、remove、set、equals、hashcode等操作），因此是线程安全，性能上比ArrayList要差。

LinkedList使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但是插入数据时只需要记录本项的前后项即可，所以插入数度较快！

LinkedList双向链表，是指可以从first依次遍历至last（从头到尾），也可以从last遍历至first（从尾到头），但首尾没有构成环，不同于双向循环链表（注意区分）：

6、Java中的抽象类和接口的区别

简单来说，

接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的，

另外，实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。

还有，接口可以实现多重继承，而一个类只能继承一个超类，但可以通过继承多个接口实现多重继承，接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用.

7、Struts2中的action和Servlet的区别

Struts1的action完全就是Servlet

因为ActionServlet类继承自Servlet

而struts2就是纯JavaBean。。他的实现是基于拦截器

当FilterDispather拦截到请求以后，会根据你的请求，去xml中找相关的bean，然后创建一个JavaBean

跟Servlet没半毛钱关系

需要把Action看成一个前端的逻辑单元，甚至是独立于Struts框架本身（所以建议在Action 中尽量不要使用Struts2的API，比如HttpRequest, ActionContext等等）。Servlet完全是容器相关的，所以从这一点上说，Action更加抽象化了一层。当然如果从MVC模式看的话Struts 1中的Servlet应该算是Controller部分，Action应该看成是Model部分;而在Struts 2中用FilterDispatcher代替了Servlet。

8、简单介绍Spring的IOC和AOP

Spring框架为J2E E应用常见的问题提供了简单、有效的解决方案，使用Spring，你可以用简单的P OJO(P lain Old Java Object)来实现那些以前只有E JB才能实现的功能。这样不只是能简化服务器端开发，任何Java系统开发都能从Spring 的简单、可测试和松耦合特征中受益。可以简单的说，Spring是一个轻量级的反向控制（IoC）和面向切面编程（AOP）容器框架[3]。Spring IoC，借助于依赖注入设计模式，使得开发者不用理会对象自身的生命周期及其关系，而且能够改善开发者对J2EE模式的使用；Spring AOP，借助于Spring实现的拦截器，开发者能够实现以声明的方式使用企业级服务，比如安全性服务、事务服务等。Spring IoC和Spring ; AOP组合，一起形成了Spring，这样一个有机整体，使得构建轻量级的J2E E架构成为可能，而且事实证明，非常有效。没有Spring IoC的Spring A OP是不完善的，没有Spring AOP的Spring IoC是不健壮的。

9、描述你在项目中的异常处理方案

异常，为我们处理非正常的业务流程提供了很好的解决方案，如果你有过dbase、c、pascal等过程式语言开发的经历，你一定会深刻体会到，异常机制给你的代码可读行、可维护性带来的好处，同时，程序的健壮性也得到了增强。

在 java项目中，异常设计要注意下面的几点。

一、自定义异常父类的选择

A、自定义异常的父类，可以选择为RuntimeException或Exception。RuntimeException是运行时异常，你可以选择它来做为你的异常父类，因为这种异常不受到编译器检查，因此，给予了程序员很大的灵活性，程序员可以处理这种异常，也可以不处理（实际上并不是不处理，而是不立即处理，等到一个合适的地方再进行处理）。选择RuntimeException作为父类，是很多框架常采用的，如果你是做底层框架的，可以选择 RuntimeException。

B、业务层异常，一般选择Exception作为父类，因为业务层异常比较重要，一般都是要由调用者进行处理或者是要告知调用者会发生这种异常。如果你的代码

是提供给第三方厂商用的，业务层封闭统一的异常就显得非常的有必要。这类异常会强制要求程序员进行处理（异常转译或继续声明抛出），程序完整性、健壮性得到了加强。

二、业务层自定义异常结构的设计

A、业务层自定义异常可以考虑按子系统来划分，也就是说，每一个子系统（模块）都有自己的异常定义，每个子系统自己维护自己的，统一向调用者抛出。

B、根据业务类型，从逻辑上划分异常类型，比如：权限相关的，安全相关的，数据库相关的等等。

总的来说，这两种自定义异常也可以混合使用，因为有的时候，子系统（业务模块）本身就是从逻辑上进行划分的。

三、异常结构定义

异常类的父类选定后，再定义自己的异常结构。一般的异常类中，要定义这么一些东西。

A、描述字符串，说明异常的起因，或说明等。

B、异常码。定义一个int或String类型的异常码，异常码在整个系统中统一定义，根据异常继承结构，异常码也可以定义得有层次结构。异常码在大的系统中比较常见，Oracle ,Sqlserver等数据库产品中，或华为、中兴的一些驱动api 中。

C、定义一个Throwable的成员变量，用以封装异常结构链。

D、定义无参数、有参数（String，Throwable）的构造方法。

四、在WEB三层模型中，异常的处理

在经典的三层架构模型中，通常都是这样来进行异常处理的：

A、持久层一般抛出的是RuntiomeException类型的异常，一般不处理，直接向上抛出。

B、业务层一般要封装自定义异常，统一向外抛出（这里要注意，如果用spring 在业务层管理异常，一定要配置好异常回滚类型，因为spring默认只回滚RuntiomeException类型的）。我也见过一些想省事的人，业务层也不定义任何异常，也不进行try catch，如果业务层出现异常将在表现层进行处理及页面跳转。

C、表现层必须要处理业务层的异常，以正确向客户报告系统出现的问题，这里面是最后一道异常处理的地方。我也见过有懒人在业务层都不处理，直接在web.xml中配置errorPage的，但不建议这么做。

用好异常，对于项目的可维护性、健壮性都有极大的好处，当然，异常也不是万能的，在有些项目中并不适用，比如：纯算法项目，对性能要求极高的项目等，因为异常栈会对系统性能有一定开销，在这些项目中，最后还在老老实实用方法的返回值去标识方法执行的结果，用if else去处理业务逻辑中的非正常情况吧。

10、Forward和redirect的区别

forward方式：request.getRequestDispatcher("/somePage.jsp").forwardrequest, response);

redirect方式：response.sendRedirect("/somePage.jsp");

forward是服务器内部重定向，程序收到请求后重新定向到另一个程序，客户机并不知道；

redirect则是服务器收到请求后发送一个状态头给客户，客户将再请求一次，这里多了两次网络通信的来往。当然forward也有缺点，就是forward的页面的路径如果是相对路径就会有些问题了。 forward 会将 request state , bean 等等信息带往下一个 jsp

redirect 是送到 client 端后再一次 request , 所以资料不被保留.

使用 forward 你就可以用 getAttribute() 来取的前一个 jsp 所放入的 bean 等等资料在网上看到一些帖子，总结了一些区别，可以从以下几个方面来看：

1.从地址栏显示来说

使用forward的时候浏览器不知道它所请求的具体资源来源，所以地址栏不会变；

使用redirect，服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL。

2.从数据共享来说

forward:转发页面和转发到的页面可以共享request里面的数据.

redirect:不能共享数据.

redirect不仅可以重定向到当前应用程序的其他资源,还可以重定向到同一个站点上的其他应用程序中的资源,甚至是使用绝对URL重定向到其他站点的资源.

forward,方法只能在同一个Web应用程序内的资源之间转发请求.forward 是服务器内部的一种操作.

redirect 是服务器通知客户端,让客户端重新发起请求.

所以,你可以说 redirect 是一种间接的请求, 但是你不能说"一个请求是属于forward还是redirect "

3.从运用地方来说

forward:一般用于用户登陆的时候,根据角色转发到相应的模块.

redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等.

4.从效率来说

forward:高.

redirect:低.

11、Java实现多线程有那些方法，如何启动一个线程

1、认识Thread和Runnable

Java中实现多线程有两种途径：继承Thread类或者实现Runnable接口。Runnable是接口，建议用接口的方式生成线程，因为接口可以实现多继承，况且Runnable只有一个run方法，很适合继承。在使用Thread的时候只需继承Thread，并且new一个实例出来，调用start()方法即可以启动一个线程。

Thread Test = new Thread();

Test.start();

在使用Runnable的时候需要先new一个实现Runnable的实例，之后启动Thread即可。

Test impelements Runnable;

Test t = new Test();

Thread test = new Thread(t);

test.start();

总结：Thread和Runnable是实现java多线程的2种方式，runable是接口，thread 是类，建议使用runable实现java多线程，不管如何，最终都需要通过thread.start()来使线程处于可运行状态。

2、认识Thread的start和run

1）start：

用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到spu 时间片，就开始执行run()方法，这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。

2）run：

run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。

总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。

3、线程状态说明

线程状态从大的方面来说，可归结为：初始状态、可运行状态、不可运行状态和消亡状态，具体可细分为上图所示7个状态，说明如下：

1）线程的实现有两种方式，一是继承Thread类，二是实现Runnable接口，但不管怎样，当我们new了thread实例后，线程就进入了初始状态；

2）当该对象调用了start()方法，就进入可运行状态；

3）进入可运行状态后，当该对象被操作系统选中，获得CPU时间片就会进入运行状态；

4）进入运行状态后case就比较多，大致有如下情形：

·run()方法或main()方法结束后，线程就进入终止状态；

·当线程调用了自身的sleep()方法或其他线程的join()方法，就会进入阻塞状态(该状态既停止当前线程，但并不释放所占有的资源)。当sleep()结束或join()结束后，该线程进入可运行状态，继续等待OS分配时间片；

·当线程刚进入可运行状态(注意，还没运行)，发现将要调用的资源被锁牢(synchroniza,lock)，将会立即进入锁池状态，等待获取锁标记(这时的锁池里也许已经有了其他线程在等待获取锁标记，这时它们处于队列状态，既先到先得)，一旦线程获得锁标记后，就转入可运行状态，等待OS分配CPU时间片；

·当线程调用wait()方法后会进入等待队列(进入这个状态会释放所占有的所有资源，与阻塞状态不同)，进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒(由于notify()只是唤醒一个线程，但我们由不能确定具体唤醒的是哪一个线程，也许我们需要唤醒的线程不能够被唤醒，因此在实际使用时，一般都用notifyAll()方法，唤醒有所线程)，线程被唤醒后会进入锁池，等待获取锁标记。

·当线程调用stop方法，即可使线程进入消亡状态，但是由于stop方法是不安全的，不鼓励使用，大家可以通过run方法里的条件变通实现线程的stop。

12、Try｛｝里面有一个return语句，那么紧跟在这个try后的finally{}里面的code会不

会被执行，什么时候执行，在return前还是后？

你写一个很简单的例子就知道了

string str = "aa";

try

{

str = "bb";

return;

}

catch

{

str = "cc";

}

finally

{

str = "dd";

}

你看一下最后的结果是"bb"还是"dd"

为什么叫finally就是因为它始终是要执行的

不执行叫什么finally呢?

所以你即使return了这个值还是会按照finally里面的来执行

这个结果可以证明是执行完finally里面的代码后才return的

13、写出一种Orcal的查询分页方法或思路

select * from (

select rownum as rn, a.* from table a)

where rn between 1 and 10

显示1到10的数据，也就是第一页

你的后台在运行sql语句的时候，可以计算页面要显示的数据数，然后传给rn between 就可以了

比如一页要显示10条数据，第3页要显示的数据就是

rn between (3*10+1) and ((3+1)*10)

14、SQL中的左连接，右连接以及内连接分别有什么特点

左外连接是返回主表的所有信息,如果从表没有主表信息显示为空

而内连接是以从表为主如没数据那么就不显示

举个例子

如有2张表student grade

student

有sid,sname两列

有3条数据1,呵呵2,嘿嘿3,嘻嘻

grade

有score,sid

有2条数据90,1 80,2

比如我们要查哪个人考了多少分呢么左连接就是

呵呵90

嘿嘿80

嘻嘻null

内连接就是

呵呵90

嘿嘿80

15、以下代码是否有误：

Short c= 1；

c= c+1；

这是一个类型高级与低级的问题，前面的C是short型的，后面的1为int型的，short型与int型的相加得到short型是不可取，因为必须将int型转换为short 型，short型级别比int型高，可以short与int型相加存储为int型，但是却不能short与int型相加存储为short型，c=c+1属于short型与int型相加存储为short 型，后者为short型与short型相加存储为short型，或许说得有点绕，你可以去查int、short、long这几个的优先级，里面就会谈到这个问题

16、计算出以下代码的打印结果：

int k = 0;

for(int I = 0;I<100;i++){

k=k++;

}

System.out.print(k);

K=0

17、指出下面程序的运行结果：

class A｛

static｛

System.out.print(“1”);

｝

public A()｛

System.out.print(“2”);

｝

class B extends A｛

static｛

System.out.print(“a”);

｝

public B（）｛

System.out.print(“b”);

｝

public class Test{

public static void main(String[] args){

A ab = new B();

ab = new B();

｝

父类与子类执行的先后顺序

静态变量的执行特性

方法重写（override）的注意事项

当父类与子类都有静态代码块和构造函数的时候，执行顺序如下：

父类静态代码块 > 子类静态代码块

父类构造函数 > 子类构造函数（先有父亲，后有孩子）

如果是多级继承关系的话，最高层的父类首先执行，然后依次递减

总结：静态优先执行，父类优先执行

注意：静态代码块是在JVM加载类的时候执行的，而且静态代码块执行且仅执行一次

在调用类中的方法时，在方法体执行之前，首先要对类中的成员变量进行赋值，如果代码中没有赋具体的值，也有默认值。成员变量的赋值顺序按照前后顺序进行。

如果有既有直接赋值，也有构造方法赋值，那么根据先后顺序执行

重写（Override）重载（Overload)

重载是方法名字，返回类型一致，唯一不同的是方法的参数不同（参数类型不同，或者参数类型不同）

重写：

1. 发生方法重写的两个方法返回值，方法名，参数列表必须完全一致

2. 子类抛出的异常不能超过父类相应的方法抛出的异常

3. 子类方法的访问级别不能低于父类相应方法的访问级别（public，package，protected，

private）

多态：父类的引用指向了子类的对象，调用时执行的方法也是子类的方法，父类的方法并不会被执行

所谓多态就是父类或者接口类型的引用可以指向子类或者实现该接口的类的实例（对象）

看了上面的说明，大家也应该知道上面的程序输出结果了。

输出结果为：1a2b2b

18、写一个java方法，功能是可以将一个字符串反转，例如“abcde”执行后得到“edcba”

public class Test{

public static void main(String[] args){

String s1 = "abc";

System.out.print("翻转后：");

for(int i=s1.length()-1;i>=0;i--){

System.out.print(s1.charAt(i));

}

19、写一个简单的单例类（Singleton）。

1、饿汉式

public class A(){

private static final A a=new A();

//私有构造方法

private A(){

}

//静态工厂方法

public A getInstance(){

return a;

}

2、懒汉式

public class A {

private static A a;

private A() {}

public static A getInstance() {

if(a == null)

a = new A();

return a;

}

数据库

20、查询公司的所有员工及所属部门信息，并按人员姓名拼音首字母排序。请用sql实

现。

Select e.id,https://www.doczj.com/doc/bd16950777.html,,d.deptname from Employee e left join Dept d on e.deptid=d.deptid order by nlssort(https://www.doczj.com/doc/bd16950777.html, , 'NLS_SORT=SCHINESE_PINYIN_M');

21、delete from table a和truncate table table a 的区别

TRUNCATE和DELETE有以下几点区别

1、TRUNCATE在各种表上无论是大的还是小的都非常快。如果有ROLLBACK 命令DELETE将被撤销，而TRUNCATE则不会被撤销。

2、TRUNCATE是一个DDL语言，向其他所有的DDL语言一样，他将被隐式提交，不能对TRUNCATE使用ROLLBACK命令。

3、TRUNCATE将重新设置高水平线和所有的索引。在对整个表和索引进行完全浏览时，经过TRUNCATE操作后的表比DELETE操作后的表要快得多。

4、TRUNCATE不能触发任何DELETE触发器。

5、不能授予任何人清空他人的表的权限。

6、当表被清空后表和表的索引讲重新设置成初始大小，而delete则不能。

7、不能清空父表。

22、浏览器请求有哪几种

浏览器的请求方式

浏览器的请求方式有很多，最典型的就是get和post方式，但你是否知道其实还有几种方式，只是我们不经常用！options,head,put,delete,trace,至于为什么现在不经常用这些方式，我想是因为get和post就可以满足我们大多数的需求吧！