2023年之我拿起“java“

java

java基础

java是一门面向对象的语言

了解 j a v a 的语法，从 H e l l o W o r l d 开始 \color{red}{了解java的语法，从HelloWorld开始} 了解java的语法，从HelloWorld开始

//此处写类体
public class Test {
    //此处是主函数
    public static void main(String[] args) {
        //输出语句
        System.out.println("HelloWorld");
    }
}

j a v a 语言的注释 \color{red}{java语言的注释} java语言的注释

单行注释 //

//这是单行注释

多行注释 /* */

注意：多行注释本可以嵌套使用

/*
这是多行注释
*/

一个类中的 p u b l i c c l a s s 和 c l a s s 的区别 \color{red}{一个类中的public class 和 class的区别} 一个类中的publicclass和class的区别

  1. 一个 java 源文件中可以定义多个 class。
  2. 一个 java 源文件中 public 的 class 不是必须的。
  3.一个 class 会定义生成一个class字节码文件。
  4.一个 java 源文件中定义公开的类的话，只能有一个，并且该类名必须和 java 源文件名称一致。
  5.每一个 class 当中都可以设定程序的入口。

j a v a 中的标识符 \color{red}{java中的标识符} java中的标识符

什么是标识符

  1.在 Java 源文件中凡是程序员有权利自己命名的单词都是标识符。

标识符可以标识什么元素

  1.类名
  2.方法名
  3.变量名
  4.接口名
  5.常量名

这些名称我们在下面的知识中会介绍到的。

标识符的命名规则

  1.一个合法的标识符只能由 数字、下划线、字母、美元符号组成，无其他符号。
  2.不能数字开头。
  3.严格区分大小写.
  4.关键字不能做标识符.
5.理论上不能太长，但是 java 无长度限制。

标识符的命名规范

  1.最好见名知意。
  2.遵守驼峰命名方式。
    例如：UserService;SystemService;
  3.类名、接口名：首字母大写，后面每个单词首字母大写。
  4.变量名、方法名：首字母小写，后面每个单词首字母大写。
  5.变量名：全部大写。

j a v a 中的关键字 \color{red}{java中的关键字} java中的关键字

  关键字在 java 语言中全部小写。
    例如：int, double.

j a v a 中的字面值 \color{red}{java中的字面值} java中的字面值

  字面值就是数据。
    例如：10.00；“abc”；‘a’;

j a v a 中的变量 \color{red}{java中的变量} java中的变量

什么是变量

  1.变量本质上来说是内存中的一块空间，这快空间有数据类型、有名字、有面值。
  2.变量包含三部分：数据类型、名称、字面值【数据】。
  3.变量是内存中存储数据的结构的最基本单元。

数据类型的作用

  1.不同的数据类型有不同的类型，不同的数据类型底层分配不同的大小空间。
  2.数据类型是指导程序运行阶段应该分配多大的内存空间。

变量的要求

  1.数据与数据类型一致。

声明格式

  1.数据类型 变量名；
    例如：int a = 10;

什么是作用域

  1.变量出了大括号就消失了

变量的分类

  1.局部变量：在方法体中声明的变量叫局部变量。
  2.成员变量：在方法体外【类体之内】声明的变量叫成员变量。
  3.java遵循就近原则。
类体中不能直接编写 Java 语句【除声明变量之外】。

数据类型 \color{red}{数据类型} 数据类型

数据类型的主要作用

  1.数据类型的主要作用是指导JVM(java 虚拟机)在运行程序的时候给该数据分配多大的空间。

基本数据类型

  1.基本数据类型包括四大类八大种。

整数型

$byte(1),short(2),int(4),long(8)$

浮点型

$float(4),double(8)$

布尔型

$boolean(1)$ 只有true,false两种值。

字符型

$char(2)$ 取值范围 0 - 65535

引用数据类型

  1.类。
  2.接口。
  3.数组。
  等等……

基本数据类型之间的相互转换

  1.八种数据类型除了 布尔值 之外，剩下的7种数据类型之间都可以相互转换。
  2.小容量向大容量转化，称为自动类型转换，容量从小到大的排序。

$byte<short(char)<int<long<float<double$

任何浮点型不管占用多少个字节，都比整数型容量大。
char 和 short 可表示的种类相同，但是char 可以取更加大的整数。
  3.大容量转化为小容量，叫做强制类型转换，需要加强制类型转换符，程序才能通过编译，但在运行阶段可能损失精度，所以谨慎使用。
  4.当整数字面值没有超出 byte,short,char的取值范围，可以直接赋值给 byte,short,char 类型的变量。
  5.byte,short,char混合运算的时候，先各自转化成 int 类型在做运算。
  6.多种数据类型混合运算，先转换成容量最大的那种类型在做运算。
  7.关系运算符的结果一定是布尔类型：true\flase。
  8.byte和short 不能直接转换成char类型。

$消化一下知识在接着往下看吧！！！$

键盘录入 \color{red}{键盘录入} 键盘录入

关键字 Scanner

需要使用关键字了，不同数据类型的录入，代码也会有些许差异。

//导包
import java.util.Scanner;

//此处写类体
public class Test {
    //此处是主函数
    public static void main(String[] args) {
        // 创建对象 需要使用关键字 Scanner 
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数据");
        //这里我们录入 int 类型的数据
        int result =sc.nextInt();
        //打印我们录入的数据
        System.out.println("你录入的数据式："+result);
        //这里的 "+" 用于字符串的拼接
    }
}

分析以上代码：键盘录入的步骤
  1.导包

import java.util.Scanner;

  2.创建对象

 Scanner sc = new Scanner(System.in);

  3.接受数据

int result =sc.nextInt();

接受不同的数据，只需要修改步骤三 接受数据这一步

//接受byte类型的数据
 byte num = sc.nextByte();
 //接受short类型的数据
short num1 = sc.nextShort();
 //接受int类型的数据
int num2 = sc.nextInt();
//接受long类型的数据
long num3 = sc.nextLong();
//接受float类型的数据
float num4 = sc.nextFloat();
//接受double类型的数据
double num5 = sc.nextDouble();
//接受String类型的数据
String num6 = sc.next();

生成随机数 \color{red}{生成随机数} 生成随机数

需要使用关键字，生成不同的数据类型的数据，代码也会有所差异

//导包
import java.util.Random;
//此处写类体
public class Test {
    //此处是主函数
    public static void main(String[] args) {
        //创建对象需要使用Random关键字
        Random random = new Random();
        //创建整数类型随机数
        int result = random.nextInt();
        
    }
}

分析以上代码：键盘录入的步骤
  1.导包

import java.util.Random;

  2.创建对象

Random random = new Random();

  3.接受数据

int result = random.nextInt();

创建不同的数据，只需要修改步骤三 接受数据这一步

具体方法参考上面Scanner的方法。

随机数扩展

生成区间的随机数：【最小值，最大值】

//导包
import java.util.Random;

//此处写类体
public class Test {
    //此处是主函数
    public static void main(String[] args) {
        //创建对象需要使用Random关键字
        Random random = new Random();
        //创建0 -10 的整数类型  [0,11)
        int result = random.nextInt(11);
    }
}

循环 \color{red}{循环} 循环

for 循环

带索引的for循环

int n = 10;
for(int i = 0; i < n; i++){
	System.out.println(i);
}

快速结束嵌套循环

//外层循环起名 out
out:
for (int i = 0; i < 10; i++) {
    //内存循环起名 in
    in:
    for (int j = 0; j < 10; j++) {
        //当j等于5时，结束外层循环
        if(j==5){
            break out;
        }
    }
}

增强for循环

//ArrayList集合 这里不需要了解，我们重点看for循环
ArrayList<String> list  = new ArrayList<>()
for(String s : list){
    System.out.println(s);
}

while循环

//括号里面放boolean类型的值
while(true){
	System.out.println("这里是while循环");
}

do while循环

特点：循环至少循环一次

do{
	System.out.println("这里是do while循环");
}while(true)
//括号里面放boolean类型的值 

j a v a 的 M a t h 包 \color{red}{java的Math包} java的Math包

  1.导入包

import static java.lang.Math.*;

  2.列举几个常用方法

~求绝对值

int num = 10;
int result = Math.abs(num);

~求开方

double = 3.0;
double result = Math.sqrt(num);

等等等，还有很多方法，这里我们不一一列举。

一维数组 \color{red}{一维数组} 一维数组

定义

  数组是一个容器用来储存相同数据类型数据的容器。

格式

数据类型[] 数组名；
int[] arr;

数组初始化

数组动态初始化

格式

数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[3];

动态数组初始化取值

数组数据类型 变量名 = 数组名[索引];
int a = arr[0];

索引就是数组中每个初始化空间的编号。

静态数组初始化取值

数据类型[] 数组名 = new 数据类型[]{……};
int [] arr = new int[]{1,2,3,4,5,6,7,8,9};

数据类型[] 数组名 = {……};
int[] arr = {1,2,3,4,5,6,7,8,9};

数组求长度

数组名.length;
int len = arr.length;

数组遍历

int[] arr = new int[10];
for (int i = 0; i < arr.length; i++) {
	   int result1 = arr[i];
	   System.out.println("这是遍历数组");
}

查看数组

System.out.println(Arrays.toString(arr));

二维数组 \color{red}{二维数组} 二维数组

二维数组动态初始化

数据类型 [][] 变量名 = new 数据类型 [m][n];

二维数组遍历

int[][] arr1 = new int[3][4]; //3行4列的二维数组
for (int i = 0; i < arr1.length; i++) {
    for (int j = 0; j < arr1[i].length; j++) {
        System.out.println("这是二维数组的遍历");
    }
}

数组中不同数据类型的默认值

  1.整数数据类型
byte,short,int,long默认值为0。

  2.浮点数据类型
float,double 默认值0.0

  3.char数据类型
char 默认值 \u0000。

  4.boolean数据类型
boolean默认值false。

  5.引用数据类型
String 默认值时null。

升序排序的数组函数

Arrays.sort(arr);

冒泡排序 \color{red}{冒泡排序} 冒泡排序

int[] arr = {4,2,5,1,3};
//排序只需要排序 总长度减1次
for (int i = 0; i < arr.length-1; i++) {
    //每次排序都会确定一个数据的位置
    for (int j = 0; j < arr.length-1-i; j++) {
        if(arr[j]>arr[j+1]){
            //创建一个中间遍历 tmp进行交换两个数据
            int tmp=arr[j];
            arr[j]=arr[j+1];
            arr[j+1]=tmp;
        }
    }
}

初识方法 \color{red}{初识方法} 初识方法

概述

  1.方法就是解决问题的方法。

  2.编程中的方法，具有特定功能的代码快。

特点

  1.方法和方法之间时平行关系，不能嵌套定义。

  2.方法定义后不会自己执行，需要调用后才能执行。

  3.方法定义的先后顺序和方法执行的顺序无关，和方法调用的顺序有关，谁先调用，谁先执行。

这里我们浅做了解，具体在后面的学习中理解强化。

初识类和对象 \color{red}{初识类和对象} 初识类和对象

面向对象和面向过程的思想对比

  1.面向过程：是一种以过程为中心的编程思想，实现功能的每一步，都是自己实现的。

  2.面向对象：是一种以对象为中心的编程思想，通过指挥对象实现具体的功能。

对象：指的是客观存在的食物，万物皆对象。

什么是类

  1.类是对现实生活中一类具有共同属性的行为的事物的抽象。

  2.类是事物，也就是对象的一种描述，可以将类理解为一张设计图，根据设计图，可以创造除具体存在的事物。

类的组成

  1.属性：该事物的各种特征。
在类中通过成员变量来体现。（类中方法外的变量）。

  2.行为：该事物存在的功能（能够做的事情）。
在类中通过成员方法来体现（和前面的方法想比较去掉static关键字就可以）。

类和对象的关系

  1.类：类是对现实生活中一类具有共同属性和行为的事物的抽象。

  2.对象：是能够看得到摸得到的真实存在的实体。

类是对象的描述。
对象是类的实体。

类的定义

public class 类名{
	成员变量
    成员方法
}

public class Student{
	//成员变量
	String name;
	int age;
    //成员方法 行为
    public void study(){
		 System.out.println("这是成员方法");
	}
}

创建对象

类名 对象名 = new 类名();

Student stu = new Student();

使用方法

对象名.变量名
stu.name;

//此处写类体
public class Test {
    //此处是主函数
    public static void main(String[] args) {
        Student stu = new Student();
        stu.age = 18;
        stu.name = "张三";
        stu.study();
    }
}

$消化一下知识在接着往下看吧！！！$

构造方法 \color{red}{构造方法} 构造方法

  作用：用来创建对象和new 一起。

格式：

无参构造：

public 类名(){
}

public Price(){
	System.out.println("无参构造方法被调用");
}

有参构造：

public 类名(参数列表){
	……
	……
	……
}

public Price(String brand){
	this.brand = brand;
	System.out.println("有参构造方法被调用 brand");
}

特点

  1.如果本类中没有构造方法，JVM会默认提供一个无参的构造方法。

  2.构造方法可以重载。

  3.构造方法没有返回值，不能使用void。

  4.构造方法没有return关键字，可以写，但是没必要。

标准类的编写

  1.成员变量私有化，得到getXxx 和 setXxx方法。

  2.提供空参满参的构造方法。

成员变量和局部变量的区别 \color{red}{成员变量和局部变量的区别} 成员变量和局部变量的区别

代码中的位置

  1.成员变量：类中方法外。

  2.局部变量：在方法的声明上，或者方法内部。

在内存中的位置

  1.成员变量：在堆中。

  2.局部变量：在栈中。

生命周期不一样

  1.成员变量：随着对象的创建而存在，随着对象的消失而消失。

  2.局部变量：随着方法的调用而存在，随着方法的弹栈而消失。

初始化值

  1.成员变量：有默认值。
默认值在上面的知识点中提到过。

  2.局部变量：没有默认值。

初始引用类型 S t r i n g \color{red}{初始引用类型 String} 初始引用类型String

next和nextLine

next()

==next()==只能录入连续的字符串，这里的连续值没有空格的字符串。
换而言之：当遇到空格或者回车就会结束键盘录入

//创建Scanner对象
Scanner sc = new Scanner(System.in);
//键盘录入
String s = sc.next();
//比如我们想录入 welcome to CSDN

//但是实际的s为 welcome

nextLine()

nextLIne() 当遇到回车的时候才会结束键盘录入，遇到空格不会结束键盘录入。

//创建Scanner对象
Scanner sc = new Scanner(System.in);
//键盘录入
String s = sc.nextLine();
//比如我们想录入 welcome to CSDN

//但是实际的s为 welcome to CSDN

new String();

传输byte类型的数组

byte[] arr = {65,66,67,68,69};
String s = new String(arr);
System.out.println(s);
//打印结果ABCDE

分析一下代码，为什么传输进去的整数类型，但是打印的ABCDE呢？

其实是将整数类型转化为ASCLL值打印输出。

传输byte类型的数组，索引，长度

byte[] arr = {65,66,67,68,69};
String s1 = new String(arr,    1,   3);
//                     数组  索引  长度
//打印结果 BCD

代码含义，将数组arr从 1 索引开始，向后数 3 个长度，交给字符串S1。

传输 char类型的数组

char[] chars = {'a','b','c','d','e','f'};
String s = new String(chars);
System.out.println(s);
// 打印结果 abcdef

将字符数组转化成字符串。

传输 char类型的数组，索引，长度

char[] chars = {'a','b','c','d','e','f'};
String s = new String(chars,    1,   3);
//                    数组  索引  长度
System.out.println(s);
//打印结果bcd

String类型对应同一字符串，是否相等

String name1 = "张三";
String name2 = "张三";
//true

值创建后不能更改，是对象的话，一般放在堆内存中，这就意味者地址值是相等的，比较的是同一快内存地址，所以相等。

String name1 = new String("张三");
String name2 = new String("张三");
//false

在这里“张三”的地址值是一样的，但是这里new 的对象，但是“张三”重复了，为了节省内存，new的对象指向了“张三”。但是这里比较的是new的地址，地址内存不一样。

创建空的字符串

String s = "";

String s1 = new string();

//s和s1都是空的字符串。

基本类型和字符串之间的转化 \color{red}{基本类型和字符串之间的转化} 基本类型和字符串之间的转化

String类型转基本类型

byte

public class test {
    public static void main(String[] args){
        String s = "123";
        byte b = Byte.parseByte(s);
    }
}

short

public class test {
    public static void main(String[] args){
        String s = "123";
        short sh = Short.parseShort(s);
    }
}

int

public class test {
    public static void main(String[] args){
        String s = "123";
        int result = Integer.parseInt(s);
    }
}

long

public class test {
    public static void main(String[] args){
        String s = "123";
        long result = Long.parseLong(s);
    }
}

double

public class test {
    public static void main(String[] args){
        String s = "123";
        double result = Double.parseDouble(s);
    }
}

float

public class test {
    public static void main(String[] args){
        String s = "123";
        float result = Float.parseFloat(s);
    }
}

基本类型转化为String类型

方法1

  直接拼接一个空的字符串。

int num = 10;
String s1 = num + "";

方法2

int num = 10;

String s2 = String.valueOf(num);

字节码 \color{red}{字节码} 字节码

关键：getBytes();

String name = "张三";
 byte[] arr = name.getBytes();
 System.out.println(Arrays.toString(arr));
 //打印的字节码[-27, -68, -96, -28, -72, -119]

可以使用字节码反推字符串

byte[] arr1 = {-27, -68, -96, -28, -72, -119};
//这里我们运用上面介绍的知识
String name1 = new String(arr1);
System.out.println(name1);
//打印的结果为 张三

字符串常用方法 \color{red}{字符串常用方法} 字符串常用方法

equals

查看字符串是否相等.返回值是boolean类型的数据

String s1 = "abc";
String s2 = "abc";
if(s1.equals(s2)){
    System.out.println("相等");
}else{
    System.out.println("不相等");
}

//打印的结果 相等

因为s1和s2相等，所以s1.equals(s2) 结果为true。

charAt

返回指定索引处的值。返回值是char类型的数据。

String s = "abcdef";
char ch = s.charAt(1);
System.out.println(ch);
//打印结果 b

字符串s 1索引的值为 b。

endWith

测试字符串是否以指定后缀结尾，返回值是boolean类型的数据

String s = "2023年01月16日";
//判断字符串是否以 日 结尾
boolean result = s.endsWith("日");
System.out.println(result);
//打印结果 true

startWith

测试字符串是否以指定前缀开头，返回值是boolean类型的数据

String s = "2023年01月16日";
//判断字符串是否以 2023 开头
boolean result = s.startsWith("2023");
System.out.println(result);
//打印结果 true

isEmpty

判断字符串是否为空，返回值是boolean类型的数据

//空的字符串
String s = new String();
boolean result = s.isEmpty();
System.out.println(result);
//打印结果为true

length()

求字符串长度，返回值是int类型的数据

String s = "abcdef";
int len = s.length();
System.out.println(len);
//打印结果为 6

replace

指定字符串的替代，返回值是String类型的数据。

String s = "你真是TMD";
String result = s.replace("TMD","***");
//                        替换   被替换
System.out.println(result);
//打印结果 你真是***

//将TMD替换为***

split

指定字符串拆分，返回值是==String[]==类型的数组。

String s = "李四,23";
String[] result = s.split(",");
//指定,分割
System.out.println(Arrays.toString(result));
// 打印结果 [李四, 23]

substring

返回一个字符串，该字符串是此字符串的子字符串，返回值是String类型的数据。

String s = "abcdef";
String result = s.substring(1);
//返回从索引1开始的字符串
System.out.println(result);
//打印结果  bcdef

String s = "abcdef";
String result = s.substring(1,3);
//返回从索引1开始,到索引（3-1）的字符串
//最大索引取不到
System.out.println(result);
//打印结果  bc

toCharArray

将字符串转化为新的字符数组，返回值是==Char[]==类型的数组。

String s = "abcdef";
char[] result = s.toCharArray();
System.out.println(Arrays.toString(result));
//打印结果 [a, b, c, d, e, f]

toLowerCase

将所有字符串转化为小写，返回值是String类型的数据。

String s = "ABCDEF";
String result = s.toLowerCase();
System.out.println(result);
//打印结果 abcdef

toUpperCase

将所有字符串转化为大写，返回值是String类型的数据。

String s = "abcdef";
String result = s.toUpperCase();
System.out.println(result);
//打印结果 ABCDEF

equalsIgnoreCase

两个字符串比较 忽略大小写，返回值是Boolean 类型的数据

String s1 = "abcdef";
String s2 = "ABCDEF";
boolean result = s1.equalsIgnoreCase(s2);
System.out.println(result);
//打印结果 true

trim

去掉前导和尾随的空格，返回值是String 类型的数据

String s3 = "   abcdef    ";
String result3 = s3.trim();
System.out.println(result3);
//打印结果 abcdef 

S t r i n g B u i l d e r \color{red}{StringBuilder} StringBuilder

构造一个没有字符的字符串构建器，初始容量为16个字符。

//构造一个没有字符的字符串构建器，初始容量16个字符
StringBuilder sb = new StringBuilder();
// int capacity返回当前容量
int capacity = sb.capacity();
System.out.println(capacity);
//打印结果 16

append

将参数添加到序列中。

StringBuilder sb = new StringBuilder();
StringBuilder sb1 = sb.append(100);
System.out.println(sb1);
//打印结果 100
System.out.println(sb);
//打印结果 100
System.out.println(sb==sb1);
//打印结果 true

reverse

反转字符串。

String line = "abcdef";
StringBuilder result = new StringBuilder(line);
System.out.println(result.reverse());

模拟用户登录 \color{red}{模拟用户登录} 模拟用户登录

public static void main(String[] args) {

    //登录名和密码
    String username = "root";
    String password = "123456";
    //创建一个输入的对象
    Scanner sc = new Scanner(System.in);
    //只允许最多输入3次密码
    for (int i = 0; i < 3; i++) {
        System.out.println("请输入用户名：");
        //在我们输入时去掉用户名前面的空格和末尾的空格
        String userName = sc.next().trim();
        System.out.println("请输入密码：");
        //在我们输入时去掉密码 前面的空格和末尾的空格
        String pwd = sc.next().trim();
        if(userName.equals(username)&&pwd.equals(password)){
            System.out.println("登录成功");
            break;
            //登录成功，结束循环
        }else{
            System.out.println("登录失败");
            System.out.println("还有"+(2-i)+"次机会");
        }
    }

}

A r r a y L i s t \color{red}{ArrayList} ArrayList

构造方法

构造一个具有指定初始容量的空列表

ArrayList arrayList = new ArrayList();
System.out.println(arrayList);
// 打印结果 []

构造具有指定初始容量的空列表

ArrayList arrayList = new ArrayList(20);
System.out.println(arrayList);
// 打印结果 []

常用方法

add

指定的元素追加到此集合的末尾。

ArrayList arrayList = new ArrayList();
arrayList.add("张三");
arrayList.add(100);
arrayList.add(true);
arrayList.add(3.14);
System.out.println(arrayList);
// 打印结果 [张三, 100, true, 3.14]

在此集合的指定位置插入指定的元素。

ArrayList arrayList = new ArrayList();
arrayList.add(1,"李四");
//在1索引处添加李四

get

返回此集合中指定位置的元素。

String result = arrayList.get(2);
//返回的是 集合中2索引处的值。

remove

删除此集合指定位置的元素。

arrayList.remove(2);
//删除集合中2索引处的元素。

删除此集合第一次出现的指定元素。

arraylist.remove("李四");
//传入要删除的元素
//如果存在就会删除，不存在不会影响其他的

isEmpty

判断此集合是否为空，返回值是boolean类型的数据。

boolean result = arrayList.isEmpty();
//如果集合为空 ，返回true
//如果集合不为空，返回false

set

用指定的元素替换此集合中指定位置的元素。

arrayList.set(1,"张三");
//将此集合索引为1的元素替换为 张三

泛型

用来约束集合中存储数据的数据类型。

//格式：类名<数据类型>
ArrayList<String> Lists = new ArrayList<>();
//这里的String说明只能存储String类型的数据
Lists.add("张三");
Lists.add("100");
System.out.println(Lists);
//打印结果 [张三, 100]

迭代器

以正确的顺序返回该列表中元素的迭代器。文章来源地址https://www.toymoban.com/news/detail-649083.html

ArrayList<String> l = new ArrayList<>();
//Iterator<E> iterator() 以正确地顺序返回该列表中元素地迭代器
Iterator<String> iterator = l.iterator();
while(iterator.hasNext()){
	//当指针
    String s = iterator.next();
    System.out.println(s);
}

ArrayList存储特点，有序可存储

到了这里，关于2023年之我拿起“java“的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！