内部类

1. 什么是内部类？

在Java中，可以将一个类的定义放在另外一个类的定义内部，这就是内部类。内部类本身就是类的一个属性，与其他属性定义方式一致。

2. 内部类的分类有哪些

内部类可以分为四种：成员内部类、局部内部类、匿名内部类和静态内部类

静态内部类

• 定义在类内部的静态类，就是静态内部类。

public class Outer {
  private static int radius = 1;
  static class StaticInner {
    public void visit() {
      System.out.println("visit outer static variable:" + radius);
    }
  }
}

• 静态内部类可以访问外部类所有的静态变量，而不可访问外部类的非静态变量；静态内部类的创建方式，new 外部类.静态内部类()，如下：

Outer.StaticInner inner = new Outer.StaticInner();
inner.visit();

成员内部类

• 定义在类内部，成员位置上的非静态类，就是成员内部类。

public class Outer {
  private static int radius = 1;
  private int count =2;
    class Inner {
      public void visit() {
        System.out.println("visit outer static variable:" + radius);
        System.out.println("visit outer variable:" + count);
      }
  }
}

成员内部类可以访问外部类所有的变量和方法，包括静态和非静态，私有和公有。成员内部类依赖于外部类的实例，它的创建方式 外部类实例.new 内部类()，如下：

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.visit();

局部内部类

• 定义在方法中的内部类，就是局部内部类。

public class Outer {
  private int out_a = 1;
  private static int STATIC_b = 2;
  public void testFunctionClass(){
    int inner_c =3;
    class Inner {
      private void fun(){
        System.out.println(out_a);
        System.out.println(STATIC_b);
        System.out.println(inner_c);
      }
    }
    Inner inner = new Inner();
    inner.fun();
  }
  public static void testStaticFunctionClass(){
    int d =3;
    class Inner {
      private void fun(){
        // System.out.println(out_a); 编译错误，定义在静态方法中的局部类不可以访问外部类的实例变量
        System.out.println(STATIC_b);
        System.out.println(d);
      }
    }
    Inner inner = new Inner();
    inner.fun();
  }
}

• 定义在实例方法中的局部类可以访问外部类的所有变量和方法，定义在静态方法中的局部类只能访问外部类的静态变量和方法。局部内部类的创建方式，在对应方法内， new 内部类()，如下：

public static void testStaticFunctionClass(){
  class Inner {
  }
  Inner inner = new Inner();
}

匿名内部类

• 匿名内部类就是没有名字的内部类，日常开发中使用的比较多。

public class Outer {
  private void test(final int i) {
    new Service() {
      public void method() {
        for (int j = 0; j < i; j++) {
          System.out.println("匿名内部类" );
        }
      }
    }.method();
  }
}
//匿名内部类必须继承或实现一个已有的接口
interface Service{
  void method();
}

• 除了没有名字，匿名内部类还有以下特点：
• 
  

1. 匿名内部类必须继承一个抽象类或者实现一个接口。
2. 匿名内部类不能定义任何静态成员和静态方法。
3. 当所在的方法的形参需要被匿名内部类使用时，必须声明为 final。
4. 匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

• 匿名内部类创建方式：

new 类/接口{
  //匿名内部类实现部分
}

3. 内部类的优点

我们为什么要使用内部类呢？因为它有以下优点：

1. 一个内部类对象可以访问创建它的外部类对象的内容，包括私有数据！
2. 内部类不为同一包的其他类所见，具有很好的封装性；
3. 内部类有效实现了“多重继承”，优化 java 单继承的缺陷。
4. 匿名内部类可以很方便的定义回调。

4. 内部类有哪些应用场景

1. 一些多算法场合
2. 解决一些非面向对象的语句块。
3. 适当使用内部类，使得代码更加灵活和富有扩展性。
4. 当某个类除了它的外部类，不再被其他的类使用时。

5. 局部内部类和匿名内部类访问局部变量的时候，为什么变量必须要加上final？

局部内部类和匿名内部类访问局部变量的时候，为什么变量必须要加上final呢？它内部原理是什么呢？

先看这段代码：

public class Outer {
  void outMethod(){
    final int a =10;
    class Inner {
      void innerMethod(){
        System.out.println(a);
      }
    }
  }
}

5. 以上例子，为什么要加final呢？是因为生命周期不一致， 局部变量直接存储在栈中，当方法执行结束后，非final的局部变量就被销毁。而局部内部类对局部变量的引用依然存在，如果局部内部类要调用局部变量时，就会出错。加了final，可以确保局部内部类使用的变量与外层的局部变量区分开，解决了这个问题。

6. 内部类相关，看程序说出运行结果

public class Outer {
  private int age = 12;
  class Inner {
    private int age = 13;
    public void print() {
      int age = 14;
      System.out.println("局部变量：" + age);
      System.out.println("内部类变量：" + this.age);
      System.out.println("外部类变量：" + Outer.this.age);
    }
  }
  public static void main(String[] args) {
    Outer.Inner in = new Outer().new Inner();
    in.print();
  }
} 

• 运行结果：

局部变量：14
内部类变量：13
外部类变量：12

重写与重载

1. 构造器（constructor）是否可被重写（override）

构造器不能被继承，因此不能被重写，但可以被重载。

2. 重载（Overload）和重写（Override）的区别。重载的方法能否根据返回类型进行区分？

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。

重载：发生在同一个类中，方法名相同参数列表不同（参数类型不同、个数不同、顺序不同），与方法返回值和访问修饰符无关，即重载的方法不能根据返回类型进行区分

重写：发生在父子类中，方法名、参数列表必须相同，返回值小于等于父类，抛出的异常小于等于父类，访问修饰符大于等于父类（里氏代换原则）；如果父类方法访问修饰符为private则子类中就不是重写。

对象相等判断

1. == 和 equals 的区别是什么

• == : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象。(基本数据类型 == 比较的是值，引用数据类型 == 比较的是内存地址)
• equals(): 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：
• 
  

情况1：类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。

情况2：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来两个对象的内容相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)。

举个例子：

public class test1 {
public static void main(String[] args) {
  String a = new String("ab"); // a 为一个引用
  String b = new String("ab"); // b为另一个引用,对象的内容一样
  String aa = "ab"; // 放在常量池中
  String bb = "ab"; // 从常量池中查找
  if (aa == bb){ // true
    System.out.println("aa==bb");
  }
  if (a == b){ // false，非同一对象
    System.out.println("a==b");
  } 
  if (a.equals(b)){ // true
    System.out.println("aEQb");
  } 
  if (42 == 42.0) { // true
    System.out.println("true");
  }
}

说明：

• String中的equals方法是被重写过的，因为object的equals方法是比较的对象的内存地址，而String的equals方法比较的是对象的值。
• 当创建String类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个String对象。

2. hashCode 与 equals (重要)

• HashSet如何检查重复
• 两个对象的 hashCode() 相同，则 equals() 也一定为 true，对吗？
• hashCode和equals方法的关系
• 面试官可能会问你：“你重写过 hashcode 和 equals 么，为什么重写equals时必须重写hashCode方法？”

hashCode()介绍

• hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode()函数。
• 散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）
  

为什么要有 hashCode

我们以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：

当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 equals()方法来检查hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。

hashCode()与equals()的相关规定

• 如果两个对象相等，则hashcode一定也是相同的
• 两个对象相等，对两个对象分别调用equals方法都返回true
• 两个对象有相同的hashcode值，它们也不一定是相等的

因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖

hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

3. 对象的相等与指向他们的引用相等，两者有什么不同？

对象的相等 比的是内存中存放的内容是否相等而 引用相等 比较的是他们指向的内存地址是否相等。

4. 当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?

是值传递。Java 语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的属性可以在被调用过程中被改变，但对对象引用的改变是不会影响到调用者的

5. 为什么 Java 中只有值传递

首先回顾一下在程序设计语言中有关将参数传递给方法（或函数）的一些专业术语。按值调用(call by value)表示方法接收的是调用者提供的值，而按引用调用（call by reference)表示方法接收的是调用者提供的变量地址。一个方法可以修改传递引用所对应的变量值，而不能修改传递值调用所对应的变量值。 它用来描述各种程序设计语言（不只是Java)中方法参数传递方式。

Java程序设计语言总是采用按值调用。也就是说，方法得到的是所有参数值的一个拷贝，也就是说，方法不能修改传递给它的任何参数变量的内容。

下面通过 3 个例子来给大家说明

example 1

public static void main(String[] args) {
  int num1 = 10;
  int num2 = 20;
  swap(num1, num2);
  System.out.println("num1 = " + num1);
  System.out.println("num2 = " + num2);
}
public static void swap(int a, int b) {
  int temp = a;
  a = b;
  b = temp;
  System.out.println("a = " + a);
  System.out.println("b = " + b);
}

结果：

• a = 20 b = 10 num1 = 10 num2 = 20

解析：

• 在swap方法中，a、b的值进行交换，并不会影响到 num1、num2。因为，a、b中的值，只是从num1、num2 的复制过来的。也就是说，a、b相当于num1、num2 的副本，副本的内容无论怎么修改，都不会影响到原件本身。

通过上面例子，我们已经知道了一个方法不能修改一个基本数据类型的参数，而对象引用作为参数就不一样，请看example 2

example 2

public static void main(String[] args) {
  int[] arr = { 1, 2, 3, 4, 5 };
  System.out.println(arr[0]);
  change(arr);
  System.out.println(arr[0]);
}
public static void change(int[] array) {
  // 将数组的第一个元素变为0
  array[0] = 0;
}

结果：

• 1 0

解析：

• array 被初始化 arr 的拷贝也就是一个对象的引用，也就是说 array 和 arr 指向的时同一个数组对象。 因此，外部对引用对象的改变会反映到所对应的对象上。

通过 example2 我们已经看到，实现一个改变对象参数状态的方法并不是一件难事。理由很简单，方法得到的是对象引用的拷贝，对象引用及其他的拷贝同时引用同一个对象。

• 很多程序设计语言（特别是，C++和Pascal)提供了两种参数传递的方式：值调用和引用调用。有些程序员（甚至本书的作者）认为Java程序设计语言对对象采用的是引用调用，实际上，这种理解是不对的。由于这种误解具有一定的普遍性，所以下面给出一个反例来详细地阐述一下这个问题。

example 3

public class Test {
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    Student s1 = new Student("小张");
    Student s2 = new Student("小李");
    Test.swap(s1, s2);
    System.out.println("s1:" + s1.getName());
    System.out.println("s2:" + s2.getName());
  }
  public static void swap(Student x, Student y) {
    Student temp = x;
    x = y;
    y = temp;
    System.out.println("x:" + x.getName());
    System.out.println("y:" + y.getName());
  }
}

结果：

• x:小李 y:小张 s1:小张 s2:小李

解析：

• 交换之前：

交换之后

通过上面两张图可以很清晰的看出：方法并没有改变存储在变量 s1 和 s2 中的对象引用。swap方法的参数x和y被初始化为两个对象引用的拷贝，这个方法交换的是这两个拷贝

总结:

Java程序设计语言对对象采用的不是引用调用，实际上，对象引用是按值传递的。

下面再总结一下Java中方法参数的使用情况：

1. 一个方法不能修改一个基本数据类型的参数（即数值型或布尔型》
2. 一个方法可以改变一个对象参数的状态。
3. 一个方法不能让对象参数引用一个新的对象。
4.