Java 基础面试知识点

时间  2019-11-17
标签 java 基础 面试 知识 栏目 Java 繁體版
原文   原文链接

Java 基础知识相关

Java中 == 和 equals 和 hashCode 的区别

对于关系操做符 ==html

  • 若操做数的类型是基本数据类型，则该关系操做符判断的是左右两边操做数的值是否相等
  • 若操做数的类型是引用数据类型，则该关系操做符判断的是左右两边操做数的内存地址是否相同。也就是说，若此时返回true,则该操做符做用的必定是同一个对象。

对于使用 equals 方法，内部实现分为三个步骤：java

  1. 先比较引用是否相同(是否为同一对象),
  2. 再判断类型是否一致（是否为同一类型）,
  3. 最后比较内容是否一致

Java 中全部内置的类的 equals 方法的实现步骤均是如此，特别是诸如 Integer，Double 等包装器类。如如下 String 中的 equals 方法实现android

// String.java 
    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }
复制代码

hashcode是系统用来快速检索对象而使用git

equals方法本意是用来判断引用的对象是否一致github

重写equals方法和hashcode方法时，equals方法中用到的成员变量也一定会在hashcode方法中用到,只不过前者做为比较项，后者做为生成摘要的信息项，本质上所用到的数据是同样的，从而保证两者的一致性面试

参考

int、char、long各占多少字节数

Java 基本类型占用的字节数安全

  • 1字节： byte , boolean
  • 2字节： short , char
  • 4字节： int , float
  • 8字节： long , double

注：1字节(byte)=8位(bits)网络

int与integer的区别

  • Integer是int的包装类，int则是java的一种基本数据类型
  • Integer变量必须实例化后才能使用，而int变量不须要
  • Integer实际是对象的引用，当new一个Integer时，其实是生成一个指针指向此对象；而int则是直接存储数据值
  • Integer的默认值是null，int的默认值是0
参考

对 Java 多态的理解

多态是指父类的某个方法被子类重写时，能够产生本身的功能行为，同一个操做做用于不一样对象，能够有不一样的解释，产生不一样的执行结果。多线程

多态的三个必要条件：并发

  1. 继承父类。
  2. 重写父类的方法。
  3. 父类的引用指向子类对象

而后可使用结合里氏替换法则进一步的谈理解

里氏替换法则 ---- 全部引用基类的地方必须能透明地使用其子类的对象

  • 子类必须彻底实现父类的方法

注意 在类中调用其余类时务必要使用父类或接口，若是不能使用父类或接口，则说明类的设计已经违背了LSP原则

注意 若是子类不能完整地实现父类的方法，或者父类的某些方法在子类中已经发生“畸变”，则建议断开父子继承关系，采用依赖、汇集、组合等关系代替继承

  • 子类能够有本身的个性
  • 覆盖或实现父类的方法时输入参数能够被放大
  • 覆写或实现父类的方法时输出结果能够被缩小

在项目中，采用里氏替换原则时，尽可能避免子类的“个性”，一旦子类有“个性”，这个子类和父类之间的关系就很难调和了， 把子类当作父类使用，子类的“个性”被抹杀——委屈了点;把子类单独做为一个业务来使用，则会让代码间的耦合关系变得扑朔迷离——缺少类替换的标准

String、StringBuffer、StringBuilder 区别

StringBuffer 和 String 同样都是用来存储字符串的，只不过因为他们内部的实现方式不一样，致使他们所使用的范围不一样，对于 StringBuffer 而言，他在处理字符串时，如果对其进行修改操做，它并不会产生一个新的字符串对象，因此说在内存使用方面它是优于 String 的

StringBuilder 也是一个可变的字符串对象，他与 StringBuffer 不一样之处就在于它是线程不安全的，基于这点，它的速度通常都比 StringBuffer 快

String 字符串的拼接会被 JVM 解析成 StringBuilder 对象拼接，在这种状况下 String 的速度比 StringBuffer 的速度快

str +=”b”等同于 str = new StringBuilder(str).append(“b”).toString();

详解内部类

内部类使得多重继承的解决方案变得更加完整

使用内部类最吸引人的缘由是：每一个内部类都能独立地继承一个（接口的）实现，因此不管外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响

使用内部类才能实现多重继承

  • 内部类能够用多个实例，每一个实例都有本身的状态信息，而且与其余外围对象的信息相互独立。
  • 在单个外围类中，可让多个内部类以不一样的方式实现同一个接口，或者继承同一个类。
  • 建立内部类对象的时刻并不依赖于外围类对象的建立。
  • 内部类并无使人迷惑的“is-a”关系，他就是一个独立的实体。
  • 内部类提供了更好的封装，除了该外围类，其余类都不能访问。

当咱们在建立某个外围类的内部类对象时，此时内部类对象一定会捕获一个指向那个外围类对象的引用，只要咱们在访问外围类的成员时，就会用这个引用来选择外围类的成员

成员内部类

在成员内部类中要注意两点，

  • 成员内部类中不能存在任何 static 的变量和方法
  • 成员内部类是依附于外围类的，因此只有先建立了外围类才可以建立内部类

静态内部类

静态内部类与非静态内部类之间存在一个最大的区别，咱们知道非静态内部类在编译完成以后会隐含地保存着一个引用，该引用是指向建立它的外围内，可是静态内部类却没有。没有这个引用就意味着：

  • 它的建立是不须要依赖于外围类的。
  • 它不能使用任何外围类的非static成员变量和方法。

参考

为何Java里的匿名内部类只能访问final修饰的外部变量？

匿名内部类用法

public class TryUsingAnonymousClass {
    public void useMyInterface() {
        final Integer number = 123;
        System.out.println(number);

        MyInterface myInterface = new MyInterface() {
            @Override
            public void doSomething() {
                System.out.println(number);
            }
        };
        myInterface.doSomething();

        System.out.println(number);
    }
}
复制代码

编译后的结果

class TryUsingAnonymousClass$1 implements MyInterface {
    private final TryUsingAnonymousClass this$0;
    private final Integer paramInteger;

    TryUsingAnonymousClass$1(TryUsingAnonymousClass this$0, Integer paramInteger) {
        this.this$0 = this$0;
        this.paramInteger = paramInteger;
    }

    public void doSomething() {
        System.out.println(this.paramInteger);
    }
}
复制代码

由于匿名内部类最终用会编译成一个单独的类，而被该类使用的变量会以构造函数参数的形式传递给该类，例如：Integer paramInteger，若是变量 不定义成final的，paramInteger在匿名内部类被能够被修改，进而形成和外部的paramInteger不一致的问题，为了不这种不一致的状况，由于Java 规定匿名内部类只能访问final修饰的外部变量

抽象类和接口的区别

  1. 默认的方法实现抽象类能够有默认的方法实现彻底是抽象的。接口根本不存在方法的实现
  2. 实现抽象类使用 extends 关键字来继承抽象类。若是子类不是抽象类的话，它须要提供抽象类中全部声明的方法的实现。子类使用关键字 implements 来实现接口。它须要提供接口中全部声明的方法的实现。
  3. 抽象类能够有构造器，而接口不能有构造器
  4. 抽象方法能够有public、protected和default这些修饰符。接口方法默认修饰符是public。你不可使用其它修饰符。
  5. 抽象类在java语言中所表示的是一种继承关系，一个子类只能存在一个父类，可是能够存在多个接口。
  6. 抽象方法比接口速度要快，接口是稍微有点慢的，由于它须要时间去寻找在类中实现的方法。
  7. 若是往抽象类中添加新的方法，你能够给它提供默认的实现。所以你不须要改变你如今的代码。 若是你往接口中添加方法，那么你必须改变实现该接口的类
参考

泛型中 extends 和 super 的区别

父类的静态方法能不能被子类重写

静态方法与静态成员变量能够被继承，可是不能被重写。它对子类隐藏，所以静态方法也不能实现多态

进程和线程的区别

进程和线程的主要差异在于它们是不一样的操做系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不一样执行路径。线程有本身的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，因此多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行而且又要共享某些变量的并发操做，只能用线程，不能用进程。

final, finally, finalize的区别

  • final 用于声明属性,方法和类, 分别表示属性不可变, 方法不可覆盖, 类不可继承.

  • finally 是异常处理语句结构的一部分，表示老是执行.

  • finalize 是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，能够覆盖此方法提供垃圾收集时的其余资源回收，例如关闭文件等. JVM不保证此方法总被调用.

参考

Parcelable和Serializable的区别

Serializable是Java中的序列化接口，其使用起来简单但 是开销很大，序列化和反序列化过程须要大量I/O操做。而Parcelable是Android中的序列化方式，所以更适合用在Android平台上，它的缺点就是使用起来稍微麻烦 点，可是它的效率很高，这是Android推荐的序列化方式，所以咱们要首选Parcelable。Parcelable主要用在内存序列化上，经过Parcelable将对象序列化到存储设备 中或者将对象序列化后经过网络传输也都是能够的，可是这个过程会稍显复杂，所以在这两种状况下建议你们使用Serializable。

参考

为何非静态内部类里不能够有静态属性

谈谈对kotlin的理解

因人而异，请自行整理答案

String 转换成 integer的方式及原理

Integer a = 2;
private void test() {
    String s1 = a.toString();  //方式一
    String s2 = Integer.toString(a);  //方式二
    String s3 = String.valueOf(a);  //方式三
}
复制代码

方式一源码：

public String toString() {
        return toString(value);
    }

    public static String toString(int i) {
        if (i == Integer.MIN_VALUE)
            return "-2147483648";
        int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
        char[] buf = new char[size];
        getChars(i, size, buf);
        return new String(buf, true);
    }
复制代码

能够看出方式一最终调用的是方式二

经过toString()方法，能够把整数（包括0）转化为字符串，可是 Integer 若是是 null 的话，就会报空指针异常

方式三源码：

public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
}
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
复制代码

能够看出 当 Integer 是null的时候，返回的String是 字符串 "null" 而不是 null

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程