您现在所在的位置:首页 >学员就业 > 就业宝典 > Java基础面试题,你能做对多少?

Java基础面试题,你能做对多少?

来源:奇酷教育 发表于:

基础1 switch支持的类型:byte, short, int, char, enum,注意:不支持long,double,JDK7之后,开始支持String。 简单示例 public c

基础

  • 1 switch支持的类型:byte, short, int, char, enum,

    注意:不支持long,double,JDK7之后,开始支持String。

//简单示例
  public class MyDemo {      
         public static void main(String... args) {
          Demo demo = Demo.A;          
            switch (demo) {              
                       case A:                  
                    break;              
                       case B:                  
                    break;
          }
      }      
          enum Demo {
          A,
          B,
          C
      }
  }

饿汉式

  • 2 if和switch的区别:

    if :1.对具体的值进行判断  2.对区间判断  3.对运算结果是boolean类型的表达式进行判断

    switch :1.对具体的值进行判断;2.值的个数通常是固定的。

    对于几个固定值的判断,建议使用switch语句,因为switch语句会将具体的答案加载进内存,相对高效一点。

  • 重载和重写的区别

    • 重载:允许存在一个以上的同名函数,只要它们的参数类型不同即可。

    • 重写:当子类继承父类,沿袭了父类的功能到子类中,子类虽具备该功能,但功能内容不一致,这是使用覆盖特性,保留父类的功能定义,并重写功能内容。

  • 单例模式

private static Single s = new Single ( ) ;          
        private Single ( ) { }  
          public static Single getInstance () 
          {          
           return s ;
          }

      懒汉式

 

class Single {      
   public static Single getInstance (){          
        if ( s== null ){              
           synchronized (Single.class){//锁不读可以提高效率
              if ( s== null ){
                  s = new Single () ;
               }
           }          
           return s ;
      }
  }

特殊关键字:final

 

1. 可以修饰类、函数、变量;  
2. 被final修饰的类不可以被继承。为了避免被继承,被子类复写。final class Demo { }  
3. 被final修饰的方法不可以被复写。final void show () { }  
4. 被final 修饰的变量是一个常量,只能赋值一次。  
5. 内部类定义在类中的局部位置上时,只能访问该局部被final修饰的局部变量。

      异常:(关于问题1,谢谢ylt提醒)

 

 try{}catch(){}finally{}  
 1.catchreturn(),finally{}会不会执行?
  答:会,会在return之后执行。  
 2.finally()在什么情况下不会执行
  答:只有一种情况不会执行,当执行到System.exit(0)时,finally不会执行。

 

public class Test {  public static void main(String[] args) {
      System.out.println("haha:" + haha(true));
  }  
private static boolean haha(boolean isTrue) {      
    try {          
         int i = 1 / 0;          
         return  isTrue ? System.out.printf("return try !null ", "test") != null : System.out.printf("return try null ", "test") == null;
      } catch (Exception e) {
          System.out.println("catch");          
          return  isTrue ? System.out.printf("return catch !null ", "test") != null : System.out.printf("return catch null ", "test") == null;
      } finally {            
          System.out.println("");
          System.out.println("finally");
      }        
  }
}
//打印结果:
catch
return catch !null 
finally
haha:true

Java静态代码块、构造函数、构造代码块

  • 先看下面一段代码,运行Test,会打印什么?

     

package test;  
public class Test {      
   public static void main(String... args) {
          TestA a;
          a = new TestA();
          a = new TestA();
          TestA aa = new TestA();
      }
  }  
  class TestA {
      {
          System.out.println("TestA code create");
      }      
          private TestB b = new TestB();      
          private static TestC c = new TestC();      
          
          public TestA() {
              System.out.println("TestA create");
      }      
          
          static {
             System.out.println("TestA static create");
      }
  }  
  class TestB {      
     public TestB() {
          System.out.println("TestB create");
      }
  }  
  class TestC {      
     public TestC() {
          System.out.println("TestC create");
      }
  }

打印结果:

 

TestC create
TestA static create
TestA code create
TestB create
TestA create
TestA code create
TestB create
TestA create
TestA code create
TestB create
TestA create

static特点:

 

  1.    随着类的加载而加载(随着类的消失而消失,生命周期最长)  
  2.    优先于对象存在  
  3.    被所有对象所共享  
  4.    可以直接被类所调用  
  5.    static是一个修饰符,用于修饰成员

构造代码块

 

作用:给对象进行初始化,对象一建立就运行,而且优先于构造函数执行。

  和构造函数的区别:
  构造代码块是给所有对象进行统一初始化;而构造函数是给对应的对象初始化
  构造代码块中定义的是不同对象共性的初始化内容

静态代码块

 

 static
  {
      静态代码块中的执行语句;
  }
  特点:随着类的加载而执行,只执行一次(再new一个对象也不会执行,类只加载一次),
  如果定义在有主函数的类中,则优先于主函数执行。用于给类进行初始化。
  有些类不用创建对象,无法用构造函数初始化,就通过静态代码块初始化。

  执行顺序:静态代码块先执行,如果有对象,构造代码块先执行,然后是构造函数。
  如果没有对象,则构造代码块和构造函数都不会执行。

Java-封装、继承、多态

抽象类的特点:

 

 1.    抽象方法一定在抽象类中。  
 2.    抽象方法和抽象类都必须被abstract关键字修饰。  
 3.    抽象类不可以用new创建对象,因为调用抽象方法没有意义。  
 4.    抽象类中的抽象方法要被使用,必须由子类复写所有的抽象方法后,建立子类对象调用。如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类。强迫子类复写,强迫子类做一些事。  
 5.    抽象类中可以不定义抽象方法,如果不定义抽象方法,那么抽象类的功能就是为了不让该类建立对象。

抽象关键字不可以和哪些关键字共存?

 

 答(1private不能:抽象方法就是给子类覆盖的,私有了就不能覆盖了。
   (2static不能:static可以直接用类名调用,而调用抽象方法没有意义。
   (3final 不能:final修饰的方法不可以被复写,修饰的类不可以被继承。与abstract冲突。

接口的特点

 

       接口是对外暴露的规则。
  ●    接口是程序的功能扩展。
  ●    接口可以多实现。
  ●    类与接口直接是实现关系,而且类可以继承一个类的同时实现多个接口。
  ●    接口与接口之间可以有继承关系,可以多继承。
       因为接口没有方法体,不会存在两个父类出现同一个方法但是方法体不同的情况,
       不会引起冲突,如下:  
       
  public class Test implements d{     
      public static void main(String... args) {
      }      
      
      @Override
      public void as() {
      }
  }  
      
      interface d extends e,f {
  }  
      interface f{      
      void as();
  }  
      interface e{      
      void as();
  }

接口和抽象类的异同点:

 

 相同点:都是不断向上抽取而来的。不可以被实例化

 不同点:1.    抽象类需要被继承,而且只能单继承;接口需要被实现,而且可以多实现  
        2.    抽象类中可以定义抽象方法和非抽象方法,子类继承后,可以直接使用非抽象方法;
        接口只能定义抽象方法,必须有子类实现。  
        3.    抽象类的继承,是is a关系,在定义该体系的基本共性内容;
              接口的实现是like a 关系,在定义体系额外功能。

继承

 

  子类的实例化过程:
  结论:子类的所有的构造函数,默认都会访问父类中空参数构造函数,因为子类中每一个构造函数内的第一行都有一句隐式的super() ;
  当父类中没有空参数的构造函数时,子类必须手动通过super或者this语句形式来指定要访问的构造函数。
  当然:子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数,
  子类中至少会有一个构造函数会访问到父类中的构造函数。

对象的初始化过程,见下图:

打印结果