java中的switch用法,循环,方法,数组以及类_java 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;
        }
    }
}

注意事项:

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(条件表达式){

        

        循环体语句;

        语句控制体;

}

代码实现:求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 循环适合判断次数不明确操作

public static void main(String[] args) {
     int x=1;
do {
System.out.println("HelloWorld");
 x++; 
    }while(x<=10); 
}

注意事项:

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

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

代码实现: 定义一个方法，该方法能够找出两个小数中的较小值并返回。

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

方法定义注意事项:

有返回值的方法调用:

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

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 ){}

数组

基本类型作为形式参数,形式参数不影响实际参数;

引用类型作为形式参数,形式参数的改变直接影响实际参数;

定义格式:

数组的初始化:

动态初始化:

静态初始化:

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

类与对象

类:

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

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

面向对象的思想特点:

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