浪潮面试

时间 2019-11-25

标签浪潮面试栏目快乐工作繁體版

原文原文链接

自我介绍

java与C++的区别

对Java的理解

常见的设计模式有哪些

一、单例模式(Singleton): 保证一个类仅有一个实例,并提供一个访问它的全局控制点,好比在加载配置文件时, 可以使用该模式.java

二、工厂模式(Factory): 定义一个用以建立对象的接口, 让子类决定实例化哪一个类.web

三、装饰着模式(Decorator): 动态的给一个对象添加一些额外的职责.面试

　好比java.io包. BufferedInputStream封装了FileInputStream, 它们都实现了InputStream接口, 但前者实现了readLine方法.算法

四、代理模式(Proxy): 为其余对象提供一种代理以控制对这个对象的访问.spring

　好比在用户登陆时, 真正的登陆类和代理登陆类都实现了Login接口, 不一样的是Proxy类的方法中增长了用户是否合法的判断, 只有合法时才去调用真正登陆类的login方法. 用户访问的实际上是Proxy的login方法.数据库

五、观察者模式(Observer): 定义了一种一对多的依赖关系,让多个观察者对象同时监听某一主题对象,在它的状态发生变化时,会通知全部的观察者.编程

　好比ServletContextListener, 在applcation启动时, 会通知全部这个接口的实现类.设计模式

讲讲单例

单例模式三要点： 数组

（1）、单例类只能有一个实例浏览器

这是最基本的，真正作到整个系统中惟一并不容易，一般还要考虑反射破坏、序列化/反序列化、对象垃圾回收等问题。

（2）、单例类必须本身建立本身的惟一实例

一般给实例构造函数protected或private权限。

（3）、单例类必须给全部其余对象提供这一实例

一般定义静态方法getInstance()返回。

优势：

（1）、提供了对惟一实例的受控访问，避免对资源的多重占用。

（2）、在内存里只有一个实例，减小了内存的开销，尤为是频繁的建立和销毁实例。

（3）、缩小名空间，避免全局变量污染空间，但比类操做更灵活。

缺点：

（1）、因为单例模式中没有抽象层，所以单例类的扩展有很大的困难。

（2）、单例类的职责太重，在必定程度上违背了"单一职责原则"。

由于单例类既充当了工厂角色，提供了工厂方法，同时又充当了产品角色，包含一些业务方法，将产品的建立和产品的自己的功能融合到一块儿。因此也不该过多使用单例模式。

Spring的优势和缺点

优势

1.使用Spring的IOC容器，将对象之间的依赖关系交给Spring，下降组件之间的耦合性，让咱们更专一于应用逻辑

2.能够提供众多服务，事务管理，WS等。

3.AOP的很好支持，方便面向切面编程。

4.对主流的框架提供了很好的集成支持，如hibernate,Struts2,JPA等

5.Spring DI机制下降了业务对象替换的复杂性。

6.Spring属于低侵入，代码污染极低。

7.Spring的高度可开放性，并不强制依赖于Spring，开发者能够自由选择Spring部分或所有

缺点

1.jsp中要写不少代码、控制器过于灵活，缺乏一个公用控制器

2.Spring不支持分布式，这也是EJB仍然在用的缘由之一。

IOC是什么、还有依赖注入

TCP/IP有几层？那些？传输层有哪些协议？，http是基于什么协议的？

答：

（1）TCP/IP有4层；

（2）应用层、传输层、网络层、数据链路层；

（3）传输层有TCP和UDP协议

（4）HTTP协议基于TCP协议

由HTTP客户端发起一个请求，创建一个到服务器指定端口（默认是80端口）的TCP链接。

HTTP服务器则在那个端口监听客户端发送过来的请求。

一旦收到请求，服务器（向客户端）发回一个状态行和（响应的）消息，消息的消息体多是请求的文件、错误消息、或者其它一些信息。

HTTP使用TCP而不是UDP的缘由在于（打开）一个网页必须传送不少数据，而TCP协议提供传输控制，按顺序组织数据，和错误纠正。

简单介绍一下http协议和https协议，说一下他们的区别与联系

HTTPS和HTTP的区别：

https协议须要到ca申请证书，通常免费证书不多，须要交费。

http是超文本传输协议，信息是明文传输，https 则是具备安全性的ssl加密传输协议。

http和https使用的是彻底不一样的链接方式用的端口也不同,前者是80,后者是443。

http的链接很简单,是无状态的。

HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议要比http协议安全。

HTTPS解决的问题：

1、HTTP和HTTPS的基本概念

HTTP：是互联网上应用最为普遍的一种网络协议，是一个客户端和服务器端请求和应答的标准（TCP），用于从WWW服务器传输超文本到本地浏览器的传输协议，它能够使浏览器更加高效，使网络传输减小。

HTTPS：是以安全为目标的HTTP通道，简单讲是HTTP的安全版，即HTTP下加入SSL层，HTTPS的安全基础是SSL，所以加密的详细内容就须要SSL。

HTTPS协议的主要做用能够分为两种：一种是创建一个信息安全通道，来保证数据传输的安全；另外一种就是确认网站的真实性。

2、HTTP与HTTPS有什么区别？

HTTP协议传输的数据都是未加密的，也就是明文的，所以使用HTTP协议传输隐私信息很是不安全，为了保证这些隐私数据能加密传输，因而网景公司设计了SSL（Secure Sockets Layer）协议用于对HTTP协议传输的数据进行加密，从而就诞生了HTTPS。

简单来讲，HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，要比http协议安全。

HTTPS和HTTP的区别主要以下：

一、https协议须要到ca申请证书，通常免费证书较少，于是须要必定费用。

二、http是超文本传输协议，信息是明文传输，https则是具备安全性的ssl加密传输协议。

三、http和https使用的是彻底不一样的链接方式，用的端口也不同，前者是80，后者是443。

四、http的链接很简单，是无状态的；HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，比http协议安全。

3、HTTPS的工做原理

咱们都知道HTTPS可以加密信息，以避免敏感信息被第三方获取，因此不少银行网站或电子邮箱等等安全级别较高的服务都会采用HTTPS协议。

一、客户端发起HTTPS请求

这个没什么好说的，就是用户在浏览器里输入一个https网址，而后链接到server的443端口。

二、服务端的配置

采用HTTPS协议的服务器必需要有一套数字证书，能够本身制做，也能够向组织申请，区别就是本身颁发的证书须要客户端验证经过，才能够继续访问，而使用受信任的公司申请的证书则不会弹出提示页面(startssl就是个不错的选择，有1年的免费服务)。

这套证书其实就是一对公钥和私钥，若是对公钥和私钥不太理解，能够想象成一把钥匙和一个锁头，只是全世界只有你一我的有这把钥匙，你能够把锁头给别人，别人能够用这个锁把重要的东西锁起来，而后发给你，由于只有你一我的有这把钥匙，因此只有你才能看到被这把锁锁起来的东西。

三、传送证书

这个证书其实就是公钥，只是包含了不少信息，如证书的颁发机构，过时时间等等。

四、客户端解析证书

这部分工做是有客户端的TLS来完成的，首先会验证公钥是否有效，好比颁发机构，过时时间等等，若是发现异常，则会弹出一个警告框，提示证书存在问题。

若是证书没有问题，那么就生成一个随机值，而后用证书对该随机值进行加密，就好像上面说的，把随机值用锁头锁起来，这样除非有钥匙，否则看不到被锁住的内容。

五、传送加密信息

这部分传送的是用证书加密后的随机值，目的就是让服务端获得这个随机值，之后客户端和服务端的通讯就能够经过这个随机值来进行加密解密了。

六、服务段解密信息

服务端用私钥解密后，获得了客户端传过来的随机值(私钥)，而后把内容经过该值进行对称加密，所谓对称加密就是，将信息和私钥经过某种算法混合在一块儿，这样除非知道私钥，否则没法获取内容，而正好客户端和服务端都知道这个私钥，因此只要加密算法够彪悍，私钥够复杂，数据就够安全。

七、传输加密后的信息

这部分信息是服务段用私钥加密后的信息，能够在客户端被还原。

八、客户端解密信息

客户端用以前生成的私钥解密服务段传过来的信息，因而获取了解密后的内容，整个过程第三方即便监听到了数据，也一筹莫展。

6、HTTPS的优势

正是因为HTTPS很是的安全，攻击者没法从中找到下手的地方，从站长的角度来讲，HTTPS的优势有如下2点：

一、SEO方面

谷歌曾在2014年8月份调整搜索引擎算法，并称“比起同等HTTP网站，采用HTTPS加密的网站在搜索结果中的排名将会更高”。

二、安全性

尽管HTTPS并不是绝对安全，掌握根证书的机构、掌握加密算法的组织一样能够进行中间人形式的攻击，但HTTPS还是现行架构下最安全的解决方案，主要有如下几个好处：

（1）、使用HTTPS协议可认证用户和服务器，确保数据发送到正确的客户机和服务器；

（2）、HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，要比http协议安全，可防止数据在传输过程当中不被窃取、改变，确保数据的完整性。

（3）、HTTPS是现行架构下最安全的解决方案，虽然不是绝对安全，但它大幅增长了中间人攻击的成本。

7、HTTPS的缺点

虽说HTTPS有很大的优点，但其相对来讲，仍是有些不足之处的，具体来讲，有如下2点：

一、SEO方面

据ACM CoNEXT数据显示，使用HTTPS协议会使页面的加载时间延长近50%，增长10%到20%的耗电，此外，HTTPS协议还会影响缓存，增长数据开销和功耗，甚至已有安全措施也会受到影响也会所以而受到影响。

并且HTTPS协议的加密范围也比较有限，在黑客攻击、拒绝服务攻击、服务器劫持等方面几乎起不到什么做用。

最关键的，SSL证书的信用链体系并不安全，特别是在某些国家能够控制CA根证书的状况下，中间人攻击同样可行。

二、经济方面

（1）、SSL证书须要钱，功能越强大的证书费用越高，我的网站、小网站没有必要通常不会用。

（2）、SSL证书一般须要绑定IP，不能在同一IP上绑定多个域名，IPv4资源不可能支撑这个消耗（SSL有扩展能够部分解决这个问题，可是比较麻烦，并且要求浏览器、操做系统支持，Windows XP就不支持这个扩展，考虑到XP的装机量，这个特性几乎没用）。

（3）、HTTPS链接缓存不如HTTP高效，大流量网站如非必要也不会采用，流量成本过高。

（4）、HTTPS链接服务器端资源占用高不少，支持访客稍多的网站须要投入更大的成本，若是所有采用HTTPS，基于大部分计算资源闲置的假设的VPS的平均成本会上去。

（5）、HTTPS协议握手阶段比较费时，对网站的相应速度有负面影响，如非必要，没有理由牺牲用户体验。

cookies和session的区别？

（1）Cookie的原理是经过Set-Cookie响应头和Cookie请求头将会话中产生的数据保存在客户端
Set-Cookie
Cookie

客户端请求服务器, 服务器将须要保存的数据经过Set-Cookie响应头发给客户端, 客户端收到后会将数据保存在浏览器的内部

当客户端再次请求服务器时, 经过Cookie请求头将上次保存的数据再带给服务器, 服务器经过Cookie头来获取数据, 经过这种方式能够保存会话中产生的数据.

Cookie是将须要保存的数据保存在了客户端, 是客户端技术. 每一个客户端各自保存各自的数据, 再次访问服务器时会带着本身的数据, 每一个客户端持有本身的数据, 所以就不会发生混

了
（2）Session是将会话中产生的数据保存在了服务器端, 是服务器端技术

Session是一个域对象
           setAttribute(String name, Object value);
           getAttribute(String name);
           removeAttribute(String name)
           getAttributeNames()

生命周期:
               当第一次调用request.getSession()方法时建立Session

               超时: 若是一个Session超时30分钟(能够在web.xml中来修改, 在根目录下经过<session-config>来配置)未被使用, 则认为Session超时, 销毁session

               自杀: 当调用session.invalidate()方法的时session当即销毁!!

               意外身亡: 当服务器非正常关闭时, 随着应用的销毁, session销毁. 当服务器正常关闭, 则未超时的session将会以文件的形式保存在tomcat服务器work目录下, 这个过程叫作

session的钝化. 当服务器再次启动时, 钝化着的session还能够恢复过来, 这个过程叫作session的活化。

做用范围: 当前会话范围

主要功能: 保存当前会话相关的数据

Session是基于一个JSESSIOINID的Cookie工做的

（3）Cookie和Session的比较:

Cookie是将会话中产生的数据保存在客户端, 是客户端的技术

Session是将会话中产生的数据保存在服务器端, 是服务器端的技术

Cookie保存的信息的时间比较长, 可是安全性不高. 可能随着用户的操做, Cookie会被清空, 因此Cookie存储数据的稳定性比较差. 所以Cookie适合存放要保存时间较长, 但安全性要求

不高的信息

Session一般保存信息的时间比较有限, 但安全性比较高, 由于是保存在服务器端, 不会随着用户的操做而致使Session意外丢失, 所以session适合存放安全性要求比较高, 可是不须要

长时间保存的数据.

session是怎么作区分的？

springMVC工做机制

一、客户端发出一个http请求给web服务器，web服务器对http请求进行解析，若是匹配DispatcherServlet的请求映射路径（在web.xml中指定），web容器将请求转交给DispatcherServlet.

二、DipatcherServlet接收到这个请求以后将根据请求的信息（包括URL、Http方法、请求报文头和请求参数Cookie等）以及HandlerMapping的配置找处处理请求的处理器（Handler）。

3-四、DispatcherServlet根据HandlerMapping找到对应的Handler,将处理权交给Handler（Handler将具体的处理进行封装），再由具体的HandlerAdapter对Handler进行具体的调用。

五、Handler对数据处理完成之后将返回一个ModelAndView()对象给DispatcherServlet。

六、Handler返回的ModelAndView()只是一个逻辑视图并非一个正式的视图，DispatcherSevlet经过ViewResolver将逻辑视图转化为真正的视图View。

七、Dispatcher经过model解析出ModelAndView()中的参数进行解析最终展示出完整的view并返回给客户端。

dubbo分布式工做原理，如何提供与消费服务

简单举例介绍一下Java面向对象的三个特征

1.封装

Java中的封装是指一个类把本身内部的实现细节进行隐藏，只暴露对外的接口（setter和getter方法）。封装又分为属性的封装和方法的封装。把属性定义为私有的，它们经过setter和getter方法来对属性的值进行设定和获取。下面我举一个简单的封装例子

 public class Person {
        private int id;
        private String name;
        private Person person;
     
        public int getId() {
            return id;
        }
     
        public String getName() {
            return name;
        }
     
        public Person getPerson() {
            return person;
        }
     
        public void setId(int id) {
            this.id = id;
        }
     
        public void setName(String name) {
            this.name = name;
        }
     
        public void setPerson(Person person) {
            this.person = person;
        }
    }

在Person类中，定义了三个成员变量，分别为id name person，它们的访问修饰都是private私有的，经过setter和getter方法对这些变量进行设值以及取值。那么这么作有什么好处呢？封装的意义就是加强类的信息隐藏与模块化，提升安全性。封装的主要做用也是对外部隐藏具体的实现细节，增长程序的安全性。
2.继承

Java中的继承是指在一个现有类（父类）的基础上在构建一个新类（子类），子类能够拥有父类的成员变量以及成员方法（可是不必定能访问或调用，例如父类中private私有的成员变量以及方法不能访问和调用）。继承的做用就是能提升代码的复用性。子类拥有父类中的一切（拥有不必定能使用），它能够访问和使用父类中的非私有成员变量，以及重写父类中的非私有成员方法。

父类：

    package cn.csu.ksh;
     
    public class Person {
        private int a=1;//父类私有成员变量
        private int id;
        private String name;
        private int age;
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        @Override
        public String toString() {
            return "Person [id=" + id + ", name=" + name + ", age=" + age + "]";
        }
        public void say() {
            System.out.println("person say..");
        }
        public void run() {
            System.out.println("person run....");
        }
        //父类的私有方法
        private void show() {
            System.out.println("person show...");
        }
    }

子类：

  public class Student extends Person {  
          
        @Override  
        public void say() {  
            super.say();  
        }  
        @Override  
        public void run() {  
            super.run();  
        }  
        public static void main(String[] args) {  
            Student stu = new Student();  
            //stu.a=1;//子类对象对父类的私有成员变量使用报错！  
            //stu.show();//子类对象调用父类的私有方法，一样报错！  
            stu.say();  
            stu.run();                 
        }  
    }

继承的好处是实现代码的复用以及扩展，子类经过对父类代码的复用，能够不用再定义父类中已经定义的成员变量，方法上直接对父类的方法进行重写实现了扩展。
3.多态

多态就是指多种状态，就是说当一个操做在不一样的对象时，会产生不一样的结果。

在Java中，实现多态的方式有两种，一种是编译时的多态，另一种是运行时多态，编译时的多态是经过方法的重载实现的，而运行时多态是经过方法的重写实现的。

方法的重载是指在同一个类中，有多个方法名相同的方法，可是这些方法有着不一样的参数列表，在编译期咱们就能够肯定到底调用哪一个方法。

方法的重写，子类重写父类中的方法（包括接口的实现），父类的引用不只能够指向父类的对象，并且还能够指向子类的对象。当父类的引用指向子类的引用时，只有在运行时才能

肯定调用哪一个方法。

其实在运行时的多态的实现，须要知足三个条件：1.继承（包括接口的实现）2.方法的重写 3.父类的引用指向子类对象

而且，咱们说的多态都是类中方法的多态，属性是没有多态性的。方法的重载我这里就不举例说明了，我说一下运行时的多态。

简单介绍一下List、Map

一，Conllection:

Collection接口：

他有两个子接口，Set和List,

1,Set（公共特色;无序）

是一个无序的集合接口，而且元素不可重复，固然，这里的无序是针对放入顺序而言，并非绝对的无序，他有两个子类，一个是hashSet,还有一个是继承了SortedSet接口的

TreeSet,这两个set集合有什么特色呢？

首先，hashSet的底层是hashmap,他有着hashmap中键的特性，那就是，无序，不可重复性，

其次，treeset实现了sortset接口，sortedset有排序能力，也就意味着treeset也有着排序的能力，他是使用二叉树进行排序的。

2，list（有序）：

list接口也有两个子类，一个是arraylist,一个是linkedList,

首先arralist的底层是object[]是一个数组，也就意味着他有着数组的特性，可是和数组相比他比数组灵活，无需设置长度，他是有序的，因此查找块，增删比较慢，

和arralist其实有一个兄弟叫vector，他和arralist是同样的

Vector是线程安全的，也就是说是它的方法之间是线程同步的,而arralist线程是异步的也就是说他是不安全的，可是效率高，相比之下，建议使用arralist.，

linkedlist:

他底层是以链表的形式进行排序的，两个元素之间就如同链子同样前关联，若是进行增删操做的时候，只须要将某个元素替换而后将后边的关联简单修改就能够完成，因此说建议查

询用arralist,增删用linkedlist;

二，map（公共特色特色：以键值对的形式存储，）:

简单来说经常使用的map类的集合也有三个，经常使用的有三个子类实现了mapj接口：map存在的意义就是为了快速查找，经过键的直接找到值，由于键是不可重复的。

1，hashMap和hashtable：

二者放在一块儿比较（底层都是hash表结构）：hashmap线程是不安全的容许键值对为null，二hashtable线程是安全的不容许键值对为null，二者的其余属性是同样的，因此二者的使

用要看具体的状况而定，

2，treemap(底层是二叉树)

线程不一样步，可用于给Map集合中的键进行排序

虽说有些集合是无序的，可是子类个别的也是按照另外一种方式进行了排序，只不过不符合咱们平常的排序方式。是按照某种规则进行的。

总结：三者的存在关系：

Map中元素，能够将key序列、value序列单独抽取出来。
使用keySet()抽取key序列，将map中的全部keys生成一个Set。
使用values()抽取value序列，将map中的全部values生成一个Collection。

为何一个生成Set，一个生成Collection？那是由于，key老是独一无二的，value容许重复

何时进行异常处理？何时捕获何时抛出？

捕获异常：

一般在运行以前java不报错，可是运行后可能会出现某些未知的错误，可是还不想直接抛出到上一级，

那么就须要经过”try{}catch“的形式进行异常捕获，以后根据不一样的异常状况来进行相应的处理。

传递异常：

一般用在多级方法调用上，最终想将异常返回到最上层进行处理的时候，那么就把异常向上抛出，知道调用的方法处，进行异常捕获。

异常抛出：

运行时异常会被Java虚拟机自动抛出！

提前抛出：

有些比较明确的异常须要提早抛出，这样咱们能够经过控制台打印的异常信息快速定位到出错的代码块，同时也能够避免没必要要的对象构造或者资源调用。

以下分别在调用两个方法的时候fileName参数都传递为null，显然采用代码二的方式更有利排查错误。

延迟捕获：让异常捕获处理放在最外层进行处理，这样才能根据不一样的状况进行不一样的处理。

异常分类

Throwable是全部异常的根，java.lang.Throwable

Error:错误，Java.lang.Error

Exception：异常，java.lang.Exception

运行时异常：

都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中能够选择捕获处理，也能够不处理。这些异常通常是由程序逻辑错误引发的，程序应该从逻辑角度尽量避免这类异常的发生。

运行时异常的特色是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即便没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译经过。

非运行时异常（编译异常）：

是RuntimeException之外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，若是不处理，程序就不能编译经过。

如IOException、SQLException等以及用户自定义的Exception异常，通常状况下不自定义检查异常。

ClassCastException(类转换异常)

IndexOutOfBoundsException(数组越界异常)

NullPointerException(空指针异常)

ArrayStoreException(数据存储异常，操做数组时类型不一致)

BufferOverflowException(还有IO操做的,缓冲溢出异常)

简单介绍一下JVM及JVM的堆栈实现

1.前言。

其实jvm能优化的空间很少，最主要的是使用的共享内存不要超过默认的2g或者本身调的参数。但了解一下仍是有点意思的，建议面试时仍是要看，别学笔者裸奔。

2.区别。

网上说是有5点区别。但笔者认为只有两点主要区别。

堆--用new创建，垃圾自动回收负责回收

一、堆是一个"运行时"数据区，类实例化的对象就是从堆上去分配空间的；

二、在堆上分配空间是经过"new"等指令创建的；

三、Java针对堆的操做和C++的区别就是，Java不须要在空间不用的时候来显式的释放；

四、Java的堆是由Java的垃圾回收机制来负责处理的，堆是动态分配内存大小，垃圾收集器能够自动回收再也不使用的内存空间。

五、但缺点是，由于在运行时动态分配内存，因此内存的存取速度较慢。

一、栈中主要存放一些基本类型的变量（int, short, long, byte, float, double, boolean, char）和对象句柄；

二、栈的存取速度比堆要快；

三、栈数据能够共享；

四、栈的数据大小与生存期必须是肯定的，缺少灵活性。

笔者认为就两点：
(1)堆主要放new的对象,而栈放基本类型和句柄，句柄指向的是堆。
(2)垃圾回收的时候回收的是堆，栈比较难回收，通常不回收（这个才是问你的缘由，呵呵)。

3.总结。

就速度而言，都是内存操做，其实并无很大区别。

举例简单介绍一下单例模式

https://blog.csdn.net/album_gyd/article/details/81369154

简单介绍一下你之前作过的项目，简单介绍一下负载均衡

举例介绍一下Java的面向对象，别说概念，举个例子谈谈

类是面向对象中的一个很重要的概念，由于类是不少个具备相同属性和行为特征的对象所抽象出来的，对象是类的一个实例。

而后，围绕类的三个特征来讲了：封装、继承和多态。

一、封装：面向对象语言的精髓

把一些属性和方法封装起来，造成一个类；

类的属性通常私有；

类的方法：该公开的公开，该私有的私有；方法，封装了实现的过程，接口是参数和返回值；

举例：

　　1）get/set 方法；对某一个属性只提供get不提供set方法，就是只读的，在类的外部不能修改；

　　2）提供统一的参数检查，在set上给与检查，判断合法性和安全性；将属性都私有，而且提供set/get 方法，作成了通用的组件，叫JavaBean;

２. 继承：面向对象的主要功能

继承是一种构建新类的方式，他是基于已有的类的定义为基础，构建新的类，已有的类称为父类，新构建的类称为子类，子类能调用父类的非private修饰的成员，

同时还能够本身添加一些新的成员，扩充父类，甚至重写父类已有的方法，更其表现符合子类的特征。让子类的表现更独特，更专业。

３．多态

从必定角度来看，封装和继承几乎都是为多态而准备的。这是咱们最后一个概念，也是最重要的知识点。

多态是同一个行为具备多个不一样表现形式或形态的能力。多态性是对象多种表现形式的体现

类中多个方法的重载叫多态，父子类中方法的覆盖也叫多态。

所以多态有两种体现：一个是方法的重装，一个是方法的覆盖。

多态有方法的多态和对象的多态（一个对象多种形态）。

简单介绍一下session和cookie，他们的生命周期是什么？Cookie是否能够跨浏览器

1、cookie机制和session机制的区别

具体来讲cookie机制采用的是在客户端保持状态的方案，而session机制采用的是在服务器端保持状态的方案。

同时咱们也看到，因为才服务器端保持状态的方案在客户端也须要保存一个标识，因此session

机制可能须要借助于cookie机制来达到保存标识的目的，但实际上还有其余选择

2、会话cookie和持久cookie的区别

若是不设置过时时间，则表示这个cookie生命周期为浏览器会话期间，只要关闭浏览器窗口，cookie就消失了。这种生命期为浏览会话期的cookie被称为会话cookie。

会话cookie通常不保存在硬盘上而是保存在内存里。

　　若是设置了过时时间，浏览器就会把cookie保存到硬盘上，关闭后再次打开浏览器，这些cookie依然有效直到超过设定的过时时间。

　　存储在硬盘上的cookie能够在不一样的浏览器进程间共享，好比两个IE窗口。而对于保存在内存的cookie，不一样的浏览器有不一样的处理方式。

3、如何利用实现自动登陆

当用户在某个网站注册后，就会收到一个唯一用户ID的cookie。客户后来从新链接时，

这个用户ID会自动返回，服务器对它进行检查，肯定它是否为注册用户且选择了自动登陆，从而使用户务需给出明确的用户名和密码，就能够访问服务器上的资源。

4、如何根据用户的爱好定制站点

网站能够使用cookie记录用户的意愿。对于简单的设置，网站能够直接将页面的设置存储在cookie中完成定制。然而对于更复杂的定制，网站只需仅将一个唯一的标识符发送给用户，由服务器端的数据库存储每一个标识符对应的页面设置。

5、cookie的发送

1.建立Cookie对象

2.设置最大时效

3.将Cookie放入到HTTP响应报头

若是你建立了一个cookie，并将他发送到浏览器，默认状况下它是一个会话级别的cookie:存储在浏览器的内存中，用户退出浏览器以后被删除。若是你但愿浏览器将该cookie存储在磁盘上，则

须要使用maxAge，并给出一个以秒为单位的时间。将最大时效设为0则是命令浏览器删除该cookie。

发送cookie须要使用HttpServletResponse的addCookie方法，将cookie插入到一个Set-Cookie　HTTP请求报头中。因为这个方法并不修改任何以前指定的Set-Cookie报头，而是建立新的报头，所以咱们将这个方法称为是addCookie，而非setCookie。一样要记住响应报头必须在任何文档内容发送到客户端以前设置。

6、cookie的读取

1.调用request.getCookie

要获取有浏览器发送来的cookie，须要调用HttpServletRequest的getCookies方法，这个调用返回Cookie对象的数组，对应由HTTP请求中Cookie报头输入的值。

2.对数组进行循环，调用每一个cookie的getName方法，直到找到感兴趣的cookie为止

　cookie与你的主机(域)相关，而非你的servlet或JSP页面。于是，尽管你的servlet可能只发送了单个cookie，你也可能会获得许多不相关的cookie。

例如：　

String cookieName = “userID”;

     Cookie cookies[] = request.getCookies();

     if (cookies!=null){

         for(int i=0;i<cookies.length;i++){

         Cookie cookie = cookies[i];

         if (cookieName.equals(cookie.getName())){

             doSomethingWith(cookie.getValue());

         }
    }
}

7、如何使用cookie检测初访者

A.调用HttpServletRequest.getCookies()获取Cookie数组

B.在循环中检索指定名字的cookie是否存在以及对应的值是否正确

C.若是是则退出循环并设置区别标识

D.根据区别标识判断用户是否为初访者从而进行不一样的操做

8、使用cookie检测初访者的常见错误

不能仅仅由于cookie数组中不存在在特定的数据项就认为用户是个初访者。若是cookie数组为null，客户多是一个初访者，也多是因为用户将cookie删除或禁用形成的结果。

可是，若是数组非null,也不过是显示客户曾经到过你的网站或域，并不能说明他们曾经访问过你的servlet。其它servlet、JSP页面以及非Java Web应用均可以设置cookie，依据路径的设置，其中的任何cookie都有可能返回给用户的浏览器。

正确的作法是判断cookie数组是否为空且是否存在指定的Cookie对象且值正确。

9、使用cookie属性的注意问题

　　属性是从服务器发送到浏览器的报头的一部分；但它们不属于由浏览器返回给服务器的报头。　

　　所以除了名称和值以外，cookie属性只适用于从服务器输出到客户端的cookie；服务器端来自于浏览器的cookie并无设置这些属性。　

　　于是不要指望经过request.getCookies获得的cookie中能够使用这个属性。这意味着，你不能仅仅经过设置cookie的最大时效，发出它，在随后的输入数组中查找适当的cookie,读取它的值，修改它并将它存回Cookie，从而实现不断改变的cookie值。

10、如何使用cookie记录各个用户的访问计数

1.获取cookie数组中专门用于统计用户访问次数的cookie的值

2.将值转换成int型

3.将值加1并用原来的名称从新建立一个Cookie对象

4.从新设置最大时效

5.将新的cookie输出

11、session在不一样环境下的不一样含义

session，中文常常翻译为会话，其原本的含义是指善始善终的一系列动做/消息，好比打电话是从拿起电话拨号到挂断电话这中间的一系列过程能够称之为一个session。

然而当session一词与网络协议相关联时，它又每每隐含了“面向链接”和/或“保持状态”这样两个含义。

　　session在Web开发环境下的语义又有了新的扩展，它的含义是指一类用来在客户端与服务器端之间保持状态的解决方案。有时候Session也用来指这种解决方案的存储结构。

12、session的机制

　　session机制是一种服务器端的机制，服务器使用一种相似于散列表的结构(也可能就是使用散列表)来保存信息。

但程序须要为某个客户端的请求建立一个session的时候，服务器首先检查这个客户端的请求里是否包含了一个session标识－称为session id,若是已经包含一个session id则说明之前已经为此客户建立过session，服务器就按照session id把这个session检索出来使用(若是检索不到，可能会新建一个，这种状况可能出如今服务端已经删除了该用户对应的session对象，但用户人为地在请求的URL后面附加上一个JSESSION的参数)。

若是客户请求不包含session id，则为此客户建立一个session而且生成一个与此session相关联的session id，这个session id将在本次响应中返回给客户端保存。

十3、保存session id的几种方式

A．保存session id的方式能够采用cookie，这样在交互过程当中浏览器能够自动的按照规则把这个标识发送给服务器。

B．因为cookie能够被人为的禁止，必须有其它的机制以便在cookie被禁止时仍然可以把session id传递回服务器，常常采用的一种技术叫作URL重写，就是把session id附加在URL路径的后面，附加的方式也有两种，一种是做为URL路径的附加信息，另外一种是做为查询字符串附加在URL后面。网络在整个交互过程当中始终保持状态，就必须在每一个客户端可能请求的路径后面都包含这个session id。

C．另外一种技术叫作表单隐藏字段。就是服务器会自动修改表单，添加一个隐藏字段，以便在表单提交时可以把session id传递回服务器。

十4、session何时被建立

一个常见的错误是觉得session在有客户端访问时就被建立，然而事实是直到某server端程序(如Servlet)调用HttpServletRequest.getSession(true)这样的语句时才会被建立。

十5、session什么时候被删除

session在下列状况下被删除：

A．程序调用HttpSession.invalidate()

B．距离上一次收到客户端发送的session id时间间隔超过了session的最大有效时间

C．服务器进程被中止

再次注意关闭浏览器只会使存储在客户端浏览器内存中的session cookie失效，不会使服务器端的session对象失效。

十6、URL重写有什么缺点

　　　对全部的URL使用URL重写，包括超连接，form的action，和重定向的URL。每一个引用你的站点的URL，以及那些返回给用户的URL(即便经过间接手段，好比服务器重定向中的Location字段)都要添加额外的信息。

　　　这意味着在你的站点上不能有任何静态的HTML页面(至少静态页面中不能有任何连接到站点动态页面的连接)。所以，每一个页面都必须使用servlet或JSP动态生成。即便全部的页面都动态生成，若是用户离开了会话并经过书签或连接再次回来，会话的信息都会丢失，由于存储下来的连接含有错误的标识信息－该URL后面的SESSION ID已通过期了。　　

十7、使用隐藏的表单域有什么缺点

仅当每一个页面都是有表单提交而动态生成时，才能使用这种方法。单击常规的<A HREF..>超文本连接并不产生表单提交，所以隐藏的表单域不能支持一般的会话跟踪，只能用于一系列特定的操做中，好比在线商店的结帐过程

十8、会话跟踪的基本步骤

1．访问与当前请求相关的会话对象

2．查找与会话相关的信息

3．存储会话信息

4．废弃会话数据

十9、getSession()/getSession(true)、getSession(false)的区别

getSession()/getSession(true)：当session存在时返回该session，不然新建一个session并返回该对象

getSession(false)：当session存在时返回该session，不然不会新建session，返回null

二10、如何将信息于会话关联起来

　　setAttribute会替换任何以前设定的值；若是想要在不提供任何代替的状况下移除某个值，则应使用removeAttribute。这个方法会触发全部实现了HttpSessionBindingListener接口的值的valueUnbound

方法。

二11、会话属性的类型有什么限制吗

一般会话属性的类型只要是Object就能够了。除了null或基本类型，如int,double,boolean。

若是要使用基本类型的值做为属性，必须将其转换为相应的封装类对象

二12、如何废弃会话数据

A．只移除本身编写的servlet建立的数据：

调用removeAttribute(“key”)将指定键关联的值废弃

B．删除整个会话(在当前Web应用中)：

调用invalidate，将整个会话废弃掉。这样作会丢失该用户的全部会话数据，而非仅仅由咱们

servlet或JSP页面建立的会话数据

C．将用户从系统中注销并删除全部属于他(或她)的会话

调用logOut，将客户从Web服务器中注销，同时废弃全部与该用户相关联的会话(每一个Web应用至多一个)。这个操做有可能影响到服务器上多个不一样的Web应用

二十3、使用isNew来判断用户是否为新旧用户的错误作法

public boolean isNew()方法若是会话还没有和客户程序(浏览器)发生任何联系，则这个方法返回true，这通常是由于会话是新建的，不是由输入的客户请求所引发的。

但若是isNew返回false，只不过是说明他以前曾经访问该Web应用，并不表明他们曾访问过咱们的servlet或JSP页面。

由于session是与用户相关的，在用户以前访问的每个页面都有可能建立了会话。所以isNew为false只能说用户以前访问过该Web应用，session能够是当前页面建立，也多是由用户以前访问过的页面建立的。

正确的作法是判断某个session中是否存在某个特定的key且其value是否正确

二十4、Cookie的过时和Session的超时有什么区别

会话的超时由服务器来维护，它不一样于Cookie的失效日期。首先，会话通常基于驻留内存的cookie

不是持续性的cookie，于是也就没有截至日期。即便截取到JSESSIONID cookie，并为它设定一个失效日期发送出去。浏览器会话和服务器会话也会大相径庭。

二十5、session cookie和session对象的生命周期是同样的吗

当用户关闭了浏览器虽然session cookie已经消失，但session对象仍然保存在服务器端

二十6、是否只要关闭浏览器，session就消失了

程序通常都是在用户作log off的时候发个指令去删除session，然而浏览器历来不会主动在关闭以前通知服务器它将要被关闭，所以服务器根本不会有机会知道浏览器已经关闭。服务器会一直保留这个会话对象直到它处于非活动状态超过设定的间隔为止。

之因此会有这种错误的认识，是由于大部分session机制都使用会话cookie来保存session id，而关闭浏览器后这个session id就消失了，再次链接到服务器时也就没法找到原来的session。

若是服务器设置的cookie被保存到硬盘上，或者使用某种手段改写浏览器发出的HTTP请求报头，把原来的session id发送到服务器，则再次打开浏览器仍然可以找到原来的session。

偏偏是因为关闭浏览器不会致使session被删除，迫使服务器为session设置了一个失效时间，当距离客户上一次使用session的时间超过了这个失效时间时，服务器就能够认为客户端已经中止了活动，才会把session删除以节省存储空间。

　　由此咱们能够得出以下结论：

　　关闭浏览器，只会是浏览器端内存里的session cookie消失，但不会使保存在服务器端的session对象消失，一样也不会使已经保存到硬盘上的持久化cookie消失。

二十7、打开两个浏览器窗口访问应用程序会使用同一个session仍是不一样的session

一般session cookie是不能跨窗口使用的，当你新开了一个浏览器窗口进入相同页面时，系统会赋予你一个新的session id，这样咱们信息共享的目的就达不到了。

此时咱们能够先把session id保存在persistent cookie中(经过设置session的最大有效时间)，而后在新窗口中读出来，就能够获得上一个窗口的session id了，这样经过session cookie和persistent cookie的结合咱们就能够实现了跨窗口的会话跟踪。

二十8、如何使用会话显示每一个客户的访问次数

因为客户的访问次数是一个整型的变量，但session的属性类型中不能使用int，double，boolean等基本类型的变量，因此咱们要用到这些基本类型的封装类型对象做为session对象中属性的值

　　但像Integer是一种不可修改(Immutable)的数据结构：构建后就不能更改。这意味着每一个请求都必须建立新的Integer对象，以后使用setAttribute来代替以前存在的老的属性的值。例如：

HttpSession session = request.getSession();

SomeImmutalbeClass value = (SomeImmutableClass)session.getAttribute(“SomeIdentifier”);

if (value= =null){

     value = new SomeImmutableClass(…);　// 新建立一个不可更改对象

}else{

     value = new SomeImmutableClass(calculatedFrom(value)); // 对value从新计算后建立新的对象

}

session.setAttribute(“someIdentifier”,value); // 使用新建立的对象覆盖原来的老的对象

二十9、如何使用会话累计用户的数据

使用可变的数据结构，好比数组、List、Map或含有可写字段的应用程序专有的数据结构。经过这种方式，除非首次分配对象，不然不须要调用setAttribute。例如

HttpSession session = request.getSession();

SomeMutableClass value = (SomeMutableClass)session.getAttribute(“someIdentifier”);

if(value = = null){

     value = new SomeMutableClass(…);

     session.setAttribute(“someIdentifier”,value);

}else{

     value.updateInternalAttribute(…);      // 若是已经存在该对象则更新其属性而不需从新设置属性

}

三10、不可更改对象和可更改对象在会话数据更新时的不一样处理

不可更改对象由于一旦建立以后就不能更改，因此每次要修改会话中属性的值的时候，都须要

调用setAttribute(“someIdentifier”,newValue)来代替原有的属性的值，不然属性的值不会被更新

可更改对象由于其自身通常提供了修改自身属性的方法，因此每次要修改会话中属性的值的时

候，只要调用该可更改对象的相关修改自身属性的方法就能够了。这意味着咱们就不须要调

用setAttribute方法了

面试过程：

考官说要不先作一下自我介绍吧，因为紧张而后把学校里自我简绍的磨练给忘了只是简短的作了姓名年龄毕业学校的回答，彻底忘了把特长兴趣爱好介绍了，回来后才发现本身脑子当时干吗了第二，考官问你对公司了解多少呢，必定要记得面试前下点功夫，而后若是实在不知道就实事求是就能够，考官通常都挺好的，他在你不知道状况下会简短的把公司概况说一下的，而后回问你对本身专业以及将来发现方向，三到五年的规划什么的，必定要面试前把规划计划好再就是你的简历问题，必定要实事求是，他们会从你简历里挑你很擅长的东西查看你的掌握状况以及真实度从而侧面看你人品还提了不少专业知识的问题最后会问你对薪资，以及本身对公司有什么要求呀，你还有什么问题呀之类，但问的必定不要问太多，一个两个表明性的就够了。