1) The jury doesn't decide whether Java interfaces are protectable code versus unprotectable specifications. That's a legal determination for a judge. The judge deals in these sorts of general or philosophical principles. The jury deals in specific facts.
2) Technical distinctions aren't necessarily legally operative distinctions. The law tends to be based on things that are within typical peoples' experience.
3) You have days of peoples' undivided attention to explain things to a jury.
So in this example, the judge would be the one to decide whether Java interfaces, in principle, were protectable or not. The jury would decide things like the fact of whether Google copied Oracle's interfaces. Someone at Google might testify that they never saw Oracle's interfaces, and came up with them independently. The jury will decide whether they believe his story. They'll be shown code. They don't have to understand how it works to know whether the same variable names, etc, are being used.
Let's use the Java interface construct as an example. It's expressed as code, but is it really just code? Isn't it really a spec other classes must implement in order to become valid Java code, expressed in code for the benefit of the compiler?
I consider my own unit tests as part of the documentation of the systems I deliver. There is little question as to whether the doctests are documentation, but testing them makes them execute. What are they then?
What if my code, during startup, reads UML files and compiles them to behavior that becomes part of the system during execution?
And my analogy works both ways - the opinion of a dozen theoretical physicists on birdseeds is equally relevant.