面向对象

1.一个类不重写，它的equals()办法如何比拟

比拟对象的地址

2.hashCode()和equals()办法有什么分割

Java对象的eqauls办法和hashCode办法是这样规定的：

  1. 相等（雷同）的对象必须具备相等的哈希码（或者散列码）。
  2. 如果两个对象的hashCode相等，它们并不肯定雷同。

3.Query接口的list办法和iterate办法有什么区别

  1. list()办法无奈利用一级缓存和二级缓存（对缓存只写不读），它只能在开启查问缓存的前提下应用查问缓存；iterate()办法能够充分利用缓存，如果指标数据只读或者读取频繁，应用iterate()办法能够缩小性能开销。
  2. list()办法不会引起N+1查问问题，而iterate()办法可能引起N+1查问问题

4.面向对象的"六准则一法令"

  • 繁多职责准则：一个类只做它该做的事件。（繁多职责准则想表白的就是"高内聚"，写代码最终极的准则只有六个字"高内聚、低耦合"，所谓的高内聚就是一个代码模块只实现一项性能，在面向对象中，如果只让一个类实现它该做的事，而不波及与它无关的畛域就是践行了高内聚的准则，这个类就只有繁多职责。另一个是模块化，好的自行车是组装车，从减震叉、刹车到变速器，所有的部件都是能够装配和从新组装的，好的乒乓球拍也不是成品拍，肯定是底板和胶皮能够拆分和自行组装的，一个好的软件系统，它外面的每个功能模块也应该是能够轻易的拿到其余零碎中应用的，这样能力实现软件复用的指标。）
  • 开闭准则：软件实体该当对扩大凋谢，对批改敞开。（在现实的状态下，当咱们须要为一个软件系统减少新性能时，只须要从原来的零碎派生出一些新类就能够，不须要批改原来的任何一行代码。要做到开闭有两个要点：①形象是要害，一个零碎中如果没有抽象类或接口零碎就没有扩大点；②封装可变性，将零碎中的各种可变因素封装到一个继承构造中，如果多个可变因素混淆在一起，零碎将变得复杂而换乱，如果不分明如何封装可变性，能够参考《设计模式精解》一书中对桥梁模式的解说的章节。）
  • 依赖倒转准则：面向接口编程。（该准则说得直白和具体一些就是申明办法的参数类型、办法的返回类型、变量的援用类型时，尽可能应用形象类型而不必具体类型，因为形象类型能够被它的任何一个子类型所代替，请参考上面的里氏替换准则。）里氏替换准则：任何时候都能够用子类型替换掉父类型。（对于里氏替换准则的形容，Barbara Liskov女士的形容比这个要简单得多，但简略的说就是能用父类型的中央就肯定能应用子类型。里氏替换准则能够查看继承关系是否正当，如果一个继承关系违反了里氏替换准则，那么这个继承关系肯定是谬误的，须要对代码进行重构。例如让猫继承狗，或者狗继承猫，又或者让正方形继承长方形都是谬误的继承关系，因为你很容易找到违反里氏替换准则的场景。须要留神的是：子类肯定是减少父类的能力而不是缩小父类的能力，因为子类比父类的能力更多，把能力多的对象当成能力少的对象来用当然没有任何问题。）
  • 接口隔离准则：接口要小而专，绝不能大而全。（臃肿的接口是对接口的净化，既然接口示意能力，那么一个接口只应该形容一种能力，接口也应该是高度内聚的。例如，琴棋书画就应该别离设计为四个接口，而不应设计成一个接口中的四个办法，因为如果设计成一个接口中的四个办法，那么这个接口很难用，毕竟琴棋书画四样都精通的人还是多数，而如果设计成四个接口，会几项就实现几个接口，这样的话每个接口被复用的可能性是很高的。Java中的接口代表能力、代表约定、代表角色，是否正确的应用接口肯定是编程程度高下的重要标识。）
  • 合成聚合复用准则：优先应用聚合或合成关系复用代码。（通过继承来复用代码是面向对象程序设计中被滥用得最多的货色，因为所有的教科书都无一例外的对继承进行了宣扬从而误导了初学者，类与类之间简略的说有三种关系，Is-A关系、Has-A关系、Use-A关系，别离代表继承、关联和依赖。其中，关联关系依据其关联的强度又能够进一步划分为关联、聚合和合成，但说白了都是Has-A关系，合成聚合复用准则想表白的是优先思考Has-A关系而不是Is-A关系复用代码，起因嘛能够本人从百度上找到一万个理由，须要阐明的是，即便在Java的API中也有不少滥用继承的例子，例如Properties类继承了Hashtable类，Stack类继承了Vector类，这些继承显著就是谬误的，更好的做法是在Properties类中搁置一个Hashtable类型的成员并且将其键和值都设置为字符串来存储数据，而Stack类的设计也应该是在Stack类中放一个Vector对象来存储数据。记住：任何时候都不要继承工具类，工具是能够领有并能够应用的，而不是拿来继承的。）
  • 迪米特法令：迪米特法令又叫起码常识准则，一个对象该当对其余对象有尽可能少的理解。再简单的零碎都能够为用户提供一个简略的门面，Java Web开发中作为前端控制器的Servlet或Filter不就是一个门面吗，浏览器对服务器的运作形式无所不知，然而通过前端控制器就可能依据你的申请失去相应的服务。调停者模式也能够举一个简略的例子来阐明，例如一台计算机，CPU、内存、硬盘、显卡、声卡各种设施须要相互配合能力很好的工作，然而如果这些货色都间接连贯到一起，计算机的布线将异样简单，在这种状况下，主板作为一个调停者的身份呈现，它将各个设施连贯在一起而不须要每个设施之间间接替换数据，这样就减小了零碎的耦合度和复杂度。

5.如何通过反射获取和设置对象公有字段的值

能够通过类对象的getDeclaredField()办法获取字段（Field）对象，而后再通过字段对象的setAccessible(true)将其设置为能够拜访，接下来就能够通过get/set办法来获取/设置字段的值了。

6.外部类能够援用他蕴含类的成员吗

一个外部类对象能够拜访创立它的外部类对象的内容，外部类如果不是static的，那么它能够拜访创立它的外部类对象的所有属性；外部类如果是static的，即为nested class，那么它只能够拜访创立它的外部类对象的所有static属性;个别一般类只有public或package的拜访润饰，而外部类能够实现static，protected，private等拜访润饰。当从外部类继承的时候，外部类是不会被笼罩的，它们是齐全独立的实体，每个都在本人的命名空间内，如果从外部类中明确地继承，就能够笼罩原来外部类的办法。

7.异样解决

Java 通过面向对象的办法进行异样解决，把各种不同的异样进行分类，并提供了良好的接口。在Java中，每个异样都是一个对象，它是Throwable类或其它子类的实例。当一个办法出现异常后便抛出一个异样对象，该对象中蕴含有异样信息，调用这个对象的办法能够捕捉到这个异样并进行解决。
Java的异样解决是通过5个关键词来实现的：try、catch、throw、throws和finally。个别状况下是用try来执行一段程序，如果出现异常，零碎会抛出（throws）一个异样，这时候你能够通过它的类型来捕获（catch）它，或最初（finally）由缺省处理器来解决。用try来指定一块预防所有”异样”的程序。紧跟在try程序前面，应蕴含一个catch子句来指定你想要捕获的”异样”的类型。throw语句用来明确地抛出一个”异样”。throws用来表明一个成员函数可能抛出的各种”异样”。Finally为确保一段代码不论产生什么”异样”都被执行一段代码。能够在一个成员函数调用的里面写一个try语句，在这个成员函数外部写另一个try语句爱护其余代码。每当遇到一个try语句，"异样"的框架就放到堆栈下面，直到所有的try语句都实现。如果下一级的try语句没有对某种”异样”进行解决，堆栈就会开展，直到遇到有解决这种”异样”的try语句。

8.Static Nested Class 和 Inner Class的不同

Static Nested Class是被申明为动态（static）的外部类，它能够不依赖于外部类实例被实例化。而通常的外部类须要在外部类实例化后能力实例化。Static-Nested Class 的成员, 既能够定义为动态的(static), 也能够定义为动静的(instance)。
Nested Class的动态成员(Method)只能对Outer Class的动态成员(static memebr)进行操作(ACCESS), 而不能Access Outer Class的动静成员(instance member);而 Nested Class的动静成员(instance method) 却能够 Access Outer Class的所有成员, 这个概念很重要, 许多人对这个概念含糊. 有一个一般的准则, 因为静态方法(static method) 总是跟 CLASS 相关联(bind CLASS), 而动静办法( (instance method) 总是跟 instance object 相关联, 所以,静态方法(static method)永远不能够Access跟 object 相干的动静成员(instance member),反过来就能够, 一个CLASS的 instance object 能够 Access 这个 Class 的任何成员, 包含动态成员(static member).

9.Comparable和Comparator接口的作用以及它们的区别

Java提供了只蕴含一个compareTo()办法的Comparable接口。这个办法能够个给两个对象排序。具体来说，它返回正数，0，负数来表明输出对象小于，等于，大于曾经存在的对象。
Java提供了蕴含compare()和equals()两个办法的Comparator接口。compare()办法用来给两个输出参数排序，返回正数，0，负数表明第一个参数是小于，等于，大于第二个参数。equals()办法须要一个对象作为参数，它用来决定输出参数是否和comparator相等。只有当输出参数也是一个comparator并且输出参数和以后comparator的排序后果是雷同的时候，这个办法才返回true。

10.如何通过反射创建对象

  • 办法1：通过类对象调用newInstance()办法，例如：String.class.newInstance()
  • 办法2：通过类对象的getConstructor()或getDeclaredConstructor()办法取得结构器（Constructor）对象并调用其newInstance()办法创建对象，例如：String.class.getConstructor(String.class).newInstance("Hello");

11.extends 和super 泛型限定符

  1. 泛型中上界和下界的定义
  • 上界<? extend Fruit>
  • 下界<? super Apple>
  1. 上界和下界的特点
  • 上界的list只能get，不能add（确切地说不能add出除null之外的对象，包含Object）
  • 下界的list只能add，不能get
import java.util.ArrayList;import java.util.List; class Fruit {}class Apple extends Fruit {}class Jonathan extends Apple {}class Orange extends Fruit {} public class CovariantArrays {  public static void main(String[] args) {    //上界    List<? extends Fruit> flistTop = new ArrayList<Apple>();    flistTop.add(null);    //add Fruit对象会报错    //flist.add(new Fruit());    Fruit fruit1 = flistTop.get(0);     //下界    List<? super Apple> flistBottem = new ArrayList<Apple>();    flistBottem.add(new Apple());    flistBottem.add(new Jonathan());    //get Apple对象会报错    //Apple apple = flistBottem.get(0);  }}
  1. 上界<? extend Fruit> ，示意所有继承Fruit的子类，然而具体是哪个子类，无奈确定，所以调用add的时候，要add什么类型，谁也不晓得。然而get的时候，不论是什么子类，不论追溯多少辈，必定有个父类是Fruit，所以，我都能够用最大的父类Fruit接着，也就是把所有的子类向上转型为Fruit。
    下界<? super Apple>，示意Apple的所有父类，包含Fruit，始终能够追溯到老祖宗Object 。那么当我add的时候，我不能add Apple的父类，因为不能确定List外面寄存的到底是哪个父类。然而我能够add Apple及其子类。因为不论我的子类是什么类型，它都能够向上转型为Apple及其所有的父类甚至转型为Object 。然而当我get的时候，Apple的父类这么多，我用什么接着呢，除了Object，其余的都接不住。
    所以，归根结底能够用一句话示意，那就是编译器能够反对向上转型，但不反对向下转型。具体来讲，我能够把Apple对象赋值给Fruit的援用，然而如果把Fruit对象赋值给Apple的援用就必须得用cast。

12.泛型

泛型，即“参数化类型”。一提到参数，最相熟的就是定义方法时无形参，而后调用此办法时传递实参。那么参数化类型怎么了解呢？顾名思义，就是将类型由原来的具体的类型参数化，相似于办法中的变量参数，此时类型也定义成参数模式（能够称之为类型形参），而后在应用/调用时传入具体的类型（类型实参）。

public class GenericTest {       public static void main(String[] args) {          /*          List list = new ArrayList();          list.add("qqyumidi");          list.add("corn");          list.add(100);          */          List<String> list = new ArrayList<String>();         list.add("qqyumidi");         list.add("corn");         //list.add(100);   // 1  提醒编译谬误          for (int i = 0; i < list.size(); i++) {             String name = list.get(i); // 2             System.out.println("name:" + name);         }     } }

采纳泛型写法后，在//1处想退出一个Integer类型的对象时会呈现编译谬误，通过List<String>，间接限定了list汇合中只能含有String类型的元素，从而在//2处毋庸进行强制类型转换，因为此时，汇合可能记住元素的类型信息，编译器曾经可能确认它是String类型了。