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

java基础

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

向上转型

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

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

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

向上转型的作用

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

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

抽象类

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

接口

接口中可以包含变量和方法，变量被隐式指定为 public static final，方法被隐式指定为 public abstract（JDK 1.8一个类可以同时实现多个接口，一个类实现某个接口则必须实现该接口中的抽象方法，否则该类必须被定义为抽象类
接口支持多继承，即一个接口可以继承（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对象创建的方式

使用new关键字创建对象
反射:
通过反射创建对象的方式又有两种，一是通过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());
}

反序列化
序列化：指把 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

2024年java面试准备--java基础篇（一）