面向对象编程——继承

什么是继承

继承

继承和被继承有两个类来承接，一个父类（被继承类），一个是子类（继承类）；子类通过extends关键字继承父类的成员属性和方法；
什么是继承？继承就是子类继承父类的成员属性和方法；
继承的作用是什么呢？之前我们讲过方法是为了很好的重复利用代码，即代码重用；而继承也是同样的作用而产生的，只不过其余方法的重复利用不同，它的作用是类的代码重用，以此来简化代码.

语法规则

继承是在一个类的基础上加上新的功能，其解决的问题就是共性的抽取；
即猫和鸟这两个类都有一个共同的特征，都是动物，那么我们就可以定义一个动物类来供上述两个类来继承；
那么动物类应该怎么写呢，这有要来讨论这猫和鸟的类有什么共同的成员属性和方法，举个例子，猫和鸟都有一个姓名成员属性和eat这一个方法，那么在动物类上书写上，这样猫和鸟就可以直接继承从而获得成员属性，不用在类中书写，从何增加代码的简洁性和保密性；

public class Oper_2_28 {
    public static void main(String[] args) {
        //name 和 eat()是从父类中继承过来的
        Cat cat = new Cat();
        cat.name = "咪咪";        
        cat.eat("猫粮");   
        //run() 和 fly() 是自己定义而来的
        cat.run();
        Bird bird = new Bird( 2);
        bird.name = "鹊鹊";
        System.out.println(cat.name + " " + bird.name);
        bird.eat("谷粒");
        bird.fly();
    }
}
class Animal {
    String name;
    public void eat(String food){
        System.out.println(name + food);
    }
}
class Cat extends Animal{


    public  void run(){
        System.out.println("猫再跑");
    }
}
class Bird extends Animal{
    int age;
    public Bird( int age){
        this.age = age;
    }
    public void fly(){
        System.out.println(name + "在飞");
    }
}

在使用继承的时候，需要注意几点。
一个子类只能继承一个父类，相当于一个人只能有一个爸爸一般；子类通过继承可以获得父类的成员属性和成员方法，但是子类还可以通过父类继承的类的形式来获取新的功能；
构造方法
子类调用父类的构造方法使用super关键字；

 public Cat(String name,   int age){
        super(name, age);
    }

但是一般来说，如果父类中没有一个有参数的构造方法（默认的也是无参数构造方法），那么子类也不用调用父类的构造方法，因为子类也为默认调用父类的构造方法，默认情况下的具体如下：

    public Animal(){
    }
    ---------------------------------
    public Cat(){
        super();
    }

如果父类创建了一个有参数的构造方法，那么我们就要通过super来调用父类的构造方法才可继续使用父类的成员属性，否则就会报错，特别需要注意super关键字要放在子类构造方法的第一行，具体如何调用如下：

    public Animal(String name, int age){
        this.name = name;
        this.age = age;
    }
    ------------------------------
    public Cat(String name, int age){
        super(name, age);
    }

调用父类方法
在主方法中可以用子例实例来调用父类中定义的方法，而其中的参数并不会是父类中的参数，是子类中的参数进行赋值；

    public void eat(String food){
        System.out.println(name  + food);
    }
    -------------------------------
    public class Oper_2_28 {
    public static void main(String[] args) {
        Animal animal = new Animal("alnsho", 10);
        Cat cat = new Cat("咪咪", 12);
        cat.eat("鱼");
    }
}

咪咪鱼

访问限制符

访问限制符有public，protected，default，private

• private: 类内部能访问, 类外部不能访问
• default：默认(也叫包访问权限): 类内部能访问, 同一个包中的类可以访问, 其他包中不能访问.
• protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问.

重点介绍protected，protected对于同包中的类来说就相当于是public修饰的一般，而在不同包中，只有继承关系能够使用其修饰的成员变量和成员方法，其他类则不能够访问；
一般来说，我们比较常使用的是private来修饰属性，public来修饰方法；可以这么说，能用private就用private，不能使用就逐级递增，用protected，不能再使用default，还不能就使用public.

组合

组合理解起来并不难，其实就是在类中实例化其他类：
Person.java

public class Person {
    Cat cat = new Cat("妮妮", 2);
    Bird bird = new Bird("kaka", 1);

    @Override
    public String toString() {
        return "Person{" +
                "cat=" + cat.name +
                ", bird=" + bird.name +
                '}';
    }
}

StringBlogs.java

public class StringBlogs {
    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println(person1.toString());
    }
}

Person{cat=妮妮, bird=kaka}

组合和继承十分相似，都是在类中对其他类进行操作，那么怎么区分呢？
我们常常用 has a 来表达组合的含义，译为拥有；用 is a 来表达继承的意思，译为是什么；
举个例子：圆和点，我们可以说圆中有一个点或者说圆拥有一个点而不能说成圆是一个点.