小编NIN*_*OOP的帖子

我们可以确定ArrayList<E>使用其公共方法的长度size(),例如

ArrayList<Integer> arr = new ArrayList(10);
int size = arr.size();

类似地,我们可以Array使用length属性确定对象的长度

String[] str = new String[10];
int size =  str.length;

虽然size()方法ArrayList是在ArrayList类中定义的,但是这个length属性是在哪里Array定义的？

Java语言文档说:

如果将基本类型或字符串定义为常量并且在编译时已知该值,则编译器会将代码中的常量名称替换为其值.这称为编译时常量.

我的理解是,如果我们有一段代码:

private final int x = 10;

然后,编译器将x用文字替换代码中的每个匹配项10.

但假设常量在运行时初始化:

private final int x = getX(); // here getX() returns an integer value at run-time.

与编译时常量相比,是否会出现性能下降(无论可能忽略不计)？

另一个问题是以下代码行:

private int y = 10; // here y is not final

编译器以与编译时常量相同的方式处理？

最后,我从答案中理解的是:

1. final static 表示编译时常量
2. 只是final意味着它是一个常量但在运行时被初始化
3. 只是static意味着在运行时初始化
4. 不是final变量,不会被视为常量.

我的理解是否正确？

我把一个字符串数组元素是一个映射,其中字符串数组的元素是键,字的频率是值,例如:

String[] args = {"if","it","is","to","be","it","is","up","me","to","delegate"};

然后地图会有像这样的条目 [ if:1, it:2 .... ]

Set<String> keys = m.keySet();
System.out.println("keyset of the map : "+keys);

打印所有键: "if","it","is","to","be","it","is","up","me","to","delegate"

Set<Map.Entry<String, Integer>> entrySet = m.entrySet();
Iterator<Map.Entry<String, Integer>> i = entrySet.iterator();
while(i.hasNext()){
    Map.Entry<String, Integer> element = i.next();
    System.out.println("Key: "+element.getKey()+" ,value: "+element.getValue());
}

打印所有键值对:

使用条目集打印所有值:

Key: if ,value: 1
Key: it ,value: 2
Key: is ,value: 2
Key: to ,value: 2
Key: be ,value: 1
Key: up ,value: 1
Key: me ,value: 1
Key: delegate ,value: 1

但是下面的代码块应该打印与上面完全相同的输出,但它不会:

Iterator<String> …

我已经了解到,在Java中,静态块在初始化类时执行,并且在构造每个类的实例之前执行实例块.我总是在实例块之前看到要执行的静态块.为什么案件相反enums？

任何人都可以请解释示例代码的输出:

enum CoffeeSize {

    BIG(8), LARGE(10),HUGE(12),OVERWHELMING();
    private int ounces ;

    static {
        System.out.println("static block ");
    }
    {
        System.out.println("instance block");
    }

    private CoffeeSize(int ounces){
        this.ounces = ounces;
        System.out.println(ounces);
    }
    private CoffeeSize(){
        this.ounces = 20;
        System.out.println(ounces);
    }

    public int getOunces() {
        return ounces;
    }
} 

输出:

实例块
8
实例块
10
实例块
12
实例块
20
静态块

我如何传递隐藏参数？我想调用一个页面(test.jsp),但也传递2个隐藏参数,如帖子.

response.sendRedirect("/content/test.jsp");

示例代码是:

    public class OverloadingTest {

       public static void test(Object obj){
           System.out.println("Object called");
       }

       public static void test(String obj){
           System.out.println("String called");
       }

       public static void main(String[] args){
           test(null);
           System.out.println("10%2==0 is "+(10%2==0));
           test((10%2==0)?null:new Object());
           test((10%2==0)?null:null);
   }

输出是:

名为
10%2 == 0的 字符串为true
称为
String的对象称为

第一次调用test(null)带String参数调用方法,这是可以理解的The Java Language Specification.

1)任何人都可以解释我test()在前面的电话中调用的基础吗？

2)当我们提出时,说一个if条件:

    if(10%2==0){
        test(null);
    }
    else
    {
        test(new Object());
    }

它总是使用String参数调用方法.

编译(10%2)时编译器会计算表达式吗？我想知道表达式是在编译时还是在运行时计算的.谢谢.

我的Parent班级是:

import java.io.IOException;
public class Parent {
        int x = 0;
        public int getX() throws IOException{
        if(x<=0){
         throw new IOException();
        }
       return x;
      }
 }

我extend这个类写一个子类Child:

public class Child1 extends Parent{
     public int getX(){
        return x+10;
   }
}

注意在覆盖类中的getX方法时Child,我已从throws方法定义中删除了该子句.现在,它会导致编译器出现异常行为,这是预期的:

new Parent().getX() ;

如果不try-catch按预期将其封闭在块中,则不会进行编译.

new Child().getX() ;

编译而不将其封闭在一个try-catch块中.

但是下面的代码行需要try-catch块.

Parent p = new Child();
p.getX();

正如可以预见的那样,即在运行时多态性期间使用父类引用来调用子方法,为什么Java的设计者没有强制要求在覆盖特定父类方法时在方法定义中包含throws子句？我的意思是如果父类方法在其定义中有throws子句,那么在覆盖它时,重写方法还应该包括throws子句,不是吗？

当我们创建一个扩展抽象类的Subclass对象时,抽象类构造函数也会运行.但我们知道我们不能创建抽象类的对象.因此,这是否意味着即使构造函数在没有任何异常的情况下完成运行,也无法保证是否创建了对象？

为什么我需要声明local variable的final,如果我的Inner class方法中定义需要使用它？

示例:

class MyOuter2 {

private String x = "Outer2";

void doStuff() {
    final String y = "Hello World";

    final class MyInner {

        String z = y;

        public void seeOuter() {
            System.out.println("Outer x is "+x);
            System.out.println("Local variable is "+y);
            MyInner mi = new MyInner();
            mi.seeOuter();
        }
    }
}

}

为什么String y需要是最终常量？它是如何影响的？

namespace TestApp
{
  class Program
  {
    public Program()
    {
      var breakpoint1 = 0;
    }

    static void Main(string[] arguments)
    {
      var breakpoint2 = 0;
    }
  }
}

1. 为什么breakpoint 1永远不会受到打击,但它breakpoint 2总能击中？
2. 有没有办法在进入之前执行默认构造函数Main()？