2024年java面试准备--java基础篇

java基础

这些java基础的相关知识是我准备实习期间总结一些网上java基础和自己被面试官询问到的一些知识点，供大家学习参考，有问题可私信我，后续会更新集合、spring、线程、mysql、redis等相关知识点和面试易考点~~

向上转型

向上转型：一句话总结就是“父类引用指向子类对象”

关于方法：父类引用可以调用子类和父类公用的方法（如果子类重写了父类的方法，则调用子类的方法），但子类特有的方法无法调用。

关于属性: 父类引用可以调用父类的属性，不可以调用子类的属性

向上转型的作用

1. 减少一些重复性的代码
2. 对象实例化的时候可以根据不同需求实例化不同的对象

自增（前）b=++a可以写成a=a+1，b=a。 自增（后）b=a++可以写成b=a，a=a+1。

抽象类

1. 使用abstract修饰的类或方法，就抽象类或者抽象方法
2. 抽象类是不能具体的描述一个对象，不能用抽象类直接实例化对象
3. 抽象类里面的成员变量和成员方法，都是和普通类一样的，只不过就是不能进行实例化了
4. 当一个普通类继承这个抽象类后，那么这个普通类必须重写抽象类当中的所有的抽象方法（我们之前说过抽象类是不具体的，没有包含足够的信息来描述一个对象，所以我们需要把他补充完整）
5. 但当一个抽象类A继承了抽象类B，这是抽象类A就可以不重写抽象类B当中的抽象方法
6. final不能修饰抽象类和抽象方法（因为抽象类存在的最大意义就是被继承，而被final修饰的不能被继承，final和抽象，他们两个是天敌）
7. 抽象方法不能被private修饰（抽象方法一般都是要被重写的，你被private修饰了，还怎么重写）
8. 抽象类当中不一定有抽象方法，但如果一个类中有抽象方法，那么这个类一定是抽象类。

接口

1. 接口中可以包含变量和方法，变量被隐式指定为 public static final，方法被隐式指定为 public abstract（JDK 1.8一个类可以同时实现多个接口，一个类实现某个接口则必须实现该接口中的抽象方法，否则该类必须被定义为抽象类
2. 接口支持多继承，即一个接口可以继承（extends）多个接口，间接解决了 Java 中类不能多继承的问题。

抽象类和接口有什么区别

继承方面

抽象类只能单继承;而接口可以多继承

成员属性方面

抽象类中可以有普通属性，也可以有常量;

接口中的成员变量全部默认是常量，使用public static final修饰，这个可以省略不写

代码块方面

抽象类可以含初始化块;

接口不能含初始化块

构造函数方面

抽象类可以有构函数，但是这里的构造函数不是用来创建对象的，而且用来被实现类调用进行初始化操作的

接口不能有构造函数;

方法方面

接口在JDK1.8之后可以定义抽象方法(无方法体)、default修饰的默认方法(有方法体)、static修饰的静态方法(有方法体)，JDK1.8以前是只能有抽象方法。

抽象类中除了静态方法和抽象方法外还可以有普通方法。

二者相同之处

接口与抽象类都不能被实例化，需要被其他进行实现或继承。

接口与抽象类里面都能包含抽象方法，实现接口或继承抽象类的子类都必须实现这些抽象方法。

设计模式

1.JDK中常用的设计模式

单例模式：用于 Runtime，Calendar 和其他的一些类中。

工厂模式：被用于各种不可变的类如 Boolean，像 Boolean.valueOf。

观察者模式：被用于 Swing 和很多的事件监听中。

装饰器模式：被用于多个 Java IO 类中。

2.Spring中常用的设计模式

工厂模式：BeanFactory就是简单工厂模式的体现，用来创建对象的实例；

单例模式：Bean默认为单例模式。

代理模式：Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术；

模板方法：用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTemplate。

观察者模式：定义对象键一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知被制动更新，如Spring中listener的实现–ApplicationListener。

3. 单例模式

某个类只能生成一个实例，该实例全局访问，例如Spring容器里一级缓存里的单例池。

优点：

唯一访问：如生成唯一序列化的场景、或者spring默认的bean类型。

提高性能：频繁实例化创建销毁或者耗时耗资源的场景，如连接池、线程池。

缺点：

不适合有状态且需变更的

实现方式：

饿汉式：线程安全速度快，饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了。

懒汉式：双重检测锁，第一次减少锁的开销、第二次防止重复、volatile防止重排序导致实例化未完成，而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。本身是非线程安全的

静态内部类：线程安全利用率高+

枚举：effictiveJAVA推荐，反射也无法破坏

4. 工厂模式

定义一个用于创建产品的接口，由子类决定生产何种产品。

优点： 解耦：提供参数即可获取产品，通过配置文件可以不修改代码增加具体产品。

缺点： 每增加一个产品就得新增一个产品类

5. 抽象工厂模式

提供一个接口，用于创建相关或者依赖对象的家族，并由此进行约束。

优点： 可以在类的内部对产品族进行约束

缺点：假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。

6.观察者模式

观察者模式是一种对象行为模式。它定义对象间的一种一对多的依赖关系，当一个对象(目标对象)的状态发生改变时，所有依赖于它的对象(观察对象)都得到通知并被自动更新。

特点：被观察者和观察者一般是一对多的关系，一个被观察者对应多个观察者，当一个被观察者的状态发生改变时，被观察者通知观察者，然后可以在观察者内部进行业务逻辑的处理。

7.装饰器模式

装饰器模式是一种结构型设计模式，用于在不修改原有对象的基础上动态地给对象添加新的功能。装饰器模式通过创建一个新的装饰器类，继承原有类的基本功能，然后扩展或覆盖原有功能。装饰器模式可以在运行时根据需要灵活地给对象添加或组合功能。

8.代理模式

给一个对象提供一种代理对象以控制对该对象的访问。 简单点理解： 目标对象：原对象，我们需要通过代理对象控制它的访问，扩展其功能。 代理对象：代理模式产生的对象，是原对象的替身，在原有基础上进行修改。 在不改变原对象代码的基础上对原对象的功能进行扩展 再简单点理解： 比如点外卖事件 你想吃麻辣烫，自己又不想去店里吃，所以你点外卖，此时的外卖小哥，可以看作为代理对象。而你又想在吃完麻辣烫后喝一杯珍珠奶茶，所以你又联系外卖小哥帮你去店里买一杯。这个过程可以理解为加的扩展功能。

什么是面向对象

Java是面向对象的编程语言，不同于C语言是面向过程的。对于面向对象和面向过程的区别，举一个简单的例子说明一下(我们以洗衣机洗衣服为例)∶

面向过程:

面向过程的编程方式，程序会将要完成的某一个任务拆解成一系列的小步骤(函数)，如:。

①打开洗衣机:methodo1()

②放入要洗的衣服:method02()。

③放入洗衣粉:method03()。

④清洗: methodo4()

⑤烘干: method05()

面向对象:面向对象的编程方式，程序会将要完成的洗衣机洗衣服的任务拆分成如下两个对象:

人(Person ):Person在洗衣机洗衣服这个程序任务中有三个作用，分别是打开洗衣机、放入要洗的衣服、放入洗衣粉

洗衣机(Nachine ): Machine在洗衣机洗衣服这个程序任务中有两个作用，分别是清洗、烘干

Java对象创建的方式

1. 使用new关键字创建对象
   
2. 反射:
   通过反射创建对象的方式又有两种，一是通过Class.newInstance
   

public void aa() throws Exception{
    Class c = Student.class;
    Student student =(Student)c.newInstance();
    student.setSId(1);
    system.out.println(student.getSId());
}

二是通过调用构造器再去创建对象Constructor.newInstance

先通过反射获取类中无参构造器，然后通过newInstance()获取对象：

public void aa() throws Exception{
    Class<Student> c = Student.class;
    Constructor<Student> constructor = c.getConstructor();
    Student student = constructor.newInstance();
    student.setSId(1);
    System.out.println(student.getSId( ));
}

3. Clone

通过Clone创建对象首先要在实体类中必须先实现Cloneable接口并复写Object的clone方法（因为Object的这个方法是protected的，你若不复写，外部也调用不了呀）。

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student implements Cloneable {
    private int sId;
    private String sName;
    @Override
    public Student clone() throws CloneNotSupportedException {
        return (Student) super.clone();
    }
}

public void aa() throws CloneNotSupportedException {
    student_student = new Student();
    Student clone = student.clone();
    clone.setSId(1);
    System.out.println(clone.getSId());
}

1. 反序列化
   序列化：指把 Java 对象转换为字节序列的过程；
   反序列化：指把字节序列恢复为 Java 对象的过程；
   因此我们可以通过反序列化创建对象，具体代码如下：
   

public void aa() throws IOException,ClassNotFoundException {
    File file = new File("E:/a.txt");
    FileOutputStream fos = new FileoutputStream(file);
    objectoutputStream oos = new objectOutputStream(fos);
    Student student1 = new Student();
    oos. writeobject(student1);
    FileInputStream fis = new FileInputStream(file);
    0bjectInputStream ois = new ObjectInputStream(fis);
    Student student2 = (Student) ois.readObject();
    student2.setSId(1);
    System.out.println(student2.getSId());
}

2024年java面试准备--java基础篇（二）https://developer.aliyun.com/article/1393059