Java面试题--每日一练，点滴积累，点滴成长。

问答题：

1.abstract class和interface有什么区别?

a.接口中的变量为常量
b.接口中的方法都为抽象方法，抽象类中可以有非抽象的方法。
（即接口只能有抽象方法和不可变常量）
c.一个类可以实现多个接口，但只能继承一个抽象类。
d.抽象类主要用于抽象类别，而接口用来抽象功能。

2.什么是方法重载？什么是方法重写？重写和重载的区别？

 a.方法重载，发生在同一个类中，方法名相同，参数类型不同，不能以返回值类型来区分重载。
 b.方法重写，一般发生在父子类中，方法名和参数类型必须相同。
 c.构造方法可以重载，但不能重写。
 d.多态性：编译时的多态和运行时多态。
 （方法重载为编译时多态，方法重写为运行时多态）

3.对比访问控制修饰符public,protected,默认,private(当前类，同包，子类，其他包)

 public 当前类 同包 子类 其他包
 protected 当前类 同包 子类
 default 当前类 同包
 private 当前类

4.写出String、StringBuffer、StringBuilder三者的区别？

 String 为字符串常量，创建的String字符串存放于常量池中。
 StringBuffer为字符串变量，线程安全。
 StringBuilder为字符串变量，线程不安全，性能优于StringBuilder.

5.阐述Java面向对象特征？

 封装：将对象抽取成一个实体，属性设置为私有,提高数据安全性，仅对外提供相应的接口。
 继承：根据已有类创建一个新类，新类具有父类的属性和方法，可以在已有类的基础上进行功能性拓展。
 多态：相同的行为产生不同的结果，一般需要
   a.通过方法重写
   b.父类引用指向子类实例

6.详述ArrayList和LinkedList的区别？HashMap和Hashtable的区别？

ArrayList和linkedList的区别：

ArrayList实现基于数组，LinkedList的实现基于链表。
其中，用于随机访问时，ArrayList性能优于LinkedList;
用于数据修改时，ArrayList性能低于于LinkedList。

HashMap与HashTable的区别：

   a.上级不同，HashMap继承于AbstratMap，HashTable继承于Dictionary
   b.hashmap线程不安全，hashtable线程安全；
   c.hashmap允许一个key（键）为空，允许多个值为空；hashtable不允许为空

7.写出继承关系中类成员的初始化顺序？（最后自己写出代码）（忘记了）

静态变量和静态初始化代码会最先执行, 跨类执行. 优先于任何父类子类里的其他非静态变量和方法. 顺序为自父类至子类.
同一个类里面的静态变量和静态初始化代码的执行顺序, 只与其在代码中的顺序有关.
静态初始化结束后, 按类依次执行初始化和构造方法, 顺序为自父类至子类
父类的初始化和构造方法中, 如果调用了一个方法有被子类覆写, 则实际调用的是最终子类的方法.

class Parent {   
    // 静态变量   
    public static String p_StaticField = "父类--静态变量";   
    // 变量   
    public String p_Field = "父类--变量";   
  
    // 静态初始化块   
    static {   
        System.out.println(p_StaticField);   
        System.out.println("父类--静态初始化代码");   
    }   
  
    // 初始化块   
    {   
        System.out.println(p_Field);   
        System.out.println("父类--初始化代码");   
    }   
  
    // 构造器   
    public Parent() {   
        System.out.println("父类--构造器");   
    }   
}   
  
public class SubClass extends Parent {   
    // 静态变量   
    public static String s_StaticField = "子类--静态变量";   
    // 变量   
    public String s_Field = "子类--变量";   
    // 静态初始化块   
    static {   
        System.out.println(s_StaticField);   
        System.out.println("子类--静态初始化代码");   
    }   
    // 初始化块   
    {   
        System.out.println(s_Field);   
        System.out.println("子类--初始化代码");   
    }   
  
    // 构造器   
    public SubClass() {   
        System.out.println("子类--构造器");   
    }   
  
    // 程序入口   
    public static void main(String[] args) {   
        new SubClass();   
    }   
}  

初始化顺序为

1. 父类--静态变量 
2. 父类--静态初始化代码 
3. 子类--静态变量 
4. 子类--静态初始化代码 
5. 父类--变量 
6. 父类--初始化代码 
7. 父类--构造器 
8. 子类--变量 
9. 子类--初始化代码 
10. 子类--构造器

8.写出异常的分类，及每个类型下的常用异常类（至少写4个）。(忘记了)

异常的分类：受检异常和运行时异常
受检异常：SQLException FileNotFoundException ClassNotFoundException IOException  ...
运行时异常：AthrithometicException ArraysOutOfBoundsException NullPointorException ClassCastException ClassNotDefException 
...

9.写出Java中数据类型的分类？并写出每种基本数据类型在内存中所占字节数？

byte 1
short 2
int 4
long 8
float 4
double 8

char 2

boolean 

10.写出Java中流的分类？并写出读写文件常用的类。

三类：
   a.从流的方向：输入与输出
   b.从流的单位：字节和字符
   c.从功能上：节点与处理（包装）
   字节流：FileInputStream
                FileOutputStream
                BufferedInputStream
                BufferedOutputStream
   字符流：
               FileReader
               FileWriter
               BufferedReader
               BufferedWriter

11.写出递归读取指定文件夹下文件和目录（手写代码）

public static void listAllFiles(String path){
File dir = new File(path);
if(dir.exists()){
if(dir.isDirectory()){
File[] files = dir.listFiles();
for(File file:files){
String absolutePath =file.getAbsolutePath();
System.out.println(file.getName());
if(file.isFile()){//这端代码好像可以省略？
break;
}
listAllFiles(absolutePath);
}
}
}
}

12.写出对数组中的5个元素进行排序（冒泡、选择）【代码】

//对数组排序 选择排序
public static void sort(int[] nums){
        int temp = 0;
        for(int i=0;i<nums.length;i++){
            for(int j=i+1;j<nums.length;j++){
                if(nums[j]<nums[i]){
                   temp = nums[i];
                   nums[i]=nums[j];
                   nums[j]=temp;
                }
            }
        }
        for(int n:nums){
            System.out.println(n);
        }
    }
//冒泡排序：比较相邻两个元素
public static void sort2(int[] nums){
        int temp = 0;
        for(int i=0;i<nums.length-1;i++){
            for(int j=0;j<nums.length-1-i;j++){
                if(nums[j]>nums[j+1]){
                    temp = nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;
                }
            }
        }
        for(int n:nums){
            System.out.println(n);
        }
    }

13.写出final、this、super、static关键字的使用方法？（忘记了，周末需要整理一下）

final 修饰的类为最终类，不能被继承 final修饰的变量为常量，不能被修改,final修饰的方法不能被重写
this:  //网上摘录
   a.成员变量与局部变量重名时，用于区分成员变量和局部变量
   b. 调用本类的其他构造方法
   c.调用其本类的其他方法
super：//网上摘录
   a.直接引用父类的实例变量；
   b.通过super调用父类方法；
   c.使用super调用父类构造函数
static 修饰的量为静态变量（类变量）被本类的所有实例对象所共享；
        修饰的方法为静态方法 ，方法修饰符不为private时，可通过类名.方法名进行方法调用；
       任意一个该类的实例修改了值后，所有该类实例对象用的都是新变量值。

14.写出创建数据库、创建表、创建数据库用户的基本语法？

create database 数据库名;

create table user(
字段名 字段类型 约束和索引 注释
  )

create user 用户名@主机地址 password('密码')

15.什么是SQL?及SQL的分类？

SQL:结构化查询语言
SQL：DDL数据库定义语言：create ，alter,drop
     DML数据库操纵语言:insert update delete
     DQL数据库查询语言:select 

16.写出插入数据、修改数据、删除数据的SQL语法。

 insert int user(字段名1，字段名2...)
values(值1，值2...)，
          (值1，值2...)；               ；

update user set 字段名=新值 where 条件；

17.写出单例模式的代码。（忘记了）

一、懒汉式单例：(调用才创建，线程不安全)

   public class Singleton(){
    private Singleton(){}//构造方法设置为private，避免类在外部被实例化，在同一个虚拟机中，Singleton的唯一实例只能通过getInstance()方法访问；
    private static Singleton single = null;
//静态工厂方法
    public static Singleton getInstance(){
    if(single==null){
    single = new Singleton();
         }
      return single;
       }
以上方法线程不安全，将方法改为：
方式1：加同步
      public static synchronized Singleton getInstance(){
    if(single==null){
    single = new Singleton();
         }
      return single;
       }
或方式2：双重检查锁定
     public static Singleton getInstance(){
     if(single==null){
     synchronized(Singleton.class){
     if(single==null){
     single = new Singleton();
     }
   } 
  }
     return single; 
 }
}
或方式3：静态内部类;实现线程安全的同时，避免了线程同步带来性能影响
    public class Singleton{
     private static class innerClass{
    private static final Singleton INSTANCE = new Singleton();   
    }
    private Single(){}
    public static final Singleton getInstance(){
       return innerClass.INSTANCE;
    }
}

二、饿汉式单例,类初始化时即创建实例,创建后对象不再改变，线程安全。

public class Singleton{
    private Singleton(){}
    private static final Singleton single = new Singleton();
   //静态工厂方法
   public static Singleton getInstance(){
     return single;
   }
}

18.阐述Comparable和Comparator的区别（不清楚）

comparable支持排序,comparator不支持排序；

Comparable：实现该接口的对象成为可比较的对象，在对象内部定义一个比较的方法。

class People implements Comparable{

    private int id;
    private String name;
    private int age;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Object o) {
        if(null==o) return 0;
        if (o instanceof People){
           People p = (People)o;
           if(this.age==p.age&&this.id==p.id&&this.name.equals(p.name)){
               return 1;
           }
           return 0;
        }
        return 0;
    }
}

Comparator:实现该接口，相当于是创建了一个专门的比较器，在compare方法中写比较细节
class PeopleComparator implements Comparator<People> {
        @Override
        public int compare(People o1, People o2) {
            if(o1.getName().equals(o2.getName())&&o1.getAge()==o2.getAge()&&o1.getId()==o2.getId()){
                return 1;
            }
            return 0;
        }
    }