JavaSE| 面向对象
Posted kris12
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JavaSE| 面向对象相关的知识，希望对你有一定的参考价值。
面向对象
面向对象只是其中一种编程思想，还有很多其他的编程思想：面向过程、面向切面、面向服务编程...
面向过程的思维方式：注重步骤、过程，面向过程强调的是功能行为； 面向对象的思维方式：关注的是“对象”。面向对象，将功能封装进对象，强调具备了功能的对象。面向对象更加强调运用人类在日常的思维
逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。
类（class）、对象（object也称为实例instance）
对象：一个一个的具体事物
当很多个对象它们有共同的特性的时候，我们就可以抽象出一个类别，用一个Java类来表示。
完成需求时：
先去找具有所需功能的对象来用； 如果该对象不存在，那么创建一个具有所需功能的对象； 这样简化开发并提高复用。
java类及类的成员：java中用类class来描述事物。 类与类之间的关系：关联、继承、聚集、组合
属性：对应类中的成员变量，Field = 属性 = 成员变量；行为：对应类中的成员方法，Method = 成员方法 = 函数。
类与对象是的关系
类是对象的抽象的概念，类是体现了对象的共同的特性。类是创建对象的模板，设计图。对象是类的具体。
一、类的设计
类的成员的设计，类的成员包括：
1、属性；2、代码块；3、构造器；4、方法；5、内部类
* 类的成员的顺序： * 1、属性：包括静态的类变量和非静态的实例变量 * 2、代码块：包括静态代码块和非静态代码块 * 非静态代码块又称为构造块 * 3、构造器：包括无参构造和有参构造 * 4、方法：包括静态方法和非静态方法 * 5、内部类
二、类的声明
语法格式：
【修饰符】 class 类名{
}
注意：
（1）类名：命名规则和命名规范（见名知意，每一个单词首字母大写）
（2）建议，就算这个类不是public，我们也与“源文件名”一样
类对象的内存解析
new出来一个变量（实体），首地址赋给a1，通过栈空间a1引用变量
1. 类的成员之一：属性
1、声明属性的语法格式： 【修饰符】 数据类型 属性名； 属性也称为成员变量。
2、声明属性的位置：必须在类中，其他成员（方法、构造器等）的外面
类 {
【修饰符】 数据类型1 属性名1;
【修饰符】 数据类型2 属性名2;
【修饰符】 数据类型3 属性名3;
....
}
3、属性如何赋值？
（1）属性有默认值
基本数据类型：
byte,short,int,long：0
float,double：0.0
char：\\u0000
boolean：false
引用数据类型：（类、数组、接口） null
（2）属性的赋值
在其他类中： 对象.属性名 = 值;
4、属性的特点
1）属性有默认值； 2）每一个对象的属性是独立的
变量的三要素：数据类型、变量名、变量值
变量的三要素：（1）数据类型（2）变量名（3）变量值
对象的创建：
类名（数据类型_引用数据类型） 对象名 = new 类名（）； 如 Student stu = new Student( );
属性在类里边声明，对象创建之后，要用对象来调用属性。 stu.name;
如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰。
1）匿名对象
2）有名对象
类名 对象名 = new 类名( )； 数据类型 变量名 = new 类名()；
说明：类是一种数据类型，引用数据类型。
对象名也是变量名，是引用数据类型的变量，new 类名()是一个值，是一个对象。
引用数据类型的变量、元素，它应该赋值为一个“对象”
回忆：变量的声明格式 数据类型 变量名;
变量的赋值： 变量名 = 值；
注意类创建的数组与它的对象的区别：
Teacher[ ] arr = new Teacher[ 5 ] 数组； Teacher tea = new Teacher( ) 对象；
元素类型是引用数据类型的数组称为对象数组。因为元素中存储的是对象。
arr[ i ]
System.out.println(new Circle()); //new Circle()匿名对象 -->> Circle@15db9742 Circle c1 = new Circle(); //有名对象，它的名字就是c，c是对象名 c1.circle = 1.2; String name = "kris";//String也是类名,name是对象名，"张三"是一个字符串的对象 if(name.equals("kris")){ } //创建了一个java.util.Scanner的对象 //java.util.Scanner也是一种类，也是数据类型 java.util.Scanner input = new java.util.Scanner(System.in); //input是对象名 int num = input.nextInt(); int[] arr = new int[5];//创建了一个数组对象，数组的元素相当于数组的成员变量，属性 //int[] -->>数组类型 <<-->>引用数据类型 -->>默认为null //int[][] -->>int类型为基本数据类型 -->>默认为0
class TestCircle{ public static void main(String[] args){ Circle c1 = new Circle(); //创建了一个圆对象 c1.radius = 2.1; //为属性赋值； System.out.println(c1.radius); System.out.println(c1.getArea()); System.out.println(c1.getLength()); } } /* 1、声明一个类 2、用类来创建具体的对象 */ class Circle{ double radius; double getArea(){ return Math.PI * radius * radius; } double getLength(){ return 2 * Math.PI * radius; } }
变量的分类
按照变量声明的“位置”分为：
- 局部变量
- 成员变量（ 1）实例变量：没有static修饰的属性。2）类变量：使用static修饰的属性 ）
① 成员变量：（某个成员变量不能被外部类直接访问，使用private修饰符）
* 成员变量的声明的位置：类中方法、代码块等外面。
* 成员变量的初始化：1）有默认值； 2）显式初始化；（比如说给属性变量赋值private int i = 10; 用构造器进行初始化还是初始化的值，并不会累加 ）
3）构造器； 4）set方法可以再次修改值。
*成员变量：1）实例变量：堆； 2）类变量：方法区
* 成员变量：相对长，随着对象的创建而创建，随着对象被垃圾回收而消亡。每一个对象的成员变量是独立的。
* 成员变量：权限修饰符（private,缺省,protected,public）、static、final、volatile等
② 局部变量：
* 局部变量的声明的位置：1）方法的形参列表； 2）方法体中； 3）代码块。
* 局部变量的初始化：1）形参的初始化，必须在调用时，由实参赋值；2）其他的局部变量，必须手动初始化
* 局部变量：栈
* 局部变量：短，当代码执行到局部变量的声明处开始，到它的作用域结束而结束
* 局部变量：final
java可以声明局部变量而不进行初始化；
public class TestVar {
public static void main(String[] args) {
// java可以声明局部变量而不进行初始化
String str;
int zhangsan = 10;
}
}
字节码文件：
LocalVariableTable:
Start Length Slot Name Signature
0 4 0 args [Ljava/lang/String;
3 1 2 zhangsan I
LocalVariableTable 本地栈变量表，压栈时给每一个变量一个局部变量表LocalVariableTable;
没有s变量，没有初始化只是声明了，它根本不会出现了这里边；java要求变量在使用前必须初始化；
* 区别：声明的位置、初始化的方式、值的存储的位置不同、生命周期、修饰符不同
2. 类的第二个成员：方法
1、概念
方法（method），又称为函数（function），代表的是一个独立的功能。例如：
Math.sqrt(m)，这个sqrt(m)方法，返回m的平方根
System.out.println()，这个println(x)方法，打印()中的内容
把代码封装到一个方法中的目的，简单的实现功能的复用
2、方法的要求和特点
（1）必须先声明后使用
（2）不调用不执行，调用一次执行一次
（3）调用时必须遵循一定的格式
3、方法的声明
语法格式：
【修饰符】返回值类型 方法名(【形参列表】){
方法体语句块;
}
名词解释：方法 = 方法头 + 方法体 方法头：【修饰符】返回值类型 方法名(【形参列表】) 方法头在很多书或文档中也称为“方法签名”
【修饰符】 class 类名{
【修饰符】返回值类型 方法名(【形参列表】){
方法体语句块;
}
}
因此，方法的声明的位置必须在类中，方法外。
方法的声明的形式
1、无参无返回值
语法格式：
【修饰符】void 方法名(){
方法体语句块;
}
只要是void就是没有返回值的。
2、有参无返回值
语法格式：
【修饰符】void 方法名( 数据类型 形参名 ) { //有void就没有返回值，在调用时也不用写[ 变量= ] 了。 （变量 = 方法名（实参列表））
方法体语句块；
}
形参列表：形参本质上就是一个变量。它只是个形式，没有具体值。只有在方法被“调用”时，形参才能确定值。
方法的调用
1、大多数时候都是在方法体中，偶尔可能在为属性显式赋值时调用
2、格式 【变量 = 】 方法名（【实参列表】）;
调用方法时()中的参数列表我们称为“实参列表”，因为它是有具体的值，实参的作用就是给形参赋值的。
要求：
（1）调用时()中是否要写【实参列表】看声明时()中有没有【形参列表】，并且【实参列表】的个数、顺序、类型与【形参列表】一一对应。
3、无参有返回值
语法格式：
【修饰符】返回值类型 方法名(){
方法体语句块;
}
（1）返回值类型可以是任意Java类型（包括基本数据类型和引用数据类型）
（2）但是只能返回一个值，当然这个值可以是一个简单值（例如：整数5），也可以是一个复杂的值（例如：是一个对象，或者多个对象组成的集合等）
（3）方法体中，必须有“return 值;”
这种“无参有返回值”形式的方法，一般常见于，键盘输入、产生随机值、get值()等这样的功能。
方法的调用
1、大多数时候都是在方法体中，偶尔可能在为属性显式赋值时调用
2、格式 【变量 = 】 方法名（【实参列表】）;
要求：
（1）调用时()中是否要写【实参列表】看声明时()中有没有【形参列表】，并且
要求【实参列表】的个数、顺序、类型与【形参列表】一一对象
（2）前面是否需要【变量=】，看声明时方法的返回值类型是否是void，如果是void，就不能写【变量=】;
如果返回值类型不是void，就可以使用“变量=”，要求这个“变量”和被调用方法的“返回值类型”应该一致或兼容。
4、有参有返回值
语法格式：
【修饰符】返回值类型 方法名(形参列表){
方法体语句块;
}
方法的调用
1、大多数时候都是在方法体中，偶尔可能在为属性显式赋值时调用
2、格式 【变量 = 】 方法名（【实参列表】）;
（1）调用时()中是否要写【实参列表】看声明时()中有没有【形参列表】，并且
要求【实参列表】的个数、顺序、类型与【形参列表】一一对象
（2）前面是否需要【变量=】，看声明时方法的返回值类型是否是void，如果是void，就不能写【变量=】;
如果返回值类型不是void，就可以使用“变量=”，要求这个“变量”和被调用方法的“返回值类型”应该一致或兼容。
class TestMethod2{ public static void main(String[] args){ printJiuJiu();//无参无返回值 printRectangle(5,5,\'*\'); //有参无返回值 System.out.println(getNum()); //有参无返回值 int max = getMaxNum(7,9); System.out.println("最大值为:" + max); System.out.println("三个数最大值为:" + getThreeNum(5,9,12)); } public static void printJiuJiu(){ //无参无返回值 for(int i = 1;i <= 9;i++){ for(int j = 1;j < i;j++){ System.out.print(j + "*" + i + "=" + j*i + "\\t"); }System.out.println(); } } public static void printRectangle(int m, int n, char x){ //有参无返回值 //第一轮:i=1, j=1,2,3,4,5,6循环6次; for(int i = 1;i <= m; i++ ){ for(int j = 1; j <= n; j++ ){ System.out.print(x); }System.out.println(x); } } public static int getNum(){ //无参有返回值 int num = (int)(Math.random() * 100); return num; } public static int getMaxNum(int a,int b){ //有参有返回值 if(a > b){ return a; }else{ return b; } } public static int getThreeNum(int a, int b, int c){ int max = getMaxNum(a, b); max = getMaxNum(c, max); return max; } }
class TestMethod{ public static void main(String[] args){ System.out.println("数组为:"); int[] arr = {3,6,2,9,0,8,4,5}; printShuZu(arr); for(int i = 0;i < arr.length; i++){ System.out.print(arr[i] + "\\t"); } //System.out.println(printSum(1,100)); System.out.println("阶乘为:"); System.out.println(printJieCheng(10)); } //声明一个方法，可以为所有的int[]数组实现从小到大排序 //冒泡排序； 有参数没有返回值 public static void printShuZu(int[] arr){ //数组,长度为8,排序 // 第一次 i=1,j=0,1,2,3,4,5,6; for(int i = 1;i < arr.length; i++){ for(int j = 0;j < arr.length - i; j++){ if(arr[j] > arr[j+1]){ int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } } //声明一个方法，可以累加[m,n]之间的和 //有参数有返回值的； public static int printSum(int m , int n){ int sum = 0; for(int i = m;i<=n; i++){ sum += i; } return sum; } //（3）声明一个方法，可以实现求任意正整数的阶乘 public static int printJieCheng(int m){ int jieCheng = 1; for(int i = 1;i < m; i++){ jieCheng *= i; } return jieCheng; } }
4、类的成员方法
（1）本类中方法，可以直接使用本类的属性
（2）本类中方法，可以直接调用本类的方法
（3）如果在别的类中使用，需要用“ 对象. ”调用
（4）？ static 有影响
/*声明一个圆类，有属性：半径radius 给圆类增加成员方法： (1)求圆的面积的方法 */ class Circle{ double radius; //(1)求圆的面积的方法; 返回值：面积 //形参：是否需要？这里不需要，因为对象中已经有半径值 double getArea(){ double area = Math.PI * radius * radius; return area; } double getPerimeter(){ return 2 * Math.PI * radius; } String getInfo(){ return "圆的半径是：" + radius + "，它的面积是：" + getArea() + "，它的周长：" + getPerimeter(); } } class TestCircle{ public static void main(String[] args){ //(1)先创建圆对象 Circle c1 = new Circle(); //(2)求面积，求哪个圆的面积 double d = c1.getArea(); System.out.println("面积：" + d); //(3)设置半径的值 c1.radius = 2.5; d = c1.getArea(); System.out.println("面积：" + d); System.out.println("周长：" + c1.getPerimeter()); System.out.println(c1.getInfo()); } }
5、方法的参数传递机制
实参给形参传值
形参：在声明方法的()中的参数列表，
【修饰符】 返回值类型 方法名（数据类型 形参名, 数据类型 形参名， 。。。）{}
实参：在调用方法的()中的参数列表，
【变量 = 】 方法名(值1，值2，值3, 。。。); 这个值可能是常量值，例如：(4,6)，也可能是表达式，例如：(2*3)，也可能是变量，例如(a,b)
1、形参的数据类型是基本数据类型
实参给形参传递的是“数据值”，“形参”是“实参”的一个“副本”，对形参的修改不会影响实参。
方法的参数传递机制：实参给形参传值
主方法和你所定义的方法在内存中是两个互相独立的空间，当你调用自己定义的方法执行完之后，它就会撤掉，变成垃圾准备回收了。
{ public static void main(String[] args) { int i = 0; change(i);//i=0，调用change函数,完成之后，它在内存中就会撤掉；主方法和change方法是两个独立的内存。 System.out.println("调用方法后" + i); //i=0 i = i++; //i=0,先把他load到操作栈里边，i再自增i=1,再把操作栈里的值赋值给i； //System.out.println(i++); //如果运行这一步,输出0，则下面输出i=1 System.out.println("i = " + i); //i=0 } public static void change(int i){ i++; System.out.println(i); //i=1 } }
2、形参的数据类型是引用数据类型
实参给形参传递的是“地址值”，意味着“形参”和“实参”同时指向“同一个”对象，
那么“形参”修改了它的属性，也意味着“实参”的属性也被修改了。
实参把它的地址值传给了形参，new出来的对象是放到堆里边的，主方法和自己定义的方法还是两个互相独立的内存空间，但是它们有相同的地址值，通过地址值把变量修改之后，实参和形参指向的是同一个对象，修改都会改变。它撤离之后，主方法中的那个变量还是修改之后的变量。
特殊情况：如果形参是String，Integer等不可变对象时，那么无论怎么修改形参都和实参无关的。
因为形参已经指向新的对象。
String对象是不可变的，但当它发生改变比如字符串的拼接时，它就会产生一个新的对象（y = x，跟这种是一样的，改变的是地址值，对象不一样了），新的字符串跟原来无关的，这时自己定义的方法执行完之后它还是会撤离的，新的对象跟着一起撤离，原来主方法中的字符串还是在的，它不会变。
class TestPassValue{ public static void main(String[] args){ toDouble1(3); MyDate d = new MyDate(); //把变量MyDate d放到栈里边，一个单独的内存空间,会有一个地址值如0x666； 而new产生对象是放在堆里边的,x默认为0，把它改成3； d.x = 3; toDouble2(d); //主方法和自己定义的方法是两个独立的内存空间，但有一个相同的地址值，通过myCanShu找到堆里边的x，把它改成原来的3倍大，执行完后撤走。 //System.out.println(d.x); int[] array = {3,2,5,9,1,4,0}; sort(array);//array实参把数组的首地址给形参arr，意味着arr和array指向同一个数组，对arr的排序就是对array的排序。 //发现可以实现排序 String s = "I Love"; //虽然没有new关键字，但它还是对象，它不是存在栈里边，在常量池里边，value=”I Love”，字符串的对象 change(s); //实参s把地址值给了形参String str = s；但String对象是不可变的，一旦改变如拼接、截取等，就会产生一个新的字符串对象。--> value=I LoveChina System.out.println("s = " + s); //产生新对象之后，原来的value=I Love就不要了，自己定义的方法执行完就会撤离，这时候你原来在主方法中的s=I Love还是在的。 } //产生的是新对象，跟原来的没有关系，这是个陷阱。 public static void toDouble1(double num1){ //形参为基本数据类型时,形参的改变不会影响到实参 System.out.println(num1); num1 *= 2; System.out.println(num1); } public static void toDouble2(MyDate myCanShu){ //形参为引用数据类型时,形参修改了它的属性，实参也要改变。 System.out.println(myCanShu.x); myCanShu.x *= 3; //变量MyDate myCanShu，会有一个地址值0x666,这个方法单独开一个内存空间，隐含了一个MyDate myCanShu = d ; System.out.println(myCanShu.x); } //定义一个对数组排序的方法 //假如是有3个元素的数组 //i=1, j=0,1 //i=2, j=0 public static void sort(int[] arr){ //形参为数组(数据类型+变量名) //foreach循环 for(int num : arr){ System.out.print(num); } for(int i = 1; i < arr.length; i++){ for(int j = 0; j < arr.length-i; j++){ if(arr[j] > arr[j+1]){ int temp = arr[j]; arr[j] = arr[j+1];; arr[j+1] = temp; } } } System.out.println(); for(int num : arr){ System.out.print(num); } } public static void change(String str){ //形参为String引用数据类型时 //特殊情况：如果形参是String，Integer等不可变对象时，那么无论怎么修改形参都和实参无关的。 //因为形参已经指向新的对象。 System.out.println(); str += "China"; System.out.println(str); } } class MyDate{ int x; }
6、命令行参数
/* 命令行参数：（了解） 给main()传递的实参，称为命令行参数 如果要给main()的形参传值，可以用如下的格式： java 类名 实参1 实参2 实参3... 参数： 形参 实参 命令行参数 */ class TestCommandParam{ //public static是修饰符 //void：表示main没有返回值 //main：方法名 //String[] args：形参 public static void main(String[] args){ System.out.println("参数的个数：" + args.length); //参数的个数：0 for(int i=0; i<args.length; i++){ System.out.println(args[i]); } } }
参数--可变参数
* 参数： * （1）形参 * 在方法的声明时，方法签名中()声明额参数就是形参 * 形参的形式：(数据类型 形参名) * (数据类型1 形参名1,数据类型2 形参名2) * ... * （2）实参 * 在方法的调用时，方法()中传的值、变量、表达式都是实参，作用是给形参赋值 * * 实参列表的个数、数据类型、顺序必须与形参列表一一对应 * * （3）命令行参数：给main()传递的实参，称为命令行参数 * java 类名 参数值1 参数值2 ... * * （4）可变参数： * 在声明方法时，某个形参的形式： 数据类型... 形参名 * 在调用方法时，这个形参对应的实参，可以传递0~n个值 * * 如何声明可变参数？ * 【修饰符】 返回值类型 方法名(数据类型... 可变参数名){ * } * 【修饰符】 返回值类型 方法名(其他形参列表, 数据类型... 可变参数名){ * } * * 要求： * （1）声明时： * 一个方法，只能有一个可变参数，并且可变参数必须是最后一个 * （2）调用时： * 非可变参数的部分，原来该怎么传还怎么传； * 可变参数的部分，（A）可以传对应数据类型的0~n个的值（B）还可以传对应类型的数组 * * 需求：声明一个方法，可以找出1~n个整数中的最大值
public class TestVariableParam { public static void main(String[] args) { //例如：找出5,3,2,8中的最大值 /*int[] array = {5,3,2,8}; int max = getMax(array); System.out.println("最大值：" + max);*/ int max = getMax(5,3,2,8); System.out.println("最大值：" + max); max = getMax(9); System.out.println("最大值：" + max); int[] nums = {6,7,8,2}; max = getMax(nums[0], nums); System.out.println("最大值：" + max); } //声明一个方法，可以找出1~n个整数中的最大值 //返回值类型：int，因为要返回“最大值” //形参列表： //方式二：int a, int... args //int... args，在声明它的方法中，和“数组”一样使用即可 public static int getMax(int a, int... args){ //(1)先假设a最大 int max = a; //(2)用max中与args中的值一一比较 for(int i=0; i<args.length; i++){ if(max < args[i]){ max = args[i]; } } return max; } //声明一个方法，可以找出1~n个整数中的最大值 //返回值类型：int，因为要返回“最大值” //形参列表： //方式一：int[] /* public static int getMax(int[] arr){ //判断数组不为空 if(arr!=null && arr.length>0){ //(1)假设第一个元素最大 int max = arr[0]; //(2)用max中的值与剩下的元素一一比较 for (int i = 1; i < arr.length; i++) { if(max < arr[i]){ max = arr[i]; } } //(3)返回max return max; }else{ //抛出异常 throw new RuntimeException("数组不能为空"); } }*/ }
public class TestVariableParam2 { public static void main(String[] args) { System.out.println(getSum()); System.out.println(getSum(1,2)); System.out.println(getSum(0,1,2,3,4,5,6)); int[] arr = {4,5,6,7,2}; System.out.println(getSum(arr)); } //需求：求n个整数的和，n可以是0个，也可以是很多个 public static int getSum(int... nums){ int sum = 0; for (int i = 0; i < nums.length; i++) { sum += nums[i]; } return sum; } }
/* * 按照方法的重载：不属于重载 * 编译器认为它们是一样的，int[]...和int[]是一样的 */ public class TestOverload { public static void main(String[] args) { int[] arr = {1,2,3,4}; //getSum(arr);//如果假设下面是对的， 那么这句就不知道调用哪个了 } /*public static int getSum(int... args){ return 0; } public static int getSum(int[] args){ return 0; }*/ }
/* * 非严格意义说，是重写，但不推荐这么，int[]和int...不完全等价 */ public class TestOverride { public static void main(String[] args) { Base b = new Sub(); int[] arr = {1,2,3,4,5}; b.test(arr);//如果传数组，没问题，编译时类型和运行时类型都可以处理 // b.test(1,2,3,4);//编译时按父类编译，就会报错 Sub s = new Sub(); // s.test(1,2,3,4); } } class Base{ public void test(int[] args){ System.out.println("父类的test"); } } class Sub extends Base{ public void test(int... args){ System.out.println("子类的test"); } }
方法的重载：Overload
在同一个类中，出现了两个或多个“方法名称相同”、“形参列表不同”的方法，
这些方法我们称为“方法的重载”，和返回值类型无关。
形参列表不同：个数、数据类型不同
package day05; /*一、面向对象思想的落地法则一 * 1.设计类，并设计类的成员（成员变量&成员方法） * 2.通过类，来创建类的对象（也称作类的实例化） * 3.通过“对象.属性” 或 “对象.方法”来调用，完成相应的功能 * * 二、创建的多个对象，彼此各拥有一套类的属性。当对其中一个类的对象进行修改时， * 不会影响到其他对象的属性值。 * * 三、类的属性（成员变量） * 成员变量 vs 局部变量 * 相同点：1.遵循变量声明的格式：数据类型 变量名 = 初始值 * 2.都有作用域 * 不同点：1.声明的位置的不同：成员变量：声明在类里边，方法外 * 局部变量：声明在方法内，方法的形参部分，代码块内 * 2.成员变量的修饰符有四个：public private protected 缺省 * 局部变量没有修饰符，与所在的方法修饰符相同。 * 3.初始化值：一定会有初始化值以上是关于JavaSE| 面向对象的主要内容，如果未能解决你的问题，请参考以下文章