网站导航
> 文档中心 > day2 java基础连环10问，你能坚持到第几问？【面试篇】

day2 java基础连环10问，你能坚持到第几问？【面试篇】

网友: 文档中心 2022-04-18 09:55:01

day2 java基础连环10问，你能坚持到第几问？【面试篇】

    • 👉 静态方法和实例方法有何不同？
    • 👉重载和重写的区别
    • 👉什么是可变长参数？
    • 👉Java 中的几种基本数据类型了解么？
    • 👉基本类型和包装类型的区别？
    • 👉包装类型的常量池技术了解么？
    • 👉自动装箱与拆箱了解吗？原理是什么？
    • 👉面向对象和面向过程的区别
    • 👉成员变量与局部变量的区别
    • 👉创建一个对象用什么运算符?对象实体与对象引用有何不同?

⭐️ ⭐️ 重点：每天更新10道面试题
⚠️⚠️ 重要的事情：如果你是大一大二每天看10道面试题，学习的知识也会更加牢固，等到大三准备找工作的时候可以得心应手，如果你是大三大四每天看10道面试题，找工作也不会太慌张，如果你已经上班了，每天复习10道，解决中年危机哈哈哈
📋📋 后续内容：目前博主正在持续性输出java基础经典面试题（还有好多在整理），后续还会有spring、mybatis、mybatis-plus、SpringBoot、SpringCloud以及juc并发编程、jvm等，当然还有数据结构、操作系统、计算机网络、http等。
⭐️ ⭐️ 上篇文章：Java基础连环十五问，你能坚持到第几问？【面试篇】
可以每天和博主一起看10道面试题，欢迎大家点赞👍➕收藏⭐️➕评论💬支持博主🤞

在这里插入图片描述

👉 静态方法和实例方法有何不同？

1、调用方式

在外部调用静态方法时，可以使用 类名.方法名 的方式，也可以使用 对象.方法名 的方式，而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象 。

不过，需要注意的是一般不建议使用 对象.方法名 的方式来调用静态方法。这种方式非常容易造成混淆，静态方法不属于类的某个对象而是属于这个类。

因此，一般建议使用 类名.方法名 的方式来调用静态方法。

public class Person {    public void method() {      //......    }    public static void staicMethod(){      //......    }    public static void main(String[] args) { Person person = new Person(); // 调用实例方法 person.method(); // 调用静态方法 Person.staicMethod()    }}

2、访问类成员是否存在限制

静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），不允许访问实例成员（即实例成员变量和实例方法），而实例方法不存在这个限制。

👉重载和重写的区别

重载就是同样的一个方法能够根据输入数据的不同，做出不同的处理。重写就是当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法。

重载

发生在同一个类中（或者父类和子类之间），方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同。

《Java 核心技术》这本书是这样介绍重载的：
如果多个方法(比如 StringBuilder 的构造方法)有相同的名字、不同的参数， 便产生了重载。

StringBuilder sb = new StringBuilder();StringBuilder sb2 = new StringBuilder("HelloWorld");

编译器必须挑选出具体执行哪个方法，它通过用各个方法给出的参数类型与特定方法调用所使用的值类型进行匹配来挑选出相应的方法。 如果编译器找不到匹配的参数， 就会产生编译时错误， 因为根本不存在匹配， 或者没有一个比其他的更好(这个过程被称为重载解析(overloading resolution))。

Java 允许重载任何方法， 而不只是构造器方法。

综上：重载就是同一个类中多个同名方法根据不同的传参来执行不同的逻辑处理。

重写
重写发生在运行期，是子类对父类的允许访问的方法的实现过程进行重新编写。

  1. 方法名、参数列表必须相同，子类方法返回值类型应比父类方法返回值类型更小或相等，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类。
  2. 如果父类方法访问修饰符为 private/final/static 则子类就不能重写该方法，但是被 static 修饰的方法能够被再次声明。
  3. 构造方法无法被重写

综上：重写就是子类对父类方法的重新改造，外部样子不能改变，内部逻辑可以改变。
在这里插入图片描述
方法的重写要遵循“两同两小一大”（以下内容摘录自《疯狂 Java 讲义》）：
1.“两同”即方法名相同、形参列表相同；
2. “两小”指的是子类方法返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等；
3. “一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。

⭐️ 关于 重写的返回值类型 这里需要额外多说明一下，上面的表述不太清晰准确：如果方法的返回类型是 void 和基本数据类型，则返回值重写时不可修改。但是如果方法的返回值是引用类型，重写时是可以返回该引用类型的子类的。

public class Hero {    public String name() { return "超级英雄";    }}public class SuperMan extends Hero{    @Override    public String name() { return "超人";    }    public Hero hero() { return new Hero();    }}public class SuperSuperMan extends SuperMan {    public String name() { return "超级超级英雄";    }    @Override    public SuperMan hero() { return new SuperMan();    }}

👉什么是可变长参数？

从 Java5 开始，Java 支持定义可变长参数，所谓可变长参数就是允许在调用方法时传入不定长度的参数。就比如下面的这个 printVariable 方法就可以接受 0 个或者多个参数。

public static void method1(String... args) {   //......}

另外，可变参数只能作为函数的最后一个参数，但其前面可以有也可以没有任何其他参数。

public static void method2(String arg1, String... args) {   //......}

遇到方法重载的情况怎么办呢？会优先匹配固定参数还是可变参数的方法呢？

答案是会优先匹配固定参数的方法，因为固定参数的方法匹配度更高。

我们通过下面这个例子来证明一下。

public class VariableLengthArgument {    public static void printVariable(String... args) { for (String s : args) {     System.out.println(s); }    }    public static void printVariable(String arg1, String arg2) { System.out.println(arg1 + arg2);    }    public static void main(String[] args) { printVariable("a", "b"); printVariable("a", "b", "c", "d");    }}输出：ababcd

另外，Java 的可变参数编译后实际会被转换成一个数组，我们看编译后生成的 class文件就可以看出来了。

public class VariableLengthArgument {    public static void printVariable(String... args) { String[] var1 = args; int var2 = args.length; for(int var3 = 0; var3 < var2; ++var3) {     String s = var1[var3];     System.out.println(s); }    }    // ......}

👉Java 中的几种基本数据类型了解么？

Java 中有 8 种基本数据类型，分别为：
6 种数字类型：
4 种整数型：byte、short、int、long
2 种浮点型：float、double
1 种字符类型：char
1 种布尔型：boolean。

这 8 种基本数据类型的默认值以及所占空间的大小如下：
在这里插入图片描述
对于 boolean，官方文档未明确定义，它依赖于 JVM 厂商的具体实现。逻辑上理解是占用 1 位，但是实际中会考虑计算机高效存储因素。

另外，Java 的每种基本类型所占存储空间的大小不会像其他大多数语言那样随机器硬件架构的变化而变化。这种所占存储空间大小的不变性是 Java 程序比用其他大多数语言编写的程序更具可移植性的原因之一（《Java 编程思想》2.2 节有提到）。
注意：

  1. Java 里使用 long 类型的数据一定要在数值后面加上 L，否则将作为整型解析。
  2. char a = 'h’char :单引号，String a = “hello” :双引号。

这八种基本类型都有对应的包装类分别为：Byte、Short、Integer、Long、Float、Double、Character、Boolean 。

👉基本类型和包装类型的区别？

  • 包装类型不赋值就是 null ，而基本类型有默认值且不是 null。
  • 包装类型可用于泛型，而基本类型不可以。
  • 基本数据类型的局部变量存放在 Java 虚拟机栈中的局部变量表中，基本数据类型的成员变量（未被 static 修饰 ）存放在 Java 虚拟机的堆中。包装类型属于对象类型，我们知道几乎所有对象实例都存在于堆中。
  • 相比于对象类型， 基本数据类型占用的空间非常小。
  • 为什么说是几乎所有对象实例呢？ 这是因为 HotSpot 虚拟机引入了 JIT 优化之后，会对对象进行逃逸分析，如果发现某一个对象并没有逃逸到方法外部，那么就可能通过标量替换来实现栈上分配，而避免堆上分配内存。

⚠️注意 ： 基本数据类型存放在栈中是一个常见的误区！ 基本数据类型的成员变量如果没有被 static 修饰的话（不建议这么使用，应该要使用基本数据类型对应的包装类型），就存放在堆中。

class BasicTypeVar{  private int x;}

👉包装类型的常量池技术了解么？

Java 基本类型的包装类的大部分都实现了常量池技术。

Byte,Short,Integer,Long 这 4 种包装类默认创建了数值 [-128，127] 的相应类型的缓存数据，Character 创建了数值在 [0,127] 范围的缓存数据，Boolean 直接返回 True or False。

Integer 缓存源码：

public static Integer valueOf(int i) {    if (i >= IntegerCache.low && i <= IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)];    return new Integer(i);}private static class IntegerCache {    static final int low = -128;    static final int high;    static { // high value may be configured by property int h = 127;    }}

Character 缓存源码:

public static Character valueOf(char c) {    if (c <= 127) { // must cache      return CharacterCache.cache[(int)c];    }    return new Character(c);}private static class CharacterCache {    private CharacterCache(){}    static final Character cache[] = new Character[127 + 1];    static { for (int i = 0; i < cache.length; i++)     cache[i] = new Character((char)i);    }}

Boolean 缓存源码：

public static Boolean valueOf(boolean b) {    return (b ? TRUE : FALSE);}

如果超出对应范围仍然会去创建新的对象，缓存的范围区间的大小只是在性能和资源之间的权衡。

两种浮点数类型的包装类 Float,Double 并没有实现常量池技术。

Integer i1 = 33;Integer i2 = 33;System.out.println(i1 == i2);// 输出 trueFloat i11 = 333f;Float i22 = 333f;System.out.println(i11 == i22);// 输出 falseDouble i3 = 1.2;Double i4 = 1.2;System.out.println(i3 == i4);// 输出 false

下面我们来看一下问题。下面的代码的输出结果是 true 还是 false 呢？

Integer i1 = 40;Integer i2 = new Integer(40);System.out.println(i1==i2);

Integer i1=40 这一行代码会发生装箱，也就是说这行代码等价于 Integer i1=Integer.valueOf(40) 。因此，i1 直接使用的是常量池中的对象。而Integer i2 = new Integer(40) 会直接创建新的对象。

因此，答案是 false 。你答对了吗？

记住：所有整型包装类对象之间值的比较，全部使用 equals 方法比较。

在这里插入图片描述

👉自动装箱与拆箱了解吗？原理是什么？

什么是自动拆装箱？
装箱：将基本类型用它们对应的引用类型包装起来；
拆箱：将包装类型转换为基本数据类型；
举例：

Integer i = 10;  //装箱int n = i;   //拆箱

上面这两行代码对应的字节码为：

   L1    LINENUMBER 8 L1    ALOAD 0    BIPUSH 10    INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;    PUTFIELD AutoBoxTest.i : Ljava/lang/Integer;   L2    LINENUMBER 9 L2    ALOAD 0    ALOAD 0    GETFIELD AutoBoxTest.i : Ljava/lang/Integer;    INVOKEVIRTUAL java/lang/Integer.intValue ()I    PUTFIELD AutoBoxTest.n : I    RETURN

从字节码中，我们发现装箱其实就是调用了 包装类的valueOf()方法，拆箱其实就是调用了 xxxValue()方法。
因此，

  • Integer i = 10 等价于 Integer i = Integer.valueOf(10)
  • int n = i 等价于 int n = i.intValue();
    注意：如果频繁拆装箱的话，也会严重影响系统的性能。我们应该尽量避免不必要的拆装箱操作。
private static long sum() {    // 应该使用 long 而不是 Long    Long sum = 0L;    for (long i = 0; i <= Integer.MAX_VALUE; i++) sum += i;    return sum;}

👉面向对象和面向过程的区别

两者的主要区别在于解决问题的方式不同：

  • 面向过程把解决问题的过程拆成一个个方法，通过一个个方法的执行解决问题。
  • 面向对象会先抽象出对象，然后用对象执行方法的方式解决问题。

另外，面向对象开发的程序一般更易维护、易复用、易扩展。

👉成员变量与局部变量的区别

  • 语法形式 ：从语法形式上看，成员变量是属于类的，而局部变量是在代码块或方法中定义的变量或是方法的参数；成员变量可以被public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。
  • 存储方式 ：从变量在内存中的存储方式来看,如果成员变量是使用 static 修饰的，那么这个成员变量是属于类的，如果没有使用 static 修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
  • 生存时间 ：从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动生成，随着方法的调用结束而消亡。
  • 默认值 ：从变量是否有默认值来看，成员变量如果没有被赋初始值，则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。

👉创建一个对象用什么运算符?对象实体与对象引用有何不同?

new 运算符，new 创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。

一个对象引用可以指向 0 个或 1 个对象（一根绳子可以不系气球，也可以系一个气球）;一个对象可以有 n 个引用指向它（可以用 n 条绳子系住一个气球）。

网络标签：

相关问题