面向对象

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>

2. 上界和下界的特点

• 上界的 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);
  }
}

3. 上界 <? 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 类型了。