面向对象——继承（extends关键字，访问修饰符，方法重写，super关键字）

面向对象——继承

A.extends关键字

extends：继承、拓展

• 一个新类可以从现有的类派生，这样的过程叫做继承
• 那么在继承的过程中，新类被称为子类，现有的类被称为父类，子类将会继承父类的属性和行为。

继承的语法

[修饰符] class 子类类名 extends 父类类名{类体部分}

public class Student extends Person{}

字类的扩展

子类除了可以拥有父类非私有的属性和方法外，也可以扩展自己的属性和方法。

public class Person {
    public String name;
    public int age;

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

public class Student extends Person{

    //extends :继承、拓展
    //一个新类可以从现有的类派生，这样的过程叫做继承
    //那么在继承的过程中，新类被称为子类，现有的类被称为父类，
    // 子类将会继承父类的属性和行为。

    public String id;
    public int state;

    public void study(){
        System.out.println("我在学习额！");
    }

}

主函数

public class main {
    public static void main(String[] args) {


        Student stu = new Student();
        stu.name = "张三";
        System.out.println(stu.name);

        stu.eat();
        stu.study();
    }
}

继承的使用：

• Java中的继承是单继承，也就是一个类只能有一个父类。
• 如果一个类没有显式的继承某一个类java.lang.Object类，那么它有一个默认的父类是
• Java继承了父类非私有的成员变量和成员方法，但是请注意：子类是无法继承父类的构造方法的

访问修饰符

访问修饰符对成员变量和成员方法的访问限定.

public:访问范围：任意地方都可以访问。继承范围：任意字类都可以继承。

private:访问范围：只有本类内部。继承范围：不能被继承。

protected:(受保护的)：访问范围：本类内部+同包其他类，非同胞的其他类不可以访问。继承：能被继承。

default：访问范围：本类内部客户以访问。继承范围：同包子类可以继承，非同胞字类无法继承。

权限排序：private<default<protected<public.

public class Person {
    //属性
    public String name;//公共的
    private  int age;//私有的
    protected String sex;//受保护的
    String id;//default   默认的不用谢

    //方法
    public  void ptingt(){
        System.out.println(this.name);
        System.out.println(this.age);
        System.out.println(this.sex);
        System.out.println(this.id);
    }
    
    //构造方法
    public Person(){

    }
}

B.方法的重写

重写 override

• 子类从父类继承的某个实例方法无法满足子类的功能需要时，需要在子类中对该实例方法进行重新实现，这样的过程称为重写，也叫做覆写。

  方法重写的要求

  • 子类重写方法的访问修饰范围必须大于或者等于父类对应方法的访问修饰符范围
    除修饰符外，重写方法的其他部分必须和父类保持一致

  父类：

package com.jicheng.jicheng_fangfachongxie;

public class Person {
    private String name;
    private int age;

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

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

    //获取name
    public  String  getName(){
        return this.name;
    }

    //获取age
    public int getAge(){
        return this.age;
    }

    //跑方法
    public void run() {
        System.out.println("paoqilaile");
        }



        //构造器
        public Person(String name,int age){
        this.name = name;
        this.age = age;


    }
}

继承Person

package com.jicheng.jicheng_fangfachongxie;

public class Student extends Person {
    private String id;
    private int state;

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

    public void setId(String id){
        this.id = id;
    }

    public  String getId(){
        return this.id;
    }

    //方法重写
    //将从父类继承下来的方法重新实现
    //方法重写不能修改返回值类型，方法名，参数
    //权限修饰符可以扩大，
    
    @Override//重写
    public void run(){
        System.out.println("学生跑！");
    }

    public void study(){
        System.out.println("跑起来！");
    }

}

//主函数对类调用

public class main {
    public static void main(String[] args) {
        Student stu = new Student("asd",15);
        stu.run();
        System.out.println(stu.getName());
        System.out.println(stu.getAge());
    }
}

C.super关键字

• super代表的是父类对象
• super的使用方式
• super.属性名 用于在子类中调用父类被隐藏的同名实例变量
• super([参数列表]) 用于在子类的构造方法中调用父类的构造方法

注意（super)

1. 每一个子类的构造方法在没有显示调用super()系统都会提供一个默认的super()
2. super() 书写在第一行
3. 可以在子类构造方法中显示调用super(),完成对特定父类构造方法的调用**

属性为Public

父类：

public class Person {

    public int abc = 333333;
  }

子类：

public class Student extends Person {

    public int abc = 1;
    }

//super
public void info(){
    System.out.println(this.abc);//调用本类
    System.out.println(super.abc);//调用父类
}

属性为pravate,父类创建构造器的时候。

public class Person {
    private String name;
    private int age;
    private String wojiao;

    //构造器
    public Person(String name, int age, String wojiao) {
        this.name = name;
        this.age = age;
        this.wojiao = wojiao;
    }
}

public class Student extends Person {
    private String id;
    private int state;
    
	//super
    //可以通过super()小括号调用父类的构造方法
    //构造器
    public Student(String id,String name, int age, String wojiao) {
        super(name, age, wojiao);
        this.id = id;
    }
}

写类的时候要写两个构造器，一个有参，一个无参。（有用！！！！！）

D.总结代码（利用代码实现各个知识点）

Per_1类父类。

package com.jicheng.super_1;

public class Per_1 {
    private String name;
    private int age;
    public String sex;


    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 void running() {
        System.out.println("你再跑一个我看看！");
    }

    //方法2
    public void info(){
        System.out.println("我是Peo_1类的:");
        System.out.println(this.getName());
    }


    //构造方法无参数
    public Per_1() {

    }

    //构造方法有参数
    public Per_1(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;

    }
}

子类：Stu_1类。

package com.jicheng.super_1;

public class Stu_1 extends Per_1{
    private String rever;
    private  int day;

    //私有变量的修改值方法
    public String getRever() {
        return rever;
    }

    //私有变量的获取值方法
    public void setRever(String rever) {
        this.rever = rever;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    //方法重写
    @Override
    public void running(){
        System.out.println("你看我跑不跑的！");
    }

    public void who(){
        super.info();//调用父类的方法
    }

    //无参数构造方法
    public Stu_1(){

    }

    //有参数构造方法
    public Stu_1(String name,int age,String sex,String rever,int day){
        super(name,age,sex);//父类的属性
        this.rever = rever;
        this.day = day;

    }

}

测试主方法：

package com.jicheng.super_1;

public class main {
    public static void main(String[] args) {
        Stu_1 stu = new Stu_1();//无参实例化方法
        Stu_1 stu_1 = new Stu_1("张三",15,"sda","sadasd",16);//有参实例化方法


        stu.running();//调用重写的方法
        stu.who();//调用输出父类信息方法
        stu_1.who();//有参的调用

        stu.setName("李四");//给Per_1中的name初始化值
        stu.who();//调用输出父类信息方法

    }
}

运行结果：