【JAVA】【面试】【基础篇】- 基本功

时间 2019-11-07

原文原文链接

再快不能快基础，再烂不能烂语言！ java

【基础篇】- 基本功

什么是面向对象

现实世界存在的任务事物均可以称之为对象，面向对象是对现实世界建模的一种方式，将一种抽象的思想给具体实例化，对象中包含的内容特征是它的属性，对象的一些操做行为是它的方法。例如简历就是一个对象，里面的内容是它的属性，看、拿、放均可以称为这个对象的方法。mysql
面向对象的特征

封装：把描述一个对象的属性和行为封装成一个类，把具体的业务逻辑功能实现封装成一个方法，其次封装的意义还有效的保护属性经过访问修饰符私有化属性(成员变量),公有化方法。面试

继承：实现代码的复用，全部的子类所共有的行为和属性抽取为一个父类，全部的子类继承该类可具有父类的属性和行为，继承具备单一性和传递性。sql

多态：程序中定义的引用类型变量所指向的具体类型和调用的具体方法在程序编译阶段没法肯定，而是在运行期才能肯定该引用类型变量指向具体哪一个对象而调用在哪一个类中声明的方法。数据库

多态的表现形式有强制类型转换，向上造型等，多态可分为行为多态和对象多态。编程
- 行为多态：同一个run( ){ }方法，不一样的对象调用时会有不一样的实现，猫调用时是跑，鱼调用时是游，鸟调用时是飞。数组
- 对象多态：同一个对象，能够被造型为不一样的类型，好比同一我的对象，能够被造型为儿子，父亲，员工等。浏览器
面向对象的七大设计原则

1. 开闭原则(Open-Closed Principle, OCP)：安全

软件实体应对扩展开放，对修改关闭。在不修改现有代码的基础上去扩展新功能。bash

2. 单一职责原则（Single Responsibility Principle）：

定义一个类，应该只有一个职责。若是一个类有一个以上的职责，多个职责耦合在一块儿，会致使设计的局限性以及代码的复用性。

3. 里氏替换原则（Liskov Substitution Principle）：

子类型必须可以替换掉它们的父类型。子类能够扩展父类的功能，但不能改变父类原有的功能。当子类的方法重载父类的方法时，方法的前置条件(即方法的形参)要比父类方法的输入参数更宽松。当子类的方法实现父类的抽象方法时，方法的后置条件(即方法的返回值)要比父类更严格。

4. 迪米特法则（Law Of Demeter）：

迪米特法则又称为最少知道原则，即一个对象应该对其余对象保持最少的了解，只与直接的朋友通讯。若是两个类没必要彼此直接通讯，那么这两个类就不该当发生直接的相互做用。尽可能减小类与类之间的耦合。软件编程的总原则：低耦合高内聚。迪米特法则的初衷就是下降类之间的耦合，因为每一个类都减小了没必要要的依赖，所以的确能够下降耦合关系。

5. 依赖倒置原则（Dependence Inversion Principle）

高层模块不该该依赖低层模块，两者都应该依赖其抽象；抽象不该该依赖细节；细节应该依赖抽象。依赖倒置原则就是要咱们面向接口编程，理解了面向接口编程，也就理解了依赖倒置。

6. 接口隔离原则（Interface Segregation Principle）

客户端不该该依赖它不须要的接口；一个类对一个类的依赖应该创建在最小的接口上。

7. 合成/聚合原则(Composite/Aggregate Reuse Principle,CARP)

尽可能使用合成/聚合，尽可能不要使用继承。原则：一个类中有另外一个的对象。
低耦合高内聚的理解

内聚：每一个模块尽量独立完成本身功能，不依赖与模块外部的代码。

耦合：模块与模块之间接口的复杂程度，模块之间联系越复杂耦合度越高，牵一发而动全身。

低耦合是指减小对其余类的依赖，高内聚是指调用的方法尽可能写在本类中，对一个项目来讲，就是减小第三方依赖。
复制代码

final、finally、finalize的区别

final：能够用来修饰类、方法和变量(成员变量或局部变量)
- 修饰类：当修饰类的时候，表面该类不能被继承，注意：final类中全部的成员方法都会隐式的定义为final方法。
- 修饰方法：把方法锁定，防止继承对其修改。final修饰过的方法不能被重写。注意：若父类中final方法权限为private，子类不能继承，若子类从新定义相同方法名的函数，会认为是子类中的一个新方法。
- 修饰变量：final成员变量表示常量。只能被赋值一次，赋值后其值再也不改变。当final修饰一个基本数据类型时，表示该基本数据类型的值一旦初始化后便不能发生变化；若是final修饰一个引用类型时，则在对其初始化以后便不能再让其指向其余对象了，但该引用所指向的对象的内容是能够发生变化的。final修饰成员变量，必需要初始化。
finally：finally做为异常处理的一部分，它只能用在try/catch语句中，而且附带一个语句块，表示这段语句最终必定会被执行。

如下这几种状况是不会被执行的：
- 调用了System.exit()方法
- JVM崩溃了(异常状况致使)
finalize：finalize()是在java.lang.Object理定义的，也就是每个对象都有这么一个方法。这个对象在gc启动时，该对象被回收的时候被调用。其实gc能够回收大部分对象(凡是new出来的对象，gc都能搞定)，因此通常不须要去实现finalize的。

int 和 Integer的区别

Integer是int的包装类，int是java的一种基本数据类型。
Integer变量必须实例化后才能使用，int变量不须要。
Integer实际是对象的引用，当new一个Integer时，其实是对一个指针指向此对象；而int则是直接存储数据值。
Integer的默认值是null，int默认值是0.

public static void main(String[] args) {
    Integer i = 10;
    Integer j = 10;
    System.out.println(i == j);     //true
      
    Integer a = 128;
    Integer b = 128;
    System.out.println(a == b);     //false
     
    int k = 10;
    System.out.println(k == i);     //true
    int kk = 128;
    System.out.println(kk == a);    //true
      
    Integer m = new Integer(10);
    Integer n = new Integer(10);
    System.out.println(m == n);     //false
}
复制代码

重载和重写的区别

重载(Overloading)：重载发生在本类，方法名相同，参数列表不一样，与返回值无关，只和方法名、参数列表、参数的类型有关。
- 方法名必须相同
- 方法的参数列表必定不同
- 访问修饰符和返回类型能够相同也能够不一样
重写(Overriding)：重写发生在父类和子类之间，通常表示父类和子类之间的关系。
- 方法名必须相同，返回类型必须相同
- 参数列表必须相同
- 访问权限不能比父类中被重写的方法的访问权限更低。例如：父类的一个方法声明为public，那么子类重写后就不能声明为protected。

抽象类和接口的区别

抽象类：抽象类用abstract来修饰，抽象类是用来捕捉子类的通用性，它不能被实例化，只能用做子类的超类，抽象类是被用来建立继承层级里子类的模版。

接口：接口是抽象方法的集合，若是一个类实现了某个接口，那么它就继承了这个接口的抽象方法，就像契约模式，若是实现了这个接口，那么久必须保证使用这些方法，而且实现这些方法，接口是一种形式，接口自身不能作任何事情，接口里面的方法默认都是abstract的。

使用场景：

若是拥有一些方法，并想让他们中的一些有默认的具体实现，请选择抽象类。
若是想实现多重继承，那么请使用接口，因为java不支持多继承，子类不能继承多个类，但一个类能够实现多个接口，所以可使用接口来解决。
若是基本功能在不断变化，那么久使用抽象类，若是使用接口，那么每次变动都须要相应的去改变实现该接口的全部类。

参数	抽象类	接口
默认的方法实现	能够有默认的方法实现	彻底抽象，根本不存在方法实现
实现方式	子类用extends关键字来继承抽象类，若是子类不是抽象类的话，它须要实现父类抽象类中全部抽象方法，父类中非抽象方法可重写也可不重写	子类用implements去实现接口，须要实现接口中全部方法
构造器	抽象类能够有构造器(构造器不能用abstract修饰)	接口不能有构造器
与正常Java类区别	正常Java类可被实例化，抽象类不能被实例化	接口和正常java类是不一样的类型
访问修饰符	抽象方法能够用public、protected、default修饰	接口默认是public、不能用别的修饰符去修饰
main方法	抽象类能够有main方法，能够运行	接口中不能有main方法
多继承	抽象类可继承一个类和实现多个接口	接口能继承一个或多个接口

说说反射的用途及实现

反射：反射的核心是JVM在运行时才动态加载或调用方法/访问属性，它不须要事先(写代码或者编译期)知道运行对象是谁。注意：因为反射会额外消耗必定的系统资源，所以若是不须要动态地建立一个对象，那么久不须要反射。

反射框架提供的功能：
- 在运行时判断任意一个对象所属的类；
- 在运行时构造任意一个类的对象；
- 在运行时判断任意一个类所具备的成员变量和方法(经过反射甚至能够调用private方法)；
- 在运行时调用任意一个对象的方法
反射的用途：反射最重要的用途就是开发各类通用框架。

反射的基本实现：得到Class对象、判断是否为某个类的实例、建立实例、获取方法、获取构造器信息、获取类的成员变量、调用方法、利用反射建立数组。
说说自定义注解的场景及实现

java中有四种元注解：

@Retention：定义该注解的生命周期(何时使用该注解)

RetentionPolicy.RUNTIME:始终不会丢弃，运行期也保留注解，所以可使用反射机制读取该注解的信息。自定义注解时一般使用这种方式。

@Inherited：定义该注释和子类的关系(是否容许子类继承该注解)，若是一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类。

@Documented：一个简单的Annotations标记注解，表示是否将注解信息添加在java文档中(注解是否将包含在JavaDoc中)

@Target：表示该注解用在什么地方(注解用于什么地方)

ElementType.TYPE用于描述类、接口(包括注解类型)或enum声明。
```
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@Target({ElementType.FIELD,ElementType.METHOD})
@interface MyAnno{
    public String name() default "zhangsan";
    public String email() default "hello@example.com";
}
 
//建立用户类
class  User{
 
    @MyAnno(name = "zhang")
    private String name;
 
    @MyAnno(name = "zhang@example.com")
    private String email;
 
 
    @MyAnno(name = "sayHelloWorld")
    public String sayHello(){
        return "";
    }
复制代码
```

HTTP请求的GET和POST方式的区别

Get：通常用于获取、查询资源信息

POST：通常用于更新资源信息

Get请求	POST请求
请求参数会显示在地址栏中	请求参数不会显示在地址栏中
请求体是空	请求体是请求参数
请求参数显示在请求首行中(GET/name=aaa)	请求参数不显示在请求首行中(POST/ )
请求参数显示地址栏中【不安全】	地址栏不显示请求参数【相对安全】
请求参数放首行，http对请求首行显示1kb	请求参数放请求体，请求体没有大小限制
请求参数不能经过request.setCharacterEncoding("gbk")来设置编码	request.setCharacterEncoding("gbk")只能设置请求体的编码集

session和cookie区别
1. session存储在服务器端，cookie存储在客户端(浏览器)。
2. cookie不是很安全，别人能够分析存放在本地的cookie并进行cookie欺骗，考虑到安全应当使用session。
3. session会在必定时间内保存在服务器上。当访问增多，会比较占用服务器的性能，考虑到减轻服务器性能方面，应当使用cookie。
4. 单个cookie保存的数据不能超过4k，不少浏览器都限制一个站点最多保存20个cookie。
5. 能够考虑将登录信息等重要信息存放为session，其余信息如需保留，能够放在cookie中。
session分布式处理
1. 客户端cookie加密。（通常用于内网中企业级的系统中，要求用户浏览器端的cookie不能禁用，禁用的话，该方案会失效）。
2. 集群中，各个应用服务器提供了session复制的功能，Tomcat和Jboss都实现了这样的功能。特定：性能随着服务器增长急剧降低，容易引发广播风暴；session数据须要序列化，影响性能。
3. session的持久化，使用数据库来保存session。就算宕机了也没有事，数据库的session照样存在。特色：每次请求session都要读写数据库，会带来性能开销。使用内存数据库，会提升性能，可是宕机会丢失数据(像支付宝的宕机，有同城灾备，异地灾备)。
4. 使用共享存储来保存session。和数据库相似，就算宕机了也没事。其实就是专门搞一台服务器，所有对session落地。特定：频繁的进行序列化和反序列化会影响性能。
5. 使用memcached来保存session。本质上是内存数据库的解决方案。特色：存入memcached的数据须要序列化，效率极低。
JDBC流程
1. 注册驱动程序：Class.forName("com.mysql.jdbc.Driver");
2. 使用驱动管理类来获取数据链接对象：conn = DriverManager.getConnection(...);
3. 获取数据库操做对象：Statement state = conn.createStatement();
4. 定义操做的SQl语句
5. 执行state.executeQuery(sql);
6. 处理结果集：ResultSet，若是SQl前有参数值就设置参数值setXXX()
7. 关闭对象，回收数据库资源(关闭结果集->关闭数据库操做对象->关闭链接)

public class JDBCTest {
    /**
     * 使用JDBC链接并操做mysql数据库
     */
    public static void main(String[] args) {
        // 数据库驱动类名的字符串
        String driver = "com.mysql.jdbc.Driver";
        // 数据库链接串
        String url = "jdbc:mysql://127.0.0.1:3306/jdbctest";
        // 用户名
        String username = "root";
        // 密码
        String password = "1234";
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try {
            // 一、加载数据库驱动（ 成功加载后，会将Driver类的实例注册到DriverManager类中）
            Class.forName(driver);
            // 二、获取数据库链接
            conn = DriverManager.getConnection(url, username, password);
            // 三、获取数据库操做对象
            stmt = conn.createStatement();
            // 四、定义操做的SQL语句
            String sql = "select * from user where id = 100";
            // 五、执行数据库操做
            rs = stmt.executeQuery(sql);
            // 六、获取并操做结果集
            while (rs.next()) {
                System.out.println(rs.getInt("id"));
                System.out.println(rs.getString("name"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 七、关闭对象，回收数据库资源
            if (rs != null) { //关闭结果集对象
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (stmt != null) { // 关闭数据库操做对象
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null) { // 关闭数据库链接对象
                try {
                    if (!conn.isClosed()) {
                        conn.close();
                    }
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
复制代码

MVC设计思想

MVC是Model-View-Controller的简称，它是一种架构模式，它分离了表现与交互。分为三个核心部件：模型、视图、控制器。

Model(模型)，是程序的主体部分，主要包含业务数据和业务逻辑。在模型层，还会涉及到用户发布的服务，在服务中会根据不一样的业务需求，更新业务模型中的数据。

View(视图)，是程序呈现给用户的部分，是用户和程序交互的接口，用户会根据具体的业务需求，在View视图层输入本身特定的业务数据，并经过界面的事件交互
将对应的输入参数提交给后台控制器进行处理。

Controller(控制器)，Controller是用来处理用户输入数据，以及更新业务模型的部分。控制器中接收了用户与界面交互时传递过来的数据，并根据数据业务逻辑来
执行服务的调用和更新业务模型的数据和状态。

MVC架构的控制流程
1.全部的终端用户请求被发送到控制器。
2.控制器依赖请求去选择加载哪一个模块，并把模型附加到对应的视图。
3.附加了模型数据的最终视图作为相应发送给终端用户。
复制代码

equals与==的区别

比较基本数据类型时，只能采用==，比较的是数值

当比较引用数据类型时，==比较的是引用地址，而equals其实也是，equals是Object定义的方法，而其默认的显示也是比较地址。咱们经常使用的String类型，由于重写了equals方法，其内部比较的是内容。

更详细的面试总结连接请戳：👇👇
juejin.im/post/5db8d9…

【推荐篇】- 书籍内容整理笔记	连接地址
【推荐】【Java编程思想】【笔记】	juejin.im/post/5dbb7a…
【推荐】【Java核心技术卷Ⅰ】【笔记】	juejin.im/post/5dbb7b…

如有错误或者理解不当的地方，欢迎留言指正，但愿咱们能够一块儿进步，一块儿加油！😜😜

【JAVA】【面试】【 基础篇】- 基本功

【基础篇】- 基本功

什么是面向对象

面向对象的特征

面向对象的七大设计原则

低耦合高内聚的理解

final、finally、finalize的区别

int 和 Integer的区别

重载和重写的区别

抽象类和接口的区别

说说反射的用途及实现

说说自定义注解的场景及实现

HTTP请求的GET和POST方式的区别

session和cookie区别

session分布式处理

JDBC流程

MVC设计思想

equals与==的区别

更详细的面试总结连接请戳：👇👇juejin.im/post/5db8d9…

【JAVA】【面试】【基础篇】- 基本功

更详细的面试总结连接请戳：👇👇
juejin.im/post/5db8d9…