下列代码编译后处出现什么问题?
public class Myclass{
public static void main(String a[]){
mymethod(a);
}
public void mymethod(String[] a){
System.out.println(a);
System.out.println(a[1]);
}
}
a.错误,不能静态引用mymethod方法
b.错误,main方法不正确
c.错误,数组必须包含参数
d.mymethod方法必须声明为static类型
分析:首先,main方法是静态方法,但是mymethod不是静态方法,所以不能直接调用。数组引用的时候可以直接调用数组名。d中的必须太绝对了。可以通过对象来调用的。
下列出错的是?
a)
import java.awt.*;
package MyPackage;
class MyClass{}
b)
package MyPackage;
import java.awt.*;
class MyClass{}
c)
/*this is a comment*/
package MyPackage;
import java.awt.*;
class MyClass{}
d)
分析:a会出错,打包命令得在最前面
byte类型的大小是?
-128~127
boolean a = null;是错误的
因为只能给个true或者false
下列代码在输入下面的命令后会输出什么内容?
命令行:java myproj good morning
代码:
public class myproj{
public static void main(String a[]){
System.out.println(a[2]);
}
}
分析:会报错!因为只有两个参数
goto、then都是java的关键字。(×)
then不是,goto是。但是goto一般不会用到。
下列哪些是合法的标识符?
a)2v
b)v2
c)_v
d)_3_
e)$v
f)#v
必须是字母、下划线、 开头,可以包含数字、字母、下划线、
试图编译以下代码会出现什么情况?
public class Sort {
static int i ;
public static void main(String [] args){
System.out.println(i);
}
}
静态变量不给初值也行,初值默认是0,所以输出0
试图编译以下代码会出现什么情况?
public class Sort {
public static void main(String [] args){
int a[] = new int[]{1,2,3};
System.out.print(a[1]);
}
}
会输出2.记住这样赋值也是正确的。其实也等价于:int a[] ={1,2,3};
试图编译以下代码会出现什么情况?
public class Sort {
public static void main(String [] args){
int a[] = new int[5];
System.out.print(a[1]);
}
}
会输出0,默认是0,但是不建议这么做。
下列程序运行后会怎样?
public class MyClass extends a {
public static void main(String [] args){
System.out.println("OK");
}
}
abstract class a{
abstract void method();
}
会报错的,解决方法就是:将MyClass 中继承的抽象方法实现;或者将MyClass声明为手抽象方法,也就是:public abstract class MyClass extends a……
运行下列程序会输出什么?
switch (9) {
case 1:
System.out.println("1");
case 2:
case 9:
System.out.println("9");
default:
}
default后面可以不跟任何东西,case也一样
switch (9) {
default:
System.out.println("default");
case 1:
System.out.println("1");
case 2:
System.out.println("2");
case 3:
System.out.println("3");
}
这个全部都会出输出!
switch (9) {
default:
System.out.println("default");
case 1:
System.out.println("1");
case 2:
System.out.println("2");
case 9:
System.out.println("9");
}
这个只会输出9
下列代码编译后有错误吗?
if(1){
}
错误!必须是布尔值!(此处与C语言不同)
int i,j;
System.out.println(i);
错误,这个必须初始化才能用。静态变量和数组可以不初始化。
int i=1,j=1;
if (i == 0 && j == 1) {
}
正确!两个布尔值在与是可以的
int i=1,j=1;
if (i == 0 & j == 1) {
}
正确!两个布尔值按位与也是可以的!布尔值与后还是布尔值
#### 如果在当前目录下不存在a.txt文件,试图编译和运行下面的代码会输出什么?
public class MyClass {
public static void main(String [] args){
MyClass m = new MyClass();
System.out.println(m.method());
}
public int method(){
try {
FileInputStream dis = new FileInputStream("a.txt");
} catch (Exception e) {
System.out.println("No file");
return -1;
}finally{
System.out.println("Doing finally");
}
return 0;
}
}
分析,很明显要先输出No file,然后执行return 语句,此时若直接退出,就违背了finally中的语句一定会被执行的原则,所以这里的return语句先保留一个断点,然后就执行finally中的语句,最后再接着执行return语句。
输出内容是:
No file
Doing finally
-1
假如,返回的值可以改变,也就是修改程序如下:
public class MyClass {
public static void main(String [] args){
MyClass m = new MyClass();
System.out.println(m.method());
}
int i = 0;
public int method(){
try {
FileInputStream dis = new FileInputStream("a.txt");
} catch (Exception e) {
System.out.println("No file");
return i;
}finally{
i++;
System.out.println("Doing finally");
}
return 11;
}
}
此时函数的返回值还是0,虽然i已经成了1了。也就是返回的时候已经确定了返回值,之后再改变已经无济于事了。
假如,再次修改程序,在finally中加一个return语句,如下:
public class MyClass {
public static void main(String [] args){
MyClass m = new MyClass();
System.out.println(m.method());
}
int i = 0;
public int method(){
try {
FileInputStream dis = new FileInputStream("a.txt");
} catch (Exception e) {
System.out.println("No file");
return i;
}finally{
i++;
System.out.println("Doing finally");
return i;
}
//return 11;
}
}
此时,最后的return 语句要注释掉,不然就出现了多个return。这时候就会返回1了。此时返回的就是finally中的值了。
在下列的注释处插入哪些部分代码是合法的?
class Base{
public void method (int i){}
}
public class MyClass {
public static void main(String [] args){
}
//注释
}
1 void method (int i) throws Exception{}
2 void method (long i) throws Exception{}
3 void method (long i)
4 public method (int i) throws Exception{}
首先,每个方法后的throws Exception其实是在迷糊人,这个没有什么影响。
1中,显然是想覆盖,但是子类方法不能缩小父类方法的访问权限。
2中,数据类型不一样,这是重载。
3中,同2,也是可以的。
4中,抛出异常了,这是不可的。
下列分别输出什么?
System.out.println(Math.floor(-4.7));
System.out.println(Math.round(-4.7));
System.out.println(Math.ceil(-4.7));
String s = new String ("Bycicle");
System.out.println(s.substring(2, 4));
输出:
-5.0
-5
-4.0
ci
== 和 equals()
java虚拟机中的内存,分为三块:栈区、堆区、代码区(也包括数据区,比如静态变量)
当new一个对象的时候:Cat c=new Cat();cat这个引用是放在栈区的,但是cat这个对象实际上是在堆区存着。
当int a = 1;那么a的引用和存储都在栈区存着。普通变量都是这样。
想想这样一个问题,当一个类中存在一个静态变量的时候,这时候,不管你new不new对象,这个静态变量都是存在的,这个静态变量和类的信息就存在代码区中。
其实代码区就是指挥中心,堆区和栈区就是存储数据的,根据数据类型不一样来分别存放。
当String s1 = “abc”;这时候,会在堆区中有个字符池。(因为字符的拼接相当频繁,所以创建了个这么个东西。)s1就指向“abc”;当再次执行:String s2 = “abc”;这时候s1和s2的地址是一样的。
==比较的是地址,
String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
String s4 = new String("abc");
String s = "ab" ;
String s5 = s + "c";
String s6 = "ab" + "c";
System.out.println(s1 == s2);//地址一样,true
System.out.println(s1 == s3);//地址不一样,false
System.out.println(s3 == s4);//地址不一样,属于不同对象,false
System.out.println(s1 == s5);//地址不一样了,false
System.out.println(s1 == s6);//赋值的一瞬间,这个地址还是一样。
System.out.println(s1.equals(s2));//true,内容一样
System.out.println(s1.equals(s3));//true,内容一样
System.out.println(s3.equals(s4));//true,内容一样
System.out.println(s1.equals(s5));//true,内容一样
System.out.println(s1.equals(s6));//true,内容一样
给出下列代码,怎样调用构造方法会出输出OK?
public class MyClass extends a {
public static void main(String [] args){
MyClass m = new MyClass();
//one
}
public MyClass() {
//two
}
}
class a{
a(int i){
System.out.println("OK");
}
a(){
System.out.println("NO");
}
aa(){
//three
}
}
a)在one后放a(10);
b)在one后放super(10);
c)在two后放super(10);
d)three后放super(10);
分析,a中,完全没有意义。
b中,super方法一般放在构造方法中。如果希望在子类中调用父类的构造方法,就要求在子类的构造方法中调用super()。括号中为父类的构造方法的参数列表。
c正确
d则不行了