2.从零开始学习Java-Java语言基础（二）

于 2020-09-18 15:07:26 发布
阅读量136 收藏
点赞数
分类专栏： 从零开始学习Java-了解底层 JavaSE 文章标签： java javase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44886347/article/details/108665593
版权

1.选择结构

1.1 if选择结构

语法：

if(布尔表达式){
    //代码块
}

执行流程：

  • 对布尔表达式进行判断；
  • 结果为true，则先执行代码块，再执行后续代码。
  • 结果为false，则跳过代码块，直接执行后续代码。

1.2 if else选择结构

语法：

if(布尔表达式){
    //代码块1
}else{
 	//代码块2  
}

1.3 多重if选择结构

语法：

if(布尔表达式1){
    //代码块1
}else if(布尔表达式2){
    //代码块2
}else if(布尔表达式3){
    //代码块3
}else{
    //代码块4
}

public class Car {
	public static void main(String[] args) {
		System.out.println("请输入您的余额：");
		Scanner input = new Scanner(System.in);
		int money = input.nextInt();
		if (money <= 100) {
			System.out.println("捷马上，必须滴");
		}else if (money >= 300) {
			System.out.println("买宝马");
		}else if (money >= 200) {
			System.out.println("买路虎");
		}else {
			System.out.println("买不起");
		}
	}
}

1.4 嵌套if选择结构

语法：

if(外层表达式){
    if(内层表达式){
        //内层代码块1
    }else{
        //内层代码块2
    }
}else{
    //外层代码块
}

2.switch语句

分支结构：

2.1 语法：

switch(变量 | 表达式){ 
case 值1: 
	逻辑代码1;
case 值2: 
	逻辑代码2;
case 值n: 
	逻辑代码n;
default: 
	未满足时的逻辑代码;
}

2.2 可判断的类型：

byte、short、int、char、String（JDK7+）、枚举

2.3 注意：

注意：

  • 当匹配的case执行后，不会自动退出整个结构， 而是继续向下执行。
  • break关键字可在匹配的case执行后，跳出整个结构。
  • 适用等值判断。

局部变量：

  • 概念：声明在方法内部的变量，必须先赋值再使用。
  • 作用范围：定义行开始到所在的代码块结束。
  • 注意：多个变量，在重合的作用范围内，不可出现重名（命名冲突）。

3.循环结构

3.1 while循环

while(布尔表达式){ 
    //逻辑代码（循环操作） 
}

特点：

首次即有入口条件，先判断、再执行，适用于循环次数明确的情况。

3.2 do while循环

do{
    逻辑代码（循环操作） 
}while(布尔表达式);

特点：

首次没有入口条件，先执行，再判断。适用于循环次数不确定的情况。

3.3 for循环

for(初始部分 ; 循环条件 ; 迭代部分){
    //循环操作 
}

for(int i=0,j=n;i<=n;i++,j--){
    
}

特点：

首次即有入口条件，先判断、再执行，适用于循环次数明确的情况。

4.流程控制

1.break：循环执行中，遇到break， 则退出整个switch、循环结构。

2.continue:结束本次、进入下一次循环。

5.嵌套循环

概念：

在一次完整的循环结构中，嵌套另一个完整的循环结构。

外面的循环执行一次，内里的循环执行一遍。

break在循环中使用使用标记：

//break在二重循环中使用
//break默认跳出最近的循环，使用跳出外层循环需要使用标记。break 标记码在何处使用，跳出循环都是在标记的循环位置。

例如：
    //注意":"
    lable:for(int i=1;i<=5;i++){
        for(int j=1;j<=5;j++){
            break lable;//在int i的地方的循环跳出循环。
        }
    }

6.方法(函数)

概念：

实现特定功能的一段代码，可反复使用。

经验：

将需要在多个位置重复使用的一组代码，定义在方法内部。

位置：

方法定义在类的内部，与main方法并列。

注意：

调用方法时，会优先执行方法内部代码，结束后，返回到方法调用处，继续向下执行。

6.1定义语法：

public static void 方法名称( ){
    //方法主体 }

例如：

public class TestFunction{
    public static void main(String[] args){
        System.out.println("床");
        printSign();
        System.out.println("前");
        printSign()；
        System.out.println("月");
		printSign();
    }
    public static void printSign(){
        for(int i = 1;i <= 10;i++){
            System.out.println("_");
        }
        System.out.println();
    }
}

6.2 方法的参数：

多数情况下，方法与调用者之间需要数据的交互；调用者必须提供必要的数据，才能使方法完成相应的功能。

6.2.1 形参和实参：

形参：“形参”等价于“局部变量的声明”。

实参：“实参”等价于“局部变量的赋值”。

//定义语法：
public static void 方法名称(形式参数){
    //方法主体
}
//调用语法：
//方法名称（实际参数）

作用:方法的参数可以让代码功能灵活、普适性更高，易于修改及维护。

调用带参方法时，依次传入实参。类型、个数、顺序，必须与形参对应。

public class TestFuncation{
    public static void main(String[] args){
        System.out.println("你好啊");
        printSign(10,'#');
        System.out.println("明天你好");
    }
    //定义：打印count个sign的函数
    public static void printSign(int count,char sign){
        for(int i = 1;i <= count; i++){
            System.out.print(sign);
        }
        System.out.println();
    }
}

6.3 返回值及返回值类型：

public static 返回值类型 方法名称(形式参数列表){//规定返回值的具体类型（基本、引用、void）
    //方法主体
    return value;//根据需求返回一个结果（值）。
}//变量类型与返回值类型一致。

调用语法：

变量 = 方法名称();//变量类型和返回值类型一致。

public class TestResultValue{
    public static void main(String[] args){
        int result = add(5,6);
        System.out.println(result);
    }
    public static int add(int a,int b){
        return a+b;
    }
}

public class TestReturn {
    public static void main(String[] args){
      int result = add(1, 1);//调用返回值
      System.out.println(result);
    }
    public static int add(int a,int b){
        int sum = a+b;
        return sum;//把得到的传给main方法
    }
}

int result = add(1,2);//调用返回值
public static int add(int a,int b){
    return sum;//返回值
}

面试题：

public class Testget {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] numbs = {1,2,3,4,5};
		int numb = 1;
		add(numb,numbs);//没有接收到数据（即add()方法中的返回值c）//在静态方法中，有的只关注功能的实现，不需要接收返回值。
		
		System.out.println(numb+"\n");//sum依然为1
		for (int i = 0; i < numbs.length; i++) {
			System.out.println(numbs[i]);
		}
		
	}
	public static int add(int a,int[]as) {//因为as[]只是存在栈中的地址，所以地址所对应的堆中的数据改变，全局结果都发生改变，无需返回值。
		 int c = a + 1;
		 for (int i = 0; i < as.length; i++) {
			as[i]=as[i]+1;
		}
		 return c;
	}
}
//输出结果
1

2
3
4
5
6

public class Testget {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] numbs = {1,2,3,4,5};
		int numb = 1;
		int result = add(numb,numbs);//接受到结果，result为add()的返回值c=2；
		
		System.out.println(result+"\n");
		for (int i = 0; i < numbs.length; i++) {
			System.out.println(numbs[i]);
		}
		
	}
	public static int add(int a,int[]as) {
		 int c = a + 1;
		 for (int i = 0; i < as.length; i++) {
			as[i]=as[i]+1;
		}
		 return c;
	}
}
//输出结果：
2

2
3
4
5
6

6.4 return关键字：

作用：

  • 返回结果；
  • 结束方法；

经验：

return的两种用法：

1.应用在具有返回值类型的函数中：

return value；//结束当前函数，并伴有返回值，返回到函数调用处。

2.应用中没有返回值类型（void）的函数中：

return；//表示结束当前整个函数，直接返回到函数调用处。

public static void show(){
    for(int i = 1;i <= 100;i++){
        if(i == 50){
            return;
        }
    }
}

定义语法：

public static 返回值类型 函数名称（形式参数列表）{

//函数主体
    return value;//返回值，根据需求返回一个结果。
}

注意：

  • 当有返回值的方法存在分支结构时，必须保证每一条分支都具有正确的返回值。
  • 一个方法只有一个返回值。

6.5 方法的好处：

一个函数只做一件事，单一职能原则。

  • 减少代码冗余；
  • 提高复用性；
  • 提高可读性；
  • 提高可维护性；
  • 方便分工合作。

使用经验：1.在方法中可以使用对全局变量进行修改达到监视的效果。2.可以得到方法返回值通过值的变化达到监视的效果。

public class Bank {
    private User loginuser;//当前登录用户
    }
    private void login(){

            if (登录条件){
                System.out.println("登陆成功！");
                loginuser = users[i];//登录成功loginuser就有值。
                break;
            }else{
                System.out.println("登陆失败！");
                break;
            }
        }
        if (loginuser!=null){//判断
            System.out.println("====欢迎使用奥特曼系统====");

//优化
//可以使用reuturn的返回值判断

6.6 多级调用：

优先执行方法内部代码，结束后，返回到调用处，继续向下执行。

无穷递归：当方法自己调用自己时，如果没有正确的出口条件，则产生无穷递归。

6.7 递归（resusive）：

定义：

将大问题拆分成若干个小问题，大小问题的解决方法相同，有固定规律，需设置有效的出口条件，方法中自己调用自已。

  1. 解法相同；
  2. 固定规律；
  3. 设置有效的出口；//没有出口则造成无穷递归，内存溢出。即报错:java.lang.StackOverflowError
  4. 自己调用自己。

  • 什么是递归？

    解决具有既定规律的问题时，在方法内部再次调用自身方法的一种编程方式。

  • 何时使用递归？

    当需要解决的问题可以拆分成若干个小问题，大小问题的解决方式相同，方法中自己调用自己。

  • 使用循环解决的常规问题，都可以替换为递归解决。 如何正确使用递归？

    设置有效的出口条件，可以让调用链上的每个方法都可以正确返回，避免无穷递归。

    以下代码设置了程序的出口：

    if(n==1){
    return 1;
}//没有出口则造成无线调用，内存溢出。

public class TestFactorial{
    public static void main(String[] args){
        System.out.println(factorical(5));
    }
    public static int factorical(int n){
        if(n==1){
            return 1;//增加出口条件，n=1时，无需计算阶乘，直接返回结果1。
        }
        return n*factorical(n-1);
    }
}

注意：所有能以递归解决的问题，循环都可以解决。当解决复杂问题时，递归的实现方式 更为简单。

斐波那契数列：

import java.util.Scanner;
public class FeiBo {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int i = input.nextInt();
		System.out.println(sum(i));
	}
	public static int sum(int n) {
		if (n==1||n==2) {
			return 1;
		}else {
			return sum(n-1)+sum(n-2);
		}
	}
}

7.栈：先进后出。

8.局部变量

8.1 概念 ：

声明在方法内部的变量，必须先赋值再使用。

8.2 作用范围：

定义行开始到所在的代码块结束。

8.3 注意：

多个变量，在重合的作用范围内，不可出现重名（命名冲突）。

桥上走的那一句
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值