方法重载
请记住下面重载的条件
- 方法名称必须相同。
- 参数列表必须不同(个数不同、或类型不同、参数类型排列顺序不同等)。
- 方法的返回类型可以相同也可以不相同。
- 仅仅返回类型不同不足以成为方法的重载。
- 重载是发生在编译时的,因为编译器可以根据参数的类型来选择使用哪个方法。
方法的重写
- 重写的方法必须要和父类保持一致,包括返回值类型,方法名,参数列表也都一样。
- 重写的方法可以使用 @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;}
}