一、抽象类和抽象方法

1. 区分抽象方法和普通方法
   1）当一个方法被abstract修饰时，该方法成为抽象方法
   2）抽象类所在的类必须定义为抽象类
   3）抽象方法不会有具体的实现，而是在抽象类的子类中通过方法重写进行实现
   4）定义抽象方法语法：
   [访问修饰符]  abstract  <返回类型> <方法名>([参数类表])
   5）区别：
   　　抽象方法需要用abstract修饰，普通方法不需要；抽象方法没有方法体
2. 区分普通类和抽象类
   1）当一个类被abstract修饰时被称为抽象类
   2）定义抽象类：abstract  class <类名>{    }
   3）区别：
   　　抽象类需要用abstract修饰，普通类不需要；
          普通类可以实例化，抽象类不能被实例化（但可以创建一个引用变量，其类型是一个抽象类，指向非抽象的子类实例）
3. 抽象类结构
   public abstract  class 类名{
       修饰符  abstract  返回值类型 方法名();
       修饰符  返回值类型  方法名(){ 
            方法体
       }
   } 
4. 抽象类和抽象方法的使用：
   抽象方法只能定义在抽象类中，抽象类中可以包含抽象方法和普通方法及普通类包含的一切成员；
   如果子类没有实现父类的所有抽象方法，则子类必须定义为抽象类；
   没有抽象构造方法，也没有抽象静态方法；
   抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用

package com.abstractInterface;
public abstract class Base {//抽象类中可以没有抽象方法,但包含了抽象方法的类就必须被定义为抽象类public abstract void method1();public abstract void method2();public void method3(){}//没有抽象的构造方法//public abstract Base(){}//没有抽象的静态方法//static abstract void method4();public Base(){System.out.println("父类的无参构造方法");}static void method4(){System.out.print("静态方法表示类所特有的功能，这种功能的实现不依赖于类的具体实例，也不依赖于它的子类。因此，当前类必须为静态方法提供实现");}
}

package com.abstractInterface;
//如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类
public abstract class Sub1 extends Base {public void method1() {System.out.println("重写父类的method1");}
}

package com.abstractInterface;
//否则就必须实现父类的所有抽象方法
public class Sub2 extends Base {public Sub2(){System.out.println("子类的无参构造方法");}@Overridepublic void method1() {System.out.println("重写父类的抽象方法method1");}@Overridepublic void method2() {System.out.println("重写父类的抽象方法method2");}
}

public class Test {public static void main(String[] args) {//抽象类不允许实例化//Base base=new Base();//抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用//抽象类不能被实例化,但可以创建一个引用变量，其类型是一个抽象类，指向非抽象的子类实例Base sub=new Sub2();sub.method1();sub.method4();}
}

二、抽象类的优势

　　如图，设计一个抽象类，它有两个普通方法：飞行（弹射飞）和叫（嗷嗷），还有一个抽象方法攻击。分裂鸟和火箭鸟为这个抽象类的子类。
　　分裂鸟和火箭鸟都继承了父类的飞行和叫的方法，并重写了父类的攻击方法（两种鸟的攻击方式不同）。

　　总结：抽象类中已经实现的方法可以被其子类使用，使得代码可以被复用；同时提供了抽象方法，保证了子类具有自身的独特性

三、抽象类的局限性

　　"愤怒的小鸟"的游戏中，分裂鸟和火箭鸟的叫声都是“嗷嗷”，但是红色鸟和炸弹鸟飞出来后是“渣渣”叫，胖子鸟飞出来后干脆不叫，所以类图做如下修改：

　　此时，使用抽象类就会出现以下问题：1.叫的方法不在通用；2.子类继承鸟抽象类后，写出来的叫的方法可能会出现代码重复的情况，如红色鸟和炸弹鸟都是“喳喳“叫。

　　问题1，可以将叫方法给抽象方法，由其子类去具体实现；但这样会造成代码冗余的问题，如这里的分裂鸟和火箭鸟的叫方法也会一样，也就是问题2会更加突出。

　　为解决上述问题，最理想的方法是使用接口。

四、接口

　　生活中，常见的如USB接口有以下特点：USB接口本身没有实现任何功能；USB接口规定了数据传输的要求；USB接口可以被多种USB设备实现

1. 接口概念
   java中接口的作用和生活中的接口类似，他提供一种约定，是的实现接口的类早形式上保持一致。
   如果抽象类中所有的方法都是抽象方法，就可以使用java提供的接口来表示，所以，从这个角度来讲，接口是一种特殊的”抽象类“，但两者语法和设计理念都不同
2. 定义和实现一个简单的接口
   

   
   接口是一个不能实例化的类型，需要注意：
   1）接口：接口中不能有构造方法；
                   接口使用interface修饰符，访问修饰符只能是public，且可选；
   　　         接口成员可以是全局变量和公共的抽象方法（默认用 public 修饰）；
                   接口中的变量都是静态常量（public static final），并必须指定初始值；
   2）实现接口：实现接口用implements关键字；
   　　                实现接口的类必须实现接口中定义的所有抽象方法，否则必须定义为抽象类；
                          接口的实现类中允许包含普通方法；
                          实现类可以实现多各接口；
   

   package com.interfaceDemo;
   /*** USB接口。* @author yu*/
   public interface UsbInterface {/*** USB接口提供服务。*/void service();
   }
   

   　　

   package com.interfaceDemo;
   /*** U盘。* @author yu*/
   public class UDisk implements UsbInterface {public void service() {System.out.println("连接USB口，开始传输数据。");}
   }
   

   　　

   package com.interfaceDemo;
   /*** USB风扇。* @author yu*/
   public class UsbFan implements UsbInterface {public void service() {System.out.println("连接USB口，获得电流，风扇开始转动。");}
   }
   

   　　

   package com.interfaceDemo;
   /*** 测试类。* @param args*/
   public class Test {public static void main(String[] args) {//1、U盘UsbInterface uDisk = new UDisk();uDisk.service();//2、USB风扇UsbInterface usbFan= new UsbFan();usbFan.service();}
   }

3. 更复杂的接口
   1）接口本身也可以继承接口：
   　　[修饰符] interface 接口名 extends 父接口1，父接口2，....{
              常量定义；
              方法定义；
          }
   2）一个普通类只能继承一个父类，但能同时实现多个接口，也可以同时继承抽象类和实现接口：
         class 类名 extends 父类名 implements 接口1，接口2，....{
            类的成员；
         }
   

   package com.interfaceDemo;
   /*** 鸟叫的接口* @author yu*/
   public interface ShoutAbility {/*** USB接口提供服务。*/public void shout();   //鸟叫的抽象方法
   }
   /****************************************/
   package com.interfaceDemo;
   /*** 嗷嗷叫* @author yu*/
   public class AoShout implements ShoutAbility {public void shout() {System.out.println("嗷嗷。。。。。");}
   }
   /******************************************/
   package com.interfaceDemo;
   /*** USB风扇。* @author yu*/
   public class ZhaShout implements ShoutAbility {public void shout() {System.out.println("喳喳。。。。。");}
   }
   /******************************************/
   package com.interfaceDemo;
   /** 无叫声*/
   public class NoShout implements ShoutAbility{public void shout(){//无叫声}
   }
   /******************************************/
   package com.interfaceDemo;
   /** 鸟类*/
   public abstract class Bird {ShoutAbility shoutAbility;   //鸟叫的方式String birdName;  //鸟的名字//构造方法，用来初始化鸟叫的行为//构造方法
   //    public Bird(String birdName){
   //        this.birdName = birdName;
   //    }public Bird(ShoutAbility shoutAbility,String birdName){this.shoutAbility = shoutAbility;this.birdName = birdName;}//叫public void Shout(){shoutAbility.shout();}//飞行public void fly(){System.out.println(this.birdName+"弹射飞！");}//攻击public abstract void attrack();
   }
   /********************************/
   package com.interfaceDemo;
   /** 分裂鸟*/
   public class SplitBird extends Bird{//构造方法public SplitBird(ShoutAbility shoutAbility,String birdName){super(shoutAbility,birdName);}//重写分裂方法public void attrack(){System.out.println("分裂攻击！");}}
   /************************************/
   package com.interfaceDemo;
   /** 火箭鸟*/
   public class RocketBird extends Bird{public RocketBird(ShoutAbility shoutAbility,String birdName){super(shoutAbility,birdName);}public void attrack(){System.out.println("加速冲撞！");}
   }
   /********************************************/
   package com.interfaceDemo;
   /** 红色鸟*/
   public class RedBird extends Bird{//构造方法public RedBird(ShoutAbility shoutAbility,String birdName){super(shoutAbility,birdName);}//重写分裂方法public void attrack(){System.out.println("普通攻击！");}
   }
   /******************************************/
   package com.interfaceDemo;
   /** 炸弹鸟*/
   public class BombBird extends Bird{//构造方法public BombBird(ShoutAbility shoutAbility,String birdName){super(shoutAbility,birdName);}//重写分裂方法public void attrack(){System.out.println("爆炸攻击！");}
   }
   /********************************************/
   package com.interfaceDemo;
   /** 胖子鸟*/
   public class FatBird extends Bird{//构造方法public FatBird(ShoutAbility shoutAbility,String birdNme){super(shoutAbility,birdNme);}//重写分裂方法public void attrack(){System.out.println("扔蛋攻击！");}
   }
   /********************************************/
   package com.interfaceDemo;import java.text.Bidi;/*** 测试类。* @param args*/
   public class Test {public static void main(String[] args) {ShoutAbility shoutAbility = new AoShout();  //嗷嗷叫ShoutAbility shoutAbility1 = new ZhaShout();  //喳喳叫ShoutAbility shoutAbility2 = new NoShout();  //无叫声Bird bird = new SplitBird(shoutAbility,"分裂鸟");bird.fly();bird.Shout();bird.attrack();Bird bird1 = new RocketBird(shoutAbility,"火箭鸟");bird1.fly();bird1.Shout();bird1.attrack();Bird bird2 = new RedBird(shoutAbility1,"红鸟");bird2.fly();bird2.Shout();bird2.attrack();Bird bird3 = new BombBird(shoutAbility1,"爆炸鸟");bird3.fly();bird3.Shout();bird3.attrack();Bird bird4 = new FatBird(shoutAbility2,"胖子鸟");bird4.fly();bird4.Shout();bird4.attrack();}
   }
   

   　　

4. 面向对象的设计原则
   1）摘取代码中变化的行为，形成接口
   2）多用组合，少用继承
   3）针对接口编程，不依赖于具体实现：具体代码实现中，体现在方法参数尽量使用接口，方法的返回值尽量使用接口，属性类型尽量使用接口等
   4）针对扩展开放，针对改变关闭：项目中需求发生变化，应添加一个新的接口或类，而不要去修改源码
   总的来说，接口和抽象类是实现堕胎的2种重要方式，是面向对象设计的基础