java svgbase64转byte_3.1.java语法基础

1.1.java语法基础：

1.1.1.标识符和注释

1.1.1.1.标识符和注释

标识符：自定义的用于标识变量名、函数名、类名、接口名等的字符串

标识符的规则：非数字开头字母、$、下划线、数字组成；区分大小写；不能用关键字、保留字

关键字：在java语言里有特殊含义的单词，都是小写(static...)。List,Set不是关键字，是接口名

保留字：其实就是还没有赋予特殊含义，但是准备日后要使用过的单词。

JAVA关键字与保留字说明及使用

abstract 、boolean 、break 、byte 、case 、       catch、       char 、class 、continue 、       default、do 、       double 、else 、extends 、       false 、       final 、finally 、float 、       for 、       if、implements 、       import 、instanceof 、int 、       interface 、       long 、       native 、new 、       null 、       package、private 、protected 、       public 、       return、       short 、static 、       super 、       switch、synchronized 、this、throw 、       throws 、transient、try、true 、       void、       volatile、while

驼峰命名法：当变量名或函式名是由一个或多个单词连结在一起，而构成的唯一识别字时，第一个单词以小写字母开始；第二个单词的首字母大写或每一个单词的首字母都采用大写字母

小驼峰：除第一个单词之外，其他单词首字母大写(变量和函数)

大驼峰：第一个单词的首字母大写其他单词首字母也大写(类名,接口)

常量：所有字母都大写

注释：提高代码阅读性，解释代码意义，调试时候用

单行：用//表示，编译器看到//会忽略该行//后的所文本

多行：用/**/表示，编译器看到/*时会搜索接下来的*/,忽略掉/**/之间的文本。

文档：文档注释用/** */表示，是java特有的注释，其中注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。

文档注释   (编写软件说明书)

1.需要使用sum给我们提供的javadoc工具生成一个html的说明文档。

2.只能抽取public的属性或者方法内容。

格式：

Javadoc –d 指定存储文档的路径  -version –author(可选)  目标文件

       

       @author 作者

       @version 版本

       @param 方法的参数

       @return 返回值

注释的使用细节：

       三种注释可以出现在程序的任何地方，但是不推荐找任意位置。

1. 编程习惯：

              1. 给那条语句进行说明，注释应该写在该语句的旁边。

2. 单行注释一般写在语句的后面多行注释和文档注释一般写在语句的上面

       注意：文档注释只能出现在类、属性、方法的上面。

1.1.1.2.java类结构

package demo.day01;//必须是小写字母。多个单词用.隔开

import java.util.scanner;//javaAPI一定在当前库中存在

public class Hello{//类名的每个单词的首字母大写

System.out.println();//编译错误，语句一定要在成员内编译错误没有class文件不能运行

//类体中的成员，要缩进1个tab

public static void main(String[] args){

//方法中成员也要缩进1tab

Scanner sonsole=new Scanner(System.in);

}//方法体的结束也要和方法的声明位置对齐

}//类体 括号要配对，声明开始的位置和结束的位置要对齐

1.1.1.3.java中的规范：见规范文档

最好遵循阿里java开发手册

1.1.2.数据类型和常量、变量

1.1.2.1.进制

进制：进制是一种记数方式 ，可以用有限的数字符号代表所有的数值。由特定的数值组成。

计算机硬盘存储的都是二进制，二进制的最高位是符号位：0表示正数，1表示负数

1.1.2.1.1.整型的表现形式

1.十进制： 都是以0-9这九个数字组成，不能以0开头。

2.二进制： 由0和1两个数字组成。

3.八进制： 由0-7数字组成，为了区分与其他进制的数字区别，开头都是以0开始。

4.十六进制：由0-9和A-F组成。为了区分于其他数字的区别，开头都是以ox开始。

1.1.2.1.2.进制的由来

     几乎每个民族最早都使用都十进制计数法，这是因为人类计数时自然而然地首先使用的是十个手指。 但是这不等于说只有十进制计数法一种计数方法。例如，世界各国在计算年月日时不约而同地使用“十二进制”12个月为一年又如：我国过去16两才算为一斤，这就是“十六进计数法”,一个星期七天，这个就是”七进制计算法”。 计算机是由逻辑电路组成，逻辑电路通常只有两个状态，开关的接通与断开，这两种状态正好可以用“1”和“0”表示。

二进制--原码、反码、补码

对于有符号的而言：

1、一个数在计算机中的二进制表示形式,  叫做这个数的机器数。机器数是带符号的，在计算机用一个数的最高位存放符号, 正数为0, 负数为1.

真值:真实数据值，因为机器数最高为是符号位，所以负数的机器数和真值是不一样的

机器数一般就是补码

2、正数的原码、反码、补码都一样，是机器数本身

负数的源码：

3、负数的反码=它的原码符号位不变，其它位取反

4、负数的补码=它的反码+1

5、0的反码，补码都是0

6、java没有无符号数，换言之，java中的数都是有符号的

7、在计算机运算的时候，都是以补码的方式来运算的，符号也参与运算。

8、计算机中没有减法运算，减法是加上一个负数

八进制的由来 

                     二进位制在计算机内部使用是再自然不过的。但在人机交流上，二进位制有致命的弱点——数字的书写特别冗长。例如，十进位制的100000写成二进位制成为11000011010100000。为了解决这个问题，在计算机的理论和应用中还使用两种辅助的进位制——八进位制和十六进位制。二进位制的三个数位正好记为八进位制的一个数位，这样，数字长度就只有二进位制的三分之一，与十进位制记的数长度相差不多。例如，十进位制的100000写成八进位制就是303240。十六进位制的一个数位可以代表二进位制的四个数位，这样，一个字节正好是十六进位制的两个数位。十六进位制要求使用十六个不同的符号，除了0—9十个符号外，常用A、B、C、D、E、F六个符号分别代表(十进位制的)10、11、12、13、14、15。这样，十进位制的100000写成十六进位制就是186A0。

人使用的十进制 、 计算机底层处理的数据是二进制、八进制、十六进制，

那么如果给计算机输入不同的进制数据呢？

1.1.2.1.3.进制转换

1.1.2.2.java数据类型 (基本数据类型和引用数据类型)

基本数据类型：数值型(整数类型、小数(浮点)类型)、布尔类型、字符类型

引用数据类型: 数组、类、接口。

1.1.2.2.1.数值型

1.1.2.2.1.1.整数类型

可以表示一个整数，常用的整数类型有：byte,short,int,long

byte  占用内存 一个字节 范围：-128至127 8bit  2(8)

short 占用内存 两个字节 范围：-32768至32767 16bit  2(16)

int   占用内存 四个字节 范围：-2147483648至2147483647 32bit  2(32)

long  占用内存 八个字节 范围：-?至? 64bit  2(64)

如果一个数值没有采取特殊的处理，那么该整数默认的类型是int。

可以使用数值后面添加L或l改变默认的整数类型。

1.1.2.2.1.2.小数(浮点)类型

可以表示一个小数，常用的小数(浮点)类型有：

float(单精度),double(双精度)默认

float 占用内存 四个字节 范围：3.4E-38至3.4E+38 只能提供7位有效数字

double占用内存 八个字节 范围：1.7E-308至1.7E+308 可提供16位有效数字

注意：3.4E-38--e是exponent的缩写，意为指数。这里特指e右边的数是以10为底的指数。例如3.4e-38表示3.4×10^(-38

1.1.2.2.2.布尔类型

可以表示"真"或者"假"，类型是boolean

比如：

boolean spBool=true; //给变量spBool定义为boolean型并赋值为真

1.1.2.2.3.字符类型

可以表示 单个字符，字符类型是char，char是两个字节(可以存放汉字)

多个字符我们称为字符串，在java中String这种数据类型表示，但是String不是基本数据类型，是引用数据类型

结论：在java中，对char进行运算的时候，直接当做ascii码对应的整数对待。

思考：int test1='a'+'b';  输出值195

      char test2='a'+'b'; 输出值? A

      char test3='中';    输出值 20013

1.1.2.3.类型运算规则

级别从低到高为：byte,char,short(这三个平级)-->int-->float-->long-->double

自动类型转换：从低级别到高级别，系统自动转的；

强制类型转换：什么情况下使用?把一个高级别的数赋给一个别该数的级别低的变量；

自动类型提升：只有运算符号两边数据类型相同时才能运算(结果也是与两个数的数据类型是同类型，如果得到的结果不同，会强转)，类型向占用内存大的数据类型一方转

赋值的值是一个常量

int a=1.2; (报错)    double b=3;

结论：数据类型可以自动的从低精度-->高精度。高精度不能转为低精度。

byte小于

在java中的小数默认是double数据类型

float赋值时要在值后加f

long赋值时要在值后加l

强制转换:(类型)数据

如何把高精度转成低精度？

int a=(int)1.2;

1.1.2.3.1.类型转化

1、自动类型转换(也叫隐式类型转换)

   可以将一个数赋值给更大数值范围的变量，例如可以经byte 变量赋值给short变量可以将short变量赋值给int变量可以将int变量赋值给long变量。

Java内部其实做了工作就是自动将数值进行了类型提升，就叫做自动类型转换(也叫隐式类型转换)

byte b = 1; //00000001         short s = b;  //00000000 00000001         int i = s;         long lon = i;         double d = lon; //1.0

自动类型转换(也叫隐式类型转换)

要实现自动类型的转换，需要满足两个条件，第一两种类型彼此兼容，第二目标类型取

值范围必须大于源类型。所有的数字类型，包括整形和浮点型彼此都可以进行转换。

例如：

byte b=100;         int x=b;         System.out.println(x);//程序把b结果自动转换为int类型。

2、强制类型转换(也叫显式类型转换)

不可以将一个数值赋给范围更小数值范围的变量，除非进行类型转换。

byte b = 100;         b = b + 2;//编译失败         System.out.println(b);

上述例子发生了什么，发生了类型转换。

b+2 遇到了加法运算，2默认是int类型，byte类型b变量存储的值自动类型提升为

了int类型。执行完加法运算后的结果就是int类型，想要将int的类型值放入到byte类型变量b中，无法放入，编译报错。

byte b=1;         b=(byte)(b+2);

当两种类型彼此不兼容，或者目标类型取值范围小于源类型(目标是byte源是int)

无法自动转换，此时就需要进行强制类型转换。

强制类型转换需要注意：

   损失精度！！！

int a=128;         byte b=(byte)a;         System.out.println(b);//-128         /*         * 此时的强转已经造成了数值的不准确         */

   int 

00000000

00000000

00000000

10000000

                                                      

10000000

                                                       byte       

   

      

再次分析此行代码

byte b = 100; b = b + 2;         System.out.println(b);

  编译：提示如下错误。

  

3、类型转换的原理

可以把byte 理解为1两的碗，short 2两的碗，int 4两的碗，long 8两的碗。1两碗的满碗酒可以倒入 2两 4两 8两的碗中。但是 4两碗的酒倒入1两碗的酒就有一些问题。

1、什么时候要用强制类型转换

   比如小数部分只想保留整数部分.

   一定要清楚要转换的数据在转换后数据的范围内否则会损失精度.

public static void main(String[] args) {         byte b = 100;         b = (byte) (b + 2);         System.out.println(b); // 102         //舍弃小数部分         double d=5.5;         int num=(int)d; }

2、表达式的数据类型自动提升

算术表达式，逻辑表达式  

所有的byte型、short型和char的值将被提升到int型。

如果一个操作数是long型，计算结果就是long型；

如果一个操作数是float型，计算结果就是float型；

如果一个操作数是double型，计算结果就是double型。

分析 System.out.println(‘a’+1)结果？

自动类型提升

byte b = 3;         int x = 4;         x = x + b;// b会自动提升为int 类型参与运算。         System.out.println(x);// 7

强制类型转换

byte b = 2;         /*         * 强制类型转换，强制将b+2强制转换为byte类型，再赋值给b         */         b = (byte) (b + 2);         System.out.println(b);// 4

思考1

byte  b=126;

问：既然数据默认的有数据类型，那么126 默认是int类型的，为什么存储到byte类型时不会报错呢。

126 是常量java在编译时期会检查该常量(每个常量)是否超出byte类型的范围。如果没有可以赋值。

思考2：byte b=128;能否正常的编译和运行。

该语句会出现编译错误，128超出了byte变量的存储范围，所以出现编译错误。

思考2

byte b1=3，b2=4，b;

b=b1+b2；

b=3+4；

哪一句编译失败？为什么？

b =3+4， 3和4都是常量，所以java在编译时期会检查该常量(每个常量)是否超出byte类型的范围。如果没有可以赋值。例如b=128+1 就无法编译通过。b=127+1;也是无法通过。

b =b1+b2 不可以，因为b1 和b2 是变量，表达式求值时，变量值会自动提升为int型，表达式结果也就成了int型，这是要赋值给byte型的b，必须进行强制类型转换了。

6、System.out.println(‘a’+1)结果

美国人为了让计算机识别他们生活中的文字,让二进制表示生活中的文字.所以一个字母代表了一个二进制.,二进制也有十进制的表现形式.,把生活中的字母都用数字来标识,例如97 代表a ，98 代表 b。打印’a’就把a作为输出显示,没有疑问。但是 ‘a’+1  有加号涉及到了运算。根据java自动类型提升规则，同样道理 char 提升为int 。就把’a’代表的数字体现了出来。a 表示的是97  97+1就是98; 那么 想要查看98 表示的char 是什么 怎么实现呢 ?就要用到刚才介绍的强制类型转换了 System.out.println(char(‘a’+1))；就取到了98 在ASCII码表中表示的字符。大写A 和小写a 在 ASCII有不同的表现。还有一个概念字符’1’ 在ASCII中 不是数字 1,可以运行代码查看,到此就可以明白了char 类型,char类型也是可以参与运算的,为什么可以参与运算呢。因为字符在ASCII表中都有对应的数字体现。所有的计算机兼容ASCII。

        System.out.println('a'+1); //98

      System.out.println((char)('a'+1));  //b

补充问题：

int i='a'+'b';         System.out.println(i);//结果？                System.out.println("hello"+'j'); //结果？

总结：

所有数值运算符都可以用在char型数据上，如果另一个操作数是一个数字或者字符，那么char会自动提升为int型，如果另一个操作数是字符串，那么字符就会和字符串相连。”Helloj”

1.1.2.4.常量

常量：是在程序中的不会变化的数据。

1.整数常量指所有的整数

2.小数常量指所有的小数

3.Boolean常量指 true false

4.字符常量‘s’只放一个数字 字母 符号

5.字符串常量 “”多个或者一个

6.Null常量 只有一个数值  就是null

char 类型

char类型表示的是单个字符类型，任何数据使用单引号括起来的都是表示字符。字符只能有一个字符，比如：普通的老百姓穿上军装就是军人。      

    注意：特殊字符的转义序列：转义字符

   转义字符的概述:

特殊字符使用”\”把其转化成字符的本身输出，那么使用”\”的字符称作为转移字符。

需求：使用输出语句，打印出带引号的信息例如输出。

System.out.println("teacher said"java is fun"");编译是无法正常通过的。语法有错误，编译器读到第二个引号就认为是字符串的结束，剩余的不知道怎么处理。如何解决这个问题：java中使用转义字符来表示特殊的字符。一个转义字符以反斜杠(\)开始。

     问题：想要打印带引号的字符串怎么办，就可以使用反斜杠(\)后跟字符，这个反斜杠就是转义字符。

转义字符	名称	Unicode
\b	Backspace (退格键)	\u0008
\t	Tab   (Tab键盘)	\u0009
\n	Linefeed (换行)	\u000A
\r	Carriage Return(回车)	\u000D
\\	Backslash (反斜杠)	\u005C
\'	Single Quote (单引号)	\u0027
\"	Double Quote (双引号)	\u0022

上述问问题解决：System.out.println("teacher said\"java is fun\"");

注意：换行符就是另起一行，回车符就是回到一行的开头，所以我们平时编写文件的回车符应该确切来说叫做回车换行符

1.1.2.5.变量，初始化，赋值

变量：内存中的一片存储区域，区域的数据可以在同一数据类型范围变化。相当于是用于存储可变数据的容器。

容器特点：

1.必须要有大小

2.存储一定格式的可变数据

3.必须要有名字

4 .  作用域

什么时候定义变量？只要是数据不确定的时候，就定义变量。

计算机主要用于处理生活中的数据，由于生活中存在大量的可变数据，那么计算机就必须具备存储可变数据的能力。比如：

1.时间每一秒都在发生变化，根据不同的时间要有不同的处理方式。

2.气象站会根据温度发布天气预报信号。

定义变量：数据类型 变量名=初始化值；

或者

          数据类型 变量名；

  变量名=变量值；

一定要给定义变量赋值                                                                                             

初始化变量

在定义变量的时候，就给值

int a=45;这就是初始化变量a

给变量赋值

比如你先定义了变量：int tt;

然后再给值tt=780;  ->这就是给变量赋值

1.1.3.运算符

1.1.3.1.算术运算符

1.1.3.1.1.单目运算

+取正 -取负 ++自增 --自减

算术运算符：++自加、--自减。

练习

int a=90;

a++;          等同于(a=a+1)

这时a等于？ 91

int b=89;

b--;          等同于(b=b-1)

这时b等于？ 88

int a=56;

int b=a++; 

System.out.println(b); 56

System.out.println(a); 57

int a=56;

int b1=++a;

System.out.println(a);//57

System.out.println(b1);57

int b=++a;相当于a=a+1再将b=a；(内存解析：先将++a做a=a+1运算，预存内存a的值，再将预存a的值取出参与运算)

int b=a++;相当于b=a再将a=a+1。(内存解析：先将a的值预存在内存中，a++做a=a+1运算，再将预存内存的值取出来参与运算)

1.1.3.1.2.双目运算符

java中常用的算术运算符是：+加(连接符 任何数据跟字符串相加都是相连接成字符串)、-减、*乘、/除、%取模

其实%运算可以得到两个数的余数。(当被模数   a%2可以做开关算法)

算术运算符：+=左加、-=左减、/=左除、%=左取模

a-=34;b%=a;       (相当于a=a-34,b=b%a)

练习

short s=3;//先检查是否在short范围内，如果在，再转换，砍掉高位，进行赋值

s+=4;//编译通过，前者在赋值过程中底层做了强制转换动作

s=s+4;//它不做转换，而且是两次运算

1.1.3.1.3.三元运算

(条件表达式boolean)？表达式1：表达式2(boolean true执行表达式1 false执行表达式2)

三元运算符和if esle的区别：

b=a>1?100:200;三元运算符就是一个运算符，必须要有结果，像上面没有结果是不行的，然而if else是可以没有结果的，当if else运算后，有一个具体的结果时，可以简化为三元运算符。

System.out.println((x%2==0?"偶数":"奇数"));

1.1.3.2.关系运算符(结果是布尔类型)

用于判断逻辑关系的运算符

==等于；2、>大于；3、=大于等于；5、<=小于等于；6、!=不等于< span="">

1.1.3.3.逻辑运算符(连接两个布尔类型的表达式)

&与；|或；&&与；2、||或；3、!非 4^异或

&:与，特点：两边为真才为真，一边为假则为假

| 或，特点：一边为真则为真，两边为假才为假

&&与的运算关系，真真为真，其它都为假。

||或的运算关系，假假为假，其它都为真。

!非的运算关系，真取假，假取真

^相同则结果为假，不同则结果为真 规律：一个数同时异或这个数两次结果还是这个数。用于加密

&与&&的区别：

共同点：二者都可以作为逻辑与的运算符，表示逻辑与，

不同点：&&有短路的功能，如果第一个表达式为false时，不需要进行第二个表达式的运算，

当&操作符两边的表达式不是boolean类型时，表示按位与操作。Eg:我们通常使用0x0f来与一个整数进行&运算，获取低四位；

|和||的区别：

 |：无论左边的运算结果是什么，右边都参与运算。

 ||：当左边为真时，右边不参与运算的。

1.1.3.4.位运算符和移位运算

位运算(二进位运算操作的都是2倍数)

java中有4个位运算，分别是“按位与&、按位或|、按位异或^，按位取反~”，它们的运算规则是：

按位与&：两位全为1，结果为1

按位或|：两位有一个为1，结果为1

按位异或^：两位一个为0，一个为1，结果为1(

一个数异同一个数两次结果还是这个数

)

按位取反~：0->1，1->0

java中有3个移位运算符：

>>、<

>>算术右移：低位溢出，符号位不变，并用符号位补溢出的高位除以2的几次方

<符号位不变，低位补0剩以2的几次方

>>>逻辑右移，运算规则是：低位溢出，高位补0

1.1.3.5.运算符的优先级与结合性

1.1.4.程序流程控制

1.1.4.1.顺序控制

1.1.4.2.分支控制

让程序有选择的执行，分支控制有三种：

1、单分支；2、双分支；3、多分支

1.1.4.2.1.单分支语法：

   if(条件表达式){

      语句;

   }

1.1.4.2.2.双分支语法：

   if(条件表达式){

      语句;

   }else{

      语句;

   }

1.1.4.2.3.多分支语法：

1.1.4.2.3.1.if多分支

   if(条件表达式){

      语句;

   }else if(条件表达式){

      语句;

   }else if(条件表达式){

      语句;

   }else{//可以没有这个分支

      语句;

   }

1.1.4.2.3.2.switch多分支

switch(条件表达式){ //条件表达式数据类型要和case常量表达式一致，允许                                                 byte,short,int,char,enum等，否则就会报错。

   case 常量1:

      语句1;//语句1至break中相当于{}可以加入相应程序代码

      break;  //break，表示跳出switch语句

   case 常量2:

      语句1;

      break;

      ...

   case 常量n:

      语句n;

      break;

   default:

      语句;

      break;

   }

1.1.4.2.4.循环控制

循环控制有三种

1.1.4.2.4.1.for循环 语法：

   for(循环初值;循环条件;步长){

      语句;  //循环体

   }

循环嵌套：大圈套小圈思想

练习

镂空菱形

public void testFor(){

                int lay=4;//菱形上半部行数

                for(int i=1;i<=< span="">lay-1;i++){ //判断循环上半部分

                        for(int k=1;k<=< span="">lay-i;k++){ //找行内*号前输出空格

                                System.out.print(" ");

                        }

                        for(int j=1;j<=(< span="">i-1)*2+1;j++){ //找行内输出星的位置

                                if(j==1||j==(i-1)*2+1){  //判断行最小长度和最大长度，并在最小长度和最大长度上输出*号，行内输入出空格。

                                        System.out.print("*");

                                }else{

                                        System.out.print(" ");

                                }

                        }

                        System.out.println(); //换行

                }

                for(int i=1;i<=< span="">lay;i++){  //判断循环菱形下半部分

                        for(int k=1;k<=< span="">i-1;k++){ //判断循环找*号前要输出空格处

                                System.out.print(" ");

                        }

                        for(int j=1;j<=(< span="">lay-i)*2+1;j++){ //判断循环行长度

                                if(j==1||j==(lay-i)*2+1){ //判断行最小长度和最大长度，并在最小长度和最大长度上输出*号，行内输入出空格。

                                        System.out.print("*");

                                }else{

                                        System.out.print(" ");

                                }

                        }

                        System.out.println();//输出换行

                }

}

1.1.4.2.4.2.while循环 语法：

   while(循环条件){

      语句;  //循环体

   }

特别说明：while循环是先判断在执行语句。

1.1.4.2.4.3.do while循环 语法：

   do{

      语句;  //循环体

   }while(循环条件);

特别说明：do while循环是先执行，再判断。

1.1.5.五、函数

函数：具有特殊功能的小程序。函数定义好之后，是需要被调用才会执行的。 main函数是有jvm调用的，不需要我们手动调用。

修饰符 返回值类型(void) 函数名(参数类型 形参名，参数类型 形参名，。。。。。。){

函数体；

Return (返回值与上面的类型匹配，结果返回给调用者);

}

函数的作用：将代码进行封装，提高了代码的复用性

定义函数：1.返回值类型；2.是否穿在未知的参数(是否存在要由调用者确定的参数)

注意事项：返回值类型与参数类型无关 函数体内可以调用函数 不可以定义函数

递归调用

递归算法：在函数或子过程的内部，直接或者间接地调用自己的算法。

递归算法的实质：是把问题转化为规模缩小了的同类问题的子问题。然后递归调用函数(或过程)来表示问题的解。

递归算法解决问题的特点：

(1)递归就是在过程或函数里调用自身。

(2)在使用递增归策略时，必须有一个明确的递归结束条件，称为递归出口。

(3)递归算法解题通常显得很简洁，但递归算法解题的运行效率较低，即占用内存很大，有时这种情况用栈来代替解决。所以一般不提倡用递归算法设计程序。

(4)在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。

最后我再补充一点:递归只是用在简单的循环场合中,这种场合就是递归函数体只含有一个IF-else语句的情况:

权限修饰符+(static)+函数返回类型+函数名(参数列表){

if(递归结束条件){递归结束终值赋值语句;return 返回值;}

else{累计计算+循环调用函数语句;

     return 返回值;}

}

函数重载：同类同名，参数列表不同(1.参数个数不同；2.参数类型不同；3.排列顺序不同)