Java基础语法

注释

书写注释是一个非常好的习惯

Java中的注释有三种:

# 单行注释 //
# 多行注释 /* */
# 文档注释 /**      */

File——New——Moudle（模块）

注释字体颜色修改

有趣的注释

/***
 *                    _ooOoo_
 *                   o8888888o
 *                   88" . "88
 *                   (| -_- |)
 *                    O\ = /O
 *                ____/`---'\____
 *              .   ' \\| |// `.
 *               / \\||| : |||// \
 *             / _||||| -:- |||||- \
 *               | | \\\ - /// | |
 *             | \_| ''\---/'' | |
 *              \ .-\__ `-` ___/-. /
 *           ___`. .' /--.--\ `. . __
 *        ."" '< `.___\_<|>_/___.' >'"".
 *       | | : `- \`.;`\ _ /`;.`/ - ` : | |
 *         \ \ `-. \_ __\ /__ _/ .-` / /
 * ======`-.____`-.___\_____/___.-`____.-'======
 *                    `=---='
 *
 * .............................................
 *          佛祖保佑             永无BUG
 */
————————————————
版权声明：本文为CSDN博主「Mr_YDK」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/ydk888888/article/details/81563608

标识符和关键词

Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

表示类名的标识符用大写字母开始。

如：Man, GoodMan

表示方法和变量的标识符用小写字母开始，后面的描述性词以大写开始。

如：eat(), eatFood() 		//驼峰命名法

关于 Java 标识符，有以下几点需要注意：

• 所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始

• 首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合

• 不能使用关键字作为变量名或方法名。

• 标识符是大小写敏感的

• 合法标识符举例：age、$salary、_value、__1_value

• 非法标识符举例：123abc、-salary、#abc

数据类型

Java是一种强类型语言，每个变量都必须声明其类型。

1、强弱类型语言

强类型语言

也称为强类型定义语言。要求变量的使用要严格符合规定，所有变量都必须先定义后（初始化）才能使用。

Java、.NET、C++等都是强制类型定义的。也就是说，一旦一个变量被指定了某个数据类型，如果不经过转换，那么它就永远是这个数据类型了。

安全性高，运行效率相对较慢，鱼和熊掌不可兼得！强类型定义语言在速度上可能略逊色于弱类型定义语言，但是强类型定义语言带来的严谨性能够有效的避免许多错误。

弱类型语言

也称为弱类型定义语言。与强类型定义相反。像vb，php等就属于弱类型语言·

在VBScript中，可以将字符串‘12’和整数3进行连接得到字符串‘123’，也可以把它看成整数123，而不需要显示转换。是不是十分的随便，我们Java就不是这样的。

但其实它们的类型没有改变，VB只是在判断出一个表达式含有不同类型的变量之后，自动在这些变量前加了一个clong（）或（int）（）这样的转换函数而已。能做到这一点其实是归功于VB的编译器的智能化而已，这并非是VB语言本身的长处或短处。

数据类型

Java的数据类型分为两大类：基本类型（primitive type）和引用类型 （reference type）

int：正负21亿

Long类型要在数字后面加个L

float类型要在数字后面加个F

一共8种基本数据类型

Java语言的整型常数默认为Int型，浮点数默认是double

什么是字节

/*
位（bit）：是计算机 内部数据 储存的最小单位，11001100是一个八位二进制数。 
字节（byte）：是计算机中 数据处理 的基本单位，习惯上用大写 B 来表示, 1B（byte,字节）= 8bit（位） 
字符：是指计算机中使用的字母、数字、字和符号 

### ASCIIS码： 
    1个英文字母（不分大小写）= 1个字节的空间 
    1个中文汉字 = 2个字节的空间 
    1个ASCII码 = 一个字节 

### UTF-8编码： 
    1个英文字符 = 1个字节 
    英文标点 = 1个字节 
    1个中文（含繁体） = 3个字节 
    中文标点 = 3个字节 

### Unicode编码： 
    1个英文字符 = 2个字节 
    英文标点 = 2个字节 
    1个中文（含繁体） = 2个字节
    中文标点 = 2个字节 
*/

数据类型扩展

整型拓展

/*
十进制整数，如：99, -500, 0。
二进制数，要求以0b开头
八进制整数，要求以 0 开头，如：015 
十六进制数，要求 0x 或 0X 开头，如：0x15 
*/

浮点数使用拓展

1. 默认是double

2. 浮点数存在舍入误差，很多数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。

3. 避免比较中使用浮点数

字符型拓展

单引号用来表示字符常量。例如‘A’是一个字符，它与“A”是不同的，“A”表示一个字符串。

char 类型用来表示在Unicode编码表中的字符。.

Unicode编码被设计用来处理各种语言的所有文字，它占2个字节，可允许有65536个字符；

转义字符

Unicode具有从0到65535之间的编码，他们通常用从'u0000'到uFFFF之间的十六进制值来表示（前缀为u表示Unicode)

char c1 = '\u0061'
System.out.println(c1);			//a

布尔型拓展

boolean类型（一位，不是一个字节），就是0|1

boolean类型有两个值，true和false,不可以 0 或非 0 的整数替代 true 和 false ，这点和C语言不同。

boolean 类型用来判断逻辑条件，一般用于程序流程控制。

编码规范

if ( is && !un ) {....}		//老手

if (is == true && un == false ) {...} 		//新手

所以要习惯去掉所有的==fasle 和 ==true。Less is More！！ 代码要精简易读！

类型转换

由于Java是强类型语言，所以要进行有些运算的时候的，需要用到类型转换。

整型、实型（常量）、字符型数据可以混合运算。

运算中，不同类型的数据先转化为同一类型，然后进行运算。

转换从低级到高级（根据容量来看）。

低 ----------------------------------------> 高 

byte,short,char—> int —> long—> float —> double

小数的优先级一定大于整数

数据类型转换必须满足如下规则：

不能对boolean类型进行类型转换。

不能把对象类型转换成不相关类的对象。

在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

操作比较大的数时，要留意是否溢出，尤其是整数操作时

public static void main(string[] args) {
	int money = 1000000000;//10亿
	int years = 20;
	int total = money*years;/返回的是负数
	long total1 = money*years;				//返回的仍然是负数。默认是int，因此结果会转成int值,再转成1ong。但是已经发生了数据丢失
    
	long tota12 = money*((1ong)years);		//先将一个因子变成long，整个表达式发生提升。全部用1ong来计算。
    
	system.out.println(tota1);
    system.out.println(total1);
    system.out.println(tota12);
}

转换过程中可能导致溢出或损失精度，例如：

int i =128; 
byte b = (byte)i; 

浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入

L和l 的问题(程序规范)：

/*
不要命名名字为l的变量
long类型使用大写L不要用小写
*/

• 强制类型转换——高到低

  // (类型)变量名
  

• 自动类型转换——低到高

  /*
  例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。
  */
  

JDK7扩展

• 二进制整数

由于我们在开发中也经常使用二进制整数，因此JDK7为我们直接提供了二进制整数的类型。

我们只要以：0b开头即可。

• 下划线分隔符

在实际开发和学习中，如果遇到特别长的数字，读懂它令人头疼！JDK7为我们提供了下划线分隔符，可以按照自己的习惯进行分割。

int b = 1_2234_5678; 

我们很容易就知道这是1亿2234万5678啦！ 非常符合国人的习惯！

变量、常量、作用域

1、变量（variable）

Java是一种强类型语言，每个变量都必须声明其类型。

Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储单元，声明格式为：

// 数据类型 变量名 = 值；可以使用逗号隔开来声明多个同类型变量。
// 不建议在一行里面定义多个值，不方便阅读
type varName [=value] [{,varName[=value]}] ； 

注意事项：

• 每个变量都有类型，类型可以是基本类型，也可以是引用类型。

• 变量名必须是合法的标识符。

• 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

演示

int a, b, c; 					// 声明三个int型整数：a、 b、c 
int d = 3, e = 4, f = 5; 		// 声明三个整数并赋予初值 
byte z = 22; 					// 声明并初始化 z 
double pi = 3.14159; 			// 声明了双精度浮点型变量 pi 
char x = 'x'; 					// 声明变量 x 的值是字符 'x'。

//String可以看作是数组，是引用类型，不是基本数据类型
String s = "runoob"; 			// 声明并初始化字符串 s 

【编码规范】

虽然可以在一行声明多个变量，但是不提倡这个风格，逐一声明每一个变量可以提高程序可读性。

2、变量作用域

变量根据作用域可划分为三种：

类变量（静态变量： static variable）：独立于方法之外的变量，用 static 修饰。

实例变量（成员变量：member variable）：独立于方法之外的变量，不过没有 static 修饰。

局部变量（lacal variable）：类的方法中的变量。

public class Variable{ 
    static int allClicks=0; 		// 类变量 
    String str="hello world"; 		// 实例变量，就是没有static关键词的类变量 
    
    public void method(){ 
        int i =0; 					// 局部变量 
    } 
}

局部变量

方法或语句块内部定义的变量。生命周期是从声明位置开始到”}”为止。

在使用前必须先声明和初始化(赋初值)。

局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

public static void main(String[] args) {
    int i; 
    int j = i+5 ; // 编译出错，变量i还未被初始化 
    
    System.out.println(j); 
}

修改为：

public static void main(String[] args) { 
    int i=10; 
    int j = i+5 ; 
    
    System.out.println(j); 
}

实例变量

方法外部、类的内部定义的变量。

从属于对象，生命周期伴随对象始终。

如果不自行初始化，他会自动初始化成该类型的默认初始值

（数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false，除了基本类型其他默认值都是null）

public class Test { 
    // 这个实例变量对子类可见 
    public String name; 
    // 私有变量，仅在该类可见 
    private double salary; 
    ... 
}

静态变量

使用static定义。

从属于类，生命周期伴随类始终，从类加载到卸载。

(注：讲完内存分析后我们再深入！先放一放这个概念！)

如果不自行初始化，他会自动初始化成该类型的默认初始值

（数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false）

public class Employee { 
    //salary是静态的私有变量 
    private static double salary; 
    // DEPARTMENT是一个常量 
    public static final String DEPARTMENT = "开发人员"; 
    
    public static void main(String[] args){ 
        salary = 10000; 
        
        System.out.println(DEPARTMENT+"平均工资:"+salary); 
    } 
}

3、常量

常量(Constant)：初始化(initialize)后不能再改变值！不会变动的值。

所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

final 常量名=值; 
final double PI=3.14; 
final String LOVE="hello";

常量名一般使用大写字符。

程序中使用常量可以提高代码的可维护性。例如，在项目开发时，我们需要指定用户的性别，此时可以定义一个常量 SEX，赋值为 "男"，在需要指定用户性别的地方直接调用此常量即可，避免了由于用户的不规范赋值导致程序出错的情况。

public class Demo {

    //修饰符不存在先后顺序，变量类型前面的static,final都是修饰符
    static final  double PI=3.14;
    final static double SEX=10;

    public static void main(String[] args) {
        System.out.println(PI);
        System.out.println(SEX);
    }
}

# 运行结果
"E:\Program Files\Java\jdk1.8.0_202\bin\java.exe" -Files\Java\jdk1.8.0_202\jre\lib\rt.jar;D:\code\out\production\code" Demo
3.14
10.0

Process finished with exit code 0

4、变量的命名规范

1. 所有变量、方法、类名：见名知意

2. 类成员变量：首字母小写和驼峰原则 : monthSalary

3. 局部变量：首字母小写和驼峰原则

4. 常量：大写字母和下划线：MAX_VALUE

5. 类名：首字母大写和驼峰原则: Man, GoodMan

6. 方法名：首字母小写和驼峰原则: run(), runRun()

基本运算符

1、二元运算符

两个操作数

整数运算

如果两个操作数有一个为Long, 则结果也为long

没有long时，结果为int。即使操作数全为shot,byte，结果也是int.

public static void main(String[] args) { 
    long a = 1231321311231231L; 
    int b = 1213; 
    short c = 10; 
    byte d = 8; 
    
    System.out.println((a+b+c+d)); //Long类型 
    System.out.println((b + c + d));//Int类型 
    System.out.println((c + d));//Int类型 
}

浮点运算

如果两个操作数有一个为double, 则结果为double.

只有两个操作数都是flfloat, 则结果才为flfloat.

public static void main(String[] args) { 
    float a = 3.14565F; 
    double b = 3.194546464; 
    float c = 1.3123123F; 
    
    System.out.println(a+b); //double类型 
    System.out.println(b+c); //double类型 
    System.out.println(a+c); //float类型 
}

关系运算符

返回布尔值！

2、取模运算

其操作数可以为浮点数,一般使用整数。如：5.9%3.9=2.000000004

要点：

负数%负数＝负数；

负数%正数＝负数；

正数%负数＝正数；

public static void main(String[] args) { 
    System.out.println(9 % 4); //1 
    System.out.println(-9 % -4); //-1 
    System.out.println(-10 % 4); //-2 
    System.out.println(9 % -4); //1 
}

【注：一般都是正整数运算，进行结果的判断！】

3、一元运算符

自增（++）自减（--）

自增自减运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数，分为前缀和后缀两种。

public static void main(String[] args) { 
    int a = 3; 
    int b = a++; 			//执行完后,b=3。先给b赋值，再自增。 
    int c = ++a; 			//执行完后,c=5。先自增,再给b赋值 }

注意：java中的乘幂处理

public static void main(String[] args) { 
    int a = 3^2; 				//java中不能这么处理， ^是异或符号。 
    double b = Math.pow(3, 2); 
}

4、逻辑运算符

逻辑与：&&和&，逻辑或：||和|，逻辑非：！。

public static void main(String[] args) { 
    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)); //如果是真，则变为假，如果是假则变为真
}

逻辑与和逻辑或采用短路的方式。从左到右计算，如果确定值则不会再计算下去。在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。

逻辑与只要有一个为false, 则直接返回false.

逻辑或只要有一个为true, 则直接返回true;

public static void main(String[] args){ 
    a = 5;//定义一个变量； 
    boolean b = (a<4)&&(a++<10); 
    
    System.out.println("使用短路逻辑运算符的结果为"+b); 
    System.out.println("a的结果为"+a); 
}

"E:\Program Files\Java\jdk1.8.0_202\bin\java.exe" -javaagent:E:\ideaIU_2021.2.3_Portable\ideaIU_2021.2.3_Portable\lib\idea_rt.jar=58169:E:\ideaIU_2021.2.3_Portable\ideaIU_2021.2.3_Portable\bin -Dfile.encoding=UTF-8 -classpath Files\Java\jdk1.8.0_202\jre\lib\rt.jar;D:\code\out\production\code" operator.Demo
使用短路逻辑运算符的结果为false
a的结果为5

解析： 该程序使用到了短路逻辑运算符(&&)，首先判断 a<4 的结果为 false，则 b 的结果必定是 false， 所以不再执行第二个操作 a++<10 的判断，所以 a 的值为 5。

5、位运算符

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。位运算符作用在所有的位上，并且按位运算。

A = 0011 1100 
B = 0000 1101 
----------------- 
A&b = 0000 1100 
A | B = 0011 1101 			// 或
A ^ B = 0011 0001 			// 异或
~A= 1100 0011

右移一位相当于除2取商。

左移一位相当于乘2。

【常见面试题：int a=2*8怎样运算效率最快？】

public static void main(String[] args) { 
    System.out.println(2 << 3); 
}

用移位运算 int a=2<<3; a就是2乘以8 最后结果是16 这是最省内存 最有效率的方法

这个方法确实高效率的。我来解释一下：2的二进制是10 在32位存储器里面是0000 0000 0000 0010 左移三位后变成 0000 0000 0001 0000 也就是16

解释一下，在系统中运算是以二进制的形式进行的。相比来说两个二进制数相乘运算比移位运算慢一些。

位操作是程序设计中对位模式按位或二进制数的一元和二元操作。 在许多古老的微处理器上， 位运算比加减运算略快， 通常位运算比乘除法运算要快很多。 在现代架构中， 情况并非如此: 位运算的运算速度通常与加法运算相同(仍然快于乘法运算). 详细的需要了解计算机的组成原理！

6、扩展运算符

public static void main(String[] args) { 
    int a=10; 
    int b=20; 
    a+=b; // a = a + b 
    
    System.out.println(a+":"+b); 
}

7、字符串连接符

“+” 运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串

然后再进行连接。

public class Demo {
    public static void main(String[] args){
        int a=10;
        int b=20;

        String s1="Hello 中文!";
        String s2=1+s1; 			//转换成String

        System.out.println(""+a+b);	//先转化为字符串
        System.out.println(a+b+"");	//先算a+b
        System.out.println(s2);
    }
}

"E:\Program Files\Java\jdk1.8.0_202\bin\java.exe" -javaagent:E:\ideaIU_2021.2.3_Portable\ideaIU_2021.2.3_Portable\lib\idea_rt.jar=59201:E:\ideaIU_2021.2.3_Portable\ideaIU_2021.2.3_Portable\bin -Dfile.encoding=UTF-8 -classpath "E:\Program Files\Java\jdk1.8.0_202\jre\lib\charsets.jar;E:\Program  Files\Java\jdk1.8.0_202\jre\lib\rt.jar;D:\07. code\out\production\code" operator.Demo
1020
30
1Hello 中文!

Process finished with exit code 0

8、三元运算符

三目条件运算符，语法格式：

x ? y : z

其中x为boolean类型表达式，先计算x的值，若为true，则整个三目运算的结果为表达式y的值，否则整个运算结果为表达式z的值。

public static void main(String[] args) { 
    int score = 80; 
    String type = score < 60 ? "不及格" : "及格"; 
    
    System.out.println("type= " + type); 
}

三元运算符在真实开发中十分的常见，大家可以多练习使用，之后我们会讲解分支语句，可以利用三元运算符做到更加精简代码！便于理解！

9、运算符优先级

下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。

大家不需要去刻意的记住，表达式里面优先使用小括号来组织！！方便理解和使用，不建议写非常冗余的代码运算！

public static void main(String[] args) { 
    boolean flag = 1<4*5&&122>3||'q'+3<5; 
    
    System.out.println(flag); 
}

包机制

为了更好地组织类，Java提供了包机制（package），用于区别类名的命名空间。

包的本质就是文件夹

// 包语句的语法格式为:
package pkg1[. pkg2[. pkg3...]];

一般利用公司域名倒置作为包名;

www.baidu.com——包名：com.baidu.www
com.kuangstudy.www
sail 风帆

为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用"import"语句可完成此功能

import package1[.package2...].(classname|*);

还有一个问题：我们平时在IDE中可以跑的文件，用命令行就会报错；

罪魁祸首正是代码第一行：package com.kuang.demo01;

这就是Java中的包机制，使用package com.kuang.demo01;

就要求此份.java文件必须保存在这样一个目录下，这样Java解释器才能找到它。 在IDEA中能正确运行，你可以去Windows下的工程中查看，HelloWorld这个文件必是在这样的目录结构下的。

JavaDoc生成文档

javadoc命令是用来自动生成自己API文档注释的

Java SE8官方文档：Overview (Java Platform SE 8 ) (oracle.com)

作业: 学会查找使用IDEA生成JavaDoc文档!

参数信息

• @author作者名
• @version版本号
• @since指明需要最早使用的jdk版本
• @param参数名
• @return返回值情况
• @throws异常抛出情况

// 快捷键: /**加回车
package com.sail.base;

/**
 * @author 
 * @version 
 * */
public class Doc {
}