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

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