您好,欢迎访问代理记账网站
移动应用 微信公众号 联系我们

咨询热线 -

电话 15988168888

联系客服
  • 价格透明
  • 信息保密
  • 进度掌控
  • 售后无忧

【2021】从零开始的java面试题(java基础篇)

文章目录

  • 1.什么是面向对象?
  • 2.JDK JRE JVM
  • 3.==和equals比较
  • 4.为什么局部内部类和匿名内部类只能访问局部final变量?
  • 5.String、StringBuffer、StringBuilder
  • 6.重载和重写的区别
  • 7.接口和抽象类的区别
  • 8.List 和 Set的区别
  • 9.hashCode与equals

前言

本专题系列文章仅用于个人学习总结,从java基础逐步到常见服务框架。觉得基础的大佬可以提前离开。本专栏工作之余抽空更新…
 

java基础


1.什么是面向对象?

  面向对象是更注重事情有哪些参与者(对象)、及各自需要做什么。(面向过程更注重事情的每一个步骤及顺序) 其四大特征如下:

  • 封装:封装的意义,在于明确标识出允许外部使用的所有成员函数和数据项(内部细节对外部调用透明,外部调用无需修改或者关心内部实现)
  • 继承: 继承基类(父类)的方法,并做出自己的改变和/或扩展(子类共性的方法或者属性直接使用父类的,而不需要自己再定义,只需扩展自己个性化的)
  • 多态: 基于对象所属类的不同,外部对同一个方法的调用,实际执行的逻辑不同。(继承和接口可以实现多态)
  • 抽象: 抽取关键相关特性(属性和方法)构成对象,用程序的方法逻辑和数据结构 属性模拟现实的世界对象。(所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。)

 

2.JDK JRE JVM

  • JDK:Java Develpment Kit java 开发工具(程序员所需的各开发工具,包含 JRE JVM等)
  • JRE:Java Runtime Environment java运行时环境(运行java程序)
  • JVM:java Virtual Machine java 虚拟机(编译,解释.class文件,操作系统才能够执行)
    在这里插入图片描述

 

3.==和equals比较

== : 对比的是栈中的值,基本数据类型是变量值,引用类型是堆中内存对象的地址
equals: Object中默认也是采用==比较(通常开发者要自己重写,改为比较属性内容)
ps: 初学者可能没注意到这点,平时使用String比的也是内容,根本没有去重写它呀。实际上String类中,已经帮我们重写了equals方法。
下面我们来看一个例子:

/**
 * @author wook
 * @date 2021/4/23 21:35
 */
public class WookTest {
    private Integer id;
    private String name;
    public WookTest(Integer id,String name){
        this.id = id;
        this.name = name;
    }
    public static void main(String[] args) {
        WookTest wook = new WookTest(1, "wook");
        WookTest wook2 = new WookTest(1, "wook");
        System.out.println(wook.equals(wook2)); 
    }
}

根据开头的概念,所有类都继承Object,而Object的equals采用==比较内存地址,所以此处结果为:false 。那如果想让结果返回 :true 呢?

   @Override
   public boolean equals(Object o) {
       if (this == o) return true;
       if (o == null || getClass() != o.getClass()) return false;
       WookTest wookTest = (WookTest) o;
       return Objects.equals(id, wookTest.id) &&
               Objects.equals(name, wookTest.name);
    }

只需要在WookTest中重写equals即可(快捷键 ctrl + insert,选择equals…)。
ps: 细心的同学肯定发现了,equals和hashCode一般是成对出现的,equals搞明白了,那hashCode是干什么的呢?别着急,后面的文章会讲到。(着急请翻到第9点=。=)

 

4.为什么局部内部类和匿名内部类只能访问局部final变量?

首先回顾下 final修饰基本类型数据和引用类型数据 的情况

  • 如果是基本数据类型的变量,则其数值一旦在初始化之后便不能更改;
  • 如果是引用类型的变量,则在对其初始化之后便不能再让其指向另一个对象。但是引用的值是可变的
  public static void main() {
        final int[] iArr = {1, 2, 3, 4};
        iArr[2] = -3;//合法
        iArr = null;//非法,对iArr不能重新赋值(不能重新指向)
        final Person p = new Person(25);
        p.setAge(24);//合法
        p = null;//非法
    }

回到正题 为什么局部内部类和匿名内部类只能访问局部final变量?

/**
 * @author wook
 * @date 2021/4/23 22:35
 */
public class Test {
    //局部final变量a,b
    //jdk8在此处做了优化(语法糖),可不写final,但实际上也是有的,参数a,b在内部类中不能修改
    public void test(final int b) {
        final int a = 10;
        //匿名内部类
        new Thread() {
            public void run() {
                System.out.println(a);
                System.out.println(b);
            }
        }.start();
    }
}

class OutClass {
    private int age = 12;
    public void outPrint(final int x) {
        //局部内部类
        class InClass {
            public void InPrint() {
                System.out.println(x);
                System.out.println(age);
            }
        }
        new InClass().InPrint();
    }
}

ps:程序编译后的文件共有4个(内部类生成的class为原类名+$1…2…3)

  • Test.class 、 Test$1.class
    • ps: 再有匿名内部类则为 Test$2.class)
  • OutClass.class 、 OutClass$1InClass.class
    • ps: 再有局部内部类则为 OutClass$1其他内部类名

首先需要知道的一点: 内部类和外部类是处于同一个级别的,内部类不会因为定义在方法中就会随着方法的执行完毕就被销毁(例如开了线程跑匿名内部类)。

这里就会产生问题:

  • 当外部类的方法结束时,局部变量(a)就会被销毁了,但是内部类对象可能还存在(只有没有人再引用它时,才会死亡)。这里就出现了一个矛盾:内部类对象访问了一个不存在的变量。为了解决这个问题,就将局部变量复制了一份作为内部类的成员变量,这样当局部变量死亡后,内部类仍可以访问它,实际访问的是局部变量的"copy"。这样就好像延长了局部变量的生命周期。
  • 将局部变量复制为内部类的成员变量时,必须保证这两个变量是一样的,也就是如果我们在内部类中修改了成员变量,方法中的局部变量也得跟着改变,怎么解决问题呢?
    • 就将局部变量设置为final,对它初始化后,我就不让你再去修改这个变量,就保证了内部类的成员变量和方法的局部变量的一致性。这实际上也是一种妥协。使得局部变量与内部类内建立的拷贝保持一致。

:因为内部类复制了一份作为内部类的成员变量,为保证复制的与原先的值一致,只能妥协,使用final修饰,不让别人修改。

 

5.String、StringBuffer、StringBuilder

  • String是final修饰的,不可变,每次操作都会产生新的String对象
  • StringBuffer和StringBuilder都是在原对象上操作
    • StringBuffer是线程安全的(方法都是synchronized修饰的)
    • StringBuilder线程不安全的

性能: StringBuilder > StringBuffer > String

场景: 经常需要改变字符串内容时使用后面两个优先使用StringBuilder,多线程使用共享变量时使用StringBuffer。

 

6.重载和重写的区别

重载: 发生在同一个类中,方法名必须相同,参数类型不同、个数不同、顺序不同,方法返回值和访问修饰符可以不同,发生在编译时。
重写: 发生在父子类中,方法名、参数列表必须相同,返回值范围小于等于父类,抛出的异常范围小于等于父类,访问修饰符范围大于等于父类;如果父类方法访问修饰符为private则子类就不能重写该方法。

public int add(int a,String b)
//编译报错(非重载)
public String add(int a,String b)

 

7.接口和抽象类的区别

  • 抽象类可以存在普通成员函数,而接口中只能存在public abstract 方法。
  • 抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是public static final类型的。
  • 抽象类只能继承一个,接口可以实现多个。

详细说明:(赶时间知道上面三点即可)
  接口的设计目的,是对类的行为进行约束(更准确的说是一种“有”约束,因为接口不能规定类不可以有什么行为),也就是提供一种机制,可以强制要求不同的类具有相同的行为。它只约束了行为的有无,但不对如何实现行为进行限制。

  抽象类的设计目的,是代码复用。当不同的类具有某些相同的行为(记为行为集合A),且其中一部分行为的实现方式一致时(A的真子集,记为B),可以让这些类都派生于一个抽象类。在这个抽象类中实现了B,避免让所有的子类来实现B,这就达到了代码复用的目的。而A减B的部分,留给各个子类自己实现。正是因为A-B在这里没有实现,所以抽象类不允许实例化出来(否则当调用到A-B时,无法执行)。
ps: 真子集就是一个集合中的元素全部是另一个集合中的元素。

解释一下抽象类的话:

  • ①A类和B类都有action()方法,但实现不同
  • ②A类和B类都有fun()方法,且实现相同
  • ③可将A类和B类的fun()方法提取到抽象类C,A和B去继承C
  • ④而action则作为C类的抽象方法,由A和B去重写

总结:
  抽象类是对类本质的抽象,表达的是 is a 的关系,比如: 宝马是一辆车 。抽象类包含并实现子类的通用特性,将子类存在差异化的特性进行抽象,交由子类去实现
  而接口是对行为的抽象,表达的是 like a 的关系。比如: 鸟像飞行器一样可以飞,但其本质上 is a Bird 。接口的核心是定义行为,即实现类可以做什么,至于实现类主体是谁、是如何实现的,接口并不关心。
使用场景: 当你关注一个事物的本质的时候,用抽象类;当你关注一个操作的时候,用接口。
ps:抽象类的功能要远超过接口,但是,定义抽象类的代价高。因为高级语言来说(从实际设计上来说也是)每个类只能继承一个类。在这个类中,你必须继承或编写出其所有子类的所有共性。虽然接口在功能上会弱化许多,但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度。(Java 8 接口default method不讨论)

 

8.List 和 Set的区别

  • List:有序,按对象进入的顺序保存对象,可重复,允许多个Null元素对象,可以使用Iterator取出所有元素,在逐一遍历,还可以使用get(int index)获取指定下标的元素
  • Set:无序,不可重复,最多允许有一个Null元素对象,取元素时只能用Iterator接口取得所有元素,在逐一遍历各个元素 (没有get方法)

 

9.hashCode与equals

hashCode介绍:
  hashCode() 的作用是获取哈希码,也称为散列码;它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中,Java中的任何类都包含有hashCode() 函数。

  散列表存储的是键值对(key-value),它的特点是:能根据“键(索引)”快速的检索出对应的“值”。这其中就利用到了散列码!(可以快速找到所需要的对象)

ps: hashCode方法的主要作用是为了配合基于散列的集合一起正常运行,这样的散列集合包括HashSet、HashMap以及HashTable。

以“HashSet如何检查重复”为例子来说明为什么要有hashCode:
  对象加入HashSet时,HashSet会先计算对象的hashcode值来判断对象加入的位置,看该位置是否有值,如果没有、HashSet会认为对象没有重复出现。但是如果发现有值(hash冲突了),这时会调用equals()方法来检查两个对象是否真的相同。如果两者相同,HashSet就不会让其加入操作成功。如果不同的话,就会重新散列到其他位置。这样就大大减少了equals的次数(equals性能较差),相应就大大提高了执行速度。

  • 如果两个对象相等,则hashcode一定也是相同的
  • 两个对象相等,对两个对象分别调用equals方法都返回true
  • 两个对象有相同的hashcode值,它们也不一定是相等的
  • equals方法被覆盖过,则hashCode方法也必须被覆盖
  • hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode(),则该class的两个对象无论如何都不会相等(即使这两个对象指向相同的数据(内容))

理论明白了,下面通过代码来说明:
ps:代码参照海子大佬 https://www.cnblogs.com/dolphin0520/p/3681042.html

import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
 
class People{
    private String name;
    private int age;
 
    public People(String name,int age) {
        this.name = name;
        this.age = age;
    }  
 
    public void setAge(int age){
        this.age = age;
    }
 
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return this.name.equals(((People)obj).name) && this.age== ((People)obj).age;
    }
}
 
public class Main {
 
    public static void main(String[] args) {
 
        People p1 = new People("Jack", 12);
        System.out.println(p1.hashCode());
 
        HashMap<People, Integer> hashMap = new HashMap<People, Integer>();
        hashMap.put(p1, 1);
 
        System.out.println(hashMap.get(new People("Jack", 12)));
    }
}

这里我只重写了equals方法,也就说如果两个People对象,如果它的姓名和年龄相等,则认为是同一个人。

这段代码本来的意愿是想这段代码输出结果为“1”,但是事实上它输出的是“null”。为什么呢?原因就在于重写equals方法的同时忘记重写hashCode方法。

虽然通过重写equals方法使得逻辑上姓名和年龄相同的两个对象被判定为相等的对象(跟String类类似),但是要知道默认情况下,hashCode方法是将对象的存储地址进行映射。那么上述代码的输出结果为“null”就不足为奇了。原因很简单,p1指向的对象和System.out.println(hashMap.get(new People(“Jack”, 12)));这句中的new People(“Jack”, 12)生成的是两个对象,它们的存储地址肯定不同。下面是HashMap的get方法的具体实现:

所以在hashmap进行get操作时,因为得到的hashcdoe值不同(注意,上述代码也许在某些情况下会得到相同的hashcode值,不过这种概率比较小,因为虽然两个对象的存储地址不同也有可能得到相同的hashcode值),所以导致在get方法中for循环不会执行,直接返回null。

因此如果想上述代码输出结果为“1”,很简单,只需要重写hashCode方法,让equals方法和hashCode方法始终在逻辑上保持一致性。

import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
 
class People{
    private String name;
    private int age;
 
    public People(String name,int age) {
        this.name = name;
        this.age = age;
    }  
 
    public void setAge(int age){
        this.age = age;
    }
 
    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return name.hashCode()*37+age;
    }
 
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return this.name.equals(((People)obj).name) && this.age== ((People)obj).age;
    }
}
 
public class Main {
 
    public static void main(String[] args) {
 
        People p1 = new People("Jack", 12);
        System.out.println(p1.hashCode());
 
        HashMap<People, Integer> hashMap = new HashMap<People, Integer>();
        hashMap.put(p1, 1);
 
        System.out.println(hashMap.get(new People("Jack", 12)));
    }
}

这样一来的话,输出结果就为“1”了。

“设计hashCode()时最重要的因素就是:无论何时,对同一个对象调用hashCode()都应该产生同样的值。如果在讲一个对象用put()添加进HashMap时产生一个hashCdoe值,而用get()取出时却产生了另一个hashCode值,那么就无法获取该对象了。所以如果你的hashCode方法依赖于对象中易变的数据,用户就要当心了,因为此数据发生变化时,hashCode()方法就会生成一个不同的散列码”。
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
 
class People{
    private String name;
    private int age;
 
    public People(String name,int age) {
        this.name = name;
        this.age = age;
    }  
 
    public void setAge(int age){
        this.age = age;
    }
 
    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return name.hashCode()*37+age;
    }
 
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return this.name.equals(((People)obj).name) && this.age== ((People)obj).age;
    }
}
 
public class Main {
 
    public static void main(String[] args) {
 
        People p1 = new People("Jack", 12);
        System.out.println(p1.hashCode());
 
        HashMap<People, Integer> hashMap = new HashMap<People, Integer>();
        hashMap.put(p1, 1);
 
        p1.setAge(13);
 
        System.out.println(hashMap.get(p1));
    }
}

这段代码输出的结果为“null”,想必其中的原因大家应该都清楚了。

因此,在设计hashCode方法和equals方法的时候,如果对象中的数据易变,则最好在equals方法和hashCode方法中不要依赖于该字段。


分享:

低价透明

统一报价,无隐形消费

金牌服务

一对一专属顾问7*24小时金牌服务

信息保密

个人信息安全有保障

售后无忧

服务出问题客服经理全程跟进