java语法基础_java先执行后判断-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_59219574/article/details/122627854

一、变量命名规则

1、只能包含字母、数字、_和$符，并且不能以数字开头

2、严格区分大小写

3、不能使用关键字

4、允许中文命名，但不建议，建议"英文的见名知意"、“小驼峰命名法”

二、八种基本数据类型

byte,short,int,long,float,double,boolean,char

1、byte：字节型，用于存储整数的，占用1个字节，范围-128到127

2、short：短整型，用于存储整数的，占用2个字节，范围-32768到32767

3、int：最常用的整型，用于存储整数的，占用4个字节，范围-2^31到231-1

4、long：长整型，用于存储较大的整数的，占用8个字节，范围-2^63到263-1

5、float：单精度浮点型，用于存储小数的，占用4个字节，不能表示精确的值

6、double：双精度浮点型，最常用的存储小数的类型，占用8个字节，不能表示精确的值

7、boolean：布尔型，存储true或false，占用1个字节

8、char：字符型，采用Unicode字符编码格式，存储单个字符，占用2个字节

ASCII码：‘a’—97 ‘A’—65 ‘0’—48

三、类型间的转换：

1、基本类型由小到大依次为：

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

char----

2、两种方式：

（1）自动/隐式类型转换：小类型到大类型

（2）强制类型转换：大类型到小类型

1）语法：(要转换成为的数据类型)变量

2）强转有可能溢出或丢失精度

3、两点规则：

（1）整数直接量可以直接赋值给byte,short,char，但不能超出范围

（2）byte,short,char型数据参与运算时，系统一律自动将其转换为int再运算

四、运算符：运算的符号

1、算术：+，-，*，/，%，++，–

（1）%:取模/取余，余数为0即为整除

（2）++/–：自增1/自减1，可在变量前也可在变量后

1）a++的值为a--------(a–的值为a)

2）++a的值为a+1------(–a的值为a-1)

2、关系：>，<，>=，<=，==，!=

关系运算的结果为boolean型，关系成立则为true，关系不成立则为false

3、逻辑：&&，||，!

（1）&&：短路与(并且)，两边都为真则为真，见false则false，当第1个条件为false时，发生短路(后面的不执行了)

（2）||：短路或(或者)，有真则为真，见true则true，当第1个条件为true时，发生短路(后面的不执行了)

（3）!：逻辑非(取反)，非真则假，非假则真

4、赋值：=，+=，-=，*=，/=，%=

（1）简单赋值运算符：=

（2）扩展赋值运算符：+=，-=，*=，/=，%=

注：扩展赋值自带强转功能

5、字符串连接：+

（1）若两边为数字，则做加法运算

（2）若两边出现了字符串，则做字符串连接

（3）任何类型与字符串相连，结果都会变为字符串类型----同化作用

6、条件/三目：?:

（1）语法：

boolean?数1:数2

（2）执行过程：

计算boolean的值

若为true，则整个表达式的值为?号后的数1

若为false，则整个表达式的值为:号后的数2

五、分支结构：基于条件执行某语句

1、if结构：1条路

（1）语法：

if(boolean){ 语句块 }

（2）执行过程：

判断boolean的值: 若为true，则执行语句块1(if整个结束) 若为false，则if直接结束

2、if…else结构：2条路

（1）语法：

if(boolean){ 语句块1 }else{ 语句块2 }

（2）执行过程：

判断boolean的值: 若为true，则执行语句块1(整个结束) 若为false，则执行语句块2(整个结束)

3、Scanner：接收用户输入的数据

（1）在package下：

   java.util.Scanner

（2）在main中：

  Scanner scan = new Scanner(System.in);

（3）在第2步之下：

System.out.println("请输入年龄:");   
int age = scan.nextInt();    
System.out.println("请输入商品价格:");    
double price = scan.nextDouble();

4、if…else if结构：多条路

（1）语法：

if(boolean-1){

语句块1

}else if(boolean-2){

语句块2

}else if(boolean-3){

语句块3

}else{

语句块4

}

（2）执行过程：

判断boolean-1，若为true则执行语句块1(结束)，若为false则再判断boolean-2，

若为true则执行语句块2(结束)，若为false则再判断boolean-3，

若为true则执行语句块3(结束)，若为false则执行语句块4(结束)

5、switch…case结构：多条路

优点：效率高、结构清晰

缺点：只能对整数判断相等

break：跳出switch

常见面试题：switch可以作用于什么类型的数据上

-------------------------byte,short,int,char,String,枚举类型

六、循环结构

1、循环三要素：

（1）循环变量的初始化

（2）循环的条件(以循环变量为基础)

（3）循环变量的改变(向着循环的结束变）

2、while结构：先判断后执行，有可能一次都不执行

（1）语法：

while(boolean){

语句块-------------反复执行的代码

}

（2）执行过程：

判断boolean的值，若为true则执行语句块，

再判断boolean的值，若为true则再执行语句块，

如此反复，直到boolean的值为false时，while循环结束

3、do…while结构：先执行后判断，至少执行一次

要素1与要素3相同时，首选do…while

（1）语法：

do{ 语句块 }while(boolean);

（2）执行过程：

先执行语句块，再判断boolean的值，若为true则

再执行语句块，再判断boolean的值，若为true则

再执行语句块，如此反复，直到boolean的值为false，则 do…while结束

4、变量的作用域

从变量的声明开始，到包含它最近的大括号结束

5、生成随机数

int num = (int)(Math.random()*1000+1); //1到1000
Math.random()--------------0.0到0.9999999999999999...
*1000----------------------0.0到999.99999999999999...
+1-------------------------1.0到1000.9999999999999...
(int)----------------------1到1000

6、for结构：应用率高、与次数相关的循环

语法：

// 1 2 3

for(要素1;要素2;要素3){

语句块/循环体----------------反复执行的代码 4

}

7、三种循环结构的选择规则

先看循环是否与次数相关：

若相关----------------------------直接上for
若无关，再看要素1与要素3是否相同：
- 若相同------------------------直接上do…while
- 若不同------------------------直接上while

8、break/continue

（1）break：跳出循环

（2）continue：跳过循环体中剩余语句而进入下一次循环

9、嵌套循环：

（1）循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列

（2）执行过程：外层循环走一次，内层循环走所有次

（3）建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层，若业务必须通过三层以上的循环才能解决，说明你的设计有问题

（4）break只能跳出当前一层循环

七、数组

1、是一种数据类型(引用类型)，相同数据类型元素的集合

2、初始化：给数组中的元素做初始化

3、访问：访问的是数组中的元素

（1）通过(数组名.length)可以获取数组的长度(元素的个数)

（2）通过下标/索引来访问数组中的元素

下标从0开始，最大到(数组的长度-1)

4、遍历/迭代：从头到尾挨个走一遍

5、ArrayIndexOutOfBoundsException 数组下标越界异常

数组下标范围为0到(数组长度-1)，超出范围则发生如上的异常

6、复制：

System.arraycopy(a,1,b,0,4);
//a:源数组
//1:源数组的起始下标
//b:目标数组
//0:目标数组的起始下标
//4:要复制的元素个数

int[ ] b = Arrays.copyOf(a,6);
//a:源数组
//b:目标数组
//6:目标数组的长度(元素个数)
//---若目标数组长度>源数组长度，则末尾补默认值
//---若目标数组长度<源数组长度，则将末尾的截掉
a = Arrays.copyOf(a,a.length+1);//数组扩容(创建了一个更大的新的数组，并将源数组数据复制进去了)

7、排序：

（1）Arrays.sort(arr); //升序排列(从小到大)

（2）冒泡法排序：

第一步：从第一位开始，把相邻两位进行比较如果发现前面的比后面的大，就把大的数据交换在后面，循环比较完毕后，最后一位就是最大的。
第二步：再来一次，只不过不用比较最后一位，以此类推

for(intj = 0; j < a.length; j++) {
      for(inti = 0; i < a.length-j-1; i++) {
        if(a[i]>a[i+1]){ 
          int temp = a[i];
          a[i] = a[i+1];
          a[i+1] = temp;
        }
      }
    }

（3）选择法排序

把第一位和其他所有的进行比较，只要比第一位小的，就换到第一个位置来，比较完后，第一位就是最小的。
然后再从第二位和剩余的其他所有进行比较，只要比第二位小，就换到第二个位置来比较完后，第二位就是第二小的，以此类推

for (int j = 0; j < a.length-1; j++) {
			for (int i = j+1; i < a.length; i++) {
				if(a[i]<a[j]){   
					int temp = a[j];
					a[j] = a[i];
					a[i] = temp;
				}
			}
		}