Java面向对象(2)

一. Java抽象类

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都可以用来描绘对象。如果一个类中没用足够的信息用来实例化对象，那么这个类就叫做抽象类。
抽象类必须被继承才能被使用。
抽象类除了不能实例化之外，类的其他功能依然存在。

1.1 抽象类

使用abstract来定义抽象类：

[可见度] abstract class 类名{

}

1.2 继承抽象类

我们能通过一般的方法来继承抽象类，即使用extends关键字：
public class Salary extends Employee

1.3 抽象方法

抽象方法的实现由子类完成。
使用关键字abstract来声明抽象方法。
抽象方法没有方法体，方法名后面直接跟分号，而不是花括号。

public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
   
   //其余代码
}

声明抽象方法会造成以下两个结果：

如果一个类拥有抽象方法，那么该类必须是抽象类。
子类必须重写父类的抽象方法，除非子类自身也是抽象类

二. Java接口（Interface）

接口在Java中是一种抽象类型，是抽象方法的集合。
一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口与类相似点：

一个接口可以拥有多个方法；
接口保存在 .java结尾的文件中，文件名使用接口名；
接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别

接口支持多继承；
接口没有构造方法；
接口不能用于实例化对象；
接口中的方法全部为抽象方法；
接口不是被类继承了，而是要被类实现；
接口不能包含成员变量，除了 static 和 final 变量。

2.1 接口的声明

使用关键字interface来声明接口：

[可见度] interface 接口名 [extends 其他接口名]{
//声明变量
//抽象方法
}

接口特性

接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
实例

interface Animal {
   public void eat();
   public void travel();
}

2.2 接口的实现

当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。
类使用implements关键字来实现接口，implements关键字放在类名后面。
...implements 接口名称 [,其他接口名称，...]

实例

public class ImpDemo implements Animal{
public void eat{
  System.out.println("can eat")；
}
public void travel{
  System.out.println("can travel")；
}
public static void main(String[] args){
  ImpDemo imp = new ImpDemo();
  imp.eat;
imp.travel;
}
}

2.3 接口的多继承

在Java中，类的多继承是不合法，但接口允许多继承。
在接口的多继承中extends关键字只需要使用一次，在其后跟着继承接口。如下所示：
public interface Hockey extends Sports, Event
以上的程序片段是合法定义的子接口，与类不同的是，接口允许多继承，而 Sports及 Event 可能定义或是继承相同的方法

三. Java 多态

多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作。

多态的优点

消除类型之间的耦合关系
可替换性
可扩充性
接口性
灵活性
简化性

多态存在的三个必要条件

继承
重写
父类引用指向子类对象

多态的实现方式

重写
接口
抽象类和抽象方法

实例

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

运行结果

吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠