Java第一阶段学习总结

day1（甘特图）

甘特图：让工程项目变成可视化图表，也叫项目进度规划表。

一般由：任务名称、工期、开始时间、完成时间、前置任务、资源名称、日期组成

如下所示，资源名称那就是人的名字，前置任务代表作这任务之前需要完成几个任务。

 链接：https://pan.baidu.com/s/1m30uhWhuyVH1qFLTgVPd_A?pwd=6666 
提取码：6666 
--来自百度网盘超级会员V1的分享
上面是软件链接
今天任务就是做一个斗地主的甘特图，软件的使用

 

day2(流程图)

常见的流程图的组成如下：
终结符：用来表示一个流程图的开始和结束
流程框：程序的执行步骤
数据框：让用户输入数据
判定框：判断条件是否正确
批注：备注，提示
流程线：用来连接各种流程框

流程图绘制规范：
1、流程框尽量对齐
2、流程框大小一致
3、必须要有开始和结束（终结符）
4、文字尽量精简，流程简化
5、流程框之间的间距一致
6、流程线不要相交

顺序结构   分支结构  循环结构

1、输入两个数，计算2个数的和
2、输入2个数，判断这2个数大小关系
3，a，b，c   他们不等，有6种情况 

 

 

求1...+100的和

 作业
闰年就是能被400整除是世纪闰年，能被4整除不能被100整除是普通闰年

day3(讲解习题)

1、讲解昨天的作业
2、讲解12306登录页面的流程
3、自己想注册的流程

作业：
1、自助停车缴费流程图，
要求从进入停车场开始，需要判断停车位，
停车费，是否提前缴费，在出场的时候，如果在提前缴费15分钟内出场不用补差价，否则需要补差价，
1个小时以内(不包含一个小时)免费
2、输入一个数，判断这个数是不是完数
完数：一个数恰好等于它的除了它本身之外所有因数之和，这个数就称为“完数”。
例如：6的因数有：1、2、3；由于6=1+2+3，所以6是完数。
3、输入10个数，输出最大值和最小值
4、安装mysql和navicate

（拓展）100-999之间的完数

day4（时序图）

1、根据上周学习知识去制作思维导图

2、讲解上周作业

3、时序图组成：对象生命线（对象以及生命）、激活块（对象处于激活状态）、调用消息、返回消息、消息的自调用

 用viso软件，新建-软件数据库-UML模型图-UML序列

 1个简单的登录时序图，需要注意的点：调用消息和返回消息都有一定的延迟，所以不能水平线，有时间差，浏览器和服务器处于一直激活状态，用户这边看需求使用激活块

  作业：

1、利用手机软件叫外卖时序图。
用户、平台、商家、骑手
2、输入一个数，求这个数的阶乘
如：5！=1*2*3*4*5流程图
3、画出100-999中所有水仙花数的流程图
（拓展）1!+3!+5!+7!+9!+11!

day5(变量行业规定和基本数据类型和转义序列反斜杠)

1、讲解上节课任务

2、Java学习的第一节课，用cmd运行出HelloWorld

3、IDEA的基本使用，用它实现java代码

4、注释有3种：单行  多行  文档注释    ctrl+/ 注释  如下3种

标识符其规则：由字母，数字，下划线和$组成，不能以数字开头 ，不能用关键字

业内规定：

类首字母大写，驼峰命名法   

包：小写字母组成，域名倒置

变量/方法：首字母小写，驼峰命名法

常量：全部大写字母，单词之间下划线隔开  要加个final修饰，不可改变

数据类型分为基本数据类型和复合数据类型

基本数据类型（四类八型):

整数类型: byte 8 short 16  int(默认)  32  long 64   数字是位数

byte的值域 -128~127  Math.pow(2,7)~Math.pow(2,7)-1   其他几个同理

short的值域-32768 ~32767  如果范围小于这个可以用short来定义

int的值域 正负21亿就是8个0    10位数  如果是手机号11位数就用long来定义这个变量

浮点类型: float double(默认)  单精度 双精度

最小值：Float.MIN_VALUE=1.4E-45 （2的-149次方）
最大值：Float.MAX_VALUE=3.4028235E38 （2的128次方-1）

最小值：Double.MIN_VALUE=4.9E-324 （2的-1074次方）
最大值：Double.MAX_VALUE=1.7976931348623157E308 （2的1024次方-1）

字符型:   char          只有这用单引号，其他基本都是双引号

布尔型Boolean: true false

\t插入一个tab键   \n在文中该处换行   \r在文中该处插入回车  \"在文中该处插入双引号

\\在文中该处插入反斜杠

作业：

总结idea的快捷键

抄书上第二单元的代码并运行截图

day6(各种运算符使用以及强制类型转换)

1、复习上节课内容

2、设置idea软件的设置_lucky友人a的博客-CSDN博客

3、强制类型转换

4、算术运算符:     +  -   *   /  % ++  --

5、关系运算符:    >  <   >=  == <=  !=

6、逻辑运算符:   与 或 非  && ||  !  

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

8、运算符：操作二进制数    &    |     还有位运算符

9、三目运算符：

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入年份（正整数）:");
    int i = sc.nextInt();
    String result = i % 400 == 0 || (i % 4 == 0 && i % 100 != 0) ? "闰年" : "平年";
    if (result == "闰年" || i % 400 == 0) {
        System.out.println("世纪" + result);
    } else {
        System.out.println(result);
    }
}

10、分支语句

作业：

一、抄书作业：
抄写第三章的3.1和3.2的代码
二、编程题：
1、对一批货物征收税金（长整型）。价格在1万元及以上的货物征税5%，
在5000元及以上，1万元以下的货物征税3%，在1000元及以上，5000元
以下的货物征税2%，1000元以下的货物免税。编写一程序，读入货物价格，计算并输出税金。

2、超市为了促销，规定：购物不足50元的按原价付款，
超过50不足100的按九折付款，超过100元的，超过部分按
八折付款，100以内的九折付款。编一程序完成超市的自动计费的工作。
 
3、我家的狗5岁了，5岁的狗相当于人类多大呢？其实，狗的前两年每
一年相当于人类的10.5岁，之后每增加一年就增加四岁。那么5岁的狗
相当于人类多少年龄呢？应该是：10.5 + 10.5 + 4 + 4 + 4 = 33岁。
编写一个程序，获取用户输入的狗的年龄，通过程序显示其相当于人
类的年龄。如果用户输入负数，请显示一个提示信息。

做学生成绩系统，如果成绩大于80分，输出优秀，
如果成绩大于70分并且小于80分，输出良好，如果成
绩大于60分并且小于70分，输出及格，小于60分输出不及格

day7（简单异常处理和分支语句）

1、讲解作业，新知识方法以及异常处理

try {
    
}catch (Exception e){
    
}

2、if-else语句的多种使用 if -else if -else  可嵌套

if(布尔表达式)
    {
        //如果布尔表达式为true将执行的语句
    }

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

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

3、做一个人人工服务程序

 4、断点、使用debug模式运行

 5、输入1-7输出星期几

6、switch case

switch(expression){
    case value :
        //语句
        break; //可选
    case value :
        //语句
        break; //可选
    //你可以有任意数量的case语句
    default : //可选
        //语句
}
例子：
char grade = 'C';
  switch(grade)
{
    case 'A' :
        System.out.println("优秀");
        break;
    case 'B' :
    case 'C' :
        System.out.println("良好");
        break;
    case 'D' :
        System.out.println("及格");
        break;
    case 'F' :
        System.out.println("你需要再努力努力");
        break;
    default :
        System.out.println("未知等级");
}

如果 case 语句块中没有 break 语句时，JVM 并不会顺序输出每一个 case 对应的返回值，而是继续匹配，匹配不成功则返回默认 case。

作业：

1、假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，提示用户输入一个两位数，然后按照下面的规则判定用户是否中奖。
1)如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。
2)如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金 3 000美元。
3)如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1 000美元。
4)如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。
5)如果用户输入的数字没有匹配任何一个数字，则彩票作废。

2、分别输入年月日：判断这是当年的第几天

day8（随机数和循环语句和break和continue）

1、随机数   

Random random = new Random(); //new出这个对象

int r=random.nextInt(2);  //调用这个对象的方法 范围是0~1的整数

int rr=random.nextInt(90)+10;//范围是10-99的整数

 2、讲解题目  分支判断可以考虑%  

3、输入一个数，判断它是否能被3、5、7整除，注意考虑同时整除的情况

4、while循环 只要布尔表达式为 true，循环就会一直执行下去。

while( 布尔表达式 ) {                     

代码语句          }

5、do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

do {
       代码语句
}while(布尔表达式);

例子：
int x = 10;
do{
    System.out.print("value of x : " + x );
    x++;
    System.out.print("\n");
}while( x < 20 );

例子：

int x = 10;
  while( x < 20 ) {
    System.out.print("value of x : " + x );
    x++;
    System.out.print("\n");
}

6、for循环

for(初始化; 布尔表达式; 更新) {

    代码语句           }

例子：

  for(int x = 10; x < 20; x++) {
    System.out.print("value of x : " + x );
    System.out.print("\n");
}

• 声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
• 然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
• 执行一次循环后，更新循环控制变量。
• 再次检测布尔表达式。循环执行上面的过程。

7、break 关键字 

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。

break 跳出最里层的循环，并且继续执行该循环下面的语句。

8、continue 关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

在 for 循环中，continue 语句使程序立即跳转到更新语句。

在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

作业：

1、石头剪刀布
1.从控制台输入要出的拳 —石头(1)/剪刀(2)/布(3)
2.电脑随即出拳
3.比较胜负
石头 胜 剪刀
剪刀 胜 布
布 胜 石头
2、输入十个数字，求出最大值和最小值
3、输入一个数，判断是不是完数
4、抄书：第三章剩余部分代码

day9(面试题equals和==)

== 对于基本类型来说是值比较，对于引用类型来说是比较的是引用；而 equals 默认情况下是引用比较，只是很多类重写了 equals 方法，比如 String把它变成了值比较，所以一般情况下 equals 比较的是值是否相等。

 输入10个数，求最大值和最小值

字符串不是基本数据类型，所以不能直接比较，需要借助方法

x.equals("y")     判断是否相等

CTRL+ALT+T  快速异常处理

作业：

1、输入一个数，计算这个数的阶乘
2、求3-10000之间的完数
3、一张纸的厚度是0.08mm，对折多少次之后能达到珠穆兰玛峰的高度（8848.13）
4、使用for循环输出如下图形：
1
1,2
1,2,3
1,2,3,4
1,2,3,4,5
 

day10（简单递归与do while循环）

1、讲解习题

2、快捷键fori直接回车 生成for循环

3、简单递归

 4、计算耗时

 5、do while循环 必运行一次    

6、break中断当前循环    continue跳过本次循环   return结束当前方法

7、要求玩家输入一个数字，回车之后，系统自动生成一串连续的倒数。
（eg. 输入7，回车按下之后，系统返回 7，6，5，4，3，2，1）

8、循环画图

作业：

day11(讲解双重for循环)

1、讲解题目   画空心等腰三角形

public static void huaTu333() {
    for (int i = 1; i <= 5; i++) {
        for (int m = 5; m >= i; m--) {
            System.out.print(" ");
        }
        for (int j = 1; j <= (2 * i) - 1; j++) {
            if (j == 1 || j == (2 * i) - 1) {
                System.out.print("*");
            } else {
                if (i < 5) {
                    System.out.print(" ");
                } else {
                    if (j % 2 == 0)
                        System.out.print(" ");
                    else {
                        System.out.print("*");
                    }
                }
            }
        }
        System.out.println("");
    }
}

2、作业

1、一个口袋中放有12个球，已知其中3个是红的，3个是白的，6个是黑的，现从中任取8个，问共有多少种可能的颜色搭配？
2、一球从100米高度自由落下，每次落地后反跳回原高度的一半；
再落下，求它在第10次落地时，
共经过多少米？第10次反弹多高？
3、
   *
 ***
*****
 ***
  *

day12(讲解习题)

1、讲解题目 

2、有1 2 3 4 这四个数字，设计程序计算能组成多少个互不相同且无重复数字的3位数？
分别是什么？

3、有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。

作业：

1、猴子吃桃问题
猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个
第二天早上又将剩下的桃子吃掉一半，又多吃了一个。
以后每天早上都吃了前一天剩下的一半零一个。
到第10天早上想再吃时，见只剩下一个桃子了。
求第一天共摘了多少。
2、输入开始数字、结束数字和间隔，计算范围内的所有数字之和
如：开始数字5，结束数字10，间隔2，那么结果=5+7+9=21
3、三天打鱼两天晒网：中国有句俗语叫“三天打鱼两天晒网”。某人从1990年1月1日起开始“三天打鱼两天晒网”，
问这个人在以后的以后的某一天中
是打鱼还是晒网。（以2020年8月1日为例）

day13(日期使用)

1、讲解习题

2、浅讲日期方法

3、总结

1、下面计算一年中的第几天

try {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入年：");
        String y = scanner.nextLine();
        System.out.print("请输入月：");
        String m = scanner.nextLine();
        System.out.print("请输入日：");
        String d = scanner.nextLine();
        String t=y+"-"+m+"-"+d;
        Date date = new SimpleDateFormat("y-M-d").parse(t);
        Calendar ca = Calendar.getInstance();
        ca.setTime(date);
        int day = ca.get(Calendar.DAY_OF_YEAR);//一年中的第几天
        System.out.println("这是当年的第"+day+"天");
    }catch (Exception e){
        System.out.println("输入有误，请重新输入");
    }

2、计算相差天数

try {
    String dateStart = "2013-02-19";
    String dateStop = "2013-02-25";
    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
    Date d1= new SimpleDateFormat("y-M-d").parse(dateStart);
    Date d2= new SimpleDateFormat("y-M-d").parse(dateStop);
    long diff = d2.getTime() - d1.getTime();
    long diffDays = diff / (24 * 60 * 60 * 1000);
    System.out.print("两个时间相差："+diffDays+"天");
} catch (ParseException e) {
    System.out.println("输入有误，请重新输入");
}

3、3天打鱼2天晒网解决

try {
    String dateStart = "1990-01-01";
    String dateStop = "2020-08-01";
    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
    Date d1= new SimpleDateFormat("y-M-d").parse(dateStart);
    Date d2= new SimpleDateFormat("y-M-d").parse(dateStop);
    long diff = d2.getTime() - d1.getTime();
    long Days = (diff / (24 * 60 * 60 * 1000)) +1;   //计算相差天数加1天
    System.out.println();
    if(Days%5==1||Days%5==2||Days%5==3){
        System.out.println("他在打鱼！！！");
    }else {
        System.out.println("他在晒网！！！");
    }
} catch (ParseException e) {
    System.out.println("输入有误，请重新输入");
}

day14(JDK的安装)正式开班 第一阶段

1、自我介绍

2、目标：企业标准    

3、目的：（1）了解掌握Java核心语法（2）培养编程思维（3）熟悉企业工作的形式

4、里程碑（1）Java核心语法（2）面向对象编程 （3）Swing编程

5、JDK安装   

win+r 输入cmd 输入java -version 查看是否安装   

安装完jdk和jre后，设置环境变量

(1)新建->变量名"JAVA_HOME"，变量值"C:\Java\jdk1.8.0_05"(即JDK的安装路径)

(2)编辑->变量名"Path"，在原变量值的最后面加上“;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin”

(3)新建->变量名“CLASSPATH”,变量值“.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar”
再终端里输入javac测试

day15(特点、面试题JDK、变量规则、数据类型)

面试题：JDK 和 JRE 有什么区别？

• JDK：Java Development Kit 的简称，Java 开发工具包，提供了 Java 的开发环境和运行环境。
• JRE：Java Runtime Environment 的简称，Java 运行环境，为 Java 的运行提供了所需环境。

JDK 包含了 JRE，同时还包含了编译 Java 源码的编译器 Javac，还包含了很多 Java 程序调试和分析的工具。简单来说：如果你需要运行 Java 程序，只需安装 JRE 就可以了，如果你需要编写 Java 程序，需要安装 JDK。

1、Java是一门编程语言

2、它能编写游戏、搭建服务器、编辑网页、制作应用程序

3、简单性、高安全性、可跨平台、可移植性、健壮性(吸收了c/c++语言的特点，提供相对安全的内存管理和访问机制)、面向对象

4、Java分为javase(核心语法相关)、javaee(网页端相关)、javame(移动端相关)被挪进ee里了

5、用终端运行HelloWorld

6、jvm（java虚拟机）+核心类库=jre           jre（java运行环境）+开发工具=jdk

7、Java是一门编译的高级语言，经过编译生成字节码再给jvm运行

8、Main方法：主要作用是为程序提供一个入口执行

9、Java基本元素
1、标识符就是个名字（变量的名字），其规则：由字母，数字，下划线和$组成，不能以数字开头 ，不能用关键字      

业内规定：

类首字母大写，驼峰命名法   

包：小写字母组成，域名倒置

变量/方法：首字母小写，驼峰命名法

常量：全部大写字母，单词之间下划线隔开  要加个final修饰，不可改变

关键字：java官方用掉的名字，不要使用常量，不能改变的量

注释：用于标注代码的含义，让部分代码不执行

数据类型
1、基本数据类型         
java官方送给我们使用的类型
（四类八型）
boolean 布尔   true false
char      16 字符    单引，且只有1个
byte    8字节型   01111111    2的7次方     0是正
short    16  短整型
int    32整型
long    64长整型

float     单精度浮点型
double     双精度浮点型

2、复合数据类型

day16(数据类型转换和各种运算符和if分支语句)

1、变量命名规范   需要语义化，需要见面知意

stuManSys 驼峰命名  首字母小写小驼峰  首字母大写是大驼峰

stu_man_sys 帕斯卡命名法

2、数据类型的互相转换：（1）自动转换，就是短的类型自动变长的类型（2）强制转换，长的变短的必须强制转换，造成精度损失。

3、算术运算符:     +  -   *   /  % ++  -- 

其中/会取整，用于解决一个数它的百位，%取余的意思，10%3结果是1  3%10结果10

比如a=135    int i=a/100;   i就是百位数  int ii=a/10%10;  ii就是百位数   a%10就是个位

System.out.println(90/4); //数学上22.5这里的结果是22向上取整

a++  a--  ++a  --a  ++放前面先自增再运算  后面是先运算再自增

win+r 输入mspaint 打开画图

4、关系运算符:    >  <   >=  == <=  !=  

5、逻辑运算符:   与 或 非 && ||  !  

&&   逻辑与运算符当两个操作数都为真，条件才为真。

| |逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。

！逻辑非运算符

6、短路逻辑运算符

当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。&&和&区别就是第一个要是真就不判断另一个，也就是短路了。另个同理

boolean b = (a<4)&&(a++<10);
System.out.println("使用短路逻辑运算符的结果为"+b);用到了短路逻辑运算符(&&)，首先判断 a<4 的结果为 false，则 b 的结果必定是 false，所以不再执行第二个

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

8、位运算符：操作二进制数    &    |     >>  <<

7 0111          7/2 =3  1      3/2=1  1    1/2=     1        7的二进制结果倒着余数 111

9 1001  9/2=4  1  4/2=2  0   2/2=1   0   1/2=   1   结果倒着余数 1001

   0001      7&9结果1       &必须2个是1才是1

9、三目运算符也叫条件运算符也被称为三元运算符    

  variable x = (expression) ? value if true : value if false

  b = (a == 1) ? 20 : 30;  判断a是否等于1正确，如果正确则20，错就30再赋值给b

补充、instanceof 运算符

( Object reference variable ) instanceof  (class/interface type)

如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。例子：

String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真
如果被比较的对象兼容于右侧类型，该运算符仍然返回 true。

10、复合数据类型(也叫引用数据类型)   无数种 .自带方法和属性  基本数据类型.后面没有方法

String 只要带双引号就是字符串

Scanner   我们给电脑信息      一般配合提示

11、java基础运行流程

所有代码从上往下，同一行从左往右运行，并且只运行一次

12、java流程控制语句

1、分支语句 2、循环语句

if(布尔表达式/布尔值)
    {
        //如果布尔表达式为true将执行的语句
    }

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

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

13、遇到恶心光标时刻，再按一次insert键或者shift+0

作业：

一：复习上课java内容

二：查询如下内容

1：什么是短路且 和短路或

三：先手动计算如下式子，然后再交由java程序进行运算 查看结果是否不同

Int a =10； 求出a和b的值

Int b = (a++)+a+2*(++a)+(a--)+(a* (--a))

Int b = a +2*(a--)+a*(a++) + (++a)

四：使用分支语句完成以下题目 并提交 源码 以及代码和运行结果的截图

用户输入人数，根据人数提供不同房间

1人 单人间 2人 双人间 3-5人 包厢套房 5以上 总统套房

输入三个互不相等的数字 求他们的大小关系

最终输入a>b>c 或者a>c>b 等等 这种类型

输入年份 判断是否是闰年。

规则：4年一闰 百年不闰 400年再闰

day17(switch语句和break等)

1、系统的健壮性：遇到一些意外事情，能否合理解决问题

2、代码冗余   冗长的代码和多余的代码

3、分支语句  switch 针对一个变量进行判断

switch(变量名){
    case 数值1 :
        //语句
        break; //可选
    case 数值1 :
        //语句
        break; //可选
    //你可以有任意数量的case语句
    default : //可选  默认的意思
        //语句
}

break可以被去掉，不过会往下穿透

default拿到最上面，需要加break不然会穿透

4、循环语句：方便书写，方便维护

（1）for  （2）while   （3）do...while  （4） foreach

（1）for(初始化变量; 范围判断; 增量) {

    循环体           }

作业：

8.4

一：复习上课内容，整理好java流程控制语句的使用方式是什么

二：查询如下内容

1：switch 括号内 可以写什么类型的变量 (这个问题和jdk版本有关系 )

2：while，do while foreach语法是什么

三：使用switch语句完成以下题目 并提交 源码 以及代码和运行结果的截图

用户输入月份，系统显示对应季度

12，1，2 为冬季。

3，4，5为春季

6，7，8为夏季

9，10，11为秋季

输入小时数显示是否是工作时间

9-12和14-17时为工作时间 其余为休息时间

四：使用for循环语句实现

求1到100以内所有偶数和

求1+2+3+4+...+到多少的时候 数字和大于100

求10的阶乘

公园里有一只猴子和一堆桃子，猴子每天吃掉桃子总数的一半，把剩下一半中扔掉一个坏的。到第七天的时候，猴子睁开眼发现只剩下一个桃子。问公园里刚开始有多少个桃子？

day18（循环和随机数）

1、变量作用域

2、for循环里面生成的i，不能在外面使用，方法内声明的变量，方法外不可用。

for(初始化变量; 范围判断; 增量) {

    循环体           }

while( 条件 ) {                     

条件为true，就会反复执行大括号里的代码          }

条件是布尔值或者结果为布尔值的表达式

do {
       代码语句
}while(布尔表达式);

for和while都被称为前置判断循环       do..while是后置判断循环

while和do while都属于不确定次数的循环语句

for 是属于确定次数的循环语句

3、随机数

Random random = new Random();
int sys = random.nextInt(3);  //随机数赋sys访问0，1，2

4、如何停止 使用break关键字

作业：

一：复习本周java所有知识点，并整理总结

二：完善猜拳游戏，实现，

1：游戏可重复游玩，可停止

2：每一小局游戏完成后，都会用中文提示电脑和用户 分别出了什么

三：完成如下题目

1：求1到5的阶乘和

2：使用 若干张 1,2,5元纸币，凑20元钱 问总共有多少种可能，并列出所有结果

3：求 水仙花数（个位数的三次方+十位数的三次方+百位数的三次方等于自身）

四：查找 continue还有return的用法

五：预习数组内容。

day19（数组）

1、创建数组方式

（数组即同一类型的数据的有限集合）  python里[]是list列表没有数组
dataType[] arrayRefVar = new dataType[arraySize];  //动态声明
dataType[] arrayRefVar = new dataType[ ]{value0, value1, ..., valuek};//用的少，使用1、3
dataType[] arrayRefVar = {value0, value1, ..., valuek}; //静态声明方式

也可将数组作为函数的参数    public static void printArray(int[] array) {

    int[] arr = new int[5];
    for (int j = 0; j <5 ; j++) {
      int i = new Random().nextInt(100)+1;//括号里是0~99所以外面加1就是1~100
      arr[j]=i;
    }
    System.out.println("定义数组5个长度，范围1~100随机：");
    for (int ii : arr) {
      System.out.println(ii);
    }
    System.out.println("------------------");

    while (true) {
      for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 1 - i; j++) {
          if (arr[j] > arr[j + 1]) {
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j+1]=temp;
          }}
        }

    System.out.println("冒泡排序完最小值为："+arr[0]);
    System.out.println("冒泡排序完最大值为："+arr[arr.length-1]);

  }
//    int max=arr[0];
//    for (int i = 1; i < arr.length; i++) {
//      if (arr[i] > max) {
//        max = arr[i];
//      }
//    }
//    System.out.println("最大值为：" + max);

}

2、循环

for(type element: array)
{
    System.out.println(element);  //来遍历数组 For-Each 
}

for (int i:ints) {    //来遍历数组   For-Each 
    System.out.println(i);
}

for (int i = 0; i  
  
3、双重for循环
 
  
4、学习的两条腿 （1）基础知识点（2）足够的练习和经验积累
 
  
5、Math.pow(a,b)  a是底数 b是指数
 
  
6、数组：就是数据的集合，在java中可以用一个变量名存储多个数值
 
  
数组的两种声明方式：
 
  
静态声明：
 
  
String[] arr={"张三","李四","王者"};//静态声明方式
 
  
动态声明：
 
  
String[] arr1=new String[5];//动态声明  5是数组长度
 
  
数组获取内容：下标对应获取  下标取值从0开始 最大到数组长度减1
 
  
看到数组想循环
 
  
null 什么都没有 什么都不是   
 
  
5、把多个一维数组合起来放一个数组里那么这个是二维数组
 
  
  public static void eWei() {
    String[] stu1 = {"张三", "jx220222", "男", "20"};
    String[] stu2 = {"李四", "jx220223", "男", "22"};
    String[] stu3 = {"王五", "jx220224", "女", "23"};
    String[][] stu = {stu1, stu2, stu3};
//    System.out.println(stu[0][0]);  //第一下标找数组然后再找里面的
//    System.out.println(stu[2][0]);//2是y轴，0是x轴
//    System.out.println(stu[2][2]);
    for (String[]ii : stu) {
      System.out.println(ii[0]);
    }
  }
 
  
 
  
public static void arr() {
    String[] stu1 = {"张三", "Jx202211", "男", "22"};
    String[] stu2 = {"李四", "Jx202212", "女", "21"};
    String[] stu3 = {"王五", "Jx202213", "男", "25"};
    String[] stu4 = {"小六", "Jx202214", "女", "20"};
    String[][] stu = {stu1, stu2, stu3, stu4};
    for (int i = 0; i < stu.length; i++) {
        for (int j = 0; j < stu[i].length; j++) {
            System.out.print(stu[i][j]+"\t");
        }
        System.out.println();
    }
}
 
  
作业：
 
  
一：复习上课java内容
 
  
二：完善猜拳游戏，实现，
 
  
1：游戏可重复游玩，可停止
 
  
2：游戏获胜者加一分，失败和平局不扣分，先到5分者获胜。有一方获胜后，提问是否继续游戏，根据用户输入 决定是否再来一次5分比较
 
  
3：每一小局游戏完成后，都会提示电脑和用户 分别出了什么
 
  
三：设置一个长度为5的数组 数组中的每个数字都是0到100的随机数。求出 并提示 数组中的 最大值 最小值 平均值 和所有数字的和。
 
  
四：1：实现99乘法表 如图所示
 
  
一阶段第一里程碑
 
  
（1）打地鼠(运用二维数组/函数封装)
 
  
思路：（1）先弄个地图，2维数组（动态声明)（2）然后给数组赋值，当作地洞，用双重循环遍历赋值（3）再去弄个地鼠放进去，地鼠的X，Y坐标，调用随机数方法分别赋值，那么数组的YX坐标就是老鼠的位置，因为二维数组第一个[]代表是列，所以先Y（4）因为看不到地图，所以我们把地图画出来，用双重循环遍历（5)用户输入XY的坐标放到数组里要是结果等于老鼠的值，那么就打中了老鼠（6）可以用函数封装将上面的都封装起来，可以给程序加循环，异常处理，给老鼠加血条，积分等等，代码如下所示：
 
  
public class Demo {
    public static String[][] map = new String[5][5];
    public static int score = 0, blood = 3;
    public static Scanner scanner = new Scanner(System.in);
    public static void main(String[] args) {
        System.out.println("欢迎来到打地鼠游戏!");
        System.out.println("您一共有3格血，加油！");
        while (true) {
            try {
                init();
                laoShu();
                huiZhi();
                hitMouse();
                if (blood == 0) {
                    System.out.println("很遗憾您没有血了！！！");
                    System.out.println("请输入y继续游戏，输入其他停止游戏：");
                    String next = scanner.next();//这是输入字符串的方法
                    if (next.equalsIgnoreCase("y")) {  //.equalsIgnoreCase方法忽略大小写或||
                        System.out.println("您一共获得了" + score + "分");
                        System.out.println("游戏继续!!！");
                        System.out.println("--------------------------");
                        blood = 3;
                        score = 0;
                        continue;
                    } else {
                        System.out.println("游戏结束");
                        System.out.println("您一共获得了" + score + "分");
                        break;
                    }
                }
            } catch (Exception e) {
                System.out.println("输入有误！");
                break;
            }
        }
    }
    public static void init() {  //初始化地图
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[i].length; j++) {
                map[i][j] = "*";
            }
        }
    }
    public static void laoShu() { //随机位置添加老鼠
        Random random = new Random();
        int mouse_x = random.nextInt(5);
        int mouse_y = random.nextInt(5);
        map[mouse_y][mouse_x] = "P";
        System.out.println("老鼠的x坐标是" + mouse_x + "，老鼠的y坐标是" + mouse_y);
    }
    public static void huiZhi() { //绘制地图
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[i].length; j++) {
                System.out.print(map[i][j] + "\t");
            }
            System.out.println();
        }
    }
    public static void hitMouse() {
        System.out.println("请输入要打的老鼠的X坐标：");
        int x = scanner.nextInt();
        System.out.println("请输入要打的老鼠的Y坐标：");
        int y = scanner.nextInt();
        if (map[y][x].equals("P")) {
            System.out.println("打中了！");
            score++;
            System.out.println("您的积分加1,您现在有" + score + "分" + "，您现在有" + blood + "格血");
        } else {
            System.out.println("没有打中目标！血量-1");
            blood--;
            if (blood > 0) {
                System.out.println("您还有" + blood + "格血");
            }
        }
    }
}
 
  
（2）猜拳(运用函数封装/分支和循环语句)
 
  
简单思路：用户出拳，电脑出拳，比较，代码如下：
 
  
public class Demo {
    public static int userQuan;//声明全局变量
    public static int pcQuan;//声明全局变量
    public static int pcPoint = 0;
    public static int userPoint = 0;
    public static Scanner scanner = new Scanner(System.in);
    public static void main(String[] args) {
        while (true) {
            try {
                userChuQuan();
                pcChuQuan();
                System.out.println("用户出" + chuLi(userQuan) + ",电脑出" + chuLi(pcQuan));
                result();
                if (userPoint == 5||pcPoint == 5 ) {
                    if (pcPoint == 5) {
                        System.out.println("电脑最终获得了胜利,继续加油！！");
                    }
                    else{
                        System.out.println("您最终获得了胜利，恭喜恭喜！");
                    }
                    pcPoint=0;//电脑
                    userPoint=0;//人
                    System.out.println("------------------");
                    System.out.print("继续请输入1，退出输入任意键：");

                    int i1 = scanner.nextInt();
                    if (i1 == 1) {
                        continue;
                    } else {
                        break;
                    }
                }
            } catch (Exception e) {
                System.out.println("输入有误！");
                break;
            }
        }
    }
    public static void result() {
        if (userQuan == pcQuan) {
            System.out.println("平局");
            System.out.println("电脑现在的分数是"+pcPoint+",   您现在的分数是"+userPoint);
        } else if ((userQuan == 0 && pcPoint == 1) || (userQuan == 1 && pcPoint == 2) || (userQuan == 2 && pcPoint == 0)) {
            userPoint++;
            System.out.println("电脑现在的分数是"+pcPoint+",   您胜+1分,您现在的分数是"+userPoint);
        } else {
            pcPoint++;
            System.out.println("电脑胜+1分,电脑现在的分数是"+pcPoint+",   您现在的分数是"+userPoint);
        }
    }
    public static void userChuQuan() { //用户出拳
        System.out.print("请出拳,0-石头，1-剪刀，2-布:");
        userQuan = scanner.nextInt();
    }
    public static void pcChuQuan() {//电脑出拳
        Random random = new Random();
        pcQuan = random.nextInt(3);
    }
    public static String chuLi(int i) {
        switch (i) {//将1转换为中文剪刀
            case 0:
                return ("石头");
            case 1:
                return ("剪刀");
            case 2:
                return ("布");
        }
        return null;
    }
}
 
  
 
  
day20（函数与打地鼠）
 
  
1、ctrl+shift+alt+l  格式化代码
 
  
2、System.out.print 打印不换行   加ln就是换行
 
  
3、写打地鼠     
 
  
用二维数组代表地图   
 
  
（1）、声明二维数组（动态声明）代表地图
 
  
（2）、初始化地图
 
  
（3）、随机放入老鼠
 
  
（4）、绘制地图
 
  
（5）、玩家输入坐标打老鼠
 
  
String next = scanner.next();//这是输入字符串的方法
 
  
==的问题 本质是比较内存中的地址是否相同
 
  
java里面会节省内存，比如int num=10；int num1=10；都指向同一空间
 
  
System.out.println("s"=="s");  结果是true 都是一个空间
 
  
如果是输入的字符串，因为电脑不知道是否相同，所以开辟另个空间，所以==不可以
 
  
需要用字符串.equals 方法来比较字符串内容
 
  
字符串.equalsIgnoreCase()方法无视大小写 或者用||
 
  
4、如何解决冗余: 使用函数/方法解决它
 
  
5、函数：一段具备特定功能的、高度封装的代码块
 
  
封装:省略技术细节，只提供使用方法   比如手机芯片怎么做，你只要使用就行
 
  
英文名：function   
 
  
   (1)函数的声明   
 
  
               1、修饰符：public static  公开的 静态的
 
  
                2、返回值类  void  表返回值为null
 
  
                3、函数名    小驼峰命名
 
  
                4、参数列表  不写
 
  
                5、方法体  要执行的代码
 
  
（2）函数的调用     函数名();即调用
 
  
作业：
 
  
一：复习上课java内容，搞清楚打地鼠游戏如何实现的，并重新编辑一次打地鼠一遍，要求不看之前案例能够写出来。
 
  
二：继续完善打地鼠游戏 要求，
 
  
1：玩家一开始有血量3 没打中老鼠扣一点生命值 当生命为0的时候，才提问用户 是否重新开始游戏
 
  
2：玩家打中老鼠会加积分
 
  
3：游戏可重复进行，完成一次游戏后，要求输入y 才继续游戏 否则停止
 
  
day21(函数参数和返回值和作用域)
 
  
1、参数就是函数执行中，可能不相同的数值
 
  
参数分为：
 
  
形参  是虚的 不存在  占位置用的 用在函数声明过程中    声明时候必须加数据类型
 
  
实参 实际存在的  具备实际含义的参数  用在函数的调用过程中
 
  
2、多个参数之间用，隔开  有顺序要求
 
  
3、返回值：函数调用得到时候必须去接收它，用一个变量去接收
 
  
关键字 return      相当于小黑屋的同学往外面传一份卷子出去   返回数字出去，还能结束当前函数
 
  
4、变量作用域：函数内声明的变量  函数外无法使用 这种在函数内声明的变量称为局部变量
 
  
5、开始封装猜拳游戏  先根据功能模块  再对代码进行划分  然后再封装
 
  
（1）用户出拳  （2）电脑出拳（3）判断胜负（4）是否重复游戏模块
 
  
6、public static int userQuan;//声明全局变量 ，方法里不能有数据类型，不然又变局部变量
 
  
7、函数递归即函数里面调用函数自己 无线递归会导致内存溢出 不要乱用
 
  
8、第二个里程碑  面向对象编程  oop编程
 
  
什么是对象:所有一切看得到，摸着到都是对象，世间万物皆对象
 
  
如何描述对象：
 
  
对象的特点    称为属性
 
  
对象的行为 称为方法
 
  
day22（封装和对象的使用）
 
  
1、一定是自己主动做的事情才是对象的方法
 
  
2、由多个相同或是相似的对象抽象出来就是类
 
  
3、从类当中实例化出对象 
 
  
4、类是模板决定了这个对象有什么属性和方法,模板只是设计图，不能做东西，但是设计图设计出来的东西就可以用，也就是实例化出对象，让对象做事情
 
  
5、Java是一门面向对象语言
 
  
6、Java新建文件里的class 就是类的意思   class也定义了一种新的数据类型
 
  
7、方法基本类似于函数
 
  
8、对象使用属性 语法 对象名.属性
 
  
9、对象使用方法 语法 对象名.方法名()
 
  
10、面向对象的三大特性
 
  
（1）封装：私有化属性，并提供公有的访问方法。正常修改学生类，可以随意修改学生年龄1000岁都可以，这样不对，所以我们需要封装，可以改，但有条件
 
  
先将属性私有化了private，然后添加公有的get、set方法，get有返回值，set没有
 
  
快捷生成  选中-右键 -generate就能找到了
 
  
（2）继承
 
  
（3）多态
 
  
11、修饰符：
 
  
//private：私有的 能且仅能在本类中使用
 
  
//protect：本类、子类、同一包的类可见
 
  
//default（无修饰）：本类、同一包的类可见
 
  
//public:公有的 所有类 所有地方都可以访问
 
  
作业：
 
  
一：复习上课所讲对象还有类的知识点，整理对象的使用方式
 
  
二：将现实生活中找5个事物 列出他们的属性还有方法 要求至少5个属性 三个方法
 
  
并将结果写在记事本中。
 
  
随后用类的方式写在java文件中，然后实例化 并调用所有属性和方法。
 
  
三：思考整理 打地鼠游戏中 有几个对象 以及他们的属性各有什么。写在记事本中。
 
  
四：预习面向对象三大特性的其他两个，和修饰符的protected 以及 default 分别什么意思
 
  
day23(构造函数和重载)
 
  
1、打地鼠游戏里的对象
 
  
老鼠类    属性：X  Y                              方法：随机坐标
 
  
玩家类    属性： X  Y  血量   积分         方法：输入坐标
 
  
地图(可有可无) 
 
  
控制者/Controller 类如下（类似于电影后面的导演,管理一切）
 
  
属性 ：地鼠和玩家都是它的
 
  
方法：初始化地图   放置老鼠  绘制地图  判断是否打中   
 
  
2、面向过程：只关注事情本身的完成，不关注谁去做，就像大象塞进冰箱，不管是谁把冰箱打开，谁把大象弄进去
 
  
面向对象：更多关注 谁去做事情     各有各的好处
 
  
3、想弄个狗类，来实例化3种不同的狗以及不同年龄，可以用对象.属性赋值解决，但很麻烦。为了省事可以使用构造函数
 
  
4、构造函数：是一个没有返回值，并且函数名和类型相同的函数，在对象实例化的一瞬间就会执行，利用构造函数的参数，对属性进行赋值。
 
  
5、this指向对象本身
 
  
6、方法的重载：即在同一类中方法名相同  但是参数列表不同，是数据类型的不同，构造函数也可以用重载
 
  
 
  
day24(生命周期和static)
 
  
1、System.exit(0)  让程序整体退出
 
  
2、str.equalsIgnoreCase("")   判断字符是否相等并且无视大小写 
 
  
3、对象的生命周期 
 
  
对象的出生：一旦被声明被赋值之后  对象即出现
 
  
对象的销毁：当该对象没有被指向 就会被自动销毁
 
  
String a；这是空，没有对象，所以没有出生和销毁
 
  
属性的赋值写在构造函数里
 
  
4、static 静态的  声明的变量            可以直接用类名.变量名调用
 
  
它的方法只能访问它的数据，不能访问普通数据     少用，不能调动态
 
  
5、动态的 能调用动和静态  类的方法一般不加static ，加了就不能访问本类的属性
 
  
 
  
 
 
  
 6、普通数据类型里的变量名放在栈里面，数据放堆里面
 
  
作业：
 
  
一：复习上课所讲对象知识点，整理对象的使用方式和概念，做好笔记
 
  
二：完善打地鼠游戏 要求：
 
  
1：用户自定义地图大小功能
 
  
2：加入连击功能，连击提供分数倍数，最高分数5倍分数，没打中之后 会断连击。
 
  
三：继续预习继承和多态概念。
 
  
day25(继承和super)
 
  
1、函数不是必须要使用，先解决功能实现，再考虑是否去优化。
 
  
2、使用继承 解决代码冗余问题
 
  
 
  
3、 继承就是子类继承父类的属性和方法   苹果是水果可以继承水果类  食草动物是动物可以继承动物类  必须满足is-a关系    父类更通用 子类更具体
 
  
4、关键字extends  写在类名后面
 
  
5、一个类不可以继承多个类，只能继承1个
 
  
5、继承不可滥用，牵一发而动全身，父类改变一次，其他全部受到影响，即耦合性过高，现在继承通常用于我们写的类继承java官方的类
 
  
6、继承关系下    父类和子类构造函数的运行
 
  
        首先父的构造函数先执行   然后子的构造函数后执行    main方法里new的是子类，可以使用子类的构造函数的参数，父类想传参必须在子类里面加super再加需要传的值。因为没new父所以不能传参，必须靠子类
 
  
7、新的关键字 super ：放在代码里 用来子类给父类的构造函数的参数传参 ，找爹
 
  
8、在子类中可以用super.可以找到父类的属性和方法
 
  
9、类型转换，有点类似
 
  
作业：
 
  
一：复习上课所讲对象继承相关知识点，整理对象的使用方式和概念，做好笔记
 
  
二：完善打地鼠游戏 要求：
 
  
1：实现大中小三个老鼠，统一继承同一个父类，打中每个老鼠后加的分数不同，显示的名字也不同，
 
  
2：加入连击功能，连击提供分数倍数，连击后 根据连击获得对应倍数的基准分。连击最大5倍分数，没打中之后连击归0
 
  
尝试，做更多功能进入游戏中，并在做完功能后，写一份功能文档描述完成的功能。
 
  
三：查找default 和protected 的作用范围和用法，并记录。
 
  
四：预习多态，接口相关概念。
 
  
day26（多态和重写和接口）
 
  
1、多态指同一个事物能呈现出多种形态的能力   多态是继承的一种体现
 
  
2、比如创建狮子、老虎类，它们的方法都是吃和睡，方向需要传参那种类名和参数名小写，再创建饲养员类用来测试狮子和老虎类，正常需要创建2个test方法，传入老虎类和狮子类的类名和参数名小写，再创建Main类里弄main方法，new狮子和老虎和饲养员对象，饲养员.test（这是new的狮子）再饲养员.test（new的老虎对象），结果显示老虎和狮子吃睡   ！！！
 
  
多态的使用，需要再创建一个新的动物类，写入空的吃和睡的方法，啥参数都没，狮子类和老虎类去继承这个动物类。再去测试类那先将方法体注释，重新写一个方法，传入动物类的类名和参数名，直接调用动物的吃和睡方法。再去main运行结果一样。不过比前面更方便。这就是多肽使用
 
  
3、重写，指方法重写    
 
  
父类的方法，子类写的一模一样，最终执行的是子类的方法
 
  
重写规则：修饰符不能强于父类，返回类型、方法名、参数列表必须一样
 
  
4、重构：代码删了重新写
 
  
5、接口 ：没有方法体的方法的集合   
 
  
新建接口  new Java class里的interface
 
  
好处1：规定好整体项目的开发的规范
 
  
好处2：规定项目骨架 方便内容填充
 
  
6、接口的使用：
 
  
实现接口的要在类中 implements 
 
  
实现接口的类 需要全部实现  接口中的方法
 
  
有方法体的方法 被称为 实例方法
 
  
没方法体的方法 被称为 抽象方法
 
  
一个类可以实现多个接口 ，继承不能多继承。
 
  
7、继承代表血缘关系
 
  
接口代表社会关系
 
  
day27(常量)
 
  
1、往打地鼠游戏里加入道具功能
 
  
炸弹 (1）属性：名字 x  y坐标（2）方法：随机坐标
 
  
不能直接继承老鼠父类，不符合is-a关系，不能继承但是职责是一样的
 
  
 
  
 
  
2、常量：声明之后 不能改变的量就是常量     名称全部大写
 
  
关键字final 最终的意思       一个程序里的素材比如音乐图片等定义为常量，可以好调用
 
  
public static  final int NUM=100;
 
  
System.out.println(Demo.NUM);//使用文件名.常量调用它
 
  
 3、常量不仅可以在类里面声明，也就是上面，也可以在接口里面声明。接口里声明的变量都是常量 
 
  
public interface ChangLiang {
    int NUM=10;  //这是接口。然后定义的变量就是常量，接口无法new也无需
}
 
  
public class Demo {
    public static  final int NUM=100;

    public static void main(String[] args) {
        System.out.println(Demo.NUM);//这是调用文件名的常量
        System.out.println(Math.PI);
        System.out.println(ChangLiang.NUM); //这是调用接口里的常用
    }
}
 
  
作业：
 
  
一：复习上课所讲对象多态和接口相关知识点，整理使用方式和概念，做好笔记
 
  
二：完善打地鼠游戏 要求：
 
  
1：实现 增加炸弹功能 打到炸弹会扣分 并且 炸弹和老鼠使用相同接口
 
  
2：尝试 增加道具功能 例如：获取血包后会恢复生命值 宝藏分数更高等等
 
  
3：尝试，做更多功能进入游戏中，
 
  
4：所有写好的功能 需要写一份说明 讲清楚有什么功能 如何玩游戏
 
  
三：完成作业后，记得填写群内进度。
 
  
day28(接口与抽象类和API和验证码)
 
  
1、创建一个动物接口，里面有很多方法，猫类实现这接口，就必须全部实现，有些动物会飞，猫不会，这就是接口的缺陷。解决1：使用一个父类去实现这个接口，子类继承这个父类。   解决2：使用抽象类又可以写方法的实现又可以写方法的继承，也是使用继承
 
  
2、抽象类还是个类  抽象关键字  abstract
 
  
3、抽象类里既可以写抽象方法，还可以写实例方法
 
  
普通类只有实例方法，接口只有抽象方法(无方法体)
 
  
4、抽象类和接口一样不能被new
 
  
错错错错
 
  
 5、学习了监听之后  接口和抽象类都会用到
 
  
6、Java String的用法   复合数据类型
 
  
字符串类似于字符的数组，有下标和长度
 
  
7、API 使用文档
 
  
indexof 作用查找字符串，找不到返回-1  找到返回对应坐标，大小写敏感,默认找第一个出现的字母,也可以查找多字符串              关键字搜索   返回值不为-1就搜到   
 
  
System.out.println(str.indexOf("or",4));//从索引4开始找
 
  
8、验证码   （1）随机字母或者数字 （2）长度一般4到6       是一个反图灵测试
 
  
 
  
        String codeBox = "0123456789qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM";
        //太像的字符会被去掉
        String code="";
        for (int i=0;i<4;i++) {
            int ranNum = new Random().nextInt(codeBox.length());
//            System.out.println(codeBox.charAt(ranNum));
            code+=codeBox.charAt(ranNum);
        }
        System.out.println(code);
    }
 
  
作业：
 
  
一：复习对象所有知识点，整理使用方式和概念，做好笔记，写成思维导图并提交
 
  
二：将打地鼠游戏再次梳理，并理解每个部分功能，随后尝试加入新功能进去，记得写好说明
 
  
三：将ppt（发在群里了）里面的字符串常用函数自己操作 并写好对该函数的理解，用自己的语言写
 
  
四：把验证码自己再写一次 并且加上比较的功能，能够提示是否输入正确 并且大小写不敏感
 
  
五：预习异常和arrayList概念
 
  
day29(封装类与异常处理与断点调试与列表)
 
  
1、数字属于基本类型 默认不带方法，但它们都有对应的封装类
 
  
2、封装类  int对应Interger  char对应Character  其他都是首字母大写
 
  
int num =10;
Integer newInt = new Integer(num);//可以new或者直接等于num
char num1 = 'a';
Character newNum1=num1;
System.out.println(newInt.toString()+newNum1.toString());
 
  
3、异常
 
  
出现了意外导致程序中断
 
  
try{
 
  
写可能产生异常的代码块
 
  
}catch(e){
 
  
写一旦出现了异常就执行内部的代码
 
  
}
 
  
e.printStackTrace()  //提示报错信息
 
  
e代表错误对象
 
  
Exception
 
  
InputMismatchException 代表输入异常
 
  
ArithmeticException  算数异常
 
  
4、多重异常处理
 
  
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数字：");
try {
    int i = scanner.nextInt();
    System.out.println("结果是" + 10 / i);
} catch (InputMismatchException e) {
    System.out.println("您输入的不是数字");
}catch (ArithmeticException e) {
    System.out.println("请不要输入0");
}catch (Exception e) {
    System.out.println("程序出错，请管理员修改");
}
System.out.println("结束");
 
  
5、断点调试 先红点起来，debug run  它
 
  
6、分包
 
  
设计模式 
 
  
MVC模式：
 
  
（1）Model模型类 指所有实体类
 
  
（2）View 视图层 指所有试图相关类
 
  
（3）Controller控制层   指所有管理者相关类
 
  
 7、登录\注册功能
 
  
需要账号和密码
 
  
登录的步骤：
 
  
注册的步骤：
 
  
本游戏中有几个用户?多个用户，不能用数组存，具体几个不清楚
 
  
需要一个  可变长度  并且 可以存储玩家这样的复合类型的存储方式，这时候需要arrayList 属于 数据结构之一 它的父类是List类  某种意义上说arrayList是可变长度的数组
 
  
列表方法：
 
  
        add()  列表的添加
 
  
        size() 查看列表的长度
 
  
        get(下标)   根据列表下标获取内容
 
  
Player[] player = new Player[5];
ArrayList arrayList = new ArrayList();
//如果不告诉arrayList要存什么类型，默认是object
Player player1 = new Player();
Player player2 = new Player();
Player player3 = new Player();
Player player4= new Player();
arrayList.add(player1);
arrayList.add(player2);
System.out.println(arrayList.size());
System.out.println(arrayList.get(0));
 
  
 
  
Player[] player = new Player[5];
ArrayList arrayList = new ArrayList();
//如果不告诉arrayList要存什么类型，默认是object
Player player1 = new Player();
Player player2 = new Player();
Player player3 = new Player();
Player player4= new Player();
arrayList.add(player1);
arrayList.add(player2);
System.out.println(arrayList.size());
System.out.println(arrayList.get(0).play_x);
 
  
 
  
ArrayList arrayList = new ArrayList();
//如果不告诉arrayList要存什么类型，默认是object
Player player1 = new Player();
Player player2 = new Player();
Player player3 = new Player();
Player player4= new Player();
arrayList.add(player1);
arrayList.add(player2);
arrayList.add(player3);
arrayList.add(player4);
for (int i = 0; i  
  
作业：
 
  
一：复习对象所有知识点，复习整理异常用法，整理好ArrayList的语法
 
  
二：将打地鼠游戏用trycatch进行完善和整理。
 
  
三：再次练习arrayList语法，思考登陆注册功能需要的内容有什么。
 
  
day30(登录与注册)
 
  
1、arrayList  可以看成一个可变长度的数组
 
  
add  给类别添加内容 
 
  
 size 查询长度 
 
  
 get 获取列表内容   
 
  
 remove 删除指定下标内容
 
  
clear  全部删除
 
  
列表不能存基本数据类型，数组可以，如果要是使用，去用它们的封装类即可。
 
  
2、打地鼠里的Player是角色，不是人，把登录注册写在Controller里面
 
  
3、注册：（1）输入账号（判断账号是否重复，如果重复，直接结束注册)（2）输入密码及确认密码（3）判断2个密码是否相同（4）存储账号密码   以属性的形式存在player里面（5）player存到列表里面（6）提示注册成功
 
  
4、登录（1）输入账号密码（2）开始比较验证码是否正确（3）循环列表进行比较（4）如果账号密码相同则提示登录成功否则提示登录失败
 
  
作业：
 
  
一：复习上课相关知识点。
 
  
二：继续完善打地鼠游戏 加入登陆注册功能，理解清楚上课的案例怎么实现的
 
  
要求：额外实现 注册查重功能
 
  
三：预习swing功能
 
  
day31(第三里程碑Swing)
 
  
1、界面（1）客户端（2）浏览器端
 
  
Swing 组件是基于 AWT 构建。
 
  
Swing组件除了 AbstractButton 类之外都以 J 开头。
 
  
2、Swing的结构  最外层顶级容器（JFrame、JDialog、JApplet）   然后中间容器 （JPanel、JScrollPane、JTabbedPane、JToolBar） 再若干组件
 
  
(1)顶级容器使用，一般新建一个类去继承JFrame，然后主类去new它，自动运行构造函数
 
  
public class MyFirstFrame extends JFrame {
    public MyFirstFrame() {
        setSize(600,300);//设置宽高
        setLocationRelativeTo(null);//设置居中
        setTitle("我的第一个界面");//设置标题
        setResizable(false);//设置不能修改大小
        setDefaultCloseOperation(EXIT_ON_CLOSE);//点X退出程序，这是常量结果是3，写3也可以，不过不推荐
        setVisible(true);//最后一行，显示
    }
}
 
  
 
  
public class Test {
    public static void main(String[] args) {
        MyFirstFrame myFirst = new MyFirstFrame();

    }
}
 
  
(2)中间容器使用，一般弄完顶层容器之后，去新建一个类用来处理中间容器比如JPanel,继承它，然后设置它,再它里面添加组件，再去顶层容器那new中间容器，并添加使用
 
  
public class MyFirstPanel extends JPanel {
    public MyFirstPanel() {
        setBackground(new Color(39, 128, 59));//设置背景颜色
        JButton btn1 = new JButton("这是按钮");//添加按钮组件并给按钮起名称
        add(btn1);//添加它
        JLabel jLabel = new JLabel("天气不错！");
        add(jLabel);
    }
}
 
  
3、组件布局有差别   (1)自由布局setLayout(null) 
 
  
4、背景图在
 
  
MyFirstPanel类里面重写它的方法
 
  
@Override
protected void paintComponent(Graphics g) {//这个没s
    super.paintComponent(g);//实现图片绘制的方法
    Image bgImg = new ImageIcon("img/3.png").getImage();
    g.drawImage(bgImg, 0, 0, 600, 300,null);//第五参数观察者
}
 
  
5、菜单在顶级容器里添加  （1）菜单栏（2）菜单（3）菜单项
 
  
绝大部分组件添加用add，它用setJmenuBar
 
  
public class MyFirstFrame extends JFrame {
    public MyFirstPanel myFirstPanel;//声明
    public MyFirstFrame() {
        myFirstPanel = new MyFirstPanel();//new它
        setSize(600, 300);//设置宽高
        setLocationRelativeTo(null);//设置居中
        setTitle("我的第一个界面");//设置标题
        setResizable(false);//设置不能修改大小
        setDefaultCloseOperation(EXIT_ON_CLOSE);//点X退出程序，这是常量结果是3，写3也可以，不过不推荐
        add(myFirstPanel);//添加中间容器

        JMenuBar jMenuBar = new JMenuBar();//菜单栏
        JMenu jMenu1 = new JMenu("菜单1");//菜单
        jMenuBar.add(jMenu1);
        setJMenuBar(jMenuBar);//注意！添加菜单栏带顶级容器,其他用add

        JMenuItem jMenuItem1 = new JMenuItem("第1项");//菜单项
        JMenuItem jMenuItem2 = new JMenuItem("第2项");
        JMenuItem jMenuItem3 = new JMenuItem("第3项");
        jMenu1.add(jMenuItem1);//将菜单项添加到菜单
        jMenu1.add(jMenuItem2);
        jMenu1.add(jMenuItem3);

        JMenu jMenu4 = new JMenu("子菜单");//子菜单
        JMenuItem jMenuItem = new JMenuItem("普通1");
        jMenu4.add(jMenuItem);
        jMenuBar.add(jMenu4);
        JMenu jMenu5 = new JMenu("普通2");//子菜单
        jMenu4.add(jMenu5);
        JMenuItem jMenuItem4 = new JMenuItem("1");
        JMenuItem jMenuItem5 = new JMenuItem("2");
        jMenu5.add(jMenuItem4);
        jMenu5.add(jMenuItem5);

        setVisible(true);//最后一行，显示
    }
}
 
  
day32(布局管理器)
 
  
1、乱码：字符集     用记事本打开 确定是否还是中文 如果是 可以通过另存修改字符集
 
  
如果修改字符集没用  那么直接复制所有代码进编译器
 
  
2、布局管理器  
 
  
（1）null是自由布局
 
  
 
  
（2） FlowLayout 是JPanel的默认布局        流式布局
 
  
 
  
 
  
setLayout(new FlowLayout(FlowLayout.LEFT));//流式布局 左边  其他设置宽高都无效化
 
  
setLayout(new FlowLayout(FlowLayout.LEFT,0,20));//设置水平0和垂直20间距
 
  
（3）BorderLayout  边界布局 是JFrame的默认布局
 
  
如果是add方法做添加，必须指定位置添加，东西南北，默认是中间
 
  
setLayout(new BorderLayout());//设置布局
 
  
add(btn1,BorderLayout.NORTH);//北 
 
  
setLayout(new BorderLayout(10,20));//参数设置间隔
 
  
优先满足上下左右，剩下给中间  
 
  
右边区域太小咋办？用了布局就不能设置大小，可以用
 
  
btn3.setPreferredSize(new Dimension(250,0));//因为是右边，所以只有宽度，高设置无法生效
 
  
 
  
 如果是上下区域，宽度无效，如果是左右区域，高度无效。
 
  
右边区域有不少JLabel咋办，首先右边只能放一个组件，所以在右侧区域里面放一个JPanel
 
  
（4）GridLayout 网格布局
 
  
 
  
 
  
setLayout(new GridLayout(3,2));//3行与2列
 
  
 
  
（5）CardLayout 卡片布局
 
  
3、事件：java中的事件，就是一件能被java捕获到的事情
 
  
java处理事件的模式是 授权事件模型
 
  
1、事件源  2、监听器 
 
  
day33（事件监听器）
 
  
1、
 
  
 2、将用的到的组件或是JPanel都作为属性书写  而不是局部变量1
 
  
3、写监听的步骤（1）写好监听器（2）实例化监听器（3）给组件注册监听
 
  
4、先给注册按钮   安装监听
 
  
监听器类一般写在Controller
 
  
第一种监听使用鼠标监听  利用鼠标监听器的接口
 
  
事件安装之后 一定要验证 是否安装成功   很重要这一点！！！
 
  
发现每一个按钮和菜单项 好像都得写一个监听器类
 
  
如何优化？
 
  
5、窗口监听
 
  
给谁安装？
 
  
6、弹窗使用的类 JOptionPane
 
  
发现每一个按钮  和菜单项好像都要写一个监听器如何优化？
 
  
 
  
7、ActionListener   动作监听
 
  
可以给按钮 以及菜单项的点击都能监听但是不同按钮之间 怎么区分？
 
  
ActionCommand 动作指令
 
  
实现注册功能，方法是在监听中调用到controller 的注册方法，不适应用ui一样套个static，使用构造参数传参，监听器需要参数
 
  
 
  
day34（打地鼠游戏主界面）
 
  
1、思路：(1)游戏中要出现地鼠  地鼠随机坐标出现（2）老鼠会随时间改变位置（3）老鼠可以被命中（4）命中之后改变老鼠图片（5）倒计时30s打老鼠（6）最后有结算功能
 
  
2、定时器 
 
  
每隔一段时间 做点什么事情  
 
  
两大关键要素  间隔时间 以及 做的事情
 
  
Timer是定时器，但是自己的类不要叫这个，我们打地鼠是界面版，所以必须导入swing包中的Timer，并且必须结合界面才能运行。
 
  
3、如何判断命中老鼠？碰撞体积检测
 
  
鼠标坐标获取
 
  
问题1：没开始就能打
 
  
问题2：一只老鼠可以被打很多次  
 
  
问题3：计算积分
 
  
day35（斗地主项目1）
 
  
1、需求分析、项目功能编写
 
  
2、完成了欢迎界面以及游戏界面的菜单栏
 
  
3、游戏主界面的思路：（1）进入游戏主界面，初始化3个玩家，一个自己，默认初始1000分，点击菜单栏里的发牌，开始随机发牌，一副牌54张，1人17张，留3做底牌，在地主确认之前不能看底牌，随机生成一张牌作为叫地主的根据、游戏发牌中再点发牌会暂停询问是否继续或者重新开始。（2）叫牌 按随机某个玩家，按出牌顺序轮流，叫牌可以选择某分值的叫地主、不叫、如果有玩家叫根据分数决定谁是地主，确定了地主后顶部显示三张底牌插入到用户玩家牌里，并明显显示哪3张
 
  
day36(2)
 
  
1、完善所有界面布局及监听，设计卡牌类
 
  
day37(3)
 
  
1、完成玩家类和发牌动画效果
 
  
day38(4)
 
  
1、叫地主思路：父类有个方法给2个ai来继承，玩家重写自己的，每次叫的时候判断是否为地主，如果叫的是1，那么下一个只能叫2，3，或者不叫。玩家如果弹出来的必须是数组里面剩余的选项
 
  
day39(5)
 
  
1、完成叫分所有功能
 
  
day40(6)
 
  
1、完成简单出牌
 
  
day41(7)
 
  
day42(8)
 
  
day43(9)
 
  
day44(10)
 
  
day45(11)