Java基础语法知识总结
Java八大基本数据类型
整数类
byte java使用过程中使用最少的数据类型,它在内存中占用1个字节,也就是8位(bit),值得范围是:-128~127,也就是-2的7次方到2的7次 方减一,默认值0。
short 短整型,它在内存中占用的是2个字节,16位,值得取值范围是-32768~32767,也就是-2的15次方到2的15次方减一,默认值0。
int 整型,在内存中占4个字节,32位,取值范围-2147483648~2147483647,也就是-2的31次方到2的31次方减一,默认值0。
long 长整型,在内存中占8个字节,64位,值的取值范围是-2的63次方到2的63次方减一,默认值要注意了,因为是长整型,所以默认是虽说是0,但是准确的说是0L,必须要加上L来表示它是long类型,不加就成了int类型了.
逻辑类
boolean 布尔类型,它比较特殊,布尔类型只允许存储true(真)或者false(假),不可以用0或者非0表示,可以使用 1 bit 来存储,但是具体大小没有明确规定。JVM 会在编译时期将 boolean 类型的数据转换为 int,使用 1 来表示 true,0 表示 false。JVM 支持 boolean 数组,但是它是通过读写 byte数组来实现的。
文本类
char 字符类型,它在内存中占用2个字节,也就是16 bit,因为java本身的字符集不是用ASCII码来存储的, 而是用的16位的Unicode字符集,所以它的字符存储范围也就是’\u0000 – u\ffff’,默认值呢?就是’\u0000’。在实际编程中,赋值时使用单引号( ’ ’ )。
浮点类
float 单精度浮点型, 在内存中占4个字节(32位),主要用来存储小数,但是有限制,有效小数位只有6~7位,默认是0.0f ,取值范围是:3.402823e+38 ~ 1.401298e-45(e+38表示是乘以10的38次方,同样,e-45表示 乘以10的负45次方)。
double 双精度浮点型,在内存中占8个字节,64位,也是用来存储小数的,默认是0.0,取值范围是1.797693e+308 到4.9000000e-324(e+308表示是乘以10的308次方,同样,e-324表示乘以10的负324次方)。
注意: 不声明小数类型的情况下,默认为double类型。
数据类型的转换(boolean不参与数据类型的转换)
char(16 bit)
|
byte(1 bit) -> short(16 bit) -> int(32 bit) -> long(64 bit)
| |
float(32 bit) double(64 bit)
注意: 根据类型所占内存大小,小可转大,大转小会失去精度。
数据类型默认值
整型: 0
浮点型: 0.0
布尔型: false
Char: ‘ ’(空)
引用数据类型: null
自定义方法
方法的声明: 解决一类问题的代码有序的组合,是一个功能模块。
组成:访问修饰符 返回类型 方法名(形参){方法体}
例:
public static void add(int a,int b) {
int result=a+b;
System.out.println("和是"+ result);
}
方法的分类
无参无返回值方法
例:
public static void print(String[] args) {
System.out.println("输出语句");
}
无参有返回值方法
例:
public static boolean Isture() {
//中间省略一段判断数据结果的代码,判断为假,结束并返回一个值
return false;
}
有参无返回值方法
例:
public static void add(int a) {
a++;
}
有参有返回值方法
例:
public static int cal(int a,int b) {
return a-b;
}
关键字return、break、continue的区别
return 结束方法
break 结束本次循环
continue终止本次循环继续下次循环
方法的调用
例:
//方法名();
add();
方法的重载
重载的条件
形参类型、个数、顺序不同构成重载;只有返回值不同不构成重载。
例:
public class Name {
public static void main(String[] args){
System.out.println(getSum(1,2,3));
System.out.println(getSum(1.1,2.2,2.3));
}
public static int getSum(int a,int b){
System.out.println("两个参数");
return a+b;
}
public static int getSum(int a,int b,int c){
System.out.println("三个参数");
return a+b+c;
}
public static double getSum(double a,double b,double c){
System.out.println("三个参数");
return a+b+c;
}
}
递归(非常消耗内存)
结构:
定义递归头(什么时候不调用自身的方法)
递归体(什么时候需要调用自身)
例1:
public static int fun(int n) {
//递归头
if(n==1||n==0){
return 1;
}else{
//递归体
return fun(n-1)*n;
}
}
//自己调自己
例2:
public class Name {
public static void main(String args[]) {
print(9);
}
//递归打印九九乘法表
public static void print(int i) {
if (i==1) {
System.out.println("1*1=1 ");
} else {
print(i-1);
for (int j=1; j<= i; j++) {
System.out.print(j+"*"+i+"="+j*i+"\t");
}
System.out.println();
}
}
}
数组
数组的定义
长度的属性关键字: length
定义数据类型为int的数组
例:
int[] arr=new int();
数组的动态初始化
先确定数量后赋值,一旦确定长度,不可改变。
例:
String[] arr=new String[6];
arr[0]="你好";
arr[1]="哈罗";
数组的静态初始化
例:
String[] arr=new String[]{“你好”,“哈罗”}
数组遍历
遍历: 按照一定规则取出数组中的内容。
例:
public static void main(String[] args) {
double[] arr={1.0,1.1,1.2};
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
增强for循环: for(数据类型 变量名:要遍历的对象)这里变量名是要遍历的直接类容。
例:
double[] arr={1.0,1.1,1.2};
for(double i:arr){
System.out.println(i);
}
数组排序
冒泡排序: 每次分别拿两个数进行比较,把大的放到后面,全部比较一次后,确保最大的数放到最末尾。
例:
public class Test01 {
public static void main(String[] args) {
int[] add= {3,9,5,3,8,6,2,4,6,2,85,8,3};
sortBubble(add);//调用方法
System.out.println(Arrays.toString(add));
}
public static void sortBubble(int[] add) {
for(int a=0;a<add.length;a++) {
//循环下一for,循环一次下一个for循环一遍,直到下一个for不满足条件,跳出
for(int j=0;j<add.length-1;j++) {//索引位置
if(add[j]>add[j+1]) {//索引位置的值进行比较
//两个索引位置的值进行互换
int tep=add[j+1];//建立一个临时的值
add[j+1]=add[j];
add[j]=tep;
}
}
}
}
}
选择排序: 拿第一个数分别和接下来剩下的数进行比较,保留其中最小数的索引,然后把它和当前正在对比的数进行互换。
例:
//int[] add= {3,9,5,3,8,6,2,4,6,2,85,8,3};
public static void sortSelect(int[] add) {
for(int i=0;i<add.length;i++) {//索引为0开始
int minIndex=i; //每执行一次,就保留当前最小数索引
for(int j=i;j<add.length;j++) {
if(add[j]<add[minIndex]) {//当索引j与minIndex为0时,条件不成立
//当j索引位置的值小于minIndex索引位置的值,向下执行
minIndex=j;//第二个循环循环一遍,拿到最小数索引,向下执行交换
}
}
//交换把最小数排数组第一位
int tep=add [minIndex];
add [minIndex]=add[i];
add [i]=tep;
}
}
二维数组及遍历
定义格式
动态初始化: 数据类型[ ][ ] 二维数组名=new 数据类型[一维长度][二维长度];
注意: 一维必须给值。
静态初始化: 数据类型[ ][ ] 二维数组名=new 数据类型[ ][ ]{{“1”,“2” },{“3”,“4”},…};
二维数组遍历
例:
public class Array02 {
public static void main(String[] args) {
int[][] arr= {{1,3,5},{3,1},{4}};
System.out.println("普通for里面嵌套增强for");
for(int i=0;i<arr.length;i++) {//i表示外层数组的索引
for(int p:arr[i]) {//增强for循环
System.out.println(p);
}
}
}
}
Arrays(数组)工具类的使用
Arrays.toString()
// 把数组中的内容用字符串的形式返回
Arrays.equals()
// 比较两个数组的内容是否相等
Arrays.deepToString()
//针对多维数组使用
Arrays.deepEquals(a,b)
//针对多维数组使用
Arrays.fill(数组,值)
//将指定的数据类型的值分配给指定的数据类型型数组的每个元素
Arrays.fill(数组,左边索引,右边索引,值);
//将指定的值分配到指定数组的指定范围(前闭后开)
Arrays.parallelSort(数组);
//将指定的数组排序
Arrays.binarySearch(数组,值)
//二分查找法
注意: 使用二分查找法,首先保证数组是有序的
常量final
定义: 用final修饰的,在程序运行期间值不会改变。