总结(IX) Java Interview --- java面试二三事

JVM 就是java虚拟机.JVM 会把Java code编译为byte code, 然后执行这些byte code.所有系统都能够安装JAVA虚拟机,这也体现了Java程序的多平台执行优势.

OOPS就是面向对象编程,主要包括以下4个概念:
1. Abstraction 抽象性
2. Polymorphism 多态
3. Inheritance 继承
4. Encapsulation 封装

* Overloadding 发生在compile阶段,Overriding 发生在runtime阶段.
* Overloading是在同一个类中写同一个函数,只是参数的类型不同.而overriding一般会在子类中出现,并且重写的时候函数名字和参数类型是一样的.
* 返回类型,overloading 是可以自由定义,但是Overriding就必须和继承的父类保持一致.
* 你可以overloading一个static 类, 但是不能overriding一个static类.

static method是一个类级别的方法,你可以直接调用它.但是instance方法是一个对象级别的方法,你必须首先创建一个引用指向它,然后再进行调用.

* String是immutable,不可改变的.Stringbuilder 和 Stringbuffer 都是mutable的.
* Stringbuffer 是 synchronized,Stringbuilder 不是
* Stringbuilder 比 Stringbuffer 快.
* StringBuffer线程安全,且保证同步.Stringbuilder不保证线程同步.
* String也是线程安全的,因为它不能够改变.

当写函数的过程中,如果参数是基本类,如int或者double,那么我们会发现java是值传递.但是,在Java中对象作为参数传递时,是把对象在内存中的地址拷贝了一份传给了参数.所以,总体来说,都是pass by value.

Searialziation 是将对象转化为数据流,方便对象能够在网络中进行传递.Desearialziation当然就是讲流转为对象了.

* Final 能够修饰变量,方法和类.修饰变量,说明该变量不能再改变.修饰method,说明该方法不能被overridden.修饰class说明该类不能够被继承.

* finally是用在异常处理的情况.代码如果被写入了finally的块中,不管该段代码是否抛出异常,到最后finally块中的代码都必须执行.这个修饰一般用在关闭网络流,数据库或者输入输出流一类的处理.

* finalize是用在垃圾回收的过程.finalize会被垃圾回收调用,会在对象被抛弃之前清理所有的活动.java提供finalize()方法,垃圾回收器准备释放内存的时候,会先调用finalize().

一般在java中,创建多线程有两种方法:
* 继承Thread类;
重写run() 函数,然后调用start()函数.

public class simpleThread extends Thread {
	public void run() {
		// 写上你的task
		System.out.println("Hello");
	}
}

public class simple {
	public static void main(String[] agrs) {
		simpleThread t = new simpleThread();
		t.start();
	}
}

* 实现Runnable接口.
方法和上面差不多,不过是实现接口,重写的函数还是run方法.

public class simpleThread implements Runnable {
	public void run() {
		// 写上你的task
		System.out.println("Hello");
	}
}

public class simple {
	public static void main(String[] agrs) {
		Thread t = new Thread( new simpleThread() );
		t.start();
	}
}

// 以 singleton 的模式实现该类
public class Logging {
	// 创建一个实例，有且只有一个
	private static final Logging singletonInstance = new Logging();

	// 私有构造函数
	private Logging() {}

	// 返回实例，保证了有且只有一个实例
	public static Logging getSingleton() {
		return singletonInstance;
	}
}

private static Logging singletonInstance = null;
public static Logging getSingleton() {
	if(singletonInstance == null)
		singletonInstance = new Loging();
	reutrn singletonInstance;
}

private static Logging singletonInstance = null;
public synchronized static Logging getSingleton() {
	if(singletonInstance == null)
		singletonInstance = new Loging();
	reutrn singletonInstance;
}

class SomeClass
{
    public static void main(String args[]) 
    { 
        // call the proveIt method and print the return value
    	System.out.println(SomeClass.proveIt()); 
    }

    public static int proveIt()
    {
    	try {  
            	return 1;  
    	}  
    	finally {  
    	    System.out.println("finally block is run 
            before method returns.");
    	}
    }
}

finally block is run before method returns.

public class Useupstack {
	public static void main(String[] args) {
		help();
	}
	
	public static help() {
		help();
	}
}

#include <stdlib.h>
#include <unistd.h>

void main(int argc, char** argv)
{
    while(1)
    {
        malloc(1);
    }
}