java中的switch用法,循环,方法,数组以及类

编程小6 Java (3) 2024-05-18 20:12

Hi，大家好，我是编程小6，很荣幸遇见你，我把这些年在开发过程中遇到的问题或想法写出来，今天说一说java中的switch用法,循环,方法,数组以及类,希望能够帮助你!!!。

选择结构语句之switch:

switch
语句在开发过程中的使用仅次于
if
语句的使用.

switch语句:

switch
语句格式：

switch
(
表达式
) {

case
值
1
：

语句体
1
;

break
;

case
值
2
：

语句体
2
;

break
;

…

default
：

语句体
n
+
1
;

break
;

}

执行流程:

执行流程
switch接收结果,

接收的结果和case后面的值1进行对比,成立,执行语句1,break 结束语句;
值1和switch接收的结果不匹配,和值2进行比较,成立,执行语句2, break,结束语句;
如果上面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;
        }
    }
}

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%10;
            int shi=x/10%10;
            int bai=x/10/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%10;
            int shi=x/10%10;
            int bai=x/10/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<num){
                    System.out.println("您猜的值小了");
                }else{
                    System.out.println("您在第"+count+"次猜对了");
                    break;
                }
            }else{
                System.out.println("您的答题次数用完了!");
                break;
            }
        }
    }
}

方法概述:

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

方法的定义:

修饰符返回值类型方法名（参数列表）｛

代码（方法体）
...

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]完成了哪些事情?

在栈内存中,给int [] arr 变量开辟栈内存空间
new int [2] ,在堆内存申请空间
系统对数组内容进行默认初始化,int类型元素的默认值是0;
系统默认初始化完毕,产生一个堆内存空间地址值
将堆内存空间地址值赋值给栈内存变量arr
栈内存变量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<arr.length;i++){
            if (target==arr[i]){
                return i;
            }
        }
        return -1;

    }

    public static int getIndex2(int [] arr,int target){
        System.out.println("-------------------------");
        int index=-1;
        for (int i=0;i<arr.length;i++){
            if (target==arr[i]){
                index=i;
            }
        }
        return index;
    }
}

数组逆序:代码实现

分析:

角标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<end; start++,end--){
            int temp= arr[start];
            arr[start]= arr[end];
            arr[end]=temp;
        }
        extracted1(arr);
    }
}

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

分析:

   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;i<arr.length;i++){
            if (i==arr.length-1){
                System.out.println(arr[i]+"]");
            }else {
                System.out.print(arr[i]+", ");
            }
        }
    }
    public static int getMax(int [] arr){
        int max=arr[0];
        for (int i=1;i<arr.length;i++){
            if (arr[i]>max){
                max =arr[i];
            }
        }
        return max;
    }
    public static void getMin(int [] arr){
        int min=arr[0];
        for (int i=1;i<arr.length;i++){
            if (arr[i]<min){
                min=arr[i];
            }
        }
        System.out.println("最小值是:"+min);
    }
}

数组冒泡排序:代码实现

冒泡排序:
     两两比较,将较大的值往后放,第一次比较完毕,最大值出现在最大索引处;
   依次这样比较,可以得到排好序的数组;

  规律
   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;i<arr.length;i++){
            if (i==arr.length-1){
                System.out.println(arr[i]+"]");
            }else {
                System.out.print(arr[i]+", ");
            }
        }
    }
    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;
                }
            }
        }
        System.out.println("冒泡排序后:");
        printArray(arr);
    }
}

类与对象

类:

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

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

面向对象的思想特点:

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

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

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

类:代码中体现 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关键字的特点?

被private修饰的成员变量以及成员方法只能在本类中访问
可以修饰成员变量也可以成员方法,就是为了外界不能直接访问
被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();
    }

今天的分享到此就结束了，感谢您的阅读，如果确实帮到您，您可以动动手指转发给其他人。

java integer long 转换_long（Long）与int（Integer）之间的转换

Java实现发布订阅模式

发表回复取消回复

请先登录账户再评论哦

java中的switch用法,循环,方法,数组以及类

选择结构语句之switch:

注意事项:

case的穿透性:

循环结构语句:

循环语句:while

for循环和while循环的区别:

循环语句 do...while

注意事项:

跳出语句:

死循环:

方法概述:

方法定义注意事项:

有返回值的方法调用:

没有返回值的方法调用:

方法的重载:

数组

定义格式:

数组的初始化:

动态初始化:

静态初始化:

java中的内存分配:

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

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

数组逆序:代码实现

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

数组冒泡排序:代码实现

类与对象

类:

面向对象的思想特点:

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

java的重要特点:

学生事物:

面向对象的三大特征:

封装:

发表回复 取消回复

相关推荐

JavaScript提交表单

java二维数组初始化为0_怎样把java二维数组初始化为0

学习java心得体会(二)

2022最新Java面试宝典（史上最全，BAT大厂面试必备，用心看完该篇就够了，建议先关注点赞加收藏）

最新文章

JavaScript提交表单

java二维数组初始化为0_怎样把java二维数组初始化为0

学习java心得体会(二)

2022最新Java面试宝典（史上最全，BAT大厂面试必备，用心看完该篇就够了，建议先关注点赞加收藏）

Java实现发布订阅模式

java中的switch用法,循环,方法,数组以及类

java integer long 转换_long（Long）与int（Integer）之间的转换

最全 JavaScript Array 方法 详解

javascript网页特效（一）

盘点Java中常见的框架

发表回复取消回复

最全 JavaScript Array 方法详解