疯狂java学习笔记之面向对象(九) - 抽象和接口

一、抽象(abstract)：

　　1、抽象类：

　　　使用abstract修饰的类就是抽象类;

　　　相比于普通类抽象类增加了支持抽象方法的功能,但也丢失了创建实例的功能(抽象类中不能创建实例),其他普通类有的抽象类可以有。

　　　抽象类的三个注意点:

　　　　①、虽然抽象类不能创建实例,但它依然有构造器(主要给其子类的构造器调用-子类至少调用父类构造器一次);

　　　　②、抽象类中可以没有抽象方法(可有可无);

　　　　③、抽象类总是不能创建实例/对象的 - 即使它没有包含抽象方法。

 public abstract class TestAbstract{
     private int age;

     {
         System.out.println("-这是个对象初始化块-");
     }

     public TestAbstract(){}

     //虽然抽象类不能创建实例,但它依然有构造器(主要是供其子类构造器调用,至少调用一次)
     //子类不使用super()时则隐式调用父类无参构造器,有super()则根据参数来决定。
     public TestAbstract(int age){
         this.age = age;
     }

     public static void main(String[] args){
         System.out.println("Hello World!!");
         //抽象类中不能创建实例,编译时即报错
         //TestAbstract ta = new TestAbstract();
     }
 }

　　2、抽象方法:

　　　使用abstract修饰且没有方法体的方法就是抽象方法。

　　　注意点:

　　　　①、抽象方法不能有方法体 - 花括号内容(出现花括号没任何代码都算有方法体)；

　　　　②、abstract不能和final同时出现 - 因为abstract方法必须由子类去重写,而final修饰的方法又不允许重写,因此不能同时出现；

　　　　　　对于abstract类来说,该类主要用于派生子类,final修饰的类同样不允许被集成,因此也不能同时出现 - abstract和final是永远互斥的；

　　　　③、abstract与static不能同时修饰方法   - static修饰的方法编译时已经确定下来,无法让子类@Override；

　　　　④、abstract与private不能同时修饰方法 - private修饰的方法不能被子类访问,而abstract又要求方法必须由子类重写,所以两者是互斥的。

 public abstract class TestAbstract2{
     //抽象类相对于普通类除了不能创建实例,其他功能都是有的,普通方法等能存在。
     public void info(){}

     //抽象方法中不能有方法体-即使方法体内容为空
     //public abstract void aa(){}

     public abstract void test();

     //abstract 与static不能同时修饰方法 - static修饰的方法编译时已经确定下来,无法让子类@Override
     //public abstract static void bb();

     //abstract方法必须由子类重写,而private又不能让子类访问所以出错
     private abstract void cc();

 }

　　三、抽象的作用：

　　　抽象类的作用:主要是与"模版模式" 结合一起使用的。

　　　比如有如下场景需求:程序要实现A方法,但A方法又需要调用B方法且B方法在该类中暂时不知道如何实现(因为其子类实现B方法的方法可能都不一样,因此B方法可定义成抽象方法)。

　　　抽象类的子类一般要实现抽象父类提供的所有方法,否则该子类也只能是抽象类(这样就无实际意义~)　　

 abstract class SpeedMeter{
     //定义一个转动速度。
     private double turnRate;

     //抽象类的构造器主要用于被子类的构造器调用
     public SpeedMeter(double turnRate){
         this.turnRate = turnRate;
     }

     //对于private修饰的Field一般推荐设置个set和get方法,典型的封装
     public void setTurnRate(double turnRate){
         this.turnRate = turnRate;
     }

     public double getTurnRate(){
         return this.turnRate;
     }

     //计算速度的方法
     /*
         这里就是模版模式,此处我们定义一个计算速度的模板:转速*周长
         但此处并不清楚计算周长方法,所以此处把周长getSpeed()定义成抽象方法,子类只需提供计算周长的方法即可
         计算周长的方法是有差异的,车轮:2*PI*半径等
     */
     public abstract double getSpeed();

 }

 class CarSpeedMeter extends SpeedMeter{
     private double radius;

     public CarSpeedMeter(double radius,double turnRate){
         super(turnRate);
         this.radius = radius;
     }

     @Override
     public double getSpeed(){
         return 2 * radius * Math.PI;
     }
 }

 class TankSpeedMeter extends SpeedMeter{
     private double bianchang;
     public TankSpeedMeter(double bianchang,double turnRate){
         super(turnRate);
         this.bianchang = bianchang;
     }

     //假设坦克的周长计算方法为 8 * 边长
     @Override
     public double getSpeed(){
         return 8 * bianchang;
     }
 }

 public class TestSpeedMeter{
     public static void main(String[] args){
         SpeedMeter sm = new CarSpeedMeter(20,2000);
         System.out.println("汽车的速度为: " + sm.getSpeed());
         SpeedMeter tk = new TankSpeedMeter(8,1000);
         System.out.println("坦克的速度为: " + tk.getSpeed());
     }
 }

二、接口(interface)：

　　接口的作用非常丰富,接口往往是和设计模式结合一起使用的。

　　接口可以认为是一种"彻底"的抽象类,它是从多个相似的类中抽取出来的一种规范,接口体现的是规范。

　　接口体现的规范:如主板上各种不同类型的"插槽",无论接入的哪个厂商、型号的硬件都可以彼此进行通信(任何一套公开的标准/规范,需要通过接口来体现)。

　　接口定义语法:

　　[修饰符] interface 接口名{

　　　　//0~N 个Field、特殊的Field

　　　　//0~N 个抽象方法

　　　　//0~N 个内部类、内部接口、内部枚举类定义

　　}

　　[修饰符]：只能是public和默认省略,不能是protected因为接口在保外,而protected只能在包名进行访问

　　接口名: 由多个单词连缀而成,每个单词的首字母要大写,推荐以i开头(c#定义已i开头且是个不错的习惯)。

　　注意点:

　　　①、接口不能有构造器,也不能有初始化块；

　　　②、接口的Field默认有3个修饰符: public static final，无论你写或不写,反正都有这三个修饰符；

　　　　接口的Field定义时必须指定初始值 -- 接口Field默认有static final修饰，final修饰的变量只能被赋值一次，你不指定系统给你赋默认值0、0.0、null等。

　　　③、接口的方法默认有2个修饰符:public abstract，无论你写与不写，反正都有这二个修饰符；

　　　　接口的方法不能有static，因为接口的方法默认有abstract修饰。

　　　④、接口的内部类、内部枚举类、内部接口，默认有两个修饰符: public static

 public interface iWalk{
     int age = 33;
     //接口中的Field默认有public static final修饰,必须在声明时指定初始值
     //final修饰的变量必须在声明时/初始块中指定,但接口又不能有初始化块,那必须在声明时指定了
     //String name;

     //接口的所有成员都需要提供给外部类、包访问,接口公开的标准必须由public修饰
     //private double weight = 99;

     //接口中的方法默认有public abstract修饰
     void info();

     //抽象方法不能有方法体
     //void test(){}
 }

　　接口的继承：

　　一个接口可以有N个直接父接口;

　　接口可用于定义变量；不能直接创建实例；提供其他类来实现自己。

　　implements:实现一个或N个接口，接口实现类要么为接口所有的抽象方法提供实现，否则你的实现类也只能是抽象类。接口主要是在"面向接口编程"时提供更好、更灵活的机制。

 interface IEatable{
     void eat();
 }

 interface IFlyable{
     void fly();
 }

 interface Iwalkable extends IEatable{
     int age = 20;
     void info();
     /*
         接口中的方法必须为抽象方法
     public static void main(String[] args){
         Iwalkable iw = new Sparrow();
     }
     */
 }

 public class Sparrow implements IFlyable,Iwalkable{
     //因为Sparrow实现了两个接口,所以它必须实现两个接口的所有方法
     @Override
     public void eat(){
         System.out.println("这只麻雀在一口一口吃麦子");
     }

     public void fly(){
         System.out.println("这麻雀在飞走了！");
     }

     public void info(){
         System.out.println("这是一只小小麻雀");
     }

     public static void main(String[] args){
         //向上转型,iw引用变量编译时只是Iwalkable类型,编译器只能允许它调用Iwalkable内的方法
         Iwalkable iw = new Sparrow();
         iw.info();
         iw.eat();
         //iw编译时为Iwalkable类型,直接调用fly方法会报错
         //iw.fly();

         //Sparrow sp = new Sparrow();
         //强制向下转型
         Sparrow sp = (Sparrow)iw;
         sp.fly();

         IFlyable ia = new Sparrow();
         ia.fly();
     }
 }

接口与抽象类之间的相似之处:

　　①、都可以包含抽象方法；

　　②、都不能创建实例

　　③、子类抽象类或实现接口，都要求实现所有抽象方法，否则这个子类也只能是抽象类

接口与抽象类之间的区别：

　　①、接口里只能有抽象方法，而抽象类中可以没有抽象方法也可以包含普通方法；

　　②、接口中不能定义static方法，而抽象类中可以包含static方法；

　　③、接口的Field默认有public static final三个修饰符修饰，而抽象类的Field完全可以是普通Field；

　　④、接口不能包含构造器，而抽象类完全可以有构造器(供子类至少调用一次)；

　　⑤、接口不能包含初始化块，而抽象类完全可以有初始化块；

　　⑥、接口可以有多个直接的父接口，而抽象类只能有一个直接的父类。