一、基础和语法

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("父类--静态初始化块");

}

}

打印结果如下：

父类--静态变量

父类--静态初始化块

子类--静态变量

子类--静态初始化块

父类--变量

父类--初始化块

父类--构造器

子类--变量

子类--初始化块

子类--构造器

大家可能会注意到一点，那就是，并不是父类完全初始化完毕后才进行子类的初始化，实际上子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了。另外，静态变量和静态初始化块的初始化次序，是按照定义的先后顺序进行的，变量和初始化块也是如此。大家可以调换静态变量和静态初始化块的次序来看一下。