Java简单基础

Java基础

---

参考视频：https://www.bilibili.com/video/BV12J41137hu/

一、注释

1. 单行注释

   //我是一行注释
   //单行注释只能注释一行，使用双斜杠“//”，双斜杠后面的内容不会被执行
   

2. 多行注释

   /*
   我是多行注释
   多行注释使用"/* */" 在**里面写注释内容即可
   */
   

3. 文档注释

   /**
   *我是文档注释，我不常用
   * 每一行前面都会有一个*
   *@Author 还可以写一些标注
   */
   

二、关键字

https://blog.csdn.net/weixin_44893902/article/details/105204049 附上前辈链接

关键字一共有53个，且都为小写。包含48个关键字，2个保留字和3个特殊直接量。

1. 48个关键字

   abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while

2. 2个保留字

   goto、const

3. 3个特殊直接量

   true、false、null

三、标识符

1. 作用：用于类名、变量名和方法名
2. 命名规则
   • 标识符不可以使用53个关键字
   • 标识符只能由26个字母、0-9十个数字、_下划线和$美元符号组成；不能再有其他的任何成分。
   • 表示符不可以是数字开头
3. 命名规范
   • 类名首字母大写，后面每个单词首字母大写（大驼峰命名法）
   • 变量名首字母小写，后面每个单词首字母大写（大驼峰命名法）
   • 方法名和变量名一致

四、数据类型

Java是强类型语言，所有的变量必须严格按照要求来定义。

基本数据类型	引用数据类型
整数：byte、short、int、long	类：String、Integer等
浮点数：float、double	接口
字符：char	数组
布尔值：boolean	lambda ···

数据类型         所占空间					          数据范围
    整数
    byte	  1字节   -2^7 ~ 2^7-1                   -128 ~ 127
    short	  2字节  -2^15 ~ 2^15-1                -32768 ~ 32767
    int 	  4字节  -2^31 ~ 2^31-1           -2147483648 ~ 2147483647
    long	  8字节  -2^63 ~ 2^63-1  -9223372036854774808 ~ 9223372036854774807
    浮点数
    float     4字节                          3.402823e+38 ~ 1.401298e-45
    double    8字节                         1.797693e+308 ~ 4.9000000e-324
    字符
    char  	  2字节  
    布尔 
    boolean 单独使用 	 4字节(int)  		取值只有 true 或者 false
    boolean 数组		 1字节(byte)

注意

java 默认整数是int类型，浮点数是double类型；对于long类型和float类型，声明变量时需要分别在变量后面加上“L”和“F”

4.1 数据类型扩展

1. 整数扩展

           //Java中各种进制的表示：二进制0b  八进制0   十进制   十六进制0x
           //只需要在整数前面加上对应进制的前缀就行
           int binaryNum = 0b10;		// 二进制 2
           int octalNum = 010; 		// 八进制 8
           int decimalNum = 10;		// 十进制 10
           int hexadecimalNum = 0x10;  //十六进制 16
           System.out.println(binaryNum);
           System.out.println(octalNum);
           System.out.println(decimalNum);
           System.out.println(hexadecimalNum);
   

2. 浮点数拓展

   Java中浮点数存在舍入误差，不可以使用浮点数进行比较判断

   	float floatNum1 = 0.1F; //自己计算 0.1
           double doubleNum1 = 1.0 / 10; //自己计算 0.1
           //理论上上面两个数相等 实际上判断结果是false 就是因为浮点数存在舍入误差
           System.out.println(floatNum1 == doubleNum1); //false
   

   过大的浮点数也会存在舍入误差

   		float floatNum2 = 9999999999999F;
          	        float floatNum3 = floatNum2+1;
   		//相加之后两个应该不相等 但结果却是相等
           System.out.println(floatNum2 == floatNum3);//true
   

3. 字符拓展

   字符类型可以强制转化为int类型，而且字符本身就可以理解为数字。

   计算机中，通过Unicode和ASCII码两种表将字符和数字进行对应。

           char char1 = 'A';
           char char2 = '中';
           char char3 = '国';
           System.out.println(char1);      //A
           System.out.println((int)char1); //65
           System.out.println(char2);      //中
           System.out.println((int)char2); //20013
           System.out.println(char3);      //国
           System.out.println((int)char3); //22269
   

   同样的，我们也可以将Unicode编码和ASCII编码转换为字符。

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

   上面新建的字符中，我们可以看到和其他字符不一样，我们规定char类型只能有单个字符，但是上面声明的字符却不是。这里我们就要提出一种新的字符—转义字符。

   转义字符

        常用的转义字符
            \t		水平制表符  水平移动一个Tab位置
            \n		换行符
            \r		回车
		System.out.println("Hello\tWorld");
        System.out.println("Hello\nWorld");
		//控制台打印
		Hello	World
		Hello
		World

4.2 数据类型转换

在学习数据类型转换之前，我们需要先了解到数据类型的数据范围大小。

小-----------------------------------------------------------------------------大

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

当数据类型不一致时，就会发生数据类型的转换。

4.2.1 自动类型转换

特点：不需要进行特殊处理，自动完成。
规则：数据范围小的数自动转换为数据范围大的数。
    long longNum = 'a';//发生了自动类型转换

4.2.2 强制类型转换

特点：需要进行特殊处理，不能自动完成。
规则：数据范围大的数强制类型转换为数据范围小的数。
    范围小的数据类型 变量名 = (范围小的数据类型)原来范围大的数。
    int intNum = (int)80L;//发生了强制类型转换

4.2.3 注意事项

1. 一般不推荐使用强制类型转换，可能会发生精度损失、数据溢出等问题。
        //数据溢出
        int i = 128;
	byte b = (byte)i;
	System.out.println(b);//打印 -128 ；byte的最大值是127，强制类型转换虽然编译没问题，但是会发生数据溢出。
	
	int num1 = 20_0000_0000;//20亿，JDK7新特性，数字之间用下划线连接，不影响数字，方便易读。
	int num2 = num1 * 10; 
	System.out.println(num1 * num2);//1345294336 我们可以发现 并不是我们想要的200亿 由于数据过大发生了数据溢出
	System.out.println( ((long)num1) * num2);//4000000000 只有对单个数字进行数据类型转换才能保证数据不溢出
	
	//精度损失
	float f = 13.14F;
	double d = -13.14;
	System.out.println((int)f);//打印 13 ；
	System.out.println((int)d);//打印 -13 ；浮点数强制类型转换为整数，发生了精度损失。
2. byte、short、char发生数学运算时，会先自动转换为int类型再计算。
    //
    short shortNum = 127;
    byte byteNum = 127;

	//下面这行代码在编译器中会报错，因为byte、short、char发生数学运算时，会先自动转换为int类型再计算。
	//相当于 shortNum1 = byte * short ---> int * int = int 
    short shortNum1 = byteNum * shortNum; 

	//需要将该结果强制类型转换为short,而且要保证没有数据溢出
	short shortNum1 = (short)(byteNum * shortNum);
3. boolean不能发生任何强制类型转换。
4. 不能把数据类型转换为不相干的类型。

五、变量、常量

5.1 变量

5.1.1 格式：数据类型 变量名 = 值;

5.1.2 注意：

1. 变量都有数据类型，可以是基本类型，也可以是引用类型。
2. 变量名必须是合法的标识符。

5.1.3 变量作用域：

• 类变量

public class Demo{
    //类变量 - static
    //可以在类里面直接使用，会随着类的出现而出现
    static {
        int a = 1;
        float f = 1.0f;
    }
}

• 实例变量

public class Demo{
    //实例变量
    //属于对象，如果不赋值，使用类型的默认值(整数/char -- 0；浮点数 -- 0.0；其余类型 -- null)
    int b = 2;
    double d = 3.14;
}

• 局部变量

public class Demo{
    public void demoMethod(){
        //局部变量
        //使用之前必须要声明和赋值！！
        int c= 3;
        char e = 'a';
    }
}

5.2 常量

5.2.1 格式： final 常量名 = 值;

5.2.2 注意事项

• 常量一般是在程序运行中不会改变的量。
• 常量的命名一般使用大写字母和下划线的组合（两个单词之间使用下划线）。

六、运算符

6.1 算术运算符

6.1.1 四则运算

+、-、*、/

6.1.2 取模运算

%

6.1.3 自增自减运算

++、--

自增自减运算符分为前++(–) 和后++(–)

++a  是先加后用，就是将加1之后的值进行使用（前++）
a++  是先用后加，使用之后再加1（后++）
减法同样

6.1.4 注意

一旦运算中出现不同的数据类型，那么结果将自动转换为默认数据类型或者数据范围大的那种数据类型。

• 整数默认是 int

• 浮点数默认是double

• 布尔值默认是false

long l = 999_9999_9999L;
int i = 2;
short s = 3;
byte b = 4;
System.out.println(l+i+s+b); //long类型
System.out.println(i+s+b); //int类型
System.out.println(s+b); //int类型

6.2 赋值运算符

简单赋值运算符	=
复合赋值运算符	+=、-=、*=、/=、%=

复合赋值运算符在进行计算时，隐含了强制类型转换。

6.3 关系运算符

> 、<、 >=、 <=、 == 、!=

《注意》
    当有多个值使用关系运算符时，不可以连着用。例如 3<a<5 这是错误的
    关系运算符的结果只有 true 和 false  两种

6.4 逻辑运算符

与、或、非 —> &&、||、！

《注意》
    && 和 || 运算符会发生短路现象，可提高性能
    短路：
    boolean flag = true || a++; //发生短路现象，a++不会被执行
    boolean flag1 = false && b--; //发生短路现象，b--不会被执行

6.5 位运算符 — 二进制的运算

& （按位与）、|（按位或） ^（异或） ~（取反） <<（左移） >>（右移） >>>（无符号右移）

& （按位与）--- 二进制位都是1结果才为1，其余都为0
A: 1000 0001
B: 0100 1101    
A & B = 0000 0001    
    
|（按位或）--- 二进制位有都是0结果才是0，其余都为1
A: 1000 0001
B: 0100 1101    
A | B = 1100 1101        
    
^（异或） --- 二进制位相同为0 不同为1
A: 1000 0001
B: 0100 1101    
A ^ B = 1100 1100   
    
~（取反）--- 所有二进制位 0 变 1  1变0
A: 1000 0001
B: 0100 1101    
~A = 0111 1110
~B = 1011 0010
    
《计算效率贼高！！！》
<<（左移）--- 看上去向两个向左的箭头，表示要把二进制数据在内存空间中向左边移动,   
int a = 3 << n; //相当于3乘以2的n次方
a = 0000 0011
a << 2  =  0000 1100 = 12 = 3*(2^2)
>>（右移）--- 与左移运算符的方向恰好相反，右移之后正数首位补0 负数首位补1
int b = 8 << n; //相当于8除以2的n次方
b = 0000 1000
b >> 2  =  0000 0010 = 2 = 8 /(2^2)
>>>（无符号右移）--- 与数据正负无关，右移之后首位都填充0
int c = 8 << n; //相当于8除以2的n次方
c = 0000 1000
c >>> 2  =  0000 0010 = 2 = 8 /(2^2)

6.6 条件运算符 — 三元运算符

? :

格式： 变量数据类型 变量名 = (布尔表达式) ? (真值结果) : (假值结果);

注意：结果类型必须和变量类型一致

int max = 4,min = 3;
int a = (max > min)?1:0; 

6.7 优先级

在编码的时候，建议写上小括号，易读

优先级记忆方法：单目乘除为关系，逻辑三目后赋值。

6.8 包机制

6.9 JavaDoc

命令：javadoc -encoding UTF-8 -charset UTF-8 类名.java  该命令需要在类所在文件夹下运行