java基础部分代码相关题

public class SendValue{
public String str="6";
public static void main(String[] args) {
        SendValue sv=new SendValue();
        sv.change(sv.str);
        System.out.println(sv.str);
    }
public void change(String str) {
        str="10";
    }
}

Java中String类型变量是immutable（不可变的）。
尽管 change()方法中的str与sv.str都是新的对象实例成员变量值”6”的引用，由于String类型的不可变性，change()方法中的str=”10”语句实际上是将传入的str副本引用指向了一个值为“10”的新的内存地址，但原数据引用 sv.str的引用值（也就是“6”的内存地址）并没有发生改变，因此sv.str指向的值仍旧为6.

System.out.println(“is ”+ 100 + 5)；
System.out.println(100 + 5 +“ is”)；
System.out.println(“is ”+ (100 + 5))；

1.”is”说明后面的内容都会被强制转换为string，所以是最后结果是拼接起来的
2.100+5先得到105，然后与is拼接
3.先算括号内的

public class Test
{
public static Test t1 = new Test();
    {
         System.out.println("blockA");
    }
static
    {
        System.out.println("blockB");
    }
public static void main(String[] args)
    {
        Test t2 = new Test();
    }
 }

静态块：用static申明，JVM加载类时执行，仅执行一次
构造块：类中直接用{}定义，每一次创建对象时执行
执行顺序优先级：静态块>main()>构造块>构造方法
静态块按照申明顺序执行，先执行Test t1 = new Test();
所有先输出blockA，然后执行静态块，输出blockB，最后执行main
方法中的Test t2 = new Test();输出blockA。

int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));

1、基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
2、两个Integer类型进行“==”比较，如果其值在-128至127，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关，这里不进行赘述。
3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true
4、基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。

class CompareReference{
public static void main(String [] args){
float f=42.0f;
float f1[]=new float[2];
long x=42;
   f1[0]=42.0f;
  }
}
判断x==f1[0]

java核心卷I中43页有如下表述：两个数值进行二元操作时，会有如下的转换操作：
如果两个操作数其中有一个是double类型，另一个操作就会转换为double类型。
否则，如果其中一个操作数是float类型，另一个将会转换为float类型。
否则，如果其中一个操作数是long类型，另一个会转换为long类型。
否则，两个操作数都转换为int类型。
故，x==f1[0]中，x将会转换为float类型。

public  static void main(String[] args){
    String s;
    System.out.print("s="+s);
}

由于String s没有初始化，代码不能编译通过。
成员变量有初始值，而局部变量没有初始值得。本体中的s定义在方法中所以为局部变量-没有初始值。变量没有初始值就使用了，编译通不过

public class TestClass {
private static void testMethod(){
        System.out.println("testMethod");
   }
public static void main(String[] args) {
        ((TestClass)null).testMethod();
   }
}

静态的方法也是可以通过对象.来访问的，其次，null可以被强制类型转换成任意类型的对象，于是通过它来执行静态方法，就可以理解了。

public class Base
{
private String baseName = "base";
public Base()
    {
        callName();
    }

public void callName()
    {
        System. out. println(baseName);
    }

static class Sub extends Base
    {
private String baseName = "sub";
public void callName()
        {
            System. out. println (baseName) ;
        }
    }
public static void main(String[] args)
    {
        Base b = new Sub();
    }
}

new Sub();在创造派生类的过程中首先创建基类对象，然后才能创建派生类。
创建基类即默认调用Base()方法，在方法中调用callName()方法，由于派生类中存在此方法，则被调用的callName（）方法是派生类中的方法，此时派生类还未构造，所以变量baseName的值为null

Integer i01 = 59;
int i02 = 59;
Integer i03 =Integer.valueOf(59);
Integer i04 = new Integer(59)。

JVM中一个字节以下的整型数据会在JVM启动的时候加载进内存，除非用new Integer()显式的创建对象，否则都是同一个对象
所有只有i04是一个新对象，其他都是同一个对象。

boolean b=true?false:true==true?false:true;
System.out.println(b);

== 优先级高于三目运算符，先判断 true == true，此时返回为 true,
这时表达式为 boolean b = true?false:true?false:true
此时三目运算符从右向左执行,true?false:true，返回false
这时表达式为 boolean b = true?false:false;
结果为：boolean b = false ;

public abstract class MyClass {
 public int constInt = 5;
 //add code here
 public void method() {
 }
}

public abstract void method(int a);
constInt = constInt + 5;
public int method();
public abstract void anotherMethod() {}

A是抽象方法，抽象类可以包含抽象方法，也可以不包含，虽然A 方法名是method，与题目中的方法同名，但是参数不同，是重载方法
B 在类中不能constInt = constInt + 5; 方法中可以
C 的方法名与题目中的方法名相同，返回值不能作为重载的依据
D 抽象方法没有方法体

class A {
public int func1(int a, int b) {
return a - b;
    }
}
class B extends A {
public int func1(int a, int b) {
return a + b;
    }
}
public class ChildClass {
public static void main(String[] args) {
    A a = new B();
    B b = new B();
    System.out.println("Result=" + a.func1(100, 50));
    System.out.println("Result=" + b.func1(100, 50));
    }
}

也就是编译时候，会看左边引用类型是否能正确编译通过，运行的时候是调用右边的对象的方法。编译时候会发现左边满足条件所以编译通过，运行时候又会调用右边也就是 class B 的方法，所以答案都是150。

向上转型： Person p = new Man() ; //向上转型不需要强制类型转化
向下转型： Man man = (Man)new Person() ; //必须强制类型转化

public class Spike
{
public static void main(String[] args)
    {
        Counter a = new Counter();
        System.out.println(a.increment());
        System.out.println(a.anotherIncrement());
        Counter b = new Counter();
        System.out.println(b.increment());
    }
}
class Counter
{
private static int count = 0;
public int increment()
    {
return count++;
    }
public int anotherIncrement()
    {
return ++count;
    }
}

return count++是先return再+1
return ++count是先+1再return

秒客网

java基础部分代码相关题

相关文章