java基础第二弹

最新推荐文章于 2024-09-14 18:46:05 发布

点点星光洒满宇宙

最新推荐文章于 2024-09-14 18:46:05 发布

阅读量944

点赞数 38

分类专栏： javaSE学习资料总结文章标签： java 开发语言学习

本文链接：https://blog.csdn.net/qq_65124761/article/details/140334059

版权

javaSE学习资料总结专栏收录该内容

5 篇文章 1 订阅

订阅专栏

Java基础知识全解第二弹

记录回顾自己学过的java常见的基础知识,希望可以给初学者一些帮助，如果合适的话希望各位给一个免费的点赞和关注，在此谢谢各位了。

一、流程控制

1.分支结构

1.1 单分支if

语法:

if(boolean值){ //boolean可以是一个很长的表达式，&& || 拼接
    语句
}

注意：若if语句块中只有一条语句，则if后面的{}可以省略，但是不建议省略,若按照阿里规约，强制不能省

1.2 if-else

语法:

if(boolean值){
    语句
} else {
    语句
}

1.3 多重if

语法：

if(条件1) {
    //语句1
} else if(条件2) {
     //语句2
} else if(条件3) {
     //语句3
} 
//....else if可以有多个
else {
    //语句4
}
//最后一个else可以省略

1.4 嵌套if

语法：

if(条件1) {
    if(条件){
       //语句 
    }else{
       //语句 
    }
    //语句1
} else if(条件2) {
     //语句2
} else if(条件3) {
     //语句3
}

1.5 if-else

1.6 switch

多重if一般用于处理区间范围的判断，等值也可以做，但是没有switch结构简洁高效。switch通常用于等值判断。

语法：

switch(条件){
    case 值1:
        //语句1
        break;  
    case 值2:
        //语句3
        break;  
    //....case 可以有多个
    default:
        //上述case若都没有匹配上，可以给一个默认结果
}

注意：switch语句支持那些数据类型的变量：
byte,short,int,char,enum
从7.0版本的jdk支持String


//若干语句可以合并。
//案例
class Test12{
	public static void main(String[] args){
		int i = 12;
		switch(i){
			case 3:
			case 4:
			case 5:
			System.out.println("春季");
			break;
			case 6:
			case 7:
			case 8:
			System.out.println("夏季");
			break;
			case 9:
			case 10:
			case 11:
			System.out.println("秋季");
			break;
			case 12:
			case 1:
			case 2:
			System.out.println("冬季");
			break;
			
		}
	}
}

2.循环结构

2.1 循环解释

所谓的循环就是往复地做相同的事情。

2.2 循环四要素

a.初始化表达式

b.布尔值测试表达式

c.循环体

d.更改表达式

2.3 for循环

语法：

for(表达式1：表达式2：表达式3){
	代码块；
}

习题

统计1-100之间有多少个6的倍数

	int count=0;
	for(int c=1;c<=100;c++){
	      if(c%6==0){
		  count++;
		  }
	}
	System.out.println(count);

//打印1000以内所有的素数

for(int i=2;i<1000;i++){
	boolean flag=true;
	for(int j=2;j<Math.sqrt(i);j++){
	if(i%j==0){
		flag=false;
		break;
	}
}
if(flag)
	System.out.println(i);
}
       System.out.println(math(100));

2.4 while循环

语法：

while(条件) {
    //执行循环操作
    //修改控制循环条件的那个变量
}

2.5 do while循环

语法：

do {
    //your code
}while(条件);

注意：do-while循环的循环体至少会执行一次

2.6 嵌套循环

一个循环是另一个循环的循环体

内层循环结束，外层循环才走一次

外层循环结束，内层循环走了内层✖外层的次数

案例：

for(int i=0;i<10;i++){
	for(int j=0;j<10-i;j++){
   System.out.print(" ");
}
	for(int z=0;z<(i+1);z++){
   System.out.print(" *");
}
    System.out.println();
}*///打印等腰三角形

2.7 结束循环关键字

2.7.1 break————结束循环

注意：如果在嵌套循环中，执行了break语句，那么他只会结束当前这一层循环

2.7.2 continue----用来结束当前这一次循环，开启下一次循环

2.8 无限循环-----该循环一直在执行循环体

格式：

①

while(true){

③

④

}

for(；；){

③

}

案例：

/*请用户不停地从键盘输入一个整数，如果输入0，则打印Game Over,在打印您一共输入XX个整数和XX个负整数*/
Scanner sc=new Scanner(System.in);
int zheng=0,fu=0;
System.out.println("请你从键盘输入一个整数：");
while (true){
	int num=sc.nextInt();
	if(num==0){
		System.out.println("Game Over");
		System.out.println("一共输入"+zheng+"个整数");
		System.out.println("一共输入"+fu+"个负整数");
		break;
	}else{
		if(num>0)
			zheng++;
		els
			fu++;
	}
}

二、方法

1.方法的格式

修饰符返回值类型方法名称(形式参数列表) {
方法体
return 值;

}

2.方法调用的规则：

程序从main方法开始执行，如果存在方法调用，则在调用处停下来等被测方法执行完，回到当前方法才能停下来

3.return关键字

用法：用来结束当前方法

注意：被调用方法如果声明为void则表示无返回值，return语句不加返回值
被调用方法如果声明为某种类型的返回值，则return语句必须带上该类型数值。

4.递归

一个方法的内部自己调用自己，递归调用必须要有结束的条件，将一个复杂的问题层层转化成一系列相似的小问题来求解，大大的节约了代码量。

递归的三个关键

①找到递归出口（即终止条件）

②找到递归公式

③设计递归方法内部的运算部分

//递归算法求1-100累加求和
public static int math(int i){
	int sum=0;
	if(i==1){
		

		return 1;
	}else{
		sum=i+math(i-1);
		return sum;

}	
}

三、数组

1. 一维数组

定义：用来存放一组相同数据的容器。

数组的初始化方式：

①动态初始化：

数组类型[] 数组名=new 数组类型[长度]；

赋值：

数组名[下标]=值

取值：

数组名[下标]

注意：下标从0开始，到长度-1结束；
如果动态初始化一个数组，它的每一个元素都是一个默认值

实例

int[] arr=new int[10];//这是一个长度为10的数组

②静态初始化

int[]arr=new int{100,200,300};还可以简写成int[]arr={100,200,300};

数组类型[] 数组名 =数组类型[]{值1，值2…}

动态和静态的区别在于动态初始化需要将定义语句和赋值语句分开编写，而静态初始化的定义语句和赋值语句是同一句话。

1.1 数组长度

数组长度一旦声明，就无法修改，我们可以通过数组名.length来查找数组长度。

2.二维数组

一个一维数组中的每个元素都是一维数组。

动态初始化：

数据类型 [][] [] [] 数组名=new 数据类型 [长度] [长度]；

赋值；

数组名[下标]=值

静态初始化：

数字类型[] []数组名=new 数据类型[] []{{值1，值2…}，{值3，值4…}}

注意：二维数组中的每个一维数组长度可以不同

3.forEach

作用：增强for循环，它可以快速遍历一个数组。

格式：

for(数据类型变量名：数组名){

使用变量

}

4.冒泡排序

原理：相邻的两个数两两比较，如果需要就交换位置，第一轮就结束，最小的就排到前面，第二轮结束就第二小的排到前面，依次类推。

案例

  int arr[]={200,300,100,50,40};
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = arr.length-1; j >i ; j--) {//每一轮都从后往前比较，如果前面一个比后面一个大就交换，持续arr.length轮
                if (arr[j] < arr[j-1]) {
                    int temp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j - 1] = temp;
                }
            }
        }
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);

        }//结果是将数组中的数从小到大排序