章节1：Java基础知识

课时1：java300集如何学习

• 基于JDK7.0
• 深入内存结果，分析JDK源码
• 高手从基础培养
• 学习语言，精通一门
• 内容包括：java基础、java虚拟机、数据结构与基本算法
• 第一季98集基础的基础

课时2：java历史、java核心优势

1.计算机语言发展史：
第一代：机器语言 //0101010
第二代：汇编语言 //使用单词表示计算机的操作
第三代：高级语言：
------面向过程：c语言（现代语言的鼻祖）
------ 面向对象：c++ java(c++-) C#
2.java简史
sun公司发明
Green项目
发明人:James Gosling
核心优势：跨平台
3.java版本
javaEE 服务器端
JAVASE 个人电脑
JAVAME 电子产品

课时3：JDK/JRE/JVM的区别 JDK下载安装 环境变量配置

JDK/JRE/JVM的区别

JDK java开发工具包（大）
JRE JAVA运行时环境（中）
JVM java虚拟机（小）
JVM是一种规范，针对不同操作系统。可以用软件实现；也可以用硬件实现
.java(编译 )---->.class类( 执行)---->jvm for UNIX/Windows...

java开发环境的配置

1.下载 oracle官网下载
2.安装
3.环境变量配置
JAVA_HOME -->E:\安装\Program Files\Java\jdk1.7.0_21
Path -->%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
classpath --> jdk5.0以上可以不对其进行配置

课时4：java第一个程序 HELLOWORD

public class Helloworld4{
    public static void main(String[] args){
        System.out.println("Helloworld!"); 
    }
}

课时5：helloword深化 文本编辑器的使用 注释

工具

文本编辑器：notepad++
集成开发环境IDE：Eclipse

几点常识

1.java大小写敏感
2.main方法是程序的入口方法，他有固定的书写形式：
public static void main(String[] args){}
3.在java中以“{}”划分程序的各个部分
4.java语句可以跨多行，每个语句以“;”结束
5.一个源文件可以对应多个class文件
6.编程风格：注意缩进、成对编程、见名知意
7.注释：“//”单行注释 “/*.......*/” 多行注释 也可注释一个单词

public class Hello {
    public static void main(String args[]){
        //debug模式
        int a = 1;
        int b = 2;
        int c = a*b;
        System.out.println(c);      
        System.out.println("大家好");
    }
}
class Man {
    
}

课程6：标识符 unicold和GDK 各种字符集的关系

1.标识符
作用：--给变量、类、方法命名
命名规则：
标识符必须以字母、下划线、美元符开头
标识符不可使用关键字
标识符其他部分可以是字母、下划线、美元符和数字的任意组合
java标识符的大小写敏感且对长度无限制
注：java内部不采用通常语言使用的ASCII字符集，而采用unlcode这样的标准国际字符集，因此，汉字也可以来定义标识符，但不建议使用汉字来定义标识符
2.字符集
ISO8859-1(西欧字符集)--> BIG5(台湾大五码，繁体)
ISO8859-1(西欧字符集)-->GB2312(大陆)-->GBK(GB2312的扩展，可繁体) -->GB18030
ISO8859-1(西欧字符集)-->Unicode(UTF-8) 国际通用字符集

• Unicode是一个字符集，而UTF-8是Unicode的其中一种，Unicode是定长的都为双字节，而UTF-8是可变的，对于汉字来说Unicode占有的字节比UTF-8占用的字节少1个字节。Unicode为双字节，而UTF-8中汉字占三个字节。
• GB18030：中国所有非手持、嵌入式计算机系统强制标准。汉字/维吾尔文等

课程7：整数类型、进制转换、编程中的L问题

1.java是一种强类型语言，每个变量都必须声明其类型

        基本数据类型  整数型  整数类型(byte/short/int/long)

                            浮点类型(float/double)
                     字符型（char）
                     布尔型（boolean）
  数据类型
         引用数据类型  类（class）
                     接口(interface)
                     数组

2.java语言整型常数的三种表现形式

• 十进制数，如：50，-500
• 八进制数，默认以0开头，如：010
• 十六进制数，以0X或0x开头，如：0x15
  3.java语言整型常数默认为int类型，如想声明long型常量，可在后加l或L（通常用大写）
  4.java整数类型表格图

Bigdecimal大小数、BigInterger大整数
5.代码

public class Helloworld5{
    public static void main(String[] args){
        int a = 10;
        int a2 = 010;    //8进制
        int a3 = 0xf;    //16进制
        System.out.println(a);
        System.out.println(a2);
        System.out.println(a3);
        System.out.println(Integer.toBinaryString(a));    //10进制-->2进制输出
        System.out.println(Integer.toOctalString(a));      //10进制-->8进制输出
        System.out.println(Integer.toHexString(a));       //10进制-->16进制输出
        byte a6 = 100;      
        System.out.println(a6);       //如果数据的大小没有超过byte/short/char的
        System.out.println("你好");   //表述范围，则可以被自动转型
        //byte a8 = 200;
        //System.out.println(a8);
        long a8 = 3245678982L;
        System.out.println(a8);
    }
}

课程8：浮点数 浮点误差问题

1.float类型被称作单精度类型，尾数可以精确到7位有效数字，多数情况下精度不能满足要求
2.double类型精度是float的两倍，被称作双精度，大多数程序采用此类型
3.java浮点类型常量两种表示形式：

• 十进制形式：3.14
• 科学技术法形式：314e2 314E2 314E-2
  double f = 314e2; //31410^2
  double f2 = 314e-2; //31410^(-2)

4.浮点数值默认为double类型，要将类型变为float，需要在后面增加F/f
5.浮点数存在舍入误差，很多数字不能精确表示，如需进行无舍入误差的数字计算，需要使用BigDecimal类，最好避免比较中使用浮点数。
6.表格

public class Double8{
    public static void main(String[] args){
        double d = 3.13;
        float f = 6.28f;  //如果不加f,精度损失，无法运行
        double d2 = 314e-2;
        System.out.println(d2);

        float f1 = 0.1f;
        double d1 = 1.0/10;
        System.out.println(f1==d1);  //输出false
    }
}

课程9:char 字符串入门 boolean

1.字符型

• 'A'是一个字符，单引号用来表示字符常量
• “A”表示含有一个字符的字符串
• char字符用来表示在Unicode编码表中的字符
• unicode编码被设计用来处理各种语言的所有文字，它占两个字节，可允许65536个字符
  java语言中还允许使用转译字符'' 来将其后的字符转变成其它的含义 如：'\n' 换行符
• char在0-65535范围，运算时直接当做整数来运算
• 可以把0-65535之间的整数直接转型为char
  2.代码

public class TestChar9{
    public static void main(String[] args){
        char c1 = 'a';
        char c5 = '\n';
        char c2 = '\''; 
        char c3 = '\t'; 
        char c4 = '\\';
        System.out.print(c1);
        System.out.print(c5);    // \n 换行符，前一结果输出后直接换行
        System.out.print(c2);    // \  转译符
        System.out.print(c3);    // \t 制表符
        System.out.print(c4);    
        char c6 = 'a';     //字符可以做数字来计算
        int i = c6 + 3;
        System.out.println(i);  //先输出本条结果，再换行
        System.out.print(i);
        char q = (char)99;      //强制将数字类型转换成字符类型
        System.out.println(q);
        for (int j=0;j<26;j++ ) {          //for循环
            char zimu = (char)(c6+j);
            System.out.print(zimu);
        }
        String str = "woshidada";         //java里的字符串
            System.out.println(str);
        boolean t = false;                //boolean类型逻辑判断
        if(t==true){     //不建议这么写，因为易写成t=true，那样无论前面怎么定义，
                  // 输出都是true。因为t本身就是boolean变量，直接if(t)就可以
           System.out.println("true");  
        }
    }
}  

3.java里的字符串，定义成string类了
4.boolean类型（占一位，不是一个字节）一个字节有8位

• boolean类型有两个值，trun和false
• boolean类型用来判断逻辑条件，一般用于程序控制

课程10：基本数据类型自动转换 强制转换 类型提升问题

自动转换

1.自动类型转换:容量小的数据类型可以自动转换为容量大的数据
2.特例：可以将整型常量直接赋值给byte,short,char等类型常量，而不需要强制类型转换，只要不超过其表数范围即可

数据类型自动转换图

3.同字节小范围转换为同字节大范围丢失精度
4.小字节小范围转换成大字节大范围无妨
5.大字节小范围转换成小字节大范围丢失精度

强制类型转换

• 强制类型转换，又被称为造型，用于转换一个数值的类型，在有可能丢失信息的情况下进行的转换是通过造型来完成的，但可能造成精度降低或溢出。
• 当将一种类型强制转换成另一种类型，而又超出了目标类型的表示范围，就会被截断成为一个完全不同的值
• 类型提升问题：两个数进行计算时，结果会自动向范围大的数字类型转换

public class Day10{
    public static void main(String[] args){
        byte b = 123;
        //byte b2 = 300;
        //char a = -3;
        char c2 = 'a';
        int i = c2;
        long d = 12343;  //这里long可以转换成float，但可能损失精度
        float f = d;
        int t2 =100;
        char t3 = (char)t2;
        System.out.println(t3);
        System.out.println("Helloworld!");
        int q1 = 3;
        long q2 = 4;
        double q3 = 5.3;
        int q4 = (int)(q1+q2);
        float q6 = (float)(q1+q3);
        int money = 1000000000;
        int years = 20;
        long total = (long)money*years;
        System.out.println(total);

        long times = 70L*60*24*365*80;   //L在前面加，防止计算时就超出int范围
        System.out.println(times);
    }
}

课时11：JDK新特性 二进制整数 下划线分隔符

二进制整数

下划线分隔符

public class erjinzhi11{
    public static void main(String[] args){
        int a = 0b0000_0000_0000_0000_0000_0000_0000_0011;
        System.out.println(a);
        int b = 1_2343_2343;
        System.out.println(b); 
    }
}

课时12：变量 成员变量 局部变量 常量 命名规范

变量

1.java是一种强类型语言，每个变量都必须声明其类型
2.java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域
3.变量在使用前必须对其声明，只有在变量声明以后，才能为其分配相应长度的存储单元，声明格式为
type varName [=value] [{,varName[=value]}] ; //[]为可有可无的
4.注意事项：

• 每个变量都有类型，类型可以是基本类型，也可以是引用类型
• 变量名必须是合法的标识符

5.变量声明

• 变量声明举例： double salary; int age;
• 可以在一行中声明多个变量（不提倡，可读性低）：int i,j;
  -可将变量的声明与初始化放在同一行中，如：int age = 18;

6.局部变量和实例变量

• 局部变量：方法或语句块内部定义的变量
  -在使用前必须声明和初始化（赋初值）
• 实例变量（成员变量）：
  -方法外部、类的内部定义的变量
  -如果不初始化，它会自动初始化成该类型的默认初始值（数值型变量初始化成0或0.0，字符型变量初始化是16位的0，布尔默认是false)

Final常量

只能被初始化一次,常量用大写

命名规范

1.所有变量、方法、类名：见名知意
2.变量、方法名：
-首字母小写和驼峰原则
-run(),runRun(), age ageNew monthSatary
3.常量：
-大写字母和下划线：MAX_VALUE
4.类名：
-首字母大写和驼峰原则：Man，GoodMan

public class Bian12{     //Bian12为类
    int t;      //实例变量、成员变量
    public static void main(String[] args){   //main为方法
        int a;
        a = 4;
        int b = a+3;
        int x,y,z;
        final int C = 34;
        //q = 35;
        final MAX_SPEED = 120;
        System.out.println(b); 

    }
}

课时13：运算符01 算术 逻辑 位运算符 扩展运算符

java语言支持如下运算符

• 算术运算符：+ - * / % ++ --
• 赋值运算符：=
• 关系运算符：> < >= <= == ！=
• 逻辑运算符：&& || !
• 位运算符：& | ^ ~ >> << >>>(了解)
• 条件运算符：？ ：
• 扩展赋值运算符： += -= *= /=

算术运算符

1.二元运算符类型提升

• 整数运算：如果两个操作数中有一个为long,则结果也为long，没有long时，结果为int,即使操作数全为short/byte,结果也是int
• 浮点运算：如果两个操作数有一个是double,则结果为double，只有两个操作数都是float，则结果才为float

2.一元运算符（++/--）
int a = 3;
int b = a++; //执行完后b=3,a=4，先给b赋值，再自增
int c = ++a; //执行完后c=5,a=5,先自增，再赋值给c

逻辑运算符（布尔:ture、false）

• 逻辑与：&&
• 逻辑或：||
• 逻辑非：！
• 逻辑与和逻辑或采用短路的的方式，从左到右计算，如果确定值，则不会计算下去
  boolean c = 1>2&&2>(3/0); &&不会抛出异常；说明没有执行3/0

位运算符（了解）

• ~--取反 &--按位与
• |--按位或 ^--按位异或
• <<:左移运算符
• >>:右移运算符
• 笔试可能会考：
  左移一位相当于乘2 int b = 3<<2; //322
  右移一位相当于除2取商 int d = 12>>2; //12/2/2
  例：8&4
  8：1000 //o相当于false
  4：0100
  1100
  例：：按位异或
  0 0 1 1 //参数相同得0，不同得1
  0 1 0 1
  0 1 1 0

扩展运算符

代码

public class Bian13{
    public static void main(String[] args){
        /*
        int e = 10%3;
        double d = 10.2%3;
        System.out.println(d); 
        int a = 3;
        int b = a++;  
        System.out.println(a); 
        System.out.println(b);
        int c = ++a;
        System.out.println(a); 
        System.out.println(c); 
        boolean f = 1>2&&2>(3/0);
        */
        int m = 8;
        int n = 4;
        System.out.println(m&n);
        System.out.println(m|n);
        System.out.println(~m);   //取反 -9
        System.out.println(m^n);
        int a = 3;
        a = a+5;
        a += 5;
        System.out.println(a);

    }
}

课时14：运算符02 字符串连接 三元运算符 优先级问题

位运算符

• 布尔类型的数据类型进行位运算
  boolean b1 = true&false;
  System.out.println(b1);
  此方法无法进行短路运算，所以一般还是采用逻辑运算

字符串连接符

• “+”运算符两侧的操作数中只要有一个是字符串(string)类型，系统会自动将另一个操作数转换成字符串然后再进行连接。
  String str = "5";
  int s = 4;
  System.out.println(s+str); //输出45

三元条件运算符

• 三元条件运算符，语法格式：
  x?y:z
  其中x为boolean类型表达式，先计算x的值，若为trun，则整个三元运算的结果为表达式y的值，否则整个运算结果为表达式z的值
• 经常用来代替简单的if-else判断

运算符优先级问题

• 大家不要刻意去记优先级关系
• 表达式里面优先使用小括号来组织

public class Boolean14{
    public static void main(String[] args){
        boolean b1 = true||false;
        System.out.println(b1); 
        String str = "5";
        int s = 4;
        System.out.println(s+str);
        int a = 3;
        int b = 4;
        String daxi = "";
        if(a<b){
            daxi = "a<b";
        }else{
            daxi = "a>b";
        }
        System.out.println(daxi);
        int c=5;
        int d=3;
        String daxiao = "";
        daxiao = (c<d)?"c<d":"c>=d";
        System.out.println(daxiao);
    }
}

eclipse开发环境的使用 建立java项目 运行java项目

eclipse介绍

• 最初IBM研发
• Eclipse是一个开放源代码的、基于java的可扩展开发平台
• 最初主要用于java语言开发，目前可通过插件用于其他语言的开发

安装

指定空间 指你放java文件的地方

课程16：eclipse运行程序的问题(src和bin问题)_debug模式

debug模式：程序分步执行，检查错误代码

课程17：if语句 单选择 双选择 多选择结构

控制语句

• 顺序结构、选择结构、循环结构
• 选择结构：单选择结构、双选择结构、多选择结构

单选择结构

if语句对条件表达式进行一次测试，若测试为真，则执行下面的语句，否则跳过该语句
附：
Math类的使用
int i = (int)(6*Math.random());
//产生：[0,5]

if-else双选择结构

当条件表达式为真时，执行语句1，否则执行else的语句

if___else if___else if多选择结构

-if(布尔表达式1){
语句块1；
-}else if(布尔表达式2){
语句块2；
-}.......
-}else if(布尔表达式n){
语句块n;
-}else{
语句块n+1;
}

• 逐条进行判断，条件匹配，进入语句体；否则对if语句继续匹配

 * 测试if语句
 */
public class If17 {
    public static void main(String[] args) {
        double d = Math.random(); //出一个[0~1)的小数
        int e = 1+(int)(d*6); //e属于[1,6]
        System.out.println(e);
        System.out.println("双选择结构");
        if(e>3) {
            System.out.println("大数！！！！");
        }else{
            System.out.println("小数！");
        }
        System.out.println("多选择结构");
        if(e==6){
            System.out.println("运气太好啦！");
        }else if(e>=4){
            System.out.println("运气挺好的！");
        }else if(e>=2){
            System.out.println("运气一般");
        }else{
            System.out.println("运气太差");
        }
    }
}

课时18:switch语句基本用法 case穿透现象

要点：每条case后必须加break，否则会case穿透，后面的每一条都执行。
利用case穿透

//Switch语句
public class Switch18 {
    public static void main(String[] args) {
        double d = Math.random(); 
        int e = 1+(int)(d*6); 
        System.out.println(e);
        switch (e){
        case 6:
            System.out.print("运气非常好！");
            break;          //break必须写上，否则case穿透会每一条都打印
        case 5:
            System.out.println("运气好！");
            break;
        case 4:
            System.out.println("运气一般！");
            break;
        default:
            System.out.println("运气不好！");
            break;
        }
//元音、半元音、辅音判断
        System.out.println("###############");
        char c = 'a';
        int rand = (int)(26*Math.random());
        char c2 = (char)(c+rand);
        System.out.print(c2 + ": ");
        switch (c2){
        case 'a':
        case 'e':  //利用了case穿透
        case 'i':
        case 'o':
        case 'u':
            System.out.println("元音");
            break;
        case 'y':
        case 'w':
            System.out.println("半元音");
            break;
        default:
            System.out.println("辅音");        
        }
        }
}

课时19:JDK7.0新特性之：switch增强

增强switch

• JDK7之前表达式结果只能是int(可以自动转为int的byte/short/char)、枚举类型
• 表达式结果可以是：字符串

public class Switch19 {
    public static void main(String[] args){
        String a = "索扬扬";
        switch (a){
        case "索扬扬":
            System.out.println("输入的是我的名字");
            break;
        default:
            System.out.println("输入的是别人的名字");
            break;
        }
    }
}

课时20：while语句_dowhile语句

While循环

• 在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次
• 语句中应有使循环结束的语句，否则会出现无限循环-“死”循环

Do-while循环（用的很少，了解）

• Dowhile: 先执行，后判断 总是保证循环体至少执行一次
• While：先判断，后执行

public class Whille20 {
    public static void main(String[] agrs){
        int a = 1;        //初始化
        while(a<=10){        //条件判断
            System.out.println(a);        //循环体
            a++;        //迭代
        }
        System.out.println("循环结束！");
        int b = 1;
        int sum = 0;
        while (b<=100){
            sum += b;//sum=sum+b
            b++;
        }
        System.out.println("和为" +sum);
        System.out.println("--------------");
        int e = 1;
        do{
            System.out.println(e);
            e++;
        }while(e<3);
    }
}

课时21：for语句

For循环

1.for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构
2.语法形式
-for(初始表达式;布尔表达式;步进){
-循环体;
}
3.for循环在执行条件测试后，先执行程序部分，再执行步进
4.在for语句的初始化部分声明的变量，其作用域为整个for循环体

代码

public class For21 {
    public static void main(String[] agrs){
        System.out.println("for循环");
        for(int i = 1;i<=5;i++){
            System.out.println(i);
        }
        System.out.println("计算100以内基数（偶数）的和");
        int oddSum = 0;
        int evenSum = 0;
        for(int e = 0;e<=100;e++){
            if(e%2!=0){
                oddSum +=e;
            }else{
                evenSum +=e;
            }
        }
        System.out.println("基数的和："+oddSum);
        System.out.println("偶数的和："+evenSum);
        System.out.println("0~1000被5整除的数，每行3个显示");
        for(int j = 1;j<=1000;j++){
            if(j%5==0){
                System.out.print(j+"\t");
            }
            if(j%15==0){
                System.out.println();
            }
        }
    }
}

课时22：综合练习_九九乘法表

输出打印九九乘法表

public class chenfa9922 {
    public static void main(String[] args) {
    for(int m=1;m<=3;m++){
        for(int i=1;i<=m;i++){
            System.out.print(i+"*"+m+"="+(i*m)+"\t");
        }
        System.out.println();
    }
    }
}

课时23break和continue_带标签的break和continue

break和continue

• 在任何循环语句的主体部分，均可用break控制循环的流程，break用于强行退出循环，不执行循环中剩余的语句，（break语句还可用于多支语句switch中）
• continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

带标签的break和continue

• goto关键字很早就在程序设计语言中出现，尽管goto仍是java的一个保留字，但并未在语言中得到正式使用，java没有goto
• 然而break continue这两个关键字的身上，我们仍然能看出一些goto的影子--带标签的break continue

代码

public class breakContinue23 {
    public static void main(String[] agrs){
    //生成0~100随机数，直到88为止，停止循环
        int total = 0;
        System.out.println("Begin");
        while(true) {
            total++;
            int i = (int)Math.round(100*Math.random());
            if(i==88){
                break;
            }
        }
        System.out.println("Game over,used " + total + " time.");
        System.out.println("把100到150之间能被3整除的数输出");
        for(int q=100;q<=150;q++){
            if(q%3!=0){       //如果满足就直接上去继续执行for循环
                continue;    
            }
            System.out.println(q);
        }
        System.out.println("101~150之间的质数");//只能被1和自己整除的数
        int count = 0;
        outer: for (int w = 101;w<150;w++){
            for (int j = 2;j<w/2;j++){
                if(w%j == 0)
                    continue outer;
            }
            System.out.print("质数"+w+"\t");
        }
    }
}

课程24：方法、方法的本质、形参、实参、return语句

方法

• java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段
• 声明格式

[修饰符1 修饰符2 ...] 返回值类型 方法名(形式参数列表){
      java语句;... ... ...
 }

• 形式参数：在方法被调用时，用于接收外界的参数
• 实参：调用方法时实际传给方法的数据
• 返回值：方法在执行完毕后返还给调用它的环境的数据
• 返回值类型：事先约定的返回值的数据类型，如无返回值，必须给出返回值类型void
• java语言中使用下述形式调用方法：对象名.方法名（实参列表）
• 实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配
• return 语句终止方法的运行并指定要返回的数据
• java中进行方法调用中传递参数时，遵循值传递的原则： 基本类型传递的是该数据值得本身，引用类型传递的是对对象的引用，而不是对象本身
• java中只有值传递
• 设置方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只能完成1个功能，这样利于我们后续的扩展

public class newText24 {
    public static void test01(int a){  //public static 修饰符1   修饰符2
        int oddSum = 0;           //返回值类型    void指无返回值
        int evenSum = 0;
        for(int i = 0;i<=a;i++){
            if(i % 2 !=0){
                oddSum +=i;
            }else{
                evenSum +=i;
            }
        }
        System.out.println("奇数的和："+ oddSum);
        System.out.println("偶数的和："+ evenSum);
    }
    public static void test02(int a,int b,int c){        
        for (int j = 1;j<=a;j++){
            if(j % b == 0){
                System.out.print(j + "\t");
            }
            if(j % (b * c) == 0){
                System.out.println();
            }
        }
    }
    public static int add(int a,int b){  //public static 修饰符1   修饰符2  
        int sum = a+b;             //int返回值类型    int a形式参数列表
        return sum;            //int返回值类型   add方法名
    }
    public static void main(String[] agrs){
        test01(1000);
        System.out.println("#################");
        test02(100,6,4);
        int s = add(3,5);     //3,5为实参   s为返回值
        System.out.println(s);
    }
}

课程25：递归算法详解

递归结构

• 递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己
• 递归结构包括两部分
  定义递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
  递归体：什么时候需要调用自身方法

递归算法

5！=？

public class diGui25 {
    static int b = 0;
    
    public static void test01(){
        b++;
        System.out.println(b);
        if(b<=10){
        test01();
        }else{
            System.out.println("over");
        }
    }
    public static long factorial(int a){
        if(a == 1){
            return 1;
        }else{
            return a*factorial(a-1);
        }
    }
    public static void main(String[] agrs){
        test01();
        System.out.println(factorial(5));
    }
}

课程26：api文档 package的概念 生成自己项目的api文档

API文档的阅读

• API:Application Programming Interface 应用程序编程接口
• package的简单使用：java中的核心包：java.lang包

package 包的用法

• 为什么需要package?
  1.为了解决类之间的重名问题
  2.为了便于管理类：合法的类位于合适的包
• package怎么用
  1.通常是类的第一句非注释性语句 package cn.syy;
  2.包名：域名倒着写即可，再加上模块名，便于内部管理类
• 注意事项
  1.写项目时都要加包，不要使用默认包
  2.com.gao和com.gao.car这两个包没有包含关系，是两个完全独立的包，
  只是逻辑上看起来后者是前者的一部分

方法就是函数 项目-->包com.gao-->类.java-->方法class

JDK中主要的包

• java.lang 包含一些java语言的核心类，如String、Math、Integer、System和Thread,提供常用功能
• java.awt 包含了构成抽象窗口工具类（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)
• java.net 包含执行与网络相关的操作的类
• java.io 包含能提供多种输入/输出功能的类
• java.util 包含一些实用工具类，如定义系统特性，使用与日期日历相关的函数

生成自己项目的API文档

• 特殊的注释： 文档注释：/**
• 使用JAVADOC生成API文档： 解决问题：代码和文档的分离
• 常用的java注释标签：
  @Author 作者
  @version 版本
  @param 参数
  @return 返回值的含义
  @throws 抛出异常描述
  @deprecated 废弃。建议用户不在使用该方法

课程27 键盘输入 Scanner类的使用 import简单入门

代码

import java.util.Scanner;
public class scanner27 {
    public static void text01(){
        Scanner s = new Scanner(System.in);  //new Scanner是构造器
        String str = s.next();   //程序运行到next会阻塞，等待键盘的输入
        System.out.println("刚才键盘输入："+str);
    }
    public static void text02(){
        Scanner s = new Scanner(System.in); 
        System.out.println("请输入一个加数：");
        int a = s.nextInt();
        System.out.println("请输入另一个加数：");
        int b = s.nextInt();
        int sum = a+b;
        System.out.println("计算的和为："+ sum);
    }
    public static void main(String[] agrs){
        text02();     
    }
}