从头开始学Java—Java基础语法之idea实操
已把本章所需代码上传至博客园，点击下载JavaSEv1.0源码
注释
在上课的时候，所有教语言的老师都会要求我们写注释，并告诉我们，书写注释是一个非常好的习惯，他能帮助别人看懂我的代码。何止别人，我在课设结束后答辩的时候，也都是靠注释保命的。
来来来，打开我们的idea，开始写注释啦。为了方便，我们就不建Java项目了，先建一个空的项目，双击运行idea，依次选择Create New Project、Empty Program
给我们的项目命名选位置，项目名就叫JavaSE吧！Finish
- 进入编辑页面后，依次选择File，New，module，进入新模块new module界面。进入这里就和之前建的hello world一样，选中Java，点击Next
- 又到了Java命名的地方了，就叫Grammar吧，点击Finish
- 又看到了熟悉的src文件夹，我们就在这里实操开始学习Java基础语法，点击工具栏Project Structure，弹出项目结构界面
- 点击Project，他显示我们没有装SDK，并且默认的语言是11
- 我们点击下拉按钮，选择自己的jdk版本1.8,项目语言等级也是8，让他们保持一致，点击OK
- 这样环境就配置好了，让我们再用Hello World来测试一下，右击Grammar里的src，依次选择New、Java Class，类名命名为helloworld，OK
- 像上次那样，继续使用psvm,sout,快速书写出mian函数和输出方法，点击绿色小箭头运行。哦，报了个错，让我瞅瞅，原来是环境没配置完，缺少输出目录，点击OK，又回到了第六步的界面
- 建一个项目输出目录
- 运行，Hello World！
-
添加注释，咦？是灰色的，毫不起眼，换一个的蓝色注释。
// 这是单行注释符号 /* 这是多行注释符号 这里面可以写很多行注释 */ /** *这是文档注释符号 *这个注释是有功能的 */
- 先点Apply，再点OK，单行注释颜色变了
ps:可以百度一下，有趣的代码注释，发现程序猿们的逗逼日常，寻找学习中的乐趣
标识符
- 标识符及命名规则
-
类名，变量名以及方法名都称之为标识符。
-
标识符的命名规则：由字母（A-Z或a-z），数字，下划线（_），美元符（$）组成，但数字不能开头。
-
标识符不能是java的关键字和保留字，但可以包含关键字和保留字，不能包含空格。
- 关键字
关键字
下面列出了 Java 关键字。这些保留字不能用于常量、变量、和任何标识符的名称。
| 类别 | 关键字 | 说明 |
|---|---|---|
| 访问控制 | private | 私有的 |
| protected | 受保护的 | |
| public | 公共的 | |
| default | 默认 | |
| 类、方法和变量修饰符 | abstract | 声明抽象 |
| class | 类 | |
| extends | 扩充,继承 | |
| final | 最终值,不可改变的 | |
| implements | 实现（接口） | |
| interface | 接口 | |
| native | 本地，原生方法（非 Java 实现） | |
| new | 新,创建 | |
| static | 静态 | |
| strictfp | 严格,精准 | |
| synchronized | 线程,同步 | |
| transient | 短暂 | |
| volatile | 易失 | |
| 程序控制语句 | break | 跳出循环 |
| case | 定义一个值以供 switch 选择 | |
| continue | 继续 | |
| default | 默认 | |
| do | 运行 | |
| else | 否则 | |
| for | 循环 | |
| if | 如果 | |
| instanceof | 实例 | |
| return | 返回 | |
| switch | 根据值选择执行 | |
| while | 循环 | |
| 错误处理 | assert | 断言表达式是否为真 |
| catch | 捕捉异常 | |
| finally | 有没有异常都执行 | |
| throw | 抛出一个异常对象 | |
| throws | 声明一个异常可能被抛出 | |
| try | 捕获异常 | |
| 包相关 | import | 引入 |
| package | 包 | |
| 基本类型 | boolean | 布尔型 |
| byte | 字节型 | |
| char | 字符型 | |
| double | 双精度浮点 | |
| float | 单精度浮点 | |
| int | 整型 | |
| long | 长整型 | |
| short | 短整型 | |
| 变量引用 | super | 父类,超类 |
| this | 本类 | |
| void | 无返回值 | |
| 保留关键字 | goto | 是关键字，但不能使用 |
| const | 是关键字，但不能使用 | |
| null | 空 |
数据类型
Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
byte：
- byte 数据类型是8位、有符号的，以二进制补码表示的整数；
- 最小值是 -128（-2^7）；
- 最大值是 127（2^7-1）；
- 默认值是 0；
- byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
- 例子：byte a = 100，byte b = -50
short：
- short 数据类型是 16 位、有符号的以二进制补码表示的整数
- 最小值是 -32768（-2^15）；
- 最大值是 32767（2^15 - 1）；
- Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
- 默认值是 0；
- 例子：short s = 1000，short r = -20000
int：
- int 数据类型是32位、有符号的以二进制补码表示的整数；
- 最小值是 -2,147,483,648（-2^31）；
- 最大值是 2,147,483,647（2^31 - 1）；
- 一般地整型变量默认为 int 类型；
- 默认值是 0 ；
- 例子：int a = 100000, int b = -200000
long：
- long 数据类型是 64 位、有符号的以二进制补码表示的整数；
- 最小值是 -9,223,372,036,854,775,808（-2^63）；
- 最大值是 9,223,372,036,854,775,807（2^63 -1）；
- 这种类型主要使用在需要比较大整数的系统上；
- 默认值是 0L；
- 例子： long a = 100000L，Long b = -200000L。
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写
float：
- float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
- float 在储存大型浮点数组的时候可节省内存空间；
- 默认值是 0.0f；
- 浮点数不能用来表示精确的值，如货币；
- 例子：float f1 = 234.5f
double：
- double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
- 浮点数的默认类型为double类型；
- double类型同样不能表示精确的值，如货币；
- 默认值是 0.0d；
- 例子：double d1 = 123.4
boolean：
- boolean数据类型表示一位的信息；
- 只有两个取值：true 和 false；
- 这种类型只作为一种标志来记录 true/false 情况；
- 默认值是 false；
- 例子：boolean one = true
char：
- char类型是一个单一的 16 位 Unicode 字符；
- 最小值是 \u0000（即为 0）；
- 最大值是 \uffff（即为65、535）；
- char 数据类型可以储存任何字符；
- 例子：char letter = 'A';
什么是字节
-
位（bit）：是计算机内部数据存储的最小单位，11001100是一个八位二进制数
-
字节（byte）：是计算机数据处理的基本单位，习惯用大写B来表示
-
1B = 8 bit
数据类型拓展
//整数拓展，进制：二进制，八进制，十进制，十六进制在Java中的表示
/*
二进制 以 0b 开头
八进制 以 0 开头
十六进制 以 0x 开头 0~9 A~F
*/
int i1 = 10;
int i2 = 010;
int i3 = 0x10;
System.out.println(i1);
System.out.println(i2);
System.out.println(i3);
System.out.println("---------------------------------------------");
//浮点数拓展，float和double的比较
/*
float 是一个有限的，离散的小数，具有舍入误差
所以最好不要用浮点数进行比较
在比较小数时，可用数学工具类 BigDecimal
*/
float f1 = 0.1f;
double d1 = 0.1;
System.out.println(f1);
System.out.println(d1);
System.out.println(f1 == d1); //false
float f2 = 1203867564;
float f3 = f2 + 1;
System.out.println(f2);
System.out.println(f3);
System.out.println(f2 == f3); //true
System.out.println("---------------------------------------------");
//字符拓展 所有的字符本质都是数字
/*
上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。
这被称为 ASCII 码，一直沿用至今。ASCII 码一共规定了128个字符的编码，最前面的一位统一规定为0。
Java的class文件采用utf8的编码方式，JVM运行时采用utf16，Java的字符串是unicode编码的。
总之，Java采用了unicode字符集，使之易于国际化。
*/
char c1 = 'A';
char c2 = '中';
System.out.println(c1);
System.out.println((int) c1);
System.out.println(c2);
System.out.println((int) c2);
System.out.println("---------------------------------------------");
//转义字符，具有特殊意义的字符， \t 制表符 ， \n 换行符号。
System.out.println("hello world");
System.out.println("hello\tworld");
System.out.println("hello\nworld");
System.out.println("---------------------------------------------");
类型转换
整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。
自动类型转换从低级到高级。强制类型转换从高级到低级。
低 ------------------------------------> 高
byte,short,char—> int —> long—> float —> double
操作比较大的数时，注意溢出问题
public class TypeConversion {
public static void main(String[] args) {
/*
1.不能对布尔值进行转换
2.不能把对象类型转换成不相干的类型，比如说你不能把🐖转换成人
3.在把高容量转换到低容量数据类型时，要强制转换
4.转换时可能存在数据溢出等问题
*/
int i1 = 128;
byte b1 = (byte) i1; // 强制转换
System.out.println(i1);
System.out.println(b1); // 溢出
System.out.println("---------------------------------------------");
System.out.println((int)3.14159); // double类型转换后精度丢失
System.out.println((int)-49.89F); // double类型转换后精度丢失
System.out.println("---------------------------------------------");
char c1 = 'a';
int i2 = c1 + 1 ;
System.out.println(i2);
System.out.println((char)i2);
System.out.println("---------------------------------------------");
// 操作比较大的数时，要注意溢出
//jdk 7 新特性，数字间可用下划线分割
int money = 10_0000_0000;
// System.out.println(money);
int year = 30;
int total1 = money * year ;
System.out.println(total1);
long total2 = money * year ; // 默认是int,计算完成后才转换为long类型，计算时已经溢出
System.out.println(total2);
long total3 = (long)money * year;
System.out.println(total3);
}
}
变量
在Java中，每个变量都要声明其类型。Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
- 变量作用域
- 类变量 一般会加static关键词
- 全局变量
- 局部变量 通常在方法中定义
public class Variables {
// 定义的属性，即变量
// 全局变量，从属于对象，定义在方法之外，偶尔叫实例变量
String name; // 默认初始化值为null，除了基本类型其他类型初始值都是空
int age; // 整型默认初始化值为0， 浮点型默认值为0.0
boolean falg; // 默认初始化值为false
// 类变量，即静态变量 要加static，从属于本类，其他类不能引用此类变量
static double salary = 7200;
// 主函数main方法
public static void main(String[] args) {
// 局部变量，是在方法中定义的变量。生命周期从本方法中的 { 开始，在 } 中结束。在使用前必须声明并初始化。
int i1 = 1024;
System.out.println(i1);
System.out.println("---------------------------------------------");
// 定义过的全局变量可以在这个方法使用，也可在其他方法中使用
// 变量类型 变量名 = new 变量类型（）
Variables vab = new Variables();
System.out.println(vab.name);
System.out.println(vab.age);
System.out.println(vab.falg);
System.out.println("---------------------------------------------");
// 类变量
System.out.println(salary);
}
}
常量
常量，是初始化后不能再变化的值。可以看作是特殊的变量，他的值被设定后，在程序中不能被改变。定义常量的关键字为final
运算符
public class Operator {
public static void main(String[] args) {
// 二元运算符
// 在分号后面按 Ctr + D 快捷键，复制当前行到下一行
int a = 10;
int b = 20;
byte c = 30;
int d = 60;
int e = 6;
// 算数运算符，在有多个不同级别的数据类型做运算，先将运算统一成该运算中最高的数据类型后再运算
System.out.println(a + b);
System.out.println(a - b);
System.out.println(c * d); // byte，short，int互相运算时，运算结果都是int类型
System.out.println(c / d); // 当结果存在小数时，注意变量的范围
System.out.println((double)c / d);
System.out.println(a % e); // 取除得的余数
System.out.println("---------------------------------------------");
// 关系运算，返回的结果只有两种：true 和 false
System.out.println(a > b);
System.out.println(a < b);
System.out.println(a == b); // == 为判断是否等于；= 为赋值
System.out.println(a != b);
System.out.println("---------------------------------------------");
// 一元运算符
// ++ 自增运算符 ；--自减运算符
int x = 2 ;
int y = x++ ; // x++ 即 x = x + 1
System.out.println(x);
int z = ++x ; // ++ 在前，先自增再赋值，++在后，先赋值再自增
System.out.println(x);
System.out.println(y);
System.out.println(z);
// 逻辑运算符，与、或、非
boolean f = true;
boolean g = false;
System.out.println("f && g : " + (f && g));
System.out.println("f || g : " + (f || g));
System.out.println("! (f && g) : " + !(f && g));
System.out.println("---------------------------------------------");
// 位运算，效率高，因为直接与底层打交道
/*
A 1101 1001
B 0000 1101
A&B 0000 1001 全1才1，否则为0
A|B 1101 1101 全0才0，否则为1
A^B 1101 0100 相同为0，否则为1；异或，等价于不进位加法
~B 1111 0010 取反
// << 左移 相当于✖2
// >> 右移 相当于➗2
二进制 十进制
0000 0000 0
0000 0010 2
0000 1000 8
0001 0000 16
*/
System.out.println( 2 << 3);
System.out.println("---------------------------------------------");
// 加和赋值操作符
int i1 = 10;
int i2 = 30;
i1 += i2; // i1 = i1 + i2
System.out.println(i1);
System.out.println(i2);
System.out.println("---------------------------------------------");
// 字符串连接符； 在加号（+）运算符的两侧，只要String类型不是在最末尾，就会把结果转换为String类型
System.out.println("" + i1+i2);
System.out.println(i1+i2 + "" + i2);
System.out.println(i1+i2 + a + "");
System.out.println("---------------------------------------------");
// 三元运算符
/*
x ? y : z
如果x为true，则结果为y,否则，结果为z
*/
int score = 61;
String type = score < 60 ? "补考" : "棒！";
System.out.println(type);
}
}
包机制
Java的包机制主要是为了区别类的命名。
为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。使用 "import" 语句可完成此功能。
在 java 源文件中 import 语句应位于 package 语句之后，所有类的定义之前，可以没有，也可以有多条，其语法格式为：
import package1[.package2…].(classname|*);
让我们来建一个包，这个小节的类命名为Package。点击New，Package，在弹框中给包命名为base（包命名全小写）。为使用某一个包的成员，用import语句来导入包
JavaDoc
JavaDoc命令是用来生成自己的API文档的。可以去百度使用IDEA生成JavaDoc文档
- 常用参数信息
- @author 作者名
- @version 版本号
- @since JDK版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
浙公网安备 33010602011771号