封装继承（代表性代码）

1.定义一个Person类

public class Person {
    
    private String name;  // 姓名
    private int age;      // 年龄
    
    public Person() {    // 无参构造
        super();
    }
    public Person(String name, int age) {  // 有参构造
        super();
        this.name = name;
        this.age = age;
    }
    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;
    }
    
   
    
    @Override  // 重写toString()方法
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    
    public void show() {
        System.out.println("Person类中的show()方法");
    }
    
    
    
}

2.写一个Student 学生类

public class Student extends Person {
    private int id;   // 学号
    
    public Student() {  // 无参构造
        super();
    }

    public Student(String name, int age,int id) {   // 有参构造
        
        super(name,age);  // 调用父类中的构造方法
        this.id = id;
    }


     //提供供外界访问的 get/set()方法
    public int getId() {
        return id;
    }


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

     @Override
    public String toString() {
        return "Student [id=" + id +" name="+getName()+" age="+getAge()+ "]";
    }


    @Override
    public void show() {
        System.out.println("Student类中重写后的show()方法");
         
    }
}

3.写一个 Teacher 教师类

package com.monkey1024;

public class Teacher extends Person {
    
    private double salary;  // 工资

    public Teacher() {
        super();
    }

    public Teacher(String name, int age,double salary) {
        super(name, age);
        this.salary = salary;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Person [name=" + getName() + ", age=" + getAge() + ", salary="+salary+"]";
    }

    @Override
    public void show() {
         System.out.println("Teacher类中重写后的show()方法");
    }

}

测试类：

public class Test {

    public static void main(String[] args) {
        
        // 创建一个学生类
        Student student = new Student("小茅棚",23,01);   // 姓名，年龄，学号
        System.out.println(student);
        student.show();
        System.out.println("--------------------");
        
        // 创建一个教师类
        Teacher teacher = new Teacher("马云",55,88888.8); // 姓名， 年龄， 工资
        System.out.println(teacher);
        teacher.show();

    }

}

控制台结果：

Student [id=1 name=小茅棚 age=23]
Student类中重写后的show()方法
--------------------
Person [name=马云, age=55, salary=88888.8]
Teacher类中重写后的show()方法

测试类中写如下内容：

public class Test {
    
    // 定义一个静态的print()方法，既能打印人类的功能，又能打印老师的功能 还能能打印学生的功能

    public static void print(Person p) {    // 形参要的是是一个Person类型
        p.show();
    }

    public static void main(String[] args) {
        Test.print(new Person());
        System.out.println("--------------");
        Test .print(new Student());
        System.out.println("--------------");
        Test.print(new Teacher());
        
     

    }

}

控制台结果：

Person类中的show()方法
--------------
Student类中重写后的show()方法
--------------
Teacher类中重写后的show()方法

public static void print(Person p) {

该方法中要求的是一个 Person类型的引用作为方法的形参

在main()方法的代码中，把Person类的子类 Student类的引用和 Teacher类的引用作为形参传递过去，并不报错。且运行阶段调用的是他们各自的方法。

代码改进：

如 Person类中，有 name 和 age属性，其中age代表的是年龄。

生活经验告诉我们，年龄通常不能小于0，且通常不会超过150岁。

但是在以上的代码中，将age设置为负数或 888，程序也正常运行。这显然是不符合逻辑的。

改动代码：

在setAge()方法中对传入的 age值做合理值判断

 public void setAge(int age) {
        if(age>0 && age<=150)   // 判断条件
        this.age = age;
        else
            System.out.println("年龄输入不符合常理....");
    }

在构造方法中将 this.age= age; 改为setAge(age);

public Person(String name, int age) {  // 有参构造
        super();
        this.name = name;
        // this.age = age;
        setAge(age);    
    }

测试：

System.out.println(new Person("james",888));

控制台打印结果：

年龄输入不符合常理....
Person [name=james, age=0]

同理，像salary、id 等属性都最好传值前做合理值判断，来避免发生夸张不合常理的运算结果

当然也可以使用暴力点的方式处理问题，若传入不符合常理的age值，直接让程序产生异常 (暂不补充)

还有注意：

super(); // 写在子类构造方法体的首行，表示调用父类中的无参构造

super(属性类型1，属性值1, 属性类型2 属性值2...); //表示调用父类中对应的有参构造

super.父类方法(); // 写在子类重写之后的方法体内，表示调用父类中的该方法

this关键字表示 --"当前对象" 谁调用该方法，this 代表的就是谁这个对象

封装继承（代表性代码）

猜你喜欢