抽象类

一：引入

abstract class Animal { 
    private String name;
    public Animal(String name) { 
        this.name = name;
    }
    //父类方法的不确定性
    public void eat() { 
        System.out.println("这是一个动物，但是不知道吃什么..");
    }
}

• 考虑将该方法设计为抽象方 ( abstract ) 法
• 所谓抽象方法就是没有实现的方法
• 当一个类中存在抽象方法时，需要将该类声明为 ( abstract ) 类

• 一般来书哦，抽象类会被继承，有其子类来实现抽象方法

  二：基本介绍

  当父类的一些方法不能确定时,可以用abstract关键字来修饰该方法，这个方法就是抽象方法,用abstract来修饰该类就是抽象类。

  abstract class Animal{
    public abstract void eat();
  }
  class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("小猫吃饭");
    }
  }

1. 用abstract关键字来修饰一个类时，这个类就叫抽象类
   1. 访问修饰符 abstract 类名 { }
2. 用abstract关键字来修饰一个方法时,这个方法就是抽象方法
   1. 访问修饰符 abstract 返回类型 方法名 ( 参数列表 ) ; // 没有方法体
3. 抽象类的价值更多作用是在于设计,是设计者设计好后，让子类继承并实现抽象类()
4. 抽象类中，框架和设计模式使用较多

   三：注意事项和细节

• 抽象对象不能被实例化

  public static void main(String[] args) {
    new Animal();//不能实例化对象        
  }
  abstract class Animal{
    public abstract void eat();
  }

• 抽象类不一定要包含abstract方法，抽象类克没有abstract方法

  abstract class Animal{
    public abstract void eat();
    //抽象类中也可以有正常方法
    public void speak(){
        System.out.println("说话");
    }
  }

• 一旦包含abstract方法，则这个类必须声明为abstract类 ```java abstract class Animal{ //有抽象方法就要声明成抽象类 public abstract void eat();

}

- abstract只能修饰类和方法，不能修饰其它属性
```java
abstract class Animal{
    public abstract void eat();
}

• 抽象类可以有任意成员【抽象类本质还是类】，比如:非抽象方法、构造器、静态属性等等

  abstract class Animal{
    public int n = 10;
    public static String nane =  "sakura";
    public void hi(){
        System.out.println("hi");
    }
    public static void ok(){
        System.ou.println("ok")
    }
  }

• 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法,除非它自己也声明为abstract类。[举例A类,B类,C类]

  abstract class Animal{
    public abstract void eat();
    public abstract void walk();
  }
  class Cat extends Animal{
    //必须实现父类的所有抽抽象方法
    @Override
    public void eat() {
        System.out.println("小猫吃饭");
    }
    @Override
    public void walk() {
    }
  }

  四：练习

  1：

  

  五：抽象类最佳

  实践－模板设计模式

  1：基本介绍

  抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造,但子类总体上会保留抽象类的行为方式。

  2：模板设计模式能解决的问题

1. 当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
2. 编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式.

public class Test0813 {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.WorkingTime();//先去父类找，父类没有去抽象类里寻找
        BB bb = new BB();
        bb.WorkingTime();
    }
}

abstract public class Temple {
    abstract public void Job();
    public void WorkingTime(){
        long start = System.currentTimeMillis();
        Job(); //动态绑定机制
        long end = System.currentTimeMillis();
        System.out.println("执行时间：" + (end - start));
    }
}

public class AA extends Temple{
    @Override
    public void Job(){
        long sum = 0;
        for (long i = 0; i < 1000000000; i++) {
            sum+=i;
        }
    }
}
public class BB extends Temple{
    @Override
    public void Job(){
        long sum = 0;
        for (long i = 0; i < 100000; i++) {
            sum+=i;
        }
    }
}