总结java面试题

引用地址

1、创建一个对象都在内存中做了什么事情？

     1) 先将硬盘上制定位置的Person.class文件加载进内存。

     2) 执行main方法时，在栈内存中开辟了main方法的空间（压栈-进栈），然后在main方法的栈区分配了一个变量p

     3) 在堆内存中开辟了一个实体空间，分配了一个内存首地址值。new

     4）在该实体空间中进行属性的空间分配，并进行了默认初始化。

     5）对空间的属性进行显示初始化。

     6）进行实体的构造代码块初始化。

     7）调用盖实体对应的构造函数，进行构造函数初始化。

     8）将首地址赋值给p，p变量就引用了该实体。（指向了该对象）

2、成员变量和静态变量的区别

 1） 成员变量属于对象。所以也被称为实例变量；静态变量属于类，也被称为类变量。

 2） 成员变量存在于堆内存中。静态变量存在于方法区中。

 3） 成员变量随着对象的创建二存在，随着对象被回收而消失。

 4）成员变量只能被对象所调用，静态变量可以被对象调用，也可以被类名调用

**所以成员变量可以成为对象的特有数据，静态变量成为对象的共享数据。

3、静态代码块：

定义： 就是一个静态关键字标示的一个代码块区域。定义在类中。

作用：可以完成类的初始化。静态代码块随着类的加载而执行，而且只执行一次（new 多个对象就只执行一次）。

如果和主函数在同一个类中，优先于主函数执行。

4、******单例设计模式********

解决问题：保证一个类在内存中的对象的唯一性。

比如：多程序读取一个配置文件时，建议配置文件封装成对象。会方便操作其中的数据，又要保证多个程序督导的是同一个配置文件对象，就需要该配置文件对象在内存中是唯一的。

步骤：

1）因为创建对象都需要构造方法初始化，只要将本类的构造方法私有化，其他程序就无法再创建该类对象；

2）就在类中创建一个本类的对象。

3） 定义一个方法，返回该对象，让其他程序可以通过该方法就得到本来对象

//饿汉式

class Single{

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

       private static Single s = new Single();// 创建私有并静态的本类对象

       public static Single getInstance(){//定义共有并静态的方法，返回该对象

         return s;

}

}

// 懒汉式

class Single2{

      private Single2(){}

      private static Single2 s=null;

      public static Single2 getInstance(){

          if(s==null){

                  s = new Single2();

                  return s;

           }

}

}

5、final关键字

1）final是一个修饰符，可以修饰类，方法和变量

2）被final修饰的类是一个最终类，不能被继承

3）被final修饰的方法是一个最终方法，不能被重写（覆盖）

4）被final修饰的变量时一个常量，只能被赋值一次。

6、抽象类

抽象类的特点：

1）抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）

2）抽象方法只能定义方法声明，并不定义方法实现。

3）抽象类不可以被创建对象（实例化）。

4）只有通过子类继承抽象类，并覆盖抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。

抽象类的细节：

1）抽象类是否有构造函数？有，用于给子类对象进行初始化。

2）抽象类中是否可以定义非抽象方法？

可以。其实，抽象类和一般类没有什么太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。

3）抽象关键字abstract和哪些不可以共存？final,private,static

4）抽象类中可不可以定义抽象方法？可以，抽象方法目的仅仅是为了不让该类创建对象。

7、接口

1)用关键字interface定义的

2）接口中包含的成员，最常见的有全局常量和抽象方法

注意接口中的成员都有固定的修饰符

成员变量：public static final

成员方法：public abstract

接口和抽象类的区别

抽象类：将一组共性内容进行抽取，特点：可以再类中定义抽象内容让子类实现，可以定义非抽象内容让子类直接使用。

接口：一般用于定义对象的扩展功能，是在继承之外还需这个对象具备的一些功能。

区别：

1>抽象类只能被继承，而且只能单继承。

接口需要被实现，而且可以多实现。

2>抽象类中可以定义非抽象方法，子类可以直接继承使用

接口中都有抽象方法，需要子类去实现

3>抽象类使用的是 is　ａ的关系

接口使用的ｌｉｋｅ　ａ的关系

4>抽象类的成员修饰符可以自定义

接口中的成员修饰符是固定的。全都是public的。

******

我觉得这个接口和抽象类的解释是比较好的

*******

针对上面的介绍，我归纳了一下，如果需要详解的请点击上面的链接：

抽象类和接口的相同点：

1）都代表系统的抽象层

2）不能被实例化

3）都包含抽象方法

抽象类和接口的不同点

语法上：

抽象类由abstract关键字修饰，接口由interface关键字来修饰

抽象类中除了有抽象方法外，也可以有数据成员和非抽象方法；接口中所有的方法都是抽象的，接口中也可以定义数据成员，但都必须是常量

编程思想上：

接口允许多重继承，类可以实现多个接口

抽象类智能单一继承

设计理念上区分：

抽象类和接口本质的区别就是在于设计理念的不同。接口和抽象类的存在就是为了用于具体类的实现和继承的。具体类和抽象类之间的关系

是“is a”，即二者在本质上应该是相同的。比如，吧动物定义成一个抽象类，毛和够都属于动物，可由抽象类继承出来。

而具体类和接口的关系是“is like a”，它不要求接口的实现者和接口定义在概念本质上是一直的，接口只是一种协议，每个实现接口的类都必须遵守这个协议。

8、包

好处：

1>对类文件进行分类管理

2>给类文件提供多层名称空间

包和包之间的访问可以使用的权限有两种：

public :

protected: 只有不同包的子类可以使用的权限

总结java中的四种权限：

范围                     public          protected           default             private

同一个类中          ok                 ok                        ok                    ok

同一个包中          ok                ok                        ok        

不同包的子类      ok                  ok

不同包中              ok

9、线程

创建线程的两种方式：

1> 继承Tread类，然后由子类重写run方法

步骤：

定义类继承Tread类；

目的是复写run方法，将要让线程运行的代码都放到run方法中

通过创建Tread的子类对象，创建线程对象

调用线程的start方法，开启线程，并执行run方法

2> 实现一个接口Runnable

步骤：

定义类实现Runnable接口

覆盖接口中的run方法（用于封装线程要运行的代码）

通过Tread类创建线程对象

将实现了runnable接口的子类对象作为实际参数传递给Tread类中的构造函数（为什么要传递呢？因为要让线程对象明确要运行run方法所属的对象）

调用Tread对象的start方法。开启线程，并运行Runnable接口子类中的run方法

——————————————————————————————————

详细解释：

Ticket t = new Ticket();

/*

直接创建Ticket对象，并不是创建线程对象

因为创建对象只能通过new Tread类，或者new Tread子类才可以

所以最终想要创建线程。既然没有了Tread类的子类，就只能用Tread类

*/

Tread t1 = new Tread(t); //创建线程

/*

只要将t作为Tread类的构造函数的实际参数传入即可完成线程对象和t之间的关联

为什么要将t传给Tread类的构造函数呢？其实就是为了明确线程要运行的代码run方法

*/

t1.start();

——————————————————————————————————

为什么要有Runnable接口的出现？

1：通过继承Tread类的方式，可以完成多线程的建立。但是，有个局限性，如果一个类已经有了一个自己的父类，就不可以继承Tread类，因为java单继承的局限性

因此，通常创建线程都用第二种方式

因为实现Runnable接口可以避免单继承的局限性