java学习_从switch到封装

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

  1. 共同点

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

  2. 不同点

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

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

二、switch语句

  1. 语法格式
switch(变量名){
	case1:
		语句1;
		break ;
	case2;	
		语句2;
		break ;
	....
	....
	....
	default:
		语句n;
		break ;
	}
  1. 执行流程
switch后面的变量需要和case进行匹配,case 值1:成立,执行语句1,
遇见break,switch语句结束;
	如果不匹配,继续执行case 值2:成立,执行语句2,break结束

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

三、for语句

  1. 格式

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

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

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

四、while语句

  1. 拓展格式

    初始化语句;
    	while(条件表达式){
    		循环体语句;
    		控制体语句;
    	}
    
  2. 执行流程

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

五、for和while循环的区别

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

六、do-while语句

  1. 格式

    do{
        循环体语句;
        控制体语句;
    }while(条件表达式) ;
    
  2. 特点

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

七、死循环

  1. 两种死循环

    两种死循环格式:
    			for(;;){
    				循环体语句;
    			}
    			
    			while(true){		//推荐使用
    				循环体语句;
    			}	
    
  2. 死循环的应用

    // 猜数游戏 
    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;//结束中断
                }
            }
        }
    }
    
    

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

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

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

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

九、方法

  1. 方法的两种定义形式

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

    在这里插入图片描述

十、方法重载

1.重载

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

2.可变参数

  1. java允许将同一个类中多个同名同功能但参数个数不同的方法,封装成一个方法。
    就可以通过可变参数实现

  2. 使用细节:
    1)可变参数的实参可以为0个或任意多个。
    2)可变参数的实参可以为数组。
    3)可变参数的本质就是数组.
    4)可变参数可以和普通类型的参数一起放在形参列表,但必须保证可变参数在最后
    5)一个形参列表中只能出现一个可变参数

  3. 基本语法:

    访问修饰符 返回类型 方法名(数据类型... 形参名){
        
    }
    
  4. 示例

    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.数组的初始化方式

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

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

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;
            }
        }
    }
}

十二、JVM的内存分配

  1. 栈、堆、方法区、寄存器

    1. 栈内存 所有的局部变量 以及方法在运行的时候都会在栈内存中开辟空间
      特点:先进后出 压栈与弹栈
    2. 堆内存 所有new 的资源 数组 对象都是在存在堆内存中
    3. 方法区 所有的字节码文件 class文件 以及静态资源都是存在方法区
      例如:public static native Thread currentThread();
    4. 本地方法区 所有使用native 都是存在本地方法区中,就是调用c/c++代码
    5. 程序计数器 主要用于控制代码的执行
    栈内存:
    	存储局部变量(在方法定义中或者方法声明上),局部变量跟方法有关的;方法进栈,方法调用完毕,里面局部变量随着调用结束而消失
    堆内存:
    	new出来的东西(引用数据类型)存储在堆中,而且它是随着对象的创建完毕,产生堆内存空间地址值!
    方法区:
    	里面很多的区域:class字节码文件区域---存储字节码文件---jvm需要加载这个类,解析这个类所有的方法以及变量(---这个过程"反射技术")
    				static区域:----静态区域--存储跟static相关的一些方法以及变量等等
    				constant pooll:常量池  里面存储常量相关的				
    本地方法区(了解): 和系统相关的----->创建系统资源完成系统相关的操作
    寄存器(了解):   和系统cpu都有关系:电脑的核数(16核/8核的)--核数越大,高并发场景下,运行效率越高;
    
  2. jvm架构图

    在这里插入图片描述

十三、面向对象

1. 面向对象思想的特点

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

2. 面向对象的三大特征

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

3. 面向对象的理念

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

十四、类

1. 定义

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

2. 举例

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

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

                //描述学事物的行为---->代码中书写--->成员方法
                //今天开始写成员方法--之前怎么写,现在还怎么写,自己分析有没有具体返回值类型
                //有没有参数,几个参数...
                //去掉static (一般类中的成员方法:称为 "非静态方法")
                public  void study(String className){ //JavaEE
                    System.out.println("正在学习"+className) ;
                }   
            }

十五、对象

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

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

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

十六、形式参数

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

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

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

十八、封装

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

十九、this关键字

  1. jvm会给每个对象分配一个this,代表当前对象。
    如:this.name 代表当前对象(new出来的对象是谁就指向谁)的属性name

  2. 注意事项

    • this关键字可以用来访问本类的属性、方法、构造器
    • this用来区分当前类的属性和局部变量
    • this不能在类定义的外部使用,只能在类定义的方法中使用。
  3. 访问语法 :

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

  1. 图解
    在这里插入图片描述
  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值