校园信息管理系统 Day03-学生功能的抽取方法优化- 继承原理的优化

最新推荐文章于 2024-07-02 00:50:11 发布

Gold 大龙

最新推荐文章于 2024-07-02 00:50:11 发布

阅读量113

点赞数 1

分类专栏：校园信息管理系统文章标签： java-ee java

本文链接：https://blog.csdn.net/lorikiller/article/details/123762986

版权

校园信息管理系统专栏收录该内容

4 篇文章 0 订阅

订阅专栏

2.2.2.6学生功能的优化——抽取成方法

studentController中都需要进行输入学号的操作，对其进行方法的抽取，并微改输入语句，快捷键：ctrl+alt+m
这里要注意添加方法中的判断语句是

   if (flag) {//存在
                System.out.println("请重新输入");
            } else {//不存在
                break;
            }

与其相反，不能抽取为一个方法

    //输入id
    private String getString() {
        String sid;
        while (true) {
            System.out.println("请输入id");
            sid = sc.next();
            //把id给业务员，但业务员也无权修改数据库的信息
            boolean flag = studentService.isExist(sid);
            if (!flag) {//id不存在，则重新输入
                System.out.println("id不存在，请重新输入");
            } else {
                break;
            }
        }
        return sid;
    }

studentController中添加学生和修改都需要进行学生封装的操作，对其进行方法的抽取

//封装学生
    public Student getStudent(String sid) {
        System.out.println("请输入姓名");
        String name = sc.next();
        System.out.println("请输入年龄");
        String age = sc.next();
        System.out.println("请输入生日");
        String birthday = sc.next();
        //封装数据
        //创造一个学生
        Student student = new Student();
        student.setSid(sid);
        student.setName(name);
        student.setAge(age);
        student.setBirthday(birthday);
        return student;
    }

2.2.3老师环境的搭建

domain中的学生类直接复制粘贴到domain，随后改名
新建类。完成框架的建设

2.2.4系统的优化

2.2.4.1 集成改进：优化原理：继承

把老师类和学生类向上提取成一个Person类，同时删除老师类和学生类中所有代码，然后idea自动生成构造方法

package domain;

public class Teacher extends Person {
    public Teacher(String sid, String name, String age, String birthday) {
        super(sid, name, age, birthday);
    }

    public Teacher() {
    }
}

package domain;

public class Student extends Person{
    public Student(String sid, String name, String age, String birthday) {
        super(sid, name, age, birthday);
    }

    public Student() {
    }
}

在封装学生的时候，我们是调用无参构造的方法，我们也可以调用有参构造的方法，由于我们的开发原则：对扩展内容开放，对修改内容关闭。我们新建一个OtherStudentController，并与StudentController一同继承于BaseStudentController，并且把entry中的StudentController换成OtherStudentController
删除子类与父类相同的代码逻辑，保留子类独有的代码逻辑
+父类更改要重写的方法，然后return

//  父类封装学生
    public Student getStudent(String sid) {
        return null;
    }

OtherStudentController的封装学生方法

    private Scanner sc = new Scanner(System.in);
    //封装学生
    public Student getStudent(String sid) {
        System.out.println("请输入姓名");
        String name = sc.next();
        System.out.println("请输入年龄");
        String age = sc.next();
        System.out.println("请输入生日");
        String birthday = sc.next();
        //封装数据
        //创造一个学生
        Student student = new Student(sid,name,age,birthday);
        return student;
    }

StudentController的封装学生方法

public class StudentController extends BaseStudentController{
    private Scanner sc = new Scanner(System.in);
    //封装学生
    public Student getStudent(String sid) {
        System.out.println("请输入姓名");
        String name = sc.next();
        System.out.println("请输入年龄");
        String age = sc.next();
        System.out.println("请输入生日");
        String birthday = sc.next();
        //封装数据
        //创造一个学生
        Student student = new Student();
        student.setSid(sid);
        student.setName(name);
        student.setAge(age);
        student.setBirthday(birthday);
        return student;
    }
}

3知识点的引入

3.1继承

3.1.1引入

根据上面的案例，老师类和学生类有相同的属性，相同的方法放，具有共性，向上抽取，关键字extend，特点：子类可以直接使用父类中非私有的成员

3.1.2优点

提高代码的复用性，维护性，并且让类与类产生了联系，是多态的前提

3.1.3缺点

继承是侵入性的，降低代码的灵活性：子类必须拥有父类非私有的属性和方法
增强了代码的耦合性

3.1.4使用场景

1 有共性 2：产生了is a 的关系：例子我是帅哥，你也是帅哥，提取帅哥为父类，

3.1.5继承特点

只支持单继承和多层继承（爷祖）

3.1.6继承的成员变量访问特点

就近原则

public class one {
    public static void main(String[] args) {
        zi zi = new zi();
        zi.mothed1();
        zi.mothed2();
        zi.mothed3();
    }
}
//fu类
class fu {
    int a = 10;
}
//子类
class zi extends fu {
    int a = 20;
    public void mothed1() {
        System.out.println(a+"就近原则");
    }
    public void mothed2() {
        int a =30;
        System.out.println(this.a+"this关键字返回本类成员变量");
        System.out.println(a+"局部变量");
    }
    public void mothed3() {
        System.out.println(super.a+"super返回父类");
    }
}

3.1.6.1 this and super

this&super关键字：
- this：代表本类对象的引用
- super：代表父类存储空间的标识(可以理解为父类对象引用)
this和super的使用分别
- 成员变量：
  - this.成员变量 - 访问本类成员变量
  - super.成员变量 - 访问父类成员变量
- 成员方法：
  - this.成员方法 - 访问本类成员方法
  - super.成员方法 - 访问父类成员方法
构造方法：
- this(…) - 访问本类构造方法
- super(…) - 访问父类构造方法

3.1.7继承的成员方法访问特点

先去子类找，没有再去父类找

public class Two {
    public static void main(String[] args) {
        zi2 zi = new zi2();
        zi.mothed2();
        zi.mothed3();

    }
}

//fu类
class fu2 {
    //fu类方法
    public void mothed() {
        System.out.println("fu2类方法");
    }
}

//子类
class zi2 extends fu2 {

    //子类与父类同名方法
    public void mothed() {
        System.out.println("zi2类方法");
    }

//子类中的方法通过super调用父类同名方法
    public void mothed2() {
        super.mothed();
    }
// 默认有个this.  -- 调用子类方法
    public void mothed3() {
        mothed();
    }
}

3.1.8方法的重写

1、方法重写概念
- 子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）
2、方法重写的应用场景
- 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

//需求 升级手机功能
public class Three {
    public static void main(String[] args) {
        ipear2  i =new ipear2();
        i.smallBlack();

    }
}

//ipear1类-----一代
class ipear1 {
    //打电话
    public void call(String name) {
        System.out.println("给" + name + "打电话");
    }
//只会说英文
    public void smallBlack() {
        System.out.println("speak English");
    }
}

//二代
class ipear2 extends ipear1 {
    //进行重写
    public void smallBlack() {
        //调用父类的方法
        super.smallBlack();
        //添加自己的方法
        System.out.println("speak Chinese");
    }

}

3.1.8.1方法重写的注意事项

私有方法不能被重写(父类私有成员子类是不能继承的)
子类方法访问权限不能低于父类的访问权限
静态方法不能被重写,如果子类也有相同的方法,并不是重写的父类的方法，子类只是将父类的方法隐藏起来了

3.1.9权限修饰符

在这里插入图片描述

3.1.10继承中构造方法的访问特点（idea自动生成）

在这里插入图片描述
注意：子类中所有的构造方法默认都会访问父类中无参的构造方法

子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()

问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？

1. 通过使用super关键字去显示的调用父类的带参构造方法
2. 子类通过this去调用本类的其他构造方法,本类其他构造方法再通过super去手动调用父类的带参的构造方法

注意: this(…)super(…) 必须放在构造方法的第一行有效语句，并且二者不能共存

注意：super 会在堆内存开辟自己的存储空间来存放父类成员