TEXT   27

Untitled

Guest on 12th January 2022 07:21:55 AM

  1. import java.util.ArrayList;
  2.  
  3. public class Course {
  4.    private String id;
  5.    private String name;
  6.    private Instructor instructor;
  7.    private ArrayList<Student> students;
  8.  
  9.    public Course(String id, String name) {
  10.        this.id = id;
  11.        this.name = name;
  12.        students = new ArrayList<Student>();
  13.  
  14.    }
  15.  
  16.    public void addStudent(Student a) {
  17.        students.add(a);
  18.    }
  19.  
  20.    public void removeStudent(Student b) {
  21.        students.remove(b);
  22.    }
  23.  
  24.    public String getId() {
  25.        return id;
  26.    }
  27.  
  28.    public String getName() {
  29.        return name;
  30.    }
  31.  
  32.    public Instructor getInstructor() {
  33.        return instructor;
  34.    }
  35.  
  36.    public ArrayList<Student> getStudents() {
  37.        return students;
  38.    }
  39.  
  40.    public void setInstructor(Instructor instructor) {
  41.        this.instructor = instructor;
  42.  
  43.    }
  44.  
  45.    public void listStudents() {
  46.        System.out.println("Students registered in " + this.getName());
  47.        for (int i = 0; i < students.size(); i++) {
  48.            System.out.println("" + students.get(i).getName());
  49.        }
  50.    }
  51.  
  52.    public String toString() {
  53.        return "This course's id is " + this.getId() + ". The name is " + this.getName();
  54.    }
  55.  
  56. }
  57.  
  58. Department.java:
  59.  
  60. import java.util.ArrayList;
  61.  
  62. public class Department {
  63.  
  64.    private String name;
  65.    private ArrayList<Course> courses;
  66.    private ArrayList<Instructor> instructors;
  67.    private ArrayList<Student> students;
  68.  
  69.    public Department(String name) {
  70.        this.name = name;
  71.        courses = new ArrayList<Course>();
  72.        instructors = new ArrayList<Instructor>();
  73.        students = new ArrayList<Student>();
  74.  
  75.    }
  76.  
  77.    public void addInstructor(String a) {
  78.        Instructor ins = new Instructor(a);
  79.        instructors.add(ins);
  80.    }
  81.  
  82.    public void addStudent(String a) {
  83.        Student ýnd = new Student(a);
  84.        students.add(ýnd);
  85.    }
  86.  
  87.    public void assignInstructorToCourse(String instructorName, String courseId) {
  88.        int x1 = 0;
  89.        int x2 = 0;
  90.        int y1 = 0;
  91.        int y2 = 0;
  92.  
  93.        for (int i = 0; i < instructors.size(); i++) {
  94.  
  95.            if (instructors.get(i).getName().equals(instructorName)) {
  96.                x1 = 1;
  97.                x2 = i;
  98.            }
  99.        }
  100.  
  101.        if (x1 == 0) {
  102.            System.out.println("Instructor Not Found: " + instructorName);
  103.        }
  104.  
  105.        for (int i = 0; i < courses.size(); i++) {
  106.  
  107.            if (courses.get(i).getId().equals(courseId)) {
  108.                y1 = 1;
  109.                y2 = i;
  110.            }
  111.        }
  112.  
  113.        if (y1 == 0) {
  114.            System.out.println("Course not found: " + courseId);
  115.        }
  116.  
  117.        if (x1 == 1 && y1 == 1) {
  118.            instructors.get(x2).addCourse(courses.get(y2));
  119.            courses.get(y2).setInstructor(instructors.get(x2));
  120.  
  121.        }
  122.    }
  123.  
  124.    public void createCourse(String courseId, String courseName) {
  125.        Course c = new Course(courseId, courseName);
  126.        courses.add(c);
  127.    }
  128.  
  129.    public Course getCourse(String st) {
  130.        int x = 0;
  131.        for (int i = 0; i < courses.size(); i++) {
  132.            if (courses.get(i).getId().equals(st) || courses.get(i).getName().equals(st)) {
  133.                x = i;
  134.            }
  135.        }
  136.        return courses.get(x);
  137.  
  138.    }
  139.  
  140.    public ArrayList<Student> getStudents() {
  141.        return students;
  142.    }
  143.  
  144.    public Instructor getInstructorByName(String st) {
  145.        int x = -1;
  146.        for (int i = 0; i < instructors.size(); i++) {
  147.            if (instructors.get(i).getName().equals(st)) {
  148.                x = i;
  149.            }
  150.        }
  151.        if (x == -1) {
  152.            return null;
  153.        }
  154.        return instructors.get(x);
  155.    }
  156.  
  157.    public void listInstructors() {
  158.        System.out.println("Instructors registered in this department are: ");
  159.        for (int i = 0; i < instructors.size(); i++) {
  160.            System.out.println("" + instructors.get(i).getId() + ", " + instructors.get(i).getName() + ", "
  161.                    + instructors.get(i).getEmail());
  162.  
  163.        }
  164.    }
  165.  
  166.    public void listCourses() {
  167.        System.out.println("Courses given by this department are: ");
  168.        int x = 0;
  169.        for (int i = 0; i < courses.size(); i++) {
  170.            if (instructors.get(x).getCourses().size() != 0) {
  171.                if (courses.get(i).getName().equals(instructors.get(x).getCourses().get(0).getName())) {
  172.                    System.out.println("" + courses.get(i).getId() + " " + courses.get(i).getName() + " by "
  173.                            + instructors.get(x).getName());
  174.                    x++;
  175.                } else {
  176.                    System.out.println("" + courses.get(i).getId() + " " + courses.get(i).getName());
  177.  
  178.                }
  179.            }
  180.  
  181.            else {
  182.                System.out.println("" + courses.get(i).getId() + " " + courses.get(i).getName());
  183.            }
  184.        }
  185.    }
  186.  
  187.    public void listStudents() {
  188.        System.out.println("Students registered in this department are: ");
  189.        for (int i = 0; i < students.size(); i++) {
  190.            System.out.println("" + students.get(i).getId() + ", " + students.get(i).getEmail() + ", "
  191.                    + students.get(i).getName());
  192.        }
  193.  
  194.    }
  195.  
  196.    public ArrayList<Instructor> getInstructors() {
  197.        return instructors;
  198.    }
  199.  
  200. }
  201.  
  202. GradeItem.java:
  203.  
  204. public class GradeItem {
  205.    private String courseId;
  206.    private String examId;
  207.    private int grade;
  208.  
  209.    public GradeItem(String courseId, String examId, int grade) {
  210.        this.courseId = courseId;
  211.        this.examId = examId;
  212.        this.grade = grade;
  213.    }
  214.  
  215.    public String getCourseId() {
  216.        return courseId;
  217.    }
  218.  
  219.    public String getExamId() {
  220.        return examId;
  221.    }
  222.  
  223.    public int getGrade() {
  224.        return grade;
  225.    }
  226.  
  227.    public String toString() {
  228.        return "This GradeItems's courseID is " + this.getCourseId() + " and examID is" + this.getExamId()
  229.                + " and grade is " + this.getGrade();
  230.    }
  231.  
  232. }
  233.  
  234. Instructor.java:
  235.  
  236. import java.util.ArrayList;
  237. import java.util.Random;
  238.  
  239. public class Instructor extends Person {
  240.  
  241.    private ArrayList<Course> courses;
  242.  
  243.    public Instructor(String name) {
  244.        super(name);
  245.        courses = new ArrayList<Course>();
  246.        initEmail();
  247.  
  248.    }
  249.  
  250.    public void addCourse(Course a) {
  251.        courses.add(a);
  252.  
  253.    }
  254.  
  255.    public ArrayList<Course> getCourses() {
  256.        return courses;
  257.    }
  258.  
  259.    public void initEmail() {
  260.        String[] xd = this.getName().toLowerCase().split(" ");
  261.  
  262.        String ak = "";
  263.        for (int i = 0; i < xd.length; i++) {
  264.  
  265.            if (i == 0) {
  266.                ak = ak + "" + xd[i];
  267.                ak = ak + ".";
  268.            }
  269.            if (i == 1) {
  270.                ak = ak + "" + xd[i];
  271.                ak = ak + "@ozyegin.edu.tr";
  272.            }
  273.        }
  274.  
  275.        this.setEmail(ak);
  276.    }
  277.  
  278.    public void registerExamGrades(String courseId, String examId) {
  279.        Random rgn = new Random();
  280.  
  281.        int y = 0;
  282.        int ds = 0;
  283.        for (int i = 0; i < courses.size(); i++) {
  284.            if (courseId.equals(courses.get(i).getId())) {
  285.                y = 1;
  286.                ds = i;
  287.                break;
  288.            }
  289.        }
  290.        if (y == 0) {
  291.            System.out.println("Instructor " + this.getName() + " cannot grade the " + courseId + ".");
  292.        }
  293.        if (y == 1) {
  294.            for (int i = 0; i < courses.get(ds).getStudents().size(); i++) {
  295.                int x = rgn.nextInt(100);
  296.                GradeItem dýdýn = new GradeItem(courseId, examId, x);
  297.                courses.get(ds).getStudents().get(i).getGrades().add(dýdýn);
  298.            }
  299.        }
  300.    }
  301.  
  302.    public void listGradesForExam(String courseId, String examId) {
  303.        System.out.println("" + courseId + " " + examId + " grades are: ");
  304.        int xyz = 0;
  305.        int x = 0;
  306.        for (int i = 0; i < courses.size(); i++) {
  307.            if (courseId.equals(courses.get(i).getId())) {
  308.                xyz = 1;
  309.                x = i;
  310.                break;
  311.            }
  312.        }
  313.        if (xyz == 1) {
  314.            for (int a = 0; a < courses.get(x).getStudents().size(); a++) {
  315.                System.out.println("" + courses.get(x).getStudents().get(a).getName() + ": ["
  316.                        + courses.get(x).getStudents().get(a).getGradeItem(courseId, examId).getExamId() + ": "
  317.                        + courses.get(x).getStudents().get(a).getGradeItem(courseId, examId).getGrade() + "]");
  318.            }
  319.  
  320.        }
  321.  
  322.    }
  323.  
  324.    public void printAverageGradeForExam(String courseId, String examId) {
  325.        System.out.print("" + courseId + " " + examId + " average grade is:");
  326.        int xyz = 0;
  327.        int x = 0;
  328.        double gradetoplam = 0;
  329.        int sayac = 0;
  330.        for (int i = 0; i < courses.size(); i++) {
  331.            if (courseId.equals(courses.get(i).getId())) {
  332.                xyz = 1;
  333.                x = i;
  334.                break;
  335.            }
  336.        }
  337.        if (xyz == 1) {
  338.            for (int a = 0; a < courses.get(x).getStudents().size(); a++) {
  339.  
  340.                gradetoplam = gradetoplam
  341.                        + courses.get(x).getStudents().get(a).getGradeItem(courseId, examId).getGrade();
  342.                sayac++;
  343.            }
  344.  
  345.        }
  346.        System.out.println("" + gradetoplam / sayac);
  347.  
  348.    }
  349.  
  350. }
  351.  
  352. Person.java:
  353.  
  354. public abstract class Person {
  355.  
  356.    private String id;
  357.    private String name;
  358.    private String email;
  359.    public static int x = 0;
  360.  
  361.    public Person(String name) {
  362.        this.name = name;
  363.        idCreator();
  364.    }
  365.  
  366.    public abstract void initEmail();
  367.  
  368.    public String getId() {
  369.        return id;
  370.    }
  371.  
  372.    public String getName() {
  373.        return name;
  374.    }
  375.  
  376.    public String getEmail() {
  377.        return email;
  378.    }
  379.  
  380.    public void setEmail(String email) {
  381.        this.email = email;
  382.    }
  383.  
  384.    public void idCreator() {
  385.        x++;
  386.        String[] xd = this.getName().toLowerCase().split(" ");
  387.  
  388.        if (x < 10) {
  389.            id = xd[0].charAt(0) + "" + xd[1].charAt(0) + "000" + x;
  390.        }
  391.        if (x >= 10) {
  392.            id = xd[0].charAt(0) + "" + xd[1].charAt(0) + "00" + x;
  393.        }
  394.    }
  395.  
  396.    public String toString() {
  397.        return "My id is " + this.getId() + ". My name is " + this.getName() + ". My email is " + this.getEmail();
  398.    }
  399. }
  400.  
  401. Student.java:
  402.  
  403. import java.util.ArrayList;
  404.  
  405. public class Student extends Person {
  406.  
  407.    private ArrayList<Course> enrolledCourses;
  408.    private ArrayList<GradeItem> grades;
  409.  
  410.    public Student(String name) {
  411.        super(name);
  412.        enrolledCourses = new ArrayList<Course>();
  413.        grades = new ArrayList<GradeItem>();
  414.        initEmail();
  415.    }
  416.  
  417.    public void initEmail() {
  418.        String[] xd = this.getName().toLowerCase().split(" ");
  419.        String ak = "";
  420.        for (int i = 0; i < xd.length; i++) {
  421.  
  422.            if (i == 0) {
  423.                ak = ak + "" + xd[i];
  424.                ak = ak + ".";
  425.            }
  426.            if (i == 1) {
  427.                ak = ak + "" + xd[i];
  428.                ak = ak + "@ozyegin.edu.tr";
  429.            }
  430.        }
  431.        this.setEmail(ak);
  432.    }
  433.  
  434.    public void registerToCourse(Course course) {
  435.  
  436.        enrolledCourses.add(course);
  437.        course.addStudent(this);
  438.  
  439.        if (course.getInstructor() == null) {
  440.            System.out.println("Course not available");
  441.        }
  442.    }
  443.  
  444.    public void dropCourse(Course course) {
  445.        enrolledCourses.remove(course);
  446.        course.removeStudent(this);
  447.    }
  448.  
  449.    public GradeItem getGradeItem(String courseId, String examId) {
  450.        int x = -1;
  451.        for (int i = 0; i < grades.size(); i++) {
  452.            if (grades.get(i).getCourseId().equals(courseId) && grades.get(i).getExamId().equals(examId)) {
  453.                x = i;
  454.            }
  455.        }
  456.        if (x == -1) {
  457.            return null;
  458.        }
  459.  
  460.        return grades.get(x);
  461.  
  462.    }
  463.  
  464.    public void listGrades() {
  465.        for (int i = 0; i < grades.size(); i++) {
  466.            if (i != 0) {
  467.                if (grades.get(i - 1).getCourseId().equals(grades.get(i).getCourseId())) {
  468.                    System.out.println(" [" + grades.get(i).getExamId() + ": " + grades.get(i).getGrade() + "]");
  469.                } else {
  470.                    System.out.println("" + grades.get(i).getCourseId() + " grades of " + this.getName() + " ["
  471.                            + grades.get(i).getExamId() + ": " + grades.get(i).getGrade() + "]");
  472.                }
  473.            } else {
  474.                System.out.println("" + grades.get(i).getCourseId() + " grades of " + this.getName() + " ["
  475.                        + grades.get(i).getExamId() + ": " + grades.get(i).getGrade() + "]");
  476.            }
  477.        }
  478.  
  479.    }
  480.  
  481.    public ArrayList<GradeItem> getGrades() {
  482.        return grades;
  483.    }
  484.  
  485. }
  486.  
  487. SampleMain.java:
  488.  
  489. import java.util.Random;
  490.  
  491. public class SampleMain {
  492.  
  493.    public static void main(String[] args) {
  494.  
  495.        System.out.println("-----------------1-------------------");
  496.        Department department = new Department("Computer Science");
  497.  
  498.        department.addInstructor("Reyyan Yeniterzi");
  499.        department.addInstructor("Reyhan Aydogan");
  500.        department.addInstructor("Murat Sensoy");
  501.        department.listInstructors();
  502.  
  503.        System.out.println("-----------------2-------------------");
  504.  
  505.        department.createCourse("CS102", "Object Oriented Programming");
  506.        department.createCourse("CS201", "Data Structures");
  507.        department.createCourse("CS101", "Introduction to CS");
  508.        department.createCourse("CS404", "Digital Image Processing");
  509.  
  510.        department.listCourses();
  511.  
  512.        System.out.println("----------------3--------------------");
  513.  
  514.        department.assignInstructorToCourse("Reyyan Yeniterzi", "CS102");
  515.        department.assignInstructorToCourse("Reyhan Aydogan", "CS101");
  516.        department.assignInstructorToCourse("Reyyan Aydogan", "CS102");
  517.        department.assignInstructorToCourse("Murat Sensoy", "CS333");
  518.  
  519.        department.listCourses();
  520.  
  521.        System.out.println("------------------4------------------");
  522.  
  523.        for (int i = 0; i < 10; i++)
  524.            department.addStudent(createRandomName());
  525.  
  526.        department.listStudents();
  527.  
  528.        System.out.println("------------------5------------------");
  529.  
  530.        Course oop = department.getCourse("CS102");
  531.        for (int i = 0; i < 5; i++) {
  532.            Student student = department.getStudents().get(i);
  533.            student.registerToCourse(oop);
  534.  
  535.        }
  536.  
  537.        oop.listStudents();
  538.  
  539.        System.out.println("-----------------6-------------------");
  540.  
  541.        Course intro = department.getCourse("Introduction to CS");
  542.        for (int i = 0; i < 3; i++) {
  543.            Student student = department.getStudents().get(i);
  544.            student.registerToCourse(intro);
  545.        }
  546.  
  547.        intro.listStudents();
  548.  
  549.        System.out.println("------------------7------------------");
  550.  
  551.        Student student = department.getStudents().get(2);
  552.        student.dropCourse(oop);
  553.        oop.listStudents();
  554.  
  555.        System.out.println("------------------8------------------");
  556.  
  557.        Course image = department.getCourse("CS404");
  558.        student.registerToCourse(image); // no instructor is assigned to course,
  559.                                            // print error message
  560.  
  561.        System.out.println("-----------------9-------------------");
  562.  
  563.        Instructor reyyan = department.getInstructorByName("Reyyan Yeniterzi");
  564.        reyyan.registerExamGrades("CS102", "Midterm-1");
  565.        reyyan.registerExamGrades("CS102", "Midterm-2");
  566.  
  567.        Instructor murat = department.getInstructorByName("Murat Sensoy");
  568.        murat.registerExamGrades("CS102", "Midterm-3"); // instructor murat does
  569.                                                        // not have the course,
  570.                                                        // print error
  571.        Instructor reyhan = department.getInstructorByName("Reyhan Aydogan");
  572.        reyhan.registerExamGrades("CS101", "Midterm-1");
  573.  
  574.        System.out.println("---------------------10---------------");
  575.  
  576.        Student student0 = department.getStudents().get(0);
  577.        student0.listGrades();
  578.  
  579.        System.out.println("-------------------11-----------------");
  580.  
  581.        reyyan.listGradesForExam("CS102", "Midterm-1");
  582.  
  583.        System.out.println("------------------12------------------");
  584.  
  585.        reyyan.printAverageGradeForExam("CS102", "Midterm-1");
  586.  
  587.    }
  588.  
  589.    /*
  590.    * creates a random name
  591.    */
  592.    private static String createRandomName() {
  593.        String[] firstNames = { "Ali", "Ayse", "Ahmet", "Mehmet", "Mustafa", "Gizem", "Sibel", "Burak", "Bahar" };
  594.        String[] lastNames = { "Yilmaz", "Caliskan", "Korkmaz", "Kaya", "Akar", "Sonmez", "Celikoglu" };
  595.  
  596.        Random random = new Random();
  597.  
  598.        String firstName = firstNames[random.nextInt(firstNames.length)];
  599.        String lastName = lastNames[random.nextInt(lastNames.length)];
  600.        String name = firstName + " " + lastName;
  601.  
  602.        return name;
  603.  
  604.  

Raw Paste


Login or Register to edit or fork this paste. It's free.