小编Abh*_*ain的帖子

在Java中,我们看到许多final可以使用关键字的地方,但它的使用并不常见.

例如:

String str = "abc";
System.out.println(str);

在上述情况下,str可以final但通常不会这样做.

当一个方法永远不会被覆盖时,我们可以使用final关键字.类似地,如果一个类不会被继承.

在任何或所有这些案例中使用final关键字是否真的能提高性能？如果是这样,那怎么样？请解释.如果正确使用final真正重要的性能,应在Java程序员开发什么习惯,使关键字的最好用？

可能重复:
是否有java类文件/字节码编辑器来编辑指令？

Java源代码被编译成字节码,实际上是在类文件中.是否可以查看已编译类的字节码？

如果可能,可以编辑吗？

是否有可用的eclipse插件？

Java没有运算符重载的概念.

Still +运算符表现为带数字的加法运算符,并将运算符与字符串连接起来.这类似于运算符重载行为.

那么,Java是否有运算符重载？

看下面的三行代码.

  float f = 1;

  float g = 1.1;

  float h = 1.1f;

第二行有编译错误,而其他行没有编译错误.第一行工作正常,没有后缀f,第三行使用后缀f.为什么是这样？

每当我们需要对小部件的引用时,我们使用findByViewById.

当我们在同一个Activity类的代码中引用窗口小部件时,我们可以遵循以下任一方法:

1. 每次在Activity生命周期中调用findViewById.
2. 第一次获取它,将引用存储为Activity类的私有实例变量.

哪种方法更好？在性能和内存方面,每种方法的优缺点是什么.请帮忙.

编辑:如果我们转移到从A到B的新活动,我们不会完成A,因为我们想要在后退时打开A. 在这种情况下如何处理上述问题？请帮忙.

Java有自己的垃圾收集实现,因此它不需要像C++这样的任何析构函数.这使得Java开发人员懒得实现内存管理.

我们仍然可以使用析构函数和垃圾收集器,开发人员可以在其中释放资源并且可以节省垃圾收集器的工作.这可能会提高应用程序的性能.为什么Java不提供任何析构函数的机制？

开发人员无法控制GC,但他/她可以控制或创建对象.那么为什么不给它们破坏物体的能力呢？

鉴于这种:

String s1= new String("abc");
String s2= new String("abc");
String s3 ="abc";
System.out.println(s1==s3);
System.out.println(s1==s2);
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
System.out.println(s3.hashCode());

输出是:

false
false
true
true
96354
96354
96354

这里==给每个对象赋予false,但每个String对象的哈希码是相同的.为什么会这样？

public class abc1 {

 private String s;

 public abc1(String s){this.s=s;}
 public static void main(String args[])
 {
  HashSet<Object> hs=new HashSet<Object>();
  abc1 a1= new abc1("abc");
  abc1 a2= new abc1("abc");
  String s1= new String("abc");
  String s2= new String("abc");
  hs.add(a1);
  hs.add(a2);
  hs.add(s1);
  hs.add(s2);
  System.out.println(hs.size());

 }
}

为什么上面的程序输出是3？

编辑

看到以下评论我正在扩展我的问题:

System.out.println(s1 == s2);

s1和s2是否指向同一个对象？如果那么上面的语句应该打印为true但其输出为false.

它们在哈希码方面是否相似但仍然不同？

我们是否可以直接或间接访问Java中的内存位置？

如果我们尝试打印对象,它将打印哈希码.hashcode是否间接表示内存位置？

对于不同内存位置的两个对象,但它们的哈希码仍然可以变化.

-Abhishek

public class B {

    static int i =1;

    public static int multiply(int a,int b)
    {
        return i;
    }

    public int multiply1(int a,int b)
    {
        return i;
    }

    public static void main(String args[])
    {
        B b = new A();
        System.out.println(b.multiply(5,2));
        System.out.println(b.multiply1(5,2));
    }
}

class A extends B
{
    static int i =8;

    public static int multiply(int a,int b)
    {
        return 5*i;
    }

    public int multiply1(int a,int b)
    {
        return 5*i;
    }

}

输出:

1

40

为什么会这样？请解释.

由于Error和Exception是throwable类的子类,我们可以抛出任何错误,运行时ex和其他ex.我们也可以捕获这些类型中的任何一种.

为什么我们通常只捕获已检查的异常？

有人可以通过示例为我提供良好的例外链接吗？