一道面试题引发的思考:(1)

最新推荐文章于 2024-09-30 11:43:18 发布
最新推荐文章于 2024-09-30 11:43:18 发布
阅读量89 收藏
点赞数
文章标签： 面试 java
原文链接：https://segmentfault.com/a/1190000003787431
版权

这是网易2015校招Java面试题,直接上题目。

题目

package com.mousycoder.staticTest;

public class HelloB extends HelloA {
    public HelloB() {
        System.out.println("HelloB");
    }

    {
        System.out.println("I’m B class");
    }
    static {
        
        System.out.println("static B");
    }

    public static void main(String[] args) {
        new HelloB();
    }
}

class HelloA {
    public HelloA() {
        System.out.println("HelloA");
    }

    {
        System.out.println("I’m A class");
    }
    static {
        System.out.println("static A");
    }
}

答案

static A
static B
I’m A class
HelloA
I’m B class
HelloB()

考察点

  • static 相关知识

  • 非静态代码块相关知识

  • 类加载顺序

解析

  • 存在父子关系，又有静态代码块，先执行父类静态代码块，再执行子类静态代码块，故打印static A static B

  • 存在父子关系，又有非静态代码块，先执行父类非静态代码块，父类构造器，再执行子类非静态代码块，子类构造器故打印I'm A class HelloA I'm B class HelloB

结论

  • 静态代码块=>非静态代码块=>构造方法

  • 父子关系：父类静态代码块=>子类静态代码块=>父类非静态代码块=>父类构造函数=>子类非静态代码块=>子类构造函数

扩展知识

非静态代码块

{ 
   System.out.println("I'm B class");
}

这个叫做非静态代码块，也叫普通代码块，在每个类创建前(构造函数之前)调用 ，不创建对象的时候，不被调用，代码块中定义的变量都是局部变量，如果有父子关系的话，先执行父类的，再执行子类的。非静态代码块属于对象，静态代码块属于类。

package com.mousycoder.staticTest;

public class Child extends Father{
    
    static {
        System.out.println("child-->static");
    }
    
    private int n = 20;
    
    {
        System.out.println("Child Non-Static");
        n = 30;
    }
    
    public int x = 200;
    
    public Child() {
        this("The other constructor");
        System.out.println("child constructor body: " + n);
    }
    
    public Child(String s) {
        System.out.println(s);
    }
    
    public void age() {
        System.out.println("age=" + n);
    }
    
    public void printX() {
        System.out.println("x=" + x);
    }
    
    public static void main(String[] args) {
        new Child().printX();
    }
}

class Father {
    
    static {
        //System.out.println("n+"+n);
            //当n定义在下面时，会提示Cannot reference a field before it is defined，
            //所以必须把n定义移到上面才可以输出
        System.out.println("super-->static");
    }
    
    public static int n = 10;
    public int x = 100;
    
    public Father() {
        System.out.println("super's x=" + x);
        age();
    }
    
    {
        System.out.println("Father Non-Static");
    }
    
    public void age(){
        System.out.println("nothing");
    }
}

结果:

super-->static
child-->static
Father Non-Static
super's x=100
age=0
Child Non-Static
The other constructor
child constructor body: 30
x=200

解析：

  • 先执行静态代码块，有父子关系，先执行父类静态代码块，打印super-->static

  • 执行子类静态代码块，打印child-->static

  • 实例化子类的时候，先实例化父类，在调用父类构造方法之前，先调用父类非静态代码块，打印Father Non-Static

  • 实例化父类，调用父类构造方法，执行第一句 System.out.println("super's x=" + x); 在调用构造方法之前，成员变量x 已经被赋值为100，打印super's x=100

  • 执行age()方法，因为main方法中真正实例化的是子类，子类又重写了父类的age方法，所以执行子类的age方法，此时子类还没初始化，默认n=0 ,打印age=0

  • 实例化子类，调用子类构方法之前，调用子类非静态代码块，打印Child Non-Static

  • 调用子类构造方法，执行this("The other constructor"),调用子类的Child（String s），打印The other constructor

  • 执行System.out.println("child constructor body: " + n); 初始化之前 成员变量初始值为20，执行完非静态代码块后 n被修改成30 ，所以这里n =30 打印child constructor body: 30

  • 执行printX()方法，打印x = 200

注意点：

  • 子类重写父类的方法

  • 虽然非静态代码块里是局部变量，但是可以改变类的成员变量的值

静态代码块

static {
  System.out.println("static B");
}

属于静态代码块，使用场景：1.想用一个存储区域来保存一个特定的数据，不想创建对象 2.创建一个特殊的方法，与这个类的对象没有关联，即使没创建对象，也可以调用

静态变量

静态变量也叫做static变量，静态变量和非静态变量的区别在于静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当类初次加载时会被初始化，而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响 好处：1.可以用类名直接访问(方便),也可以用对象访问(不推荐) 2.只分配一次内存，节省空间

静态方法

静态方法就是不会被this和super的方法。特点：1.在static方法内部不能调用所属类的实例变量和实例方法（非静态方法），但是可以在没有创建任何对象的前提下，仅仅通过类本身(类名)来调用static方法 2.main方法就是static 方法，因为执行main方法的时候，没有创建任何对象，只能通过类名去访问 3.没有显示声明，类的构造器也是静态方法,参考：实例构造器是不是静态方法？
常见的错误Cannot make a static reference to the non-static field 就是静态方法中引用了非静态的的变量，静态变量是不依赖对象而存在的，非静态变量是依赖对象而存在的

示例：非静态方法可以访问静态变量、方法，静态方法是不可以访问非静态变量，方法

package com.mousycoder.staticTest;

public class Test {
    
    private static String str1 = "111";
    
    private String str2 = "ddd";
    
    
    public Test() {
    }
    
    public  void print1() {
        System.out.println(str1);
        System.out.println(str2);
        print1();
    }
    
    
    public static void print2(){
        System.out.println(str1);
        System.out.println(str2);  //报错  Cannot make a static reference to the non-static field
        print1(); //报错
    }

}

静态代码块

由static 关键字修饰的代码块叫做静态代码块，特点：用于提高程序性能，类在初始化的时候，JVM会按照他们在类中出现的顺序加载static 代码块，并且只会执行一遍

示例：只生成一个String s 对象和一个String m 对象

package com.mousycoder.staticTest;

import java.util.Date;
public class HelloStatic {
    
    public static String s ;
    
    public static String m ;
    
    static {
        s = new String("hell");
        m = new String("0");
    }
        String hello() {
            String s = "hell";
            String m = "o";
            return s + m;
        }
        
        public static void main(String[] args) {
            Date start = new Date();
            for (int i = 0; i < 1000000000 ; i++) {
                HelloStatic h = new HelloStatic();
                h.hello();
            }
            Date end = new Date();
            System.out.println(end.getTime() - start.getTime());
        }

}

耗时：12ms

示例： 生成N个String s和String m对象

package com.mousycoder.staticTest;

import java.util.Date;

public class Hello {
        
        String hello() {
            String s = new String("hell");
            String m = new String("o");
            return s + m;
        }
        
        public static void main(String[] args) {
            Date start = new Date();
            for (int i = 0; i < 1000000000; i++) {
                Hello h = new Hello();
                h.hello();
            }
        
            Date end = new Date();
            System.out.println(end.getTime() - start.getTime());
        }
        
}

所用时间 9645ms

公共的变量应该放到static里初始化，有利于提高效率

静态变量访问权

static 变量是被所有对象共享的，只要该对象有权限，就可以访问该变量

package com.mousycoder.staticTest;

public class Main {

    static int value = 33;
 
    public static void main(String[] args) throws Exception{
        new Main().printValue();
    }
 
    private void printValue(){
        int value = 3;
        System.out.println(this.value);
    }
}

该输出为：33 ,new Main()创建了一个对象，通过this.value是访问的该对象的value 而int value = 3 是局部变量，并不是和该对象相关联的，因为static变量是共享的，所以该对象可以访问到value 值为 33 ，把this 去掉 则结果为 3

静态变量相关面试题

package com.mousycoder.staticTest;

public class Test {
    Person person = new Person("Test");
    static{
        System.out.println("test static");
    }
     
    public Test() {
        System.out.println("test constructor");
    }
     
    public static void main(String[] args) {
        new MyClass();
    }
}
 
class Person{
    static{
        System.out.println("person static");
    }
    public Person(String str) {
        System.out.println("person "+str);
    }
}
 
 
class MyClass extends Test {
    Person person = new Person("MyClass");
    static{
        System.out.println("myclass static");
    }
     
    public MyClass() {
        System.out.println("myclass constructor");
    }
}

顺序是：

test static
myclass static
person static
person Test
test constructor
person MyClass
myclass constructor

执行顺序

test static =>new MyClass() => myclass static => new MyClass() => person static => Person person = new Person("Test") => person Test => Person person = new Person("Test") => test constructro => Person person = new Person("Myclass") => person MyClass => Person person = new Person("MyClass") => myclass contructor

说明：

  • 执行main方法，实例化MyClass

  • 发现MyClass 有父类Test，首先实例化Test

  • 加载Test类，这个时候会执行static方法，打印 test static ,

  • 然后要实例化MyClass 类，加载MyClass类，执行static方法，打印myclass static

  • 在所有类按照顺序都加载完毕后，开始一个一个实例化类，先实例化父对象 Test类

  • 在实例化之前，要先初始化成员变量，这个时候会执行Person p = new Person("Test"),这个时候发现Person类还没有被加载过，因此先加载Person类

  • 执行Person类的static方法，打印person static 接着实例化Person p = new Person("Test") 调用Person的构造方法，打印person Test

  • 然后开始调用Test的构造方法,打印test constructor,Test类初始化完毕

  • 开始实例化Myclass类，首先还是初始化MyClass的成员变量 ,因为Person已经加载过了,所以只执行一遍,只需根据类的模板执行其构造方法，来复制成另外一个副本,此时打印person MyClass

  • 最后执行Myclass的构造方法，打印myclass constructor

总结：

非静态代码块=>初始化成员变量=>非静态代码块=>构造器方法

感谢您的耐心阅读，如果您发现文章中有一些没表述清楚的，或者是不对的地方，请给我留言，你的鼓励是作者写作最大的动力，
如果您认为本文质量不错，读后觉得收获很大，不妨小额赞助我一下，让我更有动力继续写出高质量的文章。

  • 支付宝

  • 微信

作 者 : @mousycoder

原文出处 : http://mousycoder.com/2015/10/12/thinking-of-interview-question-1/

创作时间：2015-7-1

更新时间：2015-10-14

weixin_33802505
关注
一道进程相关面试题引发的思考
rlk8888的博客
11-19 257
“小明同学最近贼郁闷，去年玩比特币亏得一塌糊涂，想在股市里翻盘，听信大V推荐的股票，买了康美和长生生物，被A股狠狠的收割了一把。本想今年好好工作，谁知道遇上了O记大裁员。虽然拿了N+6，但是还是要找工作养家糊口啊！只能硬着头皮去面试了，还好，面试题目都不难，因为小明认真看过《奔跑吧》” 01 面试题目 — 在一个双核处理器的系统中，在shell界面下运行test程序。CPU0的就绪队列上有4个进程，而CPU1的就绪队列有1个进程。假设test程序和这个5个进程的nice值都是为0。 .
一道面试题引发的对javascript类型转换的思考
11-27
最近群里有人发了下面这题： 实现一个函数，运算结果可以满足如下预期结果： add(1)(2) // 3 add(1, 2, 3)(10) // 16 add(1)(2)(3)(4)(5) // 15 对于一个好奇的切图仔来说，忍不住动手尝试了一下，看到题目首先想到...
Java基础（3）继承
qq_43049006的博客
02-12 175
继承 1、关键字：extends 2、格式 //定义父类的方式：（一个普通的类的定义） public class 父类名{ //.... } //定义子类的格式： public class 子类名 extends 父类名{ //... } 3、继承中变量的重名 在父子继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方式： 1、直接通过子类对象访问： （该对象被创...
一道js面试题引发的思考
云雨之石的博客
05-01 158
这几天我们同学之间讨论了一个面试题，这里来总结一下。 这里是这道面试题： function f() { return f; } console.log(new f() instanceof f); 首先，它的答案是false。 最开始自己思考的时候，就在想 new f() 和 f 返回的结果都是什么，可以看出，最后返回的都是f函数本身，这个时候就理所当然的认为结果是true了。 但这道题其实是考察instanceof这个api的。这个api就是来判断左边是否是右边的实例，是即返回true，不是即返回fa
一道面试题引发的思考：理解 new 运算符
weixin_33955681的博客
12-20 116
今天看到一道面试题，如下，问: 实例化 Person 过程中，Person返回什么（或者 p 等于什么）？ function Person(name) { this.name = name return name; } let p = new Person('Tom'); 复制代码说实话，第一反应我以为值为 'Tom'，等到我把代码丢到控制台一输出，才明白我错了。天呐，new运算...
一道面试题引发的思考
山禾说
07-09 325
背景介绍 这里给大家分享一道很有趣的面试题。 面试过程 面试官：redis我看你有使用过，说一下redis的基本类型吧？ A：String，Hash，Set，List，Zset。 面试官：redis中string类型的实现有没有了解过？ A：（喵喵喵？） 面试官：回家等通知吧。 面试反思 作为一个爱学习的好孩子，遇到不会的当然要努力学习了，于是查阅了良多资料，算是把这个问题给搞明白了，下面且听我慢...
一道面试题引发的思考：char类型能否存储汉字
UnknownZYB的博客
07-19 425
阿里的一道电面题：char类型能否存储汉字 百度随便搜一下答案就应该能出来能存储汉字。下面看下何为char char 类型想必大家都比较熟悉了，java的八大类型之一，能存储两个字节，看情况讲道理应该能存储汉字，答案也是能的。 char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中当然可以存储汉字。 unicode如其名字，统一码，万国码 国际通用码，它的出现就是为了屏蔽各个国家不同编码的差异，unicode用两个字节表示一个字符，仿佛一切问
一道前端面试题引发的思考
微赚开发者技术分享博客
10-31 222
一、前言 昨天被朋友问道了一个关于js的题目，据他说是网上的一道 面试题，我看了一下。忽然想起了以前自己参加面试时候的一些场景： 某一天收到了一个野鸡公司的面试通知，可还没有工作的我依然心花怒放，遂梳妆打扮，沐浴焚香，经过几个小时的精心准备，怀揣着一颗赤诚的心，提前两个小时来到面试地点。面试地点是一段繁华地段的CBD，走出电梯，高大上的装修瞬间让我有了种刘姥姥进大观园的感觉，公司气氛异常热闹，每个...
一道面试题引发的思考:(2)
weixin_34228387的博客
09-22 65
题目 答案：D 分析 Java 异常的结构体系 Throwable 类包含了其线程创建时线程执行堆栈的快照，包含了给出有关错误更多的消息字符串，有颜色的代表运行时异常，非checked exception，可以不try catch ，则由jvm处理，白色的异常代表checked exceptions必须由try-catch捕获。 非R...
一道Java面试题引发的思考
YangLe
10-25 401
转载请注明出处 本文出自 容华谢后的博客 目录0.写在前面1.题目2.栈内存、堆内存栈内存（stack）堆内存（heap）3.基本类型数据、对象的内存分配基本类型数据对象4.值传递、引用传递值传递：引用传递：5.String类型String str = “a”;String str = new String("a");6.解题分析7.写在最后 0.写在前面 这两天做了一道常见的Java面试题，...
一道值得深入思考的iOS面试题详解
08-26
本文将深入探讨一道具有挑战性的iOS面试题，该题目涉及到Objective-C的内存管理、类对象、消息传递以及运行时机制。问题的核心在于如何理解并分析一段看似错误但实际上可以正确运行的代码。 首先，让我们回顾一下...
大厂面试真题-ConcurrentHashMap怎么保证的线程安全？
个人专长：数据结构和算法、大数据、数据库、主流框架
09-27 865
ConcurrentHashMap是Java中的一个线程安全的哈希表实现，它通过一系列精妙的机制来保证线程安全。
LeetCode 面试经典150题 66.加一
qq_57349657的博客
09-27 344
加一
8月面试总结
一起学习
09-27 1008
从7月中旬辞职，中间玩儿了接近两周，到8月中下旬找到工作，对之前部分面试进行一下总结（包括我朋友面试的公司）。base成都，22届，普本 。祝大家找到自己满意的工作。
java中线程的生命周期，线程有哪些状态？-----面试题分享
Yluciud的博客
09-26 439
线程的状态转换是由JVM控制的，并且随着程序的执行，线程可以在这些状态之间进行切换。例如，一个线程可以从新建状态过渡到可运行状态，然后可能会因为调用。方法而进入计时等待状态，之后又回到可运行状态继续执行，直到最终到达终止状态。在Java中，线程的生命周期指的是一个。Java中的线程状态是通过。线程从创建到最终消亡的过程。
面试中考察栈和队列的经典算法题
最新发布
A Charmer 的博客
09-30 1266
通过以上对栈和队列面试常见题目的分析与解答，希望能帮助你更好地理解和掌握这两种数据结构在面试中的应用，提高你在数据结构方面的解题能力和应对面试的信心。在实际准备面试过程中，建议你多做练习，深入理解每种数据结构的特点和操作方法，以便能够灵活运用它们解决各种问题。如果你还有其他问题或需要进一步的解释，欢迎随时提问。
前端面试经验总结2(经典问题篇)
rita_0567的博客
09-28 968
因为计算机技术的快速发展，所以程序员如果不能保持对技术的持续性学习，会更容易的被淘汰，我从来不觉得程序员是一个轻松的职业，但是程序员是我最热爱的职业，我做好了充足的准备让自己能够长期在前端行业深耕。既要扩充自己的知识宽度，同时又不要一味的追求学习的东西越多越来，今天学两天这个，明天学两天那个，工作中又没有得到使用的话，很快也都会忘记的。了解，贵公司主要是在xxx行业从事xxx业务，贵公司所处的行业是我非常看好的，我感觉贵公司的氛围我很喜欢，比如xxxx。遇到了哪些挑战，我如何在不利的条件下成长起来的。
Java面试：ArrayList 和 LinkedList 的区别是什么？谈谈你对ArrayList和LinkedList的理解
智通全网络工作室的博客
09-26 1811
ArrayList是基于动态数组实现的 List，其中元素的索引是基于顺序的。它提供了按索引访问元素的快速方式，适合需要频繁读取元素的场景。ArrayList 和 LinkedList 各有优缺点，选择合适的集合类将直接影响程序的性能和可维护性。了解它们的特性及适用场景可以帮助开发者更有效地管理数据结构，从而优化应用程序的性能。希望本篇博客能够帮助你更好地理解 ArrayList 和 LinkedList，并在未来的项目中作出明智的选择！
Java面试题全攻略：覆盖十大专题
Java面试题大全是一份详尽的Java技术面试指南，分为十个主要部分，涵盖了Java编程的各个方面，旨在帮助求职者准备全面的面试。以下是各部分的主要知识点： 1. **Core Java** (1-95题，1-24页): - 基础及语法 (1-61...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值