抽象 abstract

抽象类和抽象方法必须用abstract关键字修饰

• 抽象类格式

  abstract class 类名{}
  

• 抽象方法定义，在返回值钱，或修饰符前加上abstract关键字

• 方法没有方法体，即：没有{}

  abstract public void eat();
  public abstract void eat();
  

• 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类

• 抽象类完全可以有成员变量和非抽象成员方法

抽象类的子类--使用extends

• 要么是抽象类，不完全实现其父类的抽象方法
• 要么重写抽象类中的所有抽象方法，这个子类就是一个完全的实现类了，所以可以用来实例化对象。

抽象类、方法定义时的非法组合

• private abstract抽象方法依靠子类去实现，但是私有方法在类外就不能访问，也就无法实现
• final abstractfinal修饰的方法不能被重写，而抽象方法就是需要子类实现，矛盾
• static abstract抽象方法在本类中是没有方法体的，使用类名调用的时候调用的是没有方法体的方法，无作用

抽象类成员的特点

1. 成员变量：既可以是变量，也可以是常量
2. 构造方法：有，用于子类访问抽象类数据的初始化
3. 成员方法：既可以是抽象的也可是非抽象的

抽象类成员方法的特性

• 抽象方法 强制要求子类做的事情
• 非抽象方法 子类继承的事情，提高代码的复用性

抽象类练习

案例：动物-->猫狗

    具体事物：猫，狗
    共性：姓名，年龄，吃
    有共性，所以可以提取出父类，但是由于子类对方法“吃”有不同的实现，所以，将方法“吃”定义为一个抽象方法，所以这个父类也就成了抽象类，这个父类的实现类都需要实现自己的特有的“吃”方法，才是一个可以被实例化的类，否则还是一个抽象类。

    ////定义抽象的动物类
    public abstract class AnimalDemo {
        //私有成员变量
        private String name;   
        private int age;
        public abstract void eat(); //抽象方法
        //公有的get/set方法
        public String getName(){
            return name;
        }
        public void setName(String name){
            this.name=name;
        }
        public int getAge(){
            return age;
        }
        public void setAge(int age){
            this.age=age;
        }
        //空参构造方法
        public AnimalDemo(){}
        //有参构造方法
        public AnimalDemo(String name,int age){
            this.age=age;
            this.name=name;
        }
    }
    //继承父类    并实现父类抽象方法
    public  class DogDemo extends AnimalDemo {
        //空参构造方法
        public DogDemo(){}
        //两个参数的构造方法
        public DogDemo(String name,int age){
            //调用父类有参构造方法,并传参
            super(name,age);
        }
        //重写父类抽象方法
        public void eat(){
            System.out.println("Dog eat");
        }

    }
    //继承父类    并实现父类抽象方法
    public class CatDemo extends AnimalDemo {
        public CatDemo(){}
        public CatDemo(String name, int age){
            super(name,age);
        }
        public void eat(){
            System.out.println("cat eat");
        }
    }
    测试类
    public class DemoTest {
        public static void main(String[] args) {
            AnimalDemo ad = new DogDemo("tom",2);//采用多态  父类引用指向子类对象
            ad.eat();
            System.out.println("name:"+ad.getName()+" "+"age:"+ad.getAge());
            AnimalDemo aadd = new CatDemo("jack",3);
            aadd.eat();
            System.out.println("name:"+aadd.getName()+" "+"age:"+aadd.getAge());
        }
    }

接口interface的引入

抽象类是从多个类中抽出来的模板，如果将这种抽象进行的更彻底，则可以提炼出来一种更加特殊的“抽象类”--接口，接口里不能包含普通的方法接口里的所有方法都是抽象方法，其中的成员变量全部是常量。

接口特点

• 接口用关键字interface表示

  格式：interface 接口名 {} //不能使用class关键字
  类实现结构用 implements关键字
  

• 格式：class 类名 implements 接口名{}

  接口没有构造方法，即：接口不能实例化
  

• 按照多态的方式，有具体的子类实例化，其实这也是多态的一种，接口多态

接口的子类

• 可以是抽象类，用implements关键字
• 或者还是一个接口 ，用extends关键字
• 是一个实现类，实现接口中所有抽象方法，用implements关键字

小结

只有接口和接口之间使用的是extends关键字，抽象类和接口之间，实现类和接口之间都是用的implements关键字。

接口成员的特点

• 成员变量

• 只能是常量

• 默认的修饰符public ， static ，final ，其中任何一个都可以省略，也可以全省略

• 构造方法

没有，因为接口主要是扩展功能的，而没有具体存在

• 成员方法
• 只能是抽象方法
• 默认的修饰符 public， abstract，可以省略其一也可以全部省略

类与类，类与接口，接口与接口的关系

• 普通类与普通类--extends

  继承关系只能单继承，但是可以多层继承

• 普通类和抽象类--extends

  继承关系，只能单继承，但是可以多层继承

• 普通类与接口，抽象类与接口--implements

  实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时是想多个接口，此时应该注意extends要写在前，implements写在后

• 接口与接口--extends

  继承关系，可以单继承，也可以多继承

抽象类和接口的区别

定义时用的关键字

• 抽象类 abstract
• 接口 interface

成员区别

• 抽象类：变量常量都可以有；抽象方法，非抽象方法都可以有；也可以有构造方法
• 接口：只有常量；只有抽象方法；没有构造方法

关系区别

• 类与类 ：集成，单继承，多层继承
• 普通类与接口：实现单实现或多实现implements
• 抽象类和接口：实现，单实现，多实现abstract class a implements IA,IB
• 普通类和抽象类：继承，并实现全部抽象方法extends
• 接口与接口：继承 ，单继承，多继承extends

在接口的各种关系中，只有接口与接口是继承关系，其余的和接口之间全部都是实现关系

接口练习

    /*
        猫狗案例,加入跳高的额外功能
        分析：从具体到抽象
            猫：
                姓名,年龄
                吃饭，睡觉
            狗：
                姓名,年龄
                吃饭，睡觉
            由于有共性功能，所以，我们抽取出一个父类：
            动物：
                姓名,年龄
                吃饭();
                睡觉(){}
            猫：继承自动物
            狗：继承自动物
            跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口
            接口：跳高
            部分猫：实现跳高
            部分狗：实现跳高
        实现；
            从抽象到具体
        使用：
            使用具体类
    */
    //定义跳高接口
    public interface Jump {
        public abstract void jump();
    }
    public class Dog extends Animal {
        public void eat(){
            System.out.println("狗啃骨头");
        }
        public Dog(){}
        public Dog(String name,int age){
            super(name,age);
        }

    }

    public class Cat extends Animal {
        public void eat(){
            System.out.println("猫捉老鼠");
        }
        public Cat(){}
        public Cat(String name,int age){
            super(name,age);
        }
    }

    public class JumpDog extends Dog implements Jump{
        public JumpDog(){}
        public JumpDog(String name,int age){
            super(name,age);
        }
        public void jump(){
            System.out.println("狗可以跳");
        }
    }

    public class JumpCat extends Cat implements Jump {
        public JumpCat(){}
        public JumpCat(String name,int age){
            super(name,age);
        }
        public void jump(){
            System.out.println("猫可以跳了");
        }
    }
    //测试类
    public class JumpTest {
        public static void main(String[] args) {
            Animal a =  new Cat("tom",2);
            System.out.println("name:"+a.getName()+" "+"age:"+a.getAge());
            a.eat();
            a.sleep();
            System.out.println("----------------");
            JumpCat jc = new JumpCat("加菲",2);
            System.out.println("name:"+jc.getName()+" "+"age:"+jc.getAge());
            jc.eat();
            jc.jump();
            jc.sleep();
            System.out.println("----------------");
            System.out.println("name:"+a.getName()+" "+"age:"+a.getAge());
            a= new Dog("jerry",2);
            a.eat();
            a.sleep();
            System.out.println("----------------");
            JumpDog jg = new JumpDog("机械狗",2);
            System.out.println("name:"+jg.getName()+" "+"age:"+jg.getAge());
            jg.eat();
            jg.jump();
            jg.sleep();
        }

    }