java学习之旅（day.05）

switch多选择结构

多选择结构还有一个实现方式就是switch case

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支

switch(expression){

​ case value:

​ //语句

​ break；

​ case value;

​ //语句

​ break；//可以有任意数量的case语句

​ default：

​ //语句

}

switch语句中的变量类型可以是：

• byte, short , int或char
• javaSE 7开始支持字符串类型了，同时，case标签必须为字符串常量或字面量

package com.zhang.structure;

public class SwitchDemo01 {
    public static void main(String[] args) {
        char grade ='C';
        //switch匹配一个具体的值
        switch (grade){
            case'A':
                System.out.println("优秀");
                break;
            case'B':
                System.out.println("良好");
                break;
            case'C':
                System.out.println("及格");
                break;
            default:
                System.out.println("未知");
        }
    }
}
====================================================
    package com.zhang.structure;

public class SwitchDemo02 {
    public static void main(String[] args) {
        String name ="张三";
        //JDK7的新特性，表达式结果可以是字符串
        //字符串的本质还是数字

        //反编译，java文件编译后生成class文件，class文件是字节码文件，人看不懂，
        //需要转为人看懂的文件，即反编译。工具用：IDEA
        //方法：打开Project Structure
        //     找到项目输出路径，可以据此找到class文件在哪，然后将class文件放到
        //对应的java文件中，就可以在IDEA中打开
        switch (name){
            case"张三":
                System.out.println("张三");
                break;
            case"李四":
                System.out.println("李四");
                break;
            default:
                System.out.println("不知道");
        }
    }
}

循环结构

• while循环
• do...while循环
• for循环
• 在java5中引入了一种主要用于数组的增强型for循环

while循环

while循环是最基本的循环，结构为：

while（布尔表达式）{

//循环内容

}

package com.zhang.structure;

public class WhileDemo01 {
    public static void main(String[] args) {
        //输出1-100
        int i=0;
        while(i<100){
            i++;
            System.out.println(i);
        }
    }
}
====================================================
    package com.zhang.structure;

public class WhileDemo02 {
    public static void main(String[] args) {
        //计算1+2+3+...100的和
        int i=0;
        int sum=0;
        while(i<100){
            i++;
            sum=sum+i;
            //++i;
        }
        System.out.println(sum);
    }
}

• 只要布尔表达式为true，循环会一直执行下去，但大多数情况会让循环停下来，我们需要一个让表达式失效的方式来结束循环
• 少部分情况需要循环一直执行，比如服务器的请求响应监听等

do while 循环

do while语句表达

do{

//代码语句

}while（布尔表达式）；

• 对于while循环而言，如不满足条件，则不能进入循环

• 有时即便不满足条件，我们也至少需要执行一次，此时，就要用到do...while循环，do...while与while循环相似，区别在与do...while至少执行一次

• while循环先判断后执行，do...while先执行，后判断。

  package com.zhang.structure;
  
  public class DoWhile01 {
      public static void main(String[] args) {
       //计算1+2+3+...100
       int i=1;
       int sum=0;
       do{
           sum=sum+i;
           i++;
       }while(i<=100);
          System.out.println(sum);
      }
  }
  
  

  For循环

  所有的循环后可以用while或do while表示，但java中的For循环会使一些循环结构变得更简单

  for循环语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构

  for循环的运行次数在执行前就是确定的。

  语法格式：

  for(初始化；布尔表达式，迭代更新){

  //代码语句

  }

  快速打出for循环：100.for

package com.zhang.structure;

public class ForDemo01 {
    public static void main(String[] args) {
        //初始化//条件判断//迭代更新
        //for(int i=0;i<=100;i++){
            //System.out.println(i);
        //最先执行初始化步骤，可声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句
        //然后检查布尔表达式的值，若为true，执行循环，若为false，循环终止，执行循环体后的内容
        //再次检查布尔表达式，执行循环
        //for（；；）死循环
        //==========================================================
        //计算0-100间所有基数和偶数的和
        // (我写的）
        int sum1=0;
        int sum2=0;
        for (int i = 0,s=1; i<100; i+=2,s+=2) {
            sum1=i+sum1;
            sum2=s+sum2;
            System.out.println(i);
            System.out.println(s);
        }
        System.out.println(sum1);
        System.out.println(sum2);
        //老师讲的
        //int oddsum=0;
        //int evensum=0;
        //for (int i = 0; i < 100; i++) {
        //    if(i%2!=0){
        //        oddsum+=i;
        //    }else{
        //        evensum+=i;
        //    }

        //}
        //System.out.println("奇数的和："+oddsum);
        //System.out.println("偶数的和："+evensum);
    }
    }
==================================================
    package com.zhang.structure;

public class ForDemo02 {
    public static void main(String[] args) {
        //用while或for语句输出1-1000间能被5整除的数，且每行输出三个
        for (int i = 0; i <=100; i++) {
            if (i%5==0){
                System.out.print(i+"\t");//空格
            }
            if (i%(3*5)==0){//每行3个
                System.out.println();//换行，也可用System.out.print(“\n”);
            }
//print与println的区别：print输出不会换行，println输出后会换行
        }
    }
}
====================================================
    package com.zhang.structure;

public class ForDemo03 {
    public static void main(String[] args) {
        //打印九九乘法表
        //1.打印第一列
        //2.把固定的1再用一个循环包起来，让1也成为变量
        //3.九行九列中有重复的，要去掉重复的
        //4.调整样式
        for (int j = 1; j <=9; j++) {
            for (int i = 1; i <=j; i++) {
                System.out.print(j+"*"+i+"="+(j*i)+"\t");
            }
            System.out.println();
        }
    }
}

增强for循环

数组的时候使用

增强for循环是一种主要用于数组或集合的

语法格式：

for（声明语句：表达式）

{

//代码句子

}

package com.zhang.structure;

public class ForDemo05 {
    public static void main(String[] args) {
        //增强for循环
       int[] numbers={10,20,30,40,50};//定义了一个数组
for (int x:numbers){//遍历数组的元素：把数组numbers中的每一个元素遍历出来赋值给x
    System.out.println(x);
}
        System.out.println("====================");
//一般的for循环
        for (int i = 0; i < 5; i++) {
            System.out.println(numbers[i]);
        }
    }
}

break 与continue

break:在任何循环语句的主体部分，均可用break控制循环的流程提前终止循环，break强行退出循环，不执行循环中剩余的语句。继续执行下面的语句

continue：用在循环语句中，提前结束本次循环，即跳过循环中尚未执行的语句，接着执行下一次是否执行循环的判定。循环结束后，继续执行下面的语句

package com.zhang.structure;

public class TestDemo01 {
    public static void main(String[] args) {
//打印三角形5行
        for (int i = 1; i <=5; i++) {
            for (int j = 5; j >=i; j--) {
                System.out.print(" ");
            }
            for (int j = 1;  j<=i; j++) {
                System.out.print("*");
            }
            for (int j = 1; j < i; j++) {
                System.out.print("*");
            }
            System.out.println();

                }

    }
}

方法

System.out.println（）

类 对象 方法

调用系统类里的标准输出对象out中的方法叫做println方法

• java方法是语句的集合，他们在一起执行一个功能
• 方法是解决一类问题的步骤的有序组合
• 方法包含于类或对象中
• 方法在程序中被创建，在其他方法被引用
• 设计方法的原则：一个方法只完成1个功能，这样有利于后期的扩展

package com.zhang.method;

public class Demo01 {
    //main方法
    public static void main(String[] args) {
     //int sum=add(1,2);
       // System.out.println(sum);
        test();
    }

    //加法
    public static int add(int a,int b){
    //修饰符 返回值类型
        return a+b;
    }
    public static void test(){
        for (int i = 0; i <=100; i++) {
            if (i%5==0){
                System.out.print(i+"\t");//空格
            }
            if (i%(3*5)==0){//每行3个
                System.out.println();//换行，也可用System.out.print(“\n”);
            }
//print与println的区别：print输出不会换行，println输出后会换行
        }
    }

}

方法的定义

• java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法

  修饰符 返回值类型 方法名（参数类型 参数名）{

  方法体

  return 返回值；

  }

• 方法包含一个方法头和方法体，下面是一个方法的所有部分：

  修饰符：是可选的（可以不写），告诉编译器如何调用该方法，定义该方法的访问类型

  返回值类型：方法可能返回值，有些方法执行所需的操作，但没有返回值，在这种情况下，returnValueType（返回值类型）是关键字void

  方法名：方法的实际名称，随便取，但要遵守规范：首字母小写驼峰原则

  参数类型：实参和形参

  ​ 实参：参数像个占位符，当方法被调用时，传递值给参数，这个值称为实参或变量（在方法被调用时用于接收外界输入的数据）

  ​ 形参：调用方法时实际传递给方法的数据

  参数列表是指方法的参数类型、顺序和参数个数。参数是可选的，方法可以不包含任何参数

package com.zhang.method;

public class Demo01 {
    //main方法
    public static void main(String[] args) {
        //实际参数：实际调用传递给他的参数
       int sum=add(1,2);
       System.out.println(sum);
        //test();
    }

    //加法
    //形式参数：用来定义作用的
    public static int add(int a,int b){
    //修饰符 返回值类型
        return a+b;
    }
    public static void test(){
        for (int i = 0; i <=100; i++) {
            if (i%5==0){
                System.out.print(i+"\t");//空格
            }
            if (i%(3*5)==0){//每行3个
                System.out.println();//换行，也可用System.out.print(“\n”);
            }
//print与println的区别：print输出不会换行，println输出后会换行
        }
    }

}

方法体：方法包含具体的语句，定义该方法的功能

返回值：如果方法存在返回值，一定要把返回值通过return这个关键词返回出去，如果是void就不用返回了

方法调用

• 调用方法：对象名.方法名（实参列表）
• java支持两种调用方法的方式，根据方法是否返回值来选择
  1. 当方法返回一个值得时候，方法调用通常被当做一个值。如：int larger =max（30，40）；
  2. 如果方法返回值是void，方法调用一定是一条语句

​ 如：System.out.println("hello,zhang“）；

package com.zhang.method;

public class Demo02 {
    public static void main(String[] args) {
int max=max(10,20);
        System.out.println(max);
    }
    //比大小
    public static int max(int num1,int num2){//形式参数
        int result=0;//这里result的初始化值写多少都行，后面会被覆盖
        if (num1==num2) {
            System.out.println("num1=num2");
            return 0;//return除了返回结果的意思，还有终止方法的作用
        }
        if(num1>num2){
            //这里写return会报错，一般return写到最外边，为了将num1返回出去，要定义一个变量result
            result=num1;
        }else{
            result=num2;
        }
return result;
    }
}

值传递（java）和引用传递

值传递和引用传递

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数

方法的重载原则：

• 方法名称必须相同
• 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）
• 方法的返回类型可以相同也可以不相同
• 仅仅返回类型不同不足以成为方法的重载

方法名称相同时，编译器会根据调用方法的参数个数，参数类型等逐个去匹配，以选择对应的方法，如果匹配失败，则编译器报错