共计 7539 个字符，预计需要花费 19 分钟才能阅读完成。
一. 抽象类
抽象类的概念：
1、Java 中能够定义没有办法体的办法，还办法的具体实现由子类实现，该办法称为形象办法，蕴含形象办法的类就是抽象类；
2、如，shape 类计算周长和面积的办法无奈确定，那么就能够将这样的办法申明为形象的，以便在具体的子类中实现
3. 抽象类也叫做形象基类，抽象类是根底类和接口两头的一个中庸之道，即有根底类个性（已实现的办法体），又有接口个性（形象办法），抽象类用 abstract 润饰，抽象类中能够有形象办法也用 abstract 来润饰。
抽象类的特色：
形象办法的申明
修饰符 abstract 返回值类型 办法名（[参数列表]）；
留神：因为形象办法无奈确定具体执行的性能，所以形象办法没有办法体，须要在小括号后加上分号
抽象类的申明
语法：修饰符 abstract class 类名 extends 父类名
抽象类和一般类除了应用 abstract 润饰外和一般的类类似；
抽象类中能够没有形象办法；然而一旦某个有形象办法，那么这个类必须被申明为抽象类
static final private 不能和 abstract 共存
抽象类的应用：
因为抽象类不是一个具体的类，所以无奈实例化，然而抽象类能够用于申明变量；
抽象类能够被继承，在子类中实现所有抽象类的所有形象办法，以达到抽象类的具体化；
留神：因为形象办法无奈确定具体执行的性能，所有形象办法没有办法体，须要在小括号后加上分号；
形象办法：不容许蕴含办法体；子类中须要重写父类的形象办法，否则，子类也是抽象类
格局：
public abstract void eat（）；
形象办法：java 中能够定义一些不含办法体的办法，它的办法体的实现交给该类的子类依据本人的状况去实现。抽象类：蕴含形象办法的类叫抽象类。一个抽象类能够有一个或多个形象办法。
抽象类必须应用 abstract 修饰符来定义，形象办法也必须用 abstract 来润饰。抽象类不能被实例化，不能用 new 关键字去产生对象。形象办法只能申明，不能实现。含有形象办法的类必须被申明为抽象类, 抽象类的子类必须笼罩所有的形象办法后能力被实例化，否则这个子类还是个抽象类。
二. 接口
接口的概念：
接口为咱们提供了一种将接口与实现拆散的更加结构化的办法。接口是一个齐全的抽象类，它没有提供任何模式的具体实现，它容许创建者确定办法名，参数类表，返回类型没有任何办法体的办法。
接口被用来建设类与类之间的协定。接口类修饰符必须是 public，default（默认的，本包内有拜访权限）或者前边两个和 abstract 组合，接口也能够蕴含域，然而这些域隐士地是 public static final 类型的，所有接口域必须初始化值。接口中办法默认拜访级别都是 public，如果定义拜访级别小于 public，编译将不能通过。
接口是用来实现类间多重继承性能的构造. 接口不能实例化，即不能用 new 运算符创建对象。一个类通过应用关键字 implements 申明本人实现一个或多个接口。在类体中能够应用接口中定义的常量，而且必须实现接口中定义的所有办法 接口中的办法是主动私有的，在实现接口时必须把办法申明为 public。接口中的办法都是形象的。
一个接口能够继承另一个接口。
任何类（包含一般类，外部类，抽象类）能够实现一个接口。
接口的特色：
在 Java 中接口不仅仅是程序开发过程中“约定”，更是更加抽象化的抽象类
无奈归纳到一个类的但某些特色雷同
语法：
修饰符 interface 接口名{[常量]；[形象办法]；}
接口中形象办法能够不写 abstract 关键字，拜访修饰符默认 public
当类实现接口时，须要去实现接口中的所有形象办法，否则须要将该类设置为抽象类；
接口中能够蕴含常量，默认 public static final
接口也能够实现继承，并且能够继承多个父接口
接口的作用：
进步程序的重用性；进步程序的可扩展性；升高程序的耦合度；实现了多继承。
default：默认办法 能够带办法体 jdk1.8 后新增；能够在实现类中重写，并且能够通过接口的援用调用
static：静态方法 能够带办法体 jdk1.8 后新增；不能够在实现类中重写，能够通过接口名调用
三.外部类
什么是外部类？在 Java 中，能够将类定义在另一个类外面或者一个办法外面，这样的类称为外部类
定义：
在一个类外部定义类
外部类的写法:class 类名{} 它能够间接拜访和援用他的外部类的所有变量和办法，与外部类相比，外部类能够申明为 private 或 protected.
用 static 润饰一个外部类时（嵌套类），这个类相当于是一个内部定义的类，所以 static 的外部类中可申明 static 成员 static 外部类不能应用外部类的非 static 成员变量
函数的局部变量（形参也是局部变量），外部类的成员变量，外部类的成员变量重名，用以下形式来明确指定咱们真正要拜访的变量。
<pre spellcheck="false"
class="md-fences md-end-block ty-contain-cm modeLoaded"
lang="java" cid="n311"
mdtype="fences"
style="box-sizing: border-box; overflow: visible; font-family: var(--monospace); font-size: 0.9em; display: block; break-inside: avoid; text-align: left; white-space: normal; background-image: inherit; background-position: inherit; background-size: inherit; background-repeat: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: rgb(248, 248, 248); position: relative !important; border: 1px solid rgb(231, 234, 237); border-radius: 3px; padding: 8px 4px 6px; margin-bottom: 15px; margin-top: 15px; width: inherit; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">
public class Outer {
private int size;
class Inner {
private int size;
public void doStuff(int size) {
size++; // 援用的是 doStuff 函数的形参
this.size++; // 援用的是 Inner 类中的成员变量
Outer.this.size++; // 援用的 Outer 类中的成员变量
}
}
}</pre>
办法中定义外部类？
外部类并非只能在类里定义，也能够在几个程序块的范畴之内定义外部类。例如在办法或 for 循环体外部，均能够. 在办法中定义的外部类只能拜访办法中的 final 类型的局部变量。
<pre spellcheck="false"
class="md-fences md-end-block ty-contain-cm modeLoaded"
lang="java" cid="n362"
mdtype="fences"
style="box-sizing: border-box; overflow: visible; font-family: var(--monospace); font-size: 0.9em; display: block; break-inside: avoid; text-align: left; white-space: normal; background-image: inherit; background-position: inherit; background-size: inherit; background-repeat: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: rgb(248, 248, 248); position: relative !important; border: 1px solid rgb(231, 234, 237); border-radius: 3px; padding: 8px 4px 6px; margin-bottom: 15px; margin-top: 15px; width: inherit; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">
public void testClassInMethod(final String arg) {
class ClassInMethod {void test() {System.out.println(arg);
}
}
}</pre>
外部类如何被外部类援用？
外部类能够通过创建对象从外部类之外被调用，只有将外部类申明为 public
<pre spellcheck="false"
class="md-fences md-end-block ty-contain-cm modeLoaded"
lang="java" cid="n330"
mdtype="fences"
style="box-sizing: border-box; overflow: visible; font-family: var(--monospace); font-size: 0.9em; display: block; break-inside: avoid; text-align: left; white-space: normal; background-image: inherit; background-position: inherit; background-size: inherit; background-repeat: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: rgb(248, 248, 248); position: relative !important; border: 1px solid rgb(231, 234, 237); border-radius: 3px; padding: 8px 4px 6px; margin-bottom: 15px; margin-top: 15px; width: inherit; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">public class Outer {
private int size;
class Inner {
private int size;
public void doStuff(int size) {
size++; // 援用的是 doStuff 函数的形参
this.size++; // 援用的是 Inner 类中的成员变量
Outer.this.size++; // 援用的 Outer 类中的成员变量
}
}
public static void main(String[] args) {Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.doStuff(1);
}
}</pre>
外部 ` 类分类：
成员外部类：将一个类定义在另一个类的成员地位；获取外部类对象实例，
形式 1：new 外部类.new 外部类
形式 2：外部类对象.new 外部类
形式 3：外部类对象. 获取办法
1、外部类在内部应用时，无奈间接实例化，须要借由外部类信息能力实现实例化；
2、外部类的拜访修饰符，能够任意，然而拜访范畴会受到影响；
3、外部类能够间接拜访外部类的成员；如果呈现同名属性。优先拜访外部类中定义的；
4、能够应用外部类.this 成员的形式，拜访外部类中同名的信息；
5、外部类拜访外部类信息，须要通过外部类实例，无奈间接拜访；
6、外部类编译后.class 文件命名：外部类 $ 外部类.class；
7、外部类中是否能够蕴含与外部类雷同办法签名的办法
部分外部类：
将一个类定义在另一个类的办法体中或者代码块中；
1、定义在办法外部，作用范畴也在范畴内
2、和办法外部成员应用规定以用，class 后面不能够增加 public、private、protected、static
3、类中不能蕴含动态成员
4、类中能够蕴含 final，abstract 润饰的成员
动态外部类：
将一个类定义在另一个类的成员地位，并且 static 修饰符；
1、动态外部类中，只能间接拜访外部类的动态成员，如果须要调用非动态成员，能够通过对象实例
2、动态外部类对象实例时，能够不依赖于外部类对象
3、能够通过外部类. 外部类. 动态成员的形式，拜访外部类中的动态成员
4、当外部类属性与外部类属性同名时，默认调用外部类中的成员；如果须要拜访外部类中的动态属性，则能够通过外部类. 属性的形式；如果须要拜访外部类中的非动态属性，则能够通过 new 外部类（）. 属性的形式
匿名外部类：
匿名外部类没有名字
只须要为部分外部类建设一个对象，不用为该类指定一个名字。
<pre spellcheck="false"
class="md-fences md-end-block ty-contain-cm modeLoaded"
lang="java" cid="n293"
mdtype="fences"
style="box-sizing: border-box; overflow: visible; font-family: var(--monospace); font-size: 0.9em; display: block; break-inside: avoid; text-align: left; white-space: normal; background-image: inherit; background-position: inherit; background-size: inherit; background-repeat: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: rgb(248, 248, 248); position: relative !important; border: 1px solid rgb(231, 234, 237); border-radius: 3px; padding: 8px 4px 6px; margin-bottom: 15px; margin-top: 15px; width: inherit; color: rgb(51, 51, 51); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">
public Inner testAnonyClassInMethod() {return new Inner() { // 此处为一个匿名类定义，没有类名，意思为创立一个继承自 Inner 外部类的对象
@Override
public void doStuff(int size) {super.doStuff(size);
}
};
}</pre>
1、匿名外部类没有类型名称、实例对象名称
2、编译后的文件命名：外部类 $ 数字.class
3、无奈应用 private、public、protected、abstract、static 润饰
4、无奈编写构造方法，能够增加结构代码块
5、不能呈现动态成员
6、匿名外部类能够实现接口也能够继承父类，然而不能兼得
抽象类和接口的区别与分割?
一个类能够实现多个接口，而一个类只能继承一个抽象类。接口只定义方法，实现一个接口就是要实现接口的所有办法。而抽象类能够实现局部办法。多个无关的类能够实现同一个接口，一个类能够实现多个无关的接口