package com.hspedu.abstract_;public class Abstract01 {public static void main(String[] args) {}
}
abstract class Animal{//抽象类private String name;public Animal(String name) {this.name = name;}//父类方法不确定性的问题//该方法设计为抽象(abstract)方法//所谓抽象方法就是没有实现的方法//所谓没有实现就是指没有方法体。//当一个类中存在抽象方法时，需要将该类声明为abstract类//一般来说，抽象类会被继承，由子类实现抽象方法//    public void eat(){
//        System.out.println("这是一个动物，但是不知道吃什么...");
//    }public abstract void eat();
}

抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类（）。抽象类面试好问，在框架和设计模式使用较多。

抽象类细节

1. 抽象类不能实例化

2. 抽象类不一定包含abstract方法。可以没有抽象方法，可以有普通方法

3. 一旦含有抽象（abstract）方法，这个类必须声明为抽象类。

4. abstract只能修饰类和方法，不能修饰属性和其它的。

5. 抽象类可以有任意成员【抽象类还是类】

6. 抽象方法不能有主体{}

7. 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类

8. package com.hspedu.abstract_;public class Abstract02 {public static void main(String[] args) {}
   }
   abstract class AA{public abstract void eat();
   }class BB extends AA{@Overridepublic void eat() {System.out.println("食草动物吃草...");}
   }
   

   子类实现抽象方法就是有主体{}。

9. 抽象方法不能使用private，final，static来修饰，因为这些关键字都是和重写相违背的

10. final类是不能被继承，final方法不希望被子类修改，抽象方法不就是父类只写方法不写主体{}，然后通过子类来重写吗！

11. private是私有的方法怎么去重写呢

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

package com.hspedu.abstract_.template_;abstract public class Template {//抽象类-模板设计模式public abstract void job();//抽象方法public void calculateTime(){//实现方法，调用job方法//得到开始的时间long start = System.currentTimeMillis();job();//动态绑定//得到结束时间long end = System.currentTimeMillis();System.out.println("任务执行时间"+(end-start));}
}
class AA extends Template{//父类是抽象的，要么子类也是抽象的，要么重写父类的抽象方法@Overridepublic void job() {long sum=0;for (int i = 1; i <= 100000; i++) {sum+=i;}}
}
class BB extends Template{@Overridepublic void job() {long sum=0;for (int i = 1; i <= 80000; i++) {sum*=i;}}
}
class TemplateTest{public static void main(String[] args) {AA aa = new AA();aa.calculateTime();BB bb = new BB();bb.calculateTime();}}
/*
输出
任务执行时间2
任务执行时间2*/

接口入门

package com.hspedu.interface_;public interface UsbInterface {//接口public void start();//这是抽象方法public void stop();
}

package com.hspedu.interface_;//Person 类实现UsbInterface
public class Phone implements UsbInterface{//实现接口，就是把接口的方法实现@Overridepublic void start() {System.out.println("手机开始工作..");}@Overridepublic void stop() {System.out.println("手机停止工作..");}
}

package com.hspedu.interface_;public class Computer {//编写一个方法，计算机工作public void work(UsbInterface usbInterface){//通过接口来调用方法usbInterface.start();usbInterface.stop();}
}

package com.hspedu.interface_;public class ComputerTest {public static void main(String[] args) {//创建手机Phone phone = new Phone();//创建计算机Computer computer = new Computer();computer.work(phone);//把手机接入到计算机}
}
/*
手机开始工作..
手机停止工作..
*/

接口就是给出一些没有实现的方法，封装在一起，到某个类要使用的时候，在根据具体情况把这些方法写出来

package com.hspedu.interface_;public interface Ainter01 {//抽象方法public void say();//默认 ，jdk7和之前只能在接口中定义抽象方法default public void hi(){}//jdk8后可以定义默认还有静态方法public static void see(){}}

在接口中静态默认方法也能定义default

接口注意事项

1. 接口不能被实例化

2. 接口中所有的方法是public方法（如果不写public还是public的，不会是默认的），接口中抽象方法，可以不用abstract修饰。

3. 一个普通类实现接口，就必须将该接口的所有方法都实现

4. 抽象类实现接口，可以不用实现接口的方法

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

6. 接口中的属性，只能是final的，而且是public static final 修饰符。比如：int a=1;实际上是public static final int a = 1;（必须初始化）

7. 接口中属性的访问形式：接口名.属性名

8. 接口不能继承其他的类，但是可以继承多个别的接口。

9. 接口的修饰符只能是public 和默认，这点和类的修饰符是一样的

10. 

     都正确，B实现A。

接口VS继承

1. 继承当子类继承了父类，就自动的拥有父类的功能

2. 如果子类需要扩展功能，可以通过实现接口的方式扩展。

3. 接口比继承更加灵活，

4. 接口在一定程度上实现代码解耦（？接口规范性+动态绑定机制）

接口的多态特性

1. 多态参数（实现了A接口的类，就能把该类传进形参是A接口（Phone实现了接口））

   package com.hspedu.interface_;public class Inter02 {public static void main(String[] args) {//接口类型的变量monster可以指向实现IA接口的对象实例IA monster = new Monster();}
   }
   interface IA{}
   class Monster implements IA{}
   class Car implements IA{}
   

   接口引用可以指向实现了接口的类的对象

2. 多态数组

   package com.hspedu.interface_;public class Inter03 {public static void main(String[] args) {//多态数组--->接口类型数组Usb[] usbs = new Usb[2];usbs[0] = new Phone_();usbs[1] = new Camera_();//for (int i = 0; i < usbs.length; i++) {usbs[i].work();//动态绑定if(usbs[i] instanceof Phone_){//判断它的运行类型是((Phone_) usbs[i]).call();//向下转型}}}
   }
   interface Usb{void work();
   }
   class Phone_ implements Usb{public void call(){System.out.println("手机可以打电话...");}@Overridepublic void work() {System.out.println("手机工作中...");}
   }
   class Camera_ implements Usb{@Overridepublic void work() {System.out.println("相机工作中....");}
   }

   怎么实现特有的方法

3. 接口存在多态传递现象

   1. package com.hspedu.interface_;
      //演示多态传递现象
      public class Inter04 {public static void main(String[] args) {//接口类型的变量可以指向，实现了该接口的类的对象实例IG ig = new Teacher();IH ih = new Teacher();//不会报错，}
      }
      interface IH{void hi();
      }
      interface IG extends IH{//如果这没有继承，那么IH接口类型的变量不会指到Teacher类对象的}
      class Teacher implements IG{//通过上面的继承，这个Teacher也实现了IH接口@Overridepublic void hi() {}
      }
      

      接口多态传递