1. 金沙1005-js555888金沙老品牌
  2. 编程语言
  3. java

java中switch语句用法详解-金沙1005

思创斯忠实用户-ss • • java

java中switch语句用法详解_java定义数组并赋值switch,循环,方法,数组,类

选择结构语句之switch:

switch 语句在开发过程中的使用仅次于 if 语句的使用.
switch语句:
switch 语句格式：
switch ( 表达式 ) {
case 值 1 ：
语句体 1 ;
break ;
case 值 2 ：
语句体 2 ;
break ;
…
default ：
语句体 n 1 ;
break ;
}

执行流程:

执行流程
     switch接收结果,

  1.      接收的结果和case后面的值1进行对比,成立,执行语句1,break 结束语句;   
  2.      值1和switch接收的结果不匹配,和值2进行比较,成立,执行语句2, break,结束语句;
  3.      如果上面case都不匹配,执行default语句,语句n,break ,结束…

代码实现:键盘录入一个值,判断星期
                   1,星期一
                   2,星期二
                   3,星期三,
                   4,星期四
                   5,星期五
                   6,星期六
                   7,星期日

import java.util.scanner;
public class switchdemo {
    public static void main(string[] args) {
        scanner sc=new scanner(system.in);
        system.out.println("输入一个数据:");
        int week=sc.nextint();
        switch (week){
            case 1:
                system.out.println("星期一");
                break;
            case 2:
                system.out.println("星期二");
                break;
            case 3:
                system.out.println("星期三");
                break;
            case 4:
                system.out.println("星期四");
                break;
            case 5:
                system.out.println("星期五");
                break;
            case 6:
                system.out.println("星期六");
                break;
            case 7:
                system.out.println("星期日");
                break;
            default:
                system.out.println("非法数据");
                break;
        }
    }
}
java中switch语句用法详解_java定义数组并赋值

为防止网络爬虫，请关注公众号回复”口令”

激活idea 激活clion
datagrip dataspell
dotcover dotmemory
dottrace goland
phpstorm pycharm
resharper reshac
rider rubymine
webstorm 全家桶
switch 语句中，表达式的数据类型，可以是 byte ， short ， int ， char ， enum （枚举）， jdk7 以后可以接收字符串。

注意事项:

  • case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
  • default可以省略吗?可以省略。一般不建议。除非判断的值是固定的。(单选题)
  • break可以省略吗?可以省略，一般不建议。否则结果可能不是你想要的
  • default的位置一定要在最后吗?可以出现在switch语句任意位置。
  • switch语句的结束条件:
  • 遇到break
  • 执行到程序的末尾

case的穿透性:

在 switch 语句中，如果 case 的后面不写 break ，将出现穿透现象，也就是不会在判断下一个 case 的值，直接向后运 行，直到遇到break ，或者整体 switch 结束。
public static void main ( string [] args ) {
int i = 1 ;
switch ( i ){
case 0 :
system . out . println ( “语句体1 “ );
break ;
case 1 :
system . out . println ( “语句体2 “ );
case 2 :
system . out . println ( “语句体3 “ );
default :
system . out . println ( “语句体4 “ );
}
}
        

循环结构语句:

循环概述:

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false ，从而结束循环，否则循环将一直执行下去，形 成死循环。

for循环: 

格式:

for(初始化语句;条件表达式;控制体语句){

                循环体语句;

}

使用最多 (求和思想,统计思想)

代码实现:for循环求水仙花数

public class shuixianhua {
    public static void main(string[] args) {
        int count=0;
        system.out.println("水仙花数是:");
        for (int x=100;x<1000;x  ){
            int ge=x;
            int shi=x/10;
            int bai=x/10/10;
            if (x==ge*ge*ge shi*shi*shi bai*bai*bai){
                count  ;
                system.out.println(x);
            }
        }
        system.out.println("共有" count "个");
    }
}

循环语句:while

while语句格式:

初始化语句 ;
while(条件表达式){
        
        循环体语句;
        语句控制体;
}
代码实现:求1~100的和 
public class whiledemo {
    public static void main(string[] args) {
        int i=1;
        int sum=0;
        while(i<=100){
           
            sum=sum i;
            i  ;
        }
        system.out.println("1~100之间的和为" sum);
    }
}

利用while循环求水仙花数:

public class whiledemo3 {
    public static void main(string[] args) {
        int x = 100;
        int count=0;
        while(x>=100&&x<1000){
            int ge=x;
            int shi=x/10;
            int bai=x/10/10;
            if(x==ge*ge*ge shi*shi*shi bai*bai*bai){
                system.out.println("水仙花数是:" x);
                count   ;
            }
            x  ;
        }
        system.out.println("水仙花数共有" count "个");
    }
}

for循环和while循环的区别:

for 循环语句和 while 循环语句可以等价转换，但还是有些小区别的使用区别：
控制条件语句所控制的那个变量，在 for 循环结束后，就不能再被访问到了，而 while 循环结束还可以继续使用，如 果你想继续使用，就用while ，否则推荐使用 for 。原因是 for 循环结束，该变量就从内存中消失，能够提高内存的使 用效率。
场景区别：
for 循环适合针对一个范围判断进行操作 while 循环适合判断次数不明确操作

循环语句 do…while

初始化语句 ;
do {
循环体语句 ;
控制条件语句 ;
} while (( 判断条件语句 );
public static void main(string[] args) {
     int x=1;
do {
system.out.println("helloworld");
 x  ; 
    }while(x<=10); 
}

注意事项:

do…while 循环的特点：无条件执行一次循环体，即使我们将循环条件直接写成 false ，也依然会循环一次。这样的 循环具有一定的风险性

跳出语句:

break :        中断,结束(循环或者switch中用)

continue:    结束当前循环,立即进入下一次循环.

return:        结束方法用的.

死循环:

import java.util.scanner;
public class dielopperdemo {
    public static void main(string[] args) {
        system.out.println("进行猜数字游戏.数值值在1~100之间");
        //产生一个1~100之间的随机数   random()产生的随机数在0.0~1.0之间 [0.0,1.0)
        int num= (int) (math.random()*100 1);
        int count=0;
        while(true){
            count  ;//记录猜数字的次数
            //if 判断  限定猜题次数
            if(count<=5){
                system.out.println("输入你的数据:");
                //创建键盘录入数据对象
                scanner sc=new scanner(system.in);
                int gussnumber=sc.nextint();
                if (gussnumber>100||gussnumber<0){
                    system.out.println("您输入的数据不合法,数据在1~100之间");
                }else if(gussnumber>num){
                    system.out.println("您猜的值大了");
                }else if(gussnumber

 方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。 当我 们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。 (方法就是完成特定功能的代码块)

方法的定义:

修饰符 返回值类型 方法名 （参数列表）｛
代码（方法体） …
return ;
｝
代码实现: 定义一个方法，该方法能够找出两个小数中的较小值并返回。
import java.util.scanner;
public class demo4 {
    public static void main(string[] args) {
        scanner sc=new scanner(system.in);
        system.out.println("输入第一个小数:");
        double num1=sc.nextdouble();
        system.out.println("输入第二个小数:");
        double num2=sc.nextdouble();
        double decimal = getdecimal(num1, num2);
        system.out.println("最大值是:" decimal);
    }
    public static double getdecimal(double a,double b){
        double min;
        if(a>b){
            min=b;
        }else {
            min=a;
        }
        return min;
    }
}

方法定义注意事项:

方法不调用不执行
方法与方法是平级关系，不能嵌套定义
方法定义的时候参数之间用逗号隔开
方法调用的时候不用在传递数据类型
如果方法有明确的返回值，一定要有 return 带回一个值

有返回值的方法调用:

代码实现:比较两个数据是否相等;

import java.util.scanner;
public class demo5 {
    public static void main(string[] args) {
        scanner sc=new scanner(system.in);
        system.out.println("输入第一个数据:");
        double  num1=sc.nextdouble();
        system.out.println("输入第二个数据:");
        double num2=sc.nextdouble();
        boolean equal = getequal(num1, num2);
        system.out.println("两个数据相等吗?" equal);
    }
    public static boolean getequal(double a,double b){
        boolean flag=(a==b);
        return flag;
    }
}

没有返回值的方法调用:

代码实现:nn乘法表

import java.util.scanner;
public class demo6 {
    public static void main(string[] args) {
        scanner sc=new scanner(system.in);
        system.out.println("输入:");
        int n1=sc.nextint();
        getride(n1);
    }
    public static void getride(int a){
        for (int n =1;n<=a;n  ){
            for (int j=1;j<=n;j  ){
                system.out.print(n "*" j "=" (n*j) "\t");
            }
            system.out.println();
        }
    }
}

方法的重载:

方法名相同,与返回值的类型无关,参数列表不同(参数类型不同,参数个数不同,参数顺序不同)

例如:
public static void open (){}
public static void open ( int a ){}
static void open ( int a , int b ){}
public static void open ( double a , int b ){}
public static void open ( int a , double b ){}
public void open ( int i , double d ){}
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。
基本类型作为形式参数,形式参数不影响实际参数;
引用类型作为形式参数,形式参数的改变直接影响实际参数;

定义格式:

数据类型 [] 数组名 ;
数据类型 数组名[];

数组的初始化:

动态初始化:

初始化时只指定数组长度，由系统为数组分配初始值
格式：数据类型 [] 数组名 = new 数据类型 [ 数组长度 ];
数组长度其实就是数组中元素的个数。
举例：
int[] arr = new int[3];

静态初始化:

初始化时指定每个数组元素的初始值，由系统决定数组长度。
格式：
数据类型 [] 数组名 = new 数据类型 []{ 元素 1, 元素 2,…};
举例：
int[] arr = new int[]{1,2,3};
简写格式:int [] arr={1,2,3};

java中的内存分配:

栈:存放局部变量(现进后出)
堆:new出来的对象存储在这个区域(.创建的新对象放在堆中)
方法区:     .class文件(字节码文件)—方法调用过程需要加载类(里面存储了很多的方法,这些方法被调用,加载进栈内存)
            static区域
            常量池区域
寄存器:本地方法区,和cpu,系统有关

int [] arr=new int[2]完成了哪些事情?

  1. 在栈内存中,给int [] arr 变量开辟栈内存空间
  2. new int [2] ,在堆内存申请空间
  3. 系统对数组内容进行默认初始化,int类型元素的默认值是0;
  4. 系统默认初始化完毕,产生一个堆内存空间地址值
  5. 将堆内存空间地址值赋值给栈内存变量arr
  6. 栈内存变量arr指向堆内存空间地址

查询一个数组中元素的第一次出现的索引值,代码实现:

分析:
               1. 定义一个方法
                   方法的返回值 int
                   方法的参数类型和参数个数
                   int[],查询的具体的元素   2个参数
                2.
                     遍历数组,获取所有元素
                     判断:如果要查询的元素和数组的中元素一致,就找到了
                     返回角标值

import java.util.scanner;
public class demotest {
    public static void main(string[] args) {
        int [] arr={12,56,45,96,78};
        scanner sc=new scanner(system.in);
        system.out.println("输入元素:");
        int num1=sc.nextint();
        int index = getindex(arr,num1);
        system.out.println("index:" index);
        system.out.println("输入元素:");
        int num2=sc.nextint();
        int index1 = getindex(arr, num2);
        system.out.println("没有该元素" index1);
        system.out.println("输入元素:");
        int num3=sc.nextint();
        int index2 = getindex2(arr, num3);
        system.out.println("index:" index2);
    }
    public static int getindex(int [] arr,int target){
        for (int i=0;i

数组逆序:代码实现

分析:

角标x = 0 ,
        将arr[0]元素和arr[arr.length-1-0] 互换
        arr[1]元素和arr[arr.length-1-1] 互换
        arr[2]元素和arr[arr.length-1-2] 互换

public class demotest2 {
    public static void main(string[] args) {
        int [] arr={15,56,89,78,65};
        system.out.println("逆序前:");
        extracted1(arr);
        system.out.println("逆序后:");
        extracted(arr);
    }
    private static void extracted1(int[] arr) {
        system.out.print("[");
        for (int i = 0; i< arr.length; i  ){
            if(i== arr.length-1){
                system.out.println(arr[i] "]");
            }else {
                system.out.print(arr[i] ", ");
            }
        }
    }
    private static void extracted(int[] arr) {
        for (int start = 0, end = arr.length-1; start

求数组最大,最小值:代码实现

 分析:
 
       int[] array = {65,45,76,87,13} ;
 
       1.定义一个参照物  array[0]就是最大值   
       2.从角标1开始遍历数组的其他元素
       3.判断:使用后面的元素依次和参照物比较
                  如果后面元素比参照物,将最大值修改了
       4.获取最大值;

public class demotest4 {
    public static void main(string[] args) {
        int [] arr={12,45,56,78,98};
        printarray(arr);
        int max = getmax(arr);
        system.out.println("最大值是:" max);
        getmin(arr);
    }
    public static void printarray(int [] arr){
        system.out.print("[");
        for (int i=0;imax){
                max =arr[i];
            }
        }
        return max;
    }
    public static void getmin(int [] arr){
        int min=arr[0];
        for (int i=1;i

数组冒泡排序:代码实现

java中switch语句用法详解_java定义数组并赋值

冒泡排序:
          两两比较,将较大的值往后放,第一次比较完毕,最大值出现在最大索引处;
          依次这样比较,可以得到排好序的数组;
 
  规律
       1.两两比较,将较大的值往后放,
       2.第一次有0个不比
         第二次有1个不比
         ….
         每次比较,就会减少一次比较
        比较的次数:数组长度-1次

public class demotest3 {
    public static void main(string[] args) {
        int [] arr={65,95,46,48,15};
        system.out.println("排序前:");
        printarray(arr);
        bubblesort(arr);
    }
    public static void printarray(int [] arr){
        system.out.print("[");
        for (int i=0;iarr[j 1]){
                    int temp=arr[j];
                    arr[j]=arr[j 1];
                    arr[j 1]=temp;
                }
            }
        }
        system.out.println("冒泡排序后:");
        printarray(arr);
    }
}

类:

能够描述现实世界事物一组属性和行为的集合

类和事物的关系:一一对应;

面向对象的思想特点:

  1. 更符合生活中的思想行为习惯
  2. 让复杂的事情简单化
  3. 从执行者变成了指挥者

面向对象是基于面向过程的

面向对象里面的类和事物:

类:代码中体现      class  studnet()

事物:现实世界真实存在的东西

java的重要特点:

代码的健壮性(里面涉及java面向的对象特征以及java设计模式)

成员变量与局部变量:

成员变量:类中方法外

局部变量:方法中

学生事物:

        属性:(成员变量)姓名,年龄,性别……

        行为:(成员方法)学习,玩,吃……

代码体现:

public class studenttest {
    public static void main(string[] args) {
        student s=new student();
        s.name="蔡同斌";
        s.sex="男";
        s.age=21;
        s.hair="三七分";
        system.out.println("姓名:" s.name "; 性别:" s.sex "; 年龄:" s.age "; 发型" s.hair);
        s.eat("兰州牛肉面");
        s.smoke("黑兰州");
        s.play("英雄联盟");
        s.study();
    }
}
class student{
    string name;
    string sex;
    int age;
    string hair;
    public void eat(string toname){
        system.out.println(name "早晨喜欢吃" toname);
    }
    public void smoke(string toname){
        system.out.println("吃完饭,习惯抽一根" toname);
    }
    public void play(string toname){
        system.out.println("喜欢玩" toname);
    }
    public void study(){
        system.out.println("玩结束了,开始学习javaee");
    }
}

面向对象的三大特征:

封装,继承,多态

封装:

  private关键字的特点?

  1.  被private修饰的成员变量以及成员方法只能在本类中访问
  2.  可以修饰成员变量也可以成员方法,就是为了外界不能直接访问
  3.  被private修饰的成员变量/成员方法可以间接的通过通过的方法访问;

代码实现:

public class student {
    private string name;
    private int age;
    private string sex;
    public void setname(string a){
        name=a;
    }
    public void setage(int b){
        age=b;
    }
    public void setsex(string c){
        sex=c;
    }
    public string getname(){
        return name;
    }
    public int getage(){
        return age;
    }
    public string getsex(){
        return sex;
    }
    public void show(){
        system.out.println("姓名:" name ";  年龄:" age ";  性别:" sex);
    }
    private void study(string toname){
        system.out.println("开始学习" toname);
    }
    private void play(string toname){
        system.out.println("喜欢玩" toname);
    }
    public void method(){
        study("javaee");
        play("英雄联盟");
    }
}

测试类:

public class studenttest {
    public static void main(string[] args) {
        student s=new student();
        s.setname("高圆圆");
        s.setage(42);
        s.setsex("女");
        s.show();
        s.method();
    }
js555888金沙老品牌的版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由思创斯整理,转载请注明出处：https://ispacesoft.com/141675.html

赞 (0)
思创斯忠实用户-ss思创斯忠实用户-ss
0

相关推荐

  • java

    js 闭包传参_javascript闭包演示[通俗易懂]有个网友问了个问题，如下的html，为什么每次输出都是5，而不是点击每个p，就alert出对应的1，2，3，4，5。闭包演示functioninit(){varpary=document.getelementsbytagname(“p”);for(vari=0;ipary[i].onclick=function(){alert(i);}}}产品一产品二产品三产品四产品五解决方…

    思创斯忠实用户-ss 思创斯忠实用户-ss
    2023年1月15日
  • java

    java拖拽排序工具类packagecom.ciih.jwt.util.sort;importjava.lang.reflect.field;importjava.util.collections;importjava.util.list;/***拖拽排序工具:此工具将传入的list重新排序后返回,使用者只需要将list重新存入数据库即可完成排序.*<>*拖拽排序必然牵扯到两个元素,被拖拽的元素和被挤压的元素.排序方式就存在两种,一种是两个元素进行交换位置,一种是一个元素拖到.

    思创斯忠实用户-ss 思创斯忠实用户-ss
    2022年11月21日
  • java

    java中的字节流「建议收藏」字节流2.1io流概述和分类按数据流向:输入流，输出流按数据类型：字节输入流/输出流，字符输入流/输出流2.1io流概述和分类##io流概述：io：输入/输出（input/ouput）流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输io流就是用来处理设备间数据传输问题的常见的应用：文件复制，文件上传，文件下载按数据流向:输入流，输出流输入流为读数据，输出流为写数据按数据类型：字节输入流/输出流，字符输入流/输出流一般来说是按数据类型来分的。

    思创斯忠实用户-ss 思创斯忠实用户-ss
    2022年11月19日
  • java

    基本数据类型-java学习日记1.不同进制的数据组成 二进制： 由0,1组成。以0b开头 八进制： 由0,1,…7组成。以0开头 十进制：由0,1,…9组成。整数默认是十进制 十六进制： 由0,1,…9,a,b,c,d,e,f(大

    思创斯忠实用户-ss 思创斯忠实用户-ss
    2023年2月24日
  • java

    java框架常见的面试题有哪些_ssm三大框架面试题java框架常见的面试题spring什么是spring?使用spring框架的好处是什么?spring由哪些模块组成?什么是springbeans?解释spring支持的几种bean的作用域spring框架中的单例bean是线程安全的吗?解释spring框架中bean的生命周期依赖注入di控制反转iocaopaop中的概念spring中的aop底层实现原理springmvcspringmvc…

    思创斯忠实用户-ss 思创斯忠实用户-ss
    2022年12月27日
  • java

    java中collections.sort()的使用!java中collections.sort()的使用!在日常开发中，很多时候都需要对一些数据进行排序的操作。然而那些数据一般都是放在一个集合中如：map，set，list等集合中。他们都提共了一个排序方法sort()，要对数据排序直接使用这个方法就行，但是要保证集合中的对象是可比较的。怎么让一个对象是可比较的，那就需要该对象实现comparable接口啦。然后重写里面的co

    思创斯忠实用户-ss 思创斯忠实用户-ss
    2022年12月15日
  • java

    arcgis api for javascript 4.x documentation–tool(一)–import data as a feature layer「建议收藏」
    将数据作为要素图层导入 一.简要描述 可以在开发者仪表板和arcgis online将数据作为托管层导入和存储到云上。比如csv、geojson这种既有几何又有属性的文件，可以导入作为托管要素图层。要素图层用来存储带有属性的点、线、面。 2.步骤 1.下载数据 1)下载并解压数据，shp不要解压。 …

    思创斯忠实用户-ss 思创斯忠实用户-ss
    2022年8月4日
  • java

    java char转intchar类型的数据转换成int类型的数字。本能反应是这么写的。publicstaticvoidmain(string[]args){charc=’1′;//本能反应是这么写的。inti=c;//或者这么写inti1=(int)c;system.out….

    思创斯忠实用户-ss 思创斯忠实用户-ss
    2022年12月18日

发表回复

您的电子邮箱地址不会被公开。

联系金沙1005

关注“java架构师必看”公众号

回复4，添加站长微信。

附言：ispacesoft.com网而来。

关注微信
网站地图