JAVA@11:面向对象(继承、方法重写、super.)

4.1继承

        类的继承是指在一个现有类的基础上构建一个新的类，构建的新类被称为子类，现有类被称作父类。子类会自动拥有父类中除了私有内容外的其他所有内容，使得子类具有父类的特征和行为。

        作用：

                1.简化代码的开发；

                2.子类对父类的拓展

        声明继承关系的语法格式如下;

class 父类{
    ....
    }
class 子类 extends 父类{
    ....
}

        子类除了继承父类的属性和方法，也可以定义自己的属性和方法。

class A{
    private String name;
    private  int age;

    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;
    }
}
class B extends A{
    private String color;     //定义子类自己的属性

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}
public class Ji_Cheng {
    public static void main(String[] args) {
        B u = new B();
        u.setName("张三");
        u.setAge(19);
        u.setColor("red");
        System.out.println("name is"+ u.getName()+"age is "
                +u.getAge()+" love color is "+u.getColor());
    }
}

注意：子类虽然可以通过继承访问父类的成员和方法，但不是所有的父类属性，和方法都可以被子类访问。

        子类只能访问父类中用public和protected修饰的属性和方法，父类中被默认修饰符default和private修饰的属性和方法不能被子类访问。

类的继承中注意问题

1.         类只支持单继承，不允许多继承。也就是说，一个类只能有一个直接父类。（只有一个爸爸）
2. 多个类可以继承一个类，（多个儿子）
3. 在java中，子类和父类是相对的，一个类可以是某个类的父类，也可以是另一个类的子类。
4. 多层继承也是可以的，就是一个类的父类也可以在继承另外的父类。

5. class A{}
   class B extends A{}   //B类继承了A类，B类是A类的子类
   class C extends B{}   //C类继承B类，C类是B类的子类，同时也是A类的子类。

方法的重写(严父慈母)

        作用：子类对父类提供的方法进行重新定义

        注意：1.具有相同的方法名

                       2.参数列表

                        2，返回值类型

                        3.不能使用比父类更严格的访问权限（父类使用了public，子类就不能使用private）

class Animal{
    //定义动物叫的方法
    void shout(){
        System.out.println("动物发出叫声");
    }
}
//定义Dog类继承Animal类
class Dog extends  Animal{
    //重写父类Animal的shout（）方法
    void shout(){
        super.shout();
        System.out.println("汪汪汪...");
    }
}
public class Chong_Xie {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.shout();
    }
}

运行结果

4.1.3 super关键字

        两个关键字配合使用主要是区分父子类的重名状况

区别点	super	this
访问属性	直接访问父类中的非私有属性	访问本类属性。如果本类没有该属性，则在父类中继续寻找
调用方法	直接调用父类中的菲私有方法	调用本类中的方法。如果本类没有该方法，则从父类继续寻找
调用构造方法	调用父类构造方法，必须放在子类构造方法的首行	调用本类构造方法，必须放到构造方法的首行

语法格式：

super.属性
super.方法(参数1,参数2,...)

注意：在子类实例化对象的时候（执行子类的构造方法）会执行父类的构造方法在执行子类的构造方法

public 子类（）{
    super（参数1，参数2，...）》》》仅能存在于首行
}

class Animal{
    private String name;
    private int age;
    public Animal(String name,int age){
        this.name = name;
        this.age = age;
    }

    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 String info(){
        return "name:"+this.getName()+",age:"+this.getAge();
    }
}
//定义Dog类继承animal类
class dog extends Animal{
    private String color;
    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
    public dog(String name,int age,String color){
        super(name, age);
        this.setColor(color);
    }
    //重写父类的info（）方法
    public String info(){
        return super.info()+",color:"+this.getColor();  //扩充父类的方法
    }
}
public class Sup_er {
    public static void main(String[] args) {
        dog i = new dog("牧羊犬",3,"黑色");
        System.out.println(i.info());
    }
}