JAVA笔记1-9

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 老虎 2004-09-30
  • JAVASE 5.1 (1.5.1) Dragonfly 蜻蜓
  • JAVASE 6.0 (1.6.0) Mustang 野马 2006-04
  • JAVASE 7.0 (1.7.0) Dolphin 海豚 2011-07-28
  • JAVASE 8.0 (1.8.0) Spider 蜘蛛 2014-03-18
  • Java SE9 2017-09-21
  • Java SE10 2018-03-14
• 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
      或者 图形界面切换到上述目录 shift+鼠标右键 在此处打开命令窗口

  • 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

• 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总结

• 把今天的知识点总结一遍。

第二章 Java基础语法

02.01_Java语言基础(注释概述及其分类)(掌握)

• A:什么是注释

• B:注释的分类及讲解

  • 文档注释目前不讲，说后面讲解
  • 不知妻美刘强东、普通家庭马化腾、悔创阿里杰克马、北大还行撒贝宁；一无所有王健林、下周回国贾跃亭、名下无房潘石屹、顺便赚钱丁三石、顺丰不快王卫兄

• 注释的作用

  • A:解释说明程序
  • B:帮助我们调试错误

02.02_Java语言基础(关键字的概述和使用)(掌握)

• A:什么是关键字
  • 被Java语言赋予特定含义的单词
• B:关键字的特点
  • 组成关键字的字母全部小写
• C:常见关键字
  • public static void class等
• D:关键字的注意事项
  • goto和const作为保留字存在,目前并不使用,类似Editplus这样的高级记事本,针对关键字有特殊的颜色标记，非常直观

02.03_Java语言基础(标识符的概述和组成规则)(掌握)

• A:什么是标识符
  • 就是给类,接口,方法,变量等起名字时使用的字符序列
• B:标识符的组成规则
  • 英文大小写字母
  • 数字字符
  • $和_
• C:标识符注意事项
  • 不能使用关键字
  • 不能数字开头
  • 区分大小写

02.04_Java语言基础(标识符中常见的命名规则)(了解)

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

02.05_Java语言基础(常量的概述和使用)(掌握)

• A:什么是常量

  • 在程序执行的过程中其值不可以发生改变

• B:Java中常量的分类

  • 字面值常量
  • 自定义常量(面向对象部分讲)

• C:字面值常量的分类

  • 字符串常量 用双引号括起来的内容 String str=“helloworld”;
  • 整数常量 所有整数 int类型 int a = 10;
  • 小数常量 所有小数 double 2.3 12.0
  • 字符常量 用单引号括起来的内容,里面只能放单个数字,单个字母或单个符号
  • 布尔常量 较为特殊，只有true和false
  • 空常量 null(数组部分讲解)

• D:案例演示

  • 用输出语句输出各种常量。null不演示

02.06_Java语言基础(进制概述和二,八,十六进制图解)(了解)

• A:什么是进制scale
  • 进制：就是进位制，是人们规定的一种进位方法。 对于任何一种进制--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:任意进制到十进制的转换原理conversion
  • 系数：就是每一位上的数据。
  • 基数：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:为什么要学习原码反码补码?code
  • 后面要学习强制类型转换,如果不知道有原反补会看不懂结果
• B:有符号数据表示法的几种方式
  • 原码
    • 就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。
    • 通过一个字节,也就是8个二进制位表示+7和-7【byte】
    • 0(符号位) 0000111
    • 1(符号位) 0000111
  • 反码
    • 正数的反码与其原码相同；
    • 负数的反码是对其原码逐位取反，但符号位除外。
    • -7: 反码： 1 1111000
  • 补码
    • 正数的补码与其原码相同；
    • 负数的补码是在其反码的末位加1。
    • -7 补码: 1 1111001
• C:计算机运算时都是以补码方式进行。

02.08_Java语言基础(原码反码补码的练习)(了解)

• A:已知原码求补码(先取反获得反码，再+1得到补码)
  • 0b10110100 反码: 0b11001011 补码: 0b11001100
• B:已知补码求原码(逆操作，先-1得到反码，再取反获得源码)
  • 0b11101110 反码: 0b11101101 源码:0b100010010 -18
• C:求 -15(byte)的补码
  • 15: 8 + 4 + 2 + 1: 0b0000 1111
  • -15 原码: 0b1000 1111

  • 反码: 0b1111 0000
    

  • 补码: 0b1111 0001 
    

02.09_Java语言基础(变量的概述及格式)(掌握)

• A:什么是变量variable
  • 在程序执行的过程中，在某个范围内其值可以发生改变的量
• B:变量的定义格式
  • 数据类型 变量名 = 变量值;
• C:为什么要定义变量
  • 用来不断的存放同一类型的常量，并可以重复使用

02.10_Java语言基础(数据类型的概述和分类)(掌握)

• A:为什么有数据类型datatype
  • Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间
• B:Java中数据类型的分类
  • 基本数据类型
  • 引用数据类型
    • 面向对象部分讲解
• C:基本数据类型分类(4类8种)
  • 整数型
    • byte 占一个字节 -128到127
    • short 占两个字 -2^15~215-1
    • int 占四个字节 -2^31~231-1
    • long 占八个字节 -2^63~263-1
  • 浮点型
    • float 占四个字节 -3.403E38~3.403E38 单精度 注意：float表示范围比long更大
    • 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:案例演示conversion
  • 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(代表0)到255(无穷大)

  • 1到254 【整体-127】

  • -126到127

  • 23位是尾数位

  • A:它们底层的存储结构不同。

  • B:float表示的数据范围比long的范围要大

    • long：2^63-1
    • float：3.410^38 > 210^38 > 28^38 = 22³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
  • char c1 = 2;
  • char c2 = 3;
  • char c3 = 4;
• B:Java语言中的字符char可以存储一个中文汉字吗?为什么呢?
  • 可以。因为Java语言采用的是Unicode编码。Unicode编码中的每个字符占用两个字节。中文也是占的两个字节
  • 所以，Java中的字符可以存储一个中文汉字

第三章 运算符

03.01_Java语言基础(算术运算符的基本用法)(掌握)

• A:什么是运算符
  • 就是对常量和变量进行操作的符号。
• B:运算符的分类
  • 算术运算符，赋值运算符，比较(关系或条件)运算符，逻辑运算符，位运算符，三目(元)运算符
• C:算数运算符有哪些 算术math
  • +,-,*,/,%,++,--
• D:注意事项：
  • a:+号在java中有三种作用,代表正号,做加法运算,字符串的连接符
  • b:整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型
  • c:/获取的是除法操作的商，%获取的是除法操作的余数
  • %运算符
    • 当左边的绝对值小于右边绝对值时,结果是左边
    • 当左边的绝对值等于右边或是右边的倍数时,结果是0
    • 当左边的绝对值大于右边绝对值时,结果是余数
    • %运算符结果的符号只和左边有关系,与右边无关
    • 任何一个正整数%2结果不是0就是1可以用来当作切换条件

03.02_Java语言基础(算术运算符++和--的用法)(掌握)

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

03.03_Java语言基础(算术运算符++和--的练习)(掌握)

• A:案例演示 自增increment

  • 请分别计算出a,b,c的值?

  •   int a = 10;
      int b = 10;
      int c = 10;
    
      a = b++;    //a: b: 
      c = --a;        //a:  c:
      b = ++a;    //a: b: 
      a = c--;        //a:  c:
    

• B:案例演示

  • 请分别计算出x,y的值?

      int x = 4;
      int y = (x++)+(++x)+(x*10);
    

• C:面试题

  • byte b = 10;
  • b++;
  • b = b + 1;
  • 问哪句会报错,为什么？

03.04_Java语言基础(赋值运算符的基本用法)(掌握)

• A:赋值运算符有哪些 赋值assign

  • a:基本的赋值运算符：=

    • 把=右边的数据赋值给左边。
    • =左边必须是变量。

  • b:扩展的赋值运算符：+=,-=,*=,/=,%=

    • += 把左边和右边做加法，然后赋值给左边。

03.05_Java语言基础(赋值运算符的面试题)(掌握)

• A:案例演示
  • 面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
  • short s=1;s = s+1;
  • short s=1;s += 1;

03.06_Java语言基础(关系运算符的基本用法及其注意事项)(掌握)

• A:关系运算符有哪些(比较运算符,条件运算符) 关系relation
  • ==,!=,>,>=,<,<=
• 注意事项：

  • 无论你的操作是简单还是复杂，结果是boolean类型。

  • "=="不能写成"="。

03.07_Java语言基础(逻辑运算符的基本用法)(掌握)

• A:逻辑运算符有哪些

  • &,|,^,!
  • &&,||

• B:案例演示 逻辑 logic

• 逻辑运算符的基本用法

• 身高不够，拿钱来凑

• 注意事项：

  • a:逻辑运算符一般用于连接boolean类型的表达式或者值。
  • b:表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
    • 算术表达式：a + b
    • 比较表达式：a == b(条件表达式)

• C:结论：

• &逻辑与:有false则false。

• |逻辑或:有true则true。

• ^逻辑异或:相同为false，不同为true。

• !逻辑非:非false则true，非true则false。

  • 特点：偶数个不改变本身。

03.08_Java语言基础(逻辑运算符&&和&的区别)(掌握)

• A:案例演示
  • &&和&的区别?
    • a:最终结果一样。
    • b:&&具有短路效果。左边是false，右边不执行。
    • &是无论左边是false还是true,右边都会执行
    • int x = 3;int y = 4;
    • syso((++x == 3) & (y++ == 4));
• B:同理||和|的区别?(学生自学)
• C:开发中常用谁?
  • &&,||,!

03.09_Java语言基础(位运算符的基本用法1)(了解)

• A:位运算符有哪些 位bit
  • &,|,^,~ ,>>,>>>,<<
• B:案例演示 异或xor

  • 位运算符的基本用法1

  • &,|,^,~ 的用法

  • &:有0则0

  • |:有1则1

  • ^:相同则0，不同则1

  • ~:按位取反

03.10_Java语言基础(位异或运算符的特点及面试题)(掌握)

• A:案例演示

  • 位异或运算符的特点

  • ^的特点：一个数据对另一个数据位异或两次，该数本身不变。

• B:面试题：

  • 请自己实现两个整数变量的交换
  • 注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。

03.11_Java语言基础(位运算符的基本用法2及面试题)(了解)

• A:案例演示 >>,>>>,<<的用法 移位shift
  • <<:左移 左边最高位丢弃，右边补齐0(向左移动几位就是乘以2的几次幂)

  • :右移 最高位是0，左边补齐0;最高为是1，左边补齐1(向右移动几位就是除以2的几次幂)
    * >>>:无符号右移 无论最高位是0还是1，左边补齐0
    * 最有效率的算出2 * 8的结果(移位直接操作二进制数)

03.12_Java语言基础(三元运算符的基本用法)(掌握)

• A:三元运算符的格式 三元ternary

•   (关系表达式) ? 表达式1 : 表达式2;
  

• B:三元运算符的执行流程
• C:案例演示
  • 获取两个数中的最大值

03.13_Java语言基础(三元运算符的练习)(掌握)

• A:案例演示
  • 比较两个整数是否相同
• B:案例演示
  • 获取三个整数中的最大值

03.14_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.15_Java语言基础(键盘录入的练习1)(掌握)

• A:案例演示
  • 键盘录入练习：键盘录入两个数据，并对这两个数据求和，输出其结果
• B:案例演示
  • 键盘录入练习：键盘录入两个数据，获取这两个数据中的最大值

03.16_Java语言基础(键盘录入的练习2)(掌握)

• A:案例演示
  • 键盘录入练习：键盘录入两个数据，比较这两个数据是否相等
• B:案例演示
  • 键盘录入练习：键盘录入三个数据，获取这三个数据中的最大值

第四章 循环控制语句

04.01_Java语言基础(顺序结构语句)(了解)

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

04.02_Java语言基础(选择结构if语句格式1及其使用)(掌握)

• A:选择结构的分类
  • if语句
  • switch语句
• B:if语句有几种格式
  • 格式1
  • 格式2
  • 格式3
• C:if语句的格式1

•   if(比较表达式) {
        语句体;
    }
  

• D:执行流程：
  • 先计算比较表达式的值，看其返回值是true还是false。
  • 如果是true，就执行语句体；
  • 如果是false，就不执行语句体；

04.03_Java语言基础(选择结构if语句注意事项)(掌握)

• A:案例演示
  • a:比较表达式无论简单还是复杂，结果必须是boolean类型
  • b:if语句控制的语句体如果是一条语句，大括号可以省略；
    • 如果是多条语句，就不能省略。建议永远不要省略。
  • c:一般来说：有左大括号就没有分号，有分号就没有左大括号

04.04_Java语言基础(选择结构if语句格式2及其使用)(掌握)

• A:if语句的格式2

•   if(比较表达式) {
        语句体1;
    }else {
        语句体2;
    }
  

• B:执行流程：
  • 首先计算比较表达式的值，看其返回值是true还是false。
  • 如果是true，就执行语句体1；
  • 如果是false，就执行语句体2；
• C:案例演示

  • a:获取两个数据中较大的值

  • b:判断一个数据是奇数还是偶数,并输出是奇数还是偶数

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

04.05_Java语言基础(if语句的格式2和三元的相互转换问题)(掌握)

• A:案例演示
  • if语句和三元运算符完成同一个效果
• B:案例演示

  • if语句和三元运算符的区别

  • 三元运算符实现的，都可以采用if语句实现。反之不成立。

  • 什么时候if语句实现不能用三元改进呢?

    • 当if语句控制的操作是一个输出语句的时候就不能。
    • 为什么呢?因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出。

04.06_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可以省略,但是建议不要省略,可以对范围外的错误值提示

04.07_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;

04.08_Java语言基础(选择结构if语句的嵌套使用)(掌握)

• A:案例演示
  • 需求：获取三个数据中的最大值
  • if语句的嵌套使用。

04.09_Java语言基础(选择结构switch语句的格式及其解释)(掌握)

• A:switch语句的格式

•   switch(表达式) {       //基本数据类型可以接收byte char short int,String
          case 值1：      //引用数据类型可以接收枚举 (JDK1.5)  String字符串(JDK1.7)
            语句体1;
            break;
          case 值2：
            语句体2;
            break;
            …
          default：  
            语句体n+1;
            break;
    }
  

• B:switch语句的格式解释

• C:面试题

  • byte可以作为switch的表达式吗?
  • long可以作为switch的表达式吗?
  • String可以作为switch的表达式吗?

• C:执行流程

  • 先计算表达式的值
  • 然后和case后面的匹配，如果有就执行对应的语句，否则执行default控制的语句

04.10_Java语言基础(选择结构switch语句的练习)(掌握)

• A:整数(给定一个值,输出对应星期几)

04.11_Java语言基础(选择结构switch语句的注意事项)(掌握)

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

04.12_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);
  

04.13_Java语言基础(选择结构if语句和switch语句的区别)(掌握)

• A:总结switch语句和if语句的各自使用场景
• switch建议判断固定值的时候用
• if建议判断区间或范围的时候用
• B:案例演示
  • 分别用switch语句和if语句实现下列需求：
    • 键盘录入月份，输出对应的季节

04.14_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.15_Java语言基础(循环结构for语句的练习之获取数据)

• A:案例演示
  • 需求：请在控制台输出数据1-10
  • 需求：请在控制台输出数据10-1
• B:注意事项
  • a:判断条件语句无论简单还是复杂结果是boolean类型。
  • b:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。
  • c:一般来说：有左大括号就没有分号，有分号就没有左大括号

04.16_Java语言基础(循环结构for语句的练习之求和思想)

• A:案例演示
  • 需求：求出1-10之间数据之和
• B:学生练习
  • 需求：求出1-100之间偶数和
  • 需求：求出1-100之间奇数和

04.17_Java语言基础(循环结构for语句的练习之水仙花)

• A:案例演示 Demo_Flower.java

  • 需求：在控制台输出所有的”水仙花数”

  • 所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。

  • 举例：153就是一个水仙花数。

  • 153 = 111 + 555 + 333 = 1 + 125 + 27 = 153

04.18_Java语言基础(循环结构for语句的练习之统计思想)

• A:案例演示
  • 需求：统计”水仙花数”共有多少个

04.19_Java语言基础(循环结构while语句的格式和基本使用)

• A:循环结构while语句的格式：

•   while循环的基本格式：
    while(判断条件语句) {
        循环体语句;
    }
    
    完整格式：
    
    初始化语句;
    while(判断条件语句) {
         循环体语句;
         控制条件语句;
    }
  

• B:执行流程：
  • a:执行初始化语句
  • b:执行判断条件语句,看其返回值是true还是false
    • 如果是true，就继续执行
    • 如果是false，就结束循环
  • c:执行循环体语句;
  • d:执行控制条件语句
  • e:回到B继续。
• C:案例演示
  • 需求：请在控制台输出数据1-10

04.20_Java语言基础(循环结构while语句的练习)

• A:求和思想
  • 求1-100之和
• B:统计思想
  • 统计”水仙花数”共有多少个

04.21_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.22_Java语言基础(循环结构三种循环语句的区别)

• A:案例演示
  • 三种循环语句的区别:
  • do...while循环至少执行一次循环体。
  • 而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
• B:案例演示
  • for循环和while循环的区别：
    • A:如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用谁就用for循环，因为变量及早的从内存中消失，可以提高内存的使用效率。

04.23_Java语言基础(循环结构注意事项之死循环)

• A:一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。
• B:两种最简单的死循环格式
  • while(true){...}
  • for(;;){...}

04.24_Java语言基础(循环结构循环嵌套输出4行5列的星星)

• A:案例演示
  • 需求：请输出一个4行5列的星星(*)图案。

  •   如图：
          *****
          *****
          *****
          *****
          
      注意：
          System.out.println("*");和System.out.print("*");的区别
    

• B:结论：
  • 外循环控制行数，内循环控制列数

04.25_Java语言基础(循环结构循环嵌套输出正三角形)

• A:案例演示

•   需求：请输出下列的形状
    *
    **
    ***
    ****
    *****
  

04.26_Java语言基础(循环结构九九乘法表)

• A:案例演示
  • 需求：在控制台输出九九乘法表。
  • 1*1=1
  • 12=2 22=4
  • 13=3 23=6 3*3=9
  • ...
  • 19=9 29=19 ... 9*9=81
• B:代码优化

•   注意：
    '\x' x表示任意，\是转义符号,这种做法叫转移字符。
    
    '\t'    tab键的位置  '''
    '\r'    回车
    '\n'    换行   '\r\n'
    '\"'
    '\''
  

04.27_Java语言基础(控制跳转语句break语句)

• A:break的使用场景
  • 只能在switch和循环中

04.28_Java语言基础(控制跳转语句continue语句)

• A:continue的使用场景
  • 只能在循环中

04.29_Java语言基础(控制跳转语句标号)

• 标号:标记某个循环对其控制
• 标号组成规则:其实就是合法的标识符

04.30_Java语言基础(控制调整语句练习)

• A:练习题

•   for(int x=1; x<=10; x++) {
        if(x%3==0) {
            //在此处填写代码
            //break;  2
            //continue;  7
            System.out.println(“Java基础班”);
        }
        System.out.println(“Java基础班”);
    }
    
    我想在控制台输出2次:“Java基础班“
    我想在控制台输出7次:“Java基础班“
    我想在控制台输出13次:“Java基础班“   
  

04.31_Java语言基础(控制跳转语句return语句)

• A:return的作用
  • 返回
  • 其实它的作用不是结束循环的，而是结束方法的。
• B:案例演示
  • return和break以及continue的区别?
  • return是结束方法
  • break是跳出循环
  • continue是终止本次循环继续下次循环

补充内容 方法

00.01_Java语言基础(方法概述和格式说明)

• A:为什么要有方法
  • 提高代码的复用性
• B:什么是方法
  • 完成特定功能的代码块。
• C:方法的格式

•   修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
        方法体语句;
        return 返回值; 
    } 
  

• D:方法的格式说明
  • 修饰符：目前就用 public static。后面我们再详细的讲解其他的修饰符。
  • 返回值类型：就是功能结果的数据类型。
  • 方法名：符合命名规则即可。方便我们的调用。
  • 参数：
    • 实际参数：就是实际参与运算的。
    • 形式参数；就是方法定义上的，用于接收实际参数的。
  • 参数类型：就是参数的数据类型
  • 参数名：就是变量名
  • 方法体语句：就是完成功能的代码
  • return：结束方法的
  • 返回值：就是功能的结果，由return带给调用者

00.02_Java语言基础(方法之求和案例及其调用)

• A:如何写一个方法
  • 1,明确返回值类型
  • 2,明确参数列表
• B:案例演示
  • 需求：求两个数据之和的案例
• C:方法调用图解

00.03_Java语言基础(方法的注意事项)

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

00.04_Java语言基础(方法的练习)

• A:案例演示
  • 需求：键盘录入两个数据，返回两个数中的较大值
• B:案例演示
  • 需求：键盘录入两个数据，比较两个数是否相等

00.05_Java语言基础(方法之输出星形及其调用)

• A:案例演示
  • 需求：根据键盘录入的行数和列数，在控制台输出星形
• B:方法调用：(无返回值,void)
  • 单独调用
  • 输出调用(错误)
  • 赋值调用(错误)

00.06_Java语言基础(方法的练习)

• A:案例演示
  • 需求：根据键盘录入的数据输出对应的乘法表

00.07_Java语言基础(方法重载概述和基本使用)

• A:方法重载概述
  • 求和案例
    • 2个整数
    • 3个整数
    • 4个整数
• B:方法重载：

  • 在同一个类中，方法名相同，参数列表不同。与返回值类型无关。

  • 参数列表不同：

    • A:参数个数不同
    • B:参数类型不同
    • C:参数的顺序不同(算重载,但是在开发中不用)

00.08_Java语言基础(方法重载练习比较数据是否相等)

• A:案例演示
  • 需求：比较两个数据是否相等。
  • 参数类型分别为两个int类型，两个double类型，并在main方法中进行测试

第五章 数组

05.01_Java语言基础(数组概述和定义格式说明)(了解)

• A:为什么要有数组(容器)

  • 为了存储同种数据类型的多个值

• B:数组概念

  • 数组是存储同一种数据类型多个元素的集合，也可以看成是一个容器。
  • 数组既可以存储基本数据类型，也可以存储引用数据类型。

• C:数组定义格式
  数据类型[] 数组名 = new 数据类型[数组的长度];

05.02_Java语言基础(数组的初始化动态初始化)(掌握)

• A:什么是数组的初始化
  • 就是为数组开辟连续的内存空间，并为每个数组元素赋予值
• B:如何对数组进行初始化
  • a:动态初始化 只指定长度，由系统给出初始化值
    • int[] arr = new int[5];
  • b:静态初始化 给出初始化值，由系统决定长度
    • int[] arr = new int[]{3,2,1,4,6};
    • int[] arr = {4,6,3,1};
• 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语言基础(数组的操作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.13_排序与查找

* 冒泡排序
    * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
    * 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
    * 针对所有的元素重复以上的步骤，除了最后一个。
    * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
    
* 二分查找【有序序列】

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

第六章 类和对象

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:学生练习

  • 请把手机类写成一个标准类，然后创建对象测试功能。

  • 手机类 Phone

  • 属性: 品牌brand 价格price

  • 动作: 打电话call 发短信sendMessage

      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("玩游戏");
          }
      }
    

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:案例演示Rectangle
  • 需求：
    • 定义一个长方形类,定义 求周长和面积的方法，
    • 然后定义一个测试类进行测试。

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,插入排序
  • 4,选择排序

07.15_面向对象(说明书的制作过程)(了解)

• A:对工具类加入文档注释
• B:通过javadoc命令生成说明书
  • @author(提取作者内容)
  • @version(提取版本内容)
  • javadoc -d 指定的文件目录 -author -version ArrayTool.java
  • @param 参数名称//形式参数的变量名称
  • @return 函数运行完返回的数据【void不需要】

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。[0.0,1.0)
• D:我要获取一个1-100之间的随机数，肿么办?
  • int number = (int)(Math.random()*100)+1;

07.18_面向对象(猜数字小游戏案例)(了解)

• A:案例演示
  • 需求：猜数字小游戏(数据在1-100之间)
  • 程序运行起来，自动生成一个1-100的随机数，然后期待用户从键盘上输入一个整形数，
  • 进行比较，如果偏大或偏小，则给你提示，让你再次输入，一直猜到正确的数字，循环结束。

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();
        }
    }
    
    "Demo2_Student静态代码块"
    "我是main方法"
    "Student 静态代码块"
    "Student 构造代码块"
    "Student 构造方法"
    "Student 构造代码块"
    "Student 构造方法"
  

08.03_面向对象(继承案例演示)(掌握)

• A:继承(extends)
  • 让类与类之间产生关系,子父类关系
• B:继承案例演示：
  • 动物类,猫类,狗类
  • 定义两个属性(颜色,腿的个数)两个功能(吃饭，睡觉)
• C:案例演示
  • 使用继承前
• D:案例演示
  • 使用继承后
• E:继承格式
  • class 子类名 extends 父类名 { 属性； 方法；}

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.成员】

  • this:代表当前对象的引用,谁来调用我,我就代表谁
  • super:代表当前对象父类部分的引用

• B:this和super的使用区别

  • a:调用成员变量
    • this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
    • super.成员变量 调用父类的成员变量
  • b:调用构造方法
    • this(...) 调用本类的构造方法
    • super(...) 调用父类的构造方法
  • c:调用成员方法
    • this.成员方法 调用本类的成员方法,也可以调用父类的方法
    • super.成员方法 调用父类的成员方法

• C: this() super()必须在代码段的第一行； 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.15.02_重写规则

• 方法的重写规则

  • 参数列表必须完全与被重写方法的相同；
  • 返回类型必须完全与被重写方法的返回类型相同；
  • 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
  • 父类的成员方法只能被它的子类重写。
  • 声明为final的方法不能被重写。
  • 声明为static的方法不能被重写，但是能够被再次声明。
  • 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
  • 子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
  • 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
  • 构造方法不能被重写。
  • 如果不能继承一个方法，则不能重写这个方法。

  总结

  方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

  (1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
  (2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
  (3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

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修饰变量的初始化时机
  • 显示初始化
  • 在对象构造完毕前即可

---

09.01_面向对象(多态的概述及其代码体现)

• A:多态(polymorphic)概述
  • 事物存在的多种形态
  • 编译时多态【重载】，运行时多态
• B:多态前提
  • a:要有继承关系。
  • b:要有方法重写。
  • c:要有父类引用指向子类对象。
• C:案例演示
  • 代码体现多态

09.02_面向对象(多态中的成员访问特点之成员变量)

• 成员变量
  • 父类引用.成员变量
  • 编译看左边(父类)，运行看左边(父类)。

09.03_面向对象(多态中的成员访问特点之成员方法)

• 成员方法
  • 编译看左边(父类)，运行看右边(子类)。
  • 编译时 观察 左边对象所属类中有没有对应的方法，如果没有，编译出错！
  • 运行时 观察 左边对象引用 指向 哪个对象，如果执行子对象，则调用子类中方法。

09.04_面向对象(多态中的成员访问特点之静态成员方法)

• 静态方法
  • 编译看左边(父类)，运行看左边(父类)。
  • (静态和类相关，算不上重写，所以，访问还是左边的)
  • 只有非静态的成员方法,编译看左边,运行看右边

09.05_面向对象(超人的故事)

• A:案例分析
  • 通过该案例帮助学生理解多态的现象

09.06_面向对象(多态中向上转型和向下转型)

• A:案例演示

  • 详细讲解多态中向上转型和向下转型
    Person p = new SuperMan();向上转型
    SuperMan sm = (SuperMan)p;向下转型

  引用名 instanceof 类名

09.07_面向对象(多态的好处和弊端)

• A:多态的好处
  • a:提高了代码的维护性(继承保证)
  • b:提高了代码的扩展性(由多态保证，传参父类引用)
• B:案例演示
  • 多态的好处
  • 可以当作形式参数,可以接收任意子类对象
• C:多态的弊端
  • 不能使用子类的特有属性和行为。
  • 解决方案: 向下转型 之后去调用。
• D:案例演示
  method(Animal a)
  method(Cat c)

09.08_面向对象(多态中的题目分析题)

• A:看下面程序是否有问题，如果没有，说出结果

•   class Fu {
        public void show() {
            System.out.println("fu show");
        }
    }
  
    class Zi extends Fu {
        public void show() {
            System.out.println("zi show");
        }
  
        public void method() {
            System.out.println("zi method");
        }
    }
  
    class Test1Demo {
        public static void main(String[] args) {
            Fu f = new Zi();
            f.method();
            f.show();
        }
    }
  

• B:看下面程序是否有问题，如果没有，说出结果

•   class A {
        public void show() {
            show2();
        }
        public void show2() {
            System.out.println("我");
        }
    }
    class B extends A {
        public void show() {
            show2();
        }
        public void show2() {
            System.out.println("爱");
        }
    }
    class C extends B {
        public void show() {
            super.show();
        }
        public void show2() {
            System.out.println("你");
        }
    }
    public class Test2DuoTai {
        public static void main(String[] args) {
            A a = new B();
            a.show();   //爱
            
            B b = new C();
            b.show();
        }
    }
  

09.09_面向对象(抽象类的概述及其特点)

• A:抽象类概述
  • 抽象就是看不懂的，不确定的意思；
  • 就是用abstract修饰的类
• B:抽象类特点
  • a:抽象类和抽象方法必须用abstract关键字修饰
    • abstract class 类名 {}
    • public abstract void eat();
  • b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
  • c:抽象类不能实例化，那么抽象类如何实例化呢?
    • 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
  • d:抽象类的子类
    • 要么是抽象类【没有完成重写抽象方法】
    • 正常类 重写抽象类中的所有抽象方法
• C:案例演示
  • 抽象类特点

09.10_面向对象(抽象类的成员特点)

• A:抽象类的成员特点
  • a:成员变量：既可以是变量，也可以是常量。abstract是否可以修饰成员变量?不能修饰成员变量
  • b:构造方法：有。
    • 用于子类访问父类数据的初始化。
  • c:成员方法：既可以是抽象的，也可以是非抽象的。
• B:案例演示
  • 抽象类的成员特点
• C:抽象类的成员方法特性：
  • a:抽象方法 强制要求子类做的事情。
  • b:非抽象方法 子类继承的事情，提高代码复用性。

09.11_面向对象(葵花宝典)

• 案例演示
  • 抽象类的作用

09.12_面向对象(抽象类练习猫狗案例)

• A:案例演示
  • 具体事物：猫，狗
  • 共性：姓名，年龄，吃饭
  • 猫的特性:抓老鼠
  • 狗的特性:看家

09.13_面向对象(抽象类练习老师案例)

• A:案例演示
  • 具体事物：基础班老师，就业班老师
  • 共性：姓名，年龄，讲课。
  • 具体事物:基础班学生,就业班学生
  • 共性:姓名,年龄,学习

09.14_面向对象(抽象类练习员工案例)

• A:案例演示
  • 假如我们在开发一个系统时需要对程序员类进行设计，程序员包含3个属性：姓名、工号以及工资。
  • 经理，除了含有程序员的属性外，另为还有一个奖金属性。
  • 请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问。

09.15_面向对象(抽象类中的面试题)

• A:面试题1
  • 一个抽象类如果没有抽象方法，可不可以定义为抽象类? 如果可以，有什么意义?
  • 可以
  • 这么做目的只有一个,就是不让创建本类对象,交给子类完成。
• B:面试题2
  • abstract不能和哪些关键字共存
  • 修饰方法，不能和哪些修饰符一起使用
  • static private final

09.16_面向对象(接口的概述及其特点)

• A:接口概述
  • 从狭义的角度讲就是指java中的interface
  • 从广义的角度讲对外提供规则的都是接口
  • 接口是Java单继承的补充
• B:接口特点
  • a:接口用关键字interface表示
    • interface 接口名 {}
  • b:类实现接口用implements表示
    • class 类名 implements 接口1，接口2... {}
  • c:接口不能实例化
    • 那么，接口如何实例化呢?
    • 按照多态的方式来实例化。
  • d:接口的子类
    • a:可以是抽象类。但是意义不大。
    • b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
• C:案例演示
  • 接口特点

09.17_面向对象(接口的成员特点)

• A:接口成员特点
  • 成员变量；只能是常量，并且是静态的并公共的。
    * 默认修饰符：public static final
    * 建议：自己手动给出。
  • 构造方法：接口没有构造方法。
  • 成员方法：只能是抽象方法。
    * 默认修饰符：public abstract
    * 建议：自己手动给出。
• B:案例演示
  • 接口成员特点

09.18_面向对象(类与类,类与接口,接口与接口的关系)

• A:类与类,类与接口,接口与接口的关系
  • a:类与类：
    • 继承关系,只能单继承,可以多层继承。
  • b:类与接口：
    • 实现关系,可以单实现,也可以多实现。
    • 并且还可以在继承一个类的同时实现多个接口。
  • c:接口与接口：
    • 继承关系,可以单继承,也可以多继承。
• B:案例演示
  • 类与类,类与接口,接口与接口的关系

09.19_面向对象(抽象类和接口的区别)

• A:成员区别

  • 抽象类：
    • 成员变量：可以变量，也可以常量
    • 构造方法：有
    • 成员方法：可以抽象，也可以非抽象
  • 接口：
    • 成员变量：只可以公有静态常量
    • 成员方法：只可以抽象

• B:关系区别

  • 类与类
    • 继承，单继承
  • 类与接口
    • 实现，单实现，多实现
  • 接口与接口
    • 继承，单继承，多继承

• C:设计理念区别

  • 抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
  • 接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

09.20_面向对象(猫狗案例加入跳高功能分析及其代码实现)

• A:案例演示
  • 动物类：姓名，年龄，吃饭，睡觉。
  • 猫和狗
  • 动物培训接口：跳高