java基础知识个人记录

迷南。 2022-02-13 15:49 233阅读 0赞

**ThreadLocal(线程变量副本)**  
Synchronized实现内存共享，ThreadLocal为每个线程维护一个本地变量。  
采用空间换时间，它用于线程间的数据隔离，为每一个使用该变量的线程提供一个副本，每个线程都可以独立地改变自己的副本，而不会和其他线程的副本冲突。  
ThreadLocal类中维护一个Map，用于存储每一个线程的变量副本，Map中元素的键为线程对象，而值为对应线程的变量副本。  
ThreadLocal在Spring中发挥着巨大的作用，在管理Request作用域中的Bean、事务管理、任务调度、AOP等模块都出现了它的身影。  
Spring中绝大部分Bean都可以声明成Singleton作用域，采用ThreadLocal进行封装，因此有状态的Bean就能够以singleton的方式在多线程中正常工作了。(适合在单例的环境下，使用线程内的局部变量处理逻辑)

**StringBuffer是线程安全的**

每次操作字符串，String会生成一个新的对象，而StringBuffer不会；StringBuilder是非线程安全的

**类加载器工作机制**

1.装载：将Java二进制代码导入jvm中，生成Class文件。  
2.连接：a）校验：检查载入Class文件数据的正确性 b）准备：给类的静态变量分配存储空间 c）解析：将符号引用转成直接引用  
3：初始化：对类的静态变量，静态方法和静态代码块执行初始化工作。  
双亲委派模型：类加载器收到类加载请求，首先将请求委派给父类加载器完成。 用户自定义加载器->应用程序加载器->扩展类加载器->启动类加载器

**面向对象的特征有哪些**

抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。

继承：

封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。

多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。

**多态的好处**

允许不同类对象对同一消息做出响应，即同一消息可以根据发送对象的不同而采用多种不同的行为方式(发送消息就是函数调用)。主要有以下优点：

*  可替换性：多态对已存在代码具有可替换性
 *  可扩充性：增加新的子类不影响已经存在的类结构
 *  接口性：多态是超类通过方法签名,向子类提供一个公共接口,由子类来完善或者重写它来实现的。
 *  灵活性
 *  简化性

**JAVA多态的实现原理**

*  接口实现 
 *  继承父类重写方法 
 *  同一类中进行方法重载

a.抽象的来讲，多态的意思就是同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）

b.实现的原理是动态绑定，程序调用的方法在运行期才动态绑定，追溯源码可以发现，JVM 通过参数的自动转型来找到合适的办法。

**抽象类的意义：**

*  为其他子类提供一个公共的类型
 *  封装子类中重复定义的内容
 *  定义抽象方法,子类虽然有不同的实现，但是定义时一致的

父类的静态方法能否被子类重写
    不能。重写只适用于实例方法,不能用于静态方法，而子类当中含有和父类相同签名的静态方法，我们一般称之为隐藏。
    
    什么是不可变对象
    不可变对象指对象一旦被创建，状态就不能再改变。任何修改都会创建一个新的对象，如 String、Integer及其它包装类。
    
    静态变量和实例变量的区别?
    静态变量存储在方法区，属于类所有。实例变量存储在堆当中，其引用存在当前线程栈。
    
    能否创建一个包含可变对象的不可变对象?
    当然可以创建一个包含可变对象的不可变对象的，你只需要谨慎一点，不要共享可变对象的引用就可以了，如果需要变化时，就返回原对象的一个拷贝。最常见的例子就是对象中包含一个日期对象的引用。

**java 创建对象的几种方式**

*  采用new
 *  通过反射
 *  采用clone
 *  通过序列化机制

前2者都需要显式地调用构造方法。造成耦合性最高的恰好是第一种，因此你发现无论什么框架，只要涉及到解耦必先减少new的使用。

## switch中能否使用string做参数 ##

在idk 1.7之前，switch只能支持byte, short, char, int或者其对应的封装类以及Enum类型。从idk 1.7之后switch开始支持String。

## switch能否作用在byte, long上? ##

可以用在byte上，但是不能用在long上。

## String对象的intern() ##

intern()方法会首先从常量池中查找是否存在该常量值，如果常量池中不存在则现在常量池中创建，如果已经存在则直接返回。  
比如   
String s1=”aa”;   
String s2=s1.intern();   
System.out.print(s1==s2);//返回true

也就是说 intern()方法使得字符串引用变量的指向更加明确 用常量池来管理这些内容  
这样就大大提高了==比较的速度。

synchronized (redisKey.intern()) {
        //这样是可以的
    }

## java当中的四种引用 ##

强引用，软引用，弱引用，虚引用。不同的引用类型主要体现在GC上:

*  强引用：如果一个对象具有强引用，它就不会被垃圾回收器回收。即使当前内存空间不足，JVM也不会回收它，而是抛出 OutOfMemoryError 错误，使程序异常终止。如果想中断强引用和某个对象之间的关联，可以显式地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。
 *  软引用：在使用软引用时，如果内存的空间足够，软引用就能继续被使用，而不会被垃圾回收器回收，只有在内存不足时，软引用才会被垃圾回收器回收。
 *  弱引用：具有弱引用的对象拥有的生命周期更短暂。因为当 JVM 进行垃圾回收，一旦发现弱引用对象，无论当前内存空间是否充足，都会将弱引用回收。不过由于垃圾回收器是一个优先级较低的线程，所以并不一定能迅速发现弱引用对象。
 *  虚引用：顾名思义，就是形同虚设，如果一个对象仅持有虚引用，那么它相当于没有引用，在任何时候都可能被垃圾回收器回收

//软引用，buff和SoftReference平级放，否则可能GC回收时异常
            for (int i = 0; i < 10; i++) {
                byte[] buff = new byte[1024 * 1024];
                SoftReference<byte[]> sr = new SoftReference<>(buff);
                list.add(sr);
            }
            //弱引用
            for (int i = 0; i < 10; i++) {
                byte[] buff = new byte[1024 * 1024];
                WeakReference<byte[]> sr = new WeakReference<>(buff);
                list.add(sr);
            }
    //虚引用实现方式
    
    public class PhantomReference<T> extends Reference<T> {
        /**
         * Returns this reference object's referent.  Because the referent of a
         * phantom reference is always inaccessible, this method always returns
         * <code>null</code>.
         *
         * @return  <code>null</code>
         */
        public T get() {
            return null;
        }
        public PhantomReference(T referent, ReferenceQueue<? super T> q) {
            super(referent, q);
        }
    }

## 为什么要有不同的引用类型 ##

不像C语言，我们可以控制内存的申请和释放，在Java中有时候我们需要适当的控制对象被回收的时机，因此就诞生了不同的引用类型，可以说不同的引用类型实则是对GC回收时机不可控的妥协。有以下几个使用场景可以充分的说明：

*  利用软引用和弱引用解决OOM问题：用一个HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象所占用的空间，从而有效地避免了OOM的问题.
 *  通过软引用实现Java对象的高速缓存:比如我们创建了一Person的类，如果每次需要查询一个人的信息,哪怕是几秒中之前刚刚查询过的，都要重新构建一个实例，这将引起大量Person对象的消耗，并且由于这些对象的生命周期相对较短，会引起多次GC影响性能。此时，通过软引用和 HashMap 的结合可以构建高速缓存，提供性能。

## a=a+b与a+=b有什么区别吗? ##

\+=操作符会进行隐式自动类型转换，此处a+=b隐式的将加操作的结果类型强制转换为持有结果的类型，而a=a+b则不会自动进行类型转换。

## short s1= 1; s1 = s1 + 1; 该段代码是否有错,有的话怎么改？ ##

有错误，short类型在进行运算时会自动提升为int类型，也就是说`s1+1`的运算结果是int类型。

## short s1= 1; s1 += 1; 该段代码是否有错，有的话怎么改？ ##

\+=操作符会自动对右边的表达式结果强转匹配左边的数据类型，所以没错。

## final, finalize和finally的不同之处 ##

final 是一个修饰符，可以修饰变量、方法和类。如果 final 修饰变量，意味着该变量的值在初始化后不能被改变。finalize 方法是在对象被回收之前调用的方法，给对象自己最后一个复活的机会，但是什么时候调用 finalize 没有保证。finally 是一个关键字，与 try 和 catch 一起用于异常的处理。finally 块一定会被执行，无论在 try 块中是否有发生异常。

static都有哪些用法?
    几乎所有的人都知道static关键字这两个基本的用法：静态变量和静态方法。也就是被static所修饰的变量/方法都属于类的静态资源，类实例所共享。
    
    除了静态变量和静态方法之外，static也用于静态块，多用于初始化操作：
    
    public calss PreCache{
       static{
           //执行相关操作
       }
    }
     
    
    此外static也多用于修饰内部类，此时称之为静态内部类。

java中int char,long各占多少字节?
    类型	位数	字节数
    short	2	16
    int	4	32
    long	8	64
    float	4	32
    double	8	64
    char	2	16

## java当中使用什么类型表示价格比较好? ##

如果不是特别关心内存和性能的话，使用BigDecimal，否则使用预定义精度的 double 类型。

## 什么导致线程阻塞 ##

阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），学过操作系统的同学对它一定已经很熟悉了。Java 提供了大量方法来支持阻塞，下面让我们逐一分析。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>sleep()</td> 
   <td>sleep() 允许 指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。 典型地，sleep() 被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后重新测试，直到条件满足为止</td> 
  </tr> 
  <tr> 
   <td>suspend() 和 resume()</td> 
   <td>两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的resume() 被调用，才能使得线程重新进入可执行状态。典型地，suspend() 和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后，调用 resume() 使其恢复。</td> 
  </tr> 
  <tr> 
   <td>yield()</td> 
   <td>yield() 使当前线程放弃当前已经分得的CPU 时间，但不使当前线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。调用 yield() 的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程</td> 
  </tr> 
  <tr> 
   <td>wait() 和 notify()</td> 
   <td>两个方法配套使用，wait() 使得线程进入阻塞状态，它有两种形式，一种允许 指定以毫秒为单位的一段时间作为参数，另一种没有参数，前者当对应的 notify() 被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify() 被调用。</td> 
  </tr> 
 </tbody> 
</table>

## synchronized和ReentrantLock的区别 ##

synchronized是和if、else、for、while一样的关键字，ReentrantLock是类，这是二者的本质区别。既然ReentrantLock是类，那么它就提供了比synchronized更多更灵活的特性，可以被继承、可以有方法、可以有[各种各样][Link 1]的类变量，ReentrantLock比synchronized的扩展性体现在几点上：   
（1）ReentrantLock可以对获取锁的等待时间进行设置，这样就避免了死锁   
（2）ReentrantLock可以获取各种锁的信息   
（3）ReentrantLock可以灵活地实现多路通知   
另外，二者的锁机制其实也是不一样的:ReentrantLock底层调用的是Unsafe的park方法加锁，synchronized操作的应该是对象头中mark word

3、String 是最基本的数据类型吗？  
答：不是。Java中的基本数据类型只有8个：byte、short、int、long、float、double、char、boolean

4、float f=3.4;是否正确？  
答:不正确。3.4是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，因此需要强制类型转换float f =(float)3.4; 或者写成float f =3.4F;。

5、short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗？  
答：对于short s1 = 1; s1 = s1 + 1;由于1是int类型，因此s1+1运算结果也是int 型，需要强制转换类型才能赋值给short型。而short s1 = 1; s1 += 1;可以正确编译，因为s1+= 1;相当于s1 = (short)(s1 + 1);其中有隐含的强制类型转换。

//整型字面量的值在-128到127之间，那么不会new新的Integer对象，
    //而是直接引用常量池中的Integer对象，所以上面的面试题中f1==f2的结果是true，而f3==f4的结果是false。
    public class Test03 {
     
        public static void main(String[] args) {
            Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
     
            System.out.println(f1 == f2);
            System.out.println(f3 == f4);
        }
    }

[Link 1]: https://www.baidu.com/s?wd=%E5%90%84%E7%A7%8D%E5%90%84%E6%A0%B7&tn=24004469_oem_dg&rsv_dl=gh_pl_sl_csd