Java寒假所学知识总结一、Java知识概念二、我的第一个Java程序三、Java强化案例四、进阶案例

78 阅读 0 评论 52 点赞

我是靠谱客的博主虚心火车，最近开发中收集的这篇文章主要介绍Java寒假所学知识总结一、Java知识概念二、我的第一个Java程序三、Java强化案例四、进阶案例，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

Java知识总结

一、Java知识概念
- I）、概念
- II）、知识强化
- III）、语言介绍
- VI）、测试强制类型转换
- V）、自增与自减
- IV）、 Java对齐效果与取位
- VI）、Switch开关式以及For While循环结构
- - 1*.实例
  - 2*.强化知识点
- VII)、String的用法及构造类
二、我的第一个Java程序
- I）、在Java中对浮点型数据进行算术
- II）、自增自减案例
- III）、案例：计算成绩差与平均成绩
- IV）、截取指定位数以及设置左右对齐
- V）、赋值运算符，逻辑运算符
- VI）、计算平年闰年
- VII）、计算圆周长及面积
- VIII）、Java-好玩的猜数小游戏
- VIIII）、Java小游戏-幸运抽奖-进阶版(可多抽取多次)
三、Java强化案例
- 1*.在Java中给出年月日求出生总天数
- 2*.在Java中给出生年月-并确定它是该年的第几天
- 3*.Java案例实训-equals用法
- 4*.对两位数进行排序（不用数组情况下）
- 5*.在Java中用米粒填充国际象盘
- 6*.在Java中输出指定范围的全部素数,每行输出五个
- 7*.在Java中计算指定阶乘和
- 8*.在Java中判断整数是素数还是合数
- 9*.Java开发学生信息管理系统
- 10*.数组入门教程
四、进阶案例
- 1*.Java数组-采用for循环和while计算十个学生的平均成绩并且取两位小数
- 2*.Java中求二维数组所有元素的平均，最大，最小值

一、Java知识概念

I）、概念

JAVA编程最上面的一个Package是什么意思？ 答：最上头的标识，是为了指明所写的这个类或接口属于哪个包 在JAVA里 包其实可以理解为文件夹。

[修饰符]》  class 类名{
    程序代码》》public static void main(String[] args) {

	{
}

开篇要写成这种格式。1.里面的[修饰符]用于限定类的访问权限 可以省略，2.class是声明类，必须使用class关键字。3.类名是定义的类名称,通常使用首字母大写的形式。 注明: 要在结尾输入分号；输出和打印用{}来分隔
Python注释是#的形式 缩进很重要 很严格
JAVA:单行注释// 多行注释 像Python开头的介绍一样 /* 输入的内容*/ 缩进不是那么严格,为了阅读性 美观，要遵守符合规范的缩进形式。

II）、知识强化

标识符:凡是自己可以起名字的地方都叫标识符。比如类名，变量名，方法名，接口名，包名。
由26个英文字母大小写0-9，_或$组成
数字不可开头，不可以使用关键字和保留字，但能包含关键字和保留字
JAVA中严格区分大小写，长度无限制。标识符不能包含空格。
包名：多单词组成时所有字母都小写 xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线链接：xxx_yyy_zzz


要采用跟python一样的缩进方式书写代码，整齐规范。if else 都要加{} 为了方便阅读，将一个长字符串分开在两行中书写。在输出代码中用+号将两个字符串连接起来· +号还有的作用就是链接文字+变量。 +号代替了python中的format
在JAVA中关键字都是小写。
包名为文件夹名 package那行。 所有字母一律小写。
类名和接口如Map接口，HashMap类。
常量名所有字母都大写，单词之间用下划线链接。EXIT_ON_CLOSE
变量名和方法名的第一个单词首字母小写，从第二个单词首字母大写。nextLine,getNextline
输入psvm或者main可快速生成主方法框，输入sout敲回车也可快速生成。

III）、语言介绍

JAVA是一门强类型的编程语言，它对变量的数据类型有严格限定，在定义变量时必须先声明变量的数据类型，在为变量赋值时必须赋予和变量同一类型的值，否则程序在编译期间就会出现类型匹配错误的问题
字符类型变量用于存储一个单一字符，在Java中用char表示 每个char类型字符都会占用两个字节。

VI）、测试强制类型转换

double score=98.5
float s=(float) score//将双精度强制转换为浮点型98.5
long l=(long) score//将双精度强制换成长整型。98
int n =(int)score//去尾取整98                                                                                                     
int m=(int)(score+0.5)//四舍五入取整99
int k =(int)(score+1);//进位取整99
JAVA有八种基本数据类型：整型:（Byte、short、int、long、）float、double、）浮点数  char、）只可存储一个单一的字符  字符型 boolean 布尔型 （真假）使用float类型的变量赋值时，赋值的后面要加上字母F或者小写f，而double类型的变量赋值时，在赋值的后面加上D或d。给char类型的变量赋值时，需要用一对英文半角格式的单引号（’a‘）会把a变成ACSLL码对应的数字

char c1 = 'a';
char c2 = 'A';//char字符变为ascll型，然后在用int整型输出。
int c1asc = c1;//数据类型转换，自动类型转换和强制类型转换。类型符后的名字可以随意取，这里表示的是c1的ascll码
 //具体类型转换要具体情况分析。以上是自动类型转换
以下是强制类型转换。
强制类型转换：当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时候就需要强制类型转换。
对变量进行强制类型转换的时候，大范围变成小范围容易使数据精度丢失，
还有表达式类型提升，变量在进行运算时，发生自动类型转换。如(byte short，char)整型的变量在运算期间类型会自动提升为int。
 //什么时候使用强制类型或者自动类型转换，如果自动类型无法转换的，那么就使用强制类型转换。
整型的变量在运算期间类型会自动提升为int。小范围转大范围没问题，大范围转小范围会出现不兼容问题。
什么是变量作用域：变量需要在它的作用范围内才可以被使用，这个作用范围称为变量的作用域。
进行加减×除的时候一定要在后面打个括号单算。

V）、自增与自减

int a=2,b=++a;//执行此代码时，先进行自增++=  a=a+1，再将自增后a的值赋予b与--a同理
int c=2,d=c++;//执行此代码时，先将c的值赋值给d之后 再进行自增；与a--同理
int f=2,g=--f;//执行此代码时，先进行自减++=  a=a+1，再将自减后a的值赋予b与--a同理
int h=2,l=h--;//执行此代码时，先将c的值赋值给d之后 再进行自减；与a--同理
// 32/5=6整除  取余,在进行除法运算的时候，当除数和被除数都为整数时，得到的结果也为整数，如果有小数参与，得到的结果会是一个“小数”
//进行取模运算时，运算结果的正负取决于左边数的符号 32%5=2 -32%5=-2
//要注意优先级的顺序。如果要改变运算的顺序那么要加对括号。
一个程序包含四个部分，声明部分，输入部分，处理部分，输出部分。

IV）、 Java对齐效果与取位

//String.format("%-9s")输出字符串数据，宽度为9，用于左对齐效果，实际位数超过指定位数按实际位数输出。
//String.format("%9s")。宽度为9，用于右对齐效果。整型数据是%8d，总位数是8位,浮点型数据是%9.1f总位数是9保留一位小数  //赋值运算符作用：将常量、变量或表达式的值赋给某一个变量。将运算符右边的值赋给左边的变量a+=b
//在Java中可以通过一条赋值语句对多个变量进行赋值。int a,b,c; a=b=c=100
 x1=id%10;//取个位数
//        x2=id / 10 % 10;//取十位数
//        x3=id /100 %10;//取百位数
//        x4=id/1000;//取千位数
//逻辑运算符 a&b 有一个true 否则为false a|b 有一个为真就是真  a^b相同为Trye 不相同为False !a 如果a是false 结果为True a&&b都为True为True ||有一个为true即true
 //逻辑运算符 a&b 有一个true 否则为false a|b 有一个为真就是真  a^b相同为Trye 不相同为False !a 如果a是false 结果为True a&&b都为True为True ||有一个为true即true
 //&和&&的区别在于 &不管左边是什么右边都会进行运算，&& 只运行左边的算式，不会运行右边的。
//|和||的区别在于 |任何一边为true都为true，||只计算左边的值 
//条件运算符案列 ？可充当双分支结构if JAVA运算符优先级1级最高，14级最低。 //如果满足条件 那么输出第一个字符串，如果不满足条件那么就返回第二个字符串。
当浮点型的数据范围太小了可以用双精度类型
Math.sqrt计算平方根 Math.cbrt//计算立方根   Math.pow(a,b) a是数字 b是次方数.  .max是最大值  .min是最小值。
int num=(int)pow;//强制类型转换

VI）、Switch开关式以及For While循环结构

顺序结构》选择结构》循环结构>前测试条件循环和后测试条件循环，前：先检票后上车 有可能一次循环操作也不执行，
  }//将条件递增和赋值写在一起。
        //while循环和for循环的区别在:while单独对变量赋值 只可在（）写条件表达式， for 可以在（）写对变量的赋值以及条件表达式；
多分支结构与Python的多分支结构类似，但是区别不同的是不俗是冒号而是括号{}。
将成绩变量取整之后再整除10，以便将各个分数段转换成离散的整数值，这样才能用开关式多分支结构来进行处理
f (score>100 || score<0) {//将成绩变量取整之后再整除10，以便将各个分数段转换成离散的整数值，这样才能用开关式多分支结构来进行处理。
//            level = "超出范围";
//        }else{
//            switch ((int)score/10){//开关式多分支结构里的测试表达式，类型可以是整数，字符，甚至可以是字符串。
//                case 10:

1*.实例

 //打印输出100以内的全部素数，每行打印五个素数
for (int i = 2; i <= 100; i++) {
//            boolean flag = true;//写在表达式下面，
//            for (int j = 2; j < i; j++) {//j《 i 防止除以本身。
//                if (i % j == 0) {//表示只要被整除的是错误的就不会被打印
//                    flag = false;
  //处理部分//switch可与if else一起用 也可单用
//        switch (rank){//打开代码的开关

2*.强化知识点

采用跟python一样的缩进方式书写代码，整齐规范。if else 都要加{} 为了方便阅读，将一个长字符串分开在两行中书写。在输出代码中用+号将两个字符串连接起来· +号还有的作用就是链接文字+变量。 +号代替了python中的format
在JAVA中关键字都是小写。
包名为文件夹名 package那行。 所有字母一律小写。
类名和接口如Map接口，HashMap类。
常量名所有字母都大写，单词之间用下划线链接。EXIT_ON_CLOSE
变量名和方法名的第一个单词首字母小写，从第二个单词首字母大写。nextLine,getNextline
输入psvm或者main可快速生成主方法框，输入sout敲回车也可快速生成。

VII)、String的用法及构造类

String name;//String是字符串的意思，声明了一个字符串变量如name的时候，便可以在里面存取数据了。通常通过char类保存字符串
        int age;//整型变量
        Scanner sc=new Scanner(System.in);//Scanner是一个类,是用于扫描输入文本的新的实用程序；变量需要手动输入的时候，此时就可以用到Scanner类 构造一个Scanner类
        System.out.print("姓名:");//print和println的区别在于前者不换行，后者自带换行功能.
        name=sc.nextLine();//读取结果为String字符串类型还可以是sc.nextline
        System.out.print("年龄:");
        age=sc.nextInt();//读取结果为int整型 还可以是nextfloat

二、我的第一个Java程序

import java.util.Scanner;

public class Javahomework {
    public static void main(String[] args) {
        String id,name,gender,major,hobbies,dream;/String是字符串的意思，声明了一个字符串变量如name的时候，便可以在里面存取数据了。通常通过char类保存字符串
        int age;
        Scanner lyt=new Scanner(System.in);//Scanner是一个类,是用于扫描输入文本的新的实用程序；变量需要手动输入的时候，此时就可以用到Scanner类 构造一个Scanner类
        System.out.print("学号:");
            id=lyt.nextLine();
        System.out.print("姓名:");
            name=lyt.nextLine();
        System.out.print("性别:");
            gender=lyt.nextLine();
        System.out.print("年龄:");
            age=lyt.nextInt();
        System.out.print("专业:");
            major=lyt.next();
        System.out.print("爱好:");
            hobbies=lyt.next();
        System.out.print("梦想:");//print和println的区别在于前者不换行，后者自带换行功能.
            dream=lyt.next();
        System.out.println("学号:"+id);
        System.out.println("姓名:"+name);
        System.out.println("性别:"+gender);
        System.out.println("年龄:"+age);
        System.out.println("专业:"+major);
        System.out.println("爱好:"+hobbies);
        System.out.println("梦想:"+dream);
    }
}

I）、在Java中对浮点型数据进行算术

import java.util.Scanner;

public class javahomerwork2 {
    public static void main(String[] args) {
        float a,b;//使用String的时候，那就字符串形式 与下面的next要用nextfloat返回浮点型。
        Scanner sc=new Scanner(System.in);//构造一个类
        System.out.print("a=");
        a=sc.nextFloat();
        System.out.print("b=");
          b=sc.nextFloat();
        System.out.println(a+"+"+b+"="+(a+b));
        System.out.println(a+"-"+b+"="+(a-b));
        System.out.println(a+"×"+b+"="+(a*b));
        System.out.println(a+"÷"+b+"="+(a/b));


    }
}

II）、自增自减案例

import java.util.Scanner;

public class java20 {
    public static void main(String[] args) {
        int a = 2, b = ++a;//执行此代码时，先进行自增++=  a=a+1，再将自增后a的值赋予b与--a同理 同时加一
        int c = 2, d = c++;//执行此代码时，先将c的值赋值给d之后 再进行自增；与a--同理 按顺序先赋值还是先自增。
        int f = 2, g = --f;//执行此代码时，先进行自减++=  a=a+1，再将自减后a的值赋予b与--a同理同时减一
        int h = 2, l = h--;//执行此代码时，先将c的值赋值给d之后 再进行自减；与a--同理l=h-- 可以理解为l=h=2 赋值后h=1
        // 32/5=6整除  取余,在进行除法运算的时候，当除数和被除数都为整数时，得到的结果也为整数，如果有小数参与，得到的结果会是一个“小数”
        //进行取模运算时，运算结果的正负取决于左边数的符号 32%5=2 -32%5=-2
        //要注意优先级的顺序。如果要改变运算的顺序那么要加对括号。
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
        System.out.println(f);
        System.out.println(g);
        System.out.println(h);
        System.out.println(l);

在这里插入图片描述

III）、案例：计算成绩差与平均成绩

import java.util.Scanner;

public class java20 {
    public static void main(String[] args) { //任务1 计算成绩差与平均成绩,注明：一个程序包含四个部分，声明部分，输入部分，处理部分，输出部分。
        //各种类型的数据，需要实列化Scanner类。
        //声明部分
        double stb, java, sql, difference, average;
        Scanner sc = new Scanner(System.in);
        //输入部分
        System.out.print("输入STB的成绩:");
        stb = sc.nextDouble();
        System.out.print("输入JAVA的成绩:");
        java = sc.nextDouble();
        System.out.print("输入SQL的成绩");
        sql = sc.nextDouble();
        difference = java - sql;
        average=(java+sql+stb)/3;
        System.out.println("====================");
        System.out.println("STBttJAVAttSQL");
        System.out.println(stb+"t"+java+"tt"+sql);
        System.out.println("====================");
        System.out.println("java与sql的成绩差异为:"+difference);
        System.out.println("三科总成绩的平均分为:"+average);
        System.out.println("三科总成绩的平均分为:"+String.format("%.2f",average));

    }
}

在这里插入图片描述

IV）、截取指定位数以及设置左右对齐

import java.util.Scanner;

import static java.lang.StrictMath.pow;
import static java.lang.StrictMath.toIntExact;

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

        String.format("%-9s");//输出字符串数据，宽度为9，用于左对齐效果，实际位数超过指定位数按实际位数输出。
        String.format("%9s");//。宽度为9，用于右对齐效果。整型数据是%8d，总位数是8位,浮点型数据是%9.1f总位数是9保留一位小数
        int a,b;
        Scanner sc=new Scanner(System.in);
        System.out.print("a=");
        a=sc.nextInt();
        System.out.print("b=");
        b=sc.nextInt();
        System.out.println(a+"÷"+b+"="+(a/b)+"..."+(a%b));
        //如何拆分一个四位数
        int id;//会员卡号
        int x1,x2,x3,x4;
        int LuckNumber;//幸运数字
        Scanner hd=new Scanner(System.in);//扫描对象
        System.out.print("输入会员卡号:");
        id=hd.nextInt();//从键盘接收一个整数

        x1=id%10;//取个位数
        x2=id / 10 % 10;//取十位数
        x3=id /100 %10;//取百位数
        x4=id/1000;//取千位数
        LuckNumber=x1^3+x2^3+x3^3+x4^3;
        System.out.println(x1);
        System.out.println(x2);
        System.out.println(x3);
        System.out.println(x4);
        System.out.println("你的幸运数为"+LuckNumber);
        }
}

V）、赋值运算符，逻辑运算符

import java.util.Scanner;

import static java.lang.StrictMath.pow;
import static java.lang.StrictMath.toIntExact;
public class java21 {
    public static void main(String[] args) { //循环结构案列
        int i,sum=0; //声明为整型
        i=1;//初始条件
        while (i<=100){
            sum+=i;
            i++;

        }
        System.out.println("sum="+sum);

          //赋值运算符作用：将常量、变量或表达式的值赋给某一个变量。将运算符右边的值赋给左边的变量a+=b
        //在Java中可以通过一条赋值语句对多个变量进行赋值。int a,b,c; a=b=c=100
        //关系运算符 所得的值为True或Flase
        //案例：如何使用boolean以及 Python和Java  if else 这些区别在于 if是加冒号，java每个加{}
        int ZhangScore,LiScore;
        boolean IsHanger;
        Scanner sc= new Scanner(System.in);
        System.out.print("输入张三的成绩:");
        ZhangScore=sc.nextInt();
        System.out.print("输入李四的成绩:");
        LiScore=sc.nextInt();
        IsHanger=ZhangScore>LiScore;
        System.out.println("张三的成绩比李四的成绩高吗？"+IsHanger);
        if (IsHanger){
            System.out.println("张三的成绩确实比李四的高"); }
        else{
            System.out.println("张三的成绩比李四的低");
        }
        //逻辑运算符 a&b 有一个true 否则为false a|b 有一个为真就是真  a^b相同为Trye 不相同为False !a 如果a是false 结果为True a&&b都为True为True ||有一个为true即true
        //&和&&的区别在于 &不管左边是什么右边都会进行运算，&& 只运行左边的算式，不会运行右边的。
        //|和||的区别在于 |任何一边为true都为true，||只计算左边的值

VI）、计算平年闰年

import java.util.Scanner;

import static java.lang.StrictMath.pow;
import static java.lang.StrictMath.toIntExact;

public class java21 {
    public static void main(String[] args) {
 int year;
        boolean isLeapYear;
        Scanner sc=new Scanner(System.in);
        System.out.print("year=");
        year=sc.nextInt();
        isLeapYear =year % 4==0 && !(year  % 100 ==0) || year % 400==0;
        if (isLeapYear){
            System.out.println(year+"是闰年"); }
        else{
            System.out.println(year+"是平年");
        }

VII）、计算圆周长及面积

import java.util.Scanner;

import static java.lang.StrictMath.pow;
import static java.lang.StrictMath.toIntExact;

public class java21 {
    public static void main(String[] args) {位运算符是针对二进制数的每一位进行运算的符号，针对数字0或1进行操作。&进行与操作 |进行或操作 ~进行非操作 ^异或操作 《左移》右移
         int c=0&1,c1=0|1,c2=~2,c4=2^1,c3=3^2,c5=3<<3+2,c6=5>>1,c7=3>>>1;
        System.out.println(c);//按位与运算
        System.out.println(c1);//安稳或运算
        System.out.println(c4);//
        System.out.println(c2);//~取相反数并-1  无论何时记住还要算0
        System.out.println(c3);//
        System.out.println(c5);//乘以左边的次方从1开始
        System.out.println(c6);//整除以二的次方 从1开始
        System.out.println(c7);//
        条件运算符案列 ？可充当双分支结构if JAVA运算符优先级1级最高，14级最低。age？的变量是字符串型的
        int age;
        String msg;
        Scanner sc=new Scanner(System.in);
        System.out.print("输入你的年龄:");
        age=sc.nextInt();
        msg=age>=18?"欢迎访问本网站~":"未成年不允许访问";//如果满足条件 那么输出第一个字符串，如果不满足条件那么就返回第二个字符串。
        System.out.println(msg);

        Math.sqrt计算平方根 Math.cbrt//计算立方根   Math.pow(a,b) a是数字 b是次方数.  .max是最大值  .min是最小值。
        double x;
        double pow =Math.pow(x,3);
        int num=(int)pow;//强制类型转换

        System.out.println(num);

VIII）、Java-好玩的猜数小游戏

package net.lyt.month1;

import java.util.Scanner;

public class Java23 {
    public static void main(String[] args) {
    //猜数小游戏(在100范围内)
        int number;
        Scanner sc = new Scanner(System.in);

        int count = 1;
        while (count < 10) {//计算循环次数
            System.out.print("请猜数:");
            number = sc.nextInt();
            if (number <30 & number >0);{//有分号表示每次都输出存在 
                System.out.println("数字小了,请重新猜数."); }
            if (number >= 30 & number < 60) {
                System.out.println("再大点就到了,加油。");
            } else if (number >= 60 & number < 100) {
                System.out.println("恭喜你猜对了可真不容易！！");
                System.out.println("You are handsome and prefect boy");
                count += 1;
                break;

            }
        }

VIIII）、Java小游戏-幸运抽奖-进阶版(可多抽取多次)

int card, Num, rand;
Scanner sc = new Scanner(System.in);

int count = 0;

while (count < 9) {
    System.out.print("请输入会员卡号:");
    card = sc.nextInt();
    count += 1;
    if (card >= 100 && card <= 9999) {
        Num = card / 100 % 10;
        rand = (int) (Math.random() * 10);
        if (Num == rand) {
            System.out.println(Num + "恭喜你你的号码中奖啦");
            break;
        } else {
            System.out.println(Num + "好像你的号码没有中奖");
        }

    } else {
        System.out.println("你输入的卡号错误,请重输入");

    }

}

三、Java强化案例

1*.在Java中给出年月日求出生总天数

 int year, month, day,newYear=2022;//年月日
        int days;
        boolean isLeapYear;
        Scanner sc = new Scanner(System.in);
        System.out.print("year=");
        year = sc.nextInt();
        System.out.print("month=");
        month = sc.nextInt();
        System.out.print("day=");
        day = sc.nextInt();
        //处理部分
        isLeapYear = year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
        int sum=0;//当前几月份之前几个月的总天数
        switch (month){
            case 12:
                sum=(newYear-year-1)*365+0+day;
                break;
            case 11:
                sum=(newYear-year-1)*365+31+day;
                break;
            case 10:
                if (isLeapYear){
                    sum=(newYear-year-1)*365+31+30+day;
                }
                else{
                    sum=(newYear-year-1)*364+31+30+day;
                }
                break;
            case 9:
                if (isLeapYear){
                    sum=(newYear-year-1)*365+31+30+31+day;
                }
                else{
                    sum=(newYear-year-1)*364+31+30+31+day;
                }
                break;
            case 8:
                if (isLeapYear){
                    sum=(newYear-year-1)*365+31+30+31+30+day;
                }
                else{
                    sum=(newYear-year-1)*364+31+30+31+30+day;
                }
                break;
            case 7:
                if (isLeapYear){
                    sum=(newYear-year-1)*365+31+30+31+30+31+day;
                }
                else{
                    sum=(newYear-year-1)*364+31+30+31+30+31+day;
                }
                break;
            case 6:
                if (isLeapYear){
                    sum=(newYear-year-1)*365+31+30+31+30+31+30+day;
                }
                else{
                    sum=(newYear-year-1)*364+31+30+31+30+31+30+day;
                }
                break;
            case 5:
                if (isLeapYear){
                    sum=(newYear-year-1)*365+31+30+31+30+31+30+31+day;
                }
                else{
                    sum=(newYear-year-1)*364+31+30+31+30+31+30+31+day;
                }
                break;
            case 4:
                if (isLeapYear){
                    sum=(newYear-year-1)*365+31+30+31+30+31+30+31+30+day;
                }
                else{
                    sum=(newYear-year-1)*364+31+30+31+30+31+30+31+30+day;
                }
                break;
            case 3:
                if (isLeapYear){
                    sum=(newYear-year-1)*365+31+30+31+30+31+30+31+30+31+day;
                }
                else{
                    sum=(newYear-year-1)*364+31+30+31+30+31+30+31+30+31+day;
                }
                break;
            case 2:
                if (isLeapYear){
                    sum=(newYear-year-1)*365+31+29+31+30+31+30+31+30+31+30+day;
                }
                else{
                    sum=(newYear-year-1)*365+31+28+31+30+31+30+31+30+31+30+day;
                }
                break;
            case 1:
                if (isLeapYear){
                    sum=(newYear-year-1)*365+31+29+31+30+31+30+31+30+31+30+31+day;
                }
                else{
                    sum=(newYear-year-1)*364+31+28+31+30+31+30+31+30+31+30+31+day;
                }
                break;

        }
        System.out.println("从出生到现在一共"+sum+"天");

2*.在Java中给出生年月-并确定它是该年的第几天

int year, month, day;//年月日
int days;
boolean isLeapYear;
Scanner sc = new Scanner(System.in);
System.out.print("year=");
year = sc.nextInt();
System.out.print("month=");
month = sc.nextInt();
System.out.print("day=");
day = sc.nextInt();
//处理部分
isLeapYear = year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
int sum=0;//当前几月份之前几个月的总天数
switch (month){
    case 1:
        sum=0;
        break;
    case 2:
        sum=31;
        break;
    case 3:
        if (isLeapYear){
            sum=31+29;
        }
        else{
            sum=31+28;
        }
        break;
    case 4:
        if (isLeapYear){
            sum=31+29+31;
        }
        else{
            sum=31+28+31;
        }
        break;
    case 5:
        if (isLeapYear){
            sum=31+29+31+30;
        }
        else{
            sum=31+28+31+30;
        }
        break;
    case 6:
        if (isLeapYear){
            sum=31+29+31+30+31;
        }
        else{
            sum=31+28+31+30+31;
        }
        break;
    case 7:
        if (isLeapYear){
            sum=31+29+31+30+31+30;
        }
        else{
            sum=31+28+31+30+31+30;
        }
        break;
    case 8:
        if (isLeapYear){
            sum=31+29+31+30+31+30+31;
        }
        else{
            sum=31+28+31+30+31+30+31;
        }
        break;
    case 9:
        if (isLeapYear){
            sum=31+29+31+30+31+30+31+30;
        }
        else{
            sum=31+28+31+30+31+30+31+30;
        }
        break;
    case 10:
        if (isLeapYear){
            sum=31+29+31+30+31+30+31+30+31;
        }
        else{
            sum=31+28+31+30+31+30+31+30+31;
        }
        break;
    case 11:
        if (isLeapYear){
            sum=31+29+31+30+31+30+31+30+31+30;
        }
        else{
            sum=31+28+31+30+31+30+31+30+31+30;
        }
        break;
    case 12:
        if (isLeapYear){
            sum=31+29+31+30+31+30+31+30+31+30+31;
        }
        else{
            sum=31+28+31+30+31+30+31+30+31+30+31;
        }
        break;
}
sum+=day;
System.out.println("生日当天是一年365天中的"+sum+"天");

3*.Java案例实训-equals用法

/购物打折
        //x.equals("y") equals是用于对字符串类型进行比较是否相等
        String customer;//用户级别
        double money;//用户金额
        double discount;//购物折扣
        double pay;//实付金额
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入用户级别:");
        customer = sc.nextLine();
        System.out.print("请输入用户消费金额:");
        money = sc.nextDouble();
        if (customer.equals("会员")) {
            if (money >= 200) {
                discount = 0.75;
                System.out.println(customer + ":购物打" + discount + "折,实付金额:" + (discount * money));
            } else {
                discount = 0.8;
                System.out.println(customer + ":购物打" + discount + "折,实付金额:" + (discount * money));
            }
        } else if (customer.equals("普通用户")) {
            if (money >= 100) {
                discount = 0.9;
                System.out.println(customer + ":购物打" + discount + "折,实付金额:" + (discount * money));
            } else {
                discount = 1;
                System.out.println(customer + ":购物打" + discount + "折,实付金额:" + (discount * money));
            }
        }

4*.对两位数进行排序（不用数组情况下）

//对二位整数进行排序
        //声明部分
        int x1, x2;
        int x7, x8, x9, x10, x11, x12;
        Scanner sc = new Scanner(System.in);
        System.out.print("x1=");
        x1 = sc.nextInt();
        System.out.print("x2=");
        x2 = sc.nextInt();

        //处理部分
        x7 = x1 / 10 % 10;
        x8 = x2 / 10 % 10;
        x9 = x1 % 10;
        x10 = x2 % 10;
        x11 = x1 / 100 % 10;
        x12 = x2 / 100 % 10;
        if (x1 >= x2) {//大大大
            if (x9 >= x10) {
                if (x11 >= x12) {
                }
            }
        }
        if (x1 >= x2) {//大大小
            if (x9 >= x10) {
                if (x11 <= x12) {
                }
            }
        }
        if (x1 >= x2) {//大小大
            if (x9 <= x10) {
                if (x11 >= x12) {
                }
            }
        }
        if (x1 >= x2) {//大小小
            if (x9 <= x10) {
                if (x11 <= x12) {
                }
            }
        }
        if (x1 <= x2) {//小小小
            if (x9 <= x10) {
                if (x11 <= x12) {
                }
            }
        }
        if (x1 <= x2) {//小小大
            if (x9 <= 10) {
                if (x11 >= x12) {
                }
            }
        }
        if (x1 <= x2) {//小大小
            if (x9 >= 10) {
                if (x11 <= x12) {
                }
            }
        }

        if (x1 <= x2) {//小大大
            if (x9 >= 10) {
                if (x11 >= x12) {
                }
            }
        }
        System.out.println("升序:" + x11 + x7 + x9 + " " + x12 + x8 + x10);

        if (x1 >= x2) {//大大大
            if (x9 >= x10) {
                if (x11 >= x12) {
                }
            }
        }
        if (x1 >= x2) {//大大小
            if (x9 >= x10) {
                if (x11 <= x12) {
                }
            }
        }
        if (x1 >= x2) {//大小大
            if (x9 <= x10) {
                if (x11 >= x12) {
                }
            }
        }
        if (x1 >= x2) {//大小小
            if (x9 <= x10) {
                if (x11 <= x12) {
                }
            }
        }
        if (x1 <= x2) {//小小小
            if (x9 <= x10) {
                if (x11 <= x12) {
                }
            }
        }
        if (x1 <= x2) {//小小大
            if (x9 <= 10) {
                if (x11 >= x12) {
                }
            }
        }
        if (x1 <= x2) {//小大小
            if (x9 >= 10) {
                if (x11 <= x12) {
                }
            }
        }
        if (x1 <= x2) {//小大大
            if (x9 >= 10) {
                if (x11 >= x12) {
                }
            }
        }

        System.out.println("降序:" + x12 + x8 + x10 + " " + x11 + x7 + x9);
    }

5*.在Java中用米粒填充国际象盘

double n=0;//Java.Math.BigIngter
        int sum=0;
        for (long i=0;i<=64;i++){
            n+=Math.pow(2,i);
            int s=(int)n;
            sum+=n;
            System.out.println(sum);
        }

在这里插入图片描述

6*.在Java中输出指定范围的全部素数,每行输出五个

int count = 0;

for (int i = 200; i <= 400; i++) {
    boolean flag = true;
    for (int j = 2; j < i; j++) {
        if (i % j == 0) {
            flag = false;
        }
    }
    if (flag) {
        System.out.print(i + "t");
        count++;
        if (count % 5 == 0) {
            System.out.println();
        }
    }
}

7*.在Java中计算指定阶乘和


```java
Scanner sc=new Scanner(System.in);
System.out.print("请输入所求阶乘累加的个数:");
int n=sc.nextInt();
long test,sum=0;//为什么这么会用长整型而不是int 因为long所包含的字节数据更多
for (int i=1;i<=n;i++){//老师提升：外层求阶乘和内层求阶乘
     test=1;
    for (int j=1;j<=i;j++){
            test*=j;
    }
    sum+=test;
}
System.out.println("1!+2!+3!+10!=" + (sum));

8*.在Java中判断整数是素数还是合数

int Number;
boolean isNumber;
Scanner sc = new Scanner(System.in);
System.out.print("请输入整数:");
Number = sc.nextInt();
isNumber = true;//素数等于true 相当于来就设定了它的正确然后设置条件的时候加上false这样 如果条件没有识别出来就是true 否则就是false
for (int i = 2; i <= Number - 1;i++) {//减一让它永远除不了自身
    if (Number % i == 0) {//上面设定了它本身就是true;只有当符号条件的时候才为false
        isNumber = false;
        break;
    }
}
if (Number==1){
    System.out.println("既不是合数也不是素数");
}
else if (isNumber){//是true
    System.out.println(Number+"是素数");
}
else{
    System.out.println(Number+"是合数");

9*.Java开发学生信息管理系统

package net.lyt.month1.Net.LYT;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

import java.util.Scanner;

public class Month2 {
    public static void main(String[] args) {
        int choice;// 菜单号
        Scanner sc = new Scanner(System.in);//扫描器

        //显示登录菜单
        System.out.println("登录菜单");
        System.out.println("=======================");
        System.out.println("1.登录系统");
        System.out.println("2.退出系统");
        System.out.println("=======================");
        System.out.println("输入菜单号(1,2): ");

        choice = sc.nextInt();
        switch (choice) {
            case 1:
                login();//调用登录系统的方法
                break;
            case 2:
                System.out.println("谢谢使用");
                System.exit(0);//退出应用程序
                break;
            default:
                System.out.println("输入的单位号错误！");
                break;
        }

    }

    /*
     *定义系统登录的方法
     */
    private static void login() {
        int choice;//菜单选择号
        Scanner sc = new Scanner(System.in);

        //显示主菜单
        System.out.println("主菜单");
        System.out.println("==============");
        System.out.println("1.客户信息管理");
        System.out.println("2.购物结算");
        System.out.println("3.真情回馈");
        System.out.println("4.注销");
        System.out.println("==============");
        System.out.println("输入菜单号(1,2,3,4):");
        choice = sc.nextInt();//向系统输入信息
        switch (choice) {
            case 1:
                customer_management();//调用客户信息管理模块
                break;
            case 2:
                System.out.println("进入购物结算模块!");
                break;
            case 3:
                sincere_feedaback();//调用真情回馈模块
                break;
            case 4:
                System.out.println("登录账号已注销！");
                break;
            default:
                System.out.println("输入菜单号错误");
                break;
        }
    }

    /*
     *定义真情回馈方法
     */
    private static void sincere_feedaback() {
        int choice;//菜单选择号
        Scanner sc = new Scanner(System.in);
        //显示真情回馈菜单
        System.out.println("真情回馈");
        System.out.println("====================");
        System.out.println("1.幸运大放送");
        System.out.println("2.幸运抽奖");
        System.out.println("3.生日问候");
        System.out.println("====================");
        System.out.println("输入菜单号(1,2,3):");
        choice = sc.nextInt();
        switch (choice) {
            case 1:
                System.out.println("进入大放送模块");
                System.out.println("模块功能尚待开发");
                break;
            case 2:
                System.out.println("进入幸运抽奖模块");
                System.out.println("模块功能尚待开发");
                break;
            case 3:
                System.out.println("进入生日问候模块");
                System.out.println("朋友,祝您生日快乐");
                break;
            default:
                System.out.println("输入菜单号错误！");
                break;
        }
    }

    /*
     *定义客户信息管理方法
     */
    //显示客户信息管理菜单
    private static void customer_management() {
        int choice;//菜单选择号
        Scanner sc = new Scanner(System.in);

        //显示客户信息管理菜单
        System.out.println("客户信息管理");
        System.out.println("====================");
        System.out.println("1.显示所有客户信息");
        System.out.println("2.添加客户信息");
        System.out.println("3.修改客户信息");
        System.out.println("4.查询客户信息");
        System.out.println("====================");
        choice = sc.nextInt();
        switch (choice) {
            case 1:
                System.out.println("进入显示所有信息模块");
                System.out.println("模块功能尚待开发");
                break;
            case 2:
                System.out.println("进入添加客户信息模块");
                System.out.println("模块功能尚待开发");
                break;
            case 3:
                System.out.println("进入修改客户信息模块");
                System.out.println("模块功能尚待开发");
                break;
            case 4:
                System.out.println("进入查询客户信息模块");
                System.out.println("模块功能尚待开发");
                break;
            default:
                System.out.println("对不起,你输入的菜单号出错了");
        }
    }
}

10*.数组入门教程

package net.lyt.month1;

import java.util.Scanner;

public class Java数组 {
    public static void main(String[] args) {

        一维数组定义语法格式
        数组类型[] 数组名=new 数组类型[数组长度];
        数组类型[] 数组名=new 数组类型[]{数组元素0，数组元素1,.....};
        数组类型[] 数组名={数组元素0,数组元素1,....}

        1.第一种方式定义数组
        int[] ids=new int[100];
        //输出整个数组
        System.out.println("ids="+ids);
        //输出元组的第一个元素
        System.out.println("ids[0]="+ids[0]);
        //输出元组的最后一个元素
        System.out.println("ids[99]="+ids[99]);

        第二种方式定义数组
        String[] names=new String[]{"洪艳林","陈燕文","郑晓琳","唐竹龙"};
        //输出整个数组
        System.out.println("names="+names);
        //输出数组第一个元素
        System.out.println("names[0]="+names[0]);
        //输出数组最后一个元素
        System.out.println("names[3]="+names[3]);

        第三种方式定义数组
        Object[] objects={1,"张三丰","男",20,"15892924560","maths007@163.com"};//数组也是Object的子类 暂解为 混合的时候用
        //输出整个数组
        System.out.println("objects="+objects);
        //输出数组第一个元素
        System.out.println("objects[0]="+objects[0]);
        //输出数组最后一个元素
        System.out.println("objects[5]="+objects[5]);
        注明 数组是一组相同数据类型的数据,有一个共同的名字,可以通过下标取访问每一个元素 数组的长度还可以通过length属性来获取。
        第二种数组定义方式,可以再次对数组变量赋值,增删元素

        给数组元素赋初值或修改数组元素已有值
        1.第一种方式定义数组
         int[] ids=new int[100];
         //输出元组第一个元素
        System.out.println("ids[0]="+ids[0]);
        //给数组第一个元素赋值进行初始化
        ids[0]=1000;
        //再次输出数组的第一个元素
        System.out.println("ids[0]="+ids[0]);

        第二种方式定义数组
        String[] names=new String[]{"洪燕林","雷云腾","陈燕文","唐竹龙","郑晓琳"};
        //输出数组第一个元素
        System.out.println("names[0]="+names[0]);
        //更改元素
        names[0]="雷帅腾";
        //再次输出数组第一个元素
        System.out.println("names[0]="+names[0]);


        //第三种方式定义数组
        Object[] objects={1,"雷云腾","男","汉",19,"2529165097@qq.com"};
        //输出数组第一个元素
        System.out.println("objects[0]="+objects[0]);
        //更改数组元素并且进行输出
        objects[5]="2250177503@qq.com";
        System.out.println("objects[5]="+objects[5]);


        案列演示,统计十个学生的平均分
        double score,average,sum=0;
        final int N=10;
        Scanner sc=new Scanner(System.in);
        for (int i=1;i<=N;i++) {
            System.out.print("请输入第" + i + "个学生的成绩:");
            score = sc.nextDouble();
            sum += score;
        }
            average=sum/N;

        System.out.println(N+"个学生平均成绩为:"+average);
    }

四、进阶案例

1*.Java数组-采用for循环和while计算十个学生的平均成绩并且取两位小数

案列演示,统计十个学生的平均分
double score,average,sum=0;
final int N=10;//符号常量:学生人数 不可变的
Scanner sc=new Scanner(System.in);
for (int i=1;i<=N;i++) {
    System.out.print("请输入第" + i + "个学生的成绩:");
    score = sc.nextDouble();
    sum += score;
}
    average=sum/N;

System.out.println(N+"个学生平均成绩为:"+average);

//用数组方式
//声明部分
double[] scores=new double[11];//表示长度
double sum=0,average;
Scanner sc=new Scanner(System.in);

//输入部分
for (int i=1;i<scores.length;i++){
    System.out.print("scores["+i+"]=");
    scores[i]=sc.nextDouble();
}
//处理部分
for (int i=1;i<scores.length;i++){
    sum+=scores[i];
}
average=sum/scores.length;
//输出部分
System.out.println(scores.length+"个学生的平均分:"+average);




采用while循环求10个学生成绩平均分
double[] scores = new double[11];
double sum = 0, average;
Scanner sc = new Scanner(System.in);
int i = 1;
while (i<scores.length) {

    System.out.print("scores[" + i + "]=");

    scores[i] = sc.nextDouble();

    sum = scores[i] + sum;
    i++;
}
average = sum / scores.length - 1;
System.out.println(scores.length - 1 + "个学生的平均成绩为:" + String.format("%.2f", average));

2*.Java中求二维数组所有元素的平均，最大，最小值

//求二维数组所有元素的平均值、最大值和最小值
//声明部分
int[][] a={
        {12,45,66,24},
        {56,78,90,32},
        {32,44,56,98}
};
int sum=0;
int average;
int max,min;

//处理部分
for (int i=0;i<a.length;i++){
    for (int j=0;j<a[i].length;j++){//取第一行所有元素和,依次类推
        sum+=a[i][j];
    }
}
average=sum/(a.length * a[0].length);//3*4=12
max=a[0][0];//min=integer.MAX_VALL
for (int i=0; i<a.length;i++){
    for (int j=0; j<a[i].length;j++){
        if (max<a[i][j]){
            max=a[i][j];
        }
    }
}
min=a[0][0];
for (int i=0; i<a.length;i++){
    for (int j=0; j<a[i].length;j++){
        if (min>a[i][j]){
            min=a[i][j];
        }
    }
}
System.out.println("平均值:"+average);
System.out.println("最大值:"+max);
System.out.println("最小值:"+min);