面向对象 继承

java

OOP三大特性

• 封装 encapsulation
• 继承 inheritance
• 多态 polymorphism

继承的优点

• 增强了代码的复用性减少代码的冗余
• 正是因为有了继承才有了后边的多态

extends关键字

• 在java语言中，用extends关键字来表示一个类继承了另一个类

public class Teacher extends Person{ 
    //其余代码省略 
}

继承关系

• 子类继承父类特点：子类将拥有父类所有的方法以及属性()
• 注意：
• (1)父类中的成员(方法及属性)由private修饰子类无法继承
• (2)父类的构造方法子类无法继承‘
• (3)子类还可有拥有自己的方法以及属性
• java属于单继承，不支持多继承(所有的类都只能有一个父类)
• java不支持多继承(所有的类都只能有一个父类)，但是支持多层继承

多层继承

Animal类

public class Animal {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

Pet类

public class Pet extends Animal{}

Dog类

public class Dog extends Pet{}

Test测试类

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("旺财");
        String name = dog.getName();
        System.out.println(name+"是一只粉色的小狗");
    }
}

单继承(错误)举例说明：

public class A{
    public void D(){}
}
    public class B{
    public void D(){}
}
public class C extends A.B{
    //类中不允许出现2个完全相同的方法，这种写法是错误的，违背了java的单继承思想
    public void D(){}
    public void D(){}
}

父类Person

public class Person {
    private String name;
    private String sex;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

子类Student

public class Student extends Person {
    private String stuNo;
    public String getStuNo() {
        return stuNo;
    }
    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }
    public void showMessage(){
        System.out.println("姓名："+this.getName());
        System.out.println("性别："+this.getSex());
        System.out.println("年龄："+this.getAge());
        System.out.println("学号："+this.getStuNo());
    }
}

子类Teacher

public class Teacher extends Person{
    private String teaNo;
    public String getTeaNo() {
        return teaNo;
    }
    public void setTeaNo(String teaNo) {
        this.teaNo = teaNo;
    }
    public void showMessage(){
        System.out.println("姓名："+this.getName());
        System.out.println("性别："+this.getSex());
        System.out.println("年龄："+this.getAge());
        System.out.println("工号："+this.getTeaNo());
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        System.out.println("学生信息如下所示：");
        Student stu = new Student();
        stu.setName("苍井空");
        stu.setSex("女");
        stu.setAge(18);
        stu.setStuNo("9527");
        stu.showMessage();
        System.out.println("老师信息如下所示：");
        Teacher tea = new Teacher();
        tea.setName("饭岛爱");
        tea.setSex("女");
        tea.setAge(18);
        tea.setTeaNo("9527");
        tea.showMessage();
    }
}

super关键字

super和this这2大关键字的区别和联系

• this:代表当前类的对象，通过this可以访问当前类的成员
• super：代表当前类的父类对象，通过super可以访问父类的成员
• 使用super.父类成员 对应的属性或方法直接到父类里面去查找
• 使用this.父类成员 对应的属性或方法先到当前类里面去查找对应的属性或方法 如果没有找到，才去父类里面查找对应的属性或方法
• super();//调用父类默认构造方法
• 注意:不写也代表调用父类默认构造方法
• 调用父类构造方法是必须放在子类的构造方法内，而且必须放在构造方法的第一行

调用默认父类的构造方法

    public Pet(String name, int age, String sex, int health) {
        super();//调用父类默认构造方法
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.health = health;
    }

    public Pet(String name, int age, String sex, int health) {
        super(name,age,sex,health);//调用父类默认构造方法
    }

父类

public class Pet {
    private String name;
    private int age;
    private String sex;
    private int health;
    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 getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public int getHealth() {
        return health;
    }
    public void setHealth(int health) {
        this.health = health;
    }
}

子类

public class Penguin extends Pet{
    private String petNo;
    public Penguin(String name, int age, String sex, int health,String petNo) {
        super.setName(name);
        super.setAge(age);
        super.setSex(sex);
        super.setHealth(health);
        super(name,age,sex,health);//相当于上边
        this.petNo = petNo;
    }
    public String getPetNo() {
        return petNo;
    }
    public void setPetNo(String petNo) {
        this.petNo = petNo;
    }
}

方法重写

1. 方法重写：发生在子类和父类之间
2. 对于方法从写的理解：实质上就是子类将继承自父类的方法进行改写
   注意：
   （1）重写方法（子类）与被重写方法（父类） 方法名称 返回值 参数列表必须保持一致
   （2）子类方法（重写）访问修饰符子类访问权限不能小于父类方法（被重写方法）的访问权限
   3.子类对象调用父类重写方法是默认调用的是从写后的方法

父类Animal

public class Animal {
    public void music(){
        System.out.println("父类方法被调用，动物发出的叫声");
    }
}

子类Dog

public class Dog extends Animal{
    public void music(){
        System.out.println("子类重写父类方法被调用，小狗~~~汪汪汪");
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.music();
    }
}

final关键字

final关键字特点

• final可以用来修饰变量，方法，类
• final修饰的变量是一个常量，一旦赋了值就不能在修改（常量一般都和static关键字配合使用）
• final修饰类代表此类不能被继承
• final修饰方法代表此方法不能被重写

public class Dog extends Animal{
    public final static String name="张小明";
}
public class Test {
    public static void main(String[] args) {
        String name = Dog.name;
        System.out.println(name);
    }
}

toString

    //将当前对象转换成字符串输出
    public String toString() {
        String str = "姓名"+name+"性别"+sex+"年龄"+age+"编号"+idCard;
        return str;
    }
        public static void main(String[] args) {
        Person person = new Person("张三","女",18,"9527");
        System.out.println(person);
    }