Develop Reference

Refactoring in Java: Duplicated attributes

I am supposed to refactor duplicated attributes in Student class. I have Student and Professor classes as below. I am really confused about how to do refactoring with attributes. Should I add a new class, or made modifications in one of the classes. If so, how? I could not understand how to proceed with this to-do.
private final String matrNr;
private final String name;
private final int age;
private int semester;
private final String email;
public Student(String name, int age, String email, String matrNr, int semester) {
this.matrNr = matrNr;
this.name = name;
this.age = age;
this.semester = semester;
this.email = email;
}
public String getEmail() {
return email;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public int getSemester() {
return semester;
}
public String getMatrNr() {
return matrNr;
}
public void increaseSemester(){
semester = semester + 1;
}
}
And the professor is a like:
private final String persNr;
private final String name;
private final int age;
private final String email;
public Professor(String name, int age, String email, String persNr) {
this.persNr = persNr;
this.name = name;
this.age = age;
this.email = email;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
public String getEmail() {
return email;
}
public String getPersNr() {
return persNr;
}
}
Thanks for any kind of helps!

Your goal is to refactor duplicated attributes in the Student and Professor classes. The way to do this is to create a parent class which defines the common attributes (like "name"), and modify Student and Professor classes to extend the common parent class. In this way, both Students and Professors can have a "name", even though you have defined "name" only once in the common parent.
Below shows how you could do this with a common "Human" parent class, how the constructors would work, and how you could define a Student-only attribute (semester).
Here is a simple version a common Human class:
common "Human" class
each Human has a "name"
the name is set in the constructor (so when you're creating an object) and cannot be changed later ("name" is final; also no "setHuman()")
class Human {
private final String name;
public Human(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
Here's a simple Professor class:
by definition, a Professor is a Human (Professor extends Human)
when creating a Professor, you must specify the "name" (which is then passed to the Human constructor)
once you have a Professor, you can call getName() (which is defined on the Human class)
class Professor extends Human {
public Professor(String name) {
super(name);
}
}
Here's a simple Student class:
Student is a little different - in addition to a name, it also has a "semester"
when creating a Student, the constructor requires a name and semester, and the Student class itself keeps track of "semester" – so it's fine to have semester defined on Student, and name defined on Human.
you can call getName() (defined on Human)
you can call getSemester() (defined on Student)
class Student extends Human {
private final int semester;
public Student(String name, int semester) {
super(name);
this.semester = semester;
}
public int getSemester() {
return semester;
}
}

Why can't I inherit a specific variable from a specific class?

I want to inherit the variable "remark" from the Student class to put into the Course Class. So I basically done the "extends" keyword and the super(remark), but it's still not working. Is is possible to inherit only 1 specific variable or is there another way?
public class Course extends Student {
private String[] courseName;
private String[] courseNo;
private int courseCredit;
Course(String[] courseNo,String[] courseName,int courseCredit,char[] remark) {
super(remark);
this.courseNo = courseNo;
this.courseName = courseName;
this.courseCredit = courseCredit;
}
public void setCourseInfo(String[] courseNo,String[] courseName, int courseCredit) {
this.courseNo = courseNo;
this.courseName = courseName;
this.courseCredit = courseCredit;
}
public void setcourseName(String[] courseName) {
this.courseName = courseName;
}
public void setcourseNo(String[] courseNo) {
this.courseNo = courseNo;
}
public void setcourseCredit(int courseCredit) {
this.courseCredit = courseCredit;
}
public String[] getcourseName() {
return courseName;
}
public String[] getcourseNo() {
return courseNo;
}
public int getcourseCredit() {
return courseCredit;
}
public class Student extends Person {
private int sid;
private int numberOfCourse;
private boolean isTuitionPaid;
private String[] course;
private char[] remark;
Student(String fname,String lname,int sid,int numberOfCourse,boolean isTuitionPaid,String[] course,char[] remark) {
super (fname,lname);
this.sid = sid;
this.numberOfCourse = numberOfCourse;
this.isTuitionPaid = isTuitionPaid;
this.course = course;
this.remark = remark;
}
public void setInfo(String fname,String lname,int sid,int numberOfCourse,boolean isTuitionPaid,String[] course,char[] remark) {
this.getfname();
this.getlname();
this.sid = sid;
this.numberOfCourse = numberOfCourse;
this.isTuitionPaid = isTuitionPaid;
this.course = course;
this.remark = remark;
}
public void setRemark(char[] remark) {
this.remark = remark;
}
public char[] getRemark() {
return remark;
}
public void setStudentID(int sid) {
this.sid = sid;
}
public void setIsTuitionPaid(boolean isTuitionPaid) {
this.isTuitionPaid = isTuitionPaid;
}
public void setNumberOfCourses(int numberOfCourse) {
this.numberOfCourse = numberOfCourse;
}
public void setCoursesEnrolled(String[] courses,char[] remark) {
this.course = courses;
this.remark = remark;
}
public int getStudentID() {
return sid;
}
public int getNumberOfCourses() {
return numberOfCourse;
}

If I understand your question, you'd want to restructure your code.
Here is one (traditional) way to do it with pseudocode to help you along but leave the learning to you.
The key concept to understand is inheritance. The typical question you would ask is using "is a." Is a Course a Student? Is a Student a Course? No. Then don't extend.
public class Course {
//add getters and setters
private String name; //multiple names may make your life harder, think it through
private String[] number;
private String description;
private int credit; //are you sure this is an int??
private Student[] enrolledStudents;
}
public class Student extends Person { //not sure whether Person is really needed, but that's based on your requirements. Interfaces and composition are preferred.
//add getters and setters
private Course[] enrolledCourses;
//other properties
}
You would also need to get clearer on the Remark and the relationship to each class. Are remarks written about each student for each course? Do you need to see the remarks for all courses? Do you need to see all remarks for all students?
If the application is involved and uses say, a database, you could have a service class with something like:
public String getRemarks(Student student, Course course) {
//some implementation. A Remark could also be a class (bean) depending on your needs
}
Having a separate variable for numberOfCourses is likely not needed. You can just count the size of the enrolledCourses array.
Using Java's List will also make your life easier in many cases depending on what you need to do.
I will leave the functional style as a learning exercise, but that is where the industry has shifted toward in practice. Features of newer Java versions (e.g. records) can apply here too.

Construct object with highest ID + 1

I want to make a counter for the ID, and construct a new Person object with that ID.
My lombok class:
package nl.SBDeveloper.Persons.Lombok;
import lombok.Data;
#Data
public class Person {
private int id;
private String name;
}
My code:
Person person = new Person();
What is the best way to create this?

Define a static field. #Data creates a constructor using only the required arguments. ID is not required since it's already assigned, so you get a constructor which just takes a name.
#Data
public class Person {
private static final AtomicInteger currentId = new AtomicInteger();
private final int id = currentId.incrementAndGet();
private final String name;
}
Usage:
Person bob = new Person("Bob");

Define your data class:
public class Person {
private int id;
private String name;
Person(int id, String name) {
this.id = id;
this.name = name;
}
public String getName() {
return this.name;
}
public int getId() {
return this.id;
}
}
You can keep track of how many Person objects you create by defining a PeopleFactory object, and giving it a static personCount field. To make sure this counter is thread-safe, you would need to synchronize the field, or synchronize the method in charge of Person creation.
public class PersonFactory {
private static int personCount = 0;
public PersonFactory() {
}
public synchronized Person getPerson(String name) {
personCount++;
return new Person(personCount, name);
}
}
Testing our implementation:
public class Main {
public static void main(String[] args) {
PersonFactory personFactory = new PersonFactory();
Person bill = personFactory.getPerson("Bill");
System.out.println("ID: " + bill.getId() + ", Name: " + bill.getName());
}
}
ID: 1, Name: Bill

Java ,import not resolved,inheritance,inner class

Begging java programming recently, run into an error. please help
Have two classes , PersonTest.java:
public class PersonTest {
public static void main(String[] args) {
Person person1=new Person("dummy","sdymmt","20","male","washington");
System.out.println("Name: "+person1.getName());
System.out.println("Surname: "+person1.getSurname());
System.out.println("Age: "+person1.getAge());
System.out.println("Gender:" +person1.getGender());
System.out.println("Birthplace: "+person1.getBirthplace());
Person person2= new Person(400);
System.out.println("Income:"+person2.getX()+" mije leke");
System.out.println("Tax:"+person2.Taksat()+" mije leke");
Student student1= new Student("adsd","zedsdsadza");
System.out.println("emri"+student1.getEmer());
}
}
and also Person.java :
public class Person {
private String Name;
private String Surname;
private String Age;
private String Gender;
private String Birthplace;
private double x;
public Person()
{
}
public Person(String Name, String Surname, String Age, String Gender, String Birthplace) {
this.Name = Name;
this.Surname = Surname;
this.Age = Age;
this.Gender = Gender;
this.Birthplace = Birthplace;
}
public String getName() {
return Name;
}
public String getSurname() {
return Surname;
}
public String getAge() {
return Age;
}
public String getGender() {
return Gender;
}
public String getBirthplace() {
return Birthplace;
}
public Person(double x) {
this.x = x;
}
public double getX() {
return x;
}
double Taksat() {
return (0.1 * x);
}
public class Student extends Person {
private String University;
private String Faculty;
public Student(String Universiteti, String Fakulteti) {
super(Name, Surname, Age, Gender, Birthplace);
this.Faculty = Fakulteti;
this.University = Universiteti;
}
public String getFaculty() {
return Faculty;
}
public String getUniversity() {
return University;
}
}
}
Two classes are in the same default package. How to fix the fact that the test class doesn't recognize the inner class student as a class.

Nested non static class are called Inner Classes those classes cannot live without the Outer class (which wrapped them).
Java docs
An instance of InnerClass can exist only within an instance of
OuterClass and has direct access to the methods and fields of its
enclosing instance.
To instantiate an inner class, you must first instantiate the outer
class. Then, create the inner object within the outer object with this
syntax:
OuterClass.InnerClass innerObject = outerObject.new InnerClass();
Try using:
Person.Student student = person1.new Student(PARAMETERS);
Important Mark:
Of course, you should highly consider that this is not a good design, because you may want this classes to be visible outside of the Person class but also because Person.Student inherits from Person, which it's already contains the Student class, which usually looks like a loop or a circle relationship, which usually not a good idea for the first place.

Because there is no Student class. Since it nested, it's Person.Student

From UML to Java, Simple association

This is the Image that I'm going to transfer from UML to Java, I don't know how to lock them together and i don't know how to make one bankAccount locked to only one person.
How do i connect the 2 classes??
Here is my code so far
My main method
public class Upp5 {
public static void main(String[] args) {
Person2 david = new Person2();
BankAccount acc1 = new BankAccount();
BankAccount acc2 = new BankAccount();
david.setName("David");
david.setPnr("551012-8978");
acc1.setBnr("37");
acc2.setBnr("38");
System.out.println("Namn: " + david.getName() + " \nPersonnummer:" + david.getPnr());
System.out.println(acc1.getBnr() + "\n" + acc2.getBnr());
}
}
BankAccount.java:
public class BankAccount {
private String bnr;
private double balance;
public void credit() {
}
public void withdraw(){
}
public String getBnr(){
return bnr;
}
public void setBnr(String newAccount){
bnr = newAccount;
}
public void createAccount(String newNbr){
bnr = newNbr;
}
}
and Person2.java
public class Person2 {
private String pnr;
private String name;
//Koppla konto till pnr
public void addAccount(BankAccount a){
}
//Skapa Pnr och Namn
public void setPnr(String newPnr) {
pnr = newPnr;
}
public void setName(String newName){
name = newName;
}
// Hämta Pnr och Namn
public String getPnr(){
return pnr;
}
public String getName(){
return name;
}
}

You need to define a List<BankAccount> to your Person2 entity:
public class Person2 {
private String pnr;
private String name;
// list of bank accounts (from 0 to n) the Person can have.
private List<BankAccount> accounts;
//Koppla konto till pnr
public void addAccount(BankAccount a){
if (accounts = null) accounts = new ArrayList<BankAccount>();
accounts.add(a);
}
//Skapa Pnr och Namn
public void setPnr(String newPnr) {
pnr = newPnr;
}
public void setName(String newName){
name = newName;
}
// Hämta Pnr och Namn
public String getPnr(){
return pnr;
}
public String getName(){
return name;
}
// include getters setters
}
EDIT1: as suggested by #NathanCastlehow if you want double relationship, BankAccount.java must have a Person2 attibute
public class BankAccount {
private String bnr;
private double balance;
// one bank account can only be owned by a single Person
private Person2 person;
public void credit() {
}
public void withdraw(){
}
public String getBnr(){
return bnr;
}
public void setBnr(String newAccount){
bnr = newAccount;
}
// generate getters setters
public Person2 getPerson(){
......
}
}

You didn't put any arrows in your diagram, so we don't know if the bankaccount knows the person it is linked to. The most logical thing to do is; let the Person have a List which you always initiate in the Person's constructor.
If you want the bankaccount to know the person that owns him (which seems logical to me), let the Bankaccount have the property "Person owner" and let the constructor be require a Person to exist. I don't understand why you have made a Person2 instead of a Person class.
Tips for you: Never (!!!) use parameters like; 'a' or properties like 'nBr' because other people wanna see in an instance what they are instead of guessing. :-) And try to make some security rules (that's why I put booleans in the classes).
Solution:
Person:
public class Person {
List<BankAccount> bankAccounts;
private String name;
private String pNbr;
public Person(String name, String pNbr) {
this.name = name;
this.pNbr = pNbr;
}
public void addAccount(BankAccount newAccount){
bankAccounts.Add(newAccount);
}
}
Bankaccount:
public class BankAccount {
private String nBr; //maybe make this final?
private double balance;
private Person owner;
public BankAccount(String nbr, Person owner) {
this(nbr, 0, owner); // If you also want to support new empty accounts
}
public BankAccount(String nbr, double balance, Person owner) {
this.name = name;
this.pNbr = pNbr;
this.owner = owner;
}
public boolean Credit(double amount)
{ // TODO: write code
boolean result = false;
return result;
}
public boolean Withdraw(double amount)
{ // TODO: write code
boolean result = false;
return result;
}
}

So generally when this is done in models such as a relational model you would have an association class. So a class that has like an ID from a bank account and an ID of the person. You can lock variables using the final keyword in front of them which forces them to only be initialized once.

The easiest way to "link" classes in java is to add one of said classes as an attribute. For example:
// Make it private to maintain encapsulation
private BankAccount myBankAccount;
But this only works if you have a 1..1 (One to one) relationship.
Your UML diagram indicates a 1..n (One to many) relationship between Person and BankAccount classes. In other words,
A Person may have multiple BankAccounts.
This means you'll a have to use a structure to "keep" multiple BankAccounts in a single Person. Java already provides you with some handy classes:
ArrayList: Easy, quick, insertion-ordered list. Allows as many itens as you need.
Hashmap: Hash implementation of the Map interface. Provides a way to find itens using a "key" (Ex: An account's number). Very efficient.
A suggest reading some of those classes documentation. And you can always look for some neat examples on the internet ;)