JavaSE基础知识（附上代码实现）1

###01.01_计算机基础知识(计算机概述)(了解)
* A:什么是计算机?计算机在生活中的应用举例
    * 计算机（Computer）全称：电子计算机，俗称电脑。是一种能够按照程序运行，自动、高速处理海量数据的现代化智能电子设备。由硬件和软件所组成，没有安装任何软件的计算机称为裸机。常见的形式有台式计算机、笔记本计算机、大型计算机等。
    * 应用举例
        * 1：科学计算
        * 2、数据处理
        * 3、自动控制
        * 4、计算机辅助设计
        * 5、人工智能
        * 6、多媒体应用
        * 7、计算机网络
        * ... 
* B:什么是硬件?硬件举例
    * 计算机硬件（Computer Hardware）是指计算机系统中由电子，机械和光电元件等组成的各种物理装置的总称。这些物理装置按系统结构的要求构成一个有机整体为计算机软件运行提供物质基础。
    * 冯.诺依曼体系结构
    * 计算机的硬件分成5大组成部件：运算器、控制器、存储器、输入设备和输出设备。
    
        * 运算器和控制器是计算机的核心，合称中央处理单元（Central Processing Unit，CPU）或处理器。CPU的内部还有一些高速存储单元，被称为寄存器。其中运算器执行所有的算术和逻辑运算；控制器负责把指令逐条从存储器中取出，经译码后向计算机发出各种控制命令；而寄存器为处理单元提供操作所需要的数据。
        * 存储器是计算机的记忆部分，用来存放程序以及程序中涉及的数据。它分为内部存储器和外部存储器。内部存储器用于存放正在执行的程序和使用的数据，其成本高、容量小，但速度快。外部存储器可用于长期保存大量程序和数据，其成本低、容量大，但速度较慢。
        * 输入设备和输出设备统称为外部设备，简称外设或I/O设备，用来实现人机交互和机间通信。微型机中常用的输入设备有键盘、鼠标等，输出设备有显示器、打印机等。
* C:什么是软件?软件分类及举例
    * 计算机软件(Computer Software)是使用计算机过程中必不可少的东西，计算机软件可以使计算机按照事先预定好的顺序完成特定的功能
    * 计算机软件按照其功能划分为系统软件与应用软件
        * 系统软件： DOS(Disk Operating System), Windows, Linux, Unix, Mac, Android, iOS
        * 应用软件：office  QQ聊天  YY语言  扫雷
###01.02_计算机基础知识(软件开发和计算机语言概述)(了解)
* A:什么是软件
    * 按照特定顺序组织的计算机数据和指令的集合
* B:什么是开发
    * 软件的制作过程
* C:什么是软件开发
    * 借助开发工具与计算机语言制作软件 
* D:什么是计算机语言
    * 人与计算机之间进行信息交流沟通的一种特殊语言
* E:计算机语言的分类
    * 机器语言：
        * 机器语言是直接用二进制代码指令表达的计算机语言，指令是用0和1组成的一串代码，它们有一定的位数，并分成若干段，各段的编码表示不同的含义。
    * 汇编语言：
        * 汇编语言是使用一些特殊的符号来代替机器语言的二进制码，计算机不能直接识别，需要用一种软件将汇编语言翻译成机器语言。
    * 高级语言：  
        * 使用普通英语进行编写源代码，通过编译器将源代码翻译成计算机直接识别的机器语言，之后再由计算机执行。
        * 高级语言包括C,C++,C#,JAVA
###01.03_计算机基础知识(人机交互)(了解)
* A:人机交互的两种方式
    * a:命令行方式 
        * 需要有一个控制台，输入特定的指令，让计算机完成一些操作。较为麻烦，需要记录住一些命令。 
    * b:图形化界面方式
        * 这种方式简单直观，使用者易于接受，容易上手操作。
    
###01.04_计算机基础知识(键盘功能键和快捷键)(掌握)
* A:键盘功能键
    * a:Tab
    * b:Shift
    * c:Ctrl
    * d:Alt
    * e:空格    
    * f:Enter
    * g:Window
    * h:上下左右键
    * i:PrtSc(PrintScreen)屏幕截图
* B:键盘快捷键
    * a:Ctrl+A    全选
    * b:Ctrl+C    复制
    * c:Ctrl+V    粘贴
    * d:Ctrl+X    剪切
    * e:Ctrl+Z    撤销
    * f:Ctrl+S    保存

###01.05_计算机基础知识(如何打开DOS控制台)(掌握)
* A:xp下如何打开DOS控制台？
    * a:开始--程序--附件--命令提示符
    * b:开始--运行--cmd--回车
    * c:win+r--cmd--回车
* B:win7下如何打开DOS控制台？
    * a:开始--所有程序--附件--命令提示符
    * b:开始--搜索程序和文件--cmd--回车
    * c:win+r--cmd--回车
* C:win8下如何打开DOS控制台
    * a:鼠标左击开始--下箭头--命令提示符
    * b:鼠标右击开始--搜索--cmd--回车
    * c:鼠标右击开始--运行--cmd--回车
    * d:win+r--cmd--回车

###01.06_计算机基础知识(常见的DOS命令讲解)
* A:d: 回车    盘符切换
* B:dir(directory):列出当前目录下的文件以及文件夹
* C:cd (change directory)改变指定目录(进入指定目录)
* D:cd.. : 退回到上一级目录
* E:cd\: 退回到根目录
* F:cls : (clear screen)清屏
* G:exit : 退出dos命令行(分割线上的需要掌握,下的了解)
* /=========================================================
* md (make directory) : 创建目录
* rd (remove directory): 删除目录
* del (delete): 删除文件,删除一堆后缀名一样的文件*.txt
* notepad 创建文件
* 删除带内容的文件夹
    * rd + /s    文件夹名称(询问是否删除)
    * rd + /q + /s 文件夹名称(直接删除)
    
###01.07_Java语言基础(Java语言概述)(了解)
* A:Java语言发展史
    * 詹姆斯·高斯林（James Gosling）1977年获得了加拿大卡尔加里大学计算机科学学士学位，1983年获得了美国卡内基梅隆大学计算机科学博士学位，毕业后到IBM工作，设计IBM第一代工作站NeWS系统，但不受重视。后来转至Sun公司，1990年，与Patrick，Naughton和Mike Sheridan等人合作“绿色计划”，后来发展一套语言叫做“Oak”，后改名为Java。
    * SUN(Stanford University Network，斯坦福大学网络公司) 
* B:Java语言版本
    * JDK 1.1.4        Sparkler    宝石                1997-09-12
    * JDK 1.1.5        Pumpkin        南瓜                1997-12-13
    * JDK 1.1.6        Abigail        阿比盖尔--女子名        1998-04-24
    * JDK 1.1.7        Brutus        布鲁图--古罗马政治家和将军    1998-09-28
    * JDK 1.1.8        Chelsea        切尔西--城市名            1999-04-08
    * J2SE 1.2        Playground    运动场                1998-12-04
    * J2SE 1.2.1        none        无                1999-03-30
    * J2SE 1.2.2        Cricket        蟋蟀                1999-07-08
    * J2SE 1.3        Kestrel        美洲红隼(sǔn)            2000-05-08
    * J2SE 1.3.1        Ladybird    瓢虫                2001-05-17
    * J2SE 1.4.0        Merlin        灰背隼                2002-02-13
    * J2SE 1.4.1        grasshopper    蚱蜢                2002-09-16
    * J2SE 1.4.2        Mantis        螳螂                2003-06-26
    * JAVASE 5.0 (1.5.0)    Tiger        老虎    
    * JAVASE 5.1 (1.5.1)    Dragonfly    蜻蜓    
    * JAVASE 6.0 (1.6.0)    Mustang        野马
    * JAVASE 7.0 (1.7.0)    Dolphin        海豚
* C:Java语言平台
    * J2SE(Java 2 Platform Standard Edition)标准版
        * 是为开发普通桌面和商务应用程序提供的解决方案,该技术体系是其他两者的基础，可以完成一些桌面应用程序的开发
    * J2ME(Java 2 Platform Micro Edition)小型版
        * 是为开发电子消费产品和嵌入式设备提供的解决方案
    * J2EE(Java 2 Platform Enterprise Edition)企业版
        * 是为开发企业环境下的应用程序提供的一套解决方案,该技术体系中包含的技术如 Servlet、Jsp等，主要针对于Web应用程序开发 
* C:Java语言特点
    * 简单性        
    * 解释性
    * 面向对象        
    * 高性能
    * 分布式处理    
    * 多线程
    * 健壮性        
    * 动态
    * 结构中立        
    * 安全性
    * 开源
    * 跨平台
###01.08_Java语言基础(Java语言跨平台原理)(掌握)
* A:什么是跨平台性
* B:Java语言跨平台原理
    * 只要在需要运行java应用程序的操作系统上，先安装一个Java虚拟机(JVM Java Virtual Machine)即可。由JVM来负责Java程序在该系统中的运行。
* C:Java语言跨平台图解
    * write once ,run anywhere!(一处编译,到处运行)
###01.09_Java语言基础(JRE和JDK的概述)(掌握)
* A:什么是JRE
    * 包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。
    * JRE:JVM+类库。 
* B:什么是JDK
    * JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE。所以安装了JDK，就不用在单独安装JRE了。
    * 其中的开发工具：编译工具(javac.exe)  打包工具(jar.exe)等
     * JDK:JRE+JAVA的开发工具。
* C:为什么JDK中包含一个JRE
    * 为什么JDK中包含一个JRE呢？
        * 开发完的程序，需要运行一下看看效果。
* D:JDK,JRE,JVM的作用和关系
###01.10_Java语言基础(JDK的下载和安装过程图解)(了解)
* A:JDK的下载
    * a:官网 http://www.oracle.com
    * b:演示下载流程
* B:JDK的安装
    * a:傻瓜式安装
        * 双击安装程序，然后一路next即可(但是不建议)
    * b:安装的推荐方式
        * 安装路径不要有中文或者特殊符号如空格等。
        * 所有和开发相关的软件最好安装目录统一。
            * 举例：我的JDK安装路径
                * D:\develop\Java\jdk1.7.0_72
        * 当提示安装JRE时，可以选择不安装。建议还是安装上。
    * c:演示安装流程
        * 可以先在d盘建立一个文件夹develop
        * 然后演示安装过程
* C:验证安装是否成功
    * a:通过DOS命令，切换到JDK安装的bin目录下。
        * D:\develop\Java\jdk1.7.0_72\bin
    * b:然后分别输入javac和java，如果正常显示一些内容，说明安装成功
        
###01.11_Java语言基础(JDK安装路径下的目录解释)(了解)
* a:bin目录：该目录用于存放一些可执行程序。
    * 如javac.exe（java编译器）、java.exe(java运行工具)，jar.exe(打包工具)和* javadoc.exe(文档生成工具)等。
* b:db目录：db目录是一个小型的数据库。
    * 从JDK 6.0开始，Java中引用了一个新的成员JavaDB，这是一个纯Java实现、开源的数据库管理系统。这个数据库不仅轻便，而且支持JDBC 4.0所有的规范，在学习JDBC 时，不再需要额外地安装一个数据库软件，选择直接使用JavaDB即可。
* c:jre目录："jre"是 Java Runtime Environment 的缩写，意为Java程序运行时环境。此目录是Java运行时环境的根目录，它包括Java虚拟机，运行时的类包，Java应用启动器以及一个bin目录，但不包含开发环境中的开发工具。
* d:include目录：由于JDK是通过C和C++实现的，因此在启动时需要引入一些C语言的头文件，该目录就是用于存放这些头文件的。
* e:lib目录：lib是library的缩写，意为 Java 类库或库文件，是开发工具使用的归档包文件。
* f:src.zip文件：src.zip为src文件夹的压缩文件，src中放置的是JDK核心类的源代码，通过该文件可以查看Java基础类的源代码。

###01.12_Java语言基础(Java开发工具介绍)(了解)
* A:notepad(微软操作系统自带)
* B:Editplus/Notepad++
* C:Eclipse
* D:MyEclipse
    * 给大家简单的介绍一下这些工具，然后说说我们使用这些工具的顺序。
    * 基础班：先notepad，然后Editplus，再Eclipse。
    * 就业班：MyEclipse和Eclipse都用。

###01.13_Java语言基础(HelloWorld案例的编写和运行)(掌握)
* A:定义类
* B:写main方法
* C:写输出语句
* D:Java程序开发运行与工作原理
* E:编译和运行程序

        class HelloWorld {
            public static void main(String[] args) {
                System.out.println("HelloWorld");
            }
        }
    
###01.14_Java语言基础(HelloWorld案例常见问题)(掌握)
* A:找不到文件(都演示一下，让学生看看出现的都是什么问题)
    * a:文件扩展名隐藏导致编译失败
    * b:文件名写错了
* B:单词拼写问题(都演示一下，让学生看看出现的都是什么问题)
    * a:class写成Class
    * b:String写成string
    * c:System写成system
    * d:main写成mian
* C:括号匹配问题(都演示一下，让学生看看出现的都是什么问题)
    * a:把类体的那对大括号弄掉一个
    * b:把方法体的那对大括号弄掉一个
    * c:把输出语句的那对小括号弄掉一个
* D:中英文问题(都演示一下，让学生看看出现的都是什么问题)
    * a:提示信息：错误: 非法字符: \????的格式
    * 注意：java编程中需要的基本上都是英文字符

###01.15_Java语言基础(Java语言的书写格式(约定俗成))    (掌握)
* 1,大括号要对齐,并且成对写
* 2,左大括号前面有空格
* 3,遇到左大括号要缩进,Tab
* 4,方法和程序块之间加空行让程序看起来清晰
* 5,并排语句之间加空格,例如for语句
* 6,运算符两侧加空格

###01.16_Java语言基础(path环境变量的作用及配置方式1)(掌握)
* A:在JDK的bin目录下开发程序容易产生的问题
    * a:如果文件过多，不方便管理
    * b:删除自己写过的不需要的文件，可能不小心把JDK自带的工具给删除了
* B:如何解决问题呢
    * notepad这样的命令为什么在任何路径下都能够执行,配置path环境变量
* C:配置方式
    * a:xp系统
        * 右键点击桌面计算机→选择属性→选择高级选项卡→点击环境变量→下方系统变量中查找path→双击path→将jdk安装目录下的bin目录添加到最左边并添加分号。
    * b:win7/win8系统
        * 右键点击桌面计算机→选择属性→选择高级系统设置→选择高级选项卡→点击环境变量→下方系统变量中查找path→双击path→将jdk安装目录下的bin目录添加到最左边并添加分号。
* path配置的是可执行的文件.exe,配置后可以在不同的盘符下访问path路径下的可执行文件

###01.17_Java语言基础(Path环境变量的配置方式2)(掌握)
* A:先配置JAVA_HOME
* B:再修改path
* C:最后说一下path是有先后顺序关系的

###01.18_Java语言基础(classpath环境变量的作用及其配置)(了解)
* A:为什么要配置classpath
* B:classpath配置的原理
* C:如何配置classpath

* path和classpath的区别
    * path配置的是可执行的文件.exe,配置后可以在不同的盘符下访问path路径下的可执行文件
    * classpath配置的java的类文件,就是.class文件

###01.19_Java语言基础(Editplus开发程序并编译运行)(了解)
* A:配置快捷键编译运行
* B:去除备份文件

###01.20_Java语言基础(注释概述及其分类)(掌握)
* A:什么是注释
* B:注释的分类及讲解
    * 文档注释目前不讲，说后面讲解

* 注释的作用
    * A:解释说明程序
    * B:帮助我们调试错误
    
###01.21_Java语言基础(关键字的概述和使用)(掌握)
* A:什么是关键字
    * 被Java语言赋予特定含义的单词 
* B:关键字的特点
    * 组成关键字的字母全部小写 
* C:常见关键字
    * public static void class等 
* D:关键字的注意事项
    * goto和const作为保留字存在,目前并不使用,类似Editplus这样的高级记事本,针对关键字有特殊的颜色标记，非常直观 

###01.22_Java语言基础(标识符的概述和组成规则)(掌握)
* A:什么是标识符
    * 就是给类,接口,方法,变量等起名字时使用的字符序列 
* B:标识符的组成规则
    * 英文大小写字母
    * 数字字符
    * $和_ 
* C:标识符注意事项
    * 1,不能使用关键字
    * 2,不能数字开头 

###01.23_Java语言基础(标识符中常见的命名规则)(了解)
* 见名知意
* A:包
    * 最好是域名倒过来,要求所有的字母小写 
* B:类或者接口
    * 如果是一个单词首字母大写
    * 如果是多个单词每个单词首字母大写(驼峰标识) 
* C:方法或者变量
    * 如果是一个单词全部小写
    * 如果是多个单词,从第二个单词首字母大写 
* D:常量
    * 如果是一个单词,所有字母大写
    * 如果是多个单词,所有的单词大写,用下划线区分每个单词 

###01.24_day01总结
* 把今天的知识点总结一遍。

###02.01_Java语言基础(常量的概述和使用)(掌握)
* A:什么是常量
    * 在程序执行的过程中其值不可以发生改变 
* B:Java中常量的分类
    * 字面值常量
    * 自定义常量(面向对象部分讲) 
* C:字面值常量的分类
    * 字符串常量    用双引号括起来的内容
    * 整数常量        所有整数
    * 小数常量        所有小数
    * 字符常量        用单引号括起来的内容,里面只能放单个数字,单个字母或单个符号
    * 布尔常量        较为特殊，只有true和false
    * 空常量            null(数组部分讲解)

* D:案例演示
    * 用输出语句输出各种常量。null不演示
            
###02.02_Java语言基础(进制概述和二,八,十六进制图解)(了解)
* A:什么是进制
    * 进制：就是进位制，是人们规定的一种进位方法。 对于任何一种进制--X进制，就表示某一位置上的数运算时是逢X进一位。二进制就是逢二进一，八进制是逢八进一，十进制是逢十进一，十六进制是逢十六进一。
    * 例如一周有七天,七进制,一年有十二个月,十二进制
* B:十进制的由来 
    * 十进制的由来是因为人类有十个手指 
* C:二进制的由来
    * 其实二进制来源与中国,请看史料记载
    * 18世纪德国数理哲学大师莱布尼兹从他的传教士朋友鲍威特寄给他的拉丁文译本《易经》中，读到了八卦的组成结构，惊奇地发现其基本素数（0）（1），即《易经》的阴爻yao- -和__阳爻，其进位制就是二进制，并认为这是世界上数学进制中最先进的。20世纪被称作第三次科技革命的重要标志之一的计算机的发明与应用，其运算模式正是二进制。它不但证明了莱布尼兹的原理是正确的，同时也证明了《易经》数理学是很了不起的。
* D:八进制的由来
    * 任何数据在计算机中都是以二进制的形式存在的。二进制早期由电信号开关演变而来。一个整数在内存中一样也是二进制的，但是使用一大串的1或者0组成的数值进行使用很麻烦。 
    * 所以就想把一大串缩短点，将二进制中的三位用一位表示。这三位可以取到的最大值就是7.超过7就进位了，这就是八进制。 
* E:十六进制的由来
    * 但是对于过长的二进制变成八进制还是较长，所以出现的用4个二进制位表示一位的情况，四个二进制位最大是15，这就是十六进制。
* F:不同进制表现同一个数据的形式特点
    * 进制越大，表现形式越短
 
###02.03_Java语言基础(不同进制数据的表现形式)(掌握)
* A:二进制的数据表现形式
    * 由0,1组成。以0b(b可以大写也可以小写)开头(JDK1.7版本可以表示二进制了)
* B:八进制的数据表现形式
    * 由0,1,…7组成。以0开头
* C:十进制的数据表现形式
    * 由0,1,…9组成。整数默认是十进制的 
* D:十六进制的数据表现形式
    * 由0,1,…9,a,b,c,d,e,f(大小写均可)。以0x开头 
* E:案例演示
    * 输出不同进制表现100的数据。
    * 0b100
    * 0100
    * 100
    * 0x100
        
###02.04_Java语言基础(任意进制到十进制的转换图解)(了解)
* A:任意进制到十进制的转换原理
    * 系数：就是每一位上的数据。
    * 基数：X进制，基数就是X。
    * 权：在右边，从0开始编号，对应位上的编号即为该位的权。
    * 结果：把系数*基数的权次幂相加即可。 
* B:画图练习
    * 二进制--十进制
    * 八进制--十进制
    * 十六进制--十进制

###02.05_Java语言基础(十进制到任意进制的转换图解)(了解)
* A:十进制到任意进制的转换原理
    * 除积倒取余 
* B:画图练习
    * 十进制--二进制
    * 十进制--八进制
    * 十进制--十六进制
    
###02.06_Java语言基础(快速的进制转换法)(了解)
* A:8421码及特点
    * 8421码是中国大陆的叫法，8421码是BCD代码中最常用的一种。在这种编码方式中每一位二值代码的1都是代表一个固定数值，把每一位的1代表的十进制数加起来，得到的结果就是它所代表的十进制数码。 
* B:通过8421码的方式进行二进制和十进制的相互转换
* C:二进制到八进制的简易方式
* D:二进制到十六进制的简易方式

###02.07_Java语言基础(原码反码补码)(了解)
* A:为什么要学习原码反码补码?
    * 后面要学习强制类型转换,如果不知道有原反补会看不懂结果 
* B:有符号数据表示法的几种方式
    * 原码
        * 就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。
        * 通过一个字节,也就是8个二进制位表示+7和-7
        * 0(符号位)    0000111
        * 1(符号位)    0000111
    * 反码
        * 正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
    * 补码
        * 正数的补码与其原码相同；负数的补码是在其反码的末位加1。 

###02.08_Java语言基础(原码反码补码的练习)(了解)
* A:已知原码求补码
    * 0b10110100 
* B:已知补码求原码
    * 0b11101110 
    
###02.09_Java语言基础(变量的概述及格式)(掌握)
* A:什么是变量
    * 在程序执行的过程中，在某个范围内其值可以发生改变的量
* B:变量的定义格式
    * 数据类型 变量名 = 变量值;
* C:为什么要定义变量
    * 用来不断的存放同一类型的常量，并可以重复使用 

###02.10_Java语言基础(数据类型的概述和分类)(掌握)
* A:为什么有数据类型
    * Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间
* B:Java中数据类型的分类
    * 基本数据类型
    * 引用数据类型 
        * 面向对象部分讲解 
* C:基本数据类型分类(4类8种) 
    * 整数型
        * byte 占一个字节  -128到127
        * short 占两个字  -2^15~2^15-1
        * int 占四个字节 -2^31~2^31-1
        * long 占八个字节 -2^63~2^63-1
    * 浮点型
        * float 占四个字节 -3.403E38~3.403E38  单精度
        * double 占八个字节-1.798E308~1.798E308 双精度
    * 字符型
        * char 占两个字节 0~65535
    * 布尔型
        * boolean   
            * boolean理论上是占八分之一个字节,因为一个开关就可以决定是true和false了,但是java中boolean类型没有明确指定他的大小      

###02.11_Java语言基础(定义不同数据类型的变量)(掌握)
* A:案例演示
    * 定义不同基本数据类型的变量，并输出
    * 赋值时候注意float类型,long类型

###02.12_Java语言基础(使用变量的注意事项)(掌握)
* A:案例演示
    * a:作用域问题
        * 同一个区域不能使用相同的变量名 
    * b:初始化值问题
        * 局部变量在使用之前必须赋值 
    * c:一条语句可以定义几个变量
        * int a,b,c...; 

###02.13_Java语言基础(数据类型转换之隐式转换)(掌握)
* A:案例演示
    * a:int + int
    * b:byte + int 
* B:Java中的默认转换规则
    * 取值范围小的数据类型与取值范围大的数据类型进行运算,会先将小的数据类型提升为大的,再运算 
* C:画图解释byte+int类型的问题

###02.14_Java语言基础(数据类型转换之强制转换)(掌握)
* A:强制转换问题
    * int a = 10;
    * byte b = 20; 
    * b = a + b;
* B:强制转换的格式
    * b = (byte)(a + b); 
* C:强制转换的注意事项
    * 如果超出了被赋值的数据类型的取值范围得到的结果会与你期望的结果不同 

###02.15_Java语言基础(面试题之变量相加和常量相加的区别)(掌握)
* A:案例演示
    * 面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
    * byte b1 = 3;
    * byte b2 = 4;
    * byte b3 = b1 + b2;
        * 从两方面去回答这个题
        * b1和b2是两个变量,变量里面存储的值都是变化的,所以在程序运行中JVM是无法判断里面具体的值
        * byte类型的变量在进行运算的时候,会自动类型提升为int类型 
    * byte b4 = 3 + 4;
        * 3和4都是常量,java有常量优化机制,就是在编译的的时候直接把3和4的结果赋值给b4了 
        
###02.16_Java语言基础(long与float的取值范围谁大谁小)(了解)
* 进行混合运算的时候,byte,short,char不会相互转换,都会自动类型提升为int类型,其他类型进行混合运算的是小的数据类型提升为大的
    * byte,short,char -- int -- long -- float -- double
    
    * long: 8个字节
    * float：4个字节
    * IEEE754
    * 4个字节是32个二进制位
    * 1位是符号位
    * 8位是指数位
    * 00000000   11111111
    * 0到255
    * 1到254
    * -126到127
    * 23位是尾数位
    * 每个指数位减去127
    
    * A:它们底层的存储结构不同。
    * B:float表示的数据范围比long的范围要大
        * long：2^63-1
        * float：3.4*10^38 > 2*10^38 > 2*8^38 = 2*2^3^38 = 2*2^114 > 2^63-1

###02.17_Java语言基础(字符和字符串参与运算)(掌握)
* A:案例演示
    * System.out.println('a');
    * System.out.println('a'+1);
    
    * 通过看结果知道'a'的值是多少,由此引出ASCII码表
* B:ASCII码表的概述
    * 记住三个值：
        * '0'  48
        * 'A'  65
        * 'a'  97
* C:案例演示
    * System.out.println("hello"+'a'+1);
    * System.out.println('a'+1+"hello");
* D:+在有字符串参与中被称为字符串连接符
    * System.out.println("5+5="+5+5);
    * System.out.println(5+5+"=5+5");
    
###02.18_Java语言基础(char数据类型)(掌握)
* A:char c = 97;    0到65535
* B:Java语言中的字符char可以存储一个中文汉字吗?为什么呢?
    * 可以。因为Java语言采用的是Unicode编码。Unicode编码中的每个字符占用两个字节。中文也是占的两个字节
    * 所以，Java中的字符可以存储一个中文汉字
###02.19_Java语言基础(算术运算符的基本用法)(掌握)
* A:什么是运算符
    * 就是对常量和变量进行操作的符号。
* B:运算符的分类
    * 算术运算符，赋值运算符，比较(关系或条件)运算符，逻辑运算符，位运算符，三目(元)运算符 
* C:算数运算符有哪些
    * +,-,*,/,%,++,-- 
* D:注意事项：
    * a:+号在java中有三种作用,代表正号,做加法运算,字符串的连接符
    * b:整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型
    * c:/获取的是除法操作的商，%获取的是除法操作的余数
    * %运算符
        * 当左边的绝对值小于右边绝对值时,结果是左边
        * 当左边的绝对值等于右边或是右边的倍数时,结果是0
        * 当左边的绝对值大于右边绝对值时,结果是余数
        * %运算符结果的符号只和左边有关系,与右边无关
        * 任何一个正整数%2结果不是0就是1可以用来当作切换条件 

###02.20_Java语言基础(算术运算符++和--的用法)(掌握)
* A:++,--运算符的作用
    * 自加（++）自减（--）运算
    * ++:自加。对原有的数据进行+1
    * --:自减。对原有的数据进行-1
* B:案例演示
    * a:单独使用：
        * 放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
    * b:参与运算使用：
        * 放在操作数的前面，先自增或者自减，然后再参与运算。
        * 放在操作数的后面，先参与运算，再自增或者自减。

###02.21_Java语言基础(算术运算符++和--的练习)(掌握)
* A:案例演示
    * 请分别计算出a,b,c的值?
    * 
            int a = 10;
            int b = 10;
            int c = 10;
        
            a = b++;        
            c = --a;            
            b = ++a;        
            a = c--;            
    
* B:案例演示
    * 请分别计算出x,y的值?
    
            int x = 4;
            int y = (x++)+(++x)+(x*10);
* C:面试题
    * byte b = 10;
    * b++;
    * b = b + 1;
    * 问哪句会报错,为什么 

###02.22_Java语言基础(赋值运算符的基本用法)(掌握)
* A:赋值运算符有哪些
    * a:基本的赋值运算符：=
        * 把=右边的数据赋值给左边。
        
    * b:扩展的赋值运算符：+=,-=,*=,/=,%=
        * += 把左边和右边做加法，然后赋值给左边。
    
###02.23_Java语言基础(赋值运算符的面试题)(掌握)
* A:案例演示
    * 面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
    * short s=1;s = s+1;
    * short s=1;s+=1;

###02.24_Java语言基础(关系运算符的基本用法及其注意事项)(掌握)
* A:关系运算符有哪些(比较运算符,条件运算符)
    * ==,!=,>,>=,<,<= 
* 注意事项：
    * 无论你的操作是简单还是复杂，结果是boolean类型。
    
    * "=="不能写成"="。

###02.25_day02总结
* 把今天的知识点总结一遍

###03.01_Java语言基础(逻辑运算符的基本用法)(掌握)
* A:逻辑运算符有哪些
    * &,|,^,!
    * &&,|| 
* B:案例演示
* 逻辑运算符的基本用法
    
* 注意事项：
    * a:逻辑运算符一般用于连接boolean类型的表达式或者值。
    * b:表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
        * 算术表达式：a + b
        * 比较表达式：a == b(条件表达式)
* C:结论：
* &逻辑与:有false则false。
* |逻辑或:有true则true。
* ^逻辑异或:相同为false，不同为true。
* !逻辑非:非false则true，非true则false。
    * 特点：偶数个不改变本身。

###03.02_Java语言基础(逻辑运算符&&和&的区别)(掌握)
* A:案例演示
    * &&和&的区别?
        * a:最终结果一样。
        * b:&&具有短路效果。左边是false，右边不执行。
        *     &是无论左边是false还是true,右边都会执行
* B:同理||和|的区别?(学生自学)
* C:开发中常用谁?
    * &&,||,!

###03.03_Java语言基础(位运算符的基本用法1)(了解)
* A:位运算符有哪些
    * &,|,^,~ ,>>,>>>,<<
* B:案例演示
    * 位运算符的基本用法1
    
    * &,|,^,~ 的用法
    * &:有0则0
    * |:有1则1
    * ^:相同则0，不同则1
    * ~:按位取反

###03.04_Java语言基础(位异或运算符的特点及面试题)(掌握)
* A:案例演示
    * 位异或运算符的特点

    * ^的特点：一个数据对另一个数据位异或两次，该数本身不变。
    
* B:面试题：
    * 请自己实现两个整数变量的交换
    * 注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。

###03.05_Java语言基础(位运算符的基本用法2及面试题)(了解)
* A:案例演示 >>,>>>,<<的用法:
    *  <<:左移    左边最高位丢弃，右边补齐0
    *  >>:右移    最高位是0，左边补齐0;最高为是1，左边补齐1
    *  >>>:无符号右移 无论最高位是0还是1，左边补齐0
    *  最有效率的算出2 * 8的结果

###03.06_Java语言基础(三元运算符的基本用法)(掌握)
* A:三元运算符的格式
*         (关系表达式) ? 表达式1 : 表达式2;
* B:三元运算符的执行流程 
* C:案例演示
    * 获取两个数中的最大值

###03.07_Java语言基础(三元运算符的练习)(掌握)
* A:案例演示
    * 比较两个整数是否相同
* B:案例演示
    * 获取三个整数中的最大值

###03.08_Java语言基础(键盘录入的基本格式讲解)(掌握)
* A:为什么要使用键盘录入数据
    * a:为了让程序的数据更符合开发的数据
    * b:让程序更灵活一下
* B:如何实现键盘录入呢?
    * 先照格式来。
    * a:导包
        * 格式：
            * import java.util.Scanner; 
        * 位置：
            * 在class上面。
    * b:创建键盘录入对象
        * 格式：
            * Scanner sc = new Scanner(System.in);
    * c:通过对象获取数据    
        * 格式：
            * int x = sc.nextInt();
* C:案例演示
    * 键盘录入1个整数，并输出到控制台。
    * 键盘录入2个整数，并输出到控制台。

###03.09_Java语言基础(键盘录入的练习1)(掌握)
* A:案例演示
    * 键盘录入练习：键盘录入两个数据，并对这两个数据求和，输出其结果
* B:案例演示
    * 键盘录入练习：键盘录入两个数据，获取这两个数据中的最大值

###03.10_Java语言基础(键盘录入的练习2)(掌握)
* A:案例演示
    * 键盘录入练习：键盘录入两个数据，比较这两个数据是否相等
* B:案例演示
    * 键盘录入练习：键盘录入三个数据，获取这三个数据中的最大值

###03.11_Java语言基础(顺序结构语句)(了解)
* A:什么是流程控制语句
    * 流程控制语句：可以控制程序的执行流程。
* B:流程控制语句的分类
    * 顺序结构
    * 选择结构
    * 循环结构
* C:执行流程：
    * 从上往下，依次执行。
* D:案例演示
    * 输出几句话看效果即可

###03.12_Java语言基础(选择结构if语句格式1及其使用)(掌握)
* A:选择结构的分类
    * if语句
    * switch语句
* B:if语句有几种格式
    * 格式1
    * 格式2
    * 格式3
* C:if语句的格式1
* 
        if(比较表达式) {
            语句体;
        }
* D:执行流程：
    * 先计算比较表达式的值，看其返回值是true还是false。
    * 如果是true，就执行语句体；
    * 如果是false，就不执行语句体；

###03.13_Java语言基础(选择结构if语句注意事项)(掌握)
* A:案例演示
    * a:比较表达式无论简单还是复杂，结果必须是boolean类型
    * b:if语句控制的语句体如果是一条语句，大括号可以省略；
      * 如果是多条语句，就不能省略。建议永远不要省略。
    * c:一般来说：有左大括号就没有分号，有分号就没有左大括号

###03.14_Java语言基础(选择结构if语句格式2及其使用)(掌握)
* A:if语句的格式2
* 
        if(比较表达式) {
            语句体1;
        }else {
            语句体2;
        }
* B:执行流程：
    * 首先计算比较表达式的值，看其返回值是true还是false。
    * 如果是true，就执行语句体1；
    * 如果是false，就执行语句体2；
* C:案例演示
    * a:获取两个数据中较大的值
    * b:判断一个数据是奇数还是偶数,并输出是奇数还是偶数

    * 注意事项：else后面是没有比较表达式的，只有if后面有。

###03.15_Java语言基础(if语句的格式2和三元的相互转换问题)(掌握)
* A:案例演示
    * if语句和三元运算符完成同一个效果
* B:案例演示
    * if语句和三元运算符的区别
    
    * 三元运算符实现的，都可以采用if语句实现。反之不成立。
    
    * 什么时候if语句实现不能用三元改进呢?
        * 当if语句控制的操作是一个输出语句的时候就不能。
        * 为什么呢?因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出。

###03.16_Java语言基础(选择结构if语句格式3及其使用)(掌握)
* A:if语句的格式3：
* 
        if(比较表达式1) {
            语句体1;
        }else if(比较表达式2) {
            语句体2;
        }else if(比较表达式3) {
            语句体3;
        }
        ...
        else {
            语句体n+1;
        }
* B:执行流程：
    * 首先计算比较表达式1看其返回值是true还是false，
    * 如果是true，就执行语句体1，if语句结束。
    * 如果是false，接着计算比较表达式2看其返回值是true还是false，
    
    * 如果是true，就执行语句体2，if语句结束。
    * 如果是false，接着计算比较表达式3看其返回值是true还是false，
    
    * 如果都是false，就执行语句体n+1。
* C:注意事项:最后一个else可以省略,但是建议不要省略,可以对范围外的错误值提示 

###03.17_Java语言基础(选择结构if语句格式3练习)(掌握)
* A:练习1
* 
        需求：键盘录入一个成绩，判断并输出成绩的等级。
        90-100 优
        80-89  良
        70-79  中
        60-69  及
        0-59   差
        
* B:练习2
    * 需求：
        * 键盘录入x的值，计算出y的并输出。
        
        * x>=3    y = 2 * x + 1;
        * -1         * x<=-1    y = 2 * x - 1;

###03.18_Java语言基础(选择结构if语句的嵌套使用)(掌握)
* A:案例演示
    * 需求：获取三个数据中的最大值
    * if语句的嵌套使用。

###03.19_Java语言基础(选择结构switch语句的格式及其解释)(掌握)
* A:switch语句的格式
* 
        switch(表达式) {
              case 值1：
                语句体1;
                break;
                case 值2：
                语句体2;
                break;
                …
                default：    
                语句体n+1;
                break;
        }
 
* B:switch语句的格式解释
* C:面试题
    * byte可以作为switch的表达式吗?
    * long可以作为switch的表达式吗?
    * String可以作为switch的表达式吗?
* C:执行流程
    * 先计算表达式的值
    * 然后和case后面的匹配，如果有就执行对应的语句，否则执行default控制的语句

###03.20_Java语言基础(选择结构switch语句的练习)(掌握)
* A:整数(给定一个值,输出对应星期几)

###03.21_Java语言基础(选择结构switch语句的注意事项)(掌握)
* A:案例演示
    * a:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
    * b:default可以省略吗?
        * 可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
        * 特殊情况：
            * case就可以把值固定。
            * A,B,C,D
    * c:break可以省略吗?
        * 最后一个可以省略,其他最好不要省略
        * 会出现一个现象：case穿透。
        * 最终我们建议不要省略
    * d:default一定要在最后吗?
        * 不是，可以在任意位置。但是建议在最后。
    * e:switch语句的结束条件
        * a:遇到break就结束了
        * b:执行到switch的右大括号就结束了

###03.22_Java语言基础(选择结构switch语句练习)(掌握)
* A:看程序写结果：
* 
        int x = 2;
        int y = 3;
        switch(x){
            default:
                y++;
                break;
            case 3:
                y++;
            case 4:
                y++;
        }
        System.out.println("y="+y);
    
* B:看程序写结果：
* 
        int x = 2;
        int y = 3;
        switch(x){
            default:
                y++;
            case 3:
                y++;
            case 4:
                y++;
        }
        System.out.println("y="+y);

###03.23_Java语言基础(选择结构if语句和switch语句的区别)(掌握)
* A:总结switch语句和if语句的各自使用场景
*     switch建议判断固定值的时候用
*     if建议判断区间或范围的时候用
* B:案例演示
    * 分别用switch语句和if语句实现下列需求：
        * 键盘录入月份，输出对应的季节

###03.24_day03总结
把今天的知识点总结一遍。

###04.01_Java语言基础(循环结构概述和for语句的格式及其使用)
* A:循环结构的分类
    * for,while,do...while 
* B:循环结构for语句的格式：
* 
        for(初始化表达式;条件表达式;循环后的操作表达式) {
            循环体;
        }
* C执行流程：
    * a:执行初始化语句
    * b:执行判断条件语句,看其返回值是true还是false
        * 如果是true，就继续执行
        * 如果是false，就结束循环
    * c:执行循环体语句;
    * d:执行循环后的操作表达式
    * e:回到B继续。
* D:案例演示
    * 在控制台输出10次"helloworld"
    
###04.02_Java语言基础(循环结构for语句的练习之获取数据)
* A:案例演示
    * 需求：请在控制台输出数据1-10
    * 需求：请在控制台输出数据10-1
* B:注意事项
    * a:判断条件语句无论简单还是复杂结果是boolean类型。
    * b:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。
    * c:一般来说：有左大括号就没有分号，有分号就没有左大括号

###04.03_Java语言基础(循环结构for语句的练习之求和思想)
* A:案例演示
    * 需求：求出1-10之间数据之和
* B:学生练习
    * 需求：求出1-100之间偶数和
    * 需求：求出1-100之间奇数和

###04.04_Java语言基础(循环结构for语句的练习之水仙花)
* A:案例演示
    * 需求：在控制台输出所有的”水仙花数”

    * 所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
    * 举例：153就是一个水仙花数。
    * 153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153

###04.05_Java语言基础(循环结构for语句的练习之统计思想)
* A:案例演示
    * 需求：统计”水仙花数”共有多少个

###04.06_Java语言基础(循环结构while语句的格式和基本使用)
* A:循环结构while语句的格式：
*         
        while循环的基本格式：
        while(判断条件语句) {
            循环体语句;
        }
        
        完整格式：
        
        初始化语句;
        while(判断条件语句) {
             循环体语句;
             控制条件语句;
        }
* B:执行流程：
    * a:执行初始化语句
    * b:执行判断条件语句,看其返回值是true还是false
        * 如果是true，就继续执行
        * 如果是false，就结束循环
    * c:执行循环体语句;
    * d:执行控制条件语句
    * e:回到B继续。
* C:案例演示
    * 需求：请在控制台输出数据1-10

###04.07_Java语言基础(循环结构while语句的练习)
* A:求和思想
    * 求1-100之和
* B:统计思想
    * 统计”水仙花数”共有多少个

###04.08_Java语言基础(循环结构do...while语句的格式和基本使用)
* A:循环结构do...while语句的格式：
* 
        do {
            循环体语句;
        }while(判断条件语句);
        
        完整格式；
        初始化语句;
        do {
            循环体语句;
            控制条件语句;
        }while(判断条件语句);
* B:执行流程：
    * a:执行初始化语句
    * b:执行循环体语句;
    * c:执行控制条件语句
    * d:执行判断条件语句,看其返回值是true还是false
        * 如果是true，就继续执行
        * 如果是false，就结束循环
    * e:回到b继续。
* C:案例演示
    * 需求：请在控制台输出数据1-10

###04.09_Java语言基础(循环结构三种循环语句的区别)
* A:案例演示
    * 三种循环语句的区别:
    * do...while循环至少执行一次循环体。
    * 而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
* B:案例演示
    * for循环和while循环的区别：
        * A:如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用谁就用for循环。因为变量及早的从内存中消失，可以提高内存的使用效率。
                
###04.10_Java语言基础(循环结构注意事项之死循环)
* A:一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。
* B:两种最简单的死循环格式
    * while(true){...}
    * for(;;){...}

###04.11_Java语言基础(循环结构循环嵌套输出4行5列的星星)
* A:案例演示
    * 需求：请输出一个4行5列的星星(*)图案。
    * 
            如图：
                *****
                *****
                *****
                *****
                
            注意：
                System.out.println("*");和System.out.print("*");的区别
* B:结论：
    * 外循环控制行数，内循环控制列数

###04.12_Java语言基础(循环结构循环嵌套输出正三角形)
* A:案例演示
* 
        需求：请输出下列的形状
        *
        **
        ***
        ****
        *****

###04.13_Java语言基础(循环结构九九乘法表)
* A:案例演示
    * 需求：在控制台输出九九乘法表。
* B:代码优化
* 
        注意：
        '\x' x表示任意，\是转义符号,这种做法叫转移字符。
        
        '\t'    tab键的位置
        '\r'    回车
        '\n'    换行
        '\"'
        '\''

    
###04.14_Java语言基础(控制跳转语句break语句)
* A:break的使用场景
    * 只能在switch和循环中 

###04.15_Java语言基础(控制跳转语句continue语句)
* A:continue的使用场景
    * 只能在循环中 

###04.16_Java语言基础(控制跳转语句标号)
* 标号:标记某个循环对其控制
* 标号组成规则:其实就是合法的标识符

###04.17_Java语言基础(控制调整语句练习)
* A:练习题
* 
        for(int x=1; x<=10; x++) {
            if(x%3==0) {
                //在此处填写代码
            }
            System.out.println(“Java基础班”);
        }
        
        我想在控制台输出2次:“Java基础班“
        我想在控制台输出7次:“Java基础班“
        我想在控制台输出13次:“Java基础班“    

###04.18_Java语言基础(控制跳转语句return语句)
* A:return的作用
    * 返回
    * 其实它的作用不是结束循环的，而是结束方法的。
* B:案例演示
    * return和break以及continue的区别?
    * return是结束方法
    * break是跳出循环
    * continue是终止本次循环继续下次循环

###04.19_Java语言基础(方法概述和格式说明)
* A:为什么要有方法
    * 提高代码的复用性 
* B:什么是方法
    * 完成特定功能的代码块。 
* C:方法的格式
* 
        修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
            方法体语句;
            return 返回值; 
        } 
* D:方法的格式说明
    * 修饰符：目前就用 public static。后面我们再详细的讲解其他的修饰符。
    * 返回值类型：就是功能结果的数据类型。
    * 方法名：符合命名规则即可。方便我们的调用。
    * 参数：
        * 实际参数：就是实际参与运算的。
        * 形式参数；就是方法定义上的，用于接收实际参数的。
    * 参数类型：就是参数的数据类型
    * 参数名：就是变量名
    * 方法体语句：就是完成功能的代码。
    * return：结束方法的。
    * 返回值：就是功能的结果，由return带给调用者。 

###04.20_Java语言基础(方法之求和案例及其调用)
* A:如何写一个方法
    * 1,明确返回值类型
    * 2,明确参数列表 
* B:案例演示
    * 需求：求两个数据之和的案例
* C:方法调用图解

###04.21_Java语言基础(方法的注意事项)
* A:方法调用(有具体返回值)
    * a:单独调用,一般来说没有意义，所以不推荐。
    * b:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。
    * c:赋值调用,推荐方案。
* B:案例演示
    * a:方法不调用不执行
    * b:方法与方法是平级关系，不能嵌套定义
    * c:方法定义的时候参数之间用逗号隔开
    * d:方法调用的时候不用在传递数据类型
    * e:如果方法有明确的返回值，一定要有return带回一个值

###04.22_Java语言基础(方法的练习)
* A:案例演示
    * 需求：键盘录入两个数据，返回两个数中的较大值
* B:案例演示
    * 需求：键盘录入两个数据，比较两个数是否相等     

###04.23_Java语言基础(方法之输出星形及其调用)
* A:案例演示
    * 需求：根据键盘录入的行数和列数，在控制台输出星形
* B:方法调用：(无返回值,void)
    * 单独调用
    * 输出调用(错误)
    * 赋值调用(错误)

###04.24_Java语言基础(方法的练习)
* A:案例演示
    * 需求：根据键盘录入的数据输出对应的乘法表

###04.25_Java语言基础(方法重载概述和基本使用)
* A:方法重载概述
    * 求和案例
        * 2个整数
        * 3个整数
        * 4个整数
* B:方法重载：
    * 在同一个类中，方法名相同，参数列表不同。与返回值类型无关。
    
    * 参数列表不同：
        * A:参数个数不同
        * B:参数类型不同
        * C:参数的顺序不同(算重载,但是在开发中不用)

###04.26_Java语言基础(方法重载练习比较数据是否相等)
* A:案例演示
    * 需求：比较两个数据是否相等。
    * 参数类型分别为两个int类型，两个double类型，并在main方法中进行测试

###04.27_day04总结
把今天的知识点总结一遍。

。

###05.01_Java语言基础(数组概述和定义格式说明)(了解)
* A:为什么要有数组(容器)
    * 为了存储同种数据类型的多个值
* B:数组概念
    * 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
    * 数组既可以存储基本数据类型，也可以存储引用数据类型。

* C:数组定义格式
    数据类型[] 数组名 = new 数据类型[数组的长度];
###05.02_Java语言基础(数组的初始化动态初始化)(掌握)
* A:什么是数组的初始化
    * 就是为数组开辟连续的内存空间，并为每个数组元素赋予值 
* B:如何对数组进行初始化
    * a:动态初始化 只指定长度，由系统给出初始化值
        * int[] arr = new int[5];     
    * b:静态初始化 给出初始化值，由系统决定长度    
* C:动态初始化的格式：
    * 数据类型[] 数组名 = new 数据类型[数组长度];
* D:案例演示
    * 输出数组名称和数组元素

###05.03_Java语言基础(Java中的内存分配以及栈和堆的区别)
* A:栈(掌握)
    * 存储局部变量 
* B:堆(掌握)
    * 存储new出来的数组或对象 
* C:方法区
    * 面向对象部分讲解 
* D:本地方法区
    * 和系统相关 
* E:寄存器
    * 给CPU使用
###05.04_Java语言基础(数组的内存图解1一个数组)(掌握)
* A:画图演示
    * 一个数组

###05.05_Java语言基础(数组的内存图解2二个数组)(了解)
* A:画图演示
    * 二个不同的数组

###05.06_Java语言基础(数组的内存图解3三个引用两个数组)(了解)
* A:画图演示
    * 三个引用，有两个数组的引用指向同一个地址

###05.07_Java语言基础(数组的初始化静态初始化及内存图)(掌握)
* A:静态初始化的格式：
    * 格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
    * 简化格式：
        * 数据类型[] 数组名 = {元素1,元素2,…};
* B:案例演示
    * 对数组的解释
    * 输出数组名称和数组元素
* C:画图演示
    * 一个数组

###05.08_Java语言基础(数组操作的两个常见小问题越界和空指针)(掌握)
* A:案例演示
    * a:ArrayIndexOutOfBoundsException:数组索引越界异常
        * 原因：你访问了不存在的索引。
    * b:NullPointerException:空指针异常
        * 原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。
        * int[] arr = {1,2,3};
        * arr = null;
        * System.out.println(arr[0]);

###05.09_Java语言基础(数组的操作1遍历)(掌握)
* A:案例演示
    * 数组遍历：就是依次输出数组中的每一个元素。
    * 数组的属性:arr.length数组的长度
    * 数组的最大索引:arr.length - 1;
     
            public static void print(int[] arr) {
                for (int i = 0;i < arr.length ;i++ ) {
                    System.out.print(arr[i] + " ");
                }
            }

###05.10_Java语言基础(数组的操作2获取最值)(掌握)
* A:案例演示
    * 数组获取最值(获取数组中的最大值最小值)
        
            public static int getMax(int[] arr) {
                int max = arr[0];
                for (int i = 1;i < arr.length ;i++ ) {            //从数组的第二个元素开始遍历
                    if (max < arr[i]) {                            //如果max记录的值小于的数组中的元素
                        max = arr[i];                            //max记录住较大的
                    }
                }
        
                return max;
            }
###05.11_Java语言基础(数组的操作3反转)(掌握)
* A:案例演示
    * 数组元素反转(就是把元素对调)
            
            public static void reverseArray(int[] arr) {
                for (int i = 0;i < arr.length / 2 ; i++) {
                    //arr[0]和arr[arr.length-1-0]交换
                    //arr[1]和arr[arr.length-1-1]交换
                    //arr[2]和arr[arr.lentth-1-2]
                    //...
        
                    int temp = arr[i];
                    arr[i] = arr[arr.length-1-i];
                    arr[arr.length-1-i] = temp;
                }
            }

###05.12_Java语言基础(数组的操作4查表法)(掌握)
* A:案例演示
    * 数组查表法(根据键盘录入索引,查找对应星期)
    
            public static char getWeek(int week) {
                char[] arr = {' ','一','二','三','四','五','六','日'};        //定义了一张星期表
                return arr[week];                                            //通过索引获取表中的元素
            }

###05.13_Java语言基础(数组的操作5基本查找)(掌握)
* A:案例演示
    * 数组元素查找(查找指定元素第一次在数组中出现的索引)
    
            public static int getIndex(int[] arr,int value) {
                for (int i = 0;i < arr.length ;i++ ) {                //数组的遍历
                    if (arr[i] == value) {                            //如果数组中的元素与查找的元素匹配
                        return i;
                    }
                }
                return -1;
            } 

###05.14_Java语言基础(二维数组概述和格式1的讲解)(了解)
* A:二维数组概述
* B:二维数组格式1
    * int[][] arr = new int[3][2]; 
* C:二维数组格式1的解释
* D:注意事项
    * a:以下格式也可以表示二维数组
        * 1:数据类型 数组名[][] = new 数据类型[m][n];
        * 2:数据类型[] 数组名[] = new 数据类型[m][n];
    * B:注意下面定义的区别
    * 
            int x;
            int y;
            int x,y;
            
            int[] x;
            int[] y[];
            
            int[] x,y[];    x是一维数组,y是二维数组
* E:案例演示
    * 定义二维数组，输出二维数组名称，一维数组名称，一个元素

###05.15_Java语言基础(二维数组格式1的内存图解)(了解)
* A:画图演示
    * 画图讲解上面的二维数组名称，一维数组名称，一个元素的值的问题

###05.16_Java语言基础(二维数组格式2的讲解及其内存图解)(了解)
* A:二维数组格式2
    * int[][] arr = new int[3][]; 
* B:二维数组格式2的解释
* C:案例演示
    * 讲解格式，输出数据，并画内存图

###05.17_Java语言基础(二维数组格式3的讲解及其内存图解)(了解)
* A:二维数组格式3
    * int[][] arr = {{1,2,3},{4,5},{6,7,8,9}}; 
* B:二维数组格式3的解释
* C:案例演示
    * 讲解格式，输出数据，并画内存图

###05.18_Java语言基础(二维数组练习1遍历)(掌握)
* A:案例演示
    * 需求：二维数组遍历

    * 外循环控制的是二维数组的长度，其实就是一维数组的个数。
    * 内循环控制的是一维数组的长度。

            int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
    
            for (int i = 0;i < arr.length ;i++ ) {            //获取到每个二维数组中的一维数组
                for (int j = 0;j < arr[i].length ;j++ ) {    //获取每个一维数组中的元素
                    System.out.print(arr[i][j] + " ");
                }
    
                System.out.println();
            }
###05.19_Java语言基础(二维数组练习2求和)(掌握)
* A:案例演示
* 
        需求：公司年销售额求和
        某公司按照季度和月份统计的数据如下：单位(万元)
        第一季度：22,66,44
        第二季度：77,33,88
        第三季度：25,45,65
        第四季度：11,66,99
        
        int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

        int sum = 0;                                    //定义变量,记录每次相加的结果
        for (int i = 0;i < arr.length ;i++ ) {            //获取每一个一维数组
            for (int j = 0;j < arr[i].length ;j++ ) {    //获取每一个一维数组中的元素
                sum = sum + arr[i][j];                    //累加
            }
        }

        System.out.println(sum);
###05.20_Java语言基础(思考题Java中的参数传递问题及图解)(掌握)
* A:案例演示
* 
        看程序写结果，并画内存图解释
        public static void main(String[] args) {
            int a = 10;
            int b = 20;
            System.out.println("a:"+a+",b:"+b);
            change(a,b);
            System.out.println("a:"+a+",b:"+b);
    
            int[] arr = {1,2,3,4,5};
            change(arr);
            System.out.println(arr[1]);
        }
    
        public static void change(int a,int b) {
            System.out.println("a:"+a+",b:"+b);
            a = b;
            b = a + b;
            System.out.println("a:"+a+",b:"+b);
        }
    
        public static void change(int[] arr) {
            for(int x=0; x                 if(arr[x]%2==0) {
                    arr[x]*=2;
                }
            }
        }

###05.21_day05总结
* 把今天的知识点总结一遍。

###06.01_面向对象(面向对象思想概述)(了解)
* A:面向过程思想概述
    * 第一步
    * 第二步 
* B:面向对象思想概述
    * 找对象(第一步,第二步) 
* C:举例
    * 买煎饼果子
    * 洗衣服 
* D:面向对象思想特点
    * a:是一种更符合我们思想习惯的思想
    * b:可以将复杂的事情简单化
    * c:将我们从执行者变成了指挥者
        * 角色发生了转换
* E:面向对象开发
    * 就是不断的创建对象，使用对象，指挥对象做事情。
* F:面向对象设计
    * 其实就是在管理和维护对象之间的关系。
* G:面向对象特征
    * 封装(encapsulation)
    * 继承(inheritance)
    * 多态(polymorphism)

###06.02_面向对象(类与对象概述)(掌握)
* A:我们学习编程是为了什么
    * 为了把我们日常生活中实物用学习语言描述出来
* B:我们如何描述现实世界事物
    * 属性    就是该事物的描述信息(事物身上的名词)
    * 行为    就是该事物能够做什么(事物身上的动词)
* C:Java中最基本的单位是类,Java中用class描述事物也是如此
    * 成员变量    就是事物的属性
    * 成员方法    就是事物的行为
* D:定义类其实就是定义类的成员(成员变量和成员方法)
    * a:成员变量    和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
    * b:成员方法    和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
* E:类和对象的概念
    * a:类：是一组相关的属性和行为的集合
    * b:对象：是该类事物的具体体现
    * c:举例：
        * 类     学生
        * 对象    具体的某个学生就是一个对象

###06.03_面向对象(学生类的定义)(掌握)
* A:学生事物
* B:学生类
* C:案例演示
    * 属性:姓名,年龄,性别
    * 行为:学习,睡觉

###06.04_面向对象(手机类的定义)(掌握)
* 模仿学生类，让学生自己完成
    * 属性:品牌(brand)价格(price)
    * 行为:打电话(call),发信息(sendMessage)玩游戏(playGame)

###06.05_面向对象(学生类的使用)(掌握)
* A:文件名问题
    * 在一个java文件中写两个类：一个基本的类，一个测试类。
    * 建议：文件名称和测试类名称一致。
* B:如何使用对象?
    * 创建对象并使用
    * 格式：类名 对象名 = new 类名();
* D:如何使用成员变量呢?
    * 对象名.变量名
* E:如何使用成员方法呢?
    * 对象名.方法名(...)

###06.06_面向对象(手机类的使用)(掌握)
* A:学生自己完成
    * 模仿学生类，让学生自己完成
    
###06.07_面向对象(一个对象的内存图)(掌握)
* A:画图演示
    * 一个对象

###06.08_面向对象(二个对象的内存图)(了解)
* A:画图演示
    * 二个不同的对象

###06.09_面向对象(三个引用两个对象的内存图)(了解)
* A:画图演示
    * 三个引用，有两个对象的引用指向同一个地址

###06.10_面向对象(成员变量和局部变量的区别)(掌握)
* A:在类中的位置不同
    * 成员变量：在类中方法外
    * 局部变量：在方法定义中或者方法声明上
* B:在内存中的位置不同
    * 成员变量：在堆内存(成员变量属于对象,对象进堆内存)
    * 局部变量：在栈内存(局部变量属于方法,方法进栈内存)
* C:生命周期不同
    * 成员变量：随着对象的创建而存在，随着对象的消失而消失
    * 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
* D:初始化值不同
    * 成员变量：有默认初始化值
    * 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
    
* 注意事项：
    * 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
    * 基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char
    * 引用数据类型变量包括哪些:数组,类,接口,枚举
    
###06.11_面向对象(方法的形式参数是类名的时候如何调用)(掌握)
* A:方法的参数是类名public void print(Student s){}//print(new Student());
    * 如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。

###06.12_面向对象(匿名对象的概述和应用)(掌握)
* A:什么是匿名对象
    * 没有名字的对象 
* B:匿名对象应用场景
    * a:调用方法，仅仅只调用一次的时候。
        * 那么，这种匿名调用有什么好处吗?
            * 节省代码 
        * 注意：调用多次的时候，不适合。匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
    * b:匿名对象可以作为实际参数传递
* C:案例演示
    * 匿名对象应用场景

###06.13_面向对象(封装的概述)(掌握)
* A:封装概述
    * 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

* B:封装好处
    * 隐藏实现细节，提供公共的访问方式
    * 提高了代码的复用性
    * 提高安全性。
* C:封装原则
    * 将不需要对外提供的内容都隐藏起来。
    * 把属性隐藏，提供公共方法对其访问。

###06.14_面向对象(private关键字的概述和特点)(掌握)
* A:人类赋值年龄的问题
* B:private关键字特点
    * a:是一个权限修饰符
    * b:可以修饰成员变量和成员方法
    * c:被其修饰的成员只能在本类中被访问
* C:案例演示
    * 封装和private的应用：
    * A:把成员变量用private修饰
    * B:提供对应的getXxx()和setXxx()方法
    * private仅仅是封装的一种体现形式,不能说封装就是私有

###06.15_面向对象(this关键字的概述和应用)(掌握)
* A:this关键字特点
    * 代表当前对象的引用 
* B:案例演示
    * this的应用场景
    * 用来区分成员变量和局部变量重名

###06.16_面向对象(手机类代码及其测试)(掌握)
* A:学生练习
    * 请把手机类写成一个标准类，然后创建对象测试功能。
     
            class Demo2_Phone {
                public static void main(String[] args) {
                    Phone p1 = new Phone();
                    p1.setBrand("三星");
                    p1.setPrice(5288);
            
                    System.out.println(p1.getBrand() + "..." + p1.getPrice());
                    p1.call();
                    p1.sendMessage();
                    p1.playGame();
                }
            }
            /*
            手机类
                属性:品牌brand,价格price
                行为:打电话call,发短信sendMessage,玩游戏,playGame
            */
            class Phone {                                //java bean
                private String brand;                    //品牌
                private int price;                        //价格
            
                public void setBrand(String brand) {    //设置品牌
                    this.brand = brand;
                }
            
                public String getBrand() {                //获取品牌
                    return this.brand;                    //this.可以省略,你不加系统会默认给你加
                }
            
                public void setPrice(int price) {        //设置价格
                    this.price = price;
                }
            
                public int getPrice() {                    //获取价格
                    return price;
                }
            
                public void call() {                    //打电话
                    System.out.println("打电话");
                }
            
                public void sendMessage() {                //发短信
                    System.out.println("发短信");
                }
            
                public void playGame() {                //玩游戏
                    System.out.println("玩游戏");
                }
            }
###06.17_day06总结
* 把今天的知识点总结一遍。

###07.01_面向对象(构造方法Constructor概述和格式)(掌握)
* A:构造方法概述和作用
    * 给对象的数据(属性)进行初始化
* B:构造方法格式特点
    * a:方法名与类名相同(大小也要与类名一致)
    * b:没有返回值类型，连void都没有
    * c:没有具体的返回值return;

###07.02_面向对象(构造方法的重载及注意事项)(掌握)
* A:案例演示
    * 构造方法的重载
    * 重载:方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表
* B:构造方法注意事项
    * a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
    * b:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
        * 注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
        
###07.03_面向对象(给成员变量赋值的两种方式的区别)
* A:setXxx()方法
    * 修改属性值 
* B:构造方法
    * 给对象中属性进行初始化 

###07.04_面向对象(学生类的代码及测试)(掌握)
* A:案例演示
    * 学生类：
        * 成员变量：
            * name，age
        * 构造方法：
            * 无参，带两个参
        * 成员方法：
            * getXxx()/setXxx()
            * show()：输出该类的所有成员变量值
* B:给成员变量赋值：
    * a:setXxx()方法
    * b:构造方法
    
* C:输出成员变量值的方式：
    * a:通过getXxx()分别获取然后拼接
    * b:通过调用show()方法搞定

###07.05_面向对象(手机类的代码及测试)(掌握)
* A:案例演示
    * 模仿学生类，完成手机类代码

###07.06_面向对象(创建一个对象的步骤)(掌握)
* A:画图演示
    * 画图说明一个对象的创建过程做了哪些事情?
    * Student s = new Student();
    * 1,Student.class加载进内存
    * 2,声明一个Student类型引用s
    * 3,在堆内存创建对象,
    * 4,给对象中属性默认初始化值
    * 5,属性进行显示初始化
    * 6,构造方法进栈,对对象中的属性赋值,构造方法弹栈
    * 7,将对象的地址值赋值给s

###07.07_面向对象(长方形案例练习)(掌握)
* A:案例演示
    * 需求：
        * 定义一个长方形类,定义 求周长和面积的方法，
        * 然后定义一个测试类进行测试。

###07.08_面向对象(员工类案例练习)(掌握)
* A:案例演示
    * 需求：定义一个员工类Employee
    * 自己分析出几个成员，然后给出成员变量
        * 姓名name,工号id,工资salary 
    * 构造方法，
        * 空参和有参的
    * getXxx()setXxx()方法，
    * 以及一个显示所有成员信息的方法。并测试。
        * work 

###07.09_面向对象(static关键字及内存图)(了解)
* A:案例演示
    * 通过一个案例引入static关键字。
    * 人类：Person。每个人都有国籍，中国。

* B:画图演示
    * 带有static的内存图
 
###07.10_面向对象(static关键字的特点)(掌握)
* A:static关键字的特点
    * a:随着类的加载而加载
    * b:优先于对象存在
    * c:被类的所有对象共享
        * 举例：咱们班级的学生应该共用同一个班级编号。
        * 其实这个特点也是在告诉我们什么时候使用静态?
            * 如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
        * 举例：
            * 饮水机(用静态修饰)
            * 水杯(不能用静态修饰)
            * 共性用静态,特性用非静态
    * d:可以通过类名调用
        * 其实它本身也可以通过对象名调用。
        * 推荐使用类名调用。
        * 静态修饰的内容一般我们称其为：与类相关的，类成员
* B:案例演示
    * static关键字的特点

###07.11_面向对象(static的注意事项)(掌握)
* A:static的注意事项
    * a:在静态方法中是没有this关键字的
        * 如何理解呢?
            * 静态是随着类的加载而加载，this是随着对象的创建而存在。
            * 静态比对象先存在。
    * b:静态方法只能访问静态的成员变量和静态的成员方法
        * 静态方法：
            * 成员变量：只能访问静态变量
            * 成员方法：只能访问静态成员方法
        * 非静态方法：
            * 成员变量：可以是静态的，也可以是非静态的
            * 成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
        * 简单记：
            * 静态只能访问静态。
* B:案例演示
    * static的注意事项

###07.12_面向对象(静态变量和成员变量的区别)(掌握)
* 静态变量也叫类变量  成员变量也叫对象变量
* A:所属不同
    * 静态变量属于类，所以也称为为类变量
    * 成员变量属于对象，所以也称为实例变量(对象变量)
* B:内存中位置不同
    * 静态变量存储于方法区的静态区
    * 成员变量存储于堆内存
* C:内存出现时间不同
    * 静态变量随着类的加载而加载，随着类的消失而消失
    * 成员变量随着对象的创建而存在，随着对象的消失而消失
* D:调用不同
    * 静态变量可以通过类名调用，也可以通过对象调用
    * 成员变量只能通过对 象名调用

###07.13_面向对象(main方法的格式详细解释)(了解)
* A:格式
    * public static void main(String[] args) {}
* B:针对格式的解释
    * public 被jvm调用，访问权限足够大。
    * static 被jvm调用，不用创建对象，直接类名访问
    * void被jvm调用，不需要给jvm返回值
    * main 一个通用的名称，虽然不是关键字，但是被jvm识别
    * String[] args 以前用于接收键盘录入的
* C:演示案例
    * 通过args接收键盘例如数据

###07.14_面向对象(工具类中使用静态)(了解)
* A:制作一个工具类
    * ArrayTool
    * 1,获取最大值
    * 2,数组的遍历
    * 3,数组的反转
    

###07.15_面向对象(说明书的制作过程)(了解)
* A:对工具类加入文档注释
* B:通过javadoc命令生成说明书
    * @author(提取作者内容)
    * @version(提取版本内容)
    * javadoc -d 指定的文件目录 -author -version ArrayTool.java
    * @param 参数名称//形式参数的变量名称@return 函数运行完返回的数据

###07.16_面向对象(如何使用JDK提供的帮助文档)(了解)
* A:找到文档，打开文档
* B:点击显示，找到索引，出现输入框
* C:你应该知道你找谁?举例：Scanner
* D:看这个类的结构(需不需要导包)
    * 成员变量    字段
    * 构造方法    构造方法
    * 成员方法    方法

###07.17_面向对象(学习Math类的随机数功能)(了解)
* 打开JDK提供的帮助文档学习
* A:Math类概述
    * 类包含用于执行基本数学运算的方法
* B:Math类特点
    * 由于Math类在java.lang包下，所以不需要导包。
    * 因为它的成员全部是静态的,所以私有了构造方法
* C:获取随机数的方法
    * public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
* D:我要获取一个1-100之间的随机数，肿么办?
    * int number = (int)(Math.random()*100)+1;
    
###07.18_面向对象(猜数字小游戏案例)(了解)
* A:案例演示
    * 需求：猜数字小游戏(数据在1-100之间)

###07.19_day07总结
把今天的知识点总结一遍。

###08.01_面向对象(代码块的概述和分类)(了解)(面试的时候会问,开发不用或者很少用)
* A:代码块概述
    * 在Java中，使用{}括起来的代码被称为代码块。
* B:代码块分类
    * 根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。
* C:常见代码块的应用
    * a:局部代码块 
        * 在方法中出现；限定变量生命周期，及早释放，提高内存利用率
    * b:构造代码块 (初始化块)
        * 在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
    * c:静态代码块 
        * 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。
        * 一般用于加载驱动

###08.02_面向对象(代码块的面试题)(掌握)
* A:看程序写结果
* 
        class Student {
            static {
                System.out.println("Student 静态代码块");
            }
            
            {
                System.out.println("Student 构造代码块");
            }
            
            public Student() {
                System.out.println("Student 构造方法");
            }
        }
    
        class Demo2_Student {
            static {
                System.out.println("Demo2_Student静态代码块");
            }
            
            public static void main(String[] args) {
                System.out.println("我是main方法");
                
                Student s1 = new Student();
                Student s2 = new Student();
            }
        }

###08.03_面向对象(继承案例演示)(掌握)
* A:继承(extends)
    * 让类与类之间产生关系,子父类关系 
* B:继承案例演示：
    * 动物类,猫类,狗类
    * 定义两个属性(颜色,腿的个数)两个功能(吃饭，睡觉)
* C:案例演示
    * 使用继承前
* D:案例演示
    * 使用继承后

###08.04_面向对象(继承的好处和弊端)(掌握)
* A:继承的好处
    * a:提高了代码的复用性
    * b:提高了代码的维护性
    * c:让类与类之间产生了关系，是多态的前提
* B:继承的弊端
    * 类的耦合性增强了。
    
    * 开发的原则：高内聚，低耦合。
    * 耦合：类与类的关系
    * 内聚：就是自己完成某件事情的能力

###08.05_面向对象(Java中类的继承特点)(掌握)
* A:Java中类的继承特点
    * a:Java只支持单继承，不支持多继承。(一个儿子只能有一个爹)
        * 有些语言是支持多继承，格式：extends 类1,类2,...
    * b:Java支持多层继承(继承体系)
* B:案例演示
    * Java中类的继承特点
        * 如果想用这个体系的所有功能用最底层的类创建对象
        * 如果想看这个体系的共性功能,看最顶层的类 

###08.06_面向对象(继承的注意事项和什么时候使用继承)(掌握)
* A:继承的注意事项
    * a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
    * b:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
    * c:不要为了部分功能而去继承
    * 项目经理 姓名 工号 工资 奖金
    * 程序员    姓名 工号 工资
* B:什么时候使用继承
    * 继承其实体现的是一种关系："is a"。
        Person
            Student
            Teacher
        水果
            苹果
            香蕉
            橘子
            
    采用假设法。
        如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。

###08.07_面向对象(继承中成员变量的关系)(掌握)
* A:案例演示
    * a:不同名的变量
    * b:同名的变量
###08.08_面向对象(this和super的区别和应用)(掌握)
* A:this和super都代表什么
    * this:代表当前对象的引用,谁来调用我,我就代表谁
    * super:代表当前对象父类的引用
* B:this和super的使用区别
    * a:调用成员变量
        * this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
        * super.成员变量 调用父类的成员变量
    * b:调用构造方法
        * this(...)    调用本类的构造方法
        * super(...)    调用父类的构造方法
    * c:调用成员方法
        * this.成员方法 调用本类的成员方法,也可以调用父类的方法
        * super.成员方法 调用父类的成员方法
        

###08.09_面向对象(继承中构造方法的关系)(掌握)
* A:案例演示
    * 子类中所有的构造方法默认都会访问父类中空参数的构造方法
* B:为什么呢?
    * 因为子类会继承父类中的数据，可能还会使用父类的数据。
    * 所以，子类初始化之前，一定要先完成父类数据的初始化。
    
    * 其实：
        * 每一个构造方法的第一条语句默认都是：super() Object类最顶层的父类。

###08.10_面向对象(继承中构造方法的注意事项)(掌握)
* A:案例演示
    * 父类没有无参构造方法,子类怎么办?
    * super解决
    * this解决
* B:注意事项
    * super(…)或者this(….)必须出现在构造方法的第一条语句上

###08.11_面向对象(继承中的面试题)(掌握)

* A:案例演示
*         
        看程序写结果1
        class Fu{
            public int num = 10;
            public Fu(){
                System.out.println("fu");
            }
        }
        class Zi extends Fu{
            public int num = 20;
            public Zi(){
                System.out.println("zi");
            }
            public void show(){
                int num = 30;
                System.out.println(num);
                System.out.println(this.num);
                System.out.println(super.num);
            }
        }
        class Test1_Extends {
            public static void main(String[] args) {
                Zi z = new Zi();
                z.show();
            }
        }

        看程序写结果2
        class Fu {
            static {
                System.out.println("静态代码块Fu");
            }
    
            {
                System.out.println("构造代码块Fu");
            }
    
            public Fu() {
                System.out.println("构造方法Fu");
            }
        }
    
        class Zi extends Fu {
            static {
                System.out.println("静态代码块Zi");
            }
    
            {
                System.out.println("构造代码块Zi");
            }
    
            public Zi() {
                System.out.println("构造方法Zi");
            }
        }
    
        Zi z = new Zi(); 请执行结果。

###08.12_面向对象(继承中成员方法关系)(掌握)
* A:案例演示
    * a:不同名的方法
    * b:同名的方法

###08.13_面向对象(方法重写概述及其应用)(掌握)
* A:什么是方法重写
    * 重写:子父类出现了一模一样的方法(注意:返回值类型可以是子父类,这个我们学完面向对象讲) 
* B:方法重写的应用：
    * 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。
* C:案例演示
    * a:定义一个手机类。

###08.14_面向对象(方法重写的注意事项)(掌握)
* A:方法重写注意事项
    * a:父类中私有方法不能被重写
        * 因为父类私有方法子类根本就无法继承
    * b:子类重写父类方法时，访问权限不能更低
        * 最好就一致
    * c:父类静态方法，子类也必须通过静态方法进行重写
        * 其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解(静态只能覆盖静态)
        
    * 子类重写父类方法的时候，最好声明一模一样。
* B:案例演示
    * 方法重写注意事项

###08.15_面向对象(方法重写的面试题)(掌握)
* A:方法重写的面试题
    * Override和Overload的区别?Overload能改变返回值类型吗?
    * overload可以改变返回值类型,只看参数列表
    * 方法重写：子类中出现了和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的
    
    * 方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值类型无关。

    * 子类对象调用方法的时候：
        * 先找子类本身，再找父类。

###08.16_面向对象(使用继承前的学生和老师案例)(掌握)
* A:案例演示
    * 使用继承前的学生和老师案例
    * 属性:姓名,年龄
    * 行为:吃饭
    * 老师有特有的方法:讲课
    * 学生有特有的方法:学习

###08.17_面向对象(使用继承后的学生和老师案例)(掌握)
* A:案例演示
    * 使用继承后的学生和老师案例

###08.18_面向对象(猫狗案例分析,实现及测试)(掌握)
* A:猫狗案例分析
* B:案例演示
    * 猫狗案例继承版
    * 属性:毛的颜色,腿的个数
    * 行为:吃饭
    * 猫特有行为:抓老鼠catchMouse
    * 狗特有行为:看家lookHome

###08.19_面向对象(final关键字修饰类,方法以及变量的特点)(掌握)
* A:final概述
* B:final修饰特点
    * 修饰类，类不能被继承
    * 修饰变量，变量就变成了常量，只能被赋值一次
    * 修饰方法，方法不能被重写
* C:案例演示
    * final修饰特点

###08.20_面向对象(final关键字修饰局部变量)(掌握)
* A:案例演示
    * 方法内部或者方法声明上都演示一下(了解)

    * 基本类型，是值不能被改变
    * 引用类型，是地址值不能被改变,对象中的属性可以改变

###08.21_面向对象(final修饰变量的初始化时机)(掌握)
* A:final修饰变量的初始化时机
    * 显示初始化 
    * 在对象构造完毕前即可
    
###08.22_day08总结
* 把今天的知识点总结一遍。

###10.01_面向对象(package关键字的概述及作用)(了解)
* A:为什么要有包
    * 将字节码(.class)进行分类存放 
    * 包其实就是文件夹
* B:包的概述
* 
    举例：
        学生：增加，删除，修改，查询
        老师：增加，删除，修改，查询
        ...
        
        方案1：按照功能分
            com.heima.add
                AddStudent
                AddTeacher
            com.heima.delete
                DeleteStudent
                DeleteTeacher
            com.heima.update
                UpdateStudent
                UpdateTeacher
            com.heima.find
                FindStudent
                FindTeacher
        
        方案2：按照模块分
            com.heima.teacher
                AddTeacher
                DeleteTeacher
                UpdateTeacher
                FindTeacher
            com.heima.student
                AddStudent
                DeleteStudent
                UpdateStudent
                FindStudent
###10.02_面向对象(包的定义及注意事项)(掌握)
* A:定义包的格式
    * package 包名;
    * 多级包用.分开即可
* B:定义包的注意事项
    * A:package语句必须是程序的第一条可执行的代码
    * B:package语句在一个java文件中只能有一个
    * C:如果没有package，默认表示无包名
* C:案例演示
    * 包的定义及注意事项
    
###10.03_面向对象(带包的类编译和运行)(掌握)
* A:如何编译运行带包的类
    * a:javac编译的时候带上-d即可
        * javac -d . HelloWorld.java
    * b:通过java命令执行。
        * java 包名.HellWord
###10.04_面向对象(不同包下类之间的访问)(掌握)
* A:案例演示
    * 不同包下类之间的访问

###10.05_面向对象(import关键字的概述和使用)(掌握)
* A:案例演示
    * 为什么要有import
        * 其实就是让有包的类对调用者可见,不用写全类名了 
* B:导包格式
    * import 包名;
    * 注意：
    * 这种方式导入是到类的名称。
    * 虽然可以最后写*，但是不建议。
* C:package,import,class有没有顺序关系(面试题)

###10.06_面向对象(四种权限修饰符的测试)(掌握)
* A:案例演示
    * 四种权限修饰符
* B:结论
* 
                    本类     同一个包下(子类和无关类)    不同包下(子类)    不同包下(无关类)
        private     Y        
        默认            Y        Y
        protected    Y        Y                            Y
        public        Y        Y                            Y                Y

###10.07_面向对象(类及其组成所使用的常见修饰符)(掌握)
* A:修饰符：
    * 权限修饰符：private，默认的，protected，public
    * 状态修饰符：static，final
    * 抽象修饰符：abstract
* B:类：
    * 权限修饰符：默认修饰符，public
    * 状态修饰符：final
    * 抽象修饰符：abstract
    
    * 用的最多的就是：public
    
* C:成员变量：
    * 权限修饰符：private，默认的，protected，public
    * 状态修饰符：static，final
    
    * 用的最多的就是：private
    
* D:构造方法：
    * 权限修饰符：private，默认的，protected，public
    
    * 用的最多的就是：public
    
* E:成员方法：
    * 权限修饰符：private，默认的，protected，public
    * 状态修饰符：static，final
    * 抽象修饰符：abstract
    
    * 用的最多的就是：public
    
* F:除此以外的组合规则：
    * 成员变量：public static final
    * 成员方法：
        * public static 
        * public abstract
        * public final

###10.08_面向对象(内部类概述和访问特点)(了解)
* A:内部类概述
* B:内部类访问特点
    * a:内部类可以直接访问外部类的成员，包括私有。
    * b:外部类要访问内部类的成员，必须创建对象。
    * 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
* C:案例演示
    * 内部类极其访问特点
    
###10.09_面向对象(成员内部类私有使用)(了解)
* private

###10.10_面向对象(静态成员内部类)(了解)
* static
* B:成员内部类被静态修饰后的访问方式是:
    * 外部类名.内部类名 对象名 = 外部类名.内部类对象;

###10.11_面向对象(成员内部类的面试题)(掌握)
* A:面试题
* 
        要求：使用已知的变量，在控制台输出30，20，10。
        
        class Outer {
            public int num = 10;
            class Inner {
                public int num = 20;
                public void show() {
                    int num = 30;
                    System.out.println(?);
                    System.out.println(??);
                    System.out.println(???);
                }
            }
        }
        class InnerClassTest {
            public static void main(String[] args) {
                Outer.Inner oi = new Outer().new Inner();
                oi.show();
            }    
        }

###10.12_面向对象(局部内部类访问局部变量的问题)(掌握)
* A:案例演示
    * 局部内部类访问局部变量必须用final修饰
    * 局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
        因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用

        但是jdk1.8取消了这个事情,所以我认为这是个bug

###10.13_面向对象(匿名内部类的格式和理解)
* A:匿名内部类
    * 就是内部类的简化写法。
* B:前提：存在一个类或者接口
    * 这里的类可以是具体类也可以是抽象类。
* C:格式：
* 
        new 类名或者接口名(){
            重写方法;
        }
* D:本质是什么呢?
    * 是一个继承了该类或者实现了该接口的子类匿名对象。
* E:案例演示
    * 按照要求来一个匿名内部类
        
###10.14_面向对象(匿名内部类重写多个方法调用)
* A:案例演示
    * 匿名内部类的方法调用

###10.15_面向对象(匿名内部类在开发中的应用)

* A:代码如下
* 
        //这里写抽象类，接口都行
        abstract class Person {
            public abstract void show();
        }
    
        class PersonDemo {
            public void method(Person p) {
                p.show();
            }
        }
    
        class PersonTest {
            public static void main(String[] args) {
                //如何调用PersonDemo中的method方法呢?
                PersonDemo pd = new PersonDemo ();
                
            }
        }

###10.16_面向对象(匿名内部类的面试题)
* A:面试题
* 
        按照要求，补齐代码
        interface Inter { void show(); }
        class Outer { //补齐代码 }
        class OuterDemo {
            public static void main(String[] args) {
                  Outer.method().show();
              }
        }
        要求在控制台输出”HelloWorld”

###10.17_day10总结
* 把今天的知识点总结一遍。

###11.01_Java开发工具(常见开发工具介绍)(了解)
* A:操作系统自带的记事本软件
* B:高级记事本软件
* C:集成开发环境 IDE
    * (Integrated Development Environment)
* D:Eclipse和MyEclipse的区别
    * a:Eclipse是一种可扩展的开放源代码的IDE。
    * b:Eclipse的特点描述
        * 免费
        * 纯Java语言编写
        * 免安装
        * 扩展性强
    * c:MyEclipse
        * 在Eclipse基础上追加的功能性插件，对插件收费
        * 在WEB开发中提供强大的系统架构平台
* E:下载 http://eclipse.org/
    * org是非盈利团体 
* F:安装
    * 绿色版    解压就可以使用(Eclipse)
    * 安装版   双击运行,一路next即可(JDK)
* G:卸载
    * 绿色版    直接删除文件夹即可
    * 安装版 专业卸载软件或者控制面板添加删除程序

###11.02_Java开发工具(Eclipse中HelloWorld案例以及汉化)(了解)
* A:选择工作空间
    * 工作空间  其实就是我们写的源代码所在的目录
* B:用Eclipse来完成一个HelloWorld案例
    * 代码以项目为基本单位
    * 创建项目
    * 创建包
    * 创建类
    * 编写代码
* C:编译和运行
* D:Eclipse的汉化
    * 从Eclipse3.5开始，安装目录下就多了一个dropins目录,只要将插件解压后放到到该目录即可。
    * 同理，这种方式卸载插件也是特别的方便，推荐这种方式
* E:语法检查提示
    * 红色波浪线
        * 必须处理,否则编译通不过
    * 黄色波浪线    
        * 可以不搭理他 

###11.03_Java开发工具(Eclipse的视窗和视图概述)(了解)
* A:视窗  每一个基本的窗体被称为视窗
    * PackageExplorer  显示项目结构，包，类，及资源
    * Outline   显示类的结构，方便查找，识别，修改
    * Console  程序运行的结果在该窗口显示
    * Hierarchy 显示Java继承层次结构，选中类后F4
* B:视图  是由某些视窗的组合而成的
    * Java视图
    * Debug视图

###11.04_Java开发工具(Eclipse工作空间的基本配置)(掌握)
* A:程序的编译和运行的环境配置(一般不改)
    * window -- Preferences -- Java
    * 编译环境：Compiler    默认选中的就是最高版本。
    * 运行环境：Installed JREs    默认会找你安装的那个JDK。建议配置了Java的环境变量。
    * 问题：
        * 低编译，高运行。可以。
        * 高编译，低运行。不可以。
        * 建议，编译和运行的版本一致。
* B:如何去掉默认注释?
    * window -- Preferences -- Java -- Code Style -- Code Templates
    * 选择你不想要的内容，通过右边Edit编辑。
    * 注意：请只删除注释部分，不是注释部分的不要删除。
* C:行号的显示和隐藏
    * 显示：在代码区域的最左边的空白区域，右键 -- Show Line Numbers即可。
    * 隐藏：把上面的动作再做一次。
* D:字体大小及颜色
    * a:Java代码区域的字体大小和颜色：
        * window -- Preferences -- General -- Appearance -- Colors And Fonts --Java修改 -- Java Edit Text Font
    * b:控制台
        * window -- Preferences -- General -- Appearance -- Colors And Fonts -- Debug -- Console font
    * c:其他文件
        * window -- Preferences -- General -- Appearance -- Colors And Fonts -- Basic -- Text Font
* E:窗体给弄乱了，怎么办?
    * window -- Reset Perspective
* F:控制台找不到了，怎么办?
    * Window--Show View—Console
* G:取消悬浮提示
    * window -- Preferences -- Java--Editor--Hovers。右边将Combined Hover勾去掉。
    * 这样代码的悬浮框就不会自动出现了。如果想看提示，将光标悬浮在代码上，按F2即可。
 
###11.05_Java开发工具(Eclipse中内容辅助键的使用)(掌握)
* A:Alt+/ 起提示作用
* B:main+alt+/,syso+alt+/,给出其他提示
* C:补充输出语句,选中需要输出的部分,alt+/选择最后一项即可
* C:定义自己的alt + /
    * windows--perference-Java-Editor-Templates--New

###11.06_Java开发工具(Eclipse中快捷键的使用)(掌握)
* A:新建 ctrl + n
* B:格式化  ctrl+shift+f
* C:导入包  ctrl+shift+o 
* D:注释  ctrl+/,ctrl+shift+/,ctrl+shift+\
* E:代码上下移动 选中代码alt+上/下箭头
* F:查看源码  选中类名(F3或者Ctrl+鼠标点击)
* G:查找具体的类 ctrl + shift + t
* H:查找具体类的具体方法 ctrl + o
* I:给建议 ctrl+1,根据右边生成左边的数据类型,生成方法
* J:删除代码 ctrl + d
* K:抽取方法alt + shift + m 
* L:改名alt + shift + r 
* 

###11.07_Java开发工具(Eclipse中如何提高开发效率)(掌握)
* alt + shift + s
* A:自动生成构造方法
* B:自动生成get/set方法

###11.08_Java开发工具(Eclipse中一个标准学生类及其测试)(掌握)
* A:案例演示
    * 用Eclipse实现标准学生类及其测试

###11.09_Java开发工具(Eclipse中接口抽象类具体类代码体现)(掌握)
* A:案例演示
    * 用Eclipse实现接口抽象类具体类代码

###11.10_Java开发工具(Eclipse中如何生成jar包并导入到项目中)(了解)
* A:jar是什么?
    * jar是多个class文件的压缩包。
* B:jar有什么用?
    * 用别人写好的东西    
* C:打jar包
    * 选中项目--右键--Export--Java--Jar--自己指定一个路径和一个名称--Finish
* D:导入jar包
    * 复制到项目路径下并添加至构建路径。

###11.11_Java开发工具(Eclipse中如何删除项目和导入项目)(掌握)
* A:删除项目
    * 选中项目 – 右键 – 删除
        * 从项目区域中删除
        * 从硬盘上删除
* B:导入项目
    * 在项目区域右键找到import
    * 找到General，展开，并找到
    * Existing Projects into Workspace
    * 点击next,然后选择你要导入的项目
    * 注意：这里选择的是项目名称

###11.12_Java开发工具(Eclipse中断点调试的基本使用)(了解)
* A:Debug的作用
    * 调试程序
    * 查看程序执行流程
* B:如何查看程序执行流程        
    * 什么是断点：
        * 就是一个标记，从哪里开始。
        
    * 如何设置断点：
        * 你想看哪里的程序，你就在那个有效程序的左边双击即可。
        
    * 在哪里设置断点：
        * 哪里不会点哪里。
        * 目前：我们就在每个方法的第一条有效语句上都加。
        
    * 如何运行设置断点后的程序：
        * 右键 -- Debug as -- Java Application
        
    * 看哪些地方：
        * Debug：断点测试的地方
            * 在这个地方，记住F6，或者点击也可以。一次看一行的执行过程。
        * Variables：查看程序的变量变化
        * ForDemo：被查看的源文件
        * Console：控制台
        
    * 如何去断点：
        * a:再次双击即可
        * b:找到Debug视图，Variables界面，找到Breakpoints，并点击，然后看到所有的断点，最后点击那个双叉。

###11.13_Java开发工具(Eclipse查看Java中参数传递问题)(了解)
* A:断点演示
    * 断点查看Java中参数传递问题

###11.14_常见对象(API概述)(了解)
* A:API(Application Programming Interface) 
    * 应用程序编程接口
* B:Java API
    * 就是Java提供给我们使用的类，这些类将底层的实现封装了起来，
    * 我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。

###11.15_常见对象(Object类的概述)(了解)
* A:Object类概述
    * 类层次结构的根类
    * 所有类都直接或者间接的继承自该类
* B:构造方法
    * public Object()
    * 回想面向对象中为什么说：
    * 子类的构造方法默认访问的是父类的无参构造方法

###11.16_常见对象(Object类的hashCode()方法)(了解)
* A:案例演示
    * public int hashCode()
    * a:返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
    * b:不同对象的，hashCode()一般来说不会相同。但是，同一个对象的hashCode()值肯定相同。

###11.17_常见对象(Object类的getClass()方法)(在反射的时候掌握)
* A:案例演示
    * public final Class getClass()
    * a:返回此 Object 的运行时类。
    * b:可以通过Class类中的一个方法，获取对象的真实类的全名称。    
        * public String getName()

###11.18_常见对象(Object类的toString()方法)(掌握)
* A:案例演示
    * public String toString()
    * a:返回该对象的字符串表示。
* 
        
        public Stirng toString() {
            return name + "," + age;
        }
    * b:它的值等于： 
        * getClass().getName() + "@" + Integer.toHexString(hashCode()) 
    * c:由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。
* B:最终版
    * 自动生成

###11.19_常见对象(Object类的equals()方法)(掌握)
* A:案例演示
    * a:指示其他某个对象是否与此对象“相等”。 
    * b:默认情况下比较的是对象的引用是否相同。
    * c:由于比较对象的引用没有意义，一般建议重写该方法。

###11.20_常见对象(==号和equals方法的区别)(掌握)
* ==是一个比较运算符号,既可以比较基本数据类型,也可以比较引用数据类型,基本数据类型比较的是值,引用数据类型比较的是地址值
* equals方法是一个方法,只能比较引用数据类型,所有的对象都会继承Object类中的方法,如果没有重写Object类中的equals方法,equals方法和==号比较引用数据类型无区别,重写后的equals方法比较的是对象中的属性

###11.21_day11总结
* 把今天的知识点总结一遍。

。