1.1 什么是接口
接口是一种引用数据类型。使用interface声明接口，形式
| public interface 接口名称{ } |
1.1.1 接口的特性
[1] 接口中可以声明属性(C)。接口中定义的所有变量都是static final类型的。
| public interface MyInterface { public static final String version = "1.0"; public int count = 10; // 默认是static final类型 } |
一般很少在接口中声明属性。
[2] (C)接口中的方法都是公共抽象方法。
| public interface MyInterface { public abstract void showInfo(); void showInfo3(); // 推荐写法 public void showInfo2(); } |
[3] (C)接口不能拥有构造方法，不能用于创建对象
[4] 接口可以多继承。一个接口可以继承多个其他接口(B)
| public interface CInterface extends AInterface, BInterface { } |
CInterface接口就具备了A、B接口中定义的抽象方法。
[5] (A) 一个类可以实现一个或者多个接口，该类称为接口的实现类(implement class).
实现类必须实现接口中的所有(抽象)方法
| public class ImplClassA implements AInterface,BInterface{ @Override public void showInfoA() { System.out.println("实现接口中的showInfoA"); } @Override public void showInfoB() { System.out.println("实现接口中的showInfoB"); } } |
一个类只能继承一个父类，同时实现多个接口。继承在前，实现在后。
| public class ImplClass3 extends AbsClass implements AInterface,BInterface{ @Override public void showInfoA() { // TODO Auto-generated method stub } @Override public void showInfoB() { // TODO Auto-generated method stub } @Override public void showInfoC() { // TODO Auto-generated method stub } } |
特殊情况:
如果一个抽象父类定义了和接口同名的抽象方法，实现类实现的是抽象父类的抽象方法。
| package cn.interface02; public class ImplClass4 extends AbsClass implements CInterface{ @Override public void showInfoA() { // TODO Auto-generated method stub } @Override public void showInfoB() { // TODO Auto-generated method stub } @Override public void showInfoC() { // TODO Auto-generated method stub } } |
总结:
实现类实现接口，必须实现接口中定义的抽象方法。
ð 方法即行为，表示一种功能
接口定义了一套功能，实现类必须实现这些功能 –> 实现类的能力得到拓展。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
接口与类的区别：
1:接口不能用于实例化对象。
2:接口没有构造方法。
3:接口中所有的方法必须是抽象方法。
4:接口不能包含成员变量，除了 static 和 final 变量。
5:接口不是被类继承了，而是要被类实现。
6:接口支持多继承。
1.2 接口的应用
1.2.1 面向接口编程(A)
接口表示一种约定(协议),约定(规范)了实现类应该具备(has a)的能力。
理解:
=>实现类必须实现接口中所有的方法，所以接口规范了实现类的行为
=> 接口约定了实现类应该具备的行为。
面向接口编程
所谓面向接口编程，在程序设计时，只关心实现类具备什么能力，而不关心实现类如何实现这个能力。面向接口编程时，面向接口的约定而不考虑接口的具体实现。
也就是说，面向接口编程时，接口的定义方只关系实现类是否具备接口所定义的能力，而实现类如何被的该能力接口定义方一点都不关心。
| package cn.sxt.interface06; public class Writer { // 预留墨盒接口 private InkBoxInterface inkBoxInterface; // 预留纸张接口 private PaperInterface paperInterface; public InkBoxInterface getInkBoxInterface() { return inkBoxInterface; } public void setInkBoxInterface(InkBoxInterface inkBoxInterface) { this.inkBoxInterface = inkBoxInterface; } public PaperInterface getPaperInterface() { return paperInterface; } public void setPaperInterface(PaperInterface paperInterface) { this.paperInterface = paperInterface; } public Writer(InkBoxInterface inkBoxInterface, PaperInterface paperInterface) { super(); this.inkBoxInterface = inkBoxInterface; this.paperInterface = paperInterface; } public Writer() { super(); } public void print(String content) { System.out.println("打印机正在使用"+this.inkBoxInterface.getColor()+"颜色打印"+this.paperInterface.getSize()+"打印"+content); } }
|
1.2.2 抽象类和接口的异同比较
- 抽象类和接口都是引用数据类型，他们都不能创建对象。
- 他们都可以定义抽象方法，都可以实现多态。但是抽象类可以定义非抽象方法，而接口中定义的都是抽象方法。
- 抽象类和接口都具有传递性。抽象类是单根性（单继承），而接口是多继承。
- 在概念上，都可以重写抽象方法。子类重写抽象类，实现类实现接口
抽象类和子类解决的是模块内的问题（代码重用,重写,多态）而接口解决的是模块间的问题 => 高内聚，低耦合。接口可以用解耦模块。
1.3 Object
Object 类是所有类的根类。
如果一个类没有显示继承另外一个类，那么该类一定继承于Object。
toString() 返回对象的字符串表示形式
| public class Test01 { public static void main(String[] args) { Object obj = new Object(); // 输出对象时，默认调用toString方法 System.out.println(obj); // 类型@内存地址 System.out.println(obj.toString()); Student s1 = new Student("二狗",20); System.out.println(s1); } } |
equals(Object obj) 用于判断两个对象是否相等。
== 比较两个对象的内存地址或基本数据类型的比较，object默认equals实现比较内存地址。
equals:用于比较两个对象的内容(属性)是否相等。
当自定义对象时，要比较自定义对象是否相等，就必须通过equals方法比较两个对象属性值是否相等，那就必须重写Object的equals方法。
| @Override public boolean equals(Object obj) { if(this == obj) { return true; } Student s = (Student) obj; if(this.sid.equals(s.sid) && this.name.equals(s.name) && this.age == s.age) { return true; }else { return false; } } |
1.4 内部类
在java中，一个文件可以定义多个类，文件名必须和public 类型的类的类名保持一致。这两个类是平行关系。
在java中，一个类也可以定义在一个类的内部，定义在内部的类称为内部类(inner class)，定义在外部的类称为外部类(out class).
| public class Outer { [修饰符] class Inner{ } } |
1.4.1 成员内部类
一个内部类作为一个外部类的成员而存在，此时该内部类称为外部类的成员内部类。
| public class Outer { class Inner{ } } |
一般而言，内部类都用默认修饰符。
[1]内部类如何创建对象
|
[2] 内部类中可以访问外部类的私有变量
| public class Outer { private String name = "Outer"; class Inner{ public void showInfo() { System.out.println(name); } } } |
特殊情况:外部类和内部类的变量同名
| public class Outer { private String name = "Outer"; class Inner{ private String name = "Inner"; public void showInfo() { // String name = "show info"; // 访问外部类的私有成员 System.out.println(this.name); // 访问外部类的私有成员 System.out.println(Outer.this.name); } } } |