总目录展示
该笔记共八个节点(由浅入深),分为三大模块。
高性能。 秒杀涉及大量的并发读和并发写,因此支持高并发访问这点非常关键。该笔记将从设计数据的动静分离方案、热点的发现与隔离、请求的削峰与分层过滤、服务端的极致优化这4个方面重点介绍。
一致性。 秒杀中商品减库存的实现方式同样关键。可想而知,有限数量的商品在同一时刻被很多倍的请求同时来减库存,减库存又分为“拍下减库存”“付款减库存”以及预扣等几种,在大并发更新的过程中都要保证数据的准确性,其难度可想而知。因此,将用一个节点来专门讲解如何设计秒杀减库存方案。
高可用。 虽然介绍了很多极致的优化思路,但现实中总难免出现一些我们考虑不到的情况,所以要保证系统的高可用和正确性,还要设计一个PlanB来兜底,以便在最坏情况发生时仍然能够从容应对。笔记的最后,将带你思考可以从哪些环节来设计兜底方案。
篇幅有限,无法一个模块一个模块详细的展示(这些要点都收集在了这份《高并发秒杀顶级教程》里),麻烦各位转发一下(可以帮助更多的人看到哟!)
由于内容太多,这里只截取部分的内容。
元素
角标、下标、索引
数组的长度:元素的个数
3.数组的特点:
-
数组是序排列的
-
数组属于引用数据类型的变量。数组的元素,既可以是基本数据类型,也可以是引用数据类型
-
创建数组对象会在内存中开辟一整块连续的空间
-
数组的长度一旦确定,就不能修改。
4. 数组的分类:
① 二维数:一维数组、二维数组、。。。
② 照数组元素的类型:基本数据类型元素的数组、引用数据类型元素的数组
2.一维数组
======
1.一维数组的声明与初始化
int[] ids;//声明
//1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{1001,1002,1003,1004};
//1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
int[] arr4 = {1,2,3,4,5};//类型推断
1234567
错误的方式:
// int[] arr1 = new int[];
// int[5] arr2 = new int[5];
// int[] arr3 = new int[3]{1,2,3};
2.一维数组元素的引用:通过角标的方式调用。
数组的角标(或索引从0开始的,到数组的长度-1结束)
3.数组的属性:length
System.out.println(names.length);//5
System.out.println(ids.length);
说明:
数组一旦初始化,其长度就是确定的。arr.length
数组长度一旦确定,就不可修改。
4.一维数组的遍历
for(int i = 0;i < names.length;i++){
System.out.println(names[i]);
}
5.一维数组元素的默认初始化值
> 数组元素是整型:0
> 数组元素是浮点型:0.0
> 数组元素是char型:0或’\u0000’,而非’0’
> 数组元素是boolean型:false
> 数组元素是引用数据类型:null
3.二维数组
======
1.如何理解二维数组?
数组属于引用数据类型
数组的元素也可以是引用数据类型
一个一维数组A的元素如果还是一个一维数组类型的,则,此数组A称为二维数组。
2.二维数组的声明与初始化
int[] arr = new int[]{1,2,3};//一维数组
//静态初始化
int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
//动态初始化1
String[][] arr2 = new String[3][2];
//动态初始化2
String[][] arr3 = new String[3][];
//也是正确的写法:
int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};//类型推断
12345678910
错误的方式:
// String[][] arr4 = new String[][4];
// String[4][3] arr5 = new String[][];
// int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};
3.如何调用二维数组元素:
System.out.println(arr1[0][1]);//2
System.out.println(arr2[1][1]);//null
arr3[1] = new String[4];
System.out.println(arr3[1][0]);
System.out.println(arr3[0]);//
123
4.遍历二维数组元素
for(int i = 0; i < arr.length;i++)
for(int j = 0;j < arr[i].length;j++){
System.out.print(arr[i][j] + " ")
}
1234
4.数组常见算法
========
1.数组的创建与元素赋值:
杨辉三角(二维数组)、回形数(二维数组)、6个数,1-30之间随机生成且不重复。
2.针对于数值型的数组:
最大值、最小值、总和、平均数等
3.数组的复制与复制
int[] array1,array2;
array1 = new int[]{1,2,3,4};
3.1 赋值:
array2 = array1;
如何理解:将array1保存的数组的地址值赋给了array2,使得array1和array2共同指向堆空间中的同一个数组实体。
3.2 复制:
array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++){
array2[i] = array1[i];
}
如何理解:我们通过new的方式,给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。
5.Arrays工具类使用
=============
1.理解:
① 定义在java.util包下。
② Arrays:提供了很多操作数组的方法。
2.使用:
//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
int[] arr1 = new int[]{1,2,3,4};
int[] arr2 = new int[]{1,3,2,4};
boolean isEquals = Arrays.equals(arr1, arr2);
System.out.println(isEquals);
//2.String toString(int[] a):输出数组信息。
System.out.println(Arrays.toString(arr1));
//3.void fill(int[] a,int val):将指定值填充到数组之中。
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));
//4.void sort(int[] a):对数组进行排序。
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
//5.int binarySearch(int[] a,int key)
int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int index = Arrays.binarySearch(arr3, 210);
if(index >= 0){
System.out.println(index);
}else{
System.out.println(“未找到”);
}
123456789101112131415161718192021222324252627
三、面向对象
======
java类及其类成员
==========
1.类的设计中,两个重要结构之一:属性
对比:属性 vs 局部变量
1.相同点:
1.1 定义变量的格式:数据类型 变量名 = 变量值
1.2 先声明,后使用
1.3 变量都其对应的作用域
2.不同点:
2.1 在类中声明的位置的不同
属性:直接定义在类的一对{}内
局部变量:声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
2.2 关于权限修饰符的不同
属性:可以在声明属性时,指明其权限,使用权限修饰符。
常用的权限修饰符:private、public、缺省、protected —>封装性
目前,大家声明属性时,都使用缺性就可以了。
局部变量:不可以使用权限修饰符。
2.3 默认初始化值的情况:
属性:类的属性,根据其类型,都默认初始化值。
整型(byte、short、int、long:0)
浮点型(float、double:0.0)
字符型(char:0 (或’\u0000’))
布尔型(boolean:false)
引用数据类型(类、数组、接口:null)
局部变量:没默认初始化值。
意味着,我们在调用局部变量之前,一定要显式赋值。
特别地:形参在调用时,我们赋值即可。
12345
2.4 在内存中加载的位置:
属性:加载到堆空间中 (非static)
局部变量:加载到栈空间
2.类的设计中,两个重要结构之二:方法
方法:描述类应该具的功能。
1.举例:
1
-
public void eat(){}
-
public void sleep(int hour){}
-
public String getName(){}
-
public String getNation(String nation){}
2. 方法的声明:权限修饰符 返回值类型 方法名(形参列表){
方法体
}
3. 说明:
3.1 关于权限修饰符:默认方法的权限修饰符先都使用public
Java规定的4种权限修饰符:private、public、缺省、protected -->封装性再细说
3.2 返回值类型: 返回值 vs 没返回值
3.2.1 如果方法返回值,则必须在方法声明时,指定返回值的类型。同时,方法中,需要使用 return关键字来返回指类型的变量或常量:“return 数据”。如果方法没返回值,则方法声明时,使用void来表示。通常,没返回值的方法中,就不需要使用return.但是,如果使用的话,只能“return;”表示结束此方法的意思。
构造器(或构造方法):
构造器的作用:
-
1.创建对象
-
2.初始化对象的信息
使用说明:
1.如果没显式的定义类的构造器的话,则系统默认提供一个空参的构造器
2.定义构造器的格式:权限修饰符 类名(形参列表){}
3.一个类中定义的多个构造器,彼此构成重载
4.一旦我们显式的定义了类的构造器之后,系统就不再提供默认的空参构造器
5.一个类中,至少会有一个构造器。
三大特性(封装、继承、多态)
==============
面向对象的特征一:封装与隐藏
1.为什么要引入封装性?
我们程序设计追求“高内聚,低耦合”。
高内聚 :类的内部数据操作细节自己完成,不允许外部干涉;
低耦合 :仅对外暴露少量的方法用于使用。
隐藏对象内部的复杂性,只对外公开简单的接口。便于外界调用,从而提高系统的可扩展性、可维护性。通俗的说,把该隐藏的隐藏起来,该暴露的暴露出来。这就是封装性的设计思想。
2.封装性思想具体的代码体现:
体现一:将类的属性xxx私化(private),同时,提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
private double radius;
public void setRadius(double radius){
this.radius = radius;
}
public double getRadius(){
return radius;
}
体现二:不对外暴露的私有的方法
体现三:单例模式(将构造器私有化)
体现四:如果不希望类在包外被调用,可以将类设置为缺省的。
3.Java规定的四种权限修饰符
3.1 权限从小到大顺序为:private < 缺省 < protected < public
3.2 具体的修饰范围:
3.3 权限修饰符可用来修饰的结构说明:
4.种权限都可以用来修饰类的内部结构:属性、方法、构造器、内部类
修饰类的话,只能使用:缺省、public
面向对象特征二:继承性
1.继承性的格式:
class A extends B{}
-
A:子类、派生类、subclass
-
B:父类、超类、基类、superclass
2.子类继承父类以后有哪些不同?
2.1体现:一旦子类A继承父类B以后,子类A中就获取了父类B中声明的所有的属性和方法。
特别的,父类中声明为private的属性或方法,子类继承父类以后,仍然认为获取了父类中私的结构。只因为封装性的影响,使得人类不能直接调用父类的结构而已。
2.2 子类继承父类以后,还可以声明自己特有的属性或方法:实现功能的拓展。
-
子类和父类的关系,不同于子集和集合的关系。
-
extends:延展、扩展
3.Java中继承性的说明
3.1.一个类可以被多个子类继承。
3.2.Java中类的单继承性:一个类只能有一个父类
3.3.子父类是相对的概念。
3.4.子类直接继承的父类,称为:直接父类。间接继承的父类称为:间接父类
3.5.子类继承父类以后,就获取了直接父类以及所间接父类中声明的属性和方法
面向对象的特性三:多态性
1.多态性的理解:可以理解为一个事物的多种形态。
2.何为多态性:
对象的多态性:父类的引用指向子类的对象(或子类的对象赋给父类的引用)
举例:
Person p = new Man();
Object obj = new Date();
3.多态性的使用:虚拟方法调用
有了对象的多态性以后,我们在编译期,只能调用父类中声明的方法,但在运行期,我们实际执行的是子类重写父类的方法。
总结:编译,看左边;运行,看右边。
4.多态性的使用前提:
① 类的继承关系 ② 方法的重写
6.多态性使用的注意点:
对象的多态性,只适用于方法,不适用于属性(编译和运行都看左边)
关键字
===
关键字:this
1.可以调用的结构:属性、方法;构造器
2.this调用属性、方法:
this理解为:当前对象 或 当前正在创建的对象
2.1 在类的方法中,我们可以使用"this.属性"或"this.方法"的方式,调用当前对象属性或方法。但是通常情况下,我们都择省略"this."。特殊情况下,如果方法的形参和类的属性同名时,我们必须显式的使用"this.变量"的方式,表明此变量是属性,而非形参。
2.2 在类的构造器中,我们可以使用"this.属性"或"this.方法"的方式,调用当前正在创建的对象属性或方法。但是,通常情况下,我们都择省略"this."。特殊情况下,如果构造器的形参和类的属性同名时,我们必须显式的使用"this.变量"的方式,表明此变量是属性,而非形参。
3.this调用构造器:
① 我们在类的构造器中,可以显式的使用"this(形参列表)"方式,调用本类中指定的其他构造器
② 构造器中不能通过"this(形参列表)“方式调用自己
③ 如果一个类中有n个构造器,则最多有 n - 1构造器中使用了"this(形参列表)”
④ 规定:"this(形参列表)“必须声明在当前构造器的首行
⑤ 构造器内部,最多只能声明一个"this(形参列表)”,用来调用其他的构造器
关键字:abstract
abstract: 抽象的
1.可以用来修饰:类、方法
2.具体的:
abstract修饰类:抽象类
此类不能实例化
抽象类中一定有构造器,便于子类实例化时调用(涉及:子类对象实例化的全过程)
开发中,都会提供抽象类的子类,让子类对象实例化,完成相关的操作 —>抽象的使用前提:继承性
123
abstract修饰方法:抽象方法
抽象方法只方法的声明,没方法体
我的面试宝典:一线互联网大厂Java核心面试题库
以下是我个人的一些做法,希望可以给各位提供一些帮助:
整理了很长一段时间,拿来复习面试刷题非常合适,其中包括了Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等,且还会持续的更新…可star一下!
283页的Java进阶核心pdf文档
Java部分:Java基础,集合,并发,多线程,JVM,设计模式
数据结构算法:Java算法,数据结构
开源框架部分:Spring,MyBatis,MVC,netty,tomcat
分布式部分:架构设计,Redis缓存,Zookeeper,kafka,RabbitMQ,负载均衡等
微服务部分:SpringBoot,SpringCloud,Dubbo,Docker
还有源码相关的阅读学习
体
我的面试宝典:一线互联网大厂Java核心面试题库
以下是我个人的一些做法,希望可以给各位提供一些帮助:
整理了很长一段时间,拿来复习面试刷题非常合适,其中包括了Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等,且还会持续的更新…可star一下!
[外链图片转存中…(img-vBjyD5pW-1715693505831)]
283页的Java进阶核心pdf文档
Java部分:Java基础,集合,并发,多线程,JVM,设计模式
数据结构算法:Java算法,数据结构
开源框架部分:Spring,MyBatis,MVC,netty,tomcat
分布式部分:架构设计,Redis缓存,Zookeeper,kafka,RabbitMQ,负载均衡等
微服务部分:SpringBoot,SpringCloud,Dubbo,Docker
[外链图片转存中…(img-uYGq9E1j-1715693505831)]
还有源码相关的阅读学习
[外链图片转存中…(img-RTd0HX3L-1715693505832)]