wordpress做出影视网站网页设计欣赏

方法重载

请记住下面重载的条件

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

方法的重写

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

This关键字

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

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

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

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

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

1. public Apple(int num):

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

1. public Apple(String color):

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

1. 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 开始，引入了两种特殊类型的接口方法，它们可以包含方法体：

1. 默认方法 (default 方法)：这些方法允许为接口方法提供默认实现。默认方法在接口中定义，并使用 default 关键字标记。
2. 静态方法 (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 的使用场景

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

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 应用程序。

例子

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

实现步骤：

1. 导入依赖：在pom.xml中导入AOP的依赖
2. 编写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;}
}