Java-面试复习-整理02

最新推荐文章于 2024-08-16 23:08:28 发布

冼穆

最新推荐文章于 2024-08-16 23:08:28 发布

阅读量159

点赞数

分类专栏： Java-复习文章标签： java

本文链接：https://blog.csdn.net/qq_42211249/article/details/108361534

版权

Java-复习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

面向对象三大特性

封装

封装就是把同一类事物的共性（包括属性和方法）归到同一类中，方便使用。也称信息隐藏，是指利用抽象数据类型把数据和基于数据的操作封装起来，使其成为一个不可分割的整体，数据隐藏在抽象数据内部，尽可能的隐藏数据细节，只保留一些借口使其与外界发生联系。也就是说用户无需知道内部的数据和方法的具体实现细节，只需根据留在外部的接口进行操作就行。
封装的实现：需要修改属性的访问控制符（修改为private），创建getter/setter方法（用于属性的读写），在getter/setter方法中加入属性控制语句（用于判断属性值的合法性）。
属性（成员变量）随对象存放在堆中。
直接通过对象调用属性，修改属性值是不安全的，所以为了良好的封装，我们通常将类的成员变量声明为private，为了能够在外部使用，可以通过定义public方法来对这个变量进行访问。对一个变量的操作，一遍有读取和赋值两个操作，我们分别定义2个方法来实现这两个操作，一个是getXX（XX表示要访问的成员变量的名字）用来读取这个成员变量，另一个是setXX（）用来对这个变量赋值。
Boolean的get方法默认名为isXXX（）。
封装的优点：将变化隔离，便于使用，提高重用性和安全性。
缺点：将变量等使用private修饰，或者封装进方法内，使其不能被直接访问，增加了访问步骤与难度。

继承

继承关键字：extends
多个类具有共同的属性（成员变量）与行为（成员方法）的时候，将这些共同的部分抽取出来定义到一个公共的类中，其他各类可以与这个公共的类形成继承关系，从而在多个类中不需要重复定义公共部分。这个公共的类就是父类，也称为超类或者基类，其他的类就是子类。子类可以直接访问父类的非私有化成员变量，访问父类的私有化成员变量可以使用super.get()方法。
简单地说，继承是类与类的一种关系，比较像集合中的从属关系，比如说，狗属于动物，就可以看成狗类继承了动物类，那么狗类就是动物类的子类（派生类），动物类就是狗类的父类（基类）。在Java中是单继承的，也就是说一个子类只有一个父类。
继承的特点：子类比父类强大，单继承（不能进行多继承，但是可以继承多层子类（不建议超过3层）），子类继承父类，但是对父类的成员变量是无法直接操作的，只能通过父类继承过来的setter和getter方法。
继承的优点：减少代码量，提高复用率；使类与类之间存在继承关系，是实现多态操作的前提。
缺点：继承使得多个类之间具有了子父类关系，当一个类存在多个子类的时候，如果父类发生变化，那么这些子类会跟着一同变化，造成类与类之间的“强耦合”关系。
注意点：不要仅仅为了获取某个类的某个功能而去继承这个类；类与类之间要存在所属关系，不能够随意继承。
何时继承：具有公共的属性与行为操作的时候，提高复用性；具有is-a的所属关系的类与类之间。
结论：1.执行构造方法创建对象完成对象的初始化时，先执行父类的构造，完成父类的初始化，再执行本类的初始化工作。2.第一次创建父类，是直接继承Object，而Object是jdk提供的工具类，自然不会有属性，所以Object类只提供了无参的构造，在执行父类方法时，无论是无参还是有参都会先执行父类Object的无参构造。3.但是对于子类，必须也要有自己的构造方法，由于构造执行的特性，对于无参构造，先执行了子类的无参构造，对于有参构造，则先执行父类的有参，然后才执行本类属性的初始化。4.构造方法constructor中，无论是否显示还是隐式调用super()，子类在创建对象调用时都会执行super()；5.显示调用构造是在需要通过父类的带参构造来完成子类的带参构造。如Mobile类带参构造显示调用的super(brand,price,service)；6.对于父类私有的属性，即使子类继承，但是在test.java中，子类无法直接访问，在制定子类的带参构造方法是，只能通过调用父类的带参构造来完成。对于父类非私有的属性，子类对象可以直接调用。

多态

多态指的是对象的多种形态，有引用多态和方法多态。继承是多态的实现基础。
Java程序中定义的引用变量所指向的具体类型和通过该引用类型发出的方法在调用时不确定，该引用变量发出的方法到底调用哪个类的实现的方法，必须在程序运行期间才能决定，这就是多态。
多态存在的前提（三要素）：1.必须有子类和父类，具有继承或实现（继承）；2.子类必须重写父类的方法（重写）；3.父类的引用变量指向子类的对象（向上转型）。
优点：可替换性（多态对已存在的代码具有可替代性）；可扩充性（增加的子类不影响已存在的类的特性的运行和操作）；接口性（多态时超类通过方法签名向子类提供了一个公共的接口，由子类来完善或者覆盖它而实现）；灵活性（在应用中体现了灵活多样的操作，提高了使用的效率）；简化性（多态简化对应用软件的代码的编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要）
缺点：只能使用父类的引用访问父类的成员
多态中的成员特点：成员变量：编译与运行时期都看父类；成员方法：编译时期看父类，运行时期看子类。

四种Java引用

强引用、软引用、弱引用、虚引用

强引用：
一个对象如果只有强引用，那么垃圾回收器绝不会回收它，即使内存不足的情况下，jvm宁愿抛出内存不足的异常都不会回收该对象
比如new String("");
String s = new String("");
只有 s = null；才会回收掉

软引用：
如果一个对象只有软引用，如果内存充足的情况下，垃圾回收器不会回收，如果内存不足的情况下，垃圾回收器会回收该对象
Java中提供SoftReference处理软引用（当对象要被垃圾回收器回收的情况下，它会将该对象放到ReferenceQueue实例中，再次进行插入元素操作前，会检测当前队列中是否有数据，有数据则将数据进行删除）

弱引用：
弱引用所作用的对象，一旦发生垃圾回收，该引用所作用的对象就会被回收掉
弱引用和软引用的对象比较，生命力会更短
Java中提供WeakReference处理弱引用

虚引用：
虚引用无法左右当前对象的生命周期
Java中提供PhantomReference处理虚引用

一些模式

单例模式

单例模式：保证一个类仅有一个实例并提供一个访问它的全局访问点。
原因：多个线程要操作同一对象，要保证对象的唯一性。方法：实例化过程中只实例化一次。
特点：构造方法私有化，实例的变量引用私有化，获取实例的方法共有。
懒汉式单例化：

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 {
    /*
     * 利用静态变量来记录Singleton的唯一实例
     * volatile 关键字确保：当uniqueInstance变量被初始化成Singleton实例时，
     * 多个线程正确地处理uniqueInstance变量(保证了有序性，解决了编译重排重排和运行重排问题)
     */
    private volatile static Singleton uniqueInstance;
    /*
     * 构造器私有化，只有Singleton类内才可以调用构造器
     */
    private Singleton() {
    }
    /*
     *
     * 检查实例，如果不存在，就进入同步区域
     */
    public static Singleton getInstance() {
        if (uniqueInstance == null) {
            synchronized (Singleton.class) {    //进入同步区域
                if (uniqueInstance == null) {     //再检查一次，如果为null，则创建
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}

Static关键字：1.可以修饰成员变量和成员方法；2.随着类的加载而加载；3.优先于对象存在；4.被类的所有对象共享；5.可以通过类名调用，既可以通过对象名调用，也可以通过类名调用，建议通过类名调用。
注意：1.在静态方法中没有this对象；2.静态方法只能访问静态成员变量和成员方法。

简单工厂模式、工厂方法模式、抽象工厂模式：

工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪个类，工厂方法使一个类的实例化延迟到子类。
简单工厂的优点在于工厂类中包含了必要的逻辑判断，根据客户端的条件选择使用哪一种计算方法，但是如果增加新的方法需要在原有的工厂类中增加，这样就违反了开闭原则。
工厂方法解决了这个缺点，通过对每一种方法建立类，通过接口实现计算工厂达到不需要打开简单工厂的唯一工厂就可以增加新的方法，满足了扩展性。工厂方法把简单工厂的内部逻辑判断转移给了客户端，你想要的增加功能原本需要修改工厂类，现在是修改客户端。
抽象工厂：提供一个创建一系列相关或者互相依赖对象的接口，而无需指定他们的具体的类。优点：具体的创建实例过程与客户端分离，客户端通过他们的抽象接口操纵实现，产品的具体类名也被具体工厂实现分离。比如农场中抽象出水果和蔬菜两种产品，再具体实现北方工厂和热带工厂两种具体工厂，最后得到四种具体产品：北方水果、热带水果、北方蔬菜、热带蔬菜。

类加载

虚拟机产生的起点：Java虚拟机实例是通过调用某个初始化类的特定（main）方法：这个方法必须是共有的（public）、无返回值的（void）、静态的（static），并且可以接收一个字符串的数组作为参数（String[] args）

双亲委派机制：
1、当appClassLoader加载一个class时，他不会自己去尝试加载这个类，而是将类加载请求委托给父类加载器extension ClassLoader去完成
2、当Extension ClassLoader加载class时，不会去尝试加载这个类，而是将类加载请求委托给父类加载器Bootstrap ClassLoader去完成
3、如果Bootstrap ClassLoader加载失败，会使用Extension ClassLoader尝试加载
4、如果Extension ClassLoader加载失败，会使用appClassLoader尝试加载
5、如果appClassLoader也加载失败，则会抛出CLassNotFountException

类加载过程：
1、类加载子系统（class Loader Subsystem）
2、内存空间（运行时数区域：runtime data areas）
3、执行引擎（Execution Engine）

类加载的时机：
虚拟机规范中明确了在6种情况下会对类进行一个加载
1、创建对象实例：new对象的时候，会对类进行初始化，前提这个类没有被初始化
2、通过class文件反射创建对象
3、调用类的静态属性或静态属性赋值
4、调用类的静态方法
5、初始化一个类的子类，使用子类的时候先初始化父类
6、JAVA虚拟机启动时被标记为启动类的类：比如main方法所在的类

拷贝、序列化

如果拷贝的对象里的元素只有值，没有引用，是一样的，都会将原有对象复制一份，产生一个新对象，对新对象里的值进行修改不会影响原有对象，新旧对象完全分离开。
如果拷贝的对象里的元素包含引用，浅拷贝依然保存引用，指向原对象的引用，修改值会影响原对象，没有完全分离开，深拷贝则将原对象里的引用也新建一个，放新对象（如列表等）的引用，和原对象完全分离开。

数据对象转换为二进制流的过程称为对象的序列化。
1.Java原生序列化，serializable接口
2.Hessian序列化
3.Json序列化（transient关键字，避免把有些对象的敏感属性信息序列化）

MySQL

MySQL属于关系型数据库，目前属于Oracle甲骨文公司
MySQL数据库是一种C/S模型即客户端和服务端模型的数据库
客户端通过账号、密码连接服务器，连接成功后才可以进行数据库的操作（增加、删除、修改、查询 CRUD）
MySQL的服务端采用的是IO复用+可伸缩的线程池，实现了网络高并发的经典模型

MySQL的sql语句类别的划分：
DDL（Data Definition Language）：数据库定义语言
定义了不同的数据库、数据库表，列、索引等数据库对象的定义
常用的SQL：create、drop、alter（更新）

DML（Data Manipulation Language）：数据操控语言
用于添加、删除、变更和查询数据库记录
常用的SQL：insert、delete、update、select

DCL（Data Control Language）：数据控制语言
控制不同数据库段直接访问和访问级别的语句
常用SQL：grant、remove

常见优化手段

1.数据库表结构设计（第三范式）
2.数据库字段设计（命名规范、数据类型）
3.SQL查询语句优化（尽量使用索引，避免全表扫描，不要返回用不到的字段，尽量避免向客户端返回大数据量，避免大事务操作，提高系统并发能力）

数据库范式

数据库范式就是进行数据库设计时字段、库表划分的依据
1.第一范式（1NF）：每一列保持原子特征
列是基本数据项，不能再进行拆分，否则设计成一对多的关系
不满足第一范式不能称之为关系型数据库
2.第二范式（2NF）：属性完全依赖于主键（针对联合主键，消除部分依赖）
非主属性完全依赖于主键，如果不是依赖主键，应该拆分成新的主体，拆分成一对多
3.第三范式（3NF）：2NF基础上，属性不依赖于其他非主属性（消除传递依赖）
BCNF、4NF、5NF
通过范式的学习：应用范式越高、表越多、表越多带来的问题：
1.查询时需要连接多个表，增加了查询的复杂性
2.查询时需要连接多个表，降低了数据库查询的性能
范式并不是越高越好，一般满足3NF即可

索引

索引是一种提高查询效率的数据结构（B树或者是哈希结构）
索引是创建在数据库表中，对数据库表中的一列或者多列值进行排序的一个结果，好处就是提高查询效率

索引的分类：
普通索引：没有任何限制、可以给任意字段创建普通索引
唯一性索引：使用unique修饰的字段，值不能重复，主键索引就属于唯一性索引
主键索引：使用primary key修饰的字段自动创建主键索引
单列索引：在一个字段上创建索引
多列索引：在多个字段上创建索引
全文索引：使用fulltext参数可以设置全文索引，只支持char\varchar\text类型的字段上，常用于数据量较大的字符串类型上

组合索引和多个单列索引

组合索引快，为什么？
1.需要加索引的字段，要在where条件中
2.数据量少的字段不需要加索引，因为建索引有一定开销，如果数据量小则没必要建索引（速度反而慢）
3.如果where条件中是OR关系，加索引不起作用
4.联合索引比对每个列分别建索引更有优势，因为索引建立得越多就越占磁盘空间，在更新数据的时候速度会更慢。另外建立多列索引时，顺序也是需要注意的，应该将严格的索引放在前面，这样筛选的力度会更大，效率更高。

注：多个单列索引在多条件查询时只会生效第一个索引，所以多条件联合查询时最好建联合索引。

索引的创建和删除SQL：

一、索引的创建
1、在创建表的时候指定索引字段
create table table_mname (
id int,
name varchar(12),
index(id);
);

2、在已经创建表上添加索引
2.1 create [unique|fulltext|spatial] index idx_id(索引名) on 表名(id(属性名));
2.2 alter table 表名 add [unique|fulltext|spatial] index index_name(属性名);

二、删除索引
drop index index_name on 表名;

索引的底层原理

MySQL支持两种索引，一种是B树索引，一种是哈希表索引，这两种索引的查询效率是比较高的
MySQL InnoDB存储引擎，基于B-树（实际MySQL采用的是B+树）的索引结构
B-树是一种m阶平衡树，叶子节点都在同一层，由于每一个节点存储的数据量比较大，索引整个B-树的层数是非常低的，基本上不超过三层
由于磁盘的读取也是按block块操作的（内存是按page页面操作的），因此B-树的节点大小一般设置为和磁盘块大小一致，这样一个B-树节点，就可以通过一次磁盘I/O把一个磁盘块的数据全部存储下来，所以当使用B-树存储索引的时候，磁盘I/O的操作次数是最少的（MySQL的读写效率，主要集中在磁盘I/O上）

那么MySQL最终为什么要采用B+树存储索引结构呢，我们来看看B-树和B+树在存储结构上有什么不同：
1.B-树的每一个节点，存了关键字和对应的数据地址，而B+树的非叶子节点只存关键字，不存数据地址。因此B+树的每一个非叶子节点存储的关键字是远远多于B-树的，B+树的叶子节点存放关键字和数据。因此，从树的高度上来说，B+树的高度要小于B-树，使用的磁盘I/O次数少，因此查询会更快一些。
2.B-树由于每个节点都存储关键字和数据，因此离根节点近的数据，查询就很快，离根节点远的数据，查询就很慢；B+树所有的数据都存在叶子节点上，因此在B+树上搜索关键字，找到对应数据的时间是比较平均的，没有快慢之分。
3.在B-树上如果做区间查找，遍历的节点是非常多的；B+树所有叶子节点都被连接成了有序链表结构，因此做整表遍历和区间查找是非常容易的。

哈希索引当然由哈希表实现，但哈希表对数据并不排序，因此不适合做区间查找，效率非常低，需要搜索整个哈希表结构。

exits和in性能比较

in：
确定给定的值

事务

事务隔离级别

TRANSACTION_NONE。表示不支持事务
TRANSACTION_READ_UNCOMMITTED。未提交读。说明在提交前一个事务可以看到另一个事务的变化。这样读”脏”数据，不可重复读和虚读都是被允许的。
TRANSACTION_READ_COMMITTED。已提交读。说明读取未提交的数据是不允许的。这个级别仍然允许不可重复读和虚读产生。
TRANSACTION_REPEATABLE_READ。可重复读。说明事务保证能够再次读取相同的数据而不会失败，但虚读仍然会出现。
TRANSACTION_SERIALIZABLE。可序列化/串行化。是最高的事务级别，它防止读脏数据，不可重复读和虚读。

需注意：事务隔离级别越高，为避免冲突所花费的性能也就越多。
可以通过Connection接口下面的函数来设置事务的隔离级别

冼穆

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java-面试复习-整理02

目录面向对象三大特性封装继承多态一些模式单例模式面向对象三大特性封装封装就是把同一类事物的共性（包括属性和方法）归到同一类中，方便使用。也称信息隐藏，是指利用抽象数据类型把数据和基于数据的操作封装起来，使其成为一个不可分割的整体，数据隐藏在抽象数据内部，尽可能的隐藏数据细节，只保留一些借口使其与外界发生联系。也就是说用户无需知道内部的数据和方法的具体实现细节，只需根据留在外部的接口进行操作就行。封装的实现：需要修改属性的访问控制符（修改为private），创建getter/setter方
复制链接

扫一扫

专栏目录