面向对象进阶：抽象类、接口、静态字段和方法

抽象类

为什么有抽象类？

当父类的某些方法，需要声明，但又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类。（抽象类包含：具体的方法+抽象的方法（可以没有））

例如：
如果父类的方法本身不需要实现任何功能，仅仅是为了定义方法签名，目的是让子类去覆写它，那么，可以把父类的方法声明为抽象方法：

class Person {
    public abstract void run();
}

把一个方法声明为abstract，表示它是一个抽象方法，本身没有实现任何方法语句。因为这个抽象方法本身是无法执行的，所以，Person类也无法被实例化。编译器会告诉我们，无法编译Person类，因为它包含抽象方法。
必须把Person类本身也声明为abstract，才能正确编译它：

abstract class Person {
    public abstract void run();
}

抽象类的介绍

抽象：不具体的，不能使用的

抽象类的使用注意

1)抽象类不能被实例化[举例]；
2)抽象类不一 定要包含abstract方法。 也就是说,抽象类可以没有abstract方法[举例]；
3)一旦类包含了abstract方法,则这个类必须声明为abstract [说明]；
4) abstract只能修饰类和方法，不能修饰属性和其它的。[说明]
5）抽象类本质还是类，不能一种不能被实例化，只能被继承的类。所以类里面有的属性、构造器、非抽象方法等，抽象类都有
总之：抽象类在内容上允许有抽象方法的添加；在使用上，不能想 类一样被实例化

public classAbstractDetail01 {
public static void main(String[] args) {
//抽象类，不能被实例化
//newA();
}
}
//抽象类不一定要包含 abstract 方法。也就是说,抽象类可以没有 abstract 方法
//，还可以有实现的方法。
abstract classA{
public void hi() {
System.out.println("hi");
}
}
//一旦类包含了 abstract 方法,则这个类必须声明为 abstract
abstract class B {
public abstract void hi();
}
//abstract 只能修饰类和方法，不能修饰属性和其它的
class C {
// public abstract int n1 = 1;
}

面向抽象编程

当我们定义了抽象类Person，以及具体的Student、Teacher子类的时候，我们可以通过抽象类Person类型去引用具体的子类的实例：

Person s = new Student();
Person t = new Teacher();

这种引用抽象类的好处在于，我们对其进行方法调用，并不关心Person类型变量的具体子类型：

// 不关心Person变量的具体子类型:
s.run();
t.run();

同样的代码，如果引用的是一个新的子类，我们仍然不关心具体类型：

// 同样不关心新的子类是如何实现run()方法的：
Person e = new Employee();
e.run();

这种尽量引用高层类型，避免引用实际子类型的方式，称之为面向抽象编程。
面向抽象编程的本质就是：
上层代码只定义规范（例如：abstract class Person）；
不需要子类就可以实现业务逻辑（正常编译）；
具体的业务逻辑由不同的子类实现，调用者并不关心。

抽象类最佳实践-模板设计模式

接口

接口的由来

在抽象类中，抽象方法本质上是定义接口规范：即规定高层类的接口，从而保证所有子类都有相同的接口实现，这样，多态就能发挥出威力。
如果一个抽象类没有字段，所有方法全部都是抽象方法，就可以把该抽象类改写为接口：interface。

abstract class Person {
    public abstract void run();
    public abstract String getName();
}

//抽象类无属性，只有抽象方法---->>>>>接口
interface Person {
    void run();
    String getName();
}

接口的使用

1.接口里全部是规范好的没有实现的方法

public interface UsbInterface { //接口
//规定接口的相关方法,老师规定的.即规范...
public void start();//只能是public 
void stop();//或者默认
}

2.某个类要使用的时候要根据情况把这些方法写(实现)出来

/Phone 类 实现 UsbInterface
//解读 1. 即 Phone 类需要实现 UsbInterface 接口 规定/声明的方法
public class Phone implements UsbInterface {
@Override
public void start() {
System.out.println("手机开始工作...");
}
@Override
public void stop() {
System.out.println("手机停止工作.....");
}
}

3.接口中所有的方法是 public 方法, 接口中抽象方法，可以不用 abstract 修饰

4.一个普通类实现接口,就必须将该接口的所有方法都实现,可以使用 alt+enter 来解决

5.一个类可以同时实现多个接口

6.接口不能继承其他类但是可以继承多个别的接口
interface A extends B，C｛｝

为什么使用接口

在公司开发团队中，项目经理只需要在接口里规范好没实现的方法，然后交给各个程序员去实现这些方法。这样，
既保证了方法的规范性和统一性，也便于顶层设计者的程序开发。
同时，体现了高内聚低耦合的设计思想。

抽象类和接口的对比

内容上：
使用上不同：抽象类不能实例化，只能被继承；

                接口与类的关系是：类可以实现接口，也可以实现多个接口；
                接口与接口之间;接口可以继承接口，也可以继承多个接口

静态字段和静态方法（static关键字）

静态字段：是用static修饰的字段；
实例字段在每个实例中都有自己的一个独立“空间”，但是静态字段只有一个共享“空间”，所有实例都会共享该字段。
静态字段属于所有实例“共享”的字段，实际上是属于class的字段；

静态方法：用static修饰的方法称为静态方法。
调用实例方法必须通过一个实例变量，而调用静态方法则不需要实例变量，通过类名就可以调用。

public class Main {
    public static void main(String[] args) {
        Person.setNumber(99);
        System.out.println(Person.number);
    }
}

class Person {
    public static int number;

    public static void setNumber(int value) {
        number = value;
    }
}