03Java 基础：基础语法
Java 基础：基础语法
1、注释、标识符、关键字
注释
平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到注释了。
注释并不会被执行，是给我们写代码的人看的
书写注释是一个非常好的习惯
Java中的注释有三种:
-
单行注释
-
多行注释
-
文档注释
标识符
Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
标识符注意点
- 所有的标识符都应该以字母(A-Z或者a-z),美元符($)、或者下划线（_）开始
- 首字符之后可以是字母(A-Z或者a-z), 美元符（$)、下划线（_）或数字的任何字符组合不能使用关键字作为变量名或方法名。
标识符是大小写敏感的- 合法标识符举例: age、$salary_value、_1_value
- 非法标识符举例:123abc、-salary、#abc
可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，很Low
关键字
2、数据类型
强类型语言
要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用弱类型语言
弱类型语言
Java的数据类型分为两大类
- 基本类型(primitive type)
- 引用类型(reference type)
数据类型
public class DataClass {
public static void main(String[] args) {
/* 1、整数类型 */
// byte 1 字节 8 位
// short 2 字节 16 位
// int 4 字节 32 位
// long 8字节 64 位
byte num1 = 127;
short num2 = 32767;
int num3 = 2147483647;
long num4 = 9223372036854775807L; // long 为了区别于其他的数据类型，需要在末尾天加“身份证”L,一般用的少的
System.out.println(num1);
System.out.println(num2); // 最为常用的整数类型
System.out.println(num3);
System.out.println(num4);
/* 2、浮点数类型 */
// float 4 字节 32 位
// double 8 字节 64 位
float num5 = 10.0F; // float 同样的为了区别于其他数据类型，需要在末尾填加“身份证”F，一般用的少的
double num6 = 3.1415926;
System.out.println(num5);
System.out.println(num6);
/* 3、字符型 */
// char 2 字节 16 位
char char1 = '中';
System.out.println(char1);
/* 4、布尔型 */
// boolean flag = false;
boolean flag = true;
System.out.println(flag);
}
}
数据类型拓展
public class DataClassExpand {
public static void main(String[] args) {
// 整数型拓展：进制 （0b）二进制 (0)八进制 十进制 (0x)十六进制
int num1 = 0b10;
int num2 = 010;
int num3 = 10;
int num4 = 0x10;
System.out.println(num1);
System.out.println(num2);
System.out.println(num3);
System.out.println(num4);
System.out.println("===============================================");
// 浮点数拓展：银行业务怎么表示？ 钱,
// BigDecimal
// float and boolean 是不精确的，是个大概值, 有限 离散 四舍五入 大约 接近但不等于
// 最好完全不使用浮点数型进行浮点比较
// 最好完全不使用浮点数型进行浮点比较
// 最好完全不使用浮点数型进行浮点比较
/* 实例1： 浮点数 与 运算得到的浮点数 大小不等 (约进位数不相同)*/
float num5 = 10.1F;
float num6 = 10.10000001F; // 准确表示只有前8位
double num7 = 1.00_0000_0000_0001 / 10; // 准确表示只有在只有前17位
double num8 = 10.0 / 100;
System.out.println(num5 == num6); //true
System.out.println(num7 == num8); //false
/* 实例2： 浮点数值溢出，运算不精确 */
float num9 = 12345678.0F; //float的运算精确只有8位
float num10 = num9 + 0.1F;
System.out.println(num9 == num10); //true
System.out.println("===============================================");
// 字符拓展：字符转换, unicode码（2字节）, ASCLL码， 转义字符
char char1 = 'a';
char char2 = '中';
System.out.println(char1);
System.out.println((int) char1); //强转类型
System.out.println(char2);
System.out.println((int) char2);
// 所有的文字本质上还是数字
// 编码Unicode 2字节 16位 0 - 65536 (A->65,a->97)
// U0000 ~ UFFFF
// a 的unicode码表示：97 转(十六进制) \u0061
char char3 = '\u0061';
System.out.println(char3);
// 制表符 \t
// 换行符 \n
// 回车 \r
String str1 = "hello world!";
String str2 = "hello\tworld!";
String str3 = "hello\nworld!";
String str4 = "hello\rworld!";
System.out.println(str1); // hello world!
System.out.println(str2); // hello world!
System.out.println(str3);
System.out.println(str4); // world!
System.out.println("===============================================");
String str5 = "Hello World!";
String str6 = "Hello World!";
String object_s1 = new String("Hello World!");
String object_s2 = new String("Hello World!");
System.out.println(str5 == str6); // true
System.out.println(object_s1 == object_s2); //false,相同参数的类实例，不相等
// 对象，从内存分析
// 布尔值拓展：
boolean flag = true;
if(flag==true){}; //新手
if(flag){}; //老手
// Less is More!
}
}
整数拓展：进制
- 二进制：
0b10 - 八进制：
010 - 十六进制：
0x10
什么是字节
-
位： 是计算机内部数据储存的最小单位，11001100是一个八位二进制数。
-
字节： 是计算机中数据处理的基本单位，习惯上用大写B来表示，
-
字符: 是指计算机中使用的字母、数字、字和符号
1bit 表示 1位，
1B (byte,字节) = 8bit(位)
1Byte 表示一个字节 1B = 8b。
1024B=1KB
1024KB=1M
1024M=1G.
思考: 电脑的32位和64位的区别是什么呢 ?（寻址能力）
3、类型转换
由于Java是强类型语言，所以要进行有些运算的时候的，需要用到类型转换。
运算中，不同类型的数据先转化为同一类型，然后进行运算。
- 强制类型转换
- 自动类型转换
public class TypeConversion {
public static void main(String[] args) {
/* 类型转换
低 - - - - - - - - - - - - - - - - - - -> 高
byte,short,char -> int -> long -> float -> double # 浮点最高
- 强转类型：将容量高的转换为容量低的 (byte) short; 高 ---> 低
- 自动转换：将小容量的转换为大容量的 低 ---> 高
*/
int num1 = 128;
byte num2 = (byte) num1; // 内存溢出,重新从最小的算
System.out.println(num1);
System.out.println(num2);
double num3 = 1.000_0000_0000_0000_2; // 准确识别17位
double num5 = 1.000_0000_1; //准确位数 8位
float num4 = (float) num3;
float num6 = (float) num5;
System.out.println(num4);
System.out.println(num6);
System.out.println(num4 == num6); //true
/*
注意点：
1、不能对布尔值进行转换
2、不能将对象类型转换为不相干的类型
3、将高容量类型转换为低容量类型时，是强制转换，
4、可能会初选内存溢出，或者是精度问题！
*/
/* 实例1: 高容量装换为低容量 （内存溢出，精度问题）*/
System.out.println((int) 3.14F);
System.out.println((int) -45.723); //只取整数，小数溢出
/* 实例2:: char 强转 int */
char char1 = 'a';
int int1 = char1 + 1;
System.out.println((int) char1 + 1);
System.out.println((char) int1);
/* 操作较大的数时，注意，溢出问题！！！ */
int a = 10_0000_0000;
int b = 20;
long c = a*b; //这里的原因是，它本身先运行后，才将结果赋值给c，所以c是获取溢出后的值
System.out.println(a*b); // -1474836480,内存溢出
System.out.println(c); // -1474836480,内存溢出
//解决方式：在运算之前，将数据的其中一个值进行扩容。 后面的就通过自动转换变成精确值
System.out.println((long)a*b);
//标识long 与 float时，最好使用大写 L 和 F
}
}
4、变量、常量
1变量
- 变量是什么:就是可以变化的量!
- Java是一种强类型语言，每个变量都必须声明其类型。
- Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
// 数据类型 变量名=值; 可以使用逗号隔开来声明多个同类型变量。
type varName [=value] [{,varName[=value]}];
注意事项:
- 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
- 变量名必须是合法的标识符。
- 变量声明是一条完整的语句，因此每一个声明都必须以分号结束
public class Variable {
// 这里可以声明 类变量（static）与 实例变量（原有类实例化）
static final int GLOBAL_VAL = 200; // 类常量,常量全大写 + _
static int classVal = 100; // 类变量,使用驼峰原则
String str1 = "Hello World!"; // 实例变量： 实例这个词，就是说它本身就是一个 类的实例化对象, 从属于对象，于对象属性
String name = "Redskaber";
String test; // null,除去普通的数据类型，其余的默认为null
int int1; // 0 int
float float1; // 0.0 浮点数
public static void main(String[] args) {
// 这里的范围即是局部变量的范围
// public中的变量，只能在本{}内使用
final int TEST_VAL = 20; //局部常量
int a = 10; // 局部变量
System.out.println(TEST_VAL);
System.out.println(a);
System.out.println(GLOBAL_VAL);
System.out.println(classVal);
// 类内部的public中想获取到类中的实例变量，首先new一个声明类,将会得到一个 类名数据类型 的对象 object
Variable variable = new Variable();
System.out.println(variable); // 对象
System.out.println(variable.str1); // 对象中的属性str1的属性值
System.out.println(variable.name); // 对象中的属性str1的属性值
//如果类变量没有声明对应的值,则会获取默认值
System.out.println(variable.test);
System.out.println(variable.int1); //这里前缀没有声明 static,所以只能通过 类.类变量 来获取
System.out.println(variable.float1); //这里前缀没有声明 static,所以只能通过 类.类变量 来获取
//可用通过：类.类方法 实现调用
variable.add();
}
public void add(){
// public内部没有定义的将会报错
// System.out.println(a);
System.out.println(GLOBAL_VAL);
}
}
2常量
常量(Constant): 初始化(initialize)后不能再改变值! 不会变动的值。
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
final 常量名=值;
final double PI=3.14;
常量名一般使用大写字符。
变量命名规范
- 所有变量、方法、类名:见名知意
- 类成员变量: 首字母小写和驼峰原则:monthSalary
- 局部变量: 首字母小写和驼峰原则
- 常量: 大写字母和下划线: MAX_VALUE
- 类名: 首字母大写和驼峰原则: Man, GoodMan
- 方法名: 首字母小写和驼峰原则: run(), runRun()
5、运算符
Java语言支持如下运算符:
- 算术运算符: + - * l % ++ --
- 赋值运算符: =
- 关系运算符: > < >= <= == != instanceof
- 逻辑运算符: && || !
- 位运算符: & | ^ ~ >> << >>>(了解!!! )
- 条件运算符: ? :
- 扩展赋值运算符: += -= *= /=
算术，关系运算符
package operator;
public class Operator {
public static void main(String[] args) {
int a = 10;
int b = 20;
Operator operator = new Operator(); //new一个Operator类
operator.arithmeticOperations(a, b); //调用类方法
operator.addConversion(); //调用类方法
operator.relationOperations(); //调用类方法
}
public void arithmeticOperations(int a, int b) {
// 算术运算符: + - * /
System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(a / (double) b); // / 取模运算, int/int ==> int int/(double)int ==>double
}
public void addConversion(){
long a = 233434343434L;
int b = 1234567890;
short c = 34;
byte d = 12;
float e = 1.23F;
double ee = 1.23;
System.out.println(a+b+c+d); // long
System.out.println(b+c+d); // int
System.out.println(c+d); // int
System.out.println(e-ee); // double 1.9073_4863_4588_857E-8
System.out.println(e/ee); // double 1.0000_0001_5506_8995 17位
System.out.println(b+a+e+ee); // double
System.out.println(b+a+e); // float
System.out.println(b+b); // int溢出
/* 如果运算中没有int类型，则不管结果大小，其结果类型都是int，
如果运算中有int类型，并且运算结果是在int范围内，则还是可以精确的使用int类型，
如果运算中有int类型，但是运算结果超出int范围，则会出现内存溢出现象。溢出的部分重新从最小的开始计算。
如果运算中有大于int类型的，那么运算的结果就是容量最高类型。（byte,short,char->int->long->float->double）
*/
}
public void relationOperations(){
//关系运算符
int a = 10;
int b = 20;
int c = 11;
System.out.println(a>b);
System.out.println(a==b);
System.out.println(a<b);
System.out.println(a!=b);
System.out.println(c%a); // 取余运算 11%10 ~ 1
}
}
-
如果运算中没有int类型，则不管结果大小，其结果类型都是int，
-
如果运算中有int类型，并且运算结果是在int范围内，则还是可以精确的使用int类型，
-
如果运算中有int类型，但是运算结果超出int范围，则会出现内存溢出现象。溢出的部分重新从最小的开始计算。
-
如果运算中有大于int类型的，那么运算的结果就是容量最高类型。（byte,short,char->int->long->float->double）
自增减运算
package operator;
public class SelfIncreasingAndDecreasing {
public static void main(String[] args) {
// 自增（a++,++a）自减(a--,--a)
int a = 10;
int c = a++; // int c = a; a += 1;
int d = ++a; // a +=1 ; int c = a;
System.out.println(a);
System.out.println(c);
System.out.println(d);
// 算术运算Math，幂运算
double num1 = Math.pow(2,3);
System.out.println(num1);
}
}
逻辑运算符
package operator;
public class Logic {
public static void main(String[] args) {
// 与（and） 或（or） 非（取反）
// 逻辑运算： 与（A&&B） 或（A||B） 非,取反（!(A&&B)）
boolean a = true;
boolean b = false;
System.out.println("a&&b:"+(a&&b)); // 与运算，全真为真
System.out.println("a||b:"+(a||b)); // 或运算，全假为假
System.out.println("!(a&&b):"+!(a&&b)); // 非运算，真假相反
// 短路运算：当前面部分的条件可以得出结果为真时，后序的运算将不会再执行，直接得出结果。
/* 实例1、 A&&B */
int num1 = 10;
boolean boo1= (num1>12)&&(num1++<11); // num>12 -yes-> pass
System.out.println("(num1>num2)&&(num1+num2>num2):"+ boo1); //false
System.out.println(num1); // 10
/* 实例2、A||B */
boolean boo2 = (num1>9)||(num1--<9); //num1>9 -yes-> pass
System.out.println("(num1>9)||(num1--<9):"+boo2); //true
System.out.println(num1); // 10
}
}
位运算符
package operator;
public class Bit {
public static void main(String[] args) {
// 位运算：& | ^ ~ >> << >>>(了解!!! )
// & | 与逻辑运算类似（将0是作为false，1是作为true）
// so
// A&B : AB全1为1
// A|B : AB全0为0
// A^B : AB相同为0，不同为1
// ~B : 0为1,1为0
/*
A 0011 1100
B 0000 1101
-------------
A&B 0000 1100 (一假为假)
A|B 0011 1101 (一真为真)
A^B 0011 0001 (同为0)
~B 1111 0010 (取反值)
与面试相关的位运算题：
- 2*8怎么运算最快？
2*8=16 2*2*2*2 （左移）<< >>（右移）
*/
/*
位运算的效率是极极高的！！（底层，与底层的二进制打交道的）
<< *2
>> /2
左移增大了，反之右移减小
0000 0000 0
0000 0001 1
0000 0010 2
0000 0100 4
0000 1000 8
0001 0000 16
*/ // 当1左移一位时，数值增大一倍
System.out.println(2<<3);
条件运算符：三元运算符 ？：
package operator;
public class Ternary {
public static void main(String[] args) {
// 三元运算：参数= 条件 ? 结果1:结果2;
// a = z ? x:y; <==> a = x if z else y
// 如果 z 为true，则x，否则y
int source = 60;
String grade = source >= 60 ? "合格" : "不合格";
System.out.println(grade);
}
}
赋值运算符拓展：+ String () 优先级
package operator;
public class Ternary {
public static void main(String[] args) {
Ternary ternary = new Ternary();
ternary.SelfAutoExpend();
}
public void SelfAutoExpend() {
// 自增型拓展
int a = 10;
int b = 20;
a += 10; // a = a+10;
b -= 10; // b = b-10;
System.out.println(a);
System.out.println(b);
/* 字符串拓展 字符串连接符 “+” */
/* 实例1、 String + int类型 --> (String)int类型 ---> + =String */
System.out.println("" + a + b);
System.out.println(a + b + "");
// 为避免出现类型不同的相互运算导致错误，这里严肃的提出了优先运算符 "()"
System.out.println("" + (a + b)); // 字符串与数值+，默认强转字符串类型
System.out.println(getType((a + b))); // 数值的运算的结果还是数值类型，class java.lang.Integer
}
private static String getType(Object a) {
return a.getClass().toString();
}
}
6、包机制、JavaDoc
包机制
为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。
包语句的语法格式为:
package pkg1[. pkg2[. pkg3...]];
一般利用公司域名倒置作为包名; www.baidu.com ==> com.baidu.www
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用"import”语句可完成此功能.
import package1[.package2...].(classname|*);
创建多级目录(包)
-
汉化后的
-
点击左侧菜单栏的齿轮图标
-
取消掉树外观下压缩空的中间软件包
-
-
原版的
- 点击左侧菜单栏的齿轮图标
- Tree Appearance
- 取消掉 Compact Middle Pakages
包的导入
JavaDoc
javadoc命令是用来生成自己API文档的
参数信息
- @author 作者名
- @version 版本号
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- throws 异常抛出情况
javadoc 生成文档
编码兼容：-encoding utf-8 -charset utf-8
# javadoc 参数 doc.java
$javadoc -encoding utf-8 -charset utf-8 javadoc.java
浙公网安备 33010602011771号