Java之基础语法

末蓝、 2023-02-17 08:54 18阅读 0赞

## 数据类型 ##

**基本数据类型**

数值型：
    	整型：byte(2^8，字节)、short(2^16，短整型)、int(2^32)、long(2^64，长整型，结尾用l标识)
    	浮点型：float(单精度，结尾用f标识)、double(默认)
    字符型：char（两个字节，即两个8位，汉字也是两个字节，所以可以存汉字）
    布尔型：boolean

## 类型转换 ##

隐式转换与显示转换

byte x = 1;
    x = (byte)(x + 1);//x本身为1个8位，计算的时候，x会隐式转换，向上提升为4个8位，计算完成的结果也为4个8位，想要赋给byte类型，需要进行显示转换
    double y = 1.2;
    System.out.println((int)y);//1,显示转换
    char z = 'a';
    System.out.println(z+1);//98 字符与数值相加，会先去查找自己对应的ASCII码，然后再相加，a对应的ASCII码为97

## 操作运算符 ##

//+-*/%
    //取模运算，左边小于右边，结果都等于左边,再去考虑正负号
    System.out.println(-1%3);
    //自增（++）自减（--）
    //a++ => a = a + 1
    int a = 3, b;
    b = a++;//b=3 a=4 先赋值，再自增
    System.out.println("a="+a+",b="+b);
    b = ++a;//b=5 a=5 先运算，再赋值
    System.out.println("a="+a+",b="+b);
    
    /*
    转义字符，通过\来转变后面字母或符号的含义
    \n：换行，linux中的换行只有一个字符\n
    \b：退格，即Backspace
    \r：回车键，windowsz红中的换行由两个字符来表示\r\n
    \t：制表符，即Tab键
    println中的ln会进行换行处理
    */
    System.out.println("Hello\nWorld");
    
    //赋值运算符：+=、-=、/=、%=
    short s = 5;
    //s = s + 5;//两个运算，先加再赋值，加完之后为int类型，会报错
    s+=5;//一个运算，即赋值运算，+=内部会进行类型转换，不会报错
    
    //比较运算符：==、！=、>、<、>=、<=、interface，结果只有两个true和false
    
    /*
    逻辑运算符：连接两个布尔类型的值
    &（与）、&&（短路与）、|（或）、||（短路或）、^（异或）、!（非）
    &与|，左右两边都会参与运算
    &&与||，先去判断左边，左边如果能决定整体结果，就会阻断不运算右边
    ^：两边相同为false，两边不同为true
    */
    
    /*
    位运算：直接对二进制进行运算
    */

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw_size_16_color_FFFFFF_t_70]  
位运算符详解

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

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

## 流程控制语句 ##

判断结构============================================
    if语句，特点：满足条件即执行，剩下的判断不会再走
    写法1：
    if(条件)
     表达式
    写法2：
    if(条件){ 
     表达式1
    }else{ 
     表达式2
    }
    写法3：
    if(条件1){ 
     表达式1
    }else if(条件2){ 
     表达式2
    }else{ 
     表达式3
    }
    三元运算符
    变量 = (条件)?表达式1:表达式2
    if语句和三元运算符的区别：
    运算符必须要有结果，必须返回一个值。if语句则不需要，满足条件执行一段逻辑即可
    
    选择结构============================================
    判断数值较少，且为下面四种类型的时候，优选switch，效率稍高
    数值较多，需要判断区间、返回值为布尔类型等情况，选择if语句
    
    switch(表达式)//结果为byte、short、int、char
    { 
     case 取值1:
      执行语句
      break;//如果满足条件，但没有break语句，会不考虑下面的case情况，运行所有的执行语句，直到遇到break或}为止
     case 取值2:
      执行语句
      break;
     ...
     default:
      执行语句
      break;
    }
    
    循环结构============================================ 
    while循环
    //满足条件才会循环
    while(条件语句){ 
     循环体(执行语句)
    }
    
    do while循环
    //先执行一次再进入循环，至少会执行一次循环体
    do{ 
     循环体(执行语句)
    }while(条件语句)
    
    for循环
    当前初始化变量，仅在for循环体内有效，循环结束，变量即在内存中被释放
    for(初始化表达式,循环条件表达式,循环后的操作表达式){ 
     循环体
    }
    
    无线循环的最简单表现形式
    for(;;){ }
    while(true){ }
    
    break：终止循环
    continue：跳过本次循环

## 函数 ##

用于实现一个功能
    明确两点：
    1、返回值类型，没有返回值用void标注
    2、参数类型和参数值
    public static 返回值类型 函数名(参数类型 形参1，参数类型 形参2){ 
    	内部运行语句
    	return 返回值;
    }
    例如：实现一个返回两个数中较大值的功能
    public static int getMax(int a, int b)
    { 
    	return a>b?a:b;
    }
    
    函数重载
    在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。 
    下面三个函数可以放在同一个类中
    //返回两个整数的和 
    int add(int x,int y){ return x+y;} 
    //返回三个整数的和 
    int add(int x,int y,int z){ return x+y+z;} 
    //返回两个小数的和 
    double add(double x,double y){ return x+y;}

**main主函数**  
public static void main(String\[\] args)\{\}  
一个特殊的函数，作为程序的入口，可以被jvm（虚拟机）使用  
主函数的定义：  
public：代表着该函数的权限是最大的  
static：代表主函数随着类的加载就已经存在了  
void：没有具体返回值  
main：不是关键字，一个特殊的单词，可以被jvm识别  
(String\[\] args)：参数为字符串类型的数组，这块传入的其实是new String\[0\]  
主函数是固定格式的，用于被jvm识别

class MainTest { 
    	public static void main(String[] args) { 
    		String[] arr = { "aaa","bbb","ccc"};
    		//参数可以重新传入
    		MainDemo.main(arr);
    	}
    }
    class MainDemo { 
    	public static void main(String[] args) { 
    		for(int x = 0; x < args.length; x++){ 
    			System.out.println(args[x]);
    		}
    	}
    }

## 内存结构 ##

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空 间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内 存管理方式。  
**栈内存**  
用于存储局部变量，**当数据使用完，所占空间会自动释放。**  
**堆内存**  
数组和对象，通过new建立的实例都存放在堆内存中。  
每一个实体都有内存地址值  
实体中的变量都有默认初始化值  
实体不在被使用（引用），会在**不确定的时间内被垃圾回收器回收（垃圾回收机制）**  
**方法区**  
**本地方法区**  
**寄存器**

## 数组 ##

同一种类型数据的集合。
    //定义数组基本语法
    元素类型[] 数组名 = new 元素类型[数组个数]
    //常见的几种定义数组语法
    int[] x = new int[5];
    //int x[] = new int[5];
    //数组值确定的情况下，可以用下面两种定义
    //int[] x = new int[]{1,2,3,4};
    //int[] x = {1,2,3,4};
    //y,x现在使用同一个地址，改变一个另一个去调用也会改变
    int[] y = x;
    y[1] = 5;
    System.out.println(x[1]);//5
    x数组不再用了之后，可以赋值为null，去取消引用，释放堆内存
    x = null；
    
    //数组折半查找
    public static int halfSearch_2(int[] arr, int key)
    { 
    	int min,max,mid;
    	min = 0;
    	max = arr.length - 1;
    	while(min<=max)
    	{ 
    		mid = (min + max)>>1;
    		if(key<arr[mid]){ 
    			max = mid - 1;
    		}else if(key>arr[mid]){ 
    			min = mid + 1;
    		}else{ 
    			return mid;
    		}
    	}
    	return -1;
    }
    public static int halfSearch(int[] arr,int key)
    { 
    	int min,max,mid;
    	min = 0;
    	max = arr.length - 1;
    	mid = (min + max) / 2;
    	while(arr[mid]!=key)
    	{ 
    		if(key>arr[mid])
    			min = mid + 1;
    		if(key<arr[mid])
    			max = mid - 1;
    		if(min>max)
    			return -1;
    		mid = (min + max) / 2;
    	}
    	return mid;
    }

**数组（引用数据类型）的内存结构**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw_size_16_color_FFFFFF_t_70 3]**二维数组**

int[][] arr = new int[3][4];
    /* 定义了名称为arr的二维数组 二维数组中有3个一维数组，二维数组的长度 每一个一维数组中有4个元素，每一个一维数组的长度 一维数组的名称分别为arr[0], arr[1], arr[2] 给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78; */
    //另一种定义方法
    int[][] arr2 = new int[3][];
    arr[0] = new int[3];
    arr[1] = new int[4];
    arr[2] = new int[5];
    //其他定义方法
    int[] arr3[] = { { 1,2,3},{ 3,2,1},{ 5,6,7}};
    //注意：数组为引用类型，若数组中没有数据，返回值为null
    int[][] arr4 = new int[2][];
    System.out.println(arr4[0]);//null

**二维数组内存结构**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw_size_16_color_FFFFFF_t_70 4]

## 进制转换 ##

//十进制转化为二进制
    public static void toBinTwo(int num) { 
    	StringBuffer sb = new StringBuffer();
    	while(num>0){ 
    		sb.append(num%2);
    		num = num / 2;
    	}
    	System.out.println(sb.reverse());
    }
    //十进制转化为十六进制
    public static void toBinSixteen(int num) { 
    	StringBuffer sb = new StringBuffer();
    	for(int x = 0; x < 8; x++){ 
    		int temp = num & 15;
    		if(temp>9)
    			//System.out.print((char)(temp-10+'A'));
    			sb.append((char)(temp-10+'A'));
    		if(temp<9)
    			//System.out.print(temp);
    			sb.append(temp);
    		num = num>>>4;
    	}
    	System.out.println(sb.reverse());
    }	
    /** *十进制转换为其他进制公共转换方法 *num为十进制数 *base为需要&的数 *offset为需要右移几位 *十进制转换为二进制：transform(5,1,1) *十进制转化为八进制：transform(5,7,3) *十进制转换为十六进制：transform(5,15,4) */
    public static void transform(int num, int base, int offset) { 
    	char[] chs = { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    	char[] arr = new char[32];
    	int pos = arr.length;
    	while(num!=0){ 
    		int temp = num & base;
    		arr[--pos] = chs[temp];
    		num = num >>> offset;
    	}
    	for(int x = pos; x < arr.length; x++){ 
    		System.out.print(arr[x]+",");
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200613164604875.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200613164314428.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200613170919550.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200621154505821.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/202006291009354.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw==,size_16,color_FFFFFF,t_70