Java基础一一抽象类，接口，内部类的概念及用法

一.抽象类

抽象类的概念：

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、匿名内部类可以实现接口也可以继承父类，但是不能兼得

抽象类和接口的区别与联系?

一个类可以实现多个接口， 而一个类只能继承一个抽象类。 接口只定义方法，实现一个接口就是要实现接口的所有方法。而抽象类可以实现部分方法。 多个无关的类可以实现同一个接口，一个类可以实现多个无关的接口