黑马程序员——抽象类和接口

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

1:抽象类

(1)什么是抽象类

   把多个共性的东西提取到一个类中，这是继承的做法。
   但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。
   也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。
   所以，在定义这些共性的方法的时候，就不能给出具体的方法体。
   而一个没有具体的方法体的方法是抽象的方法。
   在一个类中如果有抽象方法，该类必须定义为抽象类。

(2)抽象类的特点

 抽象类的特点和使用
  抽象类不能实例化对象，不能new
  为什么不能new对象，抽象方法无法调用
  定义子类继承抽象类，子类重写抽象方法，建立子类对象
  如果子类只重写了部分抽象方法，子类还是一个抽象类
  子类如果需要建立对象，全部重写父类抽象方法

abstract class Animal
{
    public abstract void eat();
    public abstract void sleep();
}
//定义Animal类的子类cat,继承Animal，重写抽象方法
 class Cat extends Animal
{
    //重写抽象方法，去掉abstract关键字，加上{}
    public  void eat(){
      System.out.println("猫吃鱼");
    }

    public void sleep(){
        System.out.println("睡觉");
    }


}
class AbstractClassDemo1 
{
    public static void main(String[] args) 
    {
        //创建子类Cat对象
        Cat c = new Cat();
        c.eat();
    }
}

(3)抽象类的成员特点：

    A:成员变量
        有变量，有常量
    B:构造方法
        有构造方法
    C:成员方法
        有抽象，有非抽象

(4)抽象类的练习

    A:猫狗案例练习

abstract class Animal
{
    public abstract void eat();

}

class Dog extends Animal 
{
    public void eat(){
      System.out.println("狗吃热狗");
    }
}


class Cat extends Animal 
{
    public void eat(){
      System.out.println("猫吃鱼");
    }
}

class abstractTestAnimal 
{
    public static void main(String[] args) 
    {
        Cat c = new Cat();
        c.eat();

        Dog d = new Dog();
        d.eat();
    }
}

    B:老师案例练习

/*
  老师案例
  具体事物：基础班老师，就业班老师
   共性：讲课。

  有2个事物，基础老师，就业老师 有共性，上课

  如果是老师，必须具备上课功能

  共性抽取形成一个父类，上课方法
  规定了，我这个类所有子类，必须有上课功能，怎么上课，讲的是什么，由子类重写决定

*/

//定义老师的抽象类，规定上课功能，没有具体实现
abstract class Teacher
{
    public abstract void teacher();
}

//定义基础老师
class JavaSeTeacher extends Teacher
{
    public void teacher(){
        System.out.println("讲的是Javase");
    }
}

//定义就业老师
class JavaEeTeacher extends Teacher
{
    public void teacher(){
      System.out.println("讲的是Javaee+三大框架 SSH");
    }
}

class  AbstractClassTestTeacher
{
    public static void main(String[] args) 
    {
        Teacher t = new JavaSeTeacher();
        t.teacher();

        t = new JavaEeTeacher();
        t.teacher();
        //System.out.println("Hello World!");
    }
}

(5)抽象类的几个小问题

    A:抽象类有构造方法，不能实例化，那么构造方法有什么用?
        用于子类访问父类数据的初始化
    B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?
        为了不让创建对象
    C:abstract不能和哪些关键字共存
          private  抽象本质覆盖这个方法，父类私有了，子类不知道父类中的方法
          final    final修饰方法，不能覆盖，抽象方法就是覆盖的
          static   静态修饰可以类名直接调用，抽象方法没有主体

2:接口

(1)什么是接口：

        当一个抽象类，类中的方法全部是抽象方法的时候，这个抽象类换了一个更贴切的名词叫做接口。

(2)接口的特点：

    A:接口用关键字interface修饰
    B:类实现接口用implements修饰
        class 类名 implements 接口名 {}
    C:接口不能实例化
    D:接口的实现类
        a:是一个抽象类。
        b:是一个具体类，这个类必须重写接口中的所有抽象方法。

(3)接口的成员特点：

    A:成员变量
        只能是常量
        默认修饰符：public static final
    B:构造方法
        没有构造方法
    C:成员方法
        只能是抽象的
        默认修饰符：public abstract

(4)类与类,类与接口,接口与接口

    A:类与类
        继承关系，只能单继承，可以多层继承
    B:类与接口
        实现关系，可以单实现，也可以多实现。
        还可以在继承一个类的同时，实现多个接口
    C:接口与接口
        继承关系，可以单继承，也可以多继承

(5)抽象类和接口的区别

    A:成员区别
        抽象类：可以有非抽象方法
        接口：必须都是抽象方法
    B:关系区别:
        类与类：继承
        类与接口：实现
        接口与接口：继承
    C:设计理念不同
        抽象类：is a，抽象类中定义的是共性功能。
        接口：like a，接口中定义的是扩展功能。

(6)练习：

    A:猫狗案例，加入跳高功能

/*
 猫狗案例,加入跳高和算数的额外功能
  猫可以跳高 -- 额外
  狗算数 -- 额外

  猫和狗是有共性的 -- 抽取父类，抽象类
  额外功能，定义在接口中
*/

//定义跳高接口，谁有这个额外功能，谁实现接口
interface Jump
{
    public abstract void jump();
}
//定义计算的接口，谁有这个额外功能，谁实现接口
interface Arithmetic
{
    public abstract void arithmetic();
}
abstract class Animal
{
    public abstract void eat();

}
//定义能计算的狗，是动物中的一种，同时自己额外计算
class ArithmeticDog extends Animal implements Arithmetic
{
    public void eat(){
      System.out.println("狗吃热狗");
    }

    public void arithmetic(){
      System.out.println("狗在算数");
    }
}

//定义能跳高的猫，是动物中的一种，同时自己额外跳高
class JumpCat extends Animal implements Jump
{
    public void eat(){
      System.out.println("猫吃鱼");
    }
    public void jump(){
      System.out.println("猫在跳高");
    }
}

class Cat extends Animal
{
    public void eat(){}
}

class Dog extends Animal
{
    public void eat(){}
}

class InterfaceTestAnimal 
{
    public static void main(String[] args) 
    {
        JumpCat jc = new JumpCat();
        jc.eat();
        jc.jump();

        ArithmeticDog ad = new ArithmeticDog();
        ad.eat();
        ad.arithmetic();
    }
}