JAVASE_2

JAVASE_2

八月 01, 2022
  1. 通过函数访问到Scanner.java （xxx.java）
  2. 通过左侧Structure 查看方法列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package scanner;

import java.util.Scanner;

public class class5 {
    public static void main(String[] args) {
        //我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字结束输入并输出执行结果。
        Scanner scanner = new Scanner(System.in);
        //和
        double sum =0;
        // 计算输入了多少个数字
        int m =0;
        //通过循环判断是否还有输入，并在里面对每一次进行求和统计
        while (scanner.hasNextDouble()){  //whisle使用上感觉和if差不多，最重要的是理解java的程序结构
            Double x =scanner.nextDouble(); //这条语句给x进行赋值，x是一个变量
            System.out.println("你输入的x为："+x);//这里可以输出x的值，，而出了这个{}就不可以再输出x的值了
            m = m +1;//可以写为m++
            sum = sum + x; //在这里将x的值加入到sum中
            System.out.println("你输入了第"+m+"个数据，"+"当前结果为："+sum);
        }
        //System.out.println((double)x);//会导致出现报错，找不到符号，因为离开了上面的语句后x的没有得到赋值了
        System.out.println("输入数字的和为"+sum);
        System.out.println("一共输入了"+m+"个数字");
        System.out.println(m+"个数字的平均值为"+(sum/m));

        scanner.close();
    }

}

顺序结构

  • JAVA的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。
  • 顺序结构是最简单那的算法结构
  • 语句与语句之间，框与框之间是按照从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一共算法都离不开的一种基本算法结构。

if 单选择结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package if233;

import java.util.Scanner;   //if 单选择结构，表达式成立为true则输出再end

public class class1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容:");
        String s = scanner.nextLine();
        //s.equals:判断字符串是否相等
        if (s.equals("Hello"));{//判断s和Hello这俩字符串是否相等捏
        System.out.println(s);
        } //不成立则直接End然后结束
        System.out.println("End");
        scanner.close();

    }
}

if 双选择结构

  • 语法

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

    1
    2
    3
    4
    5

    - 实例\\

    ```java

if多选择结构

语法：

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

//我日昨天的笔记没保存，呜呜呜呜呜呜呜呜呜

例1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package if233;

import java.util.Scanner;

public class class2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //考试分数>60就是及格  <60就是不及格
        System.out.println("请输入成绩：");
        scanner.nextInt();//等待用户输入一个Int
        int score = scanner.nextInt(); //将输入的给score, score 等于 scanner.next里的int.
        if (score>60) {//如果score>60则就执行
            System.out.println("及格");
        }else{ //如果不大于就走这个
            System.out.println("不及格");
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package if233;

import java.util.Scanner;

public class class3 {
    /*
    if 语句至多有1一个else语句，else语句在所有的else if语句之后。
    if 语句可以有若干个else if 语句，他们必须在else语句之前。
    一旦其中一个 else if 语句检测为true,其他的else if 以及 else 语句都将跳过执行。
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score = scanner.nextInt();
        if (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 if (score>=100 ) {
            System.out.println("开挂狗给爷爬");
        }else{
            System.out.println("菜逼");


        }
    }
}

例3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package if233;

import java.util.Scanner;

public class class4 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //考试分数>60就是及格  <60就是不及格
        System.out.println("请输入成绩：");
        scanner.nextInt();//等待用户输入一个Int
        int score = scanner.nextInt(); //将输入的给score, score 等于 scanner.next里的int.
        if (score>60) {//如果score>60则就执行
            System.out.println("及格");
        }else{ //如果不大于就走这个
            System.out.println("不及格");
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package if233;

import java.util.Scanner;

public class class5 {
    public static void main(String[] args) {
        //
        //Scanner scanner = new Scanner(System.in);
        char grade = 'C';
        switch (grade){
            case 'A':
            System.out.println("优秀");
            break;
            case 'B':
                System.out.println("良好");
                break; //表示可选 ，如果没有break会出现case 穿透现象！如果没有匹配成功会一口气输出到最后。
            case 'C':
                System.out.println("海星");
                break;
            case 'D':
                System.out.println("森么彩笔？");
                break;
            default:
                System.out.println("请不要搞事嗷！");
                break;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package if233;

public class class6 {
    public static void main(String[] args) {
        String name = "牛逼";
        //JDK7新特性，表达式结果可以是字符串！！！
        //字符串本质还是数字捏
        //反编译 java---class(字节码文件)---反编译（IDEA）
        switch (name){//将字符串name与各个对比
            case "牛逼":
                System.out.println("卧槽果然牛逼！");
                break;//防止穿透
            case "笑死":
                System.out.println("笑死我了什么垃圾");
                break;
            default:
                System.out.println("呵呵给爷爬！");


        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package if233;

public class DoWhile1 {
    public static void main(String[] args) {
        int i =0;
        int sum =0;
        do {
            sum = sum + i;
            i ++;
        }while(i<100);
        System.out.println(sum);//输出4950

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package if233;

public class DoWhile2 {
    public static void main(String[] args) {
        int a = 0;
        while (a<0){
            System.out.println(a);
            a++;
        }
        System.out.println("----------------------");
        do {
            System.out.println(a);
            a++;
        }while (a<0);
    }
}

Do while 如上

while 循环 和 for 的对比

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package if233;

public class For1 {
    public static void main(String[] args) {
        int a = 1;//初始化条件
        while (a<=100){//条件判断
            System.out.println(a);//循环体
            a+=2;//迭代
        }
        System.out.println("循环结束");
        //初始化//条件判断//迭代
        for(int i=1;i<=100;i++){

        }
        System.out.println("for循环结束");
        /*
        关于for 循环有以下几点说明：
        最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
        然后，检测布尔表达式的值。如果为true，循环体被执行。如果为flase,循环终止，开始执行循环体后面的语句。
        执行一次循环后，更新循环控制变量（迭代银子控制循环变量的增减）。
        再次检测布尔表达式。循环执行上面的过程。
         */
        //for 语句 死循环写法 for(; ;){  //因为没有初始值，没有判断，就会不停的跑下去
        // }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package if233;

public class For2 {
    public static void main(String[] args) {
        //练习1：计算0到100之间的奇数和偶数的和
        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);
        }
    }
}

例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package if233;

public class For3 {
    public static void main(String[] args) {
        //练习2：用while 或for循环输出1-1000之间能被5整除的数，并且每行输出3个
        for (int i = 0; i <= 1000; i++) {
        if (i%5==0){
            System.out.print(i +"\t");//不换行输出3个
        }
            if(i%(5*3)==0){//如果 i%（5*3）==0的时候/5*3写15也行，写5*3貌似会更快（）
                //作用是如果输出三个就变成println，起到换行的作用，println和print的区别就是输出了
                System.out.println();}

            //方法二 System.out.print(\n);输出一个转义字符，\n 用来换行
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package if233;

public class for7 {
    public static void main(String[]/*这是个数组捏*/args) {
    int [] numbers = {10,20,30,40,50};//定义一个数组

        for(int i=0;i<5;i++)
            System.out.println(numbers[i]);//在只有五个的数组中输出五个，如果输出的数量大于5则会报错
        //便利数组的元素
        //每次循环从x中取值
        for(int x:numbers){
            System.out.println(x);
        }
    }
}

//上例为一个数组的测试

break continue //用来终止滴捏

  • break在任何循环语句的主体部分，均可用Break控制循环的流程，break用于强行退出循环，不自行循环中小恒徐的语句。（break语句也在switch语句中使用）
  • continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
  • 关于goto关键字 //这是个锚，让你循环停的
    • goto 关键字很早就mao在小恒徐设计语言中出现，尽管ogot仍是java的一个保留字，但未在语言中得到正是使用；Java没有goto.然而，在Break和continue这两个关键字的身上，我们仍能看出一些goto的影子—带标签的break和continue。
    • “标签”是指后面跟一个冒号的表示符，例如：label：
    • 对Java来说唯一用到标签的敌方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只终端当前循环，但弱随同标签使用，它们就会中断到存在标签的地方。

实例 打印三角形

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package if233;

public class Lx1 {
    public static void main(String[] args) {
        //打印三角形
        //老子打印了个山，不管了就这样吧
        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 k =0; k < i ; k++) {
                    System.out.print("*");

                }

        }
        System.out.println(" ");

        }

    }
}

Debug 程序的断点

de虫虫~~~~虫虫！！！！！！！！~~~~~~~~~~

方法

  • System.out.println(),那么它是什么呢？
  • System是一个类，out是输出对象，println是一个方法
  • 意：//调用系统内输出对象,out，里的println方法
  • 命名规则：驼峰原则
  • Java方法是语句的集合，它们在一起执行一个功能。
    • 方法是解决一类问题的步骤的有序组合
    • 方法包含于类或对象中
    • 方法在程序中被创建，在其他地方被引用
  • 设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的扩展。

方法的定义

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

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

    • 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

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

    • 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。

    • 参数类型：参数像一个占位符。当方法被调用时，传递值给参数。这个值被成为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。 参数是可选的，方法可以不包含任何参数。

      • 形式参数：在方法被调用时用于接收外界输入的数据

      • 实参：调用方法时实际传给方法的数据

    • 方法体：方法体包含具体的语句，定义该方法的功能。
    • 例：
1
2
3
4
5
6
修饰符 返回值类型 方法名（参数类型 参数名）{
    ...
   方法体
    ...
        return 返回值;
}

形式参数，用来定义作用

实际参数，用来调用传递给他的参数

值传递

  • 值传递：是指在调用函数时，将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，就不会影响到实际参数

引用传递

  • 引用传递：是指在调用函数时，将实际参数的地址传递到函数中，那么在函数中对参数进行修改，将会影响到实际参数

  • 引用数据类型分为两个部分，引用变量和对象，这两个部分放在不同的地方，引用变量在栈中，而对象是放在堆内存中的，引用变量指向对象。 如下图所示，当传递参数之前会将参数进行复制，但是复制的是引用变量，复制后的引用变量还是指向内存中的同一对象，所以引用传递中，函数修改了参数会影响实际参数

在这里插入图片描述

引用传递是对于引用数据类型而言，例如对于User类姓名的修改，会改变对象的name。

注意点，引用类型中的String的值是放在常量池中，我们改变副本的值不会影响到原来的值。

在这里插入图片描述

    • 例如在change放发中改变了副本的值，但是原来的str字符串不会改变。

方法的重装

  • 在一个类中，有相同的函数名称，但形参不同的函数。

  • 方法的重装的规则：

  • 方法名称必须相同

  • 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等。）

  • 方法的返回类型可以相同也可以不相同

  • 仅仅返回类型不同不足以成为方法的重载

  • 实现理论:

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

个人理解：相当于重新载入了一个同名的，不同的方法。

命令行传参

程序运行的时候，用命令行传递给程序信息

注意点：1，路径找对，找到包的路径从包外面运行

注意点：2，实际上是通过定义命令行的参数运行程序

可变参数

  • JKD 1.5 开始，Java支持传递同类型的可变参数给一个方法。
  • 在方法声明中，在指定参数类型后加一个省略号（…）。
  • 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package Fangfa;

public class Demo04 {
    public static void main(String[] args) {

    }
    public static void printMax(double... numbers){
        if (numbers.length == 0){
            System.out.println("23333");
            return;
        }
     //懒得写了捏
    }

}

递归

  • A方法调用A方法！自己调用自己
  • 利用递归可以用简单的程序解决一些复杂的问题。它通常把一个大型复杂的问题层层华为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出接替过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对线的无限集合。
  • 递归结构包括两个部分：
    • 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
    • 递归体：什么时候需要调用自身方法。

边界条件

前阶段：

返回阶段 n*(n-1)

（递归非常的耗内存）存在大量的函数调用捏

image-20220505191817653

栈机制

  1. 1. 顺序结构
  2. 2. if 单选择结构
  3. 3. if 双选择结构
  4. 4. if多选择结构
  • 例1
  • 例3
    1. 1. Do while 如上
  • while 循环 和 for 的对比
    1. 1. 例：
    2. 2. break continue //用来终止滴捏
    3. 3. 实例 打印三角形
  • Debug 程序的断点
    1. 0.1. 方法
  • 方法的定义
    1. 1. 形式参数，用来定义作用
    2. 2. 实际参数，用来调用传递给他的参数
      1. 2.1. 值传递
      2. 2.2. 引用传递
        1. 2.2.0.1. 注意点，引用类型中的String的值是放在常量池中，我们改变副本的值不会影响到原来的值。
    3. 2.3. 方法的重装
    4. 2.4. 命令行传参
    5. 2.5. 可变参数
    6. 2.6. 递归
  • 3. 边界条件
  • 栈机制