Java基础核心知识学习笔记

方法重载

请记住下面重载的条件

方法名称必须相同。
参数列表必须不同（个数不同、或类型不同、参数类型排列顺序不同等）。
方法的返回类型可以相同也可以不相同。
仅仅返回类型不同不足以成为方法的重载。
重载是发生在编译时的，因为编译器可以根据参数的类型来选择使用哪个方法。

方法的重写

重写的方法必须要和父类保持一致，包括返回值类型，方法名，参数列表也都一样。
重写的方法可以使用 @Override 注解来标识
子类中重写方法的访问权限不能低于父类中方法的访问权限。

This关键字

这段代码比较精妙，精妙在哪呢，我一个 eatApple0方法竟然可以调用多次，你在后面还可以继续调

用，这就很神奇了，为啥呢？其实就是 this 在作票了，我在 eatApple 方法中加了一个 return

this 的返回值，也就是说哪个对象调用 eatApple 方法都能返回对象的自身。

main 方法中传递了一个 int 值为 10 的参数，它表示的就是苹果的数量，并把这个数量赋给了 num 全局变量。所以 num 的值现在就是 10。

你会发现上面这段代码使用的不是this，而是this（参数）。它相当于调用了其他构造方法，然后传递参数进去。这里注意一点：this0必须放在构造方法的第一行，否则编译不通过

public Apple(int num):

- 这个构造方法接收一个整数参数 num，表示苹果的数量。
- 它调用了另一个构造方法 Apple(int num, String color)，并传入了 num 和一个固定的字符串 "红色 " 作为参数。
- 这里的 this(num, "红色 ") 表示调用 Apple(int num, String color) 构造方法，其中 this 指的是当前正在创建的对象。

public Apple(String color):

- 这个构造方法接收一个字符串参数 color，表示苹果的颜色。
- 它调用了另一个构造方法 Apple(int num, String color)，并传入了默认数量 1 和 color 作为参数。
- 这里的 this(1, color) 表示调用 Apple(int num, String color) 构造方法，其中 this 指的是当前正在创建的对象。

public Apple(int num, String color):

- 这个构造方法接收两个参数：一个整数 num 和一个字符串 color。
- 在这个构造方法中，this 关键字被用来给成员变量 num 和 color 分别赋值为传入的参数 num 和 color。
- 这里的 this.num = num; 和 this.color = color; 中的 this 指的是当前正在创建的对象，而 num 和 color 是传入构造方法的参数。

Apple myApple = new Apple(5); 会创建一个数量为 5、颜色为红色的苹果。
Apple myGreenApple = new Apple("绿色"); 会创建一个数量为 1、颜色为绿色的苹果。
Apple myApples = new Apple(10, "黄色"); 会直接创建一个数量为 10、颜色为黄色的苹果。

继承

继承的关键字是extends

多态

多态指的是同一个行为具有多个不同表现形式。是指一个类实例（对象）的相同方法在不同情形下具有不同表现形式。封装和继承是多态的基础，也就是说，多态只是一种表现形式而已。

多态的实现具有三种充要条件

继承
重写父类方法
父类引用指向子类对象

你可以发现 main 方法中有一个很神奇的地方， Fruit fruit = new Apple( ）， Fruit 类型的对象

竟然指向了 Apple 对象的引用，这其实就是多态 ->父类引l用指向子类对象，因为 Apple 继承于

Fruit，并且重写了 eat 方法，所以能够表现出来多种状态的形式。

static关键字

final关键字

接口

interface

抽象类

abstract

异常

常见的Exception

RuntimeException 和 CheckedException

与 Exception 有关的 Java 关键字

throws 和 throw

try 、 finally 、 catch

集合

Iterable接口

顶层接口

ArrayList

Vector

Vector 同 ArrayList 一样，都是基于数组实现的，只不过 Vector 是一个线程安全的容器，它对内部的每

个方法都简单粗暴的上锁，避免多线程引起的安全性问题，但是通常这种同步方式需要的开销比较大，

因此，访问元素的效率要远远低于 ArrayList。

还有一点在于扩容上，ArrayList 扩容后的数组长度会增加 50%，而 Vector 的扩容长度后数组会增加一

倍。

LinkedList

双向链表

Stack

堆栈

HashSet

TreeSet

LinkedHashSet

Map类

Collections类

Collections 不属于 Java 框架继承树上的内容，它属于单独的分支， Collections 是一个包装类，它的作

用就是为集合框架提供某些功能实现，此类只包括静态方法操作或者返回 collections。

汇总图

泛型

泛型其实就是一种参数化的集合，它限制了你添加进集合的类型。泛型的本质就是一种参数化类型。多

态也可以看作是泛型的机制。一个类继承了父类，那么就能通过它的父类找到对应的子类，但是不能通

过其他类来找到具体要找的这个类。泛型的设计之处就是希望对象或方法具有最广泛的表达能力。

类、接口、方法、通配符

泛型方法的使用

泛型接口的使用

问题：接口中方法不是不能有方法体吗，为什么max有

从 Java 8 开始，引入了两种特殊类型的接口方法，它们可以包含方法体：

默认方法 (default 方法)：这些方法允许为接口方法提供默认实现。默认方法在接口中定义，并使用 default 关键字标记。
静态方法 (static 方法)：这些方法允许在接口中定义静态方法，它们的行为类似于类中的静态方法，而不是对象的方法。

泛型通配符

反射

Java 反射机制是在程序的运行过程中，对于任何一个类，都能够知道它的所有属性和方法；对于任意

一个对象，都能够知道调用它的任意属性和方法，这种动态获取信息以及动态调用对象方法的功能称为

java语言的反射机制。

反射举例解释一下

枚举

values() 方法显示顺序的值。

IO

File类

IO类

注解

AOP

AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，它旨在通过分离横切关注点（cross-cutting concerns）来提高代码的模块化程度。AOP 允许开发者将与业务逻辑无关的功能（如日志记录、事务管理、权限控制等）从业务逻辑中解耦出来，封装成独立的组件。

AOP 的核心概念

切面（Aspect）：封装了横切关注点的模块。例如，日志记录或事务管理等。
连接点（Join Point）：程序执行过程中的特定点，如方法调用或异常抛出等。
通知（Advice）：在特定连接点上执行的动作。通知可以是前置通知（before）、后置通知（after）、环绕通知（around）等。
切入点（Pointcut）：匹配连接点的表达式，用来指定哪些连接点应应用通知。
目标对象（Target Object）：被通知的对象。
代理（Proxy）：由 AOP 框架创建的对象，用来拦截目标对象的方法调用，并插入通知。

AOP 的使用场景

日志记录：在方法开始和结束时记录日志。
性能监控：测量方法执行的时间。
事务管理：自动管理事务边界。
权限验证：在方法调用前进行权限检查。
缓存管理：自动缓存方法结果。

AOP 的实现方式

AOP 可以通过多种方式实现，包括但不限于：

Spring AOP：Spring 框架提供的 AOP 支持，广泛用于 Java 应用程序中。
AspectJ：一种强大的 AOP 框架，支持编译时、加载时和运行时的织入。

Spring AOP 示例

以下是一个使用 Spring AOP 的简单示例，展示了如何为一个服务类的方法添加日志记录通知。

步骤 1: 创建一个切面类

创建一个切面类 LoggingAspect，该类包含前置通知和后置通知。



import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {
    
      @Around("execution(* com.example.service.*.*(..))")
11    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
    12        System.out.println("Before method: " + joinPoint.getSignature().getName());
    13        try {
        14            Object result = joinPoint.proceed();
        15            System.out.println("After method: " + joinPoint.getSignature().getName());
        16            return result;
        17        } catch (Throwable ex) {
        18            System.out.println("Error in method: " + joinPoint.getSignature().getName());
        19            throw ex;
        20        }
    21    }
22}

步骤 2: 创建一个服务类

创建一个服务类 Service，该类包含一个方法。

java


深色版本

1import org.springframework.stereotype.Service;
2
3@Service
4public class Service {
5
6    public void doSomething() {
7        System.out.println("Doing something...");
8    }
9}

步骤 3: 配置 Spring

确保你的 Spring 配置正确启用了 AOP 支持。

java


深色版本

1import org.springframework.context.annotation.Configuration;
2import org.springframework.context.annotation.EnableAspectJAutoProxy;
3
4@Configuration
5@EnableAspectJAutoProxy
6public class AppConfig {
7    // 配置类
8}

步骤 4: 使用服务类

在主类中使用 Service 类。

java


深色版本

1import org.springframework.beans.factory.annotation.Autowired;
2import org.springframework.boot.CommandLineRunner;
3import org.springframework.boot.SpringApplication;
4import org.springframework.boot.autoconfigure.SpringBootApplication;
5
6@SpringBootApplication
7public class Application implements CommandLineRunner {
8
9    @Autowired
10    private Service service;
11
12    public static void main(String[] args) {
13        SpringApplication.run(Application.class, args);
14    }
15
16    @Override
17    public void run(String... args) throws Exception {
18        service.doSomething();
19    }
20}

运行结果

当你运行这个应用程序时，你会看到在 doSomething 方法调用前后都有日志输出，这是因为切面中的通知被执行了。

总结

AOP 是一种强大的工具，可以帮助开发者更好地组织和管理代码中的横切关注点。通过将这些关注点从业务逻辑中分离出来，可以提高代码的可维护性和可扩展性。Spring AOP 是实现 AOP 的一种流行方式，适用于大多数基于 Spring 的 Java 应用程序。

例子

需求：统计各个业务层方法执行耗时。

实现步骤：

导入依赖：在pom.xml中导入AOP的依赖
编写AOP程序：针对于特定方法根据业务需要进行编程

为演示方便，可以自建新项目或导入提供的springboot-aop-quickstart项目工程

pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

AOP程序：TimeAspect

@Component
@Aspect //当前类为切面类
@Slf4j
public class TimeAspect {

    @Around("execution(* com.itheima.service.*.*(..))") 
    public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {
        //记录方法执行开始时间
        long begin = System.currentTimeMillis();

        //执行原始方法
        Object result = pjp.proceed();

        //记录方法执行结束时间
        long end = System.currentTimeMillis();

        //计算方法执行耗时
        log.info(pjp.getSignature()+"执行耗时: {}毫秒",end-begin);

        return result;
    }
}