AI编程探险家

这个屌丝很懒，什么也没留下！

热门标签

java学习_从switch到封装_java的swith函数

作者：AI编程探险家 | 2024-02-06 11:14:06

踩

java的swith函数

一、if…else…和三元运算符的区别

共同点

都是针对两种情况进行判断,都有表达式;
不同点

if…else…流程控制语句,范围很大,不仅仅可以操作数据值,还可以操作输出语句去完成逻辑判断;而三元运算符仅仅是运算符,操作两个具体的数据值;

三元运算符能实现的一定能够使用if…else…流程语句
if…else…流程语句实现的,不一定能够使用三元运算符

二、switch语句

语法格式

switch(变量名){
	case 值1:
		语句1;
		break ;
	case 值2;	
		语句2;
		break ;
	....
	....
	....
	default:
		语句n;
		break ;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

执行流程

switch后面的变量需要和case进行匹配,case 值1:成立,执行语句1,
遇见break,switch语句结束;
	如果不匹配,继续执行case 值2:成立,执行语句2,break结束
1
2
3

switch语句后面的这个变量名的数据类型：
本身能够跟的基本数据类型:byte,short,char,int
Jdk5以后可以是枚举(引用类型) enum
JDK7以后可以跟String类型

三、for语句

格式

for(初始化语句;条件表达式;控制体语句){
    //实际开发中,此处需要去完成一些逻辑判断
    循环体语句;
}
1
2
3
4

执行流程

执行流程:
	1)初始化语句,对变量进行赋值,
	2)条件表达式判断结果是否成立,成立,则执行循环体语句,进行控制体语句++或者--
	3)继续判断条件表达式是否成立,成立,继续上面这种操作...
		...
		...
	如果控制体语句造成了条件表达式不成立,语句结束!
1
2
3
4
5
6
7

for循环的嵌套

for(初始化语句1;条件表达式1;控制体语句1){
    for(初始化语句2;条件表达式2;控制体语句2){
        循环体语句.....
    }
}
1
2
3
4
5

四、while语句

拓展格式

初始化语句;
	while(条件表达式){
		循环体语句;
		控制体语句;
	}
1
2
3
4
5

执行流程

1)初始化语句进行变量赋值,执行一次;
2)判断条件表达式是否成立,成立,执行循环体语句,依次执行控制体语句;
3)再次回到2)继续操作
	...
	...
当条件表达式不成立,while循环结束
1
2
3
4
5
6

五、for和while循环的区别

1)从用法格式上看,格式不同
		for(初始化语句;条件表达式;控制体语句){
			循环体语句;
		}	
        
		初始化语句;
		while(条件表达式){
			循环体语句;
			控制体语句;
		}
2)是否明确循环次数(开发中,优先使用for)
		如果需求明确了循环次数,优先使用for循环,工程上的for循环使用最多的!
		如果不明确循环次数,使用while循环  
3)从内存角度考虑,for循环更优一些,比较节省内存空间	
		从for循环本身的格式上来说,for循环结束,里面的局部变量(方法定义中的变量)就被及时的释放空间!
		while循环格式,结束之后,依然能够去访问那个变量,(比较消耗内存空间)所以相对来说whle循环没有for循环好
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

六、do-while语句

格式

do{
    循环体语句;
    控制体语句;
}while(条件表达式) ;
1
2
3
4

特点

和for,while最大的区别就是:即使条件不成立,循环体至少执行一次
1

七、死循环

两种死循环

两种死循环格式:
			for(;;){
				循环体语句;
			}
			
			while(true){		//推荐使用
				循环体语句;
			}	
1
2
3
4
5
6
7
8

死循环的应用

// 猜数游戏 
import java.util.Scanner;

public class WhileTest {
    public static void main(String[] args) {
        //1)产生一个1-100之间的随机数 通过刚才的Math.random() *100+1 --->int
        int number = (int) (Math.random() * 100 + 1);

        //定义统计变量
        int count = 0;

        while (true) {//死循环格式
            count++;//统计变量++

            //2)2)不断的键盘录入一个数据,guessNumer(使用死循环while(true)),不明确循环次数

            //创建键盘录入对象
            Scanner sc = new Scanner(System.in);

            System.out.println("请输入您要猜的数字:");
            int guessNumber = sc.nextInt();

            if (guessNumber <= 0 || guessNumber > 100) {
                System.out.println("录入的数据不合法");
                break;
            } else if (guessNumber > number) {
                //提示"大了"
                System.out.println("你要猜的" + guessNumber + "大了");
            } else if (guessNumber < number) {
                提示"小了"
                System.out.println("你要猜的" + guessNumber + "小了");
            } else {
                System.out.println("恭喜您,第" + count + "次猜中了");
                break;//结束中断
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

八、跳转控制语句break,continue,return(和方法定义有关)

1. break:结束,中断,不能单独使用!一般在循环语句(loop),或者是switch语句中用,不能超过这个范围去使用;

2. continue  结束当前循环,立即进入下一次 循环! (不能单独用,在循环中用)

3. return:是在Java中跟定义方法相关的,跟有返回值类型的方法有关
1
2
3
4
5

九、方法

方法的两种定义形式

1.方式一：有返回值类型的方法定义
    固定格式:
        有返回值类型的方法定义(在需求中需要根据实际场景需要返回值类型:数据类型)
        
        权限修饰符 static 返回值类型 方法名(参数类型1 参数名称1,参数类型2 参数名称2....){
        //完成的方法逻辑操作
        return 结果;
        }
    调用方式：1.输出调用
    		2.赋值调用
    		3.单独调用
        
    方式二：无返回值的方法定义
    固定格式
    	无返回值的方法定义
         权限修饰符 static void 方法名(参数类型1 参数名称1,参数类型2 参数名称2....){
         完成的方法逻辑操作
         }
        
    调用方式：1.单独调用
    		

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

执行流程

十、方法重载

1.重载

概念：方法名相同，而参数不同（类型、个数或者顺序不一样）,与有无返回值及返回值类型无关
如System.out.println()可以传不同的参数，构成重载

2.可变参数

java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。
就可以通过可变参数实现
使用细节：
1)可变参数的实参可以为0个或任意多个。
2)可变参数的实参可以为数组。
3)可变参数的本质就是数组.
4)可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
5)一个形参列表中只能出现一个可变参数

基本语法：

访问修饰符 返回类型 方法名(数据类型... 形参名){
    
}
1
2
3

示例

public class VarParameter {
    public static void main(String[] args) {
        var p = new var();
        System.out.println(p.sum(3, 5));
        System.out.println(p.sum1(23, 34, 2));
    }
}

class var {
    public int sum(int a, int b) {
        return a + b;
    }

    public int sum(int a, int b, int c) {
        return a + b + c;
    }

    public int sum(int a, int b, int c, int d) {
        return a + b + c + d;
    }

    //使用可变参数，简化代码
    // 可变参数可以当成数组使用
    public int sum1(int... nums) {
        int res = 0;
        for (int i = 0; i < nums.length; i++) {
            res += nums[i];
        }
        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

十一、数组

1. 概念

数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。

2.数组的初始化方式

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
int[] arr = new int[3];
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
int[] arr1 = {11,22,33};
1
2
3
4

3. 数组之冒泡排序

/**冒泡排序思想:
	   两两比较,如果前面的元素比后面元素大,将前面的元素往后放(较大的值往后走),第一次比较完毕,最大值就出现在最大索引处;依次这样比较,就可以得到一个排好序的数组!
	   规律:
	   	两两比较,如果前面的元素比后面元素大,将前面的元素往后放;
	   	第一次比较:有0个不比,都得比
	   	第二次比较:有1个不比
	   	...
	   	每次比较一次,下一次就减少一次比较的次数
	   	最终比较的次数:数组长度-1次
*/
public static void bubbleSort(int[] arr){
    for(int i =0;i<arr.length-1;i++){//比较的次数
        //每次比较一次,下一次就减少一次比较的次
        for(int j = 0;j<arr.length-1-i;j++){
            //	两两比较,如果前面的元素比后面元素大,将前面的元素往后放;
            if(arr[j]>arr[j-1]){
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

十二、JVM的内存分配

栈、堆、方法区、寄存器

栈内存所有的局部变量以及方法在运行的时候都会在栈内存中开辟空间
特点：先进后出压栈与弹栈
堆内存所有new 的资源数组对象都是在存在堆内存中
方法区所有的字节码文件 class文件以及静态资源都是存在方法区
例如:public static native Thread currentThread();
本地方法区所有使用native 都是存在本地方法区中，就是调用c/c++代码
程序计数器主要用于控制代码的执行

栈内存:
	存储局部变量(在方法定义中或者方法声明上),局部变量跟方法有关的;方法进栈,方法调用完毕,里面局部变量随着调用结束而消失
堆内存:
	new出来的东西(引用数据类型)存储在堆中,而且它是随着对象的创建完毕,产生堆内存空间地址值!
方法区:
	里面很多的区域:class字节码文件区域---存储字节码文件---jvm需要加载这个类,解析这个类所有的方法以及变量(---这个过程"反射技术")
				static区域:----静态区域--存储跟static相关的一些方法以及变量等等
				constant pooll:常量池  里面存储常量相关的				
本地方法区(了解): 和系统相关的----->创建系统资源完成系统相关的操作
寄存器(了解):   和系统cpu都有关系:电脑的核数(16核/8核的)--核数越大,高并发场景下,运行效率越高;
1
2
3
4
5
6
7
8
9
10

jvm架构图

十三、面向对象

1. 面向对象思想的特点

    1)更符合现实生活中的思想行为习惯
    2)让复杂的事情简单化
    3)角色发生了改变:从执行者(面向过程)--->变成指挥者(面向对象)
面向过程:亲力亲为
面向过程:找一个懂行的人帮助我干这件事情(对于这个人--->面向过程)
1
2
3
4
5

2. 面向对象的三大特征

面向对象的三大特征:封装,继承,多态(面向对象重点)

3. 面向对象的理念

不断的创建对象,使用对象,指挥对象做事情!(面对对象的宗旨)
如：一直用的Scanner:键盘录入
Scanner sc = new Scanner(System.in) ;
//sc.nextInt() ; sc.nextLine();
sc.nextBoolean();

十四、类

1. 定义

类:是Java语言中最基本的单元;能够描述现实世界事物的一组事物的属性和行为的集合!
类和现实世界事物是一一对应的关系;
1
2

2. 举例

现实世界事物---学生事物
    属性:学生的姓名,学生的年龄,学生的性别....
        行为:主要就是学习

            使用Java语言来描述出来的学生事物------>定一个类----学生类
            class Student{
                //描述学事物的属性---(代码里面--->成员变量)
                //成员变量:是在类中,方法外!
                String name ;
                int age ;
                String sex ;

                //描述学事物的行为---->代码中书写--->成员方法
                //今天开始写成员方法--之前怎么写,现在还怎么写,自己分析有没有具体返回值类型
                //有没有参数,几个参数...
                //去掉static (一般类中的成员方法:称为 "非静态方法")
                public  void study(String className){ //JavaEE
                    System.out.println("正在学习"+className) ;
                }   
            }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

十五、对象

对象:描述现实世界的具体事物!(具体事物的具体的属性和行为)
	现实世界的事物---是很概括性的; 
	学生事物----->姓名,年龄,性别----是谁? 不知道,

需要描述具体的事物------> 具体学生 张三 25 男 /  李四 20 女

在代码中体现出来具体事物----->需要记住Java中的创建类对象的格式
	类名 对象名 =  new 类名() ;
	对象名.成员变量名 = 值 (根据成员变量的类型赋值);   访问成员变量 赋值
	对象名.方法名();  访问我们自己的定义的成员方法,去使用它,展示数据或者实现具体业务需求
1
2
3
4
5
6
7
8
9
10

十六、形式参数

	局部变量的生命周期:(方法定义中,或者方法声明上):局部变量随着方法调用而存在,随着方法调用结束而消失
	形式参数如果是基本数据类型,形式参数的改变不影响实际参数!后面特殊的引用数据类型:String,作为形式参数和基本类型数效果一致!
	引用类型作为形式参数,形式参数的改变是直接影响实际参数的,
	因为引用数据类型(数组,类,接口),是一种空间地址值进行传递,而基本数据类型只是数据值进行传递(随着方法调用存在,调用结束而消失)而引用类型---需要new--->需要在堆内存中开辟空间,对象使用完了,不会立即被回收,需要等待gc垃圾回收器空闲时刻自己回收!对象一旦被创建,永远指向那个地址值,除非重新new对象
1
2
3
4

十七、局部变量和成员变量的区别

局部变量和成员变量有什么区别?
       1)书写位置的区别
           局部变量:在方法定义中或者方法声明上的变量
           成员变量:类中方法外!
           实际开发中:根据具体的情况具体使用,范围越小越好,因为范围小,使用完,释放内存了!
       2)内存位置不同
            局部变量:在栈内存中---跟方法有关(方法进栈)
            成员变量:在堆内存中---跟对象有关  (类名 对象名 = new 类名();)
       3)生命周期不同:
             局部变量:随着方法调用而存在,随着方法调用结束而消失
             成员变量:随着对象的创建而存在,随着对象的创建完毕后,使用完毕(访问成员变量/访问成员方法)之后等待
                           垃圾回收器空闲时候回收而消失!(不会立即释放)
       4)初始化值不同
             局部变量:在使用之前必须初始化,否则报错
             成员变量:跟对象有关系,存在系统默认初始化,然后可以显示初始化 对象名.成员变量名=赋值;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

十八、封装

封装的步骤
将属性进行私有化private【不能直接修改属性】
提供一个公共的(public) set方法，用于对属性判断并赋值
提供一个公共的(public) get方法，用于获取属性的值

十九、this关键字

jvm会给每个对象分配一个this，代表当前对象。
如：this.name 代表当前对象（new出来的对象是谁就指向谁）的属性name
注意事项
- this关键字可以用来访问本类的属性、方法、构造器
- this用来区分当前类的属性和局部变量
- this不能在类定义的外部使用，只能在类定义的方法中使用。
访问语法：

访问成员方法 this.方法名(参数列表);
访问构造器（只能在构造器中使用） this(参数列表）;

图解

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AI编程探险家/article/detail/62437