1. 云图网首页
  2. 技术专区
  3. Java

Java零基础入门学习Day[3]

• Java


Java选择结构语句

java的选择结构语句有两种:if语句和Switch语句/

一.IF语句

if语句:

一个if语句包含一个布尔表达式和一条或多条语句

if语句语法:

if(布尔表达式)
{
       //如果布尔表达式为true将执行的语句          
}

如果布尔表达式的值为ture,则执行if语句中的代码.否则将执行if语句后面的代码.

public class Test{
    public static void main(String[] args){
        int i = 10;
        if(i < 11){
            System.out.println("这是一个if语句");
        }
    }
}

以上的代码编译运行结果如下:

Java零基础入门学习Day[3]

 

 

 

if…else语句:

if语句后面可以跟else语句,当if语句的布尔表达式值为false时,else语句块会被执行.

语法

if…else语句用法如下:

if(布尔表达式){
    //如果布尔表达式的值为true
}else{
    //如果布尔表达式的值为false
}

实例:

public class Test{
    public static void main(String[] args){
        int i = 10;
        if(i != 10){
            System.out.println("这是if语句");
        }else{
            System.out.println("这是else语句");
        }
    }
}

运行结果如下:

Java零基础入门学习Day[3]

 

 

 

if…else  if…else语句

if语句后面可以跟else if…else语句,这种语句可以检测到多种可能的情况.

使用if…else if…else语句的时候需要注意一下几点:

  • if语句至多有一个else语句,else语句在所有else if语句之后.
  • If 语句可以有若干个 else if 语句，它们必须在 else 语句之前.
  • 一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行.

if…else if…else语法如下:

if(布尔表达式 1){
   //如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
   //如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
   //如果布尔表达式 3的值为true执行代码
}else {
   //如果以上布尔表达式都不为true执行代码
}

实例:

public class Test {

   public static void main(String args[]){
      int i = 30;

      if( i == 10 ){
         System.out.print("X是10");
      }else if( i == 20 ){
         System.out.print("X是20");
      }else if( i == 30 ){
         System.out.print("X是30");
      }else{
         System.out.print("这是 else 语句");
      }
   }
}

运行结果如下:

Java零基础入门学习Day[3]

 

 

 二.Switch语句

Switch语句:

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

Switch语句语法:

switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

switch 语句有如下规则：

  • switch 语句中的变量类型只能为 byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
  • switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
  • case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
  • 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到break语句出现才会跳出 switch 语句。
  • 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
  • switch 语句可以包含一个 default 分支，该分支必须是 switch 语句的最后一个分支。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

实例:

public class Test {

    public static void main(String args[]){
       char grade = 'C';
 
       switch(grade)
       {
          case 'A' :
             System.out.println("1"); 
             break;
          case 'B' :
             System.out.println("2"); 
          case 'C' :
             System.out.println("3");
             break;
          case 'D' :
             System.out.println("4");
          case 'F' :
             System.out.println("5");
             break;
          default :
             System.out.println("x");
       }
    }
 }

运行结果如下:

Java零基础入门学习Day[3]

 

 

 

Java循环结构语句

java循环结构语句主要有三种:while循环   do….while循环   for循环

while循环(只要布尔表达式为true,循环体会一直执行下去):

while( 布尔表达式 ) {
    //循环内容
}

实例:

public class Test {
    public static void main(String args[]) {
       int x = 10;
       while( x < 20 ) {
           System.out.print("x=" + x );
           x++;
           System.out.print("/n");
       }
    } 
 }

运行结果如下:

Java零基础入门学习Day[3]

 

 

 

do…while循环(布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为true，则语句块一直执行，直到布尔表达式的值为false。):

do {
       //代码语句
}while(布尔表达式);

实例:

public class Test {

    public static void main(String args[]){
       int x = 10;
 
       do{
          System.out.print("x=" + x );
          x++;
          System.out.print("/n");
       }while( x < 20 );    } }

运行结果如下:

Java零基础入门学习Day[3]

 

 

 

for循环(for循环执行的次数是在执行前就确定的):

  • 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
  • 然后，检测布尔表达式的值。如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
  • 执行一次循环后，更新循环控制变量。
  • 再次检测布尔表达式。循环执行上面的过程。

语句:

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

实例:

public class Test {
    public static void main(String args[]) {
       for(int x = 10; x < 16; x = x+1) {
           System.out.print("x=" + x );
           System.out.print("/n");
       }
    } 
 }

运行结果如下:

Java零基础入门学习Day[3]

 

 

 

循环的跳转语句(break关键字和continue关键字):

break关键字:

break主要用在循环语句或者switch语句中，用来跳出整个语句块。

break跳出最里层的循环，并且继续执行该循环下面的语句。

语法:

break;

实例:

public class Test {

   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50};

      for(int x : numbers ) {
         if( x == 30 ) {
          break;
         }
         System.out.print( x );
         System.out.print("/n");
      }
   }
}

运行结果如下:

Java零基础入门学习Day[3]

 

 

 

continue关键字:

在for循环中，continue语句使程序立即跳转到更新语句。

在while或者do…while循环中，程序立即跳转到布尔表达式的判断语句。

语法:

continue;

实例:

public class Test {

   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50};

      for(int x : numbers ) {
         if( x == 30 ) {
          continue;
         }
         System.out.print( x );
         System.out.print("/n");
      }
   }
}

运行结果如下:

Java零基础入门学习Day[3]

 

 

 

Java数组

声明数组变量:

数组类型[] 数组标识符;
数组类型 数组标识符[];

实例:

int[] a;
int a[];

创建数组(java用new操作符创建数组):

int[] x;
x= new int[10];
//或者
int[] x=new int[10];

初始化数组:

数组类型[] 数组标识符={元素,元素,....};

实例:

public class Test {

    public static void main(String args[]) {
       int[] x={2,4,6,8};
       System.out.println("x[0]="+x[0]);
       System.out.println("x[1]="+x[1]);
       System.out.println("x[2]="+x[2]);
       System.out.println("x[3]="+x[3]);
       }
    
 }

运行结果如下:

Java零基础入门学习Day[3]

 

 

 

数组常见操作:(遍历数组    最值获取    数组排序):

for循环遍历数组:

public class Test {
    public static void main(String[] args){
        int[] x={2,4,6,8};    //定义数组
        //使用for循环遍历数组元素
        for (int i=0; i<x.length; i++){
            System.out.println(x[i]);    //通过索引访问数组元素
        }
    }
   
 }

运行结果如下:

Java零基础入门学习Day[3]

 

 

 

 最值获取:

public class Test {
    public static void main(String[] args){
        int[] x={2,4,6,8,10};    
        int max = x[0];   //定义变量max用于记住最大数,假设第一个元素为最大值
        int min = x[0];   //定义变量min用于记住最小数,假设第一个元素为最小值
        //  下面通过一个for循环遍历数组中的元素
        for (int i=0; i<x.length; i++){
            if(x[i]>max){    //比较x[i]的值是否大于max
                max = x[i];     //条件成立,将x[i]的值赋给max
        }
    }
        //  下面再通过一个for循环遍历数组中的元素
        for (int i=0; i<x.length; i++){
            if(x[i]<min){   //比较x[i]的值是否小于min
                min= x[i];      //条件成立,将x[i]的值赋给min
            }
        }
        System.out.println("max="+max);    //打印最大值
        System.out.println("min="+min);   //打印最小值
 }
}

运行结果如下:

Java零基础入门学习Day[3]

 

 

 

数组排序(冒泡排序):

public class Test{
          public static void main(String[] args){
          int score[] = {67, 69, 75, 87, 89, 90, 99, 100};
          for (int i = 0; i < score.length -1; i++){    //最多做n-1趟排序
              for(int j = 0 ;j < score.length - i - 1; j++){    //对当前无序区间score[0......length-i-1]进行排序(j的范围很关键，这个范围是在逐步缩小的)
                  if(score[j] < score[j + 1]){    //把小的值交换到后面
                         int temp = score[j];
                      score[j] = score[j + 1];
                      score[j + 1] = temp;
                  }
              }            
              for(int a = 0; a < score.length; a++){  
              }
              System.out.println("");
          }
              System.out.print("最终排序结果：");
              for(int a = 0; a < score.length; a++){
                  System.out.print(score[a] + "/t");
         }
      }
  }

运行结果如下:

Java零基础入门学习Day[3]

 

 

 

二维数组:

int[][] a =new int[2][3];

int[][] a =new int[2][];

int[][] a =new int[][];

遍历二维数组：

//遍历二维数组
public class Traverse_a_two_dimensional_array {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[][] arr = new int[2][3];//动态创建：2个元素(外围数组),每一个元素中各有3个元素(内围数组)
        arr[0] = new int[]{1,2,3};//给第1个元素(外围数组)，赋值1,2,3
        arr[1][0] = 22;//给第2个元素中的第1个元素赋值22
        arr[1][1] = 13;//给第2个元素中的第2个元素赋值13
        arr[1][2] = 81;//给第2个元素中的第3个元素值81
        for(int i = 0;i < arr.length;i++){  
            //System.out.println(arr[i]);//arr中元素：2个数组的地址
            //遍历arr[0]，arr中元素第一个数组
            for(int j = 0;j < arr[i].length;j++){
                System.out.print(arr[i][j] + ",");
            }
        }
    }
}

运行结果如下：

Java零基础入门学习Day[3]

 

原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/288538.html

赞 (0)
0
上一篇 2022年9月10日
下一篇 2022年9月10日

相关推荐

发表回复

登录后才能评论