Java学习（数据类型转换、ASCII码、运算符、方法入门、流程（顺序、判断、选择、循环））

2021/12/26 Java学习

一、数据类型转换

1.自动类型转换

/* 
当时据类型不一样时，将会发生数据类型转换
​
自动类型转换（隐式）
    1.特点：代码不需要进行特殊处理，自动完成。
    2.规则：数据范围从小到大。
*/
public class Demo01DataType{
    public static void main(String[] args){
        System.out.println(1024); //这就是一个整数，默认就是int
        System.out.println(3.14); //这就是一个浮点数，默认就是double
        
        //左边是long类型，右边是默认的int类型
        //一个等号代表复制，将右侧的int常量，交给左侧long变量进行存储
        //int --> long,符合了数据范围从小到大的要求
        //这一行代码发生了自动类型转换（数据后没加L）
        long num1 = 100;
        System.out.println(num1);//100
        
        //左边时double类型，左边是float类型，左右不一样
        //float--> double ,符合了数据范围从小到大的要求
        //这一行代码也发生了自动类型转换
        double num2 = 2.5F;
        System.out.println(num2);  //2.5
        
        //左边时float类型，左边是long类型，左右不一样
        //long--> float ,范围float更大，符合了数据范围从小到大的要求
        //这一行代码也发生了自动类型转换
        double num3 = 30L;
        System.out.println(num3);  //30.0
        
        
    }
}

2.强制类型转换以及注意事项
 

/*
强制类型转换：
    1.特点：代码需要进行特殊的格式处理，不能自动完成；
    2.格式：范围小的类型 范围小的变量 = （范围小的类型） 原本范围大的数据
    
注意事项：
    1.强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。
    2.byte/short/char这三种类型都可以发生数学运算。例如"+"
    3.byte/short/char这三种类型在运算的时候，都会被首先提升为int类型，然后再计算
    4.boolean类型不能发生数据类型转换
*/
public class Demo02DataType{
    public static void main(String[] args){
        //左边是int类型，右边是long类型，不一样
        //long--> int，不是从小到大
        //不能发生自动类型转换
        //格式：范围小的类型 范围小的变量 = （范围小的类型） 原本范围大的数据
        int num = (int) 100L;
        System.out.println(num);  //100
        
         // 无法编译成功 错误的类型,数据会有损失（数据溢出）
         //int num2 = 6000000000L;  
​
        //代码编译成功，得出结果为：1705032704
        //和预期结果不一样出现了数据溢出
        int num2 = (int)6000000000L;   
        System.out.println(num2);   //1705032704
        
        //double--> int,强制类型转换
        int num3 = (int) 3.5;
        System.out.println(num3);  //3  这不是四舍五入，所有的小数位都会被舍弃掉
        
        //char类型+运算
        char zifu1 = 'A';   //这是一个字符变量，里面是大写字母A
        System.out.println(zifu1+1);  //66,也就是大写字母A被当作65进行处理
        //计算机的底层就用一个数字（二进制）来代表字符A，就是65
        //一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译成为一个数字
        
        byte num4 = 40; //注意：右侧的数值大小不能超过左侧的范围类型
        byte num5 = 50;
        //byte + byte--> int + int --> int
        int result1 = num4 + num5;
        System.out.println(result1);   //90
        
        short num6 = 60;
        //byte + short--> int + int --> int
        //int 强制转换为short，注意必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出
        short result2 = (short)(num4 + num6);
        System.out.println(result2);   //100
         
    }
}

/*
强制类型转换：
    1.特点：代码需要进行特殊的格式处理，不能自动完成；
    2.格式：范围小的类型 范围小的变量 = （范围小的类型） 原本范围大的数据
*/
public class Demo02DataType{
    public static void main(String[] args){
        //左边是int类型，右边是long类型，不一样
        //long--> int，不是从小到大
        //不能发生自动类型转换
        //格式：范围小的类型 范围小的变量 = （范围小的类型） 原本范围大的数据
        int num = (int) 100L;
        System.out.println(num);  //100
    }
}

ASCII码： 0：48 A: 65 a: 97

/*
数字和字符的对照关系表（编码表）：
ASCII：美国信息交换标准代码。
Unicode码表：万国码，也是数字和符号的对照关系，开头0-127部分和ASCII码完全一样，但是从128开头都是不同的。例如“中”ASSCII码中没有，再Unicode码表中对应的是20013.
*/
public  class Demo03DataTypeChar{
    public static  void main(String[] args){
        char zifu1 = '1';  //其实底层保存的是49
        System.out.println(zifu1 + 0); //49
        char zifu2 = 'A'; //其实底层保存的是65
        
        char zifu3 = 'c'; //其实底=底层保存的是99
        //左侧是int类型，右边是char类习惯
        //char-->int ，确实是从小到大
        //可以发生自动类型转换
        int num = zifu3;  
        System.out.println(num); //99
        
        char zifu4 = '中';
        System.out.println(zifu4 + 0); //20013
    }
}

二、运算符

/*
运算符：进行特定操作的符号。例如：+
表达式：用运算符连起来的式子叫做表达式。
​
四则运算 + 1：
加：+
减：-
乘：*
除：/
+
取模：%
​
//首先计算得到表达式的结果，然后再打印输出这个结果
一个公式：被除数 / 除数 = 商······余数
​
对于一个整数的表达式来说，除法用的是整除，整数除以整数，结果仍然是整数，只看商，不看余数。
只有对于整数的除法来说，取模运算符才有余数的意义。
​
注意事项：
    1.一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种。
*/
public class Demo04Operator{
    public static void main(String[] args){
        //两个常量之间可以进行数学运算
        System.out.println(20 + 30); //50
        
        //两个变量之间也可以进行数学运算
        int a = 20;
        int b = 30;
        System.out.println(a - b);  //-10
        
        //变量和常量之间可以混合使用
        System.out.println(a *10);   //200
        
        int x = 10;
        int y = 3;
        
        int result1 = x / y;
        System.out.println(result1);   //3
        
        int result2 = x % y;
        System.out.println(result2);   //1
        
        //int + double --> double + double -->double(doube范围比int大)
        double result3 = x + 2.5;
        System.out.println(result3);  //12.5
        
    }
}

1)加号的多种用法

/*
四则运算当中的加号"+"有常用的三种用法：
1.对于数值来说，那就是加法
2.杜宇字符char类型来说，在计算之前，char会被提升为int，再计算。
char类型字符，和int类型数字，之间的对照关系表：ASCII、Unicode。
3.对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作
任何数据类型和字符串进行连接的时候，结果都会变成字符串
*/
public class Demo05Plus{
    public static void main(String[] args){
    //字符串类型的变量基本使用
    //数据类型 变量名称 = 数据值
    String str1 = "hello";
    System.out.println(str1);   //hello
    System.out.println("Hello"+"World");   //  HelloWorld
    
    String str2 = "Java";
    //String + int --> String
    System.out.println(str2+20);  //Java20
    
    //优先级问题
    //String + int + int
    //String       + int
    //String 
    System.out.println(str2 + 20 + 30);   //Java2030
    System.out.println(str2 + (20 + 30));   //Java50
    
}
}

2)自增自减运算符

/*
自增运算符：++
自减运算符：--
​
基本含义：让一个变量涨一个数字1，或者让一个变量降一个数字1
使用格式：写在变量名称之前，或者卸载变量名称之后，例如：++num,也可以num++
使用方式：
    1.单独使用：不和其他任何操作混合，自己独立成为一个步骤
    2.混合使用：和其他操作混合，例如和赋值混合，或者与打印操作混合，等...
使用区别:
    1.在单独使用的时候，前++和后++没有任何区别，也就是++num；和num++；是完全一样的。
    2.在混合的时候，有【重大区别】
        a.如果是【前++】，那么变量【立刻马上+1】，然后拿着结果进行使用。【先加后用】
        b.如果是【后++】，那么首先使用变量本来的数值，【然后再让变量+1】。【先用后加】
        
注意事项：
    只有变量才能使用自增、自减运算符。常量不可发生改变，所以不能用
*/
public class Demo06Operator{
    public static void main(String[] args){
        int num1 = 10;
        System.out.println(num1); //10
        ++num1;  //单独使用，前++
        System.out.println(num1);  //11
        num1++;   //单独使用，后++
        System.out.println(num1); //12
        
        //与打印操作混合的时候
        int num2 = 20;
        //混合使用，先++，变量立刻马上变成21，然后打印结果21
        System.out.println(++num2);  //21
        System.out.println(num2);  //21
        
        int num3 = 30;
        //混合使用，后++，首先使用变量本来的30，然后再让变量+1得到31
        System.out.println(num3++);  //30
        System.out.println(num3);  //31
        
        int num4 = 40;
        //和赋值操作混合
        //混合使用，先--，变量立刻马上变成39，然后打印结果39
        int result1 = --num4;
        System.out.println(result1);  //39
        System.out.println(num4);  //39
        
        int num5 = 50;
        //混合使用，后--，首先使用变量本来的50，然后再让变量-1得到49
        int result2 = num5--;
        System.out.println(result2);  //50
        System.out.println(num5);  //49
        
        int x = 10;
        int y= 20;
        //result3 = 11 + 20;  x = 11 ;   y = 19
        int result3 = ++x + y--;
        System.out.println(result3);  //31
        System.out.println(x);  //11
        System.out.println(y);  //19
        
        //30++;  （错误写法，常量不可这样）
    }
    
}

3）赋值运算符

/*
赋值运算符分为：
基本赋值运算符：就是一个等号”=“,代表将右侧的数据交给左侧的变量。
    int a = 30;
​
复合赋值运算符：
    +=      a += 3      a = a + 3
    -=      a -= 3      a = a - 3
    *=      a *= 3      a = a * 3
    /=      a /= 3      a = a / 3
    %=      a %= 3      a = a % 3
    
注意事项：
    1.只有变量才能使用赋值运算符，常量不能进行赋值；
    2.复合赋值运算符其中隐含了一个强制类型转换
*/
public class Demo07Operator{
    public static void main(String[] args){
        int a = 10;
        // a = a + 5 = 10 + 5
        a += 5; //15
        System.out.println(a);  //15
        
        int x=10;
        //x = x % 3 = 10 % 3
        x %= 3;
        System.out.println(x);  //1
        
        //50 = 30 错误写法
        
        byte num = 30;
        //num = num + 5;7
        //num = byte +int;
        //num = int + int;
        //num = int
        //num = (byte) int  //复合赋值运算符隐含的强制类型转化
        num += 5;
        System.out.println(num);  //35
    }
}

4）比较运算符

/*
比较运算符：
大于      >
小于      <
大于等于    >=
小于等于    <
相等      ==
不相等     !=
​
注意事项：
1.比较运算符的结果一定是一个布尔值，成立true，不成立false
2.如果进行多次判断，不能连着写。
数学当中的写法，例如：1 < x < 3(程序当中【不允许】这种写法)
*/
public class Demo08Operator{
    public static void main(String[] args){
        System.out.println(10>5);  //true
        int num1 = 10;
        int num2 = 12;
        System.out.println(num1 < num2);   //true
        System.out.println(num2 >= 100);  //false
        System.out.println(num2 <= 100); //true
        System.out.println(num2 <= 12); //true
        
        System.out.println(100 == 100);  //true
        System.out.println(20 !=25);    //true
        System.out.println(20 != 20);  //false
        
        int x = 2;
        //错误写法 编译报错 System.out.println(1 < x < 3);
    }
}

5）逻辑运算符

/*
逻辑运算符：
与（并且） &&  全都是ture，才是ture,否则就是false
或（或者） ||  至少一个是true，就是true，全都是false，才是false
非（取反） ！  本来是true,变成false；本来是false，变成true
​
与”&&“，或”||“，具有短路效果，如果根据左边已经可以判断得到的最终结果，那么右边的代码将不再执行，从而节省一定的性能。
​
注意事项：
1.逻辑运算符只能用于boolean值
2.与，或需要左右各自有一个boolean，但是取反只要有唯一的一个boolean值即可
3.与、或两种运算符，如果有多个文件，可以连续写
两个条件：条件A && 条件B
三个条件： 条件A && 条件B && 条件C
​
*/
public class Demo09Operator{
    public static void main(String[] args){
        //与
        System.out.println(true && false); //false
        System.out.println(3 < 4 && 10 > 5); //true && true -->true
        //或
        System.out.println(true || true ); //true
        System.out.println(true || false); //true
        System.out.println(false || false); //false
        //非
        System.out.println(!true ); //false
        System.out.println(!false); //true
        
        int a = 10;
        System.out.println(3 > 4 && ++a < 100); //false
        System.out.println(a); //10(因为3>4不成立，++a不做运算）
        
    }
}

6)三元运算符

/*
一元运算符：只需要一个数据就可以操作的运算符。例如：++、--、！
二元运算符：需要两个数据才可以操作的运算符。例如：+、=
三元运算符：需要三个数据才可以操作的运算符。

格式：
数据类型 变量名称 = 条件判断 ？ 表达式A ： 表达式B；

流程：
首先判断条件是否成立：
	如果成立为true,那么将表达式A的值赋值为左侧的变量；
	如果成立为false,那么将表达式B的值赋值为左侧的变量；
	
注意事项：
1.必须同时保证表达式A和表达式B都符合左侧数据类型的要求
2.三元运算符的毕节必须被使用
*/
public class Demo10Operator{
	public static void main(String[] args){
		int a = 10;
		int b =20;
		//数据类型 变量名称 = 条件判断 ？ 表达式A ： 表达式B；
		int max = a > b? a : b;
		System.out.println(max);  //20
		
		//必须同时保证表达式A和表达式B都符合左侧数据类型的要求
		//2.5不是int类型
		//错误  int result = 3 > 4? 2.5 : 10;
		//三元运算符的毕节必须被使用,错误用法 a > b? a : b;
		//正确用法
		System.out.println(a > b? a : b);  //20
	}
}

三、方法入门 方法就是将一个功能抽取出来，进行分析分类。 1）定义方法

/*
定义一个方法的格式：
public static void 方法名称(){
	方法体
}
方法名称的命名规则和变量一样，使用小驼峰。
方法体：也就是大括号当中可以包含任意条语句

注意事项：
1.方法定义的先后顺序无所谓。
2.方法的定义不能产生嵌套包含关系。
3.方法定义好了之后，不会执行，如果想要执行，一定要进行方法的【调用】。

如何调用方法：
方法名称（）；
*/
public class Demo11Method{
	public static void main(String[] args){
		//调用方法
		farmer();	//种菜
		seller();	//收菜
		cook();		//做菜
		me();		//吃
	}
	//农民
	public static void farmer(){
		System.out.println("种菜");
	}
	//小商贩
	public static void seller(){
		System.out.println("收菜");
	}
	//厨子
	public static void cook(){
		System.out.println("做菜");
	}
	//我
	public static void me(){
		System.out.println("吃");
	}
}

四、编译器的两点优化。
1.对于byte/short/char三种类型来说，如果右侧赋值的数值没有超出范围，那么javac编译器将会自动隐含的为我们补偿一个(byte)(short)(char)
1）如果没有超过左侧的范围，编译器不上强制。
2）如果右侧超过了左侧范围，那么直接编译器报错。 eg.byte num1 = 30;(可以直接运行得到num1为30)
2.再给变量进行赋值的时候，如果右侧的表达式当中全是常量，没有任何变量，那么编译器javac将会直接将若干个常量表达式计算得到结果。若右侧的常量结果数值，没有超过左侧范围，那么不报错可正常除结果。 （这被称为:"编译器的常量优化"）
注意：一旦表达式当中有变量参与，那么就不能进行这种优化了。（因为变量可能会发生改变） eg.byte num1 = 3 + 2;(可得到num1等于5)
eg.byte num1 = 3 + a + 2；（变量a是可变的，则不行）

五、流程
1）顺序：从前到后顺序执行程序。
2）判断：

1、单if语句

public class Demo02If {
	public static void main(String[] args){
		System.out.println("去网吧！")；
		int age = 16;
		if(age >= 18){
			System.out.println(上网！);
		}
		System.out.println("回家吃饭");		
	}
}

1.标准的if--else语句

public class Demo03IfElse{
	public static void main(String[] args){
		int num = 13;
		if(num % 2 == 0){
			System.out.println("偶数");
		} else{
			System.out.println("奇数");
		}
	}
}

3.if--else if--else

//x和y的关系满足如下：
//如果x >= 3,那么y = 2x + 1;
//如果-1 < x < 3,那么y = 2x ;
//如果x <=-1,那么y = 2x - 1;
public class Demo04IfElseExt{
	public static void main(String[] args){
		int x = 10;
		int y;
		if(x >= 3){
			y = 2 * x + 1;
		} else if(-1 < x && x < 3){
			y = 2 * x ;
		} else{
			y = 2 * x - 1;
		}
		System.out.println("结果是："+y);   //结果是：21
	}
}

题目错误添加笔记：
1）每个Unicode码占两个字节
2）移位运算符只有三个左移<<、右移>>、无符号右移>>>
3）Java当中的注释有：单行注释、多行注释（块注释）、文档注释
4）包装类就是八个基本数据类型（字符串不是，字符串不是基本数据类型）
5）Java程序经编译后会产生byte code（byte code就是.class,又名字节码文件）
6）switch（）{}结构中没括号中可使用的数据类型只能是整型和String还有枚举类型 ，long转换成int可能会有数据丢失所以不能用。浮点数也不能用，浮点数是个近似值。

3）选择语句switch

public class Demo07Switch{
	public static void main(String[] args){
		int num = 1;
		switch(num){
			case 1: System.out.println("星期一");break;
			case 2: System.out.println("星期二");break;
			case 3: System.out.println("星期三");break;
			case 4: System.out.println("星期四");break;
			case 5: System.out.println("星期五");break;
			case 6: System.out.println("星期六");break;
			case 7: System.out.println("星期七");break;
			default: System.out.println("数据不合理");break;
		}
	}
}

switch语句的注意事项：
1.多个case后面的数值不可以重复
2.switch后面小括号当中只能是下列数据类型：
基本数据类型：byte、short/char/int
引用数据类型：String字符串，enum枚举
3.switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句还可以省略。 "匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止。"

4）循环语句 循环结构的基本组成部分，一般可以分成四部分：
1.初始化语句：再循环开始最初执行，而且只做唯一一次；
2.条件判断：如果成立，则循环继续；如果不成立，则循环退出；
3.循环体：重复要做的事情内容，若干行语句；
4.步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次；

(1)循环结构 For循环

public class Demo09For{
	public static void main(String[] args){
		/*
		for(初始化语句;条件判断;步进语句){
			循环体
		}
		*/
		for(int i = 1; i <= 100; i++){
			System.out.println("你好！" + i);
		}
		System.out.println("程序停止");
	}
}

(2)循环语句While

/*
while循环有一个标准格式，还有一个扩展格式

标准格式：
while(条件判断){
	循环体
}

扩展格式：
初始化语句；
while(条件判断){
	循环体
	步进语句
}
*/
public class Demo10While{
	public static void main(String[] args){
		/*
		for(int i = 1;i <= 10; i++){
			System.out.println("你好");
		}
		*/
		int i = 1;
		while(i <= 10){
			System.out.println("你好");
			 i++;
		}
	}
}

(3)do-while循环

/*
do-while循环的标准格式:
do{
	循环体
}while(条件判断)；
//后面的这个分号不能丢
扩展格式：
初始化语句；
do{
	循环体
	步进语句
}while(条件判断)；

do-while循环和别的循环不一样的地方在于，它的第一次执行是无条件执行。
*/
public class Demo11DoWhile{
	public static void main(String[] args){
		/*
		for(int i = 1;i <= 10; i++){
			System.out.println("你好");
		}
		*/
		int i = 1;
		do{
			System.out.println("你好");
			 i++;
		}while(i <= 10);
	}
}

循环测试题：

/*
编写程序数一下 1到 100 的所有整数中出现多少个数字9（20个）
1.可以分为两个区间1-9，10-99
2.两位数求个位数可以用x%10，求十位可以用x/10
3.发现十num++
*/
public class TestNumber{
	public static void main(String[] args){
		int num = 0;
		for(int i = 1;i <= 100;i++){
			if(i <= 10){
				if(i == 9) num++;
			}
			else{
				if(i % 10 == 9) num++;
				if(i / 10 == 9)	num++;
			}
		}
		System.out.println("一共出现了"+num+"个9.");
	}
}

/*用循环求出1-100之间的偶数和 (2550个)
1.确定范围1-100
2.判断偶数x%2==0
3.是偶数加到sum ;sum = sum + x;
*/
public class TestHundredSum{
	public static void main(String[] args){
		int sum = 0;
		for(int i = 1; i <= 100; i++){
			if(i % 2 == 0) sum = sum + i;
		}
		System.out.println(sum);
	}
}

三种循环的区别：
1.如果条件判断从来没有满足过，那么for循环和while循环将会执行0次，但是do-while循环会执行至少一次。
2.for循环的变量再小括号当中定义，只有循环内部才可以使用，while和do-while循环初始化语句本来就在外面，所以出来循环之后还可以继续使用。

条件控制语句：
（1）break关键字的用法有常见的两种：
        1.可以用在switch语句当中，一旦执行，整个switch语句立刻结束。
        2.还可以用再循环语句中，一旦执行，整个循环语句立刻结束，打断循环。
（2）continue关键字： 一旦执行，立刻跳过本次循环，继续下一次循环。

关于循环的选择，有一个小建议： 凡是次数确定的场景多用for循环；否则多用while循环。

死循环：

/*
死循环：永远停不下来的循环
死循环的标准格式：
while(true){
	循环体
}
注意：
结束用：Ctrl+C（再命令提示符中使用此命令结束死循环）
死循环后不能写语句了，否则编译报错，因为死循环无法停下来，所以会报错有无法访问的语句
*/
public class Die{
	public static void main(String[] args){
		while(true){
			System.out.println("我爱JAVA！");
		}
	}
}

循环的嵌套写法：

/*
一天24小时，一个小时60分钟
*/
public class Demo17LoopHourAndMinute{
	public static void main(String[] args){
		for(int hour = 0; hour < 24; hour++){ 	//外层控制小时
			for(int minute = 0; minute < 60; minute++ ){	//内层控制小时内的分钟
				System.out.println(hour + "点"+ minute + "分");
			}
		}
	}
}