继封装和继承之后，抽象类、接口和多态同样是面向对象编程的重点。
抽象类
抽象类：不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
抽象方法：抽象类和接口中具有的特殊方法，与一般方法相比，抽象方法只需要声明而不需要实现，但必须在子类中实现。static方法不能声明为抽象方法
使用方法：使用修饰符abstract声明一个抽象类，
一般具有抽象方法：abstract <类型> <方法名>(参数);使用目的：用于继承之后定义子类，必然会用于定义子类
特性：
1. 不能创建对象
2. 具有某个功能（抽象方法），但必须在子类中实现。子类继承抽象类之后，必须实现抽象方法，不然仍然为抽象类关系（与子类）：is-a ，和常规继承一样
NewsReader抽象类代码实例
public abstract class NewsReader {
// 和普通类一样，可以有成员变量
private Integer x;
// 和普通类一样，可以有一般方法
public Integer getX() {
return x;
}
public void setX(Integer x) {
this.x = x;
}
// 可以有构造方法
public NewsReader(){
System.out.println("NewsReader");
}
// 抽象方法
// 具有这个功能，但具体的功能实现，在子类中确定
public abstract void readNews();
}
继承抽象类的UrlNewsReader子类代码实例
public class UrlNewsReader extends NewsReader{
public UrlNewsReader(){
// 先调用抽象类父类构造方法
super();
System.out.println("UrlNewsReader");
}
// 必须实现的抽象方法
public void readNews(){
System.out.println("Url reading......");
}
}
测试代码
public class Main {
public static void main(String[] args) {
// 尝试创建NewsReader对象
// NewsReader newsReader = new NewsReader();
// error:'NewsReader' is abstract; cannot be instantiated
// 创建UrlNewsReader对象
UrlNewsReader urlNewsReader = new UrlNewsReader();
urlNewsReader.readNews();
}
}
测试结果
NewsReader
UrlNewsReader
Url reading......
- 总结：抽象类虽然不能创建对象，但可以有构造方法，并可以在子类中用super关键字调用
接口
接口：接口是一种抽象类型，是一系列抽象方法的集合，语义上表示某种功能（比如听说读写，但没有具体的实现）。一个类通过实现接口的方式，从而来实现接口的抽象方法。接口中的抽象方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
意义：把接口和实现真正分开
使用方法：用关键字interface声明接口，实现的类通过关键字implements表达实现一个接口，从而声明这个类具有接口定义的属性和行为
特性：
1. 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字
2. 接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字
3. 接口中的方法都是公有的，声明不需要public关键字（隐式的public abstract，其它修饰符会报错）与类的区别：
1. 接口不能用于实例化对象
2. 接口没有构造方法
3. 接口中所有的方法必须是抽象方法（没有实现）
4. 接口不能包含成员变量，除了隐式的public static final变量（其它修饰符都会报错），因为它不是类，不能实例化对象，所以不会有状态，只有属性
5. 接口不是被类继承了，而是要被类实现
6. 接口支持多实现，表示实现了多种功能
Displayable接口代码实例
public interface Displayable {
// 隐式public static final变量
int a = 1;
// 隐式public abstract方法
void display();
}
实现接口的News类代码
// News实现Displayable
public class News implements Displayable {
protected String title;
protected String content;
public News(){}
// 构造的自由和责任交给用户
public News(String title, String content) {
this.title = title;
this.content = content;
}
public String getTitle() {
return title;
}
public String getContent() {
return content;
}
//注解表示方法来自上一层，可以检查方法名和方法类型是否写错了
@Override
// 必须实现display(),且只能公有
public void display() {
System.out.println(title + "\n" + content);
}
}
测试代码
public class Main {
public static void main(String[] args) {
News news = new News("abc","def");
news.display();
}
}
测试结果
abc
def
-
问题：抽象类和接口的选择？
回答：语义上抽象类表示一类事物的特性，而接口表示类实现的功能，除了对两者特性的区分外，对抽象类和接口的选择，得先从预估的子类抽象出来的事物来看待。如果抽象出来的共同特征能归为一个类别，用抽象类合适，如果抽象出来的特征能归为一种功能，用接口合适。因此，实现同样的功能，写法不一样，表达的意思是不一样的。
例子：Content这样的抽象，更像是一种功能，而不是一类实物的抽象，用接口较好。
多态
多态：同一个行为具有多个不同表现形式或形态的能力
优点：
1. 消除类型间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性必要条件：
1. 继承
2. 重写
3. 父类引用指向子类对象实现方式：
1. 重写
2. 接口（接口可以看作一种被继承才能实现的父类）
3. 抽象类和抽象方法（抽象类必须作为父类来继承得以实现）
实例1
class Animal{
public void move(){
System.out.println("Animals can move");
}
}
// 继承
class Dog extends Animal{
// 重写
public void move(){
System.out.println("Dogs can walk and run");
}
public void bark(){
System.out.println("Dogs can bark");
}
}
public class Test{
public static void main(String args[]){
Animal a = new Animal(); // 父类引用指向父类对象
Animal b = new Dog(); // 父类引用指向子类对象
a.move();
b.move();
// Test.java:30: cannot find symbol symbol : method bark() location: class Animal b.bark();^
// Animal类没有bark()方法
// b.bark();
}
}
// 结果
Animals can move
Dogs can walk and run
- 总结：b是Animal类型，却运行了Dog类的方法，因为编译时会检查引用类型。在运行时，JVM 会判定对象类型到底属于哪一个对象。因此，在上面的例子中，虽然 Animal有move()方法，程序会正常编译。在运行时，会运行特定对象的方法。（按Animal编译，按Dog运行）
实例2
public class Employee {
private String name;
private String address;
private int number;
public Employee(String name, String address, int number) {
System.out.println("Employee 构造函数");
this.name = name;
this.address = address;
this.number = number;
}
public void mailCheck() {
System.out.println("邮寄支票给： " + this.name + " " + this.address);
}
public String getName() {
return name;
}
...
}
public class Salary extends Employee {
private double salary; // 全年工资
public Salary(String name, String address, int number, double salary) {
super(name, address, number);
setSalary(salary);
}
public void mailCheck() {
System.out.println("Salary 类的 mailCheck 方法 ");
System.out.println("邮寄支票给：" + getName() + " ，工资为：" + salary);
}
...
}
public class VirtualDemo {
public static void main(String [] args) {
Salary s = new Salary("员工 A", "北京", 3, 3600.00); // 子类引用指向子类对象
Employee e = new Salary("员工 B", "上海", 2, 2400.00); // 父类引用指向子类对象
System.out.println("使用 Salary 的引用调用 mailCheck -- ");
s.mailCheck();
System.out.println("\n使用 Employee 的引用调用 mailCheck--");
e.mailCheck();
}
}
//结果
Employee 构造函数
Employee 构造函数
使用 Salary 的引用调用 mailCheck --
Salary 类的 mailCheck 方法
邮寄支票给：员工 A ，工资为：3600.0
使用 Employee 的引用调用 mailCheck--
Salary 类的 mailCheck 方法
邮寄支票给：员工 B ，工资为：2400.0
- 注：子类引用不可以指向父类对象
实例3
News的子类UrlNews代码
为简洁，Displayable接口及实现接口的News类代码已在上面提及，不再重复展示
public class UrlNews extends News{
private String url;
// 缺省构造函数，默认调用super()
public UrlNews() {}
// 含参构造函数
public UrlNews(String title, String content, String url) {
super(title,content);
this.url = url;
}
public String getUrl() {
return url;
}
// 重写
@Override
public void display() {
System.out.println("News from Url:" + url);
super.display();
}
}
测试代码
NewsReader抽象类及其UrlNewsReader子类代码已在上面提及，不再重复展示
public class Main {
public static void main(String[] args) throws IOException {
// 父类引用指向父类对象
News news = new News("abc","父类");
// 父类引用指向子类对象
News urlnews = new UrlNews("ABC","子类", "class.com");
news.display();
urlnews.display();
// 实现接口的子类可以放入接口参数
viewNews(news);
viewNews(urlnews);
// 接口引用指向子类对象
Displayable displayable = new UrlNews("abc","def","ghi");
displayable.display();
// 抽象类引用指向子类对象
NewsReader newsReader = new UrlNewsReader();
newsReader.readNews();
}
private static void viewNews(Displayable item) {
item.display();
System.out.println("播放完毕");
}
}
测试结果
abc // news.display();
父类
News from Url:class.com // urlnews.display();
ABC
子类
abc // viewNews(news);
父类
播放完毕
News from Url:class.com // viewNews(urlnews);
ABC
子类
播放完毕
News from Url:ghi // displayable.display();
abc
def
NewsReader // NewsReader newsReader = new UrlNewsReader();
UrlNewsReader
Url reading...... // newsReader.readNews();
-
多态的好处：利用了动态传参，可以避免很多重复代码
例如：在Main中定义read()方法，根据多态的原则，可以按如下方法定义:
private static void read(News news) {
news.display();
}
如果没有多态，则需要将News类的子类的read()方法全部定义一遍：
private static void read(UrlNews urlNews) {
urlNews.display();
}
// FileNews是News的子类时且display()方法有重写时
private static void read(FileNews fileNews) {
fileNews.display();
}
当News的子类很多时，在Main中就要写很多重复代码，浪费资源，且不方便维护。
