java笔记Day06

继承

extends关键字 意思是“扩展”。子类是父类的扩展。

java中类只有单继承，没有多继承！

子类和父类之间。从意义上讲应该具有“is a”的关系

public class Student extends Person{}

• super

​ 1.super调用父类的构造方法，必须在构造方法的第一个

​ 2.super必须只能出现在子类的方法或构造方法中！

​ 3.super和this不能同时调用构造方法！

• super和this

​ 代表对象不同：

​ this:本身调用者这个对象

​ super:代表父类对象

​ 前提：

​ this:没有继承也能使用

​ super:只能在继承条件才可以使用

​ 构造方法

​ this();本类的构造

​ super();父类的构造

//java中所有类都默认或直接继承Object类
public class Person {
    String name = "人";
    int age;
    //public公共的
    //protected受保护的
    //default默认的可不写
    //private私有的
    private int money = 1_0000_0000;//设置为私有的只能使用getset方法来修改值

    public void test(){
        System.out.println("Person");
    }

    public void print(){
        System.out.println("Person123");
    }

    public Person() {
        System.out.println("Person无参数构造器执行了");
    }

    public Person(String name, int age, int money) {
        this.name = name;
        this.age = age;
        this.money = money;
    }

    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 int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

//继承Person类
//子类继承了父类就会拥有父类除私有的全部属性和方法
public class Student extends Person{
    private String name = "学生李华";

    public Student() {
        //隐藏代码，默认调用了父类的无参构造
        //super();调用父类的构造器必须放在子类的第一行
        System.out.println("student无参数构造器执行了");
    }

    public void print(){
        System.out.println("Student123");
    }
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
        print();
        this.print();
        super.print();
    }
}

Student student = new Student();
        student.test();//调用Student类继承的Person类的test()方法
        student.test("啦啦啦");//调用Sudent类的test()方法
        System.out.println(student.getMoney());//调用Student类继承的Person类的money属性

• 方法的重写

  需要有继承关系，子类重写父类的方法！

  1.方法名必须相同

  2.参数列表必须相同

  3.修饰符：父类到子类范围可以扩大但不能缩小：public>protected>default>private

  4.抛出的异常范围：可以被缩小，不能扩大

​ 重写，子类和父类的方法必须一致：方法体不同！

重写的原因：父类的功能子类不一定需要，或者不一定满足。

多态

多态是指，针对某个类型的方法调用，其真正执行的方法取决于运行时期实际类型的方法。

多态存在的条件：

​ 有继承关系

​ 子类重写父类方法

​ 父类引用指向子类对象

多态是方法的多态，属性没有多态性。

public class Polymorphic {
    public static void main(String[] args) {
    	//给一个有普通收入、工资收入和享受国务院特殊津贴的小伙伴算税
        Income[] incomes = new Income[]{
          new Income(3000),
          new Salary(7500),
          new StateCouncilSpecialAllowance(15000)
        };
        System.out.println(TotalTax(incomes));
    }
    public static double TotalTax(Income... incomes){
        double total = 0;
        for (Income income:incomes) {
            total+= income.getTax();
        }
        return total;
    }
}
class Income{
    protected double Income;

    public Income(double income) {
        Income = income;
    }

    public double getTax(){
        return Income * 0.1;//税率10%
    }
}
class Salary extends Income{
    public Salary(double income) {
        super(income);
    }

    @Override
    public double getTax() {
        if (Income<5000){
            return 0;
        }
        return (Income - 5000) * 0.2;

    }
}
class StateCouncilSpecialAllowance extends Income{
    public StateCouncilSpecialAllowance(double income) {
        super(income);
    }

    @Override
    public double getTax() {
        return 0;
    }
}