关于java: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、匿名外部类能够实现接口也能够继承父类，然而不能兼得

抽象类和接口的区别与分割?

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