内部类和静态内部类的区别

　　内部类和静态内部类的区别
　　
　　内部类：
　　
　　1、内部类中的变量和方法不能声明为静态的。
　　
　　2、内部类实例化：B是A的内部类，实例化B：A.B b = new A().new B()。
　　
　　3、内部类可以引用外部类的静态或者非静态属性及方法。
　　
　　静态内部类：
　　
　　1、静态内部类属性和方法可以声明为静态的或者非静态的。
　　
　　2、实例化静态内部类：B是A的静态内部类，A.B b = new A.B()。
　　
　　3、静态内部类只能引用外部类的静态的属性及方法。
　　
　　inner classes——内部类
　　
　　static nested classes——静态嵌套类
　　
　　其实人家不叫静态内部类，只是叫习惯了，从字面就很容易理解了。
　　
　　内部类依靠外部类的存在为前提，而静态嵌套类则可以完全独立，明白了这点就很好理解了。
　　
　　非静态内部类中的变量和方法不能声明为静态的原因
　　
　　静态类型的属性和方法，在类加载的时候就会存在于内存中。使用某个类的静态属性和方法，那么这个类必须要加载到虚拟机中。但是非静态内部类并不随外部类一起加载，只有在实例化外部类之后才会加载。
　　
　　我们设想一个场景：在外部类并没有实例化，内部类还没有加载的时候如果调用内部类的静态成员或方法，内部类还没有加载，却试图在内存中创建该内部类的静态成员，就会产生冲突。所以非静态内部类不能有静态成员变量或静态方法。
　　
　　String，StringBuilder，StringBuffer的区别
　　
　　String 字符串常量
　　
　　StringBuffer 字符串变量（线程安全）
　　
　　StringBuilder 字符串变量（非线程安全）
　　
　　性能上通常StringBuilder > StringBuffer > String。
　　
　　String是不可变对象，每次对String类型进行改变的时候都等同于生成了一个新的String对象，然后将指针指向新的String对象，所以性能最差，对于要经常改变内容的字符串不用String。
　　
　　StringBuffer是字符串变量，对它操作时，并不会生成新的对象，而是直接对该对象进行更改，所以性能较好。
　　
　　StringBuilder和StringBuffer一样，是字符串变量，但是他不带有synchronized关键字，不保证线程安全，所以性能最好。在单线程的情况下，建议使用StringBuilder。
　　
　　总体来说：
　　
　　String：适用于少量的字符串操作的情况。
　　
　　StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况。
　　
　　StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况。
　　
　　来一些问题：
　　
　　下面这段代码的输出结果是什么？
　　
　　String a = "helloworld";
　　
　　String b = "hello" + "world";
　　
　　System.out.println((a == b));
　　
　　输出结果为：True。
　　
　　原因是String对字符串的直接相加，会在编译期进行优化。即hello+world在编译时期，被优化为helloworld，所以在运行时期，他们指向了同一个对象。我们也可以推理，对于直接字符串的相加，String不一定比其余两个慢。
　　
　　下面这段代码的输出结果是什么？
　　
　　String a = "helloworld";
　　
　　String b = "hello";
　　
　　String c = b + "world";
　　
　　System.out.println((a == c));
　　
　　输出结果为：False。
　　
　　原因是c并非两个字符串直接相加，包含了一个字符串引用，这时不会做编译期的优化。所以a、c最终生成了两个对象，这时他的效率低。
　　
　　集合和数组之间的相互转换
　　
　　数组变集合：
　　
　　通常我们会回答的是以下代码：
　　
　　List<String> list = Arrays.asList(array);
　　
　　但这并不是很好的答案，此时组合成的list是Arrays里面的一个静态内部类，该类并未实现add、remove方法，因此在使用时存在问题。
　　
　　可以这样：
　　
　　String array[]= {"hello","world","java","zhiyin"};
　　
　　List<String> list = new ArrayList<String>(Arrays.asList(array));
　　
　　集合变数组：
　　
　　String[] array=list.toArray(new String[list.size()]);
　　
　　面向对象的特征有哪些方面?
　　
　　抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。
　　
　　继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类；得到继承信息的类被称为子类。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段。
　　
　　封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口。
　　
　　多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。方法重载实现的是编译时的多态性，而方法重写实现的是运行时的多态性。
　　
　　概括的解释下线程的几种状态
　　
　　1.就绪(Runnable):线程准备运行，不一定立马就能开始执行。
　　
　　2.运行中(Running)：进程正在执行线程的代码。
　　
　　3.等待中(Waiting):线程处于阻塞的状态，等待外部的处理结束。
　　
　　4.睡眠中(Sleeping)：线程被强制睡眠。
　　
　　5.I/O阻塞(Blocked on I/O)：等待I/O操作完成。
　　
　　6.同步阻塞(Blocked on Synchronization)：等待获取锁。
　　
　　7.死亡(Dead)：线程完成了执行。
　　
　　Java集合类里面基本的接口有哪些
　　
　　1.Collection：代表一组对象，每一个对象都是它的子元素。
　　
　　2.Set：不包含重复元素的Collection。
　　
　　3.List：有顺序的collection，并且可以包含重复元素。
　　
　　4.Map：可以把键(key)映射到值(value)的对象，键不能重复。
　　
　　Iterator和ListIterator的区别
　　
　　Iterator可用来遍历Set和List集合，但是ListIterator只能用来遍历List。
　　
　　Iterator对集合只能是前向遍历，ListIterator既可以前向遍历也可以后向遍历。
　　
　　ListIterator实现了Iterator接口，并包含其他的功能，比如：增加、替换元素，获取前一个和后一个元素的索引等等。
　　
　　Enumeration和Iterator的区别
　　
　　java中的集合类都提供了返回Iterator的方法，就是迭代器，它和Enumeration（枚举）的主要区别其实就是Iterator可以删除元素，但是Enumration却不能。
　　
　　使用Iterator来遍历集合时，应使用Iterator的remove()方法来删除集合中的元素，使用集合的remove()方法将抛出ConcurrentModificationException异常。
　　
　　Enumeration接口的功能和Iterator接口的功能是重复的。此外，Iterator 接口添加了一个可选的移除操作，并使用较短的方法名。新的实现应该优先考虑使用Iterator接口而不是Enumeration接口。
　　
　　Enumeration速度是Iterator的2倍，同时占用更少的内存。但是，Iterator远远比Enumeration安全，因为其他线程不能够修改正在被iterator遍历的集合里面的对象。
　　
　　介绍一下HTTP的响应结构
　　
　　请求报文的组成：
　　
　　请求方法。
　　
　　请求的资源的URI。
　　
　　协议版本。
　　
　　可选的请求首部字段。
　　
　　内容实体。
　　
　　响应报文的组成：
　　
　　协议版本。
　　
　　状态码。
　　
　　用于解释状态码的原因短语。
　　
　　可选的响应首部字段。
　　
　　实体主体。
　　
　　**响应: **
　　
　　响应码：回应客户端此次响应是否成功。如：404(找不到请求的资源)，500(服务器内部错误)，200(成功响应)等。
　　
　　消息头：服务器与客户端通信的暗码，告诉客户端该怎么执行某些操作。
　　
　　响应正文：传递服务器响应给客户端要显示的内容，可以是下载文件或者显示界面。
　　
　　final、finalize和finally各自的作用
　　
　　final是一个修饰符，可以修饰变量、方法和类。如果 final 修饰变量，意味着该变量的值在初始化后不能被改变。
　　
　　finalize方法是在对象被回收之前调用的方法，给对象自己最后一个复活的机会，但是什么时候调用 finalize 没有保证。
　　
　　finally是一个关键字，与try和catch一起用于异常的处理。finally块一定会被执行，无论在try块中是否有发生异常。
　　
　　说一下你了解的几种进程间的通信方式
　　
　　管道pipe：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。
　　
　　高级管道popen：将另一个程序当做一个新的进程在当前程序进程中启动，则它算是当前程序的子进程，这种方式我们成为高级管道方式。
　　
　　有名管道named pipe ：有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。
　　
　　消息队列MessageQueue：消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。
　　
　　共享存储SharedMemory：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。
　　
　　信号量Semaphore：信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
　　
　　套接字Socket：套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同及其间的进程通信。
　　
　　信号sinal： 信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。
　　
　　复制代码
　　
　　1 /**
　　
　　2 * 后台菜单页面分页查询
　　
　　3 * @param page
　　
　　4 * @param limit
　　
　　5 * @param menu_name
　　
　　6 * @return
　　
　　7 */
　　
　　8 @RequestMapping("getAllMenu")
　　
　　9 @ResponseBody
　　
　　10 @RunTime
　　
　　11 public ResultMap getAllMenu(@RequestParam Integer page, @RequestParam Integer limit, @RequestParam(required = false) String menu_name) {
　　
　　12 ResultMap<www.tiaotiaoylzc.com List<Menu>> resultMap = new ResultMap<>();
　　
　　13 Page<Menu> pageInfo = new Page<www.yunshengyule178.com>(page, limit);
　　
　　14 Wrapper<Menu>www.tiaotiaoylzc.com wrapper = new EntityWrapper<>();
　　
　　15 wrapper = menu_name == null ? wrapper : wrapper.like("menu_name", menu_name);
　　
　　16 List<Menu> menuList www.yinmaoyule178.com/= dao.selectPage(pageInfo,www.yinmaoyule178.com/ wrapper.orderBy("id", false)).getRecords();
　　
　　17 resultMap.setData(menuList);
　　
　　18 resultMap.setCount(dao.selectCount(wrapper));
　　
　　19 return resultMap;
　　
　　20 }

转载于:https://www.cnblogs.com/qwangxiao/p/10668789.html