第九章 抽象类和接口

1.练习回顾

 宠物类:

public class Pet {
    String name;

    public Pet(String name) {
        this.name = name;
    }

    public void eat(){

    }
}

Dog类:

public class Dog extends Pet{
    public Dog(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println("小狗"+name+"吃骨头");
    }
}

Cat类:

public class Cat extends Pet{

    public Cat(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println("小猫"+name+"吃小鱼");
    }
}

Master类:

public class Master {
    String name;

    public Master(String name) {
        this.name = name;
    }
/** 方法重载
    public void feed(Dog dog){
        System.out.println("主人"+this.name+"喂东西");
        dog.eat();
    }
    public void feed(Cat cat){
        System.out.println("主人"+this.name+"喂东西");
        cat.eat();
    }
*/
    //使用多态
    public void feed(Pet pet){
        System.out.println("主人"+this.name+"带"+pet.name+"咪西");
        pet.eat();

    }
}

Test：

public class Test {
    public static void main(String[] args) {
        Master m = new Master("小明");
        Cat c = new Cat("花花");
        Dog d = new Dog("旺财");
        m.feed(c);
        m.feed(d);

    }
}

2.多态(续)

2.1 向上转型

        父类引用子类对象(自动成立     缺点：失去调用子类独有方法的能力)

//向上转型
Pet p1 = new Dog("老成");

// 此时只能通过父类变量访问父类中定义的内容 , 子类的东西是访问不到；

// 向上转型之后，子类的细节被屏蔽。

public class Dog extends Pet{
    public Dog(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println("小狗"+name+"吃骨头");
    }
    public void seeDoor(){
        System.out.println(name+"在看门");
    }
}

向上转型后，p1可以调用eat()方法，而子类特有的seeDoor()方法则被屏蔽。

2.2 向下转型

        子类引用父类对象(需要强制转换，谨慎使用) ，需要使用 instanceof 进行类型判断。

    public void feed(Pet pet){
        System.out.println("主人"+this.name+"带"+pet.name+"咪西");
        pet.eat();
        if (pet instanceof Cat) {
            //向下转型
            Cat cat = (Cat) pet;
            cat.catchMouse();
        }else  if(pet instanceof Dog){
            Dog dog = (Dog) pet;
            dog.seeDoor();
        }
        System.out.println("===================");
    }

3.抽象类

3.1 概念

        如果一个类只是一个概念，没有具体的形象，我们可以把这个类定义为抽象类。

关键字：abstract

抽象类的使用场景：一般作为顶层类(父类)，被子类继承

3.2 抽象类和抽象方法的定义

        抽象类的存在不是为了创建对象，是为了让子类继承用的。

抽象类：使用abstract关键字修饰的类。

[权限修饰符] abstract class 类名{}

抽象方法：使用abstract关键字修饰的方法(注：抽象方法没有方法体，也没有 { } )

[权限修饰符] abstract 返回值 方法名();//没有大括号

抽象类的特点：

①抽象类不能创建对象，不能new对象，抽象类的关键字是abstract；

②抽象类可以定义抽象方法，也可以没有抽象方法；

③有抽象方法的类一定要定义成抽象类；

④抽象类可以定义实例方法；

⑤抽象类可以定义构造方法，在子类中可以调用抽象类的构造方法；

⑥子类继承了抽象类，则一定要重写/实现其中的抽象方法,如果没有实现父类的抽象方法，则子类也要变成抽象类；

⑦抽象方法需要在方法前写abstract关键字,并且不能有方法体(不能写大括号) 。

public abstract class ParentClass {
    protected String name;
    public ParentClass(String name){
        this.name = name;
    }

    public void test(){
        System.out.println("大家好!");
    }

/** 抽象方法:
 *    1.用abstract修饰
 *    2.没有方法体，直接用分号结束
 *    3.抽象方法需要在子类中重写/实现
 */
    public abstract void test1();
}

public class SubClass extends ParentClass{
    public SubClass(String name) {
        super(name);
    }

    @Override
    public void test1() {
        System.out.println(name);
    }
}

4. 接口

4.1 概念

①一种标准、规范，大家都要遵从这个规范使用;

② 对行为（方法）的抽象（与抽象类对比，抽象类有特征和行为，而接口只关注行为）；

③ 一系列抽象方法的集合；

④ 定制规则，展现多态 ;

⑤接口和抽象类的地位等同，作为顶级存在（父类）；

⑥实现接口意味着拥有了接口所表示的能力。

接口关键字：interface

实现接口：implement 

4.2 java中的接口

接口定义的格式：

 [权限修饰符] interface 接口名{}

接口的使用步骤：

①接口中的方法不能直接使用，必须有一个实现类来实现接口；

        [权限修饰符] class 类名 implements 接口1,接口2,接口3。。。{}

         public class Mouse implements USB{}

②接口的实现类必须（覆盖重写）实现，接口中所有的抽象方法；

③创建实现类的对象，进行方法的调用。

注：如果实现类没有覆盖重写接口中的方法，那么这个实现类自己就必须是抽象类。

接口中可以包含的内容：

常量：

①接口中的常量使用public static final 三个关键字修饰；

②定义常量的格式：public static final int AGE = 10;

③使用接口中的常量：接口名. 常量名。

抽象方法：接口中的抽象方法必须是两个固定的关键字修饰 public abstract；这两个关键字可以省 略不写。

默认方法(jdk1.8之后新增)：default   增强接口的通用能力。

default 返回值 方法名(){} //默认方法有方法体

静态方法(jdk1.8之后新增)：提供通用实现，接口中的静态方法只能通过接口名调用，不能通过实现类调用。

static 返回值 方法名(){} // 静态方法有方法体

4.3 接口特点

①接口不能实例化，不能有构造方法；

②接口中的方法都是抽象方法，jdk8之后接口中可以定义默认方法和静态方法；

③接口中的成员变量默认都是public static final修饰的；

④实现类实现接口必须实现接口中的所有方法 ；

⑤多实现：一个类可以实现多个接口；

⑥接口可以继承接口：A extends B。

public interface IRun {
    // 接口中的变量默认都是静态常量: public static final 3 //int num = 10; 4 // 接口中的方法，默认就是公有抽象的
    void pao(); 
}
public class Person implements IRun {
    @Override
    public void pao() {
            System.out.println("人用两条腿跑");
        }
}

public class Rabbit implements IRun{
    @Override
    public void pao() {
        System.out.println("兔子用四条腿跑");
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println("世界末日来临，一切事物都在跑...");
        // 接口变量，引用实现类对象
        // 调用接口被实现的方法时，不同实现类有不同效果
        IRun r1 = new Person();
        IRun r2 = new Rabbit();
        r1.pao();
        r2.pao();
    }
}

5. 接口和抽象类的区别

①构造方法

        抽象类里面有构造方法 但是不能被new出来；

        接口里面没有构造方法；

②继承

        抽象里面 java单继承 一个类只能继承一个抽象父类；

        接口可以继承多个接口，一个类可以实现多个接口；

③抽象方法

        抽象类里面可以没有抽象方法，有抽象方法的类必须是抽象类；

        接口里面的方法是必须是抽象方法，只有方法名没有方法体，如果不是抽象方法就必须 是default修饰的方法；

        抽象类里面的抽象方法是用public abstract来修饰的，接口中的方法public abstract可以省略；

④变量

        接口中的变量是用public static final修饰的

抽象类和接口的对比

参数	抽象类	接口
默认的方法实现	可以有默认的方法实现	接口完全是抽象的，jdk1.8之前不存在方法的实现，jdk1.8之后有默认方法和静态方法
实现	子类使用extends关键字来继承抽象类，如果子类不是抽象类的话，它需要提供抽象类中所有声明的抽象方法的实现	子类使用关键字 implements 来实现接口，它需要提供接口中所有声明的方法的实现
构造器	抽象类可以有构造器	接口不能有构造器
与正常 Java类 的区别	除了你不能实例化抽象类之外，它和普通Java类没有任何区别	接口是完全不同的类型
访问修 饰符	抽象方法可以有public、protected和默认这些修饰符	接口方法默认修饰符是public。你不可以使用其它修饰符
main方 法	抽象类可以有main方法并且我们可以运行它	接口没有main方法，因此我们不能运行它（java8以后接口可以有default和 static方法，所以可以运行main方法）
多继承	抽象类可以继承一个类和实现多个接口	接口只可以继承一个或多个其它接口
速度	它比接口速度要快	接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法
添加新方法	如果你往抽象类中添加新的方法，你可以给它提供默认的实现，因此你不需要改变你现在的代码	如果你往接口中添加方法，那么你必须改变实现该接口的类，jdk8之后可以添加默认方法，不用实现类实现

6. 面向对象的三大特征

特征	定义	实现
封装	隐藏实现细节，提供公共的访问接口	将属性私有化，提供公共的访问接口
继承	从一个类中派生出一个新的子类，子类拥有父类中非私有的成员	子类 extends 父类
多态	父类的同一个方法在不同的子类中会有不同的实现	①继承②重写 ③向上转型