Java面试题冲刺第十七天--基础篇3

• 面试题1：jdk1.8的新特性有哪些？
• lambda 表达式：
• annotation 注解：支持多重注解：
• 新的日期时间 api：
• base64编码：
• javascript引擎nashorn：
• stream的使用：
• optional：
• 其他核心 api 的改进

面试题1：jdk1.8的新特性有哪些？

接口的默认和静态方法：

java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 default关键字即可，这个特征又叫做扩展方法。

public interface jdk8interface {  
    // static修饰符定义静态方法  
    static void staticmethod() {  
        system.out.println("接口中的静态方法");  
    }  
    // default修饰符定义默认方法  
    default void defaultmethod() {  
        system.out.println("接口中的默认方法");
    }
}

lambda 表达式：

例如：(x, y) -> { return x + y; };λ表达式有三部分组成：参数列表，箭头（->），以及一个表达式或语句块。

在java 8 中你就没必要使用这种传统的匿名对象的方式了，java 8提供了更简洁的语法，lambda表达式：

collections.sort(names, (string a, string b) -> {
      return b.compareto(a);
});

方法与构造函数引用：

java 8 允许你使用 :: 关键字来传递方法或者构造函数引用，上面的代码展示了如何引用一个静态方法，我们也可以引用一个对象的方法：

converter = something::startswith;
string converted = converter.convert("java");
system.out.println(converted);

函数式接口：

所谓的函数式接口，当然首先是一个接口，然后就是在这个接口里面只能有一个抽象方法。

annotation 注解：支持多重注解：

很多时候一个注解需要在某一位置多次使用。

@yourannotation
@yourannotation
public void test(){
    //todo
}

新的日期时间 api：

java 8新的date-time api (jsr 310)受joda-time的影响，提供了新的java.time包，可以用来替代java.util.date和java.util.calendar。

一般会用到clock、localedate、localtime、localedatetime、zoneddatetime、duration这些类，对于时间日期的改进还是非常不错的。

base64编码：

base64编码是一种常见的字符编码，可以用来作为电子邮件或web service附件的传输编码。

在java 8中，base64编码成为了java类库的标准。base64类同时还提供了对url、mime友好的编码器与解码器。

javascript引擎nashorn：

nashorn允许在jvm上开发运行javascript应用，允许java与javascript相互调用。

stream的使用：

stream api是把真正的函数式编程风格引入到java中。其实简单来说可以把stream理解为mapreduce，当然google的mapreduce的灵感也是来自函数式编程。她其实是一连串支持连续、并行聚集操作的元素。从语法上看，也很像linux的管道、或者链式编程，代码写起来简洁明了，非常酷帅！

optional：

java 8引入optional类来防止空指针异常，optional类最先是由google的guava项目引入的。optional类实际上是个容器：它可以保存类型t的值，或者保存null。使用optional类我们就不用显式进行空指针检查了。

扩展注解的支持：

java 8扩展了注解的上下文，几乎可以为任何东西添加注解，包括局部变量、泛型类、父类与接口的实现，连方法的异常也能添加注解。

并行（parallel）数组：

支持对数组进行并行处理，主要是parallelsort()方法，它可以在多核机器上极大提高数组排序的速度。

编译器优化：

java 8将方法的参数名加入了字节码中，这样在运行时通过反射就能获取到参数名，只需要在编译时使用-parameters参数。

其他核心 api 的改进

java io改进

一些io改进包括：

• files.list(path dir) 返回延迟填充的stream，其元素是目录中的条目。
• files.lines(path path) 从文件中读取所有行作为流。
• files.find() 通过在以给定起始文件为根的文件树中搜索文件，返回通过路径延迟填充的stream。
• bufferedreader.lines() 返回一个stream，其元素是从此bufferedreader中读取的行。

集合 api 的改进

我们已经看到了 foreach（）方法和用于集合的 stream api。collection api还有一些新方法是：

• iterator foreachremaining(consumer action)在所有元素都已处理完毕或该动作引发异常之前，对每个剩余元素执行给定操作的默认方法。
• collection removeif(predicate filter)删除此集合中所有满足特定条件的元素的默认方法。
• collection spliterator() 该方法返回spliterator实例，该实例可用于顺序或并行遍历元素。
• map replaceall()，compute()，merge()方法。
• 具有键冲突的hashmap类的性能改进

面试题2：什么是内部类？内部类的作用？

将一个类定义在另一个类或者另一个方法里面，这样的类称着内部类；值得注意的是，内部类能够访问外部类的所有成员，包括private修饰的。

举例：把类inner定义在类outer中，类inner就被称为内部类。

class outer {
    class inner {
    }
}

注意：

内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为 outer 的外部类和其内部定义的名为 inner 的内部类。编译完成后出现 outer.class 和 outer$inner.class 两类。所以内部类的成员变量/方法名可以和外部类的相同。

内部类的作用

1、内部类可以很好的实现隐藏。

非内部类是不可以使用 private和 protected修饰的，但是内部类却可以，从而达到隐藏的作用。同时也可以将一定逻辑关系的类组织在一起，增强可读性。

2、间接的实现多继承。

内部类提供了java的"多重继承"的解决方案，弥补了java类是单继承的不足

每个内部类都能独立地继承自一个(接口的)实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。所以说内部类间接的实现了多继承。

内部类特点

• 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号
• 内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以*地访问外部类的成员变量，无论是否是private的
• 内部类声明成静态的，就不能随便的访问外部类的成员变量了，此时内部类只能访问外部类的静态成员变量

面试题3：内部类有哪几种？分别介绍一下

成员内部类

​局部内部类

静态内部类

匿名内部类

成员内部类

成员内部类——就是位于外部类成员位置的类

  ​
public class outer {
    //不对外开放的
    class inner{
        public void show(){
            system.out.println("成员内部类");
        }
    }
}

特点：

• 内部类就像一个实例成员一样存在于外部类中。
• 内部类可以访问外部类的所有成员就想访问自己的成员一样没有限制。
• 内部类中的 this 指的是内部类的实例对象本身，如果要用外部类的实例对象就可以用类名 .this 的方式获得。
• 内部类对象中不能有静态成员，原因很简单，内部类的实例对象是外部类实例对象的一个成员。

局部内部类

局部内部类——就是定义在一个方法或者一个作用域里面的类;

class outer {
      public void method(){
          class inner {
             system.out.println("局部内部类");
          }
      }
  }

特点：

• 方法中的内部类没有访问修饰符， 即方法内部类对包围它的方法之外的任何东西都不可见。
• 方法内部类只能够访问该方法中的局部变量，所以也叫局部内部类。而且这些局部变量一定要是final修饰的常量。

静态内部类

我们所知道static是不能用来修饰类的,但是成员内部类可以看做外部类中的一个成员,所以可以用static修饰,这种用static修饰的内部类我们称作静态内部类,也称作嵌套内部类.

特点：不能使用外部类的非static成员变量和成员方法

class outter {
      int age = 10;
      static age2 = 20;
      public outter() {        
      }
      static class inner {
          public method() {
              system.out.println(age);//错误
              system.out.println(age2);//正确
          }
      }
  }
  ​
  public class test {
      public static void main(string[] args)  {
          outter.inner inner = new outter.inner();
          inner.method();
      }
  }

匿名内部类

一个没有名字的类，是内部类的简化写法

本质：其实是继承该类或者实现接口的子类匿名对象

public abstract class a implements b{
    public void a(){
        system.out.println("a");
    }
}

 public interface b{
     public void b();
 }

public class test {
    public static void main(string[] args) {
        //new出接口或者实现类
        a a= new a (){
            //实现接口里未实现的方法
            public void b() {
                system.out.println("匿名内部类");
            }
        };
        a.a();
        a.b();
}

特点：

一个类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的事先或是覆盖。

只是为了获得一个对象实例，不需要知道其实际类型。

类名没有意义，也就是不需要使用到。 每日小结

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注的更多内容！