前八章总结

java基础语法
关键字：49种关键字，其中goto和const是关键字中的保留字
保留字：true、false、null

数据类型
基础数据类型（8个）：数值型
整形：
byte（1字节）
short（2字节）
int（4字节）
long（8字节）
扩展：2进制、10进制、16进制如何相互转换
char（字符型 2字节）、boolean （布尔类型）
浮点型：float（4字节） double（8字节）
引用数据类型：接口、类、数组

标识符
标识符由字母、下划线、美元符号或者数字组成，标识符应以字母、下划线、美元符号开头，Java标识符大小写敏感，长度无限制。

作用范围: 类的类名、方法的方法名、方法的参数、方法的返回、变量、常量
基本数据类型变量：
定义：数据类型、变量名 使用：int number
String引用类型变量：
定义：引用类型 变量名 = new 引用类型（）；使用string str（）
运算符
增量和减量运算符
扩展赋值运算符
移位运算符： << （数*2^n） >>（数*2^-n） >>>（无符号右移）
比较运算符
三目运算符

表达式：
计算表达式
比较表达式
赋值表达式
布尔表达式
特别注意：++ – 参不参与表达式的区别

Java的注释

单行注释 //
代码的描述
代码的注释
多行注释 /* 注释内容 */
代码的描述
代码的注释
文本注释 /* 注释内容 /
类的描述
属性的描述
方法的描述

软件概述

计算机的发展历程：

40-50 年代，第一代计算机出现，主要用国家/政府进行科学计算，此时计算机的特点：体积庞大，大量的使用电子管，造价高昂，运算能力较差，功耗高，并且可靠性比较低

50-60年代，第二代计算机出现，此时计算机已经能处理一些简单的文字，图片，此时计算机的特点：体积大大缩小，大量的使用晶体管代替电子管，造价缩小，运算能力已经也有了较大幅度的提升，功耗降低，可靠性得到了一定程度的提升，此时这种计算机主要应用于工业生产

70 - 至今 第四代计算机出现， 大规模的使用集成电路，硬件更加的精化，软件也更加丰富，已经大规模可以个人使用

计算机的应用领域：

科学计算： 国家范围的使用，比如：航天，天气预报，国防， 武器制造，地震预报……

过程监控： 主要应用于工业生产，例如：流水线（给啤酒打盖），超市的屏蔽门（自动开关门）

信息管理： 指的是各行各业的企业级应用（例如：学校系统，医院系统，政府系统，运营商各种系统），以及互联网应用（例如：京东，淘宝，……）

人工智能： 主要模拟人的思维，和行为，进行机器人控制： 咱们可以采用机器人进行游戏（AlphaGo 机器人 与 围棋世界冠军（李世石（1:4），柯洁……）进行比赛）， 守家（澳门风云中赌神的机器人） ，救援，拆弹，农业生产……

语言翻译: 有道翻译，金山词霸……

计算机的分类： 超级计算机、大型机、小型机、微机

超级计算机
主要应用于国家，进行科学研究，或者军事模拟……，国内的天河二号运算速度每秒5.49亿亿次，连续好几年位于超级计算机前3名的位置
大型机
主要应用于大型管理系统(ERP)的服务器，性能极高，有专门的硬件以及OS（操作系统），主要厂商：IBM
小型机
主要应用于小型信息管理系统的服务器，性能很高，硬件和我们微机一样，但是配置极高
微机
我们自己的电脑

计算机上常见的操作系统：

Windows,Linux,Unix

1、Linux 是一种类Unix系统
2、它的操作比windows更加的复杂，但是更加进行程序员思维习惯
3、它的运算速度比windows高，因为它只要有一个Linux内核就可以了，但是windows绑定了太多的内部程序
4、安全性比windows高，木马程序在linux是无法运行的，例外就是它采用的是命令操作方式
5、所以，我们通常的习惯是在windows上开发软件，而在linux上运行软件。

计算机上面常见的OS系统：
windows linux unix ……
windows 是我们使用最多的操作系统，它更多的操作是通过鼠标，通过图像界面进行操作。
linux是一个开源，免费的类unix的操作系统，它分为内核版以及发行版两种不同的版本，linux centos

程序设计

编程中常见的错误类型：
开发错误、运行时错误

开发错误：语法错误、逻辑错误
运行时错误：内存溢出、存储器空间不够

软件开发步骤：
①分析问题
②确立数据类型与算法
③编制程序
④调试问题

软件、程序与计算机语言的关系：

1.软件 = 程序 + 数据
2.使用计算机语言来编写程序

计算机语言的发展：

机器语言→汇编语言→高级语言
高级语言： A + B（编译型语言、解释型语言）

编译型语言：
优点：可以脱离开发环境独立运行，执行效率比较高；
缺点：可执行程序不能跨平台；

解释型语言：
缺点：每次执行该语言的程序都需要进行一次编译，效率低，不能脱离解释器独立运行；
优点：可实现跨平台执行；

汇编语言：
MOV AX BX
优点：目标代码简短，占用内存少，执行 速度快，能访问、控制各种硬件设备
缺点：和机器语言一样是低级语言，难学，难写，难记忆

机器语言：

010101010111001001
优点：直接执行，速度快，资源占用少
缺点：可读性、可移植性差，编程繁杂

程序流程控制
流程控制：

1.方法的调用、
2.选择语句、
3.循环语句。

布尔类型的布尔值有：

true和false

组合布尔逻辑

与（&&:逻辑与 , &:按为与）、或（||:逻辑或 , |:按与或）、异或（^）、非（！：逻辑非, ~：按为非）

和（&&:逻辑与 , &:按为与）:两个表达式均为true，组合表达式为真

&&:逻辑与:
1.逻辑与 两侧的表达式必须是布尔表达式
2.逻辑和又被称为短路和，当第一个表达式为false时，第二个将不会执行
&:按为与:
1.按位与 是一种数学计算方式，两侧可以放置数值，也可以是字符，放置 能够得到数值的计算表达式，也可以放置布尔类型
2.两边的代码都会执行
3.i++参与表达式时，先用再操作自己，++i参与表达式时，先操作自己再用

或（||:逻辑或 , |:按与或）:两个表达式中一个为true，组合就为真

||:逻辑或:
1.逻辑或 两侧的表达式必须是布尔表达式
2.逻辑或又被称为短路或，当第一个表达式为true时，第二个将不会执行

|:按与或:
1.两边的代码都会执行
2.i++参与表达式时，先用再操作自己，++i参与表达式时，先操作自己再用

异或（^）:
1.异或两侧两侧可以放置数值，也可以是字符，放置能够得到数值的计算表达式，也可以放置布尔类型
2.一般自己用的比较少，业界主要用于密码进行加密过程，会使用到异或
3.两个表达式中有且只有1个为true，整个表达式才为真

非（！：逻辑非, ~：按为非）:
非真既假，非假既真。单个表达式，表达式结果的boolean值取反：true=！false

！：逻辑非:

逻辑非（！）只能用于布尔类型，不能用于数据值类型。

~：按位非:

按位非（~）可以放置数值，也可以是字符，放置能够得到数值的计算表达式，不能放置布尔类型

增量、减量：

1.增量（i++）、减量（i- -）这种表达式，不参与到其他表达式的情况下，就直接操作自增（i++） 自减(i- -）
2.如果一旦参与到 其他表达式 的情况下，i++ 或 i- -在变量后面的话，变量的用法，先用，再自增或自减
3.如果一旦参与到 其他表达式 的情况下，i++ 或 i- -在变量前面的话，变量的用法，先自增或自减，再用。

if条件判断

单分支if，双分支if，多分支if

单分支if :
if（条件）{条件满足执行}
双分支if：
if（条件）{条件满足执行} else {条件不满足执行}
多分支if :
if（条件1）{条件1满足执行} else if （条件2）{条件2满足执行} else if （条件3）{条件3满足执行}else {条件不满足执行}

多分支switch:
1.switch（变量值） case0（变量值必须<=4个字节） 代码块 break； case1（变量值必须<=4个字节） 代码块 break； default break；
2.能够作为变量类型的还有（jdk1.7以前）char、byte、short、int，（jdk1.7以后，还允许string来作为变量型）

循环结构
white循环 , do-white循环 , for循环 , 结束循环

white循环:
white循环就是先验循环

特点：先判断再进行循环

循环格式：
while(布尔表达式) {
循环体
}
do-white循环:
do-white循环是后验循环
特点：直接执行一次，再进行判断是否进行循环第二次
do{
循环体
} white（条件表达式）

for循环：

多用于有限次数循环

for（表达式1（初始值）；表达式2（条件表达式）；表达式4（计算表达式）；）{
循环体（表达式3）
}
结束循环：
break跳出循环
continue结束当次循环，进入下一次循环

类、对象和包

结构化编程和面向对象编程的区别

结构化编程：
程序用流程图和自顶向下的方法设计，着重于过程
computeMedicareTax()、computeSSTax()（找动词）

面向对象编程：
（找名词）万物皆对象
（Object Oriented Programming，简称OOP
属性是对象所具有的特征，而行为是对象可以做的动作。对象的每个属性被表示为类中的一个成员变量。对象的每个行为成为类中的一个方法。

结构化和面向对象两者区别

在结构化过程中，程序围绕着要解决的任务来设计
在面向对象过程中，程序围绕着问题域中的对象来设计

类和对象的关系
类是对象的抽象，对象是类的实例

编写java类
不能用java关键字作标识符
（公用）public class Employee{ }(文件 扩展名位.java)，相同的属性和行为
全局变量（成员变量）或类的属性：

访问修饰符、数据类型、成员变量名称（遵循小驼峰命名法）

方法：
访问修饰符
返回类型
方法名称，必须是一个有效的标识符
参数列表在（）中出现,称为“形参”
方法的定义

实例化对象

为什么产生对象？
类是模板，对象才真正具体存在
Employee employee = new Employee( );
对象的销毁：让对象没有任何的引用，把地址赋值成为null

访问对象属性和方法
通过new关键字产生对象，通过对象访问成员变量和方法

this引用
1.this代表对当前类的对象的引用
2.每个对象都有一个隐含的this变量,它可以访问类的所有信息

包组织类

Java通过引入包（package）来解决这两个问题？
1.提供了一个组织类的机制
2.为包中的类提供了一个命名空间。

创建和使用包
1.将类添加到包中；关键字：package，看看使用后的效果
2.创建了包后，类的名称变了；类全名：包名.类名
3.同包类相互调用的效果；
4.不同包的类相互调用的效果：关键字：import，看看使用后的效果
5.包目录结构：主要针对的是class文件的目录结构

对象的行为
方法的声明与 调用

声明方法的语法：

1.访问修饰符
访问修饰符的可能值包括public、private、protected或默认访问修饰符

2.可选性质的修饰符
方法签名的下一个部分是可选的修饰符，包括static、final、abstract、native以及synchronized。native方法用于编写一个Java访问映射到用不同
编程语言编写的方法。

3.返回类型
方法签名必须包括返回值的类型。如果方法不需要返回一个值，就使用void。

4.方法的方法名
public static void main(String[] args)

5.形式参数列表
参数的参数列表即可写一个，也可多个,参数个数可以自定义，定义在方法参数列表上的参数，我们取名为“形参”，形参主要用来规定该方法被调用时，可以接收数据的数据类型

6.异常列表
抛出的异常列表。方法可以抛出一个异常给方法的调用者。

可变类型的参数：（int…）

方法的调用
实际参数如果是基本数据类型和 string类型，在被调用的方法内部针对形参做任何改变，实际参数所对应的变量都不会改变，但如果是其他引用数据类型，在被调用的方法内部针对形参做了改变，实际参数所对应的变量也会跟着改变

方法调用栈
1.方法的调用
2.选择语句
3.循环语句

方法重载
当一个类有两到多个同名但是有不同参数列表的方法时，就是方法重载。
定义：相同的行为，不同的实现，根据不同的参数列表来进行区分
特点：参数的个数可能不一样，参数的类型可能不一样，参数的顺序也可能不一样，方法名一样

java面向对象的三大特征：
封装、继承、多态

封装：
1.组装属性和类的行为
2.隐藏内部信息

多态：相同的行为，不同的实现
get属性（） { }//获取私有属性的方法
set属性（） { }//设置私有属性的值的方法

构造器
一个默认构造方法具有以下的形式：
public （） { }
访问修饰符 类名（） { }

构造器的名称 必须要与类的名称相同，没有返回类型连void都没有
作用：产生对象

构造器可以不写，编译器会自动给我们生成一个公共的无参的构造器
构造器如果被我们程序员一旦写了，编译器将不会自动给我们产生成任何构造器

构造器产生对象步骤：
1.如果其他程序使用new构造器（）调用构造方法，那么构造器就会去内存中申请存储空间（person那么大），用于存放对象。
2.去申请的空间中，为属性分配对应的存储空间
3.对属性进行初始化
4.执行我们在构造器中编写的代码

有参构造：
作用：产生对象，还可以初始化成员变量
定义：有参构造的潜规则：定义有参构造之前，需要先定义无参构造
tihis（）：代表调用其他构造器，必须写在构造器中的代码最前面（只能放在构造器第一行）

栈：变量。参数。返回地址
堆：放我们创出来的对象，new的对象
方法区：常量池：常量
本地方法区：编译后的 .class文件内容（字节码文件）
程序计数器：代码执行顺序，方法栈

数组

定义：

数组是存储在一个连续的内存块中的元素的集合，也是一个引用类型。
只能存放相同类型的数据，并且放置的时候使用连续存储的数据。
数组类型变量可以同时存储多个同类型基础数据类型变量或对象。
下标（索引）从0开始，可以根据数组的下标操作数据。
集合：一个可以放东西的容器 。

数组特点
1.只能存放相同类型的数据。
2.数组定义好以后，内存中的元素的存放是连续的。
3.数组的大小，需要在定义的时候，就固定好，一旦确定，就无法修改。

数组的声明方式：
跟其他的引用数据类型声明变量一模一样。
int【】 num = new int【】

创建数组
声明一个数组变量
使用new关键字初始化数组，并提前指定数组的大小

数组长度
在使用访问数元素时候，不要超出数组所分配的空间，否则会出现运行时异常。
数组的大小，需要在定义的时候，就固定好，一旦确定，就无法修改。
java中的数组是对象，每个数组都有一个length属性来代表数组的大小，减少数组访问越界的可能性。

数组的复制
src（源数组）
srcpoc（源数组中的起始位置）
dest（目标数组）
destpoc（目标数据中的起始位置）
length（要复制的数组元素的数量）

继承

继承的来源

继承来源于生活
如果不用继承，代码可能出现混淆属性和行为
也可能出现代码重复，和扩展性无法提升的情况

继承的概念
定义：在面向对象编程中，可以通过扩展一个已有的类，并继承该类的属性和行为，来创建一个新的类，这种方式称为继承（Inheritance）

已有的类称为父类，而新类称为子类。父类也可以称为基类、超类，子类也可以称为派生类

子类、派生类：
子类可以继承除了父类私有属性和行为，以及构造函数之外的其他类容
子类还可以扩展新的属性和行为，还可以重写父类的方法。

类和类的关系
has-a（组合）
is-a（继承）
实现、依赖、关联关系、部分和整体
部分和整体：组合、聚合
构造器和父类私有属性不能继承
继承需要满足is-a的结构
优点:
1.代码的可重用性
2.提升程序的扩展性
单继承 和多继承:C语言中允许多个父类（多继承），java中不允许，一个类只能有一个父类（单继承）

子类实例化
new关键字来实例化
但不是先创建父类在创建子类
是只创建一个对象，先给父类分配属性空间，再叠加子类私有属性

java中继承的实现
关键字 ：extends
java中只允许单继承，不支持多继承，但不是否认杂交不好
优点:安全性高，层次结构清晰,
不好的地方：丰富性降低
后续，java中可以支持多实现

方法的重写

方法重写与方法重载的区别
方法的重写：子类中的方法与父类中的方法相同（方法名称、参数列表、返回类型）
方法的重载：一个类中的方法与另一个方法相同，参数列表不同
重写体现的是父类与子类方法之间的关系，多态的动态，要去继承下来改了
重载体现的是一个内部方法之间的关系， 多态的静态，要去继承下来没改

遵循原则
子类的方法的返回值的类型、方法名和形式参数列表，必须和父类中的是相同的。
访问修饰符必须不小于父类中的访问修饰符。
子类中重写的异常不能抛出比父类更多的异常

==
如果两边的数据类型是基础类型，那么直接比较值是否相等
如果两边的数据类型是引用类型，那么直接比较引用 是否相等

extends（）：
默认情况下，调用的是Object.extends( )，这个方法比较是对象的引用是否一致，但是在某些特殊的业务场景中，也可以重写该方法

super（）：
这是父类的构造方法，这行代码必须要放置在第一行，如果程序不显示写出，编译器也会默认添加上。
这个默认编译器会自动给我们添加子类构造的第一行
只能访问继承至父类的那一部分财产，私有财产除外（属性和行为）

super .
代表这来自于类型父类的财产，他不代表父类
super 作用范围：只可操作来自继承父类的财产（属性和行为）

this .
this（）：代表本类中其他构造函数，这个没有默认添加
this . 属性或this.行为（）：访问继承至父类的财产
this 作用范围：
1.可操作本类所有属性，可操作本类所有方法，还可操作来自继承父类的财产（属性和行为）
2.代表着由该类产生的对象自身，所以this.作用范围大于super.的作用范围，所以直接用this .

最终类和最终方法（final）
final类。一个类可以声明为最终类的。最终类不能被有子类。
final方法。一个方法可以声明为最终的。最终方法不能被重写。

类的高级概念

定义：用来定义类中的属性和行为，能够被其他类在什么情况下可以进行访问的符号
public > protected > default > private

访问修饰符
公开访问级别：使用public关键字修饰。（大）
1.该类或非该类都可以访问
2.公开可以被任何其它对象访问。
受保护访问级别：使用protected关键字修饰。
1.该类及其子类的成员可以访问，同一个包中的类可以访问
2.受保护的可以被同一包中的类所访问，还可以被类的子类所访问，不管子类是在哪个包中
默认访问级别：没有访问修饰符。（default）。
1.相同数据包中的类可以访问
2.默认访问可以被同一包中的其它类所访问。
私有访问级别：使用private关键字修饰。（小）
1.只有该类可以访问
2.私有只有类本身可以访问，不对外公开

封装的概念及好处
定义:
1.是oo 的四大特征之一（继承、封装、多态、抽象）
2.用于组装类的属性和行为，并通过访问修饰符以及方法来隐藏类的成员的方式
优点:
1.类还可以改变一个成员变量的数据类型，从而让类的调用不能轻易的，凭借经验就判断出类的成员变量
2.类可以通过对方法的控制，完成对成员变量的内容的整体控制。比如：天王盖地虎
3.类的成员变量通过访问器和修改器进行控制，可以成为只读或只写，不再是外部 可以任意操作

类的静态成员
定义：static修饰的全局变量叫静态变量，也叫类变量。类变量的值为所有对象所共享

定义：static修饰的全局变量叫静态方法，也叫类方法。类方法只能使用静态变量，而不能使用非静态的全局变量

在修饰方法（静态方法）时，对应的方法可被称为类方法，跟变量一样，同样与对象已经无关，直接上升为类的行为。非静态方法，必须要等到实例化对象后才可以调用，而静态方法，在类加载之后，就可以直接调用

static
static修饰的内容存在于内存的时机：类加载的时候
static的适用场景:
1.static在修饰全局变量时，一般用于修饰常量，主要目的：节约内存，将变量定义在静态区域中，而不是每个对象自身
2.static在修饰方法时，一般用于修饰工具类的工具方法，比如：Math类，array类，stringUtils类

static无法修饰构造函数，因为static修饰的属性或行为都与对象无关，但构造是专门产生对象的

静态方法中，不能访问非静态成员（属性也指方法）的原因是：
1.静态方法在加载时，非静态属性，方法压根就还没有调用
2.假设可以调用，那么存在成千上万个对象，调用谁的属性的行为？

静态初始化块和实例初始化块的用法
静态初始化块:
1.静态初始化块，需放置在属性之下，构造之上
2.在类加载时，执行一次
3.主要用于在类加载时，做一些前期的准备工作，比如：检查数据库连接是否正常，检查配置文件是否存在，或者提前读取某些文件内容，到内存中。在类加载时，就开始执行

实例初始化块:
1.实例初始化块，需放置在属性之下，构造之上
2.每实例化一次，执行一次
3.主要用于初始化成员变量，一般是对象实例化时，才会执行，并且实例化一次，执行一次。它执行在构造函数执行代码的第三步到第四步之间。当然可以使用有参构造替代实例初始化块

内部类的使用方式

成员内部类
定义在类的内部，作为类的组成
特例：静态内部类
1.用static修饰的成员内部类
2.它的特点，依旧是将该内部类，与对象脱离关系，直接上升为类的关系，效果等同于类变量，类方法
成员内部类的地位：等同于全局变量的地位
成员内部类，内部可以使用外部类所定义的所有的成员(成员变量，成员方法)
成员内部类的访问：必须要通过外部类的实例调用，才可以访问内部类。例如：pc.new Monitor();

局部内部类
定义在方法的内部，作用范围也仅局限为这个方法
特例：匿名内部类
局部内部类，同样跟局部变量一样，不能添加访问修饰符
局部内部类，无法被方法外部访问
局部内部类，内部无法通过this.访问外部类的成员,但是可以通过“外部类.this.”来访问

java文件与类文件的关系

1、java文件中，包含几个类，就对应的产生几个相应的类文件

2、java文件的名称，不一定和类文件的名称保持一样。比如：
兄弟类类文件的命名规则就是“兄弟类.class”
成员内部类类文件的命名规则就是“外部类内部类.class”局部内部类类文件的命名规则就是“外部类内部类.class”局部内部类类文件的命名规则就是“外部类内部类出现的次数 + 内部类.class”

3、一个java文件中，只允许出现一个public修饰的外部类，其他的而外部类都是default