Java面向对象（中篇）

今天开始学习方法的重写，以下素材均来自B站尚硅谷。

方法的重写（override / overweight）

1.重写，子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作

2.应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名参数的方法时，实际执行的是子类重写父类的方法。

3.重写的规定：

                        方法的声明：权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{

                                                //方法体

                                                } 

                       约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法  

        3.1子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同

        3.2子类重写的方法的权限修饰符不小于父类被重写的方法权限修饰符

                >特殊情况：子类不能重写父类中声明为private权限的方法

        3.3返回值类型：

                >父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void

                >父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是类·或A类的子类

                >父类被重写的方法的返回值类型是基本数据类型（比如：double），则子类重写的方法的返回值类型必须是相同的基本数据类型

        3.4子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

注：子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）

public class Person {
    String name;
    int age;

    public Person(){

    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println("吃饭");
    }
    public void walk(int distance){
        System.out.println("走路，走的距离是：" + distance + "公里");
        show();
    }
    private void show(){
        System.out.println("我是一个人");
    }
}

public class Student extends Person{
    String major;
    public Student(){

    }
    public Student(String major){
        this.major = major;
    }
    public void study(){
        System.out.println("学习，专业：" + major);
    }
    public void eat(){
        System.out.println("学生应该多吃蔬菜");
    }
    public void show(){
        System.out.println("我是一个学生");
    }

}

public class PersonTest {
    public static void main(String[] args){
        Student s = new Student("大数据技术与应用");
        s.eat();
        s.walk(10);

        s.study();
        Person p1 = new Person();
        p1.eat();
    }
}

4种权限修饰符：

public class Order {
    private int orderPrivate;
    int orderDefault;
    protected int orderProtected;
    public int orderPublic;

    private void methodPrivate(){
        orderPrivate = 1;
        orderDefault = 2;
        orderProtected = 3;
        orderPublic = 4;
    }
    void methodDefault(){
        orderPrivate = 1;
        orderDefault = 2;
        orderProtected = 3;
        orderPublic = 4;
    }
    protected void methodProtected(){
        orderPrivate = 1;
        orderDefault = 2;
        orderProtected = 3;
        orderPublic = 4;
    }
    public void methodPublic(){
        orderPrivate = 1;
        orderDefault = 2;
        orderProtected = 3;
        orderPublic = 4;
    }
}

public class OrderTest {
    public static void main(String[] args){
        Order order = new Order();

        order.orderDefault = 1;
        order.orderProtected = 2;
        order.orderPublic = 3;

        order.methodDefault();
        order.methodProtected();
        order.methodPublic();
    }
}

同一个包中的其他类，不可以调用Order类种私有的属性、方法；

在不同包的子类中，不能调用Order类中声明为private和缺省权限的属性、方法；

不同包下的普通类（非子类）要使用Order类，不可以调用声明为private、缺省、protected权限的属性、方法；

super关键字的使用

1.super理解为：父类的

2.super可以用来调用：属性、方法、构造器

3.super的使用：调用属性和方法

        3.1我们可以在子类的方法或构造器中，通过使用“super.属性”或“super.方法”的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略“super.”

        3.2特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用“super.属性”的方式，表明调用的是父类中声明的属性。

        3.3特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用“super.方法”的方式，表明调用的是父类中被重写的方法。

4.super调用构造器

        4.1我们可以在子类的构造器中显式的使用“super（形参列表）”的方式，调用父类中声明指定的构造器

        4.2“super（形参列表）”的使用，必须声明在子类构造器的首行！

        4.3我们在类的构造器中，针对于“this（形参列表）”或“super（形参列表）”只能二选一

        4.4在构造器的首行，没有显式的声明“this（形参列表）”或“super（形参列表）”，则默认调用的是父类中空参的构造器：super()

        4.5在类的多个构造器中，至少有一个类的构造器中使用了“super（形参列表）”，调用父类中的构造器

public class Person {
    String name;
    int age;
    int id = 1001;
    public Person(){
        System.out.println("我无处不在！");
    }
    public Person(String name){
        this.name = name;
    }
    public Person(String name,int age){
        this(name);
        this.age = age;
    }

    public void eat(){
        System.out.println("人：吃饭");
    }
    public void walk(){
        System.out.println("人：走路");
    }
}

import com.sun.org.apache.xerces.internal.impl.xpath.XPath;

import javax.swing.*;

public class Student extends Person{

    String major;
    int id = 1002;
    public Student(){

    }
    public Student(String major){
        this.major = major;
    }
    public Student(String name,int age,String major){
        super(name,age);
        this.major = major;
    }

    public void eat(){
        System.out.println("学生，多吃有营养的事物");
    }

    public void study(){
        System.out.println("学生：学习知识");
        super.eat();
        this.walk();
    }

    public void show(){
        System.out.println("name = " + this.name + ",age = " + super.age);
        System.out.println("id = "+ id);
        System.out.println("id = "+ super.id);
    }
}

public class SuperTest {
    public static void main(String[] args){
        Student s = new Student();
        s.show();

        s.study();

        Student s1 = new Student("Tom",21,"IT");
        s1.show();

        System.out.println("***************");
        Student s2 = new Student();
    }
}

总结：今日学习了方法重写的理解、方法重写的细节、方法重新的练习、测试4种不同的权限修饰符、super调用属性与方法、super调用构造器。

明日计划：学习Java的多态性。