抽象与接口的理解

继承的概念

继承描述的是事物之间的所属关系,通过继承可是使多种事物之间形成一种关系体系
类的继承是指在一个现有类的基础上去构建一个新的类,构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。在程序中,如果想声明一个类继承另一个类，需要使用extends关键字

class Animal{
    String name;
    public void show() {
        System.out.println(name+"发出了叫声");
    }
}
//Dog类继承自Animal类
class Dog extends Animal{
    //打印一个name的方法
    public void printName() {
        System.out.println("这个动物现在是"+name);
    }
}
public class Example01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name="老黑";
        dog.printName();
        dog.show();    
    }
}

注 意：
1. 在Java中，类只支持单继承，不允许多重继承，也就是说一个类只能有一个直接父类
2. 多个类可以继承同一个父类
3. 在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类
4. 在Java中，子类和父类是一种相对概念，也就是说一个类是某个父类的同时，也可以是另外一个类的子类。

重写父类方法

在继承关系中，子类会自动继承父类中定义的方法，但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行重写。需要注意的是，在子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型

class Animal{
    public void show() {
        System.out.println("发出了叫声");
    }
}
//Dog类继承自Animal类
class Dog extends Animal{
    @Override     //重写父类show()方法
    public void show() {
        System.out.println("汪汪汪");
    }
}
public class Example01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.show();
    }
}

注 意：
子类重写父类方法时，不能使用父类中被重写的方法更严格的访问权限，如：父类中的方法是public的，子类的方法就不能是private的

super关键字

Java中专门提供了一个super关键字用来访问父类的成员

1. 使用super关键字访问父类的成员变量和成员方法

　　super.成员变量
　　super.成员方法([参数1，参数2...])

案例学习

class Animal{
            String name="动物";
            public void show() {
                System.out.println(name+"发出了叫声");
            }
        }
        //Dog类继承自Animal类
        class Dog extends Animal{
            String name="黑狗";
            //打印一个name的方法
            public void printName() {
                System.out.println("这个动物现在是"+super.name);
            }
            @Override
            public void show() {
                super.show();
            }
        }
        public class Example01 {
            public static void main(String[] args) {
                Dog dog = new Dog();
                dog.printName();
                dog.show();        
            }
        }

2. 使用super关键字访问父类的构造方法，注意通过super调用父类的构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次

　　super.([参数1,参数2...])

class Animal{
    //定义Animal的有参构造
    public Animal(String name) {
        System.out.println("我是一只"+name);
    }
}
class Dog extends Animal{
    public Dog() {
        super("老王");    //调用父类有参的构造方法
    }
}
public class Example02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
    }
}

在定义一个类时，如果没有特殊需求，尽量在类中定义一个无参的构造方法，避免被继承时出现错误

 final关键字

final关键字可用于修饰类、变量和方法，它有"无法改变"或者"最终"的含义，因此被finnal修饰的类、变量和方法具有以下特性:

1. finnal修饰的类不能被技能
2. finnal修饰的方法不能被子类重写
3. finnal修饰的变量(成员变量和局部变量)是常量，只能赋值一次

抽象类

Java允许在定义方法时不写方法体。不包含方法体的方法为抽象方法，抽象方法必须使用abstract关键字来修饰

    abstract void show();                 //定义抽象方法show()

当一个类中包含了抽象方法，该类必须使用**abstract**关键字来修饰，使用abstract关键字修饰的类为抽象类

//定义抽象类Animal
abstract class Animal{
    abstract int show();
}

在定义抽象类时需要注意,包含抽象方法的类必须声明为抽象类，但抽象类可以不包含任何抽象方法，只需使用abstract关键字来修饰即可。另外，抽象类时不可以被实例化的，因为抽象类中有可能包含抽象方法，抽象方法是没有方法体的，不可以被调用。如果想调用抽象类中定义的方法，则需要创建一个子类，在子类中将抽象类中的抽象方法进行实现

//定义抽象类
abstract class Animal{
    abstract void show();
}
//定义Dog类继承抽象类Animal
class Dog extends Animal{
    @Override
    void show() {
        System.out.println("这是重写的抽象类");
    }
}
public class Example01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.show();
    }
}

接口

如果一个抽象类中的所有方法都是抽象的，则可以将这个类用另外一种方法来定义，即接口。接口是由常量和抽象方法组成的特殊类，是对抽象类的进一步抽象

[public] interface 接口名 [extends 接口1，接口2...]{
    [public] [static ] [final] 数据类型 常量名 = 常量值；
    [public] [abstract] 返回值 抽象方法名(参数列表)；
}

在一个接口中可以有多个父接口，它们之间用逗号隔开。Java使用接口的目的是为了克服单继承的限制，因为一个类只能有一个父类，而一个类可以实现多个接口。接口中的变量默认使用"public static final"来修饰，即全局常量；接口中定义的方法默认使用"public abstract"来修饰,即抽象方法。如果接口声明为public，则接口中的变量和方法全部为public。

由于接口中的方法都是抽象方法，因此不能通过实例化对象的方法来调用接口中的方法，此时需要定义一个类，并使用implements关键字实现接口中所有的方法。一个类可以在继承另一个类的同时实现多个接口，这些接口在implements子句中要是用英文逗号(,)隔开。接口的实现类声明格式如下

    [<修饰符>] class<类名> [extends <超类名>]  [implements <接口1>，<接口2>，...]

//定义Animal接口
interface Animal{
    //定义全部变量,其默认修饰为public static final
    String ANIMAL_BEHAVIOR="动物的行为";
    //定义抽象方法breathe(),其默认修饰为public abstract
    void breathe();
    //定义抽象方法run
    void run();
}
//Dog类实现了Animal的接口
class Dog implements Animal{
    @Override
    public void breathe() {
        System.out.println(ANIMAL_BEHAVIOR+"在玩耍");
    }
    @Override
    public void run() {
        System.out.println(ANIMAL_BEHAVIOR+"在奔跑");
    }
}
public class Example01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.breathe();
        dog.run();
    }
}

注意：一个类实现一个接口，必须给出接口中所有方法的实现，如果不能实现某方法，也必须写出一个空方法

在程序中还可以定义一个接口使用extends关键字去继承另一个接口

//定义animal接口
interface Animal{
    //定义全部常量,其默认修饰为public static final
    String ANIMAL_BEHAVIOR = "动物的行为";
    //定义抽象方法breathe(),其默认修饰为public abstract
    void breathe();
    //定义抽象方法run();
    void run();
}
//定义了LandAnimal接口
interface LandAnimal extends Animal{
    void liveOnLand();
}
//定义Dog类实现Animal接口
class Dog implements LandAnimal{
    //实现breath方法
    @Override
    public void breathe() {
        System.out.println(ANIMAL_BEHAVIOR+": 狗在呼吸");
    }
    //实现run方法
    @Override
    public void run() {
        System.out.println(ANIMAL_BEHAVIOR+": 狗在奔跑");
    }
    //实现liveOnLand方法
    @Override
    public void liveOnLand() {
        System.out.println("狗是陆上动物");
    }
}
//测试类
public class Example01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //使用对象名.常量名的方式输出接口中的常量
        System.out.println(dog.ANIMAL_BEHAVIOR);
        //使用接口名.常量名的方式输出接口中的常量
        System.out.println(Animal.ANIMAL_BEHAVIOR);
        dog.breathe();        //调用Dog类重写的breathe方法
        dog.run();            //调用Dog类重写的run方法
        dog.liveOnLand();    //调用Dog类重写的liveOnLand方法
    }
}

总结接口的特点:

1. 接口中的方法都是抽象的，不能实例化对象
2. 接口中的属性只能是常量
3. 当一个类实现接口时，如果这个类是抽象类，则实现接口中的部分方法即可，否则需要实现接口中的所有方法。
4. 一个类通过implements关键字实现接口时，可以实现多个接口，被实现的多个接口之间要用逗号隔开
5. 一个接口可以通过extends关键字继承多个接口，接口之间用逗号隔开
6. 一个类在继承另一个类的同时还可以实现接口，此时，extends关键字必须位于implements关键字之前