一、基础和语法
1.Java中的进制：
1)十进制 à 二进制
例：100(10进制) = ？(2进制)
解： 100 = 64 + 32 + 4
= 2^6 + 2^5 +2^2
0100 0000
0010 0000
0000 0100
---------------------------
0110 0100
2) 二进制 à 十进制
例： 101 1010(二进制) = ？(十进制)
解： 101 1010 = 2^6 + 2^4 + 2^3 + 2 = 90
3) 十进制(负数) à 二进制
规律： -n = ~n + 1
例： -110 (10进制) = ？(2进制)
110 = 64 + 32 + 8 + 4 + 2
0100 0000
0010 0000
0000 1000
0000 0100
0000 0010
---------------------
0110 1110
取反：1001 0001
+1 ：1001 0010
因此，结果为1001 0010
4) 二进制(以 ”1” 开头的二进制数) à 十进制
规律：
以”1” 开头的二进制数化为十进制数的步骤：
先减一，然后对其求反，把得到的数化为十进制，最后给该数加负号。
例： 1000 0101(2进制) = ？(10进制)
解：
减1： 1000 0100
取反： 0111 1011
化10进制：2^6 + 2^5 +2^4 + 2^3+2^1+1 = 123
加负号： -123
5)十六进制： 引入16进制的目的：简化2进制
0 12 3 4 5 6 7 8 9 A B C D E F
例：
41(16进制) = ？(10进制)
= 4×16 + 1 = 65
例：
0110 0010(2进制) = ？(16进制)
0110 = 6
0010 = 2
0110 0010 = 62
规律：四个数一组，化为16进制
2.Java中的数据类型：
基本类型(8种)：
整数类型： byte (二进制位数：8 bit，1个字节,表示范围：0x80-0x7f);
short(二进制位数：16 bit,2个字节,表示范围：0x8000-0x7fff);
int (二进制位数：32 bit,4个字节,表示范围：0x8000 0000-0xfff ffff);
long (二进制位数：64 bit,8个字节,表示范围：-2^63 -2^63-1);
浮点类型： float(二进制位数：32 bit, 4个字节);
double(二进制位数：64 bit，8个字节);
字符类型： char(二进制位数：16 bit,2个字节);
布尔类型： boolean (二进制位数：根据JVM情况而定)
3.什么是面向对象？
对象，即人们要进行研究的事物，对象具有状态和行为，用数据来描述对象的状态，用操作来描述对象的行为，对象实现了数据和操作的结合。面向对象，就是在解决问题时，将问题涉及到的事物分解成各个对象，分解的目的不是为了完成一个步骤，而是为了描述一个事物在整个解决问题的步骤中的状态和行为。
4.面向对象和面向过程的区别？
面向过程，就是在解决问题时，分析出解决问题所需要的步骤，然后用函数来把这些步骤一步一步的实现，使用的时候一个一个的依次调用就可以了。
面向对象，就是在解决问题时，将问题涉及到的事物分解成各个对象，分解的目的不是为了完成一个步骤，而是为了描述一个事物在整个解决问题的步骤中的状态和行为。
5.面向对象的特征？
面向对象的主要特征有以下几个方面：
1)抽象: 抽象就是忽略一个问题中与当前目标无关的那些方面，以便更充分的注意与当前目标有关的部分，抽象不打算了解问题的全部，而是只选择其中的一个部分，抽象包括两个方面：过程抽象和数据抽象。
2)封装：就是把过程和数据包围起来，对数据的访问只能通过已定义的界面。
3) 继承：对象的一个新类从现有类中派生，这个过程就是继承。新类继承了原始类的特性，新类称为原始类的子类，原始类称为新类的父类。子类可以从父类继承方法和变量，实现类的复用。
4)多态：多态是指允许不同类的对象对同一消息作出不同的响应。
6.类的初始化次序是怎么样的？
大家在去参加面试的时候，经常会遇到这样的考题：
给你两个类的代码，它们之间是继承的关系，每个类里只有构造器方法和一些变量，构造器里可能还有一段代码对变量值进行了某种运算，另外还有一些将变量值输出到控制台的代码，然后让我们判断输出的结果。这实际上是在考查我们对于继承情况下类的初始化顺序的了解。
我们大家都知道，在同一个类中，对于静态变量、静态初始化块、变量、初始化块、构造器，
它们的初始化顺序依次是：
(静态变量、静态初始化块)>(变量、初始化块)>构造器。
下面通过一段代码来验证一下：
package audition;
/**
* 类的初始化顺序问题：
*
*@author wwenbo
*
*/
public class ClassIntialOrder {
//1.定义变量
publicString field = "变量";
//2.定义静态变量
publicstatic String staticField = "静态变量";
//3.构造器
publicClassIntialOrder() {
System.out.println("构造器");
}
//4.初始化块
{
System.out.println("初始化块");
System.out.println(field);
}
//5.定义静态初始化块
static{
System.out.println("静态初始化块");
System.out.println(staticField);
}
publicstatic void main(String[] args) {
newClassIntialOrder();
}
}
上面的程序的打印结果如下：
静态初始化块
静态变量
初始化块
变量
构造器
那么，在继承当中的类的初始化次序又是怎样的呢？ 再通过一段代码来看一下：
package audition;
public class SubClass extends ParClass {
//1.变量
publicString s_Field = "子类--变量";
//2.静态变量
publicstatic String s_StaticField = "子类--静态变量";
//3.构造器
publicSubClass() {
System.out.println("子类--构造器");
}
//4.初始化块
{
System.out.println(s_Field);
System.out.println("子类--初始化块");
}
//5.静态初始化块
static{
System.out.println(s_StaticField);
System.out.println("子类--静态初始化块");
}
publicstatic void main(String[] args) {
newSubClass();
}
}
class ParClass {
//1.变量
publicString p_Field = "父类--变量";
//2.静态变量
publicstatic String p_StaticField = "父类--静态变量";
//3.构造器
publicParClass() {
System.out.println("父类--构造器");
}
//4.初始化块
{
System.out.println(p_Field);
System.out.println("父类--初始化块");
}
//5.静态初始化块
static{
System.out.println(p_StaticField);
System.out.println("父类--静态初始化块");
}
}
打印结果如下：
父类--静态变量
父类--静态初始化块
子类--静态变量
子类--静态初始化块
父类--变量
父类--初始化块
父类--构造器
子类--变量
子类--初始化块
子类--构造器
大家可能会注意到一点，那就是，并不是父类完全初始化完毕后才进行子类的初始化，实际上子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了。另外，静态变量和静态初始化块的初始化次序，是按照定义的先后顺序进行的，变量和初始化块也是如此。大家可以调换静态变量和静态初始化块的次序来看一下。
