java基础语法学习day03---初学者必看详解

素颜马尾好姑娘i 2023-01-20 09:34 45阅读 0赞

### java基础语法学习day03---初学者必看详解 ###

*   *  一、数据类型
     *  1、基本数据类型
     *  2、数据类型转化
     *   *  2.1、基本数据类型的注意事项
         *  2.2、 数据类型的转换
     *  二、运算符
     *   *  1、算术运算符
         *  2、赋值运算符
         *  3、关系运算符
         *  4、连接运算符
         *  5、逻辑运算符
         *  6、三元/目运算符

## 一、数据类型 ##

## 1、基本数据类型 ##

java分基本数据类型和引用数据类型
      基本数据类型只有8种
      4个整数2个小数2个非数
    1)byte (字节) 1字节  -128~127
      不常用(IO学习时使用)
    
    2)short(短整型) 2字节 -32768~32767
      不常用(和其他语言兼容使用)
    
    3)int  (整型)   4字节  -21亿~21亿
      最常用的类型
    
    4)long (长整型) 8字节  很大
      较常用(int类型不够用时使用)
      当赋值的数值大于int的取值范围时
      需要在这个值的后面加l或L
    
    5)float (单精度) 4字节
      不常用,精度不足
      正常赋值时,
      如果赋小数值,需要在小数值
      后加f或F
    
    6)double(双精度) 8字节
      常用
      精度较高
    
    7)char (字符) 2字节  0~65535
      保存一位字符
      而且有且只有一位
      'a'  --  97
      'A'  --  65
      '0'  --  48
      
      特殊字符:转义符:\
      '    --  \'
      \    --  \\
    
    8)boolean (布尔)  1字节
      取值只有true或false

## 2、数据类型转化 ##

byte------short-----int——long-----float———double

char——

*  自动类型转化（隐式类型的转化）
    
    从小类型到大类型是可以自动完成。
 *  强制类型转化（显式类型的转化）
    
    从大类型转小类型，需要进行强制转化符
    
    (需要转化成的类型)变量
    
    但是这样的话，可能会造成数据精度丢失或者溢出。

### 2.1、基本数据类型的注意事项 ###

**1)java中的数据直接量**  
在java代码中直接写出的数值  
整数直接量是int类型  
小数直接量是double类型  
**2)数据的溢出**  
当一个数据类型的变量接收了  
大于自己范围的数据  
就会产生溢出,这个现象不是  
我们想看到的,所以了解即可,  
不用研究  
**3)时间偏移量**  
1970-1-1 00:00  
开始到程序运行时经过的毫秒数  
long time=System.currentTimeMillis();  
**4)舍入误差**  
浮点型的计算可能会发生  
计算结果不精确的情况  
需要使用今后学习的引用类型解决  
现阶段只需要了解这个现象就可以了

**案例：**

package cn.tedu.day06;
    
    public class DataTypeChange {
        
    	
    	public static void main(String[] args) {
        
    		
    		int x = 5;
    		
    		//int---byte
    		byte b = 56;
    		System.out.println(b);
    		//（要强转的类型）变量
    		byte b1 = (byte)128;
    		System.out.println(b1);
    		
    		//1、自动类型的转化
    		int x1 = 5;
    		int y1 = 6;
    		long z = x1 + y1;
    		System.out.println(z);//long
    		
    		long l1 = 1024l;
    		//2、强转的时候，如果数据在转化范围内，就不会发生数据溢出
    		int i = (int) l1;//强制转化
    		
    		long l2 = 1024l * 1024 * 1024 * 4;
    		int i2 = (int)l2;//会发生溢出
    		System.out.println(i2);//0  
    		
    		double pi = 3.1415926578976588;
    		float f = (float) pi;//会造成精度的损失
    		System.out.println(f);//3.1415927
    		
    		//3、数据类型运算的时候，自动类型的转化
    		long hm = 365 * 24 * 60 * 60 * 1000;
    		
    		double d = 800 - 600.5;
    		System.out.println(d);//199.5
    		
    		double d2 = 80 / 100;
    		System.out.println(80 / 100);//0
    		System.out.println(d2);//0.0
    		
    		double d3 = 80.0 / 100;
    		System.out.println(d3);//0.8
    		//多种基本数据类型参与运算的时候，结果会发生自动类型的转化。
    		
    	}
    }

*  Byte/char/short——>int
    
     *  int直接量可以直接赋值给byte、char和short，只要不超过表示的范围。
    
        char c = 65;
        byte b = 45;
        short s = 23;
    
     *  byte、char、short三种类型参与运算的时候，先进行转化为int类型，再参与运算。

### 2.2、 数据类型的转换 ###

**1)java中运行计算的原则**  
java中只允许相同数据类型的数据  
发生计算,计算结果还是这个类型

**2)自动类型转换(隐式类型转换)**  
当不同数据类型的数据发生计算时  
java系统会自动将较小的数据类型  
转换成较大的数据类型  
,计算结果是较大的数据类型

小 大  
byte short int long float double  
char  
1.float类型比long类型大  
2.byte\\short\\char计算结果都是int  
**3)强制类型转换(显式类型转换)**  
由程序员编写代码  
将一个数据转成指定的类型  
(<类型>)<变量\\数值>  
double d=12.5;  
int i=(int)d;//12.5–>12  
强制类型转换可能造成精度丢失  
当两个不同数据类型的数据计算时  
想要较小的数据类型的结果

## 二、运算符 ##

### 1、算术运算符 ###

+ - *  /
        
    %
    ++ -- 
    
        package cn.tedu.day06;
    /**
     * 运算符
     * @author zhangjian
     *
     */
    public class OperatorDemo {
        
    	
    	public static void main(String[] args) {
        
    		//1.算术运算符
    		System.out.println(3 + 2);//5
    		System.out.println(3 - 2);//1
    		System.out.println(3 * 2);//6
    		System.out.println(3 / 2);//1
    		//发生异常-java.lang.ArithmeticException 算术异常
    		//System.out.println(3 / 0);
    		
    		//% 参与运算的时候，结果的正负与%符号左边的正负有关系。
    		System.out.println(5 % 3);//2
    		System.out.println(-5 % 3);//-2
    		System.out.println(-5 % -3);//-2
    		System.out.println(5 % -3);//2
    		
    		//++ --
    		int x = 5;
    		x++;//x = x + 1;
    		System.out.println(x);//6
    		++x;//x = x + 1;
    		System.out.println(x);//7
    		
    		x--;
    		System.out.println(x);//6
    		--x;//x = x - 1;
    		System.out.println(x);//5
    		
    		//a++  后增
    		/*
    		 * 当a++后增,参与运算的时候，先进行参与运算，后进行自增。
    		 */
    		int a = 6;
    		int b = a++;
    		System.out.println("a = " + a + ",b = " + b);//a = 7,b = 6
    		/*
    		 * ++m 前增
    		 * 当++前增，参与运算的时候，先进行自增，再参与运算。
    		 */
    		int m = 6;
    		int n = ++m;//先进行++m，得到m=7，后将m=7赋值给n,得到n=7
    		System.out.println("m = " + m + ",n = " + n);//7 7
    		
    		int p = 6;
    		int q = p--;
    		System.out.println("p = " + p + ",q = " + q);//5 6
    		
    		int i = 8;
    		int j = 7;
    		i = --j;//i = 6; j = 6
    		System.out.println("i = " + i + ",j = " + j);
    		j = ++i;//i = 7;j = 7;
    		System.out.println("i = " + i + ",j = " + j);
    	}
    }

### 2、赋值运算符 ###

= 赋值运算符，用于对变量进行赋值。把=右边的值赋值给左边的变量。

OperatorDemo01

复合的赋值运算符

\+=

-=
    
    *=

package cn.tedu.day07;
    /**
     * 赋值运算符：=
     * @author zhangjian
     */
    public class OperatorDemo01 {
        
    	
    	public static void main(String[] args) {
        
    		//
    		int num = 19, index;
    		System.out.println(num);
    		System.out.println(index = num % 3);//1
    		System.out.println(index);//1
    		
    		int x, y, z;
    		x = y = z = 66;
    		System.out.println(z);//66
    		
    		//复合赋值运算
    		x += 5;//计算的时候：x = x + 5;
    		System.out.println(x);//x=71
    		
    		x -= 5;//x = x - 5;
    		System.out.println(x);//x = 66
    		
    	}
    	
    }

### 3、关系运算符 ###

用来判断数据之间的大小关系。

**包括：大于、小于、等于(==)、大于等于(>=)、小于等于、不等于(!=)六种运算符。**

关系运算符的判断结果为：boolean类型的。关系成立结果为true，关系不成立结果为false。

OperatorDemo02

package cn.tedu.day07;
    /**
     * 关系运算符：
     * @author zhangjian
     *
     */
    public class OperatorDemo02 {
        
    	public static void main(String[] args) {
        
    		int max = 30;
    		int num1 = 6;
    		boolean b1 = max > 35;//false
    		boolean b2 = num1 % 2 == 0;//true
    		boolean b3 = num1 % 2 != 0;//false
    		System.out.println(b1);
    		System.out.println(b2);
    		System.out.println(b3);
    	}
    }

### 4、连接运算符 ###

使用 **+** 进行字符串的连接。

字符串： 双引号引起来的 “ ”

OperatorDemo03

package cn.tedu.day07;
    /**
     * 连接运算符：+
     * @author zhangjian
     *
     */
    public class OperatorDemo03 {
        
    	
    	public static void main(String[] args) {
        
    		
    		//love520
    		System.out.println("love520");
    		int num = 1314;
    		//love1314
    		System.out.println("love" + num);//love1314
    		//love1314520  ---- love1314 + 520 ---love1314520
    		System.out.println("love" + num + 520);
    		//love1834  ()优先级  优先计算括号里面的
    		System.out.println("love" + (num + 520));
    		
    		System.out.println(520 + "love");//520love
    		System.out.println(520 + 1314 + "love");//1834love
    		System.out.println(520 + (1314 + "love"));//5201314love
    		
    		String msg = "love";
    		msg = 520 + 1314 + msg + 521 + 1314;
    		System.out.println(msg);//1834love5201314
    		
    		msg = "love";
    		msg = 520 + (1314 + msg + 521) + 1314;
    		System.out.println(msg);//5201314love5211314
    		
    	}
    
    }

### 5、逻辑运算符 ###

建立在关系运算之上的，包括：与&& 或 || 非 |

运算结果为：boolean类型的。

<table> 
 <thead> 
  <tr> 
   <th>变量b1</th> 
   <th>变量b2</th> 
   <th>b1&amp;&amp;b2</th> 
   <th>b1||b2</th> 
   <th>!b1</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>true</td> 
   <td>True</td> 
   <td>True</td> 
   <td>True</td> 
   <td>False</td> 
  </tr> 
  <tr> 
   <td>True</td> 
   <td>False</td> 
   <td>False</td> 
   <td>True</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td>False</td> 
   <td>True</td> 
   <td>False</td> 
   <td>True</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <td>False</td> 
   <td>false</td> 
   <td>False</td> 
   <td>False</td> 
   <td>true</td> 
  </tr> 
 </tbody> 
</table>

**使用&&运算符：**

两个boolean类型的值，参与&&运算的时候，只有两边都为true的时候，结果才为true；

**真真为真。**

OperatorDemo04

package cn.tedu.day07;
    /**
     * && || ！
     * 逻辑运算符：
     * @author zhangjian
     *
     */
    public class OperatorDemo04 {
        
    	
    	public static void main(String[] args) {
        
    		int score = 58;
    		//小明参加考试，如果考试成绩在80到100之间，奖励个四大名著一部。
    		//  80 <= score <= 100
    		boolean b = score >= 80 && score <= 100;
    		//score >= 80  score <= 100 关系运算  boolean  
    		System.out.println(b);//false
    		
    		//会唱歌或者会跳舞
    		boolean sing = true;
    		boolean dance = false;
    		boolean b2 = sing || dance;
    		System.out.println(b2);
    		
    		int x = 5;
    		boolean b4 = sing || x++ > 3;
    		System.out.println(b4);
    		System.out.println(x);
    		
    		/*int m = 100;
    		int n = 200;
    		boolean b5 = (m > n) || (m++ > 200);
    		System.out.println(b5);//false
    		System.out.println(m);*/
    		
    		//短路逻辑
    		int m = 100;
    		int n = 200;
    		boolean b5 = (m > n) && (m++ > 200);
    		System.out.println(b5);//false
    		System.out.println(m);//m = 100,不执行
    		
    		//! 非
    		boolean isRain = true;
    		boolean b7 = !isRain;
    		System.out.println(b7);
    	}
    }

### 6、三元/目运算符 ###

回顾：

1、JDK/JRE/JVM

2、跨平台

3、java环境变量的配置

4、Eclipse的使用

5、关键字

6、标识符

7、驼峰命名法

包、变量、方法、常量等

8、变量

9、常量