有一个代码：
try:
def f():
print('hi')
print('bye) # здесь намеренно пропущен закрывающий апостроф
except:
pass
f()
实验的目的是找出当函数f的逐行定义（def）在运行时失败时调用函数时会发生什么。假设定义 (def) 作为语句失败，因此f不会在模块的全局范围内创建函数对象和对它的引用。因此，假设调用f()将导致引发 NameError。
事实上，事实证明在启动时抛出了一个 SyntaxError，并且没有打印 'hi' 行。我认为要么是blocktry没有捕捉到异常，要么是整个模块的bit-code无法创建，因此原则上没有启动，操作员def甚至都没有开始工作（实际上，就像随后的调用一样运算符f()）。
问题：请帮我弄清楚为什么电话f()打不通。也许我上面的一个假设是正确的，在这种情况下，我希望看到文档的链接详细解释正在发生的事情。
我在 Wordpress 上创建了一个新站点，注意到一些我从未注意到的事情：如果您在键盘上按 Tab，则会弹出一个按钮（左上角，“转到内容”）：
该按钮指向链接 mySite.ru/#main，即 滚动到我网站的主标签，我什至没有这样做。据我了解，表格会遍历网站的活动元素，其中第一个是不可见的，但重点显示。我可能弄错了，我很少翻遍这些网站。
请帮助我了解此按钮的性质，以及如何从网站上完全正确地删除它，而不仅仅是伪装它。
（开发使用：PHP 8.0、WP 6.0、Elementor over OceanWP 主题）
与 Java 的 Enterprise 组件完全混淆。
我是否正确理解 JEE 和 Spring 是这样的东西，我可以使用其中之一并一次获得数百辆好（！）自行车？那些。许多事情会在两条线上完成并且是安全的，可靠的等等？
需要建议：首先要学习什么？我真的不想听到 JEE 精神的东西，学习，你会理解原理，然后接受 Spring，除非现实中并非如此，我对此表示怀疑。似乎您可以学习 Spring，开始了解 AOP（面向方面的编程）并进入特定于 Spring 的工具，而无需学习 JEE。熟悉 Java SE，了解 servlet 的基础知识等就足够了。
是否可以只做 JEE 并用它来编写好的网络应用程序？例如，是否有可能仅在 JEE 的帮助下建立可靠的在线商店？那些。没有春天有好的（！）生活吗？
在这一点上，指出你的提示，以某种方式澄清我脑海中的情况。
BloodCell在一个很大很长的通用类层次结构中有一个类。重要提示：所有类都以自己的方式定义 toString()。祖先类的源代码不可用。
public class BloodCell /*...*/ {
// много кода
public String objToString() {
return Object.super.toString(); // ALARM
}
}
class Tester {
public static void main(String[] args){
var bc = new BloodCell();
System.out.println(bc.objToString());
}
}
非常渴望得到根发出的结果toString()。那些。我想在逻辑地址空间中查看对象的地址。
问：怎么办？
注意：带有注释“ALARM”的行是虚构的。我想要类似的东西。
请解释一下为什么当你在控制台输入字母't'然后输出System.in.read()andnew BufferedReader(new InputStreamReader(System.in)).read()时，当转换为type时你得到相同的结果int，即：116。毕竟字节流的标准read()必须读取一次一个字节，并返回零（作为两字节“t”记录的第一个字节），字符 BufferedReader 正确返回所有内容。
怎么了？
你能解释一下为什么吗，如果我依次按下以下键：{ 、、、、、、} ，a然后我会看到一个非常奇怪的输出，它将先前的输入与当前的输入分开约 5 个换行符？enterbenterqenter
编码：
BufferedReader in = new BufferedReader (new InputStreamReader(System.in));
char c;
do {
c = (char)in.read();
System.out.println(c);
} while (c!='q');
期待：
a
a
b
b
q
现实：
a
a
b
b
q
q
即使你认为点击的enter时候也是直接发送\n到流中，那么输入第一个字母后的输出应该是这样的：
a
a
b...
那些。还从哪里展示了一条线的拆除？...
这段代码会给出预期的结果也很有趣：
BufferedReader in = new BufferedReader (new InputStreamReader(System.in));
String s;
do {
s = in.readLine();
System.out.println(s);
} while (!s.equals("q"));
再会！
我的工作笔记本电脑尺寸很小（如果你用尺子测量屏幕），但同时它对这种尺寸有一个疯狂的分辨率：1920x1080。那些。好吧，很多像素都适合屏幕。问题在于，当我使用 java swing 时，屏幕上显示的所有内容都非常小（假设在普通显示器上，用尺子测量时，50x20 像素的按钮为 5x2 厘米，但我有 2x0.8）。我真的不想每次都改变组件、字体和窗口本身的大小，但是这样工作很难——眼睛变坏了。
问题：如何进行一些全局重新缩放，以便在绘制时，swing 通常会放大所有内容。到处都是一个像素，比如说画 4。
另外：我在windows个性化设置中已经有了150%的缩放比例，所有的应用程序，无论是浏览器、skype、ide，一切都被缩放了，但是没有swing应用程序。甚至其他开发人员的应用程序对我来说都非常小。显然，openGL级别的java绘制了以像素为单位的所有内容，并且从OS-Windows缩放不会保存......
让我们执行以下代码：
package attempt;
import java.util.concurrent.*;
class Writer implements Runnable {
public void run() {
Main.x = 1;
// Main.secret=true;
}
}
class Reader implements Runnable {
public void run() {
// boolean unused = Main.secret;
System.out.println(Main.x);
}
}
public class Main {
public static int x = 0;
public static volatile boolean secret = false;
public static void main(String[] args){
ExecutorService exec = Executors.newSingleThreadExecutor();
exec.execute(new Writer());
exec.execute(new Reader());
exec.shutdown();
}
}
我们可以肯定地说，对于这个程序，不能保证输出会是一个，因为线程Reader'a 不一定看到Writer线程 'a 执行的操作（请参阅处理器缓存）。
问题：如果您取消注释程序的所有注释，是否可以 100% 保证程序的输出为 1？
换句话说：它会完全像这样吗？
Main.x = 1;
<< // внутри одного потока
Main.secret=true;
<< // между записью и чтением volatile
boolean unused = Main.secret;
<< // внутри одного потока
System.out.println(Main.x);
，其中“<<” - 发生在之前。
据我们所知，通过更改volatile变量，我们仍然确信将读取它的其他线程将接收到新值。这样做的原因很清楚：变量值没有被缓存（当然还有更多的事情要做，但要点是这里的重点）。所以我不清楚，但是non-volatile同步期间变量更改的可见性会发生什么？
一个可靠的消息来源说：
同步强制将数据写入主存，如果一个字段被同步方法或块完全保护，
volatile则不需要声明它以进行并发访问。
所以，问题是：这是怎么发生的，为什么我们现在不需要关键字volatile？我们需要synchronizedgetter 和 setter，还是读同步就足够了？或者也许只是写下来？
让我解释一下关于 getter 和 setter 的问题的一部分：
让代码：
class A {
int n=1;
public void change(){
while (!Thread.interrupted())
synchronized (this){
n=3*n+4;
}
}
}
在main(String[] args)与类相同的包中A：
A a = new A();
new Thread(a::change).start();
TimeUnit.SECONDS.sleep(10);
System.out.println(a.n);
这里出现了问题。
现在让我们忘记变量n可能会溢出，然后我们在 10 秒内休眠后再次变为等于 1。忘记当我们读取时n它可能处于某种“不稳定”状态。
那么，方法中是否有足够的同步change()？它是否保证推入main memory我们的变量n？那些。事实上，问题是这样的：是否真的不会发生在 10 秒的睡眠后a.n我们得到 1 的情况，因为该字段的值仍在缓存中？
如果您将最后一行更改main(String[] args)为：
synchronized (a){
System.out.println(a.n);
}
现在一切都很好，更改的可见性不会有问题吗？同步机制的这方面是如何工作的？那些。change()没有推入main memory，但同步读取所有内容都被立即推入？...或者change()同步是否足够？
在答案的附录中，我将非常感谢看到 Java 文档（翻译成俄语）中的引用以及指向它们的链接。
废话不多说，我来写代码：
public class A {
static Object f() {
String str = "hello";
str = "world"; // (1) ошибка компиляции!
class X extends Object {
public String toString() {
return str;
}
}
return new X();
}
static Object g() {
String[] s = { "hello", "silence" };
s[0] = "World"; // (2) НЕТ ошибки компиляции.
class X extends Object{
public String toString() {
return s[0];
}
}
return new X();
}
public static void main(String[] args) {
}
}
注释掉该行(1)会让编译器知道实际上str有f()final，代码将编译。您无需
注释掉该行。(2)毕竟s，对一个不会改变的数组的引用。采取s[0]然后是合法的。
问题：为什么我们要求在本地类中只使用最终或有效的最终局部变量？我可以使用数组的第一个单元格，s一切都会好起来的。
我的想法和误解：类对象的代码一般会是什么样子f().X？它将是一个带有代码的对象Object，但它的方法toString()将是这样的（伪代码）：
public String toString() {
return 0x47e9c2dd;
}
据我了解，0x47e9c2dd那条线的地址在str哪里？但是如果它是这样工作的，那么当我们创建类的实例时，我们将在这个方法中放入什么地址有什么区别f().X......
toString()我也不明白：我们通过引用局部变量str定义了一个类方法f().X，它（作为引用）会在工作完成后消失f()，但同时，从返回的对象f()包含在它的toString()引用中str（作为一个东西）。所以我们花费 RAM 来保持方法的f().X.toString()定义？....
总的来说，我很困惑，我绝对不明白这些本地类发生了什么，因为这个对 final 或有效 final 的奇怪要求被分配给了我们。请解释一下这是怎么回事...
我们在 MyClass 类中有以下代码：
private static Comparator<Map.Entry<?, ?>> comparator = MyClass::compare;
@SuppressWarnings("unchecked")
private static <K,V> int compare(Map.Entry<K, V> me1, Map.Entry<K, V> me2) {
int f = ((Comparable<K>)me1.getKey()).compareTo(me2.getKey());
if (f!=0) return f;
return ((Comparable<V>)me1.getValue()).compareTo(me2.getValue());
}
问题：是否有可能以某种方式避免将方法编写compare(me1,me2)为类方法MyClass，以便有这样的东西：
private static Comparator<Map.Entry<?,?>> comparator = (K,V,me1,me2) -> {...};
最好用 and 替换该行中的标记and ，?例如，在 class中，但非静态访问当然不可用。让现场保持静止对我来说很重要。?KVMyClass<K,V>comparator
public class Test {
public static void main(String[] args) {
Integer t = 1;
int s = 1;
System.out.println(s != t); // (*)
}
}
问题：编译器对字符串做了(*)什么？我不明白是拆包t还是打包s……
一个智者写道，“自动装箱”正在这里进行，但我无法联系到他，我不知道他为什么这样写。
我只能假设，既然在比较中我们找到了它Object some_obj是什么Integer t，那么就会有一个引用比较，并且int s它是自动打包的。
从程序的结果来看：t==s- 是的。我不知道为什么会这样......似乎是因为有一些方法 forInteger和String其他类似的方法将对象带到某种形式，用相同性质的对象替换引用，以便它==工作。比如两个“不同”的字符串，例如："Hello"和"Hello"调用此方法后进行比较==给true.
总计：我真的很想看到某种文档解释正在发生的事情，正在发生的事情，以及为什么该行的结果(*)是false，这基本上意味着：t并且s是平等的。但在什么意义上他们是平等的？链接，数字？...字节码对我没有帮助，无法理解这种比较是如何进行的。
请解释我的问题是什么，或者为什么计算结果如此奇怪？在这里，如果我们假设我们想要展示的话，甚至没有什么可以砍掉（四舍五入）的(1/3)。
据我了解：11.4+5.7 = 11.0+5.0 + 1.1 = 17.1
他们在学校是这样解释的......
public class Test{
public static void main(String[] args) {
System.out.println(11.4f+5.7f);
}
}
输出：
17.099998
请告诉我这两种情况有什么区别：
public class Main {
public static void main(String[] args) {
Class c1 = String.class; // Строка 3
Class<?> c2 = String.class; // Строка 4
System.out.println(c1 +", " + c2);
}
}
在第 3 行和第 4 行中，我们做了类似的事情，但是编译器警告说它将c1是对原始类型对象的引用，而c2对于编译器来说，它是对精细对象的良好引用Class<?>
我不明白其中的区别。原始类型和问号参数化类型都Object在运行时同样填充了一个类。是的，在编译过程中，两者都被平等地处理......
也许这只是来自 Java 的一个哲学警告，它误导了原始类型偏离了真理的道路，但Class<?>立即表明程序员的目标是将其推入c2各种类？
你能解释一下为什么//(?!)没有在行中抛出 ClassCastExeption 异常吗？There (T)is , where T=String, 这意味着 there (String) new Integer(42), 应该抛出异常...... JVM 应该转换类型，但由于某种原因它没有。然后我们看看类型t，看看Integer什么是真正的类型t。但是我们推断类型的事实表明没有抛出异常。然后程序在调用函数的地方抛出异常A.<String>f()。
顺便一提！我记得 Bruce Eckel 教过有一些 javap 反编译器，他自己使用字节码或 .class 编写程序代码……我没有研究它。如果有人精通这一点，请尝试让反编译器构建这段代码，也许它会显示那里真正发生了什么，为什么？
public class A {
public static <T> T f() {
T t = (T) new Integer(42); // (?!) ЧТО ЧЁРТ ВОЗЬМИ ЗДЕСЬ ВООБЩЕ ПРОИСХОДИТ?!
System.out.println(t.getClass());
return t;
}
public static void main(String[] args) {
System.out.println(A.<String>f()); // как здесь возможно исключение? ахаха, вы серьёзно?
}
}
新：
所以，朋友们。最常见的答案是，方法f()是已编译为常规方法的常规方法，但考虑到其调用结果被强制转换为传递为的类型这一事实<NameOfTheClass>。一切似乎都已经很好了，这个答案可以被接受，但如果它在 Java 中真的像这样工作......关键是你可以main(String[])尝试调用更具爆炸性的东西：
System.out.println(A.<Double>f());
令人惊讶的是，控制台会输出：
//output:
class java.lang.Integer
42
所以如果我们让它不可见，它看起来像这样：
System.out.println((Double)A.<Double>f());
然后尝试编译它 - 会出现错误啊哈哈哈，从那里得出的结论是它不能完全一样......
我对此的猜测是该方法println()被重载，并且在A.<String>f()它选择版本println(String arg)的情况下，并且在A.<Double>f()它理解Double没有版本并设置println(Object arg)它的情况下，因为对于我们的， 42 被(Object)Integer(42)调用.toString()并显示。
对我来说，奇怪的是，由于某种原因，在第一种情况下，当我们调用A.<String>f()它时，这里的许多人认为它是这样调用(String)A.<String>f()的，从它设置版本的位置开始println(String arg)，而第二次调用时A.<Double>f()，它确实如此没有尝试这样做(Double)A.<Double>f()，它立即选择了println(Object arg)...。
您想说整个技术非常智能，如果println()成功检查参数化/泛型函数的返回是否作为重载方法中的参数存在，则不会调用强制转换[例如，String版本println()存在，是的，让我们将输出转换Object为A.f()指定的String]，如果重载版本没有在类的类型参数中指定版本A.f()，println()那么它（编译器）离开版本println(Object)并决定不尝试(Object)(Double)A.<Double>f()做是结果f()本身Object吗？
总计：我想要解释参数化方法（类）是如何工作的，这样的解释是编译器对生成代码的操作的算法是清楚的。如果我对编译器操作的一些猜测是正确的，那么我希望他们（我的猜测）得到确认，并且非常希望（！）带有指向一些文档文件的链接！
public class GenericMethods {
public <A,B,C> void f(A x,B y, C z) {
System.out.println(x.getClass().getName());
System.out.println(y.getClass().getName());
System.out.println(Класс.вывести_то_что_видит_компилятор(y));
System.out.println(z.getClass().getName());
}
public static void main(String[] args) {
GenericMethods gm = new GenericMethods();
gm.<String,Object,GenericMethods>f("Hello", 54, gm);
}
}
问题：
是否有可能以某种方式强制 JVM 显示它在编译阶段正式拥有y的函数内的f()如果使用RTTI，那么我们会看到java.lang.Integer，但是我在泛型中强行指出要取变量所属java.lang.Object的参数化类型。也就是说，我不想看到真正的类型。我需要知道正式...Byy
下面是我们使用动态代理（替代）来测量方法调用时间的代码。
问题是这样的：
我们的代理吞下一个real类的对象RealObject，然后SympleDynamicProxy.consumer(Interface iface)依次调用方法real.doSomething()，然后real.somethingElse(String arg)（我的意思是我们测量具体调用的时间“ REAL.method”，在这个意义上代理仍然有引用real）。最奇怪的是，虽然方法doSomething比较简单，但是耗时要长很多，请解释一下为什么？第一次调用创建的对象时会发生什么样的熨斗预热？毕竟，类已经加载，对象已经在堆上。第一次通话花费的时间是多少？即使somethingElse方法“更长”，为什么后续调用要快得多？
在输出中，我们看到我在自己
doSomething()身上花费了 ~ 265,000 ns
somethingElse()~ 45,000 ns
import java.lang.reflect.*;
import static lib.Printer.*;
interface Interface {
void doSomething();
void somethingElse(String arg);
}
class RealObject implements Interface {
@Override
public void doSomething() {
print("doSomething");
}
@Override
public void somethingElse(String arg) {
print("Something else: " + arg);
}
}
class DynamicProxyHandler implements InvocationHandler {
private Object proxied;
public DynamicProxyHandler(Object proxied) {
this.proxied = proxied;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("**** proxy: " + proxy.getClass() + ", method: " + method + ", args: " + args);
if (args != null)
for (Object arg : args)
System.out.println(" " + arg);
Object o;
long st = System.nanoTime();
o = method.invoke(proxied, args);
System.out.println(" spent: " + (System.nanoTime() - st));
return o;
}
}
class SimpleDynamicProxy {
public static void consumer(Interface iface) {
iface.doSomething();
iface.somethingElse("bonobo");
}
public static void main(String[] args) {
RealObject real = new RealObject();
consumer(real);
// Замеряем время:
Interface proxy = (Interface) Proxy.newProxyInstance(Interface.class.getClassLoader(),
new Class[] { Interface.class }, new DynamicProxyHandler(real));
consumer(proxy);
}
}
我们有一个Allocator有方法的类allocate(Class)。如何在不知道Class是什么类对象的情况下，从其中提取一个具有更改能力的字段？
用例objOFclassClass.newInstance()不起作用。无需为创建对象而进行的狩猎无需额外的内存成本。
class X {
public static boolean f = false;
}
class Y {
public static boolean f = false;
}
class Z {
public static boolean f = false;
}
class Allocator {
public static void allocate (Class c) throws Exception{
// Предполагая, что (c.name == "X" или "Y" или "Z"), как сделать что то в духе:
// c.setStaticField("f",true); ???
}
}
如果结果只是这样，如何摆脱“ ... 1 more ”并查看导致抛出异常的完整调用堆栈：
// other output data
myPack.DynamicFieldsException
at myPack.DynamicFields.setField(DynamicFields.java:69)
at myPack.DynamicFields.main(DynamicFields.java:99)
Caused by: java.lang.NullPointerException
at myPack.DynamicFields.setField(DynamicFields.java:70)
... 1 more
请在您的回答中提供一个具体示例，即
catch (MyException e) { ??? }
应该使用什么代码代替“？？？” 得到想要的结果（全栈输出）？
现在使用：
catch (MyException e) { e.printStackTrace(); }
这个选项：
catch (NoSuchFieldException e) {
for (StackTraceElement l : e.getStackTrace())
System.out.println(l);
}
没有显示预定义的原因如何new Exception(new Exception());或如何new MyException().initCause(new MyException());
下面的代码是工作程序。这里的主要内容：评论//НАЧАЛО СОЗДАНИЯ КОЛЛЕКЦИИ和//КОНЕЦ СОЗДАНИЯ КОЛЛЕКЦИИ. 很明显，我们使用匿名类创建了一个集合，实现了抽象类AbsctractCollection。
问题：如何在不注释掉array位于迭代器实现内部的数组声明（该位置标有注释// Роковая строка (*)）的情况下引用数组array：实现本身内部的字段AbstractCollection？调用本身发生在行中：// ЗДЕСЬ (1),// И ЗДЕСЬ (2)。
import java.util.*;
public class Main {
public static void main(String[] args) {
// НАЧАЛО СОЗДАНИЯ КОЛЛЕКЦИИ
Collection<Object> coll = new AbstractCollection<Object>() {
private final int SIZE = 10;
private Object[] array = new Object[SIZE];
@Override
public boolean add(Object o) {
int i = 0;
while (i != SIZE && array[i] != null)
i++;
if (i == SIZE)
return false;
array[i] = o;
return true;
}
@Override
public Iterator<Object> iterator() {
Object[] array = {10,20,22,33,48,"Hi People", // Роковая строка (*)
"Кислотный диджей хэй!",
2.0d, 0, null};
return new Iterator<Object>() {
int k = 0;
@Override
public boolean hasNext() {
return k != SIZE;
}
@Override
public Object next() {
return array[k++]; // ЗДЕСЬ (1)
}
@Override
public void remove() {
if (k == 0)
return;
array[k - 1] = null; // И ЗДЕСЬ (2)
}
};
}
@Override
public int size() {
return SIZE;
}
};
// КОНЕЦ СОЗДАНИЯ КОЛЛЕКЦИИ
for (int i = 34; i < 88; i++)
coll.add(i);
coll.remove(40);
System.out.println(coll);
}
}
//Output:
//[10, 20, 22, 33, 48, Hi People, Кислотный диджей хэй!, 2.0, 0, null]
我想达到的效果也是通过注释掉“致命线”来实现的。相同代码的结果，带有覆盖注释：
Output:
[34, 35, 36, 37, 38, 39, null, 41, 42, 43]
问题伪代码：
Аноним: {
Поле P //(1)
Аноним: {
Поле P //(2)
Вызов(P) // вызывается (2)
}
}
// Как вызвать P (1) ?
这是我想为我的任务获得的解决方案（给出了一个没有匿名类的示例）：
public class Test{
private String s = "Hello World!";
public void f(){
String s = "Strange string";
class A{
String s = "You have a small *ick";
{System.out.println(Test.this.s);} // Примерно этого хочется.
}
new A();
}
public static void main(String[] args){
new Test().f();
}
}
//Output:
//HelloWorld!
另外：如何String s = "Strange string";在{}类A？
我求求你，不要告诉我你可以做这个，你可以做那个，但是不要调用所需的字段，或者求助于万能的重命名。这个问题很有趣也很复杂。是的，异国情调的需求，但希望了解 Java 语言的工作原理。
如果主要问题或附加问题的答案是“不可能”，那么请解释原因，或参考任何能够得到严格证明的信息来源。