抽象类和抽象方法
抽象方法
在方法前面添加了一个关键字 abstract
抽象方法的特点
（1）抽象方法是没有方法体的。
（2）抽象方法必须得要定义在抽象类 或 接口当中 （在类前面添加上了一个abstract 就成为了抽象类）
（3）抽象方法不能是私有的（private），不能使用 final 和 static 修饰。
抽象类
在类前面添加了一个关键字 abstract
抽象类必须得要有子类才行。（抽象类一般都当作父类来继承）
抽象类当中的注意点
（1）抽象类是不能直接创建对象的。（不能通过new来实例化）
（2）抽象类当中，可以有抽象方法 ，也可以有非抽象方法（普通方法：给子类调用的）
（3）子类要去覆盖抽象方法方法，子类如果没有去覆盖抽象方法 ，也可以把子类也变成抽象类。让孙类去覆盖抽象方法。
（4）构造方法不能定义为私有化（抽象方法必须得要让子类继承之后，才能实现内部的方法体。子类继承的话，先去调用父类的构造方法）
（5）抽象类不能使用 final 来去修饰。
抽象类与普通类的区别
（1）普通类有的（方法，字段，构造器），抽象类都有。
（2）普通类可以创建对象，抽象类不能创建对象。
（3）抽象类可以包含抽象方法，也可以包含非抽象方法。
（4）抽象类必须有子类才有意义。
接口
什么是接口
硬件接口：指的是两个硬件设备之间的连接方式。硬件接口既包括物理上的接口（比如我们所以说的USB接口），还包括逻辑上的数据传送协议。
在Java中，接口表示一种规范/约束，要求实现者必须遵循该规范，用来约束使用者应该怎么做。使用抽象方法来去定义一组功能，必须要实现者提供方法的实现。
接口的好处
接口只定义了类应当遵循的规范，却不关心这些类的内部数据和其功能的实现细节。站在程序角度上说接口只规定了类里必须提供的方法，从而分离了规范和实现，增强了系统的可拓展性和可维护性。
接口的定义
类的定义：
class 类名｛
｝
接口的定义：
interface 接口名称｛
｝
接口也会生成对应的字节码
接口是一个特殊的抽象类
接口其实是一个特殊的抽象类，使用抽象方法来去定义一组功能，必须要实现者提供方法的实现。
内部的 abstract 可以省略不写，如果没有在方法前面添加 abstract，会在编译时自动的添加上。
void test();
反编译后：
public abstract void test();
接口当中的注意点
（1）接口是没有构造器，接口不能创建对象；抽象类是有构造器的，但是不能创建对象。
（2）接口当中定义变量，都是全局的静态常量
String name = "myxq";
反编译后：
public static final String name = "myxq";
（3）接口当中 定义的方法 都是公共的抽象的方法
void test();
反编译后：
public abstract void test();
（4）接口当中可以定义内部类，内部类也是公共抽象（public static class）
（5）接口是可以继承，它是可以多继承；类是不能多继承。
接口的继承
接口是可以继承，它是可多继承；类是不能多继承。
interface 接口名称 extends 被继承的接口名, 被继承的接口名 {
}
接口继承的时候，不会去覆盖父接口的方法。接口的方法都没有方法体，覆盖父接口的方法没有意义。
接口的实现
类名 extends 其它的类（只能继承一个类） implements 接口名（接口可以实现多个）｛
｝
在实现类当中必须得要去覆盖接口当中定义的方法， 实现的方法必须得是 public 修饰。
实现关系有时候也可以理解是继承关系。实现就可以看作子类覆盖父类（接口）的方法。覆盖的时候，子类的方法权限要比父类大，或者一样大，不能比它小，而接口的权限是 public，所以实现的方法必须得是 public 修饰。
// 爬行动物规范
interface Iwalkable {
void walk();
// public abstract void walk();
}
class Animal {
String name;
String Color;
}
class Cat extends Animal implements Iwalkable {
// 覆盖的时候，子类的方法权限要比父类大，或者一样大，不能比它小
public void walk() {
System.out.println("走猫步");
}
}
public class Test {
public static void main(String[] args) {
// 多态写法，把子类对象赋值给父类（接口）类型
Iwalkable cat = new Cat(); // 面向接口编程
// 多态运行时表现出来的还是子类的特征 （编译时，看左边，运行时，看右边）
cat.walk();
}
}
接口与抽象类的区别
（1）相同点
- 都是被其它类实现或者被继承
- 都不能实例化
- 都可以定义抽象方法 ，定义的抽象方法子类都必须得要覆盖。
（2）不同点
- 接口是没有构造器；抽象类当中是有构造器。
- 抽象类可以包含普通方法和抽象方法；接口当中只能有抽象方法，不能有普通方法（带有方法体）
- 接口当中默认成员变量，public static final 变量;-> 静态常量；抽象类当中是默认的权限
- 接口当中默认方法，public abstract 方法名；抽象类当中是默认的权限
面向接口编程
什么是面向接口编程
把实现类对象赋值给接口类型的变量
面向接口编程的好处
就是多态的好处：屏蔽了不同类之间实现差异，从而达到通用编程
实例
interface IUSB {
void swapData();
}
// 主板
class MotherBoard {
void pluginIn(IUSB u) {
u.swapData();
}
}
// 键盘
class KeyBoard implements IUSB {
public void swapData() {
System.out.println("打字");
}
}
// 鼠标
class Mouse implements IUSB {
public void swapData() {
System.out.println("鼠标移动");
}
}
public class Test {
public static void main(String[] args) {
IUSB m = new Mouse();
IUSB k = new KeyBoard();
MotherBoard b = new MotherBoard();
b.pluginIn(m);
b.pluginIn(k);
}
}
内部类
什么是内部类
定义在类当中的一个类
class Outter { // 外部类
String name = "myxq";
// 内部类
class Innner {
void test() {
System.out.println(name);
}
}
}
内部类可以直接访问外部类当中的成员（字段、方法、内部类）
为什么要使用内部类
（1）增强封装，把内部类隐藏在外部类当中，不允许其它类访问这个内部类
（2）增加了代码一个维护性
内部类的划分
内部类可以分为四种
（1）实例内部类：直接定义在类当中的一个类，在类前面没有任何一个修饰符
（2）静态内部类：在内部类前面加上一个static
（3）局部内部类：定义在方法的内部类
（4）匿名内部类：属于局部内部的一种特殊情况
提示：外部类的修饰符只能有两个， public 或者是 默认修饰；内部类可以使用很多个修饰符。
实例内部类
实例内部类：属于对象的内部类，不属于类的，不使用static修饰的内部类。它是直接定义在类当中的一个类，在类前面没有任何一个修饰符。
class Outter {
String name = "myxq";
class Inner {
void test() {
System.out.println(name);
}
}
}
实例内部类的创建
想要使用实例内部类，必须得要先创建外部类
Outter out = new Outter();
// 创建实例内部类
// 创建内部类对象当中，会有一个外部类的引用
Outter.Inner in = out.new Inner();
创建内部类对象当中，会有一个外部类的引用
反编译后：
class Outter$Inner
{
final Outter this$0;
void test()
{
System.out.println(name);
}
Outter$Inner()
{
this$0 = Outter.this;
super();
}
}
实例内部类注意点
（1）想要使用内部类，必须得要先创建外部类
Outter.Inner in = out.new Inner();
（2）在内部类当中可以访问外部类当中的成员
（3）在内部类当中，不能有静态的成员
（4）外部类是不能直接访问内部当中的成员
变量的访问
就近原则
class Outter {
String name = "Outername";
class Inner {
int age = 10;
String name = "inname";
void test() {
String name = "testname";
System.out.println(name);
System.out.println(this.name);
System.out.println(Outter.this.name);
}
}
}
public class Test {
public static void main(String[] args) {
Outter out = new Outter();
Outter.Inner in = out.new Inner();
in.test();
}
}
静态内部类
静态内部类：在内部类前面加上static，属于类的内部类。
class Outter {
static class Inner {
void test() {
System.out.println("test");
}
}
}
静态内部类的创建
不需要创建外部类对象
Outter.Inner in = new Outter.Inner();
in.test();
在静态内部类当中没有外部类的引用。因为它属于类，直接使用类调用即可
反编译后：
static class Outter$Inner
{
void test()
{
System.out.println("test");
}
Outter$Inner()
{
}
}
静态内部类注意点
（1）静态内部类是不需要创建外部对象
Outter.Inner in = new Outter.Inner();
in.test();
（2）在静态内部类当中 ，是没有外部类引用
（3）静态内部类，是可以访问外部类的静态成员，也可以访问外部类的普通变量。
class Outter{
static String name = "myxq";
static class Inner{
void test() {
System.out.println(name);
System.out.println(Outter.name);
}
}
}
（4）访问静态内部类当中的静态成员
class Outter {
static class Inner {
static String color = "black";
}
}
public class Test {
public static void main(String[] args) {
System.out.println(Outter.Inner.color);
}
}
（5）静态内部当中可以定义静态成员，也可以定义非静态成员
静态内部类当中访问外部类的普通变量
class Outter {
static String name = "myxq";
int age = 10;
static class Inner {
void test() {
System.out.println(name);
System.out.println(new Outter().age);
}
}
}
public class Test {
public static void main(String[] args) {
// 创建静态内部类
Outter.Inner in = new Outter.Inner();
in.test();
}
}
局部内部类
局部内部类：定义在方法当中的内部类。
class Outter {
void myxq() {
String name = "myxq";
class Inner {
void test() {
System.out.println(name);
}
}
Inner in = new Inner();
in.test();
}
}
局部内部类注意点
（1）不能使用一些修饰 public private ...
（2）局部内部只能在定义的方法当中使用
（3）局部内部类当中是不能包含静态变量
（4）局部内部类当中可以包含局部变量，使用的局部变量的本质是final（常量）
class Outter {
void myxq() {
String name = "myxq";
class Inner {
int age = 10;
void test() {
System.out.println(name);
System.out.println(age);
}
}
Inner in = new Inner();
in.test();
}
}
反编译后：
class Outter$1Inner
{
int age;
final Outter this$0;
private final String val$name;
void test()
{
System.out.println(val$name);
System.out.println(age);
}
Outter$1Inner()
{
this$0 = final_outter;
val$name = String.this;
super();
age = 10;
}
}
匿名内部类
匿名内部类：就是一个没有名字的局部内部类。
只使用一次的时候，使用匿名内部类。匿名内部类必须要有父类或者是有要实现的接口。
匿名内部类是没有构造器。
格式：
new 父类的构造器 或 接口() {
内部写的代码（在new时候就会自动执行）
}
实例：
没有使用匿名内部类前：一个类对应一个文件。
interface IUSB {
void swapData();
}
class MotherBoard {
void pluginIn(IUSB u) {
u.swapData();
}
}
class Printer implements IUSB {
public void swapData() {
System.out.println("打印工作");
}
}
class KeyBoard implements IUSB {
public void swapData() {
System.out.println("打字");
}
}
class Mouse implements IUSB {
public void swapData() {
System.out.println("鼠标移动");
}
}
public class Test {
public static void main(String[] args) {
IUSB m = new Mouse();
IUSB k = new KeyBoard();
Printer p = new Printer();
MotherBoard b = new MotherBoard();
b.pluginIn(m);
b.pluginIn(k);
b.pluginIn(p);
}
}
使用匿名内部类后：
interface IUSB {
void swapData();
}
class MotherBoard {
void pluginIn(IUSB u) {
u.swapData();
}
}
public class Test {
public static void main(String[] args) {
MotherBoard b = new MotherBoard();
b.pluginIn(new IUSB() {
public void swapData() {
System.out.println("鼠标移动");
}
});
b.pluginIn(new IUSB() {
public void swapData() {
System.out.println("打字");
}
});
b.pluginIn(new IUSB() {
public void swapData() {
System.out.println("打印工作");
}
});
}
}