条件判断/循环/

最新推荐文章于 2022-07-07 09:42:33 发布

Layyy~

最新推荐文章于 2022-07-07 09:42:33 发布

阅读量366

点赞数

本文链接：https://blog.csdn.net/Lil_Ghost/article/details/82988508

版权

If条件选择语句

if(条件表达式) // 表达式结果是布尔类型or直接放一个布尔类型的值

//小括号里面的结果如果是true就执行大括号 false则不执行

{

}

else
//false执行

{

}

用if else 比较三个数输出最大值
在这里插入图片描述

多重条件选择语句

else if 语句

if() {
}

else if() {
}

else {
}

eg 成绩优良差
在这里插入图片描述

switch语句

数据类型的限制 byte short
char int JDK1.7之后支持字符串类型 JDK1.5支持枚举类型

switch(要匹配的值) //常量或者变量不支持小数

{

case 项目: //待匹配的项只能是常量，不能是变量，所有的case项的值都是同一类型且每个case后的项不能重复

break; //结束这个switch语句可省略但会发生case穿透现象即向下再运行一个case语句直到遇到break语句

case 项目:
break;

default: //当所有的项都没有匹配时执行，不写不会报错，不一定写在最后
break;

}
eg成绩的判断
在这里插入图片描述

if和switch语句的区别

if 对true和false的判断

if可以对范围或具体值进行判断 switch只能对多个具体的常量进行判断

for循环

for(循环的初始值;循环的条件;控制循环语句) {
//条件表达式结果为true循环继续

}

while循环和do while循环

while(){

}

do {

//循环体 }while( 条件 )

do while循环 //至少执行一次

先执行do 里面的循环体，然后判断条件是否为true ，若为true，则继续执行

一般来说知道循环次数选用for循环，不知道循环次数用while

死循环

for( ; ; ){

}

While(true){

}

循环的嵌套

外层控制行，内层控制列

System.out.print(); //打印不换行

System.out.println();

System.out.print(“\n”);//换行

终止循环 break;
离开switch 和循环场景后没有意义

continue
跳出一次循环，进行下一次循环，用在循环场景中，离开此场景无意义

eg：请输出下列的形状
在这里插入图片描述

public class ForDemo7 {
    public static void main(String[] args) {
          for(int i=1;i<=5;i++){
            for(int j=1;j<=i;j++) {
                System.out.print("*");
            }
            System.out.print("\n");
        }
    }
}

方法重载概述和基本使用

public class MethodDemo3 {
    //方法重载
    public static void main(String[] args) {
        //我们在调用重载方法的时候,会根据传入的实参,去跟这这些重载方法的形参去匹配,匹配上哪个,就调用哪个
        int r3=sum(1,2,3,4);
         double sum = sum(2, 3.0);
        System.out.println(sum);
        System.out.println(r3);
        //方法重载:允许一个类中,出现多个同名方法,但是他们的参数个数或者参数 数据类型不同
        //跟返回值没关系
    }

    public static int sum(int i, int i1, int i2, int i3) {
        System.out.println("1");
        return i+i1+i2+i3;
    }

    public static int sum(int i, int i1, int i2) {
        System.out.println("2");
        return i+i1+i2;
    }
    public static int sum(int a, int b) {
        System.out.println("两个int参数的方法");
        return a + b;
    }

    public static double sum(int a, double b) {
        System.out.println("2个参数的方法,有一个参数是double");
        System.out.println("4");
        return a + b;
    }
}

Java中的内存分配以及栈和堆的区别
A:栈: 存放的是局部变量
局部变量：在方法定义中或者方法声明上的变量都是局部变量。
B:堆: 存放的是所有new出来的东西
特点：
a: 每一个new出来的东西都会为其分配一个地制值。
b: 每一个变量都有一个默认的值
byte，short，int，long – 0
float，double – 0.0
char – ‘\u0000’
boolean – false
引用数据类型 – null
c: 使用完毕就变成了垃圾，等待垃圾回收器对其回收
C:方法区:(面向对象部分讲解)
D:本地方法区:(和系统相关)
E:寄存器:(cpu使用)

数组

一维数组
数组概念
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型
数组定义格式
格式1：数据类型[] 数组名；
格式2：数据类型数组名[];
举例：
int[] a；定义了一个int类型的数组a；
int a[]; 定义了一个int类型的a数组；
数组的初始化动态初始化
概念：为数组中的数组元素分配内存空间，并为每个数组元素赋值。
分类：
a:动态初始化: 只指定长度，由系统给出初始化值
b:静态初始化: 给出初始化值，由系统决定长度
注意事项：这两种方式，只能使用一种，不能进行动静结合
动态初始化的格式：
数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例： int[] arr = new int[3]; 定义了一个int类型的数组arr，这个数组可以存放3个int 类型的值。
静态初始化的格式：
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例： int[] arr = new int[]{1,2,3};
简化格式：
数据类型[] 数组名 = {元素1,元素2,…};
举例： int[] arr = {1,2,3};
数组操作的两个常见小问题越界和空指针
a:rrayIndexOutOfBoundsException:数组索引越界异常
原因：你访问了不存在的索引。
b:NullPointerException:空指针异常
原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。

数组的操作遍历

  数组遍历：就是依次输出数组中的每一个元素。


 public class ArrayDemo8 {
    public static void main(String[] args) {
        int[] arr={3,9,9,30,54,36};
       // System.out.println(arr[0]);
        //遍历数组中的元素
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

数组的操作获取最值

public class ArrayDemo9 {
    public static void main(String[] args) {
         int[] arr={6,9,4,6,9,10,30};
        //定义一个参照变量
        int max = getMax(arr);
        System.out.println("最大值是" + max);
        int[] arr2 = {6, 9, 4, 6, 9, 10, 30,100,3};
        int max1 = getMax(arr2);
        System.out.println("最大值是" + max1);
    }

    public static int getMax(int[] arr){
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
}

数组的操作3反转

public class ArrayDemo91 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6};
        reverseArray(arr);
        System.out.println("---------------------------");
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+",");
        }
    }
    public static void reverseArray(int[] arr){
        //思路:首尾元素对调
        for (int i = 0; i < arr.length / 2; i++) {
            //定义中间变量进行值交换
            int t;
            t = arr[i];//把第一个元素给中间变量
            //首尾对调
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = t;
        }
    }
}

数组的操作4查表法

public class ArrayDemo92 {
    public static void main(String[] args) {
        String[] arr={"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个角标0---6");
        int index = scanner.nextInt();
        //调用方法
        String str=getElement(index,arr);
        System.out.println(str);
    }

    private static String getElement(int index, String[] arr) {
        if(index>=0&&index<arr.length){
            return arr[index];
        }else {
            return "输入的角标不正确";
        }
    }
}

二维数组

格式1:
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组
n表示每一个一维数组的元素个数
举例:
int[][] arr = new int[3][2];
定义了一个二维数组arr
这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
每个一维数组有2个元素，可以通过arr[m][n]来获取
表示获取第m+1个一维数组的第n+1个元素
格式2:
数据类型[][] 变量名 = new 数据类型[m][];
m表示这个二维数组有多少个一维数组
这一次没有直接给出一维数组的元素个数，可以动态的给出。
举例：
int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[1];

二维数组遍历

public class ArrayDemo5 {
    public static void main(String[] args) {
        //定义二维数组
        int[][] arr = new int[][]{{3, 6, 60}, {6, 9}, {9, 6}};
       for(int i=0;i<arr.length;i++){
           // System.out.println(arr[i]);
            for(int j=0;j<arr[i].length;j++){
                System.out.println(arr[i][j]);
            }
        }
    }
}

递归

java在方法内部，调用方法本身的现象称为递归

注意

递归要有出口，不然会成为死递归 //栈溢出
StackOverflowError

递归次数不易过多

show(i:5);

private static void show(int i){

System.out.println(“*”);

if(i<0){

return;

}else{

show(–i);

}

思想：拆分合并

Layyy~

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
条件判断/循环/

If条件选择语句if(条件表达式) // 表达式结果是布尔类型or直接放一个布尔类型的值//小括号里面的结果如果是true就执行大括号 false则不执行{}else//false执行{}用if else 比较三个数输出最大值多重条件选择语句else if 语句if() {}else if() {}else {}eg 成绩优良差switch语句...
复制链接

扫一扫