Java 是值传递还是引用传递
「基本类型值传递、对象引用传递」—— 这是一个错误答案。
Copy the prompt, then pick a model. It plays the interviewer and asks you through it scene by scene instead of handing you the answer.
On a phone with the app installed, the system opens the app directly. Links cannot open external apps inside WeChat — open it in a browser first.
The copied text ends with the answer key the model grades you against. Don't read it yourself first — working it out on your own is the point.
这一问超高频、也极易答错，而它真正的价值是：答对之后还能一路往下问。
第二幕要你解释一个具体现象 —— 为什么在方法里改了对象的字段，外面看得见；换成重新赋值，外面就看不见了。第三幕落到栈帧上：调用那一刻到底复制了什么。
第四幕给一段代码让你先说输出再说理由，第五幕问：为什么用这门语言写不出一个通用的 swap。按 Java 讲，你说了别的语言它就按那家的求值策略讲。
What this one leans on
This prompt in the repo (the answer key is at the end of that file — you'll see it)
Have you done this one?
Sign in to mark this one as practised — next time you come back you'll see when you did it.
Notes from people who did this one
How to use this
This set interrogates rather than teaches. It is a mock interview: running out of answers is a normal outcome, and it will not cover for you or finish your sentence when you trail off. If you want to understand a topic rather than rehearse for an interview, go to Computer systems, Databases or Algorithms — those guide you instead.
How one stock question fills forty minutes: the five-layer ladder
- L1 · Definition — what each term means, list the differences. Can't answer: you never learned it.
- L2 · Mechanism — which structure, which step actually produces that difference. Can't answer: you memorised the conclusion only.
- L3 · Numbers — by how much? How many microseconds, how many times, how many I/Os. Can't answer: you've never done it hands-on.
- L4 · Choice — given a concrete scenario, which one, at what cost, and when is that choice wrong. Can't answer: you can't apply it.
- L5 · Limits — under what conditions does everything you just said stop holding. Can't answer: you know it all, but you don't really understand it.
The bar: L4 is what passes an interview, L5 is what counts as really understanding it, and anything that stops at L1 is recorded as memorised.
Six scenes — the first and last are unique to this set
- In scene one it does not interrupt, comment or hint. You deliver the version you already have, start to finish, and it records that as your baseline. The silence is deliberate — it is listening, it just isn't correcting you yet.
- The middle four scenes work down the ladder; scene three, mechanism and numbers, is the main battleground.
- The last scene puts sixty seconds on the clock and makes you deliver it again, side by side with your opening version — because what an interview asks you to hand over isn't "I understand it", it's a sentence you can actually say out loud.
How to start
- Pick one, open it, copy the prompt.
- Paste it into a brand-new conversation, say nothing, and wait for its first question.
- Then answer like you would in an interview: deliver your memorised version in one go. It's fine if it's rough — that's the baseline it compares against at the end.
- After that it starts pressing. Running out of answers is a normal outcome: this isn't study material, it's a mock interview.
Five commands you can call out at any time
跳过move to the next scene now提示give me a hint, not the answer直说吧spell the full answer out重讲jump straight to the last scene, re-record the sixty-second version and compare it with the opening one复盘jump to the wrap-up and print the review card
Three traps
- The prompt you copy has the answer key at the end — don't read it first. One of its columns is the "recital fingerprints": the exact sentences you're most likely to blurt out. Read them and there's nothing left to drill.
- Don't hand over adjectives where a number belongs. "Much faster", "barely any overhead" — it stops you and asks for the figure. A conclusion you can't put an order of magnitude on is recorded as memorised.
- The last two groups are language-bound: do the Java group if you write Java, the Go group if you write Go. They are not translations of each other — each picks its own questions — so there's no need to do both.
Interviewing for a backend role next week? Take process versus thread, TCP versus UDP, why B+ trees, isolation levels, the three cache failure modes, and idempotency — the six most frequent, with almost no overlap. Been hammered in interviews and want to find the gaps? Start with "from URL to rendered page": it exposes every weak spot horizontally, and you can pick your next ones from what it turns up.
Sign in to write a note.