章节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整数类型表格图
| 类型 | 占用存储空间 | 表示范围 |
|---|---|---|
| byte | 1字节 | -128~127 |
| short | 2字节 | -215~215-1 (-32768~32767) |
| int(integer) | 4字节 | -231~231-1 约21亿 |
| long | 8字节 | -263~263-1 |
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.表格
| 类型 | 占用存储空间 | 表示范围 |
|---|---|---|
| float | 4字节 | -3.403E38~3.403E38 |
| double | 8字节 | -1.798E308~1.798E308 |
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
扩展运算符
| 运算符 | 用法举例 | 等效表达式 |
|---|---|---|
| += | a += b | a = a+b |
| -= | a -= b | a = a-b |
| *= | a *= b | a = a*b |
| %= | a %= b | a = a%b |
代码
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=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课程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();
}
}