java -- 一些基础和镜子_镜子推算时间 java-CSDN博客

本文链接：https://blog.csdn.net/qq_39308071/article/details/82286864

一，基本功

(一)，面向对象的特征

面向对象的三大特征：1.继承 2.封装 3.多态性

（1）继承：就是保留父类的属性，开扩新的东西。通过子类可以实现继承，子类继承父类的所有状态和行为，同时添加自身的状态和行为。

（2）封装：就是类的私有化。将代码及处理数据绑定在一起的一种编程机制，该机制保证程序和数据不受外部干扰。

（3）多态：是允许将父对象设置成为和一个和多个它的子对象相等的技术。包括重载和重写。重载为编译时多态，重写是运行时多态。

(二)，final, finally, finalize 的区别

1. final

在java中，final可以用来修饰类，方法和变量（成员变量或局部变量）

1.1.修饰类：当用final修饰类的时，表明该类不能被其他类所继承。当我们需要让一个类永远不被继承，此时就可以用final修饰，但要注意：final类中所有的成员方法都会隐式的定义为final方法。

1.2.修饰方法：使用final方法的原因主要有两个：

(1) 把方法锁定，以防止继承类对其进行更改。

(2) 效率，在早期的java版本中，会将final方法转为内嵌调用。但若方法过于庞大，可能在性能上不会有多大提升。因此在最近版本中，不需要final方法进行这些优化了。

final方法意味着“最后的、最终的”含义，即此方法不能被重写。

注意：若父类中final方法的访问权限为private，将导致子类中不能直接继承该方法，因此，此时可以在子类中定义相同方法名的函数，此时不会与重写final的矛盾，而是在子类中重新地定义了新方法。

1.3 修饰变量

final成员变量表示常量，只能被赋值一次，赋值后其值不再改变。类似于C++中的const。

当final修饰一个基本数据类型时，表示该基本数据类型的值一旦在初始化后便不能发生变化；如果final修饰一个引用类型时，则在对其初始化之后便不能再让其指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。本质上是一回事，因为引用的值是一个地址，final要求值，即地址的值不发生变化。　

final修饰一个成员变量（属性），必须要显示初始化。这里有两种初始化方式，一种是在变量声明的时候初始化；第二种方法是在声明变量的时候不赋初值，但是要在这个变量所在的类的所有的构造函数中对这个变量赋初值。

当函数的参数类型声明为final时，说明该参数是只读型的。即你可以读取使用该参数，但是无法改变该参数的值。

在java中，String被设计成final类，那为什么平时使用时，String的值可以被改变呢？

字符串常量池是java堆内存中一个特殊的存储区域，当我们建立一个String对象时，假设常量池不存在该字符串，则创建一个，若存在则直接引用已经存在的字符串。当我们对String对象值改变的时候，例如 String a="A"; a="B" 。a是String对象的一个引用（我们这里所说的String对象其实是指字符串常量），当a=“B”执行时，并不是原本String对象("A")发生改变，而是创建一个新的对象("B")，令a引用它。

2. finally

2.1. finally作为异常处理的一部分，它只能用在try/catch语句中，并且附带一个语句块，表示这段语句最终一定会被执行（不管有没有抛出异常），经常被用在需要释放资源的情况下。（×）（这句话其实存在一定的问题）

2.2.很多人都认为finally语句块一定会执行，但真的是这样么？答案是否定的，只有与finally对应的try语句块得到执行的情况下，finally语句块才会执行。

（1）,方法在try前返回或出现异常；

（2）,try 或catch语句块中执行了 System.exit (0) 语句，终止了 Java 虚拟机的运行；

（3）,当一个线程在执行 try 语句块或者 catch 语句块时被打断（interrupted）或者被终止（killed），与其相对应的 finally 语句块可能不会执行。还有更极端的情况，就是在线程运行 try 语句块或者 catch 语句块时，突然死机或者断电，finally 语句块肯定不会执行了。

2.2.在try-catch-finally语句中执行return语句。

finally return 会覆盖其他所有的返回；

(三)，int 和 Integer 有什么区别

Java是面向对象的编程语言，一切都是对象，但是为了编程的方便还是引入了基本数据类型，为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换，对应如下：

原始类型：boolean，char，byte，short，int，long，float，double

包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

顺便一提，Java中的基本数据类型只有以上8个，除了基本类型（primitive type），剩下的都是引用类型（reference type）。

所以最基本的一点区别是：Ingeter是int的包装类，int的初值为0，Ingeter的初值为null。

1，无论如何，Integer与new Integer不会相等。不会经历拆箱过程，new出来的对象存放在堆，而非new的Integer常量则在常量池（在方法区），他们的内存地址不一样，所以为false。

2，两个都是非new出来的Integer，如果数在-128到127之间，则是true,否则为false。因为java在编译Integer i2 = 128的时候,被翻译成：Integer i2 = Integer.valueOf(128);而valueOf()函数会对-128到127之间的数进行缓存。

3，两个都是new出来的,都为false。还是内存地址不一样。

4，int和Integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比。

(四)，重载和重写的区别

1.重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。

2.父类方法被默认修饰时，只能在同一包中，被其子类被重写，如果不在同一包则不能重写。

父类的方法被protoeted时，不仅在同一包中，被其子类被重写，还可以不同包的子类重写。

父类方法被private时，由于方法被隐藏所以不能重写，这时子类与父类的相同方法，没有实际关联关系。

1.1而重载的规则：

（1）、必须具有不同的参数列表；

（2）、可以有不同的返回类型，只要参数列表不同就可以了；

（3）、可以有不同的访问修饰符；

（4）、可以抛出不同的异常；

2.1重写方法的规则：

（1）、参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。

（2）、返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写而是重载。

（3）、访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）

（4）、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如：

父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常，可以抛出非检查异常。

(五)，抽象类和接口有什么区别

1，基础特性

抽象类是用来捕捉子类的通用特性的。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。

接口是抽象方法的集合。如果一个类实现了某个接口，那么它就继承了这个接口的抽象方法。这就像契约模式，如果实现了这个接口，那么就必须确保使用这些方法。接口只是一种形式，接口自身不能做任何事情。

2，抽象类和接口的对比

参数	抽象类	接口
默认的方法实现	可以有默认的方法实现	接口完全是抽象的。它根本不存在方法的实现
实现	子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。	子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现
构造器	抽象类可以有构造器	接口不能有构造器
与正常Java类的区别	除了你不能实例化抽象类之外，它和普通Java类没有任何区别	接口是完全不同的类型
添加新方法	如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。	如果你往接口中添加方法，那么你必须改变实现该接口的类。
访问修饰符	抽象方法可以有public、protected和default这些修饰符	接口方法默认修饰符是public。你不可以使用其它修饰符。
main方法	抽象方法可以有main方法并且我们可以运行它	接口没有main方法，因此我们不能运行它。
多继承	抽象方法可以继承一个类和实现多个接口	接口只可以继承一个或多个其它接口
速度	它比接口速度要快	接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。
		,3

3，什么时候使用抽象类和接口

（1）如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。

（2）如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。

（3）如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。

(六)，说说反射的用途及实现

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

Java反射框架提供以下功能：

          (1)、在运行时判断任意一个对象所属的类
          (2)、在运行时构造任意一个类的对象
      (3)、在运行时判断任意一个类所具有的成员变量和方法（通过反射设置可以调用 private）
      (4)、在运行时调用任意一个对象的方法

反射最重要的用途就是开发各种通用框架。

例：spring 的 ioc/di 也是反射....
           javaBean和jsp之间调用也是反射....
           struts的 FormBean 和页面之间...也是通过反射调用....
           JDBC 的 classForName()也是反射.....
           hibernate的 find(Class clazz) 也是反射....

举一个例子，在运用Struts 2框架的开发中我们一般会在struts.xml里去配置Action，比如：

<action name="login"  class="com.test.action.SimpleLoginAction"   method="execute">
           <result>/index.jsp</result>
           <result name="error">login.jsp</result>
</action>

重点：是运行时而不是编译时。由于反射会额外消耗一定的系统资源，因此如果不需要动态地创建一个对象，那么就不需要用反射。另外，反射调用方法时可以忽略权限检查，因此可能会破坏封装性而导致安全问题

           1.反射指的是对象的反向处理操作，是根据对象来取得对象的来源信息。
           2.类的对象的三种产生模式
          (1)任何类的对象可以通过Object类中的getClass()方法取得Class类对象。
          (2)"类.class"：直接根据某个具体的类来取得Class类的对象。
          (3)使用Class类提供的方法：

Date date = new Date();
Class<?> class1 = date.getClass();
Class<?> class2 = Date.class;
Class<?> class3 = Class.forName("java.util.Date");
Object object1 = class1.newInstance();
Object object2 = class2.newInstance();
Object object3 = class3.newInstance();
System.out.println(object1);
System.out.println(object2);
System.out.println(object3);

控制台
Sat Sep 01 16:47:59 CST 2018
Sat Sep 01 16:47:59 CST 2018
Sat Sep 01 16:47:59 CST 2018

(七)，说说自定义注解的场景及实现

1，注解有什么用？注解的作用基本有三个：
(1) .生成文档。这是最常见的，也是java 最早提供的注解。常用的有 @see @param @return 等
(2) .跟踪代码依赖性，实现替代配置文件功能。比较常见的是spring 2.5 开始的基于注解配置。作用就是减少配置。现在的框架基本都使用了这种配置来减少配置文件的数量。也是
(3).在编译时进行格式检查。如@override 放在方法前，如果你这个方法并不是覆盖了超类方法，则编译时就能检查出。

https://www.cnblogs.com/dalaoyang/p/8657030.html

(八)，HTTP 请求的 GET 与 POST 方式的区别

不安全安全长度有限制无

(九)，session 与 cookie 区别

(十)，session 分布式处理

(十一)，JDBC 流程

(十二)，MVC 设计思想

(十三)，equals 与 == 的区别

== 判断的是”地址“是否相等。
而equles判断的是“内容”是否相等。

关于变量之间的比较，可以分为基础类型变量的比较和对象之间的比较。

对于基本类型来说，他们存储在jvm的栈中，因此比较的是变量的内容，也就是比较的变量的值。

关于变量之间的比较，可以分为基础类型变量的比较和对象之间的比较。

对于基本类型来说，他们存储在jvm的栈中，因此比较的是变量的内容，也就是比较的变量的值。

但根据创建对象的方式不同可以分为两种情况，这里会引入两个新的问题：

（1）.为什么表达式创建和new创建，会让==比较产生不同的结果。（Integer i=1;和Integer i=new Integer(1);）

这是因为jvm在程序运行的时候会创建一个缓冲池，当使用表达式创建的时候，程序会在缓冲池中寻找相同值的对象，如果找到，就把这个对象的地址赋给当前创建的对象，因此，c和d实际上都指向了c的引用。因此在使用==时会返回true。

当用new创建对象时，是在堆中重新分配内存，因此栈中的引用是不相同的，所以，a和b引用的是值相同的不同对象。所以a==b返回false

（2）.既然equals比较的是引用，那么a.equals（b）为什么返回true。这是因为在Integer里，重写了equals方法！

集合

List 和 Set 区别
List 和 Map 区别
Arraylist 与 LinkedList 区别
ArrayList 与 Vector 区别
HashMap 和 Hashtable 的区别
HashSet 和 HashMap 区别
HashMap 和 ConcurrentHashMap 的区别
HashMap 的工作原理及代码实现
ConcurrentHashMap 的工作原理及代码实现

线程

创建线程的方式及实现
sleep() 、join（）、yield（）有什么区别
说说 CountDownLatch 原理
说说 CyclicBarrier 原理
说说 Semaphore 原理
说说 Exchanger 原理
说说 CountDownLatch 与 CyclicBarrier 区别
ThreadLocal 原理分析
讲讲线程池的实现原理
线程池的几种方式
线程的生命周期

锁机制

说说线程安全问题
volatile 实现原理
synchronize 实现原理
synchronized 与 lock 的区别
CAS 乐观锁
ABA 问题
乐观锁的业务场景及实现方式

核心篇

数据存储

MySQL 索引使用的注意事项
说说反模式设计
说说分库与分表设计
分库与分表带来的分布式困境与应对之策
说说 SQL 优化之道
MySQL 遇到的死锁问题
存储引擎的 InnoDB 与 MyISAM
数据库索引的原理
为什么要用 B-tree
聚集索引与非聚集索引的区别
limit 20000 加载很慢怎么解决
选择合适的分布式主键方案
选择合适的数据存储方案
ObjectId 规则
聊聊 MongoDB 使用场景
倒排索引
聊聊 ElasticSearch 使用场景

缓存使用

Redis 有哪些类型
Redis 内部结构
聊聊 Redis 使用场景
Redis 持久化机制
Redis 如何实现持久化
Redis 集群方案与实现
Redis 为什么是单线程的
缓存奔溃
缓存降级
使用缓存的合理性问题

消息队列

消息队列的使用场景
消息的重发补偿解决思路
消息的幂等性解决思路
消息的堆积解决思路
自己如何实现消息队列
如何保证消息的有序性

框架篇

Spring

BeanFactory 和 ApplicationContext 有什么区别
Spring Bean 的生命周期
Spring IOC 如何实现
说说 Spring AOP
Spring AOP 实现原理
动态代理（cglib 与 JDK）
Spring 事务实现方式
Spring 事务底层原理
如何自定义注解实现功能
Spring MVC 运行流程
Spring MVC 启动流程
Spring 的单例实现原理
Spring 框架中用到了哪些设计模式
Spring 其他产品（Srping Boot、Spring Cloud、Spring Secuirity、Spring Data、Spring AMQP 等）