java理论考试范围

知识集群一：Java编程基础

一、 java编程基础

（1）java起源产生

面向对象技术(OOT)

面向对象 (Object Oriented，OO) 技术引起人们的普遍关注

传统的过程化程序设计 “程序=算法+数据结构”，算法是第一位，数据结构是第二位

面向对象程序设计（Object Oriented Programming，OOP）调换了次序：

“程序=数据结构+算法”，即数据结构是第一位，算法是第二位。

面向对象的语言通常具有以下特征，对象生成功能、消息传递机制、类和遗传机制

Java起源于1994年，美国Sun Microsysystem的Patrick Nawghton、Jame Gosling和Mike Sheridan等人开始了代号为Green的项目的研制，目标是研制一种开发家用电器的逻辑控制系统，产品名称为Oak。

1995年，Oak更名为java。这个名字来自于印度尼西亚一个盛产咖啡的岛的名字，中文名为爪哇。热腾腾的香浓咖啡成为了java的语言标志

2009年，甲骨文公司（Oracle）收购Sun公司。该公司总部位于美国加利福尼亚州的红木滩。

（2）代表人物

詹姆斯.高斯林（James Gosling） ，1995年生

Java创始人之一，公认为”java之父“

（3）特点

OO是一种方法、一种思想，同时又是一种技术。OO力求更客观自然地描述现实世界，使分析、设计和实现系统的方法同认识客观世界的过程尽可能一致。

java具有如下特点：

1、简单性；2、平台无关性；3、分布式；4、健壮性；5、安全性；6、浏览器应用

（4）背景

对象是客观世界中的事物在人脑中的映像，这种映像通过对同一类对象的抽象反映成为人的意识，并作为一种概念而存在。

（5）java体系结构

完整的java体系结构由：java编程语言、java类文件格式、java API和JVM虚拟机四部分组成。

JVM是（Java Virtual Machine）(Java虚拟机)的缩写。

JVM通过在实际计算机上仿真模拟各种计算机功能来实现。JVM有自己完善的硬件架构，如处理器、堆栈、寄存器等，还有相应的指令系统。

java开发时，本质就是用java编程语言编写代码，然后将代码编译为java类文件，接着在JVM中执行类文件。

JVM处于Java体系结构的核心位置。

（6）java虚拟机（7）java运行机制

①体系结构

实现平台无关性这一特点于JVM有关。一般的高级语言如果要在不同平台上运行，至少需要编译成不同的目标代码。

引入JVM后，java语言在不同平台上运行时不需要重新编译即可运行

②JVM的运行机制

JVM通过调用某个指定类的方法main启动，传递给main一个字符串数组参数，使指定的类被装载，同时链接该类所使用的其他类型，并且初始化它们。

（8）Java类库

java类库就是Java API(Application Programming Interface，应用程序接口)。是系统提供的已实现的标准类的集合。

（9）java开发工具与环境等

JDK是Java Develoment Kit的缩写。（SDK即Software Development Kit的缩写，是旧的说法）。 JDK的命令行使用：编译器——javac，语言解释器——java

Java的集成开发环境。Eclipse、NetBeans、MyEclipse、IntelliJ IDEA、Jcreator(Le版免费)。

二、java语言基础

（1）基本编程元素

变量、表达式

（2）基本数据类型

8种基本数据类型：4种整型byte、short、int、long；两种浮点型float、double；表示字符的char型；表示布尔值的boolean型

（3）整型

①字节数、表示范围、默认值

---------------------------------------分隔线-------------------------------------------------

②byte型值域及值的延伸

byte字节型，以1个字节存储整数，以1个bit存储正负符号，存储小整数，在较大规模数组中会显著降低所需空间。

byte型存储整数，在正常范围是 -128~127，当超过范围赋值时，可以按照向左、向右延申的方法理解实际存储的值。

---------------------------------------分隔线-------------------------------------------------

（4）浮点型

浮点型数据默认为double型，如果要使用float型常量时，必须添加F或f。示例如下：

float x = 12.3456; //错误

float y = 12.3456F; //正确

使用double时，后缀D或d可加可不加。

（5）boolean型值true、false

在java中boolean变量只有true和false两个值。

（6）char型（与C不同）及编码

char型表示字符。每个char型变量占16bit，两个字节。Java中，字符的编码不是ASCII码，而是Unicode编码。

Unicode编码是用16位无符号整数表示的，有2^16个可能，即0~65535。能表示大部分字符，中文占据相当一部分。

char类型被表示为用一对单引号包含的单个字符。如char c1 = 'n'; char c2='@';

（7）标识符规则

java语言规定标识符由字母、下划线（__）、美元符（$）和数字组成，且第一个字符不能是数字。其中，字符包括大小写字母、汉字。Java使用Unicode字符集，包含65535个字符。

变量名不能是关键字（int、double等）。

Java的”字母“范围更大，不单包括英文字母，还有希腊字母和汉字

“+“这样的特殊符号不能出现在标识符中，空格也不行。

标识符中字符大小写敏感，长度没限制。

类名首字母要大写

（8）final变量

可以在任何作用域声明一个final变量。final变量的数值在初始化之后不能再进行改变。（类比于C中的#define）。

为了声明一个final变量，可以在类型之前的变量声明使用final关键字。

给定final后，不可再给该变量赋值，否则会编译报错。

（9）运算符、多种典型语句(语句部分与C基本一致)

Java的运算符主要分以下几类：算术运算符、关系和逻辑运算符、位运算符、赋值运算符、其他运算符。

1、算数运算符：加+，减-，乘*，除/，求余%，自增++，自减--。

2、关系和逻辑运算符：用于比较两个值，根据它们的关系给出相应的取值。

关系运算符运算结果只有：true和false两种。>,>=,<,<=,==,!=。

逻辑运算符运算结果只有：true和false两种。&&，||，！，^(逻辑异或)。

3、对操作数以二进制位为单位进行的操作和运算，结果均为整型量。位运算符分为移位运算符和逻辑运算符。位运算符：>>，<<，>>>(无符号右移位)，&，|，^，~。

4、赋值运算符普通赋值：“=” ；运算赋值运算，例如x>>1; y+=3

5、其他运算符

6、条件语句

---------------------------------------分隔线-------------------------------------------------

7、循环语句

---------------------------------------分隔线-------------------------------------------------

8、跳转语句

break语句：一是推出switch；二是作为循环中退出当前层次的循环

continue语句：在循环语句中只中断当次循环。

return语句：用于函数或方法返回。

（10）字符串及应用

String类型

此类型不能更改，如果程序需要使用字符串常数，该类型比较合适。

创建String字符串最简单的就是使用字符串文本，如 String str1 = "hello";

还可以用 new运算符，如String str2 = new String("hello");

前者在栈里分配内存，后者new是在堆里分配空间，内存位置不同，栈更快，堆空间多。

StringBuffer类型

该类型存入的字符串可以改变的。字符串内容经常改变，应该使用这个类型。

StringBuffer对象创建 StringBuffer name = new StringBuffer("xxx");

（11）数组及典型应用

特点：数据是同一类型，所有数据线性排列，可以通过位置索引访问数据，需明确长度。

数组的元素可以是基本数据类型，也可以是对象引用类型。数组本身是对象，这是Java的数组不同于其他语言的数组之处。

①数组声明

元素类型+数组维数，int[] k ; String s[];

元素类型后是数组名和方括号对，两者位置可以呼唤。

数组维数只与方括号对数有关

②创建数组对象

---------------------------------------分隔线-------------------------------------------------

数组对象创建后，无法操作，因为没有数组指向它。

③数组初始化

默认初始化

循环初始化

枚举初始化

---------------------------------------分隔线-------------------------------------------------

④数组的常用操作

数组的排序

---------------------------------------分隔线-------------------------------------------------

（12）源文件和class文件

三、输入输出

（1）典型输入输出及应用

系统输出流是System类的一个静态成员，名称为out。

System.out.println();

System.out.print();

printf()方法：

printf(String format, object args);

参数引用，为格式串指定对应的args参数。n$表示对应第n个args参数。

标志：

宽度：用于设定对应值在输出所占字符的字符，用整数表示。如果数据宽度大于设定宽度，原值输出，反之以空格或指定的字符进行填充。

d十进制整数，o八进制整数，s字符串，b布尔值，x十六进制整数，f浮点数，c字符。

（2）基本应用

---------------------------------------分隔线-------------------------------------------------

---------------------------------------分隔线-------------------------------------------------

---------------------------------------分隔线-------------------------------------------------

---------------------------------------分隔线-------------------------------------------------

知识集群二：面向对象基础及应用

一、面向对象概述

OOP与具体语言无关。

（1）概念

（2）理念

（3）需求

（4）特征

对象被映射为类，类是Java中最基本的单元。对象的任何行为都可以通过Java类的方法实现，而对象的属性可以通过Java类的属性实现。

1、Java的类：在Java中的所有信息都存放在一个单独的文件中，文件名拓展名是.class。

2、Java的封装：Java把对象所有特性封装在一个类中，用户只要知道其所需要的参数即可使用。类定义可以看成是将构成类的成员变量和方法封装起来。 通常用private保护成员变量。

3、Java中的继承：Java中不允许定义多继承，一个子类只有一个父类。一个类可以实现多个接口。

4、Java中的多态：在操作符、方法、子类继承父类都可以使用多态。

（5）背景

（6）优势

可重用性、可拓展性、易于维护和管理

（7）面向对象术语

类：具有相同属性和相同行为的对象的集合，类是集合，对象是类的实例

OOP使用继承实现类的共享数据和方法。新建的类称为子类，该类需要继承的类称为超类或者父类。

封装：也称为数据隐藏。对象应被看作包含或封装功能的黑匣子。程序猿应该能够在仅知道对象的属性、方法和事件的情况下进行交互，而不需要知道实现的详细信息。可以利用封装可以进行成员访问控制，成员的详细信息对于对象外的代码是私有的和不可见的。

接口：类定义的模板，实现接口的类实现该模板，接口是描述类的蓝图创建一个接口用以声明方法、方法的参数及其返回类型。任何实现此接口的类，都必须提供这些方法的定义，否则将出现编译错误。

（8）UML建模

为什么建模

建模的基本理由：建模是为了能更好地理解正在开发的系统，系统越大、越复杂，建模的重要性越大。

建模的四个目的：有助于按照实际情况或按照所需要的样式使系统可视化，能够规约系统的结构或行为，给出了指导系统构造的模板，使做出的决策文档化。

UML建模语言

UML就是统一建模语言（Unified Modeling Language）。是OMG（Object Management Group）组织于1997年发布的。UML目的之一是为开发团队提供通用的设计语言来开发和构建计算机应用。

UML的面向对象分析设计

为了创建最好的解决方案，必须遵从项目需求分析到开发这样的一个过程，如果按照面向对象的观点，称为面向对象的分析和设计（Object-oriented analysis and design，OOAD）

过程有三部分：1、识别系统的用例和角色；2、进行系统分析、并抽取类；3、系统设计，并设计类及其行为。

（9）回收机制

Java中对象通常都是动态产生，对象会占用内存空间，Java定义了垃圾回收机制，在运行时实时监测不被使用的内存，当一块内存不再使用时，系统自动回收。

二、类和对象

（1）类的定义和文件

类决定了对象的外观和行为。

一个完整的程序可能包括多个类，其中一般只有一个类有main方法。

一个.java文件里一般只存放一个类。一个.java文件中也可以存放多个类，但最多只有一个类是public属性，而且属性public属性的类的类名必须与.java文件同名。

（2）创建对象new,factory

factory方法相当于创建实例对象的new。factory是Java的工厂设计模式，在创建这个类的实例时，不用new，而是交给工厂类来创建，在工厂类中定义factory方法，让这个方法返回该类的对象即可。

---------------------------------------分隔线-------------------------------------------------

---------------------------------------分隔线-------------------------------------------------

（3）构造器的定义、运行机制和要求（4）默认构造器

（5）构造器及其重载

Java创建对象时，对象的成员可以由构造函数方法（构造器）进行初始化。

对象创建时执行构造函数。JVM有内存自动回收机制，对象回收效率依赖于垃圾回收器GC(Garbage Collector)。

构造函数是一种特殊的方法，构造函数名与类名完全相同。

构造函数没有返回值类型，也不能写void类型。

一旦定义好一个构造函数，创建对象时就会自动调用它。构造函数的任务是初始化一个对象的内部状态。

每个java类都必须有构造函数。如果没有显式定义的构造函数，Java编译器会自动添加一个无形参的默认构造函数，如果有显示定义构造函数，就不会自动添加默认构造函数。

一个类可以有多个构造函数，只要形参表不同（形参个数、类型、次序任一不同即可）。

new创建时，根据实参不同，会自动挑选相应的构造函数。如果实参形参匹配不上，将会报错。

---------------------------------------分隔线-------------------------------------------------

（6）类成员（其他类对象做成员，构造器调用顺序）

1.成员变量的使用：成员变量是类的属性，类定义中的属性指定了一个对象区别于其他对象的值。

2.成员变量的初始值：默认初始值。

整型（byte、short、int、long）的基本类型变量默认值0。

浮点型 float为0.0f double为0.0d

char型默认为\u0000

boolean基本默认是false。

引用类型的默认为null(创建对象用new时即为引用，如数组，String等）

（7）方法及重载

Java中，对对象的操作由方法完成。

定义：

方法的重载

定义：方法重载是指在同一个类里面，有两个或两个以上具有相同名称，不同形参表的方法。

方法重载的规则：方法名称相同，形参表不同，形参表的不同体现在形参的数量、类型、次序中任一方面有所不同

重载方法的匹配：1、调用被重载的方法时，实参按照形参匹配，决定调用哪个重载方法。2、如果直接匹配的找不到，则将传递的参数自动转换，寻找能匹配的方法。

递归：自己调用自己。程序易读，但是会增加系统开销，每递归一次，栈内存就多占用一截。

（8）静态成员的访问关系

使用static关键字可以把成员声明为静态成员。静态变量也叫类变量，非静态变量也叫实例变量；静态方法也叫类方法，非静态方法叫实例方法。

静态成员的最主要特点：它不属于任何一个类的对象，它不保存在任意一个对象的内存空间中，而是保存在该类的公共区域中。任何一个对象都可以直接访问该类的静态成员，都能获得相同的数据值。修改时，也在类的公共区域修改.

将方法的使用完全独立于该类的任何对象,可以用static关键字 。使用static关键字的方法即静态方法。静态方法可以能够被自己使用，而不必引用特定的实例。

静态方法能够在它的类的任何对象创造之前被访问，而不必引用任何对象。但是在静态方法中，不能以任何方式引用this和super。

静态变量使用static修饰该变量。

---------------------------------------分隔线-------------------------------------------------

静态变量和常量

public static final int x =10;

static public final int y = 20;

final static public int z=40;

static表示属于类，不必创建对象就可以使用，常量不依赖于任何对象

final表示值不能改变。

static可以于其他修饰符组合使用，顺序可以任意调换。

---------------------------------------分隔线-------------------------------------------------

静态方法访问非静态成员

静态方法不能访问非静态成员。静态方法可以访问静态成员。静态方法不能借助this访问成员，包括用this访问静态成员。 静态方法的生命周期>非静态成员。

非静态方法访问静态成员

非静态方法能够访问静态成员。

（9）main方法

方法的名字必须是main，方法必须是public static void类型，必须接收一个字符串数组的参数。

main()方法是由Java虚拟机调用的，所以必须为public。

Java中的格式为：public static void main(String[] args)

（10）包（package）

Java提供包将不同类组织起来进行管理。借助于包可以方便地组织自己的类代码，并将自己的代码与别人提供的代码库分开管理。

使用包的目的之一就是可以在同一个项目中使用名称相同的类。

想要将类放入指定的包中，使用package语句。

语法：package<包名>；

package语句必须放在源文件最前面，不可以由其他任何语句。每个源文件最多有一句package语句。

（11）导入（import）

类的导入

import<包名>.*;

import<包名>.类名

一个源文件中根据需要可以有多句import语句。

import位于package之后，类声明之前。 import语句顺序任意。

---------------------------------------分隔线-------------------------------------------------

静态导入

（12）成员访问控制（重要）

知识集群三：继承与多态

一、继承

（1）概述

关于继承，可以基于已经存在的类构造新类，还可以在新类中添加一些新的成员或修改继承了的成员，以满足新的需求。

多态是在继承的基础上引出的，可以解决子类父类中的成员重名等问题。

面向过程语言没有继承。面向对象编程语言中，有父类/基类/超类的体系。而体系内的其他类则自动成为子类/派生类。

利用继承可以很好地实现代码重用，在利用已有的类构造新类时，新类保留已有类的属性和行为，并可以根据要求添加新的属性和行为。

（2）基本术语

被继承的类一般称为超类/父类/基类，继承的类称为子类/派生类。

继承节省了定义新类的大量工作，可以方便地重用代码，在派生类中只需要定义新增和修改的成员即可。一个子类不必非要使用继承下来的属性和方法，一个子类可以选择覆盖已有的属性和方法，或添加新的属性和方法。

（3）层次结构

（4）object类（总根类）及toString，equals方法覆盖

Java中，实际上所有的类都直接或间接继承自java.lang.Object类。Object类是Java中的总跟类。如不特殊指定，自己定义的类均直接继承自Object类。

①toString

该方法将返回此对象的字符串表示。

public String toString()

Java中大多数类都重写了这个方法，通常方式是将类名以及成员变量的状态信息组合转换为一个字符串返回。

System.out.println方法在打印引用时，若引用不为空，则调用引用指向对象的toString方法，获取并打印字符串。

---------------------------------------分隔线-------------------------------------------------

②equals方法

equals方法来自于Object类，String类对其进行了重写。以满足比较字符串内容的要求。Object类中设计这个方法就是为了让继承它的类来重写，以满足比较不同类型对象是否相等的要求。

在Object类中，equals方法的实现相当于如下代码：

public boolean equals(Object obj)

{return (this==obj);}

在Object类中equals方法只是比较两个引用是否指向同一个对象，如果向特定类真正比较对象是否相等，需要在特定类中根据比较规则重写equals方法。

---------------------------------------分隔线-------------------------------------------------

（5）派生子类

类的继承用extends关键字实现。在创建新类时，使用extends指明新类的基类。定义如下。

class 派生类名 extends 基类名

{

派生类类体

}

继承规则：

根据成员变量属性即公有、私有、默认、保护型不同，继承后能否可见也不一样。

公有类型：无论基类和派生类是否在同一个包内，派生类继承基类后该成员变量都可见。

私有(private)类型：基类成员是私有型，任何派生类继承，该成员变量都不可见。

默认类型：包外派生类继承后该成员不可见，包内继承可见

保护型（protected）成员：包外包内派生继承，都可见。

（6）访问控制

（7）子类调用父类构造器（类成员、构造器执行次序）

子类会默认继承调用父类的构造器。

如果子类没有显示调用父类构造器，则自动调用父类的无参构造器，此时如果父类没有默认构造器，编译器会报错

---------------------------------------分隔线-------------------------------------------------

（8）属性隐藏

成员变量的隐藏

当子类本身具有与继承自父类的成员变量名称相同的成员变量时，构成了成员变量的隐藏。

成员变量隐藏的含义是：在子类中直接调用该成员变量时，将调用的是子类中本身具有的成员变量，而不是从父类继承的成员变量。

隐藏后，要访问同名的成员变量，要用super关键字访问。

（9）方法继承与覆盖

方法继承允许子类使用父类的方法，而覆盖是在子类中重新定义父类的方法。

方法的继承

本质上，方法与成员变量都是成员。因此方法的继承规则，与成员变量的继承规则完全相同。

方法的覆盖

在子类自身方法中，若与继承来的方法具有相同的方法名，就构成了方法的重写，也称为方法的覆盖。

方法覆盖的主要优势，是能够定义各子类的特有行为。

（10）this和super

this常用来引用当前对象，super常引用父类对象。

①this

方法中的某个对象（泛指）与当前对象的某个成员有相同的名字，这时为了不至于混淆，可以使用this关键字来指明要使用某个成员。使用方法是“this.成员名”。

除了引用当前类对象外，this可以用于将当前对象的引用作为参数，传递给类外。

this还可以调用当前类的构造函数，this(实参)。

②super

super用来引用父类的成员，包含父类的构造函数、属性以及方法。

使用方法为super.变量名或super.方法名（实参）。

---------------------------------------分隔线-------------------------------------------------

---------------------------------------分隔线-------------------------------------------------

（11）基于继承的强制类型转换

在继承过程中发生引用类型转换，而不是基本数据类型的转换。

对象引用能指向其自身类型的对象实例，父类的引用能够指向其派生类（直接派生、间接派生）的对象。

如果一个对象与另一个对象没有继承关系，那么它们就不能进行强制类型转换。

动态绑定

指在继承、方法重定义时，父类引用指向子类对象，而且在子类中有对父类方法的重写（覆盖），此时，父类引用调用有重写的方法，在程序运行过程中，动态识别所指向的子类对象，调出子类中重写后的、实参符合形参表要求的新方法。

静态绑定

父类引用指向子类对象，调用静态方法和属性时，此时，根据父类的类型来执行，调用的属性是子类继承自父类的属性。

---------------------------------------分隔线-------------------------------------------------

（12）final类、方法

final类

关键字final修饰类时，含义是该类不能再派生子类

只有当需要确保类中的所有方法都不被重写时，才应该建立final类，final关键字将为这些方法提供安全，不会重写final类中的方法，因为不能继承。

final方法

用final修饰方法后，该方法在子类中将无法重写，只能继承。

要恰当使用final方法，只有在子类覆盖某个方法会出问题时，再将此方法设为final方法。

（13）抽象类、抽象方法及关系等

把现实世界很多具有相同特征的事物归为一个抽象类。在需要一个抽象类实例时，只能用某个具体类的实例来代替。

Java是用来抽象和描述世界的，因此提供抽象类，并且其永远不能实例化，唯一的用途是用于继承拓展。

①抽象类

Java中，可以使用abstract关键字声明抽象类和抽象方法。

不能把一个类同时标识为abstract和final，这两个关键字含义相反，abstract标识很多事物总称，要再派生子类。final类不能再派生子类，二者同时标识编译将出错。

②抽象的方法

抽象方法是只有方法说明体，没有实现体，因为这些方法会因子类的不同而有不同的具体实现。

1、使用abstract关键字声明。

2、抽象方法只能存在于抽象类中，非抽象类不能有抽象方法。

3、抽象方法可以有非抽象方法，表示所有子类都具有的方法，不会因为子类的不同而不同。

4、 某类继承自抽象类，即将成为抽象类的子类时，如果自身不是抽象类，就必须实现父类（抽象类）中的抽象方法。

5、 抽象类的第一个非抽象子类，必须实现其父类（抽象类）的所有抽象方法，其中包括父类继承的抽象方法，否则编译报错。

6、private与abstract不能同时修饰，private阻止继承，也就阻止了重写，与abstract方法在子类中重写相矛盾。

---------------------------------------分隔线-------------------------------------------------

---------------------------------------分隔线-------------------------------------------------

二、多态

Java中，基于继承的多态，就是指对象功能的调用者，用超类（父类、基类）的引用调用方法。 这样可以提高灵活性，因为用超类的引用能调用各种不同子类的实现。

Java编程遵守契约精神，契约是指，规范了对象应该包含的行为方法，规范了方法接口，基于接口，利用多态，父类引用能够灵活地调用子类中不同实现的方法。

---------------------------------------分隔线-------------------------------------------------

---------------------------------------分隔线-------------------------------------------------

在 java 中允许这样的两种语法出现，一种是向上转型（Upcasting），一种是向下转型（Downcasting），向上转型是指子类型转换为父类型，又被称为自动类型转换，向下转型是指父类型转换为子类型，又被称为强制类型转换。请看下图：

多态存在的三个必要条件分别是：
① 继承
② 方法覆盖
③ 父类型引用指向子类型对象

实际上，抽象类中的抽象方法，只是起到契约的作用。抽象类的子类如果是非抽象类，子类必须要实现抽象类中的所有抽象方法，同时子类可以拥有其他特有的方法。

知识集群四：接口与内部类

一、接口

接口是Java灵活的基石。主要用来描述类可以具有什么样的功能，但并不给出每个功能的具体实现。

（1）基本知识

Java的接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征，没有方法的实现。这些方法可以在不同地方被不同的类实现，而这些实现可以具有不同的行为或功能。

Java语言规范中，一个方法的特征只包括方法的名字、参数的数目和种类，不包括方法的返回类型，参数的名字以及抛出的异常。

Java编译器检查方法重载时，会根据这些条件判断两个方法是否是重载关系。但在Java编译器检查方法的置换时，则会进一步检查返回类型和抛出的异常是否相同。

1、类只可以继承一个类，但是可以实现多个接口，继承和实现接口可以同时。

2、接口可以继承（多个）接口，没有实现的方法将会叠加。类实现接口，就必须实现所有未实现的方法，没有全部实现，那么只能成为一个抽象类。

3、接口里可以定义变量，但是一般是final常量。

（2）定义接口

定义接口，实际上是在编写一个规定，只有方法的说明，没有方法的实现。

实现接口的基本语法如下：

访问限制，只能是public/默认不写（default不行）

可以不写abstract，但编译时会自动加上，即接口都是抽象的。因为abstract与final相反，所以不能对接口使用final。

（3）关键字的运用

实现接口时，要用关键字implements。基本语法如下：

接口名列表中可以有多个接口名，如下。

（4）接口的使用

接口能够被很多不同的类实现，但是接口中定义的方法仅仅是实现某一特定功能的规范，并没有真正实现这些功能，这些功能都需要在实现该接口的类中完成实现。

---------------------------------------分隔线-------------------------------------------------

---------------------------------------分隔线-------------------------------------------------

（5）接口与抽象类的比较

不同点：

1、抽象类可以有部分方法实现，接口的所有方法都不能实现。

2、一个类只能继承一个抽象类/类，但可以实现多个接口。接口可以继承多个接口。

3、抽象类有构造方法，接口没有构造方法

4、抽象类可以有main，可以运行，接口没有main函数。

---------------------------------------分隔线-------------------------------------------------

---------------------------------------分隔线-------------------------------------------------

二、内部类

（1）内部类、外部类的概述

内部类是指在一个外部类的内部再定义一个类。内部类作为外部类的一个成员，内部类的存在依附于外部类。包含内部类的类称为外部类。

1、内部类是指在一个外部类的内部再定义的类。

2 、内部类作为外部类的一个成员，依附于外部类而存在。

3、内部类成员可以是静态，可以用public,proctected,private和默认不写（default不写）修饰。

4、外部类只能使用public和默认不写（不能用default，protected和private修饰）。

内部类继承某个类或实现某个接口，内部类的代码创建其外围类的对象。所以可以认为内部类提供了某种进入其外部类的窗口。

使用内部类最吸引人的是：每个内部类都能够独立地继承实现一个接口，所以无论外部类是否已经继承实现了这个接口，都不影响内部类。

内部类可以继承父类，实现接口。可以解决类无法多继承引起的问题。

（2）内外关系（3）（4）内/外部类关键字的使用

从外面看内部类，可以将内部类看成是外部类的一个成员，与普通成员没有什么区别，对普通成员的限制、修饰等都可以加之于非静态内部类。

①定义内部类的基本语法：

②简单内部类定义样例：

③创建内部类对象的两种方式。

1、在外部类之内创建内部类对象

---------------------------------------分隔线-------------------------------------------------

2、在外部类之外创建内部类对象

（5）内部类的class文件

内部类在编译之后，会得到独立的内部类class文件。

文件名形式：外部类的类名$内部类的类名.class。

知识集群五：异常处理

一、java的异常处理机制

Java定义了很多异常类。每个异常类都代表了一种或多种运行错误，异常类中包含了该运行的错误信息和处理错误的方法等内容。

Java采取“抛出-捕获”的方式，一旦一个异常产生了，Runtime环境和应用程序抛出各种标准类型和自定义的异常，系统就可以捕获这些异常，并且有相应的机制来处理它。这就是java的异常处理机制。

二、try-catch语句的应用与要求

可以用try-catch语句捕获并处理异常。try语句块用于指出可能出现异常的区域，后跟着catch语句，在catch语句块中编写相应的异常处理程序。try语句块只能有一个，而catch语句块可以有任意多个。catch紧跟在try语句后，catch语句块之间没有其他语句（注释除外）

正常：

---------------------------------------分隔线-------------------------------------------------

异常：

---------------------------------------分隔线-------------------------------------------------

三、finally结合try-catch的应用和要求

1、finally语句块中的代码无论在什么情况下都执行。

2、finally语句块一般在try-catch语句块后边

3、finally语句块最多一个，也可没有。

---------------------------------------分隔线-------------------------------------------------

---------------------------------------分隔线-------------------------------------------------