JAVA学习笔记----接口、抽象类、内部类

来源：互联网发布：矩阵和伴随矩阵的秩编辑：程序博客网时间：2024/05/20 17:26

接口(interface)

从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。格式：interface 接口名{}

1.多个无关的类可以实现同一个接口

2. 一个类可以实现多个无关的接口（接口变相地实现了多继承）

3.与继承关系类似，接口与实现类之间存在多态性

4.接口可以继承其它的接口(一个接口可以继承多个接口，接口只能被接口继承、被类实现)，并添加新的属性和抽象方法。

接口中的成员修饰符是固定的。

成员常量：public static final

成员函数：public abstract

发现接口中的成员都是public的。

接口特点：

1.接口不可以创建对象

2.子类必须覆盖掉接口中所有的抽象方法之后，子类才可以实例化。

3.接口的出现避免了单继承的局限性。父类中定义的事物的基本功能。接口中定义的事物的扩展功能。

接口特征：

解决多继承的弊端，将多继承这种机制在JAVA中通过“多实现”完成。

弊端：多继承时，当多个父类中有相同功能时，子类调用会产生不确定性。

其实核心原因就是在于多继承父类中功能有主体，而导致调用运行时，不确定运行哪个主体内容。

为什么多实现就解决了呢？

因为接口中的功能都没有方法体，由子类来明确。

使用接口的原因：

1.为了能够向上转型为多个基类型，以及由此而带来的灵活性

2.防止客户端程序员创建该类的对象

抽象类：

1.在class前加上abstract的类就是抽象类，如：public abstract class A{};
2.用abstract关键字来修饰一个类时，这个类叫做抽象类；用abstract来修饰一个方法时，该方法叫做抽象方法(抽象方法没有方法体)。abstract修饰符只能修饰类或方法。

多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。

抽象类：用四个字就可以概括：有得有失。所谓“得”就是增加了一个可以包含抽象方法(由子类实现)的功能，所谓“失”就是不能创建实例，而其它的功能普通类有的抽象类都有(如：定义普通方法、初始化快、内部类等)，需要补充的是抽象类的构造器主要是提供其子类的构造器调用。含有抽象方法的类必须被声明为抽象类，类中可以没有抽象方法，但是抽象方法必须位于抽象类中！

使用抽象类的唯一途径是派生一个子类，如果这个子类实现了抽象类中所有的抽象方法，那么这个子类就是一个普通的类。它可以用来创建对象。如果不实现父类中的所有抽象方法，那么它也是一个抽象类，剩下的方法由它的子类实现。

抽象类和一般类的异同点：
相同：
1.它们都是用来描述事物的。
2.它们之间都可以定义属性和行为。
不同：
1.一般类可以具体的描述事物。抽象类描述事物的信息不具体。
2.抽象类中可以多定义一个成员：抽象函数
3.一般类可以创建对象，而抽象类不能创建对象。

抽象方法：使用abstract修饰，它没有方法体，而且它必须由子类重写，由于子类必须重写抽象父类的方法，所以abstract不能与final(有final修饰的方法，意味着不能被重写)同时出现，而且子类继承了(抽象)父类，意味着abstract不能与final同时出现；除此之外，abstract还不能与static、private(private意味着不能被子类访问)同时存在。注意子类要实现抽象类的所有抽象方法，否则子类也是抽象类。

抽象类与接口区别：

1.
接口是公开(public)的，里面不能有私有的方法或变量,是用于让别人使用的,实现接口的一定要实现接口里定义的所有方法。
而抽象类是可以有私有方法或私有变量的，实现抽象类可以有选择地重写需要用到的方法，但是必须实现里面所有的抽象方法。
2.
抽象类在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。
但是，一个类却可以实现多个interface(java中实现多重继承的方法之一)。
3.
抽象类中可以有自己的数据成员，也可以有非abstarct的成员方法。
而在接口中，只能够有静态的不能被修改的数据成员（也就是必须是 static final的，不过在 interface中一般不定义数据成员），而且所有的成员方法都是抽象的。
4.
抽象类和接口所反映出的设计理念不同。
其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。（组合是"has a"关系）
5.
接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。
抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。

抽象类是描述事物的基本功能，可以定义非抽象的方法。

接口中定义只能是抽象方法，负责功能的扩展。

内部类（Inner class）：

1.在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。内部类和外层封装它的类之间存在逻辑上的所属关系。

2.Inner class的名字不能与包含它的类名相同；

3.Inner class(除嵌套类外)拥有其外围类所有成员的访问权限。原因是：当某个外围类的对象创建了一个内部类对象的时，此内部类对象必定会秘密地捕获一个指向那个外围类对象的引用（至于怎样捕获，编译器会处理所有的细节）。在拥有外部类对象之前是不可能创建内部类对象的（除嵌套类外）。这是因为内部类对象会暗暗地连接到创建它的外部类对象上。

[java] view plain copy print?

public class Dot {
public class Inner{
public Dot outer(){
return Dot.this; //内部类生产对外部类的引用
}
}
public void f() {
System.out.println("Dot.f()");
}
public static void main(String[] args) {
Dot d = new Dot();
Dot.Inner di = d.new Inner(); //创建内部类对象
di.outer().f();
}
}

public class Dot {public class Inner{public Dot outer(){return Dot.this;  //内部类生产对外部类的引用}}public void f() {System.out.println("Dot.f()");}public static void main(String[] args) {Dot d = new Dot();Dot.Inner di = d.new Inner();  //创建内部类对象di.outer().f();}}

(1)局部内部类：在方法和作用域内的内部类

[java] view plain copy print?

public interface Destination {
String readLable();
}
public class Parcel4 {
public Destination dest(String s) {
class PDestination implements Destination { //局部内部类（在方法内部）
private String label;
private PDestination(String whereTo) {
label = whereTo;
}
public String readLable() {
return label;
}
}
return new PDestination(s);
}
public static void main(String[] args) {
Parcel4 p = new Parcel4();
Destination d = p.dest("Tanzania");
}
}

public interface Destination {String readLable();}public class Parcel4 {public Destination dest(String s) {class PDestination implements Destination {    //局部内部类（在方法内部）private String label;private PDestination(String whereTo) {label = whereTo;}public String readLable() {return label;}}return new PDestination(s);}public static void main(String[] args) {Parcel4 p = new Parcel4();Destination d = p.dest("Tanzania");}}

(2)匿名内部类：

[java] view plain copy print?

public interface Contents {
int value();
}
public class Parcel4 {
public Contents cont() {
return new Contents() { //匿名内部类
private int i = 11;
public int value() {
return i;
}
};
}
public static void main(String[] args) {
Parcel4 p = new Parcel4();
Contents c = p.cont();
}
}

public interface Contents {int value();}public class Parcel4 {public Contents cont() {return new Contents() {    //匿名内部类private int i = 11;public int value() {return i;}}; }public static void main(String[] args) {Parcel4 p = new Parcel4();Contents c = p.cont();}}

(3)嵌套类：声明为static的内部类

1.要创建嵌套类的对象，并不需要其外围类的对象

2.不能从嵌套类的对象中访问非静态的外围类对象

3.嵌套类可以作为接口的一部分。

[java] view plain copy print?

public interface Destination {
String readLable();
}
public class Parcel4 {
protected static class PDestination implements Destination { //嵌套类
private String label;
private PDestination(String whereTo) {
label = whereTo;
}
public String readLable() {
return label;
}
}
public static Destination dest(String s) { //嵌套类
return new PDestination(s);
}
}

public interface Destination {String readLable();}public class Parcel4 {protected static class PDestination implements Destination {   //嵌套类private String label;private PDestination(String whereTo) {label = whereTo;}public String readLable() {return label;}}public static Destination dest(String s) {    //嵌套类return new PDestination(s);}}

为什么需要内部类？

1.内部类提供了某种进入外围类的窗口

2.每个内部类都能独立的地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。

3.内部类使得多重继承的解决方案变得完整（外部类可包涵多个内部类，而内部类可以继承其它类）。

使用局部内部类而不使用匿名内部类的原因：

需要一个已命名的构造器，或者需要重载构造器，即是需要不止该内部类的对象。而匿名内部类只能用于实例初始化。

内部类特性：
1.Inner class可以声明为抽象类，因此可以被其它的内部类继承。也可以声明为final的。
2.和外层类不同，Inner class可以声明为private或protected；
3.Inner class 可以声明为static的，但此时就不能再使用外层封装类的非static的成员变量；
4.非static的内部类中的成员不能声明为static的，只有在顶层类或static的内部类中才可声明static成员；

内部类作用：
1.内部类可以很好的实现隐藏,也就是封装性。一般的非内部类，是不允许有 private 与protected权限的，但内部类可以
2.内部类拥有外围类的所有元素（包括静态成员）的访问权限。
3.可是实现多重继承
4.可以避免修改接口而实现同一个类中两种同名方法的调用。

0 0