Archive | University

26 December 2011 ~ 0 Comments

Student Class – Java

Coding Examples Java University

One important aspect of Java is inheritance, and how we do this in Java is to use the keyword Extend. This example, following on from assignment that was set is for the Student Class with Extends the Person class. As seen in the Person class – Java post.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196

public class Student extends Person {
//Protected variables
protected Date dateEnrolled;
protected String course;
protected int year;

//Constructors
/**
* Set default values and create the student
*/
Student()
{
super();
dateEnrolled = new Date();
course = "No course yet added!";
year = 0;
}

/**
* Allow input for the creation of a student
*/
Student(String name, char sex, Date dob, String insceNumber, Date enrolled)
{
super(name, sex, dob);
natInsceNo = insceNumber;
dateEnrolled = new Date(enrolled);
course = "No course yet added!";
year = 0;
}

/**
* Allows for the cloning of a student
*/
public Student(Student other)
{//need to call the super class clone
super(other);
dateEnrolled = other.dateEnrolled;
course = other.course;
year = other.year;
}

//End of Constructors

//Start Transformers

/**
* Set the course
*/
public void setCourse(String s)
{
course = s;
}

/**
* Set the year
*/
public void setYear(int yr)
{
year = yr;
}

//Start of copy method
public void copy(Student other)
{
super.copy(other);
dateEnrolled = other.dateEnrolled;
course = other.course;
year = other.year;
}
//End of copy method

//End of Transformers

//Start of Accessors
//Get accessors
public Date getDate()
{
return dateEnrolled;
}

/**
* @return
*/
public String getCourse()
{
return course;
}

/**
* @return
*/
public int getYear()
{
return year;
}
//End of get Accessors

//Start of toString
public String toString()
{
return super.toString() + ", Course: " + course + ", Date Enrolled: " + dateEnrolled + ", Year:" + year;
}
//End of toString
//End of Accessors
}

So what we are doing here is inheriting all of the Person Class methods and using them to create a student. As we can have multiple students which inherit from a Person. Such as a Teacher is a person, therefore could extend from Person as well. Take a look at the code and try to work out what it is actually doing and focus on the Date dateEnrolled aspect.

Continue Reading

Tags: , , , , ,

22 October 2011 ~ 0 Comments

Employee Class – Java

Java University

This post relates to Person Class – Java, with Employee class extending from Person (Basically inheriting from Person). I’ll update this post soon.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

public class Employee extends Person {

	private Date dateStarted;
	private float salary;
	private int id;

	public Employee(String nme, char sex, int howOld, int number, Date start)
	{
		super(nme, sex, howOld);
		id = number;
		dateStarted = new Date(start);
		salary = 0;

	}

	//calls data from Person
	public boolean equals(Employee other)
	{
		return super.equals(other) && id == other.id && salary == other.salary && dateStarted.equals(other.dateStarted);
	}

	//allows for the setting of a salary with an input
	public void setSalary(float newSalary)
	{
		salary = newSalary;
	}

	public Employee (Employee other)
	{ //needs to match employee constructor and the same format and allows for the creator of another employee
		this(other.name, other.gender, other.age, other.id, other.dateStarted);
	}

	//Need to have all the variables to copy
	public void copy(Employee other)
	{
		dateStarted.copy(other.dateStarted);
		salary = other.salary;
		id = other.id;
		name = other.name;
		gender = other.gender;
		age = other.age;
	}

	public Date getDateStarted()
	{
		return dateStarted;
	}

	public String toString()
	{
		return "Employee Number: " + id + "Salary" + salary + "Started: " + dateStarted.toString();
	}
}

Continue Reading

Tags: , , , ,

04 October 2011 ~ 0 Comments

Person class – Java

Examples Java University

Hey guys,

Well I’ve not updated this site is a long time, been way too busy. My studies have been processing rapidly, currently working on Java inheritance. So, starting basic I’ve been working on a Person class, which will allow for the creation of a Person (Note that this is a basic version and you would have to make changes for it to be of the correct standard and conventions of java). Here is it:-

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226

public class Person {
 //variables
  protected int age, serial;
  protected char gender;
  protected String name;
  protected String address;
  private static int counter;

  //constructor
  public Person (String nme, char sex, int howOld)
  {
	  	age = howOld;
   		gender = sex;
   		name = nme;
   		address = "";
   		counter ++;
   		serial = counter + 1001;

  }

  public Person(Person other)
  {
	  name = other.name;
	  age = other.age;
	  gender = other.gender;
	  address = other.address;
  }

  //count every instance of person
  public static int count()
  {
	  return counter;
  }

  public void copy (Person other)
  {
	   age = other.age;
	   gender = other.gender;
	   name = other.name;
	   address = other.address;

  }

// accessor methods
  public int getAge()
   {
    return age;

   }//end get age

  public String toString()
  {
	  return name + " " + address;
  }

   //get gender
   public String getGender()
   {
    if(gender == 'm' || gender == 'M')
    	return "male";
    else
    	if (gender == 'f' || gender == 'F')
    	return "female";
    else
    	return "unknown";
   }
   //check to see if older
   public boolean isOlderThan(Person other)
   {
	   {
		if (age >= other.age)
			return true;
		else
			return false;
	   }

   }

	//checking to see if the same gender
	public boolean sameGender(Person other)
	{
		return gender == other.gender;
	}

	//Input a value to check age
	public boolean olderThan(int otherAge)
	{
		return age >= otherAge;
	}

	//check to see if female
	public boolean isFemale()
	{
		return gender == 'f' || gender == 'F';
	}

	public boolean equals (Person other)
	{
		return name.equals(other.name) && gender == other.gender && age == other.age && address.equals(other.address);
	}

   //transformer methods
   public void incrementAge()
   {
    age ++;
   }

   //get new address
   public void setAddress(String newAddress)
   {
    address = newAddress;
   }

}

So what does the code do? It allows for the adding of a instance called Person, with a name, gender and how old they are being set by the user via the constructor. Everything else is very self explanatory , expect the boolean equals (Person other) which checks two [persons to see if they match, and returns true if they do.

Continue Reading

Tags: , , ,
show
 
close
#oGame still play it after so many years, if anyone is #bored give it a go http://t.co/3HKrOZtR