刷牛客网Java试题的一些碎片化知识汇总

vs2008 : http://www.pcsoft.com.cn/soft/121335.html

0：方法不能独立存在
Java里的方法不能独立存在，它必须属于一个类或一个对象，因此方法也不能像函数那样被独立执行，执行方法时必须使用类或对象来作为调用者，即所有方法都必须使用"类.方法"或"对象.方法"的形式来调用。

public class A {
    public  String B(){
    	return "This is a test";
    }
    public String C(){
    	return this.B();
    }
    public String D(){
    	return B();
    }
}

注意：同一个类的一个方法调用另外一个方法时，如果被调用方法是普通方法，则默认使用 this 作为调用者；如果被调用方法是静态方法，则默认使用类作为调用者。也就是说，表面上看起来某些方法可以被独立执行，但实际上还是使用 this 或者类来作为调用者；

1：以下代码输出为？

public class B
{
    public static B t1 = new B();
    public static B t2 = new B();
    {
        System.out.println("构造块");
    }
    static
    {
        System.out.println("静态块");
    }
    public static void main(String[] args)
    {
        B t = new B();
    }
}
//输出构造块 构造块 静态块 构造块

静态块：用static申明，JVM加载类时执行，仅执行一次；

构造块：类中直接用{}定义，每一次创建对象时执行；

执行顺序优先级：静态块>main()>构造块>构造方法；

并不是静态块最先初始化，而是静态域，而静态域中包含静态变量、静态块和静态方法,其中需要初始化的是静态变量和静态块.而他们两个的初始化顺序是靠他们俩的位置决定的!

类的加载顺序：

1. 父类静态代码块(包括静态初始化块，静态属性，但不包括静态方法)
2. 子类静态代码块(包括静态初始化块，静态属性，但不包括静态方法 )
3. 父类非静态代码块( 包括非静态初始化块，非静态属性 )
4. 父类构造函数
5. 子类非静态代码块 ( 包括非静态初始化块，非静态属性 )
6. 子类构造函数

2：以下代码输出为？

Boolean flag = false;
if (flag = true)
{
    System.out.println(“true”);
}
else
{
    System.out.println(“false”);
}
//输出true

赋值语句总是返回true

3：

public class B
{
	
	public class C{}
	private class D{}
	protected class E{}
	class F{}
   
}

对于外部类来说，只有两种修饰，public和默认（default），因为外部类放在包中，只有两种可能，包可见和包不可见；

对于内部类来说，可以有所有的修饰，因为内部类放在外部类中，与成员变量的地位一致，所以有四种可能；

4：
口诀：淡云一笔安洛三福 单目>算数运算符>移位>比较>按位>逻辑>三目>赋值

5：重写的规则
重写必须遵循两同两小一大 规则：

1. 方法名相同，参数类型相同
2. 返回值类型小于等于父类的返回值类型
3. 抛出异常小于等于父类抛出异常，也就是抛出的异常更加精确
4. 访问权限大于等于父类

6：

class A{
    private String name = "Person";
    int age=0;
}
public class B extends A{
    public String grade;
    public static void main(String[] args){
        A p = new B();
        System.out.println(p.name);
    }
}

一个Java文件里，public 的类只能出现一个；子类无法访问父类的私有成员；

子类继承父类的所有成员，包括private权限的成员变量，但是继承的子类只具有私有变量的拥有权但是没有使用权；

7：以下代码输出为？

public class A {
	int a = 5;
	public static void main(String[] args) {
		System.out.println(a);   //报错
	}
}

静态方法内不能调用非静态成员；

8：
J2SDK（Standar Development Kit for Java 2） 简称JDK；

9：标识符
标识符由字母（大小写英文字母）、数字（0~9）、下划线（_）和$符号组成，不能由数字打头；也可以是Unicode字符集中的字符，如汉字；

public class A {
	static String 中文 = "asds";
	
	public static void main(String[] args) {	
		System.out.println(中文);    //输出asds
	}
}

10：

package test;

import java.util.Date; 
public class SuperTest extends Date{ 
    private static final long serialVersionUID = 1L; 
    private void test(){ 
       System.out.println(super.getClass().getName()); 
    } 
      
    public static void main(String[]args){ 
       new SuperTest().test();     //输出test.SuperTest
    } 
}

1. 首先 super.getClass() 是父类的getClass（）方法，其父类是Date，它的getClass（）方法是继承自Object类而且没有重写， 所以就是调用object的getClass（）方法。而看一下getClass的方法解释如下图
   
   所以可以知道是返回当前运行时的类； 所以可以知道是返回当前运行时的类；与Date类无关，要返回Date类的名字需要写super.getClass().getSuperclass()；
2. 在调用getName()方法而getName()是：包名+类名；

11：以下代码中输出为

class Base{
    public Base(String s){
        System.out.print("B");
    }
}
public class Derived extends Base{
    public Derived (String s) {
        System.out.print("D");
    }
    public static void main(String[] args){
        new Derived("C");     //编译错误
    }
}

子类构造方法在调用时必须先调用父类的，由于父类没有无参构造，必须在子类中显式调用，修改子类构造方法如下即可：

    public Derived(String s){
    		super("s");
    		System.out.print("D");
    	}

12：变量a、b、c分别在内存_____存储区存放

class A {
    private String a = "aa";
    public boolean methodB() {
        String b = "bb";
        final String c = "cc";
    }
}

变量a、b、c分别在内存的堆区、栈区、栈区存储区存放；
a是类中的成员变量，存放在堆区；b、c都是方法中的局部变量，存放在栈区；

13：A派生出子类B，B派生出子类C，在Java源代码中有如下声明。是否正确？

A  a0=new  A(); 

A  a1 =new  B(); 

A  a2=new  C(); 

都是正确的；

继承具有传递性，子类可以无条件向上转型！

14：所有的异常类皆直接继承于？
所有的异常类皆直接继承于java.lang.Exception；

15：Java中基本的编程单元为？
java的基本编程单元是类，基本存储单元是变量。

16：以下语句错误的是？

byte b1=1,b2=2,b3,b6,b8;
final byte b4=4,b5=6,b7;
b3=(b1+b2);  /*语句1*/
b6=b4+b5;    /*语句2*/
b8=(b1+b4);  /*语句3*/
b7=(b2+b5);  /*语句4*/
System.out.println(b3+b6);

存在编译错误的语句是：语句1、语句3、语句4；
------------知识点------------
Java表达式转型规则由低到高转换：
1、所有的byte,short,char型的值将被提升为int型；
2、如果有一个操作数是long型，计算结果是long型；
3、如果有一个操作数是float型，计算结果是float型；
4、如果有一个操作数是double型，计算结果是double型；
5、被fianl修饰的变量不会自动改变类型，当2个final修饰相操作时，结果会根据左边变量的类型而转化。
--------------解析--------------
语句1错误：b3=(b1+b2);自动转为int，所以正确写法为b3=(byte)(b1+b2);或者将b3定义为int；
语句2正确：b6=b4+b5;b4、b5为final类型，不会自动提升，所以和的类型视左边变量类型而定，即b6可以是任意数值类型；
语句3错误：b8=(b1+b4);虽然b4不会自动提升，但b1仍会自动提升，所以结果需要强转，b8=(byte)(b1+b4);
语句4错误：b7=(b2+b5); 同上。同时注意b7是final修饰，即只可赋值一次，便不可再改变。

17：Java语言中，如果"xyz"没有被创建过，String s =new String(“xyz”);创建了几个string object？
两个。第一个在堆中，第二个在字符串常量池中！如果在Java字符串常量池中已经存在，就只会创建一个；

18：Java 程序中使用赋值运算符进行对象赋值时，可以得到两个完全相同的对象？
错误。对象赋值时，比如A=B，只是把A对象的地址指向了B对象的地址，所以其实对象只有一个；

19：以下代码的输出是

class Foo {
    final int i;
    int j;
    public void doSomething() {
        System.out.println(++j + i);
    }
}

不能执行，因为编译有错；

final类型的变量一定要初始化，因为final的变量不可更改。

20：下面代码运行结果是

public class Test{ 
    public int add(int a,int b){   
         try {
             return a+b;      
         } 
        catch (Exception e) {  
            System.out.println("catch语句块");
         }
         finally{ 
             System.out.println("finally语句块");
         }
         return 0;
    } 
     public static void main(String argv[]){ 
         Test test =new Test(); 
         System.out.println("和是："+test.add(9, 34)); 
     }
}

输出： finally语句块 和是：43

1. 不管有木有出现异常，finally块中代码都会执行；
2. 当try和catch中有return时，finally仍然会执行；
3. finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，不管finally中的代码怎么样，返回的值都不会改变，仍然是之前保存的值），所以函数返回值是在finally执行前确定的；
4. finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

举例：

1. 情况1 ：try{} catch(){}finally{} return;
   显然程序按顺序执行。
2. 情况2 :try{ return; }catch(){} finally{} return;
   程序执行try块中return之前（包括return语句中的表达式运算）代码；
   再执行finally块，最后执行try中return;
   finally块之后的语句return，因为程序在try中已经return所以不再执行。
3. 情况3 :try{ } catch(){return;} finally{} return;
   程序先执行try，如果遇到异常执行catch块，
   有异常：则执行catch中return之前（包括return语句中的表达式运算）代码，再执行finally语句中全部代码，
   最后执行catch块中return. finally之后也就是4处的代码不再执行。
   无异常：执行完try再finally再return.
4. 情况4 :try{ return; }catch(){} finally{return;}
   程序执行try块中return之前（包括return语句中的表达式运算）代码；
   再执行finally块，因为finally块中有return所以提前退出。
5. 情况5 :try{} catch(){return;}finally{return;}
   程序执行catch块中return之前（包括return语句中的表达式运算）代码；
   再执行finally块，因为finally块中有return所以提前退出。
6. 情况6 :try{ return;}catch(){return;} finally{return;}
   程序执行try块中return之前（包括return语句中的表达式运算）代码；
   有异常：执行catch块中return之前（包括return语句中的表达式运算）代码；
   则再执行finally块，因为finally块中有return所以提前退出。
   无异常：则再执行finally块，因为finally块中有return所以提前退出。

最终结论 ：任何执行try 或者catch中的return语句之前，都会先执行finally语句，如果finally存在的话。
如果finally中有return语句，那么程序就return了，所以finally中的return是一定会被return的，
编译器把finally中的return实现为一个warning。

21：下列不属于java语言鲁棒性（健壮性）特点的是
A java能检查程序在编译和运行时的错误

B java能运行虚拟机实现跨平台

C java自己操纵内存减少了内存出错的可能性

D java还实现了真数组，避免了覆盖数据的可能

答案：B
跨平台不属于鲁棒性

22：下面不是面向对象的基本原则的是？
A 单一职责原则（Single-Resposibility Principle）

B 开放封闭原则（Open-Closed principle）

C 抽象类原则（Abstract-Class principle）

D 依赖倒置原则（Dependecy-Inversion Principle）

E 接口隔离原则（Interface-Segregation Principle）

答案：C

面向对象的五大基本原则
单一职责原则（SRP）
开放封闭原则（OCP）
里氏替换原则（LSP）
依赖倒置原则（DIP）
接口隔离原则（ISP）

23：构造函数不能被继承，只能被调用

24：Java中使用 final 关键字定义常量

25：Java关键字都是小写

26：Path环境变量
编译和运行 Java 程序必须经过两个步骤：

1. 将源文件编译成字节码；
2. 解释执行平台无关的字节码程序；

这两个步骤分别需要使用 java 和 javac 两个命令。

计算机如何查找命令呢？Windows 操作系统根据 Path 环境变量来查找命令。Path 环境变量的值是一系列路径，Windows 操作系统在这一系列的路径中依次查找命令，如果能找到这个命令，则该命令是可执行的；否则将出现 “xxx不是内部或外部命令，也不是可运行的程序或批处理文件” 的提示。

而 Linux 操作系统则根据 PATH 环境变量来查找命令，PATH 环境变量的值也是一系列路径。因为 Windows 操作系统不区分大小写，设置 Path 和 PATH 并没有区别；而 Linux 系统是区分大小写的，设置 Path 和 PATH 是有区别的，因此只需要设置 PATH 环境变量即可；

27：CLASSPATH环境变量
1.5以上版本的 JDK，完全可以不用设置 CLASSPATH 环境变量------即使不设置 CLASSPATH 环境变量，完全可以正常编译和运行 Java 程序；

那么 CLASSPATH 环境变量的作用是什么呢？
如果使用 1.4 以前版本的 JDK，则需要在 CLASSPATH 环境变量中添加一点（.），用以告诉 JRE 需要在当前路径下搜索 Java 类；
除此之外，编译和运行 Java 程序还需要 JDK 的 lib 路径下 dt.jar 和 tools.jar 文件中的 Java 类，因此还需要把这两个文件添加到 CLASSPATH 环境变量里；
因此，如果使用1.4 以前版本的 JDK 来编译和运行 Java 程序，常常需要设置 CLASSPATH 环境变量的值为：

//%JAVA_HOME%代表 JDK 安装目录，设置 JAVA_HOME 的原因就是不用每次都修改
.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar     

后来的 JRE 会自动搜索当前路径下的类文件，而且使用 Java 的编译和运行工具时，系统可以自动加载 dt.jar 和 tools.jar 文件中的 Java 类，因此不再需要设置 CLASSPATH 环境变量；

28：形参个数可变的方法
JDK 1.5 之后，Java 允许定义形参个数可变的参数，从而允许为方法指定数量不确定的形参。如果在定义方法时，在最后一个形参的类型后增加三点（…），则表明该形参可以接受多个参数值，多个参数值被当成数组传入：

public class TestVarargs {
    public static void test(int a,String...books)
    {
    	for(String tmp : books)
    	{
    		System.out.println(tmp);
    	}
    	System.out.println(a);
    }
	public static void main(String[] args) {
		
		test(5,"疯狂 Java 讲义","轻量级 Java EE 企业应用实战");   
	}

}

形参个数可变的参数本质就是一个数组参数：

public static void test(int a,String[] books)

这两种形式都包含了一个名为 books 的形参，在两个方法的方法体内都可以把 books 当成数组处理。但区别是调用两个方法时存在差别：

test(5,"疯狂 Java 讲义","轻量级 Java EE 企业应用实战");   
test(23,new String[]{"疯狂 Java 讲义","轻量级 Java EE 企业应用实战"});

第一种更加简洁；

注意：个数可变的形参只能处于形参列表的最后。一个方法中最多只能包含一个个数可变的形参。