JAVA的面向对象的三大特性之一：继承

1、继承的定义：

     描述事物的时候有几个类有重复的属性和方法，我们可以采用继承的方法来设计。

2、使用class A extends B 实现类的继承。

      子类， A     父类，B

3、子类继承父类后，子类只能获得父类中非private属性，如果想要继承就得提供公共的set/get方法。

       方法也是只能是公有的，私有的方法无法继承下来。 

 

4、子类除了通过继承，获取父类的结构之外，还可以定义自己的特有的成分。

 

5、java的继承性只能支持单继承，一个类只能继承一个父类，反之，一个父类可以有多个子类。

 

方法的重写：

1、前提：有子类继承父类

2、子类继承父类以后，若父类的方法对子类不适用，那么子类可以对父类的方法重写

3、重写的规则：

      1）要求子类方法的“ 返回值类型 方法名 （参数列表）” 与父类的方法都一样。

       2）子类方法的修饰符不能小于父类方法的修饰符。

       3）若父类的方法抛异常，那么子类方法抛的异常不能大于父类的异常。

       4）子类和父类的方法必须同为static或者同为非static的。

 

super关键字：

super关键字可以用来修饰属性、方法、构造器；

1、当子类与父类中有同名的属性时，可以通过 super.此属性  显式调用父类中声明的属性。

       调用子类中同名的属性， 通过  this.此属性  

2、当子类重写父类的方法后，在子类中若想再显式的调用父类中被重写的方法，使用 super.方法。

      注意：对于不重名的属性或者方法，super.属性或者super.方法，this.属性或者this.方法都行。

3、super修饰构造器，通过在子类中使用 super(形参列表) 来显式调用父类中指定的构造器。

     1）在构造器内部，super(形参列表) 必须声明在第一行；

      2）在构造器内部，super(形参列表)  或者  this(形参列表) 只能出现一个；

     3）在构造器内部，不显示地调用super(形参列表)  或者  this(形参列表)任何一个，默认调用 父类空参 的构造器

 

 

 

代码分享：

public class Person {
    protected String name = "oooXXX";
    protected String sex;
    private int age;
    int id = 142;//身份证

    public Person() {
        //super();//有没有都行，会默认自动调用
        System.out.println("这是person的无参构造器！！");
    }



    public Person(String sex){
        this();
        this.sex=sex;
        System.out.println("这是person的有参构造器");
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public String getSex() {
        return sex;
    }

    public int getAge() {
        return age;
    }

    public void eat() {
        System.out.println("吃饭喽！！！");
    }

    private void walk() {
        System.out.println("走起来！！！");
    }

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

}

public class Student extends Person {
    //方法的重写；方法的覆盖
    public void eat() {
        System.out.println("students are eating now???");
    }

    //这里不算方法的重写，因为子类就没有继承父类的walk()方法
    public void walk() {
        System.out.println("students are walking???");
    }
}

public class Worker extends Person{
    int id=101;//工号
    public Worker(){
        //super();
        super("女孩子");
        System.out.println("这是worker的无参构造器");
    }
    public void show(){
        System.out.println(this.id);
        System.out.println(super.id);
        System.out.println(super.name);
        System.out.println(this.name);
        System.out.println(this.sex);
        System.out.println(super.sex);
    }
    //重写方法
    public void eat(){
        super.eat();//调用父类中被重写的eat()方法
        System.out.println("工人在吃饭呢！！！");
        super.sleep();
        System.out.println("-------");
        this.sleep();
    }



}

public class JiChengTest {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.eat();
        //stu.walk();//父类的private方法子类无法继承
        //stu.name;//子类无法继承父类的private变量
        stu.setName("oppo");
        System.out.println(stu.getName());
        //子类通过公共的方法来间接访问私有变量，
        stu.walk();

        Worker worker = new Worker();
        worker.eat();
        worker.setSex("男");
        System.out.println("worker::" + worker.getSex() + " " + worker.getName() + " " + worker.getAge());
        //worker::男 null 0

        Worker w2 = new Worker();
        w2.show();
        w2.eat();

       System.out.println(Person.class.getSuperclass().getName());
        //java.lang.Object----这里说明person的父类默认是Object类
    }


}

 

 

结果：

这是person的无参构造器！！
students are eating now???
oppo
students are walking???
这是person的无参构造器！！
这是person的有参构造器
这是worker的无参构造器
吃饭喽！！！
工人在吃饭呢！！！
人在睡觉！！！
-------
人在睡觉！！！
worker::男 oooXXX 0
这是person的无参构造器！！
这是person的有参构造器
这是worker的无参构造器
101
142
oooXXX
oooXXX
女孩子
女孩子
吃饭喽！！！
工人在吃饭呢！！！
人在睡觉！！！
-------
人在睡觉！！！
java.lang.Object