java基础(二)：基本结构，方法，数组

最新推荐文章于 2023-07-31 19:24:14 发布

lituxiu

最新推荐文章于 2023-07-31 19:24:14 发布

阅读量176

点赞数

分类专栏： java学习文章标签： java eclipse

本文链接：https://blog.csdn.net/lituxiu/article/details/120474488

版权

java学习专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1、基本结构

1.1顺序结构

顺序结构是在程序中按顺序从上到下依次执行的过程。

class test {
   public static void main(String[] args) {
       float a,b,x;
       a=Float.parseFloat(args[0]);//输入的第1个参数对应a的值
       b=Float.parseFloat(args[1]);//输入的第2个参数对应b的值
       x=-b/a;
       System.out.println("a="+a);
       System.out.println("b="+b);
       System.out.println("x="+x);
   }}
//这里在cmd运行里要java Test  2.0  6.0 或者在eclipse中"Run Configulations"在“Arguments”的“Program arguments”输入2.0  6.0
//通过按顺序赋值给a和b

java程序的键盘录入也是顺序结构的体现:

/*
    为了让程序的数据更符合开发的数据，我们就加入了键盘录入。
    让程序更灵活一下。

    那么，我们如何实现键盘数据的录入呢?
        A:导包
            格式：
                import java.util.Scanner;
            位置：
                在class上面。
        B:创建键盘录入对象
            格式：
                Scanner sc = new Scanner(System.in);
        C:通过对象获取数据
            格式：
                int x = sc.nextInt();
*/
import java.util.Scanner;

class test {
   public static void main(String[] args) {
   //创建键盘录入数据对象
       Scanner sc = new Scanner(System.in);
       System.out.println("请你输入x数据：");
       int x = sc.nextInt();
       System.out.println("请你输入y数据：");
       int y = sc.nextInt();
       System.out.println("你输入的x数据是："+x);
       System.out.println("你输入的y数据是："+y);
   }
}

1.2选择结构

根据不同的成立的条件，选择执行不同的代码程序。选择主要分if语句和switch语句。

(1)if的3种结构

第1种是最简单的 if(条件){语句体}，只有满足条件的执行。主要是讲以下2种if结构。

       if(比较表达式) { //比较表达式成立就执行语句体1，否则执行语句体2
           语句体1;
       }else {
           语句体2;
       }

/*
   由于if语句的第二种格式刚才也完成了三元运算符可以完成的效果。
   所以，我们就认为他们可以完成一样的操作。
   但是，他们就一点区别没有吗?肯定不是。

   区别：
       三元运算符实现的，都可以采用if语句实现。反之不成立。

       什么时候if语句实现不能用三元改进呢?
           当if语句控制的操作是一个输出语句的时候就不能。
           为什么呢?因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出。
*/
class IfDemo4 {
   public static void main(String[] args) {
       //获取两个数据的最大值
       int a = 10;
       int b = 20;

       //用if语句实现
       int max1;
       if(a > b) {
           max1 = a;
       }else {
           max1 = b;
       }
       System.out.println("max1:"+max1);

       //用三元改进
       int max2 = (a > b)? a: b;
       System.out.println("max2:"+max2);
       System.out.println("----------");

       //判断一个数据是奇数还是偶数,并输出是奇数还是偶数
       int x = 100;

       if(x%2 == 0) {
           System.out.println("100是一个偶数");
       }else {
           System.out.println("100是一个奇数");
       }

       //用三元改进
       //这种改进是错误的。
       //String s = (x%2 == 0)?System.out.println("100是一个偶数");:System.out.println("100是一个奇数");;
   }
}

if(比较表达式1) {
           语句体1;
       }else if(比较表达式2) {
           语句体2;
       }else if(比较表达式3) {
           语句体3;
       }
       ...
       else { //这一块可有可无
           语句体n+1;
       }

import java.util.Scanner;

class IfDemo5 {
   public static void main(String[] args) {
       //需求：键盘录入一个成绩，判断并输出成绩的等级。
       /*
           90-100 优秀
           80-90 好
           70-80 良
           60-70 及格
           0-60 不及格
       */

       //创建键盘录入对象
       Scanner sc = new Scanner(System.in);

       //录入数据
       System.out.println("请输入你的考试成绩：");
       int score = sc.nextInt();

       //另一种判断改进
       if(score<0 || score>100) {
           System.out.println("你输入的成绩有误");
       }else if(score>=90 && score<=100) {
           System.out.println("优秀");
       }else if(score>=80 && score<90) {
           System.out.println("好");
       }else if(score>=70 && score<80) {
           System.out.println("良");
       }else if(score>=60 && score<70) {
           System.out.println("及格");
       }else {
           System.out.println("不及格");
       }
   }
}

而且if语句可以嵌套使用的，如下

/*
   获取三个数据中的最大值
   由此案例主要是为了讲解if语句是可以嵌套使用的。而且是可以任意的嵌套。
*/
class IfTest4 {
   public static void main(String[] args) {
       int a = 10;
       int b = 30;
       int c = 20;

       //三元实现
       //int temp = (a>b)? a: b;
       //int max = (temp>c)? temp: c;
       //System.out.println("max:"+max);
       //System.out.println("--------");

       //用if语句实现
       int max;
       if(a > b) {
           if(a > c) {
               max = a;
           }else {
               max = c;
           }
       }else {
           if(b > c) {
               max = b;
           }else {
               max = c;
           }
       }
       System.out.println("max:"+max);
   }
}

（2）switch语句

   switch语句格式：
       switch(表达式) {
           case 值1:
               语句体1;
               break;
           case 值2:
               语句体2;
               break;
           ...
           default:
               语句体n+1;
               break;
       }

   格式的解释：
       switch:表示这是switch选择结构
       表达式:这个地方的取值是有限定的
           byte,short,int,char
           JDK5以后可以是枚举
           JDK7以后可以是字符串
       case:后面跟的是要和表达式进行比较的值
       语句体:要执行的代码
       break:表示中断，结束的意思，可以控制switch语句的结束。
       default:当所有的值都和表达式不匹配的时候，就执行default控制的语句。其实它就相当于if语句的else。

   switch语句的注意事项：
       A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
       B:default可以省略吗?
           可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
           特殊情况：
               case就可以把值固定。
               A,B,C,D
       C:break可以省略吗?
           可以省略，但是结果可能不是我们想要的。
           会出现一个现象：case穿透。
           最终我们建议不要省略
       D:default一定要在最后吗?
           不是，可以在任意位置。但是建议在最后。
       E:switch语句的结束条件
           a:遇到break就结束了
           b:执行到末尾就结束了

//switch案例1
import java.util.Scanner;

class SwitchDemo2 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //控制键盘录入数据
        System.out.println("请输入一个数据(1-7):");
        int week = sc.nextInt(); //3

        //定义常量
        //int number = 3;
        //然后把case后面的值改为number，就会报错

        //switch判断语句
        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的面试题，看程序写结果

class SwitchTest {
   public static void main(String[] args) {
       int x = 2;
       int y = 3;
       switch(x){
           default:
               y++;
               break;
           case 3:
               y++;
           case 4:
               y++;
       }
       System.out.println("y="+y);
       System.out.println("---------------");

       int a = 2;
       int b = 3;
       switch(a){
           default:
               b++;
           case 3:
               b++;
           case 4:
               b++;
       }
       System.out.println("b="+b);
   }
}

（3）if和switch的区别？

if	switch
基本if选择结构：处理单一或组合条件的情况 if-else选择结构：处理简单的条件分支情况多重if选择结构：处理复杂的条件分支情况嵌套if选择结构：用于较为复杂的流程控制	多重分支并且条件判断是等值判断的情况

1.3循环结构

循环结构包括for循环,while循环,do...while循环三大循环体。

(1)for循环结构

for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}

/*
   案例：求5的阶乘。
   什么是阶乘呢?
       n! = n*(n-1)! 规则
       n! = n*(n-1)*(n-2)*...*3*2*1

   求和思想。
   求阶乘思想。
*/
class ForDemo5 {
   public static void main(String[] args) {
       //定义最终结果变量
       int jc = 1;
       for(int x=2; x<=5; x++) {
           jc *=x;
       }
       System.out.println("1-5的阶乘是："+jc);

//当for只执行一条循环语句时，可不用大括号，把那一条循环语句紧跟for()语句后即可
for(int x=0;x<=5;x++) System.out.println("Saturday");

   }
}

（2）while循环结构

while循环的基本格式：
       while(判断条件语句) {
           循环体语句;
       }

       扩展格式：

       初始化语句;
   while(判断条件语句) {
           循环体语句;
           控制条件语句;
       }

/*
   需求：统计水仙花数有多少个
*/
class WhileDemo3 {
   public static void main(String[] args) {
       //for循环版本
       int count = 0;

       for(int x=100; x<1000; x++) {
           int ge = x%10;
           int shi = x/10%10;
           int bai = x/10/10%10;

           if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
               count++;
           }
       }

       System.out.println("count:"+count);
       System.out.println("------------");

       //while循环版本
       int count2 = 0;

       int y = 100;
       while(y<1000) {
           int ge = y%10;
           int shi = y/10%10;
           int bai = y/10/10%10;

           if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == y) {
               count2++;
           }

           y++;
       }

       System.out.println("count2:"+count2);
   }
}

（3）do..while循环结构

do...while循环的基本格式：
       do {
           循环体语句;
       }while(判断条件语句);

       扩展格式；
       初始化语句;
       do {
           循环体语句;
           控制条件语句;
       }while(判断条件语句);

循环语句的区别:
       do...while循环至少执行一次循环体。
       而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。

   那么，我们一般使用哪种循环呢?
       优先考虑for，其次考虑while，最后考虑do...while

class DoWhileDemo {
   public static void main(String[] args) {
       //输出10次HelloWorld。
       int x = 0;
       do {
           System.out.println("HelloWorld");
           x++;
       }while(x<10);

       System.out.println("--------------");

       //求和1-100
       int sum = 0;
       int a = 1;
       do {
           sum += a;
           a++;
       }while(a<=100);

       System.out.println(sum);
   }
}

（注意：循环间是可以嵌套的，但一般最多3层循环嵌套，再多的话会影响性能了）

1.4控制跳转语句

跳转语句一般指break、continue和return

break

continue

retrun

1、跳出单层循环

2、跳出多层循环
格式：
标签名: 语句

如下：

wc:for(int x=0; x<3; x++) {
           nc:for(int y=0; y<4; y++) {
               if(y == 2) {
                   //break nc;
                   break wc; //直接跳出wc，结束全部循环
               }
               System.out.print("*");
           }
           System.out.println();
       }

1、跳出一次循环，进入下一次的执行

1、其实它的作用不是结束循环的，而是结束方法的。

//break和continue例子1
public static void main(String[] args) {
  for(int i =1;i<4;i++) {
   for(int j =1;j<4;j++) {
    if(i*j>2) {
     continue; //break; 对比下此处break和continue的区别
    }
    System.out.println("li="+(i*j));
   }
   System.out.println("wai="+i);
  }
 }

//break和continue例子2  	 
public static void main(String[] args) {	
		for(int i =1;i<4;i++) {
			for(int j =1;j<5;j++) {
				if(j%2==0) {
					continue; //break; //对比下continue和break的区别
				}
				System.out.println("li="+(i*j));
			}
			System.out.println("wai="+i);
		}
	   	
	}

2、方法

方法：完成特定功能的代码块。
(注意：在很多语言里面有函数的定义，而在Java中函数被称为方法。)

方法格式：
       修饰符返回值类型方法名(参数类型参数名1,参数类型参数名2...) {
           方法体语句;
           return 返回值;
       }
   详细解释：
       修饰符：目前就用 public static。后面我们再详细的讲解其他的修饰符。
       返回值类型：就是功能结果的数据类型。//

//public static int sum(int a,int b){..} 必须要return 返回值

//public static void sum(int a,int b){..} 可System.out.print(内容);输出

方法名：符合命名规则即可。方便我们的调用。
       参数：
           实际参数：就是实际参与运算的。
           形式参数；就是方法定义上的，用于接收实际参数的。
       参数类型：就是参数的数据类型
       参数名：就是变量名
       方法体语句：就是完成功能的代码。
       return：结束方法的。
       返回值：就是功能的结果，由return带给调用者。

   要想写好一个方法，就必须明确两个东西：
       A:返回值类型
           结果的数据类型
       B:参数列表
           你要传递几个参数，以及每个参数的数据类型

   需求：求两个数据之和的案例

   方法的执行特点：
       不调用，不执行。

   如何调用呢?(有明确返回值的调用)
       A:单独调用,一般来说没有意义，所以不推荐。//sum(x,y)
       B:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。 //System.out.println(sum(x,y))
       C:赋值调用,推荐方案。

// int result = sum(x,y);

//System.out.println(result);

   方法的注意事项：
       A:方法不调用不执行
       B:方法与方法是平级关系，不能嵌套定义
       C:方法定义的时候参数之间用逗号隔开
       D:方法调用的时候不用在传递数据类型
       E:如果方法有明确的返回值，一定要有return带回一个值

方法调用案例1

/*
键盘录入行数和列数，输出对应的星形
*/
import java.util.Scanner;

class FunctionTest4 {
   public static void main(String[] args) {
       //创建键盘录入对象
       Scanner sc = new Scanner(System.in);

       System.out.println("请输入行数：");
       int m = sc.nextInt();

       System.out.println("请输入列数：");
       int n = sc.nextInt();

       //void类型的方法调用
       pringXing(m,n);
   }

   /*
       输出星形

       两个明确：
           返回值类型：void
           参数列表：int m,int n
   */
   public static void pringXing(int m,int n) {
       for(int x=0; x<m; x++) {
           for(int y=0; y<n; y++) {
               System.out.print("*");
           }
           System.out.println();
       }
   }
}

2.1方法重载

/*
   需求：我要求数的和

   我们的需求不断的发生改变，我们就对应的提供了多个求和的方法。
   但是呢，他们的名字是不一样的。
   而我们又要求方法命名做到：见名知意。
   但是，很明显，现在没有做到。
   那么，肿么办呢?
   针对这种情况：方法的功能相同，参数列表不同的情况，为了见名知意，Java允许它们起一样的名字。

   其实，这种情况有一个专业名词：方法重载。

   方法重载：
       在同一个类中，方法名相同，参数列表不同。与返回值类型无关。
（同方法名，但参数列表和返回值类型不同）
       参数列表不同：
           A:参数个数不同
           B:参数类型不同
*/

class FunctionDemo4 {
   public static void main(String[] args) {
       //jvm会根据不同的参数去调用不同的功能
       System.out.println(sum(10,20));
       System.out.println(sum(10,20,30));
       System.out.println(sum(10,20,30,40));

       System.out.println(sum(10.5f,20f));
   }

   //需求1:求两个数的和
   public static int sum(int a,int b) {
       System.out.println("int");
       return a + b;
   }

   //需求2:求三数的和
   /*
   public static int sum1(int a,int b,int c) {
       return a + b + c;
   }
   */

   public static int sum(int a,int b,int c) {
       return a + b + c;
   }

   //需求3:求四个数的和
   /*
   public static int sum2(int a,int b,int c,int d) {
       return a + b + c + d;
   }
   */
   public static int sum(int a,int b,int c,int d) {
       return a + b + c + d;
   }

   public static float sum(float a,float b) {
       System.out.println("float");
       return a + b;
   }
}

3、数组

数组:存储同一种数据类型的多个元素按顺序排列的容器。

3.1一维数组

3.11一维数组的初始化

动态初始化：

数组声明且为数组元素分配空间与赋值的操作分开进行

静态初始化：

在定义数组的同时就为数组元素分配空间并赋值

（1）int[] score = new int [3]; //推荐

或int score [] ; score = new int[3]

（2）score[0]=98;

score[1]=99;

score[2]=100;

(1)int[] len1 = {2,3,45,56}; //推荐

（2）int[] len2= new int[] {0,1,2,3,5};

可通过数组名.length获得数组的下标长度，但是以0开始。如len2.length=5，下标是len2[0]到len2[4]，共存储5个数组值。

注意：考虑到float类型的范围和java自动转型的情况，float数组时命名float f[] = {2.4f, 4.4f, 6.4f};或float f[] = {2 ,4 ,6};这两种方式命名才正确，否则float f[] = {2.4,4.4,6.4};命名是错误的，{2.4,4.4,6.4}是自动转型为double数组类型。

3.12一维数组不同类型的默认值及内存图

数组元素类型	元素默认初始值
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0
char	0 或写为:’\u0000’(表现为空)
boolean	false
引用类型	nul

数组是引用数据类型，当数组new初始化时，在堆中开辟空间存储的数据是有默认值为0的。就是数组int[] score = new int [3]声明后没有赋值score[0]到score[2]元素值都为0。如下图（数组初始化及其内存图）

一维数组案例：数组逆序

class ArrayTest3 {
   public static void main(String[] args) {
       //定义一个数组，并进行静态初始化。
       int[] arr = {12,98,50,34,76};

       //逆序前
       System.out.println("逆序前：");
       printArray(arr);

       //逆序后
       System.out.println("逆序后：");
       //reverse(arr);
       reverse2(arr);
       printArray(arr);
   }

   public static void reverse(int[] arr) {
       for(int x=0; x<arr.length/2; x++) {
           int temp = arr[x];
           arr[x] = arr[arr.length-1-x];
           arr[arr.length-1-x] = temp;
       }
   }

   public static void reverse2(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;
       }
   }

   //遍历数组
   public static void printArray(int[] arr) {
       System.out.print("[");
       for(int x=0; x<arr.length; x++) {
           if(x == arr.length-1) { //这是最后一个元素
               System.out.println(arr[x]+"]");
           }else {
               System.out.print(arr[x]+", ");
           }
       }
   }
}

3.2二维数组

二维数组：数组元素为一维数组的一个数组。

3.21二维数组的初始化

动态初始化：

数组声明且为数组元素分配空间与赋值的操作分开进行

静态初始化：

在定义数组的同时就为数组元素分配空间并赋值

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

arr[0][0]=5;

arr[0][1]=6;

int[][] arr = {{1,2,3},{4,5},{6}};

(注意：二维数组的遍历，外循环控制的是二维数组的长度，其实就是一维数组的个数。
内循环控制的是一维数组的长度。)

二维数组案例：打印杨辉三角形

   需求：打印杨辉三角形(行数可以键盘录入)

   1
   1 1
   1 2 1
   1 3 3 1
   1 4 6 4 1
   1 5 10 10 5 1

   分析：看这种图像的规律
       A:任何一行的第一列和最后一列都是1
       B:从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。

   步骤：
       A:首先定义一个二维数组。行数如果是n，我们把列数也先定义为n。
       这个n的数据来自于键盘录入。
       B:给这个二维数组任何一行的第一列和最后一列赋值为1
       C:按照规律给其他元素赋值
           从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
       D:遍历这个二维数组。
*/
import java.util.Scanner;

class Array2Test3 {
   public static void main(String[] args) {
       //创建键盘录入对象
       Scanner sc = new Scanner(System.in);

       //这个n的数据来自于键盘录入。
       System.out.println("请输入一个数据：");
       int n = sc.nextInt();

       //定义二维数组
       int[][] arr = new int[n][n];

       //给这个二维数组任何一行的第一列和最后一列赋值为1
       for(int x=0; x<arr.length; x++) {
           arr[x][0] = 1; //任何一行第1列
           arr[x][x] = 1; //任何一行的最后1列
       }

       //按照规律给其他元素赋值
       //从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
       for(int x=2; x<arr.length; x++) {
           //这里如果y<=x是有个小问题的，就是最后一列的问题
           //所以这里要减去1
           //并且y也应该从1开始，因为第一列也是有值了
           for(int y=1; y<=x-1; y++) {
               //每一个数据是它上一行的前一列和它上一行的本列之和。
               arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
           }
       }

       //遍历这个二维数组。
       for(int x=0; x<arr.length; x++) {
           for(int y=0; y<=x; y++) {
               System.out.print(arr[x][y]+"\t");
           }
           System.out.println();
       }
   }
}

lituxiu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java基础(二)：基本结构，方法，数组

目录1、基本结构 1.1顺序结构 1.2选择结构 (1)if的3种结构（2）switch语句（3）if和switch的区别？ 1.3循环结构 (1)for循环结构（2）while循环结构（3）do..while循环结构 1.4控制跳转语句1、基本结构 java程序的基本结构包括顺序结构、选择结构和循环结构。 1.1顺序结构顺序结构是按程序语句顺...
复制链接

扫一扫