java语法（分支，方法，递归）；Debug使用

java语法

x 操作符

->分支，循环，方法

分支

条件的三种if

if

if…else…

public class IfDemo01 {    
public static void main(String[] args) {        
int a =3;        
final int DAY = 3;        
if(a<DAY){         
}else if (a<DAY){
}else {
//保证了结构完整性            
System.out.println("不运行");       
}    
}
}

switch…case…

注意事项

1. 有限个（少量)
2. switch…case…不能使用浮点类型
3. break;

问题

条件的类型

char/int/short/byre

String

enum(枚举类型)

case穿透

package com.ffyc.condition;

/**case穿透
 * 80~100 A 8,9,10
 * 70~79 B 7
 * 60~69 C 6
 * 50~59 D 5
 * 50< F 0~4
 */
public class SwitchDemo {
    public static void main(String[] args) {
        int s = 70;
        s/=10;
        switch (s){
            case 10:
            case 9:
            case 8:
                System.out.println("A");
                break;
            case 7:
                System.out.println("B");
                break;
            case 6:
                System.out.println("C");
                break;
            case 5:
                System.out.println("D");
            default:
                System.out.println("F");
        }
    }
}

菜单界面——计算器

package com.ffyc.condition;
/**
 * 带界面的计算机
 */

import java.util.Scanner;

public class SwitchDemo01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("--------------------");
        System.out.println("1.加法\t 2.减法");
        System.out.println("3.乘法\t 4.除法");
        System.out.println("5.幂\t 6.进制转换");
        System.out.println("0.退出");
        System.out.println("--------------------");
        System.out.print("请选择：");
        String choice = sc.nextLine();

        int t  = Integer.parseInt(choice);
        if (t<0||t>6){
            System.out.println("输入不合法....");
            System.exit(-1);
        }

        System.out.print("请输入第一个数：");
        //String  line = sc.nextLine();
        int a = Integer.parseInt(sc.nextLine());//line-->(sc.line)
        //a^b
        System.out.print("请输入第二个数：");
        int b = Integer.parseInt(sc.nextLine());

        String s = "";
        String str="";
        switch (choice){
            case"1":
                str="+";
                break;
            case"2":
                str="-";
                break;
            case"3":
                str="*";
                break;
            case"4":
                str="/";
                if(b==0){
                    System.out.println("除数不能为零");
                }else {
                    s= 1.0*a / b+"";
                }
                break;
            case"5":
                str="^";
                int p=1;
                for (int i = 1;i<=b;i++){
                    p*=a;
                }
                s=p+"";
                break;
            case"6":
                //int x=Integer.parseInt(sc.nextLine());
                String change="";
                if (b==2){
                    str="化为2进制>>";
                    s=Integer.toBinaryString(a);
                } else if (b == 16) {
                    str="化为16进制>>";
                    s=Integer.toHexString(a);
                }else {
                    System.out.println("对不起，只能进行十进制向2/16进制的转换...");
                }
                break;
            case"0":
                System.out.println("程序退出>>>");
                break;
            default:
                break;
        }
        System.out.println(a +str+b+"="+s);

    }
}

注：只完成了部分功能

循环

while

1. while…do…
2. do…while…

for

几个关键字

1. break
2. continue
3. return

package com.ffyc.Loop;

public class LoopDemo {
    public static void main(String[] args) {
        for (int i=0;i<5;++i){
            for (int j=0;j<5;++j){
                //if (i+j==5) break;//跳出当前循环j
                //if (i+j==5) continue;//跳过当前变量值
                if (i+j==5) return;//结束这个方法/函数
                System.out.println(j+"\t");
            }
        }
    }
}

案例

画图

以及 九九乘法表

原理

eg：画三角形

第一个：

在画

两层循环构造建议

验证：

package com.ffyc.Loop;

public class DrawDoubleLoopDemo01 {
    public static void main(String[] args) {
        int m = 100;
        int n=  1000;

        long s1= System.nanoTime();//获取当前时间

        for (int i=0;i<n;++i){
            for (int j=0;j<m;++j){
                ;
            }
        }
        long s2= System.nanoTime();//获取当前时间
        System.out.println("循环一："+(s2-s1)+"ns");

        long s3 =System.nanoTime();
        for (int i=0;i<m;i++){
            for (int j=0;j<n;++j){

            }
        }
        long s4 =System.nanoTime();
        System.out.println("循环二："+(s4-s3)+"ns");
    }
}

外小里大 省时间

    *
   ***
  *****
 *******
  $ * $
    *
    *

for循环不写循环体–》空转

方法（函数）

目的 有啥用？

代码块复用—>高级叫Api接口调用

package com.ffyc.Method;

public class MethodDemo {
    /**
     * 定义一个函数
     *直角三角形
     * @param n 三角形高度
     */
    public static void triangle(int n){

        for (int i=1;i<n;++i) {//n:高度
            for (int j=1;j<=i;++j){
                System.out.print("*");
            }
            System.out.println();
        }
    }

    /**
     * 对称的直角三角形
     * @param n 高度
     */
    public static void triangle(int n,String tu){//tu——改变图标
    //同名可以用——重载
        for (int i=1;i<n;++i) {//n:高度
            for (int k=1;k<n-i;k++){
                System.out.print(" ");//空格
            }
            for (int j=1;j<=i;++j){
                System.out.print(tu);
            }
            System.out.println();
        }
    }



    public static void main(String[] args) {

        triangle(5);
        triangle(5,"$");
    }
}

main

    public static void main(String[] args) {
        
    }

public

访问控制符

static

main需要static，所有方法static

void

返回类型void–不需要返回值

main

方法名称

String[]args

参数列表

方法调用

1. 直接调用:f(2)
2. 作为结果:
   

注意：

方法里面不能套方法

java 属性位置 （在方法外）： 只能写一句 --> 要写只能static{}在语句块里

传参

形参

即：形式参数，参与方法使用

实参

实际在使用过程中传入参数的拷贝–值传递

多参数传递，不定参数

方法重载:

​ ——在一个类（一个class{}），方法名完全相同，参数的类型或者个数不一致。

优先选择精确的，有两个参数的就不选择模糊的

递归Recursion

建包–防止类名冲突

概念

自己调自己

迭代法

递归方法

f() { f() }//函数

main{//用

f()；

}

栈溢出

递归规律

1. 起始条件：找规律
2. 终止/跳出条件
   
   

数据结构-栈 - 理解：

阶乘：

package com.ffyc.Recursion;/** * 斐波那契数列 */public class RecursionDemo02 {    public static int f(int n){    if ((n==1)||(n==2)) {        return 1;    }else {        return f(n-1)+f(n-2);    }    }    /**     * 迭代法     */public static int fac(int n){    int a=1;    int b=1;    int c=0;    for (int i=3; i <=n ; i++) {        c=a+b;        a=b;        b=c;    }    return c;}    public static void main(String[] args) {    //比较两个用时，数字越大，递归越慢；迭代快，但递归简单        long s1 = System.nanoTime();        f(20);        long s2 = System.nanoTime();        System.out.println("递归："+(s2-s1)+"ns");        long s3 =System.nanoTime();        fac(20);        long s4 = System.nanoTime();        System.out.println("迭代："+(s4-s3)+"ns");    }}

递归问题：大量重复

解决方法：优化递归——存储已经算出的结果

案例3：输一个10进制数，用递归把它转化为二进制数

跳出条件：n<2

规律：n/2

案例4：输入123，输出1+2+3=6

跳出条件：n%10<10

规律：n%10/10

案例5：辗转相除求最大公约数

数组

概念

存储多个相同类型数据，有固定长度(Integer.MAx VALUE-8)。有时需要删除或者扩容。

数组–>链表–>堆

索引/下标 连续的 O（1）

定义数组

固定长度，定值

int[] a = {1,2,3,4};

动态数据（推荐）

int[] a = new int [6];

other

int [] a = new int []{1,2,3};

数组特性

固定长度

数组名称.length ——属性

索引从0开始

[0,a.length-1]

访问数组

a[i]

数组遍历

循环

/** * 数组遍历:普通for循环 */for (int i = 0; i < a.length; i++) {    System.out.print(a[i]+"\t");}System.out.println();
}

增强型for

  /**     * 增强型for 循环     * 不涉及索引     */   
for(int t : a){        //t像一个桶；把a都扔进t        
    System.out.print(t+"\t");    
}

数组案例

/**
*第二大的函数
*/

public static int second(int[] a) {
        int max = a[0];
        int second = a[1];

        if (max < second) {
            int t = max;
            max = second;
            second = t;
        }
        for (int i = 2; i < a.length; i++) {
            int curr = a[i];

            if (curr > max) {
                second = max;
                max = curr;
            } else if (curr < second) {
                continue;
            } else {
                second = curr;
            }
        }
        return second;
    }

改编力扣

元素：0~1000，找出数组中出现次数最多的元素。

算法无非时间换空间or空间换时间。

package com.ffyc.array;

import java.util.Arrays;



/**
 * 元素：0~1000，
 * 找出数组中出现次数(频率）最多的元素。
 */
public class ArrayDemo02 {
    public static void main(String[] args) {
        int[] a = {1,4,8,4,5,4,88,88,55,0,55,6,7,8,9,9,6,2,5,88,88,88,8,8,88,8,999};
        /**
         * 造一个数组，用索引表示出现次数
         */
        int[] bukets = new int[1001];//0~1000

        for (int i = 0; i < a.length; i++) {
            int index = a[i];
            bukets[index]= bukets[index]+1;
        }
        int max = bukets[0];
        int pos =0;
        for (int i=1;i<a.length;++i){
            if (max<bukets[i]){
                max = bukets[i];
                pos = i;
            }
        }
        System.out.println("pos:"+pos+",max:"+max);
    }
}

javaDebug

步骤

1. 打断点(一般在if，for那一行)
2. 追踪
3. Step over 下一行
4. Step in 进去函数/方法