Java初了解（三）----基础语法

电玩女神 2023-07-18 03:25 20阅读 0赞

### 什么叫做开发语言？什么叫做计算机编程？ ###

最重要人和机器沟通，计算机底层物流实现只有0和1  
要把人类语言表达翻译成计算机能识别的0和1

#### 一、开发语言分类： ####

*  高级语言：C、Python、PHP、Java等
 *  低级语言：汇编语言（指令和密码）、机器码（0、1）

#### 二、关键字： ####

*  有特殊含义，这些普通开发者是不能去使用，已经被java所占用

下面列出了 Java 关键字。这些保留字不能用于常量、变量、和任何标识符的名称。  
![数据来源-菜鸟教程][-]

###### *问题：关键字是不允许使用的，那java是关键字吗？能否使用呢？* ######

*  java不是关键字，但是不能使用，sun api时，它自己使用java
 *  可以去写，但是可能出现一些“灵异”现象。不要去使用！！

###### *注意：* ######

*  单元测试JUnit，Test也不要使用！将来可能和junit冲突
 *  Spring框架，spring也不要轻易使用。

#### 三、标识符：自己定义的名称 ####

Java标识符由数字，字母和下划线（\_），美元符号（$）或人民币符号（￥）组成。  
在Java中是区分大小写的，而且还要求首位不能是数字。  
最重要的是，Java关键字不能当作Java标识符。

*  下面的标识符是合法的：  
    myName，My\_name，Points，$points,\_sys\_ta，OK，\_23b，*3*
 *  下面的标识符是非法的：  
    \#name，25name，class，&time，if
 *  驼峰规则，见名知意
 *  不能以数字开头

###### *命名规范：* ######

1.  类和接口名。每个字的首字母大写，含有大小写。  
    例如，MyClass，HelloWorld，Time等。
2.  方法名。首字符小写，其余的首字母大写，含大小写。尽量少用下划线。  
    例如，myName，setTime等。这种命名方法叫做驼峰式命名。
3.  常量名。基本数据类型的常量名使用全部大写字母，字与字之间用下划线分隔。对象常量可大小混写。  
    例如，SIZE\_NAME。
4.  变量名。可大小写混写，首字符小写，字间分隔符用字的首字母大写。不用下划线，少用美元符号。给变量命名是尽量做到见名知义。

#### 四、数据类型 ####

*  基本数据类型（8种）：int、byte、short、long、double、float、char、boolean
 *  引用数据类型：对象、数组

--------------------

##### （一）基本数据类型： #####

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

###### 1、整数型 ######

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>二进制位数</th> 
   <th>字节数</th> 
   <th>最小值</th> 
   <th>最大值</th> 
   <th>默认值</th> 
   <th>例子</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>8位</td> 
   <td>1</td> 
   <td>-128（-2^7）</td> 
   <td>127（2^7-1）</td> 
   <td>0</td> 
   <td>byte a = 100，byte b = -50</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>16位</td> 
   <td>2</td> 
   <td>-32768</td> 
   <td>32767</td> 
   <td>0</td> 
   <td>short s = 1000，short r = -20000</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>32位</td> 
   <td>4</td> 
   <td>-2147483648</td> 
   <td>2147483647</td> 
   <td>0</td> 
   <td>int a = 100000, int b = -200000</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>64位</td> 
   <td>8</td> 
   <td>-9223372036854775808</td> 
   <td>9223372036854775807</td> 
   <td>0L</td> 
   <td>long a = 100000L，Long b = -200000L</td> 
  </tr> 
 </tbody> 
</table>

###### 2、浮点型 ######

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>二进制位数</th> 
   <th>字节数</th> 
   <th>最小值</th> 
   <th>最大值</th> 
   <th>默认值</th> 
   <th>例子</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>float</td> 
   <td>单精度、32位</td> 
   <td>4</td> 
   <td>1.4E-45</td> 
   <td>3.4028235E38</td> 
   <td>0.0f</td> 
   <td>float f1 = 234.5f</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>双精度、64位</td> 
   <td>8</td> 
   <td>4.9E-324</td> 
   <td>1.7976931348623157E308</td> 
   <td>0.0d</td> 
   <td>double d1 = 123.4</td> 
  </tr> 
 </tbody> 
</table>

***数据来源代码演示：***

package cn.daniel.hello;
    
    public class Test1 { 
    	public static void main(String[] args) { 
    		// byte 
            System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);   
            System.out.println("最小值：" + Byte.MIN_VALUE);  
            System.out.println("最大值：" + Byte.MAX_VALUE);  
            System.out.println();  
      
            // short 
            System.out.println("基本类型：short 二进制位数：" + Short.SIZE); 
            System.out.println("最小值：" + Short.MIN_VALUE);  
            System.out.println("最大值：" + Short.MAX_VALUE);  
            System.out.println();  
      
            // int 
            System.out.println("基本类型：int 二进制位数：" + Integer.SIZE); 
            System.out.println("最小值：" + Integer.MIN_VALUE);  
            System.out.println("最大值：" + Integer.MAX_VALUE);  
            System.out.println();  
      
            // long 
            System.out.println("基本类型：long 二进制位数：" + Long.SIZE); 
            System.out.println("最小值：" + Long.MIN_VALUE);  
            System.out.println("最大值：" + Long.MAX_VALUE);  
            System.out.println();  
      
            // float 
            System.out.println("基本类型：float 二进制位数：" + Float.SIZE);
            System.out.println("最小值：" + Float.MIN_VALUE);  
            System.out.println("最大值：" + Float.MAX_VALUE);  
            System.out.println();  
      
            // double 
            System.out.println("基本类型：double 二进制位数：" + Double.SIZE);
            System.out.println("最小值：" + Double.MIN_VALUE);  
            System.out.println("最大值：" + Double.MAX_VALUE);  
            System.out.println();  
    
    		// char 
            System.out.println("基本类型：char 二进制位数：" + Character.SIZE);  
            // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台 
            System.out.println("最小值："  
                    + (int) Character.MIN_VALUE);  
            // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台 
            System.out.println("最大值："  
                    + (int) Character.MAX_VALUE);  
    	}
    }

***console控制台显示结果：***

基本类型：byte 二进制位数：8
    最小值：-128
    最大值：127
    
    基本类型：short 二进制位数：16
    最小值：-32768
    最大值：32767
    
    基本类型：int 二进制位数：32
    最小值：-2147483648
    最大值：2147483647
    
    基本类型：long 二进制位数：64
    最小值：-9223372036854775808
    最大值：9223372036854775807
    
    基本类型：float 二进制位数：32
    最小值：1.4E-45
    最大值：3.4028235E38
    
    基本类型：double 二进制位数：64
    最小值：4.9E-324
    最大值：1.7976931348623157E308
    
    基本类型：char 二进制位数：16
    最小值：0
    最大值：65535

> Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的"E+数字"表示E之前的数字要乘以10的多少次方。比如3.14E3就是3.14  
> × 103 =3140，3.14E-3 就是 3.14 x 10-3 =0.00314。

###### 3、布尔型：boolean ######

*  boolean数据类型表示一位的信息；
 *  1字节
 *  只有两个取值：true 和 false；
 *  这种类型只作为一种标志来记录 true/false 情况；
 *  默认值是 false；
 *  例子：boolean one = true。

###### 4、字符型：char ######

*  char类型是一个单一的 16 位 Unicode 字符；
 *  1~3字节
 *  最小值是 \\u0000（即为0），也是默认值；
 *  最大值是 \\uffff（即为65,535）；
 *  char 数据类型可以储存任何字符；
 *  例子：char letter = ‘A’;。

***问题：整数有4个类型，一个不就够了吗？为什么要4个呢？***

*  内存是一个有限稀缺资源，设计程序时，尽量减少内存占用。  
    例如：存放数字1，使用尽量小的单位，byte它可以表示1，只占用8个字节；如果int要占用32个字节，太浪费空间。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center]

***ASCII码表的作用：***

*  把人类字母翻译成计算机0或1  
    ![数据来源：ASCII搜狗百科][ASCII]

##### （二）引用数据类型 #####

*  在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
 *  对象、数组都是引用数据类型。
 *  所有引用类型的默认值都是null。
 *  一个引用变量可以用来引用任何与之兼容的类型。
 *  例子：Site site = new Site(“Daniel”)。

#### 五、基本类型与包装类型（简单了解） ####

java为了支持传统开发方式，非面向对象方式，同时，为了计算速度快。有基本类型，基本类型不属于面向对象。java是一个面向对象开发语言。针对每个基本类型对应一个包装类型，包装类型面向对象结构。

<table> 
 <thead> 
  <tr> 
   <th>基本类型</th> 
   <th>包装类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>Byte</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>Integer</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>Double</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>Character</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>Boolean</td> 
  </tr> 
 </tbody> 
</table>

*  本质差异：

1.  基本类型占用内存空间小，包装类型占用内存空间大
2.  基本类型只有数据，包装类型还有其他的方法
3.  例如：int（32b），Integer除了存放数据，它还有很多的内容

package cn.daniel.hello;
    
    public class TestArea { 
    	public static void main(String[] args) { 
    		int i = 100;
    		Integer j = 100;
    		System.out.println(i);
    		System.out.println(j);
    		//数据上没有差异
    		System.out.println(j.toBinaryString(i));
    	}
    }

> 包装类型额外有很多的方法。  
> 例如：转换二进制方法，j.toBinaryString() java自身带给它的，包装类创建时自己就已经有了很多方法

##### 装箱与拆箱 #####

类型之间的转换------用int和Integer举例

*  把int转换Integer，把基本类型int转换包装类型Integer
 *  把Integer转换int，把包装类型Integer转换基本类型int

package cn.daniel.hello;
    
    public class TestArea { 
    	public static void main(String[] args) { 
    		//1）把int转换Integer，把基本类型int转换包装类型Integer
    		int a1 = 100;			
    		Integer b1 = a1;		
    		System.out.println(a1);
    		System.out.println(b1);
    		//数据上面没有变化
    		//a1是基本类型，b1是包装类型，这是两个东西，怎么能赋值？
    		//上面过程，java底层做了很多事情？
    		//编译后真正的语句：Integer b1 = new Integer(100); ,java中对象都必须new出来，创建对象
    		Integer c1 = new Integer(100);
    		System.out.println(c1);
    		//把上面java自动把基本类型转换成包装类型过程：称为装箱（转换）
    		
    		
    		//2）把Integer转换int，把包装类型Integer转换基本类型int
    		Integer s1 = new Integer(200);		//声明包装类型
    		int s2 = s1;
    		System.out.println(s1);
    		System.out.println(s2);
    		
    		//真正代码：
    		int s3 = s1.intValue();	//intValue这个方法获取s1对象的值，拿到200，把200赋值给s3
    		//把上面java自动把包装类型转换基本类型过程：称为拆箱（转换）
    	}
    }

> 装箱：基本类型转换成包装类型的过程（小转大）  
> 拆箱：包装类型转换成基本类型的过程（大转小）

***代码演示案例***

package cn.daniel.hello;
    
    public class TestArea2 { 
    	public static void main(String[] args) { 
    		
    		//装箱：把基本类型装入包装类型，小转大
    		long x1 = 9;
    		Long x2 = x1;		//小转大，自动装箱 Long x2 = new Long(9);
    		System.out.println("装箱：把x1装入x2："+x2);
    		
    		//拆箱：把包装类型装入基本类型，大转小
    		Long y1 = new Long(900);
    		long y2 = y1;		//大转小，自动拆箱 long y2 = y1.longValue();
    		
    		System.out.println("拆箱：把y1拆出值y2："+y2);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70]

#### 六、三值交换案例 ####

package cn.daniel.hello;
    //交换
    public class Swap { 
    	public static void main(String[] args) { 
    		int a = 100;
    		int b = 200;
    		System.out.println("交换前：a="+a+"b="+b);
    		//需要中间变量，用来临时存储数据，否则就被覆盖
    		int t = a;
    		a = b;
    		b = t;
    		System.out.println("交换后：a="+a+"b="+b);
    	}
    }

**运行结果：**

交换前：a=100，b=200
    交换后：a=200，b=100

#### 七、强制转换 ####

*  java中数据类型的强制转换是通过强制转换语句完成的。
 *  强制转换语句的格式为“目标数据类型 变量 = (目标数据类型) 数据；”

***案例***

package cn.daniel.hello;
    
    import org.junit.Test;
    
    public class Cover { 
    	@Test	//小转大
    	public void smallToBig() { 
    		//字节类型转成整数类型
    		byte b = 100;
    		int i = b;		//等号右边b，当前值100，把100赋值给i，b字节，i整数，两个类型不同
    		System.out.println("小转大（自动转换）："+i);
    	}
    	
    	@Test	//大转小
    	public void bigToSmall() { 
    		int i = 100;
    		byte b = (byte)i;		//因为有风险，我们写的代码，我知道能存放这个值，强制换行
    		//把i强制转换成byte字节类型
    		System.out.println("大转小（强制转换）："+b);
    	}
    }

**基本类型转换原则：**  
类型转换主要在在**赋值、方法调用、算术运算**三种情况下发生。

1.  赋值和方法调用转换规则：  
    从低位类型到高位类型自动转换；从高位类型到低位类型需要强制类型转换：  
    （1）布尔型和其它基本数据类型之间不能相互转换；  
    （2）byte型可以转换为short、int、、long、float和double；  
    （3）short可转换为int、long、float和double；  
    （4）char可转换为int、long、float和double；  
    （5）int可转换为long、float和double；  
    （6）long可转换为float和double；  
    （7）float可转换为double；
2.  算术运算 中的类型转换：  
    基本就是先转换为高位数据类型，再参加运算，结果也是最高位的数据类型；  
    （1）byte short char运算会转换为Int；  
    （2）如操作数之一为double，则另一个操作数先被转化为double，再参与算术运算。  
    （3）如两操作数均不为double，当操作数之一为float，则另一操作数先被转换为float，再参与运算。  
    （4）如两操作数均不为double或float，当操作数之一为long，、则另一操作数先被转换为long，再参与算术运算。  
    （5）如两操作数均不为double、float或long，则两操作数先被转换为int，再参与运算。

***特殊：***

*  如采用+=、\*=等缩略形式的运算符，系统会自动强制将运算结果转换为目标变量的类型。
 *  当运算符为自动递增运算符（++）或自动递减运算符（–）时，如果操作数为byte，short或char类型不发生改变；  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 1]

[-]: /images/20230528/80cd8c82c87143c49caf1112d98eff94.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20230528/30aca6ac736d474f9553e7aaf29ae730.png
[ASCII]: /images/20230528/cc0f7f383e784dfe8891d09ebf35ee28.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70]: /images/20230528/f53bad3245c54bbaa007ba3cf4fdd53c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20230528/839e4135e2144494b68b4604d8036fee.png