Java知识点总结

Java天书

第一章 简介

为广大程序猿提供的面试天书

第二章 Java SE 基础知识

一、Java面向对象

1.面向对象都有哪些特性以及你对这些特性的理解

1）继承：继承是从已有的类得到继承信息创建新类的工程。
2）封装：通常认为封装是把操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。
3）多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。
4）抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象指关注对象有哪些属性和行为，并不关注这些行为的细节是什么。
注意：默认情况下面向对象有3大特性，继承、封装、多态。如说4大特性，就加上抽象。

2.访问权限修饰符：public、private、protected，以及不写（默认）时的区别

1为true ，0为false

修饰符	当前类	同包	子类	其他包
Public	1	1	1	1
protected	1	1	1	0
Default	1	1	0	0
Private	1	0	0	0

3.如何理解clone对象

3.1为什么要用clone？

二、JavaSE语法

1.Java有没有沟通哦语句？

goto是Java中的保留字，在目前的Java版本中尚未使用。const也是保留字。
2.&和&&的区别
&运算符有两种用法：（1）按位与；（2）逻辑与
&&运算符是短路与运算符。
｜ 和｜｜亦如此

3.在Java中，如何跳出当前的多重的嵌套循环

在最外一层循环前加入一个开关标记flag，然后需要跳出时 break flag；即可跳出多重循环。
Continue：跳过本次循环。

4.两个对象值相同（w.equals(h)==true)，但却可有不用的hashcode，这句话对不对？

不对，如果两个对象w和h满足w.equals(h)==true，他们的哈希码（hashcoede）应当相同。两个对象相同（equals方法返回true），它们的hashcode一定相同。如果它们的hashcode相同，它们并不一定相同。

5.是否可以继承String

String类是final类，不可以被继承。
对于String类型最好的重用的方式为：
（1）关联关系（Has—A）
（2）依赖关系（Use—A）

6.当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递？

是 值传递。Java语言的方法调用只能支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的属性可以在被调用过程中被改变，但对对象引用的改变是不会影响到调用者。

集合

• 顶级接口java.util.Collection(存放的是元素本身)和java.util.Map(存放的是键值对)
• Collection接口下面有两个常用的子接口,分别是List(有序,可重复)和Set(无序,不可重复)
• Set接口下面有一个常用的子接口,SortedSet(有序的,不可重复)
• List接口的常用实现类:ArrayList,LinkedList,Vector
• 注意:Vector和ArrayList功能上基本一致,区别是Vector是线程安全的(性能低),而ArrayList是线程非安全的(性能高)
• Set接口的常用实现类:HashSet,TreeSet
• Map接口下面最常用的实现类是:HashMap,
• Map接口的子接口SortedMap,实现类是TreeMap

集合和数组的互转

1. 数组–>集合
   List integers = Arrays.asList(new Integer[] { 1, 2, 3 });
   List integers = Arrays.asList(1, 2, 3);

2. 集合–>数组
   空参方法返回的Object[]类型的数组,所以涉及到类型转换,存在风险!
   Object[] arr1 = intList.toArray();

ArrayList

1. ArrayList是一种有序,可重复的集合,它的底层实现是数组,所以查询效率高,增删效率低!

LinkedList(List接口的实现类)的特点:

1. 有序,可重复
2. 底层实现是双向链表,增删效率高,查询效率低(和ArrayList正好相反)

HashMap

1. Map集合的特点是双列集合,即集合中存放的不单单是元素本身,而是键值对(KEY-VALUE)
2. KEY无序不可重复,VALUE是可以重复的

HashMap和HashTable

1. HashMap和HashTable两个集合,前者是多线程并发不安全的,性能高;后者是多线程并发安全的,性能低
2. Properties是HashTable的子类,也就是说,Properties是线程安全的!

总结: Properties是一个Key为String,value也是String的线程安全的Map集合

TreeSet

1. Set接口下的实现类HashSet和Set接口下的子接口SortedSet的实现类TreeSet[有序不可重复]
2. Set集合的特点:
3. 无序,不可重复
4. 注意:此处的无序是指添加元素的顺序非最终元素存储的顺序

TreeSet

1. TreeSet集合特点:有序,不可重复

所谓单例，就是整个程序有且仅有一个实例。该类负责创建自己的对象，同时确保只有一个对象被创建。在Java，一般常用在工具类的实现或创建对象需要消耗资源。
特点

• 类构造器私有
• 持有自己类型的属性
• 对外提供获取实例的静态方法

懒汉模式:

线程不安全，延迟初始化，严格意义上不是不是单例模式

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
  
    public static Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();  
    }  
    return instance;  
    }  
}

饿汉模式:

线程安全，比较常用，但容易产生垃圾，因为一开始就初始化

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}

双重锁模式:

线程安全，延迟初始化。这种方式采用双锁机制，安全且在多线程情况下能保持高性能。

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
        if (singleton == null) {  
            singleton = new Singleton();  
        }  
        }  
    }  
    return singleton;  
    }  
}

双重检查模式，进行了两次的判断，第一次是为了避免不要的实例，第二次是为了进行同步，避免多线程问题。由于singleton=new Singleton()对象的创建在JVM中可能会进行重排序，在多线程访问下存在风险，使用volatile修饰signleton实例变量有效，解决该问题。

静态内部类单例模式

public class Singleton { 
    private Singleton(){
    }
      public static Singleton getInstance(){  
        return Inner.instance;  
    }  
    private static class Inner {  
        private static final Singleton instance = new Singleton();  
    }  
} 

只有第一次调用getInstance方法时，虚拟机才加载 Inner 并初始化instance ，只有一个线程可以获得对象的初始化锁，其他线程无法进行初始化，保证对象的唯一性。目前此方式是所有单例模式中最推荐的模式，但具体还是根据项目选择。

枚举单例模式:

public enum Singleton {
    INSTANCE;
}

默认枚举实例的创建是线程安全的，并且在任何情况下都是单例。实际上

枚举类隐藏了私有的构造器。
枚举类的域 是相应类型的一个实例对象
那么枚举类型日常用例是这样子的：

public enum Singleton  {
    INSTANCE 
 
    //doSomething 该实例支持的行为
      
    //可以省略此方法，通过Singleton.INSTANCE进行操作
    public static Singleton get Instance() {
        return Singleton.INSTANCE;
    }
}

枚举单例模式在《Effective Java》中推荐的单例模式之一。但枚举实例在日常开发是很少使用的，就是很简单以导致可读性较差。
在以上所有的单例模式中，推荐静态内部类单例模式。主要是非常直观，即保证线程安全又保证唯一性。
众所周知，单例模式是创建型模式，都会新建一个实例。那么一个重要的问题就是反序列化。当实例被写入到文件到反序列化成实例时，我们需要重写readResolve方法，以让实例唯一。

private Object readResolve() throws ObjectStreamException{
        return singleton;
}