java-3月xly笔记

热爱111

已于 2023-03-14 16:35:41 修改

阅读量661

点赞数

分类专栏： IDEA 文章标签： java

于 2023-03-09 09:01:03 首次发布

本文链接：https://blog.csdn.net/ydyrx808/article/details/129415834

版权

IDEA 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

会议号：417 523 3263

服务器：doc.canglaoshi.org

jdk下载：https://repo.huaweicloud.com/java/jdk/

jdk配置环境变量

检测命令：
（1）win+r，输入cmd，回车
（2）java
（3）javac
需要配置：win+s，输入环境变量
配置JAVA_HOME(系统变量)
在这里插入图片描述
配置Path，新建，%JAVA_HOME%\bin

（4）java -version 查看jdk版本

一、数据类型

1、基本数据类型

（1）整型：默认是int
byte，存储范围：-128~127
short，存储范围：-32768~32767
int，存储范围：-2147483648~2147483647
long，超过int的存储范围，需要加后缀L(l)

（2）浮点型：默认是double
float，需要加后缀F(l)
double

（3）布尔型：只能是true或者是false
boolean

（4）字符型：只能存储一个汉字或者一个英文字母或者是一个数字
char

package cn.com;

/**
 * 数据类型-基本数据类型
 *
 */
public class Test2 {
    public static void main(String[] args) {
        //测试byte存储范围(-128~127)
        //定义变量格式：变量的类型 变量的名字 = 变量的值;
        byte a = -113;

        //变量名在方法里不能重复
        short s1 = 32767;
        System.out.println("s1修改之前的值" + s1);
        s1 = -32767;
        System.out.println("s1修改之后的值" + s1);

        //测试long
        long L1 = 2147483647;
        System.out.println(L1);
        L1 = 2147483648L;
        System.out.println(L1);

        //测试float和double
        float f1 = 3.0F;
        System.out.println(f1);
        double d1 = 4.0;
        System.out.println(d1);

        //测试boolean
        boolean b1 = true;
        System.out.println(b1);
        b1 = false;
        System.out.println(b1);

        //测试char
        char c1 = '达';
        System.out.println(c1);
        //c1 = '达内';    //只能存储一个中文汉字
        c1 = 'A';
        System.out.println(c1);
        c1 = 32768;//ascii码表   A65 B66 A97 b98
        System.out.println(c1);

    }
}

类型从大到小排序：
double > float > long > int > short > byte

类型转换规则：
大给小：需要强制转换（显式转换），强制转换可能会出现精度丢失问题

小给大：自动类型转换（隐式转换）

package cn.com;

/**
 * 基本数据类型转换
 * double > float > long > int > short > byte
 */
public class Test3 {
    public static void main(String[] args) {
        //大给小，需要强转转换
        byte b1 = 10;
        short s1 = 20;
        //byte = (强转的类型)short
        //强转的类型必须要和左边的的类型相等或者比左边的类型小
        b1 = (byte)s1;

        int i1 = 500;//小
        long L1 = 200;//大
        i1 = (short)L1;


        //小给大
        double d1 = 20.5;
        float f1 = -18.5F;
        d1 = f1;//大 = 小


        //测试
        short s2 = (short)50025;//小 = 大
        System.out.println(s2);
    }
}

2、引用类型（除了基本数据类型以外的）

二、运算符

1、算术运算符：+、-、、/、%（取模）、++、–
+、-、、/ 运算符进行运算时，可能会出现精度丢失的问题

package cn.com;

/**
 * 运算符-算术运算符
 */
public class Test4 {
    public static void main(String[] args) {
        //1、+
        float f1 = 3.0F;
        double d1 = 4.0;
        System.out.println(f1+d1);

        short s1 = 80;
        System.out.println("小明这次的周考成绩是："+s1+"分");

        //2、-
        double d2 = 15.0;
        double d3 = 8.3;
        System.out.println(d2-d3);

        //3、%(取模：求余数)
        byte b1 = 5;
        byte b2 = 3;
        //大取小，求余数
        System.out.println(b1%b2);

        //小取大，直接得到最小的那个数
        System.out.println(3%5);

        //4、++
        //（1）++前
        int i1 = 10;
        //++i1;//<=>  i1=i1+1
        System.out.println(++i1);//先运算，再赋值  //11
        System.out.println(i1);//11
        //（2）后++
        int i2 = 10;
        //i2++;//<=> i2=i2+1
        System.out.println(i2++);//先赋值，再运算  //10
        System.out.println(i2);//11

        //5、--
        int i5 = 0;
        int i6 = 0;

        int i3 = 20;
        //先运算，再赋值
        //--i3; //<=> i3=i3-1;    --i3=i3-1;
        i5 = --i3;
        System.out.println(i5);//19
        System.out.println(i3);//19

        int i4 = 20;
        //先赋值，再运算
        //i4--; //<=> i4=i4-1;    i4--=i4;    i4=i4-1
        i6 = i4--;
        System.out.println(i6);//20
        System.out.println(i4);//19
    }
}

2、赋值运算符：=、+=、-=、*=、/=、%=

package cn.com;

/**
 *  运算符-赋值运算符
 *  =、+=、-=、*=、/=、%=
 */
public class Test5 {
    public static void main(String[] args) {
        byte b1 = 10;
        byte b2 = 20;
        b1+=b2;//<=>b1=b1+b2;
        System.out.println(b1);//30
        b1-=b2;//<=>b1=b1-b2;
        System.out.println(b1);//10

        b2%=b1;//<=>b2=b2%b1;
        System.out.println(b2);//0
    }
}

3、关系运算符：>、<、>=、<=、==、!=

package cn.com;

/**
 * 运算符-关系运算符
 * >、<、>=、<=、==、!=
 */
public class Test6 {
    public static void main(String[] args) {
        int i1,i2,i3,i4,i5,i6;
        i1 = 10;
        i2 = 20;
        i3 = 35;
        i4 = 40;
        i5 = 55;
        i6 = 70;
        System.out.println(i3>i1);//true
        System.out.println(i4<=i6);//true
        System.out.println(i2==i5);//false
        i1+=10;
        System.out.println(i1!=i2);//false
    }
}

4、逻辑运算符：&&(与)、||(或)、!(非)

package cn.com;

/**
 * 运算符-逻辑运算符
 * &&(与)、||(或)、!(非)
 * &&   两边都为true，结果才为true，如果有一个为false，结果则为false
 *
 * ||   两边只要有一个为true，则为true，如果都是false，结果才是false
 *
 * !    取反
 */
public class Test7 {
    public static void main(String[] args) {
        int i1,i2,i3,i4;
        boolean b1,b2;
        i1 = 15;
        i2 = 25;
        i3 = -18;
        i4 = 99;
        //true && false
        b1 = (i1>i3) && (i1>i4);//false
        //false && true
        b2 = (i2>i4) || (i2>i1);//true
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(!b1);//true
        b2=!b1;
        System.out.println(b2);//true
    }
}

5、条件运算符(三元或者三目)：
A?a:b;
如果A为true，则走a，如果A为false，则走b

package cn.com;

/**
 * 运算符-三元运算符
 */
public class Test8 {
    public static void main(String[] args) {
        int b2,b3;
        b2 = 10;
        b3 = 20;
        
        //A>B?a:b;
        String s1 = b2>b3?"b2的值大":"b3的值大";
        System.out.println(s1);
    }
}

作业：
一、交换两个变量的值
编写步骤：

定义类Homework6
定义 main方法
定义两个整数变量a，b并赋值
控制台输出变量a，b互换前的值
定义一个第三方变量temp
利用第三方变量temp使a，b的值互换
控制台输出变量a，b互换后的值

package cn.com;

/**
 * 一、交换两个变量的值
 * 编写步骤：
 * 1. 定义类Homework6
 * 2. 定义 main方法
 * 3. 定义两个整数变量a，b并赋值
 * 4. 控制台输出变量a，b互换前的值
 * 5. 定义一个第三方变量temp
 * 6. 利用第三方变量temp使a，b的值互换
 * 7. 控制台输出变量a，b互换后的值
 */
public class Homework6 {
    public static void main(String[] args) {
        int a,b,temp;
        a=10;
        b=20;
        System.out.println("a = " + a);//a=10
        System.out.println("b = " + b);//b=20
        temp = a;//temp=10,a=10
        a = b;//a=20,b=20
        b = temp;//b=10,a=20
        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
}

二、
编写步骤：

定义类 Homework7
定义 main方法
定义2个int类型变量x、y，x赋值为100，y赋值为200
定义新变量add，保存变量x，y的和并打印到控制台
定义新变量sub，保存变量x，y的差并打印到控制台
定义新变量mul，保存变量x，y的积并打印到控制台
定义新变量div，保存变量x，y的商并打印到控制台

package cn.com;

/**
 * 二、
 * 编写步骤：
 *
 * 1. 定义类 Homework7
 * 2. 定义 main方法
 * 3. 定义2个int类型变量x、y，x赋值为100，y赋值为200
 * 4. 定义新变量add，保存变量x，y的和并打印到控制台
 * 5. 定义新变量sub，保存变量x，y的差并打印到控制台
 * 6. 定义新变量mul，保存变量x，y的积并打印到控制台
 * 7. 定义新变量div，保存变量x，y的商并打印到控制台
 */
public class Homework7 {
    public static void main(String[] args) {
        int x,y,add,sub,mul,div;
        x=100;
        y=200;

        add=x+y;
        sub=x-y;
        mul=x*y;
        div=x/y;
        System.out.println(add);
        System.out.println(sub);
        System.out.println(mul);
        System.out.println(div);
    }
}

三、
编写步骤：

定义类 Homework8
定义 main方法
定义2个double类型变量x、y，x赋值为100.8，y赋值为20.6
定义新变量add，保存变量x，y的和并打印到控制台
定义新变量sub，保存变量x，y的差并打印到控制台
定义新变量mul，保存变量x，y的积并打印到控制台
定义新变量div，保存变量x，y的商并打印到控制台

package cn.com;

/**
 * 三、
 * 编写步骤：
 * 1. 定义类 Homework8
 * 2. 定义 main方法
 * 3. 定义2个double类型变量x、y，x赋值为100.8，y赋值为20.6
 * 4. 定义新变量add，保存变量x，y的和并打印到控制台
 * 5. 定义新变量sub，保存变量x，y的差并打印到控制台
 * 6. 定义新变量mul，保存变量x，y的积并打印到控制台
 * 7. 定义新变量div，保存变量x，y的商并打印到控制台
 */
public class Homework8 {
    public static void main(String[] args) {
        double x,y,add,sub,mul,div;
        x=100.8;
        y=20.6;

        add=x+y;
        sub=x-y;
        mul=x*y;
        div=x/y;
        System.out.println(add);
        System.out.println(sub);
        System.out.println(mul);
        System.out.println(div);
    }
}

四、强制类型转换练习
（1）先声明两个byte类型的变量b1,b2,并分别赋值为10和20，求b1和b2变量的和，并将结果保存在byte类型的变量b3中，最后输出b3变量的值

（2）先声明两个short类型的变量s1,s2,并分别赋值为1000和2000，求s1和s2变量的和，并将结果保存在short类型的变量s3中，最后输出s3变量的值

（3）先声明1个char类型的变量c1赋值为’a’，再声明一个int类型的变量num赋值为5，求c1和num变量的和，并将结果将结果保存在char类型的变量letter中，最后输出letter变量的值。

（4）先声明两个int类型的变量i1,i2，并分别赋值5和2，求i1和i2的商，并将结果保存在double类型的变量result中，最后输出result变量的值。如何得到结果2.5呢？

package cn.com;

/**
 * 四、 强制类型转换练习
 * （1）先声明两个byte类型的变量b1,b2,并分别赋值为10和20，求b1和b2变量的和，
 * 并将结果保存在byte类型的变量b3中，最后输出b3变量的值
 *
 * （2）先声明两个short类型的变量s1,s2,并分别赋值为1000和2000，求s1和s2变量的和，
 * 并将结果保存在short类型的变量s3中，最后输出s3变量的值
 *
 * （3）先声明1个char类型的变量c1赋值为'a'，再声明一个int类型的变量num赋值为5，
 * 求c1和num变量的和，并将结果将结果保存在char类型的变量letter中，最后输出letter变量的值。
 *
 * （4）先声明两个int类型的变量i1,i2，并分别赋值5和2，求i1和i2的商，
 * 并将结果保存在double类型的变量result中，最后输出result变量的值。如何得到结果2.5呢？
 */
public class Homework9 {
    public static void main(String[] args) {
        //1
        byte b1,b2,b3;
        b1=10;
        b2=20;
        b3=(byte)(b1+b2);//运算时，会自动提升成int类型
        System.out.println(b3);

        //2
        short s1,s2,s3;
        s1=1000;
        s2=2000;
        s3 = (short)(s1+s2);//运算时，会自动提升成int类型
        System.out.println("s3 = " + s3);

        //3
        char c1 = 'a';
        int num = 5;
        char letter;
        letter=(char)(c1+num);
        System.out.println(letter);

        //4
        int i1,i2;
        i1=5;
        i2=2;
        double result = i1/(double)i2;
        System.out.println(result);
    }
}

五、

定义两个int类型变量a1和a2,分别赋值10,11,判断变量是否为偶数,拼接输出结果
定义两个int类型变量a3和a4,分别赋值12,13,判断变量是否为奇数,拼接输出结果

package cn.com;

/**
 * 五、
 * 1. 定义两个int类型变量a1和a2,分别赋值10,11,判断变量是否为偶数,拼接输出结果
 * 2. 定义两个int类型变量a3和a4,分别赋值12,13,判断变量是否为奇数,拼接输出结果
 */
public class Homework10 {
    public static void main(String[] args) {
        int a1,a2,a3,a4;
        a1=10;
        a2=11;
        a3=12;
        a4=13;
        //第一种方式
        boolean b1;
        b1=a1%2==0;
        System.out.println(a1+"是偶数"+b1);
        b1=a2%2==0;
        System.out.println(a2+"是偶数"+b1);

        b1=a3%2!=0;
        b1=a4%2!=0;
        System.out.println(a3+"是奇数"+b1);
        System.out.println(a3+"是奇数"+b1);

        //第二种方式
        System.out.println(a1%2==0?"是偶数":"不是偶数");
        System.out.println(a2%2==0?"是偶数":"不是偶数");
        System.out.println(a3%2!=0?"是奇数":"不是奇数");
        System.out.println(a4%2!=0?"是奇数":"不是奇数");
    }
}

三、流程控制语句

1、分支结构

（1）if…else

package cn.com;

import java.util.Scanner;

/**
 * if...else结构，两条路只能选其一
 * 如果b1为true，则执行代码1，如果b1为false，则执行代码2
 * 语法格式：
 * if(b1) {
 *    //代码1、业务1
 * } else{
 *     //代码2、业务2
 * }
 *
 * 说明：可以只有if，但没有else，不可以只有else，没有if
 */
public class Test9 {

    //方法
    public static void main(String[] args) {
        int score = 80;//小明的周考成绩

        if(score>=90) {
            System.out.println("奖励一台ipad");
        } else {
            System.out.println("不奖励");
        }


        /**
         *  例子1:从键盘分别接收两个整数，第一个小的整数的值给变量small
         *  第二个大的整数的值给变量big
         *  如果输入的第一个整数大于第二个整数，就进行交换
         *  最后输出显示small和big变量的值
         */
        Scanner input = new Scanner(System.in);//创建scanner对象
        System.out.println("请输入第一个整数：");
        int small = input.nextInt();//需要输入第一个整数
        System.out.println("请输入第二个整数：");
        int big = input.nextInt();//需要输入第二个整数
        System.out.println(small);
        System.out.println(big);
        if(small>big) {
            int temp;
            temp = small;
            small = big;
            big = temp;
        }
        System.out.println(small);
        System.out.println(big);
    }
}

（2）if…else if…else

package cn.com;

import java.util.Scanner;

/**
 * 分支结构-第二种
 * <p>
 * 如果b1为true，执行代码1、业务1
 * 如果b2为true，执行代码2、业务2
 * 如果b1和b2都不为true,执行else的代码4、业务4
 * <p>
 * 语法格式：
 * if(b1) {
 * 代码1、业务1
 * } else if(b2) {
 * 代码2、业务2
 * }
 * 。。。。。
 * else {
 * 代码4、业务4
 * }
 */
public class Test10 {
    public static void main(String[] args) {
        /**
         * 例子：
         * 从控制台接收一个整数，这个整数代表考试成绩
         * 根据考试成绩，判断学生等级，成绩范围[0,100]
         * 90-100   优秀
         * 80-89    好
         * 70-79    良
         * 60-69    及格
         * 60以下    不及格
         */
        Scanner input = new Scanner(System.in);
        System.out.println("请输入成绩[0,100]");
        int score = input.nextInt();

        if (score < 0 || score > 100) {
            System.out.println("你的成绩输入有误！");
        } else if (score >= 90) {
            System.out.println("你的成绩属于优秀");
        } else if (score >= 80) {
            System.out.println("你的成绩属于好");
        } else if (score >= 70) {
            System.out.println("你的成绩属于良");
        } else if (score >= 60) {
            System.out.println("你的成绩属于及格");
        } else {
            System.out.println("你的成绩属于不及格");
        }

        /**
         * 例子2：
         * 从键盘输入一个年份值和月份值，输出该月的总天数
         * 要求：年份为正数，月份1-12
         *
         * 例如：输入2022年5月，总天数是31天
         * 输入2022年2月，总天数是28天
         * 输入2020年2月，总天数是29天
         * 输入2024年2月，总天数是29天
         *
         * 闰年：能被4整除，但不能被100整除，或者能被400整除
         * 平年，除了闰年之外的
         */


        //1、从键盘输入一个年份值和月份值
        Scanner input1 = new Scanner(System.in);
        System.out.println("请输入年份：");
        int year = input1.nextInt();
        System.out.println("请输入月份：");
        int month = input1.nextInt();
        int days = 0;

        if (year > 0) {//判断年份是否>0
            if (month >= 1 && month <= 12) {
                if (month == 2) {
                    if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {//闰年
                        days = 29;
                    } else {//平年
                        days = 28;
                    }
                } else if (month == 4 || month == 6 || month == 9 || month == 11) {
                    days = 30;
                } else {
                    days = 31;
                }
                System.out.println(year + "年" + month + "月天数：" + days);
            } else {
                System.out.println("月份输入不合法！");
            }
        } else {
            System.out.println("年份输入不合法！");
        }
    }
}

（3）switch…case

package cn.com;

import java.util.Scanner;

/**
 * 分支结构
 *
 * 语法格式：
 * switch(value) {
 *     case value1:
 *        执行语句1;
 *        (break;)
 *     case value2:
 *        执行语句2;
 *        (break;)
 *     case value3:
 *       执行语句3;
 *       (break;)
 *     ......
 *     default:
 *       执行默认语句;
 * }
 *
 *  value只能是byte、short、int、char、String、enum
 */
public class Test11 {
    public static void main(String[] args) {
        /**
         * 案例：
         * 从键盘输入星期的整数值，输出对应星期的英文单词
         */
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入星期值：");
        int weekday = sc.nextInt();
        switch (weekday) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            case 4:
                System.out.println("Thursday");
                break;
            case 5:
                System.out.println("Friday");
                break;
            case 6:
                System.out.println("Saturday");
                break;
            case 7:
                System.out.println("Sunday");
                break;
            default:
                System.out.println("你输入的星期值有误！");
        }

        /**
         * 案例
         * 指定一个月份，输出该月份对应的季节
         * 一年有四季
         * 3,4,5    春季
         * 6,7,8    夏季
         * 9,10,11  秋季
         * 12,1,2   冬季
         */
        Scanner sc1 = new Scanner(System.in);
        System.out.println("请输入月份：");
        int month = sc1.nextInt();
        /*switch (month) {
            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;
            case 8:
                System.out.println("夏季");
                break;
            case 9:
                System.out.println("秋季");
                break;
            case 10:
                System.out.println("秋季");
                break;
            case 11:
                System.out.println("秋季");
                break;
            case 12:
                System.out.println("冬季");
                break;
            default:
                System.out.println("输入的月份有误！");
        }*/

        //改进版
        switch (month) {
            case 1:
            case 2:
            case 12:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            default:
                System.out.println("输入的月份有误！");
        }
    }
}

2、循环语句

（1）for

package cn.com;

/**
 * 循环语句-for
 * 语法格式：
 * for(初始化语句①;循环条件语句②;迭代语句④) {
 *     循环体语句③
 * }
 *
 * 注意：
 * （1）for(;;)中，两个;一定不能少
 * （2）循环条件必须boolean类型
 */
public class Test12 {
    public static void main(String[] args) {
        /**
         * 案例：输出从1-100
         */
        for(int i=1;i<101;i++) {
            System.out.println(i);
        }

        /**
         * 案例2：输出从100到1
         */
        for(int i=100;i>0;i--) {
            System.out.println(i);
        }

        System.out.println("---案例3---");
        /**
         * 案例3：输出1-100之间以3结尾的数
         */
        for(int i=1;i<101;i++) {
            if(i%10==3) {
                System.out.println(i);
            }
        }

        /**
         * 案例4：输出1-100之间是3的倍数的数
         */
        System.out.println("---案例4---");
        for(int i=1;i<101;i++) {
            if(i%3==0) {
                System.out.println(i);
            }
        }
    }
}

（2）while

package cn.com;

/**
 * 循环语句-while
 * 语发格式：
 * while(循环条件语句①) {
 *     循环体语句②;
 * }
 *
 * 注：循环条件必须是boolean类型
 */
public class Test13 {
    public static void main(String[] args) {
        /**
         * 案例：输出1到100
         */
        int num = 1;
        while(num < 101) {
            System.out.println(num);
            num++;
        }

        System.out.println("---案例1---");
        /**
         * 案例1：输出100到1
         */
        int num1 = 100;
        while(num1 > 0) {
            System.out.println(num1);
            num1--;
        }

        System.out.println("---案例2---");
        /**
         * 案例2：输出1-100之间是3的倍数的数
         */
        int num2 = 1;
        while(num2 < 101) {
            if(num2%3==0) {
                System.out.println(num2);
            }
            num2++;
        }

        System.out.println("---案例3---");
        /**
         * 案例3：输出1到100之间以3结尾的数
         */
        int num3 = 1;
        while(num3 < 101) {
            if(num3%10==3) {
                System.out.println(num3);
            }
            num3++;
        }
        //4:25继续
    }
}

（3）do while

package cn.com;

/**
 * 循环语句-do while
 * 语法格式：
 * do {
 *     循环体语句①
 * } while(循环条件语句②);
 *
 * 注意：
 * （1）循环条件语句必须是boolean类型
 * （2）do{} while(); 有个分号;
 * （3）do while循环不同于for和while,do while至少会执行一次
 */
public class Test14 {
    public static void main(String[] args) {
        /**
         * 案例：输出1-100
         */
        int num1 = 1;
        do {
            System.out.println(num1);
            num1++;
        } while(num1<101);

        System.out.println("---案例1---");
        /**
         * 案例1：输出100-1
         */
        int num2 = 100;
        do{
            System.out.println(num2);
            num2--;
        } while(num2>0);

        System.out.println("---案例2---");
        /**
         * 案例2：输出1-100是3的倍数的数
         */
        int num3 = 1;
        do{
            if(num3%3==0) {
                System.out.println(num3);
            }
            num3++;
        }while(num3<101);

        System.out.println("---案例3---");
        /**
         * 案例3：输出1-100以3结尾的数
         */
        int num4 = 1;
        do{
          if(num4%10==3) {
              System.out.println(num4);
          }
          num4++;
        }while(num4<101);
    }
}

作业：
一、案例：为抵抗洪水，战士连续作战89小时，编程计算共多少天零多少小时？

定义一个int类型变量hours，赋值为89
定义一个int类型变量day，用来保存89小时中天数的结果
定义一个int类型变量hour，用来保存89小时中不够一天的剩余小时数的结果
输出结果

package cn.com;

/**
 * 一、案例：为抵抗洪水，战士连续作战89小时，编程计算共多少天零多少小时？
 *
 * 定义一个int类型变量hours，赋值为89
 * 定义一个int类型变量day，用来保存89小时中天数的结果
 * 定义一个int类型变量hour，用来保存89小时中不够一天的剩余小时数的结果
 * 输出结果
 */
public class Homework21 {
    public static void main(String[] args) {
        int hours = 89;
        int day = 0;
        int hour = 0;

        int i = 0;
        while(i == 0) {
            if(hours-24>=0) {
                day++;
                hours-=24;
            } else {
                hour = hours;
                break;
            }
        }

        System.out.println(day);
        System.out.println(hour);
    }
}

二、今天是周2，100天以后是周几？

定义一个int类型变量week，赋值为2
修改week的值，在原值基础上加上100
修改week的值，在原值基础上模以7
输出结果，在输出结果的时候考虑特殊值，例如周日

package cn.com;

/**
 * 二、今天是周2，100天以后是周几？
 *
 * 定义一个int类型变量week，赋值为2
 * 修改week的值，在原值基础上加上100
 * 修改week的值，在原值基础上模以7
 * 输出结果，在输出结果的时候考虑特殊值，例如周日
 */
public class Homework22 {
    public static void main(String[] args) {
        int week = 7;
        week+=100;
        week%=7;
        System.out.println(week);
    }
}

三、求三个整数x,y,z中的最大值

定义三个int类型变量,x,y,z，随意赋值整数值
定义一个int类型变量max，先存储x与y中的最大值（使用三元运算符）
再次对max赋值，让它等于上面max与z中的最大值（使用三元运算符）
输出结果

package cn.com;

/**
 * 三、求三个整数x,y,z中的最大值
 *
 * 定义三个int类型变量,x,y,z，随意赋值整数值
 * 定义一个int类型变量max，先存储x与y中的最大值（使用三元运算符）
 * 再次对max赋值，让它等于上面max与z中的最大值（使用三元运算符）
 * 输出结果
 */
public class Homework23 {
    public static void main(String[] args) {
        int x = 0;
        int y = -13;
        int z = 27;
        int max =x>y?(x>z?x:z):(y>z?y:z);
        System.out.println(max);
    }
}

四、计算折扣后金额
从键盘输入订单总价格totalPrice（总价格必须>=0），根据优惠政策计算打折后的总价格。
编写步骤：

判断当totalPrice >=500 ,discount赋值为0.8
判断当totalPrice >=400 且<500时,discount赋值为0.85
判断当totalPrice >=300 且<400时,discount赋值为0.9
判断当totalPrice >=200 且<300时,discount赋值为0.95
判断当totalPrice >=0 且<200时,不打折，即discount赋值为1
判断当totalPrice<0时，显示输入有误
输出结果

package cn.com;

import java.util.Scanner;

/**
 * 四、计算折扣后金额
 * 从键盘输入订单总价格totalPrice（总价格必须>=0），根据优惠政策计算打折后的总价格。
 * 编写步骤：
 *
 * 判断当totalPrice >=500 ,discount赋值为0.8
 * 判断当totalPrice >=400 且<500时,discount赋值为0.85
 * 判断当totalPrice >=300 且<400时,discount赋值为0.9
 * 判断当totalPrice >=200 且<300时,discount赋值为0.95
 5. 判断当totalPrice >=0 且<200时,不打折，即discount赋值为1
 6. 判断当totalPrice<0时，显示输入有误
 7. 输出结果
 */
public class Homework24 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int totalPrice = scanner.nextInt();
        if(totalPrice>=500) {
            totalPrice*=0.8;
            System.out.println(totalPrice);
        } else if(totalPrice>=400 && totalPrice<500) {
            totalPrice*=0.85;
            System.out.println(totalPrice);
        } else if(totalPrice>=300 && totalPrice<400) {
            totalPrice*=0.9;
            System.out.println(totalPrice);
        } else if(totalPrice>=200 && totalPrice<300) {
            totalPrice*=0.95;
            System.out.println(totalPrice);
        } else if(totalPrice>=0 && totalPrice<200) {
            totalPrice*=1;
            System.out.println(totalPrice);
        } else if(totalPrice<0) {
            System.out.println("输入有误！");
        }
    }
}

五、计算今天是星期几

定义变量week赋值为上一年12月31日的星期值（可以通过查询日历获取），定义变量year、month、day，分别赋值今天日期年、月、日值。计算今天是星期几。

package cn.com;

/**
 * 定义变量week赋值为上一年12月31日的星期值（可以通过查询日历获取），
 * 定义变量year、month、day，分别赋值今天日期年、月、日值。计算今天是星期几。
 */
public class Homework25 {
    public static void main(String[] args) {
        int week = 6;
        int year = 2023;
        int month = 3;
        int day = 13;

        //是闰年
        for (int i = 1; i < month; i++) {
            switch (i) {
                case 2:
                    day += 28;
                    break;
                case 1:
                case 3:
                case 5:
                case 7:
                case 8:
                case 10:
                case 12:
                    day += 31;
                    break;
                default:
                    day += 30;
                    break;
            }
        }

        day+=week;
        day%=7;
        System.out.println(day);
    }
}

六、5个一行输出1-100之间的偶数
输出1-100偶数，每5个一行，一行中的每个数字之间使用逗号分隔

package cn.com;

/**
 * 六、5个一行输出1-100之间的偶数
 * 输出1-100偶数，每5个一行，一行中的每个数字之间使用逗号分隔
 */
public class Homework26 {
    public static void main(String[] args) {
        for(int i = 1;i < 101;i++) {
            if(i%2==0) {
                System.out.println(i);
            }
        }
    }
}

七、计算这一天是这一年的第几天
案例需求：从键盘分别输入年、月、日，使用循环for+if实现，判断这一天是当年的第几天

package cn.com;

/**
 * 计算这一天是这一年的第几天
 * 案例需求：从键盘分别输入年、月、日，使用循环for+if实现，判断这一天是当年的第几天
 */
public class Homework27 {
    public static void main(String[] args) {
        int year = 2020;
        int month = 3;
        int day = 13;

        //是闰年
        if((year%4==0 && year%100!=0) || (year%400==0)) {
            for(int i = 1;i < month;i++) {
                switch (i) {
                    case 2:
                        day+=29;
                        break;
                    case 1:
                    case 3:
                    case 5:
                    case 7:
                    case 8:
                    case 10:
                    case 12:
                        day+=31;
                        break;
                    default:
                        day+=30;
                        break;
                }
            }
        } else {//不是闰年
            for(int i = 1;i < month;i++) {
                switch (i) {
                    case 2:
                        day+=28;
                        break;
                    case 1:
                    case 3:
                    case 5:
                    case 7:
                    case 8:
                    case 10:
                    case 12:
                        day+=31;
                        break;
                    default:
                        day+=30;
                        break;
                }
            }
        }
        System.out.println(day);
    }
}

（4）三种循环分别实现死循环

package cn.com;

/**
 * 利用三种循环分别实现死循环
 */
public class Test15 {
    public static void main(String[] args) {
        //1、for
        //for(;;) {//死循环
            //System.out.println("for死循环");
        //}

        //2、while
        //while(true) {
            //System.out.println("while死循环");
       // }

        //3、do while
        //do {
            //System.out.println("do while死循环");
        //} while(true);


        //2-1、while
        int num = 1;
        while(num>0) {
            System.out.println("while死循环");
            num++;
        }
    }
}

（5）输出1-100之间所有的偶数，每5个数一行，每个数分别用,隔开

package cn.com;

/**
 * 输出1-100之间所有的偶数，每5个数一行，每个数分别用,隔开
 */
public class Test16 {
    public static void main(String[] args) {
//        System.out.println("123");        //打印后会进行换行
//        System.out.print("123");  //只打印，不会换行
        //System.out.println(); //换行

        int count = 0;

        for(int num=1;num < 101;num++) {
            if(num%2==0) {//%2==0
                if(count!=4) {
                    System.out.print(num + ",");
                    count++;
                } else {
                    System.out.print(num);
                    count++;
                }
            }
            if(count==5) {
                System.out.println();
                count=0;
            }
        }
    }
}

（6）嵌套循环


package cn.com;

/**
 * 嵌套循环：打印机三角形
 */
public class Test17 {
    public static void main(String[] args) {
//        *
//        **
//        ***
//        ****
//        *****

        for(int x=1;x<6;x++) {//用外循环来控制行数
            //再用内循环来控制每一行的个数
            for(int y=0;y<x;y++) {
                System.out.print("*");
            }
            System.out.println();//进行换行操作
        }

        System.out.println("---while---");
        //2、while
        int x = 1;
        while(x < 6) {//外循环控制外面的行数
            //内循环控制里面的个数
            int y = 1;
            while(y<(x+1)) {
                System.out.print("*");
                y++;
            }
            System.out.println();
            x++;
        }

        //3、do while
        System.out.println("---do while---");
        int num1 = 1;
        do{//外循环控制行数
            int num2 = 1;
            do{//内循环控制里面的个数
                System.out.print("*");
                num2++;
            }while(num2<(num1+1));

            System.out.println();//进行换行操作
            num1++;
        } while(num1<6);


        //     *
        //    **
        //   ***
        //  ****
        // *****
        System.out.println("-----222-----");
        for(int num3=1;num3<6;num3++) {//外循环控制行数
            for(int numx=5-num3;numx>=1;numx--) {//打印空格
                System.out.print(" ");
            }
            for(int numy=1;numy<=num3;numy++) {//打印*
                System.out.print("*");
            }
            System.out.println();
        }

        //  *****
        //  ****
        //  ***
        //  **
        //  *
        System.out.println("-----333-----");
        for(int num5=1;num5<6;num5++) {//外循环控制行数
            for(int num6=6;num6>num5;num6--) {//内循环来控制每一行的个数
                System.out.print("*");
            }
            System.out.println();
        }

        //  *****
        //   ****
        //    ***
        //     **
        //      *
        System.out.println("-----444-----");
        for(int num7=1;num7<6;num7++) {//外循环控制行数
            for(int numx=num7-1;numx>=1;numx--) {//打印空格
                System.out.print(" ");
            }
            for(int numy=6;numy>num7;numy--) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

四、数组(Array)

1、定义：数组就是一个容器，主要用来存放同一种类型的多个数据（可重复）

2、声明、创建方式

package cn.com;

/**
 * 数组(Array)
 * 数组就是一个容器，主要用来存放同一种类型的多个数据（可重复）
 *
 * 声明、创建方式：
 * （1）静态
 *  语法格式：
 *  数组的类型[] 数组的名字 = {值1,值2,值3....};
 *  或者
 *  数组的类型[] 数组的名字 = new 数组的类型[]{值1,值2,值3.......};
 *
 *  （2）动态
 *  语法格式：
 *  数组的类型[] 数组的名字 = new 数组的类型[数组的长度];
 *  数组的长度(length)=数组元素的个数
 *  数组的下标=[0,数组的长度-1]
 */
public class Test19 {
    public static void main(String[] args) {
        //1、静态创建数组
        int[] intArray1 = {1,6,3,9,5,2,7,8,4,10};//下标就是[0,9]
        //对应的下标         0 1 2 3 4 5 6 7 8  9

        int[] intArray2 = new int[]{1,2,3,4,5,6,7,8,9,10};//下标就是[0,9]

        //2、动态创建数组
        int[] intArray3 = new int[10];//下标就是[0,9]
        //输出数组的长度
        System.out.println(intArray3.length);

        //3、通过数组的下标得到元素
        int value1 = intArray1[2];
        System.out.println("value1："+value1);

        //4、通过数组的下标获取所有的元素  借助循环
        for(int x = 0;x<intArray1.length;x++) {//遍历
            System.out.println(intArray1[x]);
        }
        //4-2、借助while来遍历
        System.out.println("---while---");
        int x = 0;
        while(x < intArray2.length) {
            System.out.print(intArray2[x] + " ");
            x++;
        }
        System.out.println();
        System.out.println("---do while---");
        //4-3、借助do while来遍历
        int y = 0;
        while(y < intArray2.length) {
            System.out.print(intArray2[y] + " ");
            y++;
        }
    }
}

3、动态数组赋值

package cn.com;

/**
 * 给动态数组赋值
 * 数组的类型[] 数组的名字 = new 数组的类型[数组的长度];
 */
public class Test20 {
    public static void main(String[] args) {
        int[] intArray1 = new int[10];
        //给下标为0的元素，也就是给第一个元素赋值
        intArray1[0] = 1;
        for(int i = 0;i < intArray1.length;i++) {
//            System.out.print(intArray1[i] + " ");
        }

        //给整个数组赋值
        for(int i = 1;i < intArray1.length;i++) {
            intArray1[i] = i+1;
        }
        //输出整个数组的元素（遍历）
        for(int i = 0;i < intArray1.length;i++) {
            System.out.print(intArray1[i] + " ");
        }
    }
}

4、数组的练习

package cn.com;

/**
 * 数组求和、平均值、偶数的个数
 */
public class Test21 {
    public static void main(String[] args) {
        System.out.println("---求和以及平均值---");
        int[] intArray1 = {1,3,5,7,13};
        int sum = 0;
        //借助循环
        for(int i=0;i < intArray1.length;i++) {
            sum+=intArray1[i];
        }
        System.out.println("sum="+sum);

        double avg = (double)sum/intArray1.length;
        System.out.println(avg);

        System.out.println("---求数组中偶数的个数---");
        int[] intArray2 = {14,25,77,88,39,21,-15};
        int count = 0;//相当于是计数器
        for(int i = 0;i < intArray2.length;i++) {
            if(intArray2[i]%2==0) {
                count++;
            }
        }
        System.out.println(count);
    }
}

作业：
1、月份
用一个数组，保存12个月的英语单词，从键盘输入1-12，显示对应的单词。

{"January","February","March","April","May","June","July","August","September","October","November","December"}

package cn.com;

import java.util.Scanner;

/**
 * 1、月份
 * 用一个数组，保存12个月的英语单词，从键盘输入1-12，显示对应的单词。
 * {"January","February","March","April","May","June","July","August","September","October","November","December"}
 */
public class Homework31 {
    public static void main(String[] args) {
        String[] strArr1 = {"January","February","March","April","May","June","July","August","September","October","November","December"};
        int num = new Scanner(System.in).nextInt();
        System.out.println(strArr1[num-1]);
    }
}

2、打印扑克牌
遍历输出一副扑克牌。

String[] hua = {"黑桃","红桃","梅花","方片"};
String[] dian = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

package cn.com;

/**
 * 2、打印扑克牌
 * 遍历输出一副扑克牌。
 * String[] hua = {"黑桃","红桃","梅花","方片"};
 * String[] dian = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
 */
public class Homework32 {
    public static void main(String[] args) {
        String[] hua = {"黑桃","红桃","梅花","方片"};
        String[] dian = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        for(int x = 0;x < hua.length;x++) {
            for(int y = 0;y < dian.length;y++) {
                System.out.print(hua[x] + dian[y] + " ");
            }
            System.out.println();
        }

        for(int x = 0;x < dian.length;x++) {
            for(int y = 0;y < hua.length;y++) {
                System.out.print(hua[y] + dian[x] + " ");
            }
            System.out.println();
        }
    }
}

5、数组的练习-2

package cn.com;

import java.util.Arrays;

/**
 * {1,7,14,21,35,-16,28,59}
 * 拆分成两个数组，一个是奇数数组，一个是偶数数组
 * 最后遍历输出奇数数组的元素、偶数数组的元素
 */
public class Test23 {
    public static void main(String[] args) {
        int[] intArray1 = {1,7,14,21,35,-16,28,59};
        //1、通过intArray1确定奇数数组的长度和偶数数组的长度

        int len1,len2; //len1奇数数组长度，len2偶数数组长度
        len1=0;len2=0;


        //遍历intArray1
        for(int i = 0;i < intArray1.length;i++) {
            if(intArray1[i]%2==0) {//如果是偶数，len2++
                len2++;
            } else {//是奇数，len1++
                len1++;
            }
        }

        //2、定义奇数数组和偶数数组
        int[] len1Array1 = new int[len1];//奇数数组
        int[] len2Array1 = new int[len2];//偶数数组

        //3、给奇数数组和偶数数组分别赋值
        int x = 0;
        int y = 0;

        int num1 = 0;
        while(num1<intArray1.length) {
            if(intArray1[num1]%2==0) {//往偶数数组里面赋值
                len2Array1[x] = intArray1[num1];
                x++;
            } else {//往奇数数组里面赋值
                len1Array1[y] = intArray1[num1];
                y++;
            }

            num1++;
        }

        //遍历输出奇数数组和偶数数组
        System.out.println("奇数数组：" + Arrays.toString(len1Array1));
        System.out.println("偶数数组：" + Arrays.toString(len2Array1));
    }
}

五、方法

package cn.com;

/**
 * 项目
 * ---module(模块)
 * ------src
 * ---------包
 * ------------类
 * ---------------方法、属性(变量或者常量)、代码块...
 *
 * static：静态
 * 静态里面只能调用静态的东西，不能调用非静态的东西
 *
 * 方法的构成：
 * 修饰符 (static) 返回值 方法的名字(方法的形参) {
 *     执行语句或者业务代码
 * }
 *
 * （1）修饰符：
 *  public       公开的，全局都可访问
 *  protected   受保护的
 *  default     默认的
 *  private     私有的，只能在本类访问
 *
 * （2）返回值
 *  ①void
 *  ②返回的类型，比如int、double、char、boolean.......
 *  如果是void，代表这个方法不需要返回值
 *  如果是有返回的类型，代表这个方法需要返回相应类型的值，借助return
 *  方法的返回值如何获取？ 返回值的类型 变量的名字 = 方法名字(形参);
 *
 *  （3）方法的名字
 *  要求：名字不能有重复
 *
 *  （4）方法的形参
 *   ①形参的类型必须要和实参的类型一致
 *   ②形参可以有多个，也可以一个都没有
 */
public class Test24 {

    //程序的入口
    public static void main(String[] args) {//静态方法
        //调用m1
        m1(args);

        //m2(args);
    }

    //普通static方法
    private static void m1(String[] args) {//静态方法
        //功能：判断两个变量是否相等
        int num1 = 10;
        int num2 = 20;
        System.out.println(num1==num2);//false
    }

    //普通方法
    private void m2(String[] args) {

    }
}

package cn.com;

import java.util.Arrays;

/**
 * 方法的测试
 */
public class Test25 {

    public static void main(String[] args) {
        m1(args);

        //调用m2方法
        int m2ReturnValue = m2(args);
        //获取m2方法的返回值
        System.out.println("m2方法的返回值：" + m2ReturnValue);

        //调用m3方法
        boolean m3ReturnValue = m3(args);
        //获取m3方法的返回值
        System.out.println("m3方法的返回值：" + m3ReturnValue);

        //调用m4方法
        int[] iArr1 = m4(args);
//        System.out.println("m4方法的返回值：" + iArr1);//[I@1b6d3586
        System.out.println("m4方法的返回值:" + Arrays.toString(iArr1));
    }

    //创建一个static方法，方法的返回值是void
    public static void m1(String[] args) {
        System.out.println("执行了m1方法.....");
    }

    //创建一个static方法，方法的返回值是int类型
    public static int m2(String[] args) {
        System.out.println("执行了m2方法.....");
        int a = 10;
        int b = 20;
        int c = a + b;
        return c;
    }

    //创建一个static方法，方法的返回值是int类型
    public static boolean m3(String[] args) {
        System.out.println("---执行了m3方法---");
        char c1 = 'a';
        char c2 = 97;
        boolean b1 = (c1==c2);
        return b1;
    }

    //创建一个static方法，方法的返回值是int[]
    //方法里面的业务是将{1,7,19,8,3,6,22}，拆出一个偶数数组，返回该偶数数组
    public static int[] m4(String[] args1111) {
        int[] intArr1 = {1,7,19,8,3,6,22};
        //1 通过数组里面的偶数,确定偶数数组的长度
        int num1 = 0;
        int count1 = 0;//统计偶数数组的长度
        while(num1 < intArr1.length) {
            if(intArr1[num1]%2==0) {
                count1++;
            }
            num1++;
        }

        //2 定义偶数数组
        int[] intBrr1 = new int[count1];

        //3 为偶数数组赋值
        num1=0;
        count1=0;
        while(num1<intArr1.length) {
            if(intArr1[num1]%2==0) {
                intBrr1[count1] = intArr1[num1];
                count1++;
            }
            num1++;
        }

        //4 返回偶数数组
        return intBrr1;
    }
}