You can use the word 'this', or use another name.

class Car {
private int wheels, seats;
private String price;

public Car(int wheels, int seats, String price){
this.wheels = wheels;
this.seats = seats;
this.price = price;
}

or...

class Car {
private int noOfWheels, noOfSeats;
private String priceOfCar;

public Car(int wheels, int seats, String seats){
noOfWheels = wheels;
noOfSeats = seats;
priceOfCar = price;
}

...you have a return type. the method is not a constructor when it has a return type (it is however still a valid method)

class Car{
public void Car(){

}
}

Where you can enforce effective encapsulation

• 1. Access within the class
• 2. Subclass inside the package/li>
• 3. Subclass outside the package/li>
• 4. Other class inside the package/li>
• 5. Other class outside the package/li>

• public - (1,2,3,4,5) Can be access by anything
• private - (1 only) Used within the class (not accessible outside the class)
• protected - (1,2,3,4) Just like public, though classes outside the package cannot access it

Foundations of OOP

• Abstraction -- 'Taking away' the complicated processes thus leaving only the high-level
• Encapsulation -- combining everything together function + values = Class
• Inheritance -- You 'inherit' the commonalities from a superclass, saves having to re-write the code again
• Polymorphism -- Calling from a number of methods (all with the same name) though one method will be selected based on the arguments passed

Where you can enforce effective encapsulation

You can have methods with the same name though the arguments are different.
Example: When you instantiate a class and pass only 2 arguments (wheels and seats), it will know to pick the bottom method.

class Car {
private int wheels, seats;
private String price;

public Car(int wheels, int seats, String price){
//Stuff here
}
public Car(int wheels, int seats){
//Stuff here
}

If will also determine the type of argument

byte b = 10;
Integer i = 10;

value(b); //passing the byte
value(i); //passing an Integer (not an int)
value("10"); //passing a String


public static void price(byte b){System.out.println("This is a byte")}
public static void price(int b){System.out.println("This is an int")}
public static void price(Object b){System.out.println("This is an object")}
public static void price(String b){System.out.println("This is a String")}

It would return:
This is a byte
This is an object
This is a string

You call a method, with arguments, though the argument types don't match any of the values

private static void price(int x, int y);
private static void price(int x, String y);
price("Hello","Daniel");

class AnotherOverload { public static void anotherMethod(byte val) { System.out.println("this is a byte");
public static void anotherMethod(short val) { System.out.println("this is a short");
}

You use the this keyword to call one constructor from another constructor of the same class

Public Fruit (int x, String y, String z){
 size = x;
 texture = y;
 shape = z;
}

Public Fruit (int x, String y){
 this(x , y,"Round");
}

Object is the superclass. A new instance of the Number class can be used to hold derived type objects. Number [] num = new Number[2];
num[0] = new Byte((Byte)10);
num[1] = new Integer(10);

System.out.println(sum(num));

The access level for the toString() method must be Public

public String toString() { return "x =" + x; }

I cannot be anything more stricter.

protected String toString() { return "x =" + x; }

public String toString() { return "x =" + x; }

The toString() method returns a string

protected String toString() { return "x =" + x; }

Return type of the methods should exactly match when overriding methods. In the example below, the Circle c2 = c1.copy is trying to run the method within the Circle, though the method is an overriding method from the Super class.

+-+Shape
+-+copy()

+-+Circle Shape
+-+public Shape copy()

+-+ Test
+-+ new Circle(), Circle c2 = c1.copy

This requires explicit downcasting to the derived class.
Circle c2 = (Circle) c1.copy
Though this is no longer required to do as Circle c2 = c1.copy compiles successfully within Java 5

About the author