JAVA 面试题及思考

====================================

=======学而时习之========================

=====================

public class Test {

    public static void main(String[] args) {
        String str = "123";
        changeStr(str);
        System.out.print(str);
    }
    
    public static void changeStr(String str){
        str = "abc";
    }

}

关键词：java内存分配

public class Test {
    static boolean foo(char c) {
        System.out.print(c);
        return true;
    }

    public static void main(String[] args) {
        int i = 0;
        for (foo('A'); foo('B') && (i < 2); foo('C')) {
            i++;
            foo('D');
        }
    }
}

关键词：c for

public class B extends A {  
 // here  
}  
  
class A {  
    protected int method1(int a, int b) {  
        return 0;  
    }  
}  
//Which two are valid in a class that extends class A? (Choose two)  
//A. public int method1(int a, int b) { return 0; }  
//B. private int method1(int a, int b) { return 0; }  
//C. private int method1(int a, long b) { return 0; }  
//D. public short method1(int a, int b) { return 0; }  
//E. static protected int method1(int a, int b) { return 0; }

关键词：override , overload

The public type A must be defined in its own file
Cannot reduce the visibility of the inherited method from A
The return type is incompatible with A.method1(int, int)
This static method cannot hide the instance method from A
Duplicate method method1(int, int) in type A
方法重载是单个类内部，通常说方法调用 a. 方法名 b. 参数
方法重写是继承关系中，全部相同，除了 a. 子可见度>=父可见度 b. 子final可终止继承

public class Outer {  
    public void someOuterMethod() {  
        // Line 3  
    }  
  
    public class Inner {  
    }  
  
    public static void main(String[] args) {  
        Outer o = new Outer();  
        // Line 8  
    }  
}  
  
// Which instantiates an instance of Inner?  
// A. new Inner(); // At line 3  
// B. new Inner(); // At line 8  
// C. new o.Inner(); // At line 8  
// D. new Outer.Inner(); // At line 8  
// E. new Outer().new Inner(); // At line 8

关键词：内部类

构造方法也是方法
构造方法前必须有new 修饰
谁调用方法：实例调用实例方法new，类调用类方法static
还有一种内部类叫静态内部类

CREATE TABLE zxg(a VARCHAR2(10),b VARCHAR2(10))  
  
INSERT INTO zxg VALUES('a',NULL);  
INSERT INTO zxg VALUES('b','234');  
INSERT INTO zxg(a,b) VALUES ('c','');  
INSERT INTO zxg(a,b) VALUES ('d',' ');  
  
SELECT * FROM zxg  
--1 a     
--2 b   234  
--3 c     
--4 d      
SELECT * FROM zxg WHERE b LIKE '%'  
--1 b   234  
--2 d

关键词：LIKE , NULL

关于oracle中like ‘%’ 或者 like '%%' 还有 is null ，is not null
长度为零的字符串即空字符串varchar2 类型时为 null
好比调一个方法的前提是调动者得存在

//final 是形容词最终的，final 类不可以被继承，final 字段不可以被改变，final方法不可以被重写  
//The type A cannot subclass the final class B  
//Cannot override the final method from B  
//The final field A.s cannot be assigned  
//finally 是副词 try{}catch(){}finally{}  
//finalize() 是方法，垃圾回收机制

关键词：final , finally , finalize

7.Controlling Access to Members of a Class

Access Levels
Modifier	Class	Package	Subclass	World
`public`	Y	Y	Y	Y
`protected`	Y	Y	Y	N
no modifier	Y	Y	N	N
`private`	Y	N	N	N

no modifier (package-private)

关于package的一个问题：

package a;

package a.b;

有父子关系吗？

在a中定义一个pckage-private 的类，该类能不能被a.b中的类访问？

答案是：不能。

需要明确package存在的意义：通过 the fully qualified name 区分不同的类。

文件夹包含关系是存放的实现，域名倒置是避免重复的实现。

public class Test {

    public static void main(String[] args) {
        // 向上转型
        Father f = new Child();
        // f.mygirlfriendis(); 
        // The method mygirlfriendis() is undefined for the type Father
        System.out.println(f.name);
        f.iam();
        // 向下转型
        if (f instanceof Child) {
            Child c = (Child) f;
            System.out.println(c.name);
            c.iam();
            c.mygirlfriendis();
        }
    }

}

class Father {

    String name = "Father";

    public void iam() {
        System.out.println(this.name);
    }

}

class Child extends Father {

    protected String name = "Child";

    public void iam() {
        System.out.println(this.name);
    }

    public void mygirlfriendis() {
        System.out.print("Xuhua");
    }
}

执行结果：

Father
Child
Child
Child
Xuhua

关键词：向上转型，向下转型

把子类的实例赋给父类的引用
把指向子类的父类的引用强转为子类
超类作为方法的参数，目的是简化接口

public static void main(String[] args) {

        String s = null;
        System.out.println(String.valueOf(s));
        
        System.out.println(String.valueOf(null));
        
    }

关键词：方法重载

10. 引用是怎么回事

Circle c;	c	null
c = new Circle();	c	0x45f	→	c:Circle
				radius:0

Circle c; 和 Circle c = null; 的区别

class Test {
    Person person;

    public void f() {
//        Person xx;
//        System.out.println(xx); //The local variable xx may not have been initialized
        System.out.println(person);
    }
}

class Person {

}

= 代表初始化
成员变量不用初始化，因为会自动初始化
局部变量需要初始化，不然编译期间会报错
引用用于存储对象的地址
引用位于栈，对象位于堆
栈用于程序运行，堆用于数据存储

posted on 2016-08-06 08:25 zno2 阅读(451) 评论(0) 编辑收藏举报

刷新页面返回顶部

zno2

JAVA 面试题及思考

导航