How class accomplish data hiding?

Answer 1

Data hiding is one of the important aspects of a class. Data hiding means to hide the members of the class and providing the access to only some of them. we can make the members of the class private or public. in private,the outside world cannot access those members which been made private.and rest we can make public.only the public members are accessed by the out side world and all the private members can be accessed using only the public members.in this way a class provides security to its data members.

Answer 2

A class is a collection of data and methods to work with that, and other, data. An object is a specific instance of a class. For example, "ArrayList" is a class that contains methods such as "add" and "remove" for changing the items in the list. The instances (objects) of ArrayList can use these methods to perform operations. It's easier to show the structure of things with a custom class.

public class MyClass

{

//Data / "Fields":

private int num;

//Constructors:

public MyClass()

{

}

public MyClass(int initialNumValue)

{

num = initialNumValue;

}

//"Getters" and "Setters":

public int getNum()

{

return num;

}

public void setNum(int newNumValue)

{

num = newNumValue;

}

}

The above code is an example of a class declaration. It's the blueprint for all MyClass objects. Take note of the use of the keywords "private" and "public". This is an example of data hiding, also called encapsulation. The actual number is hidden so that no other class can modify its values. The other classes have to use the provided public methods to modify the value of num. While in simple cases, this really is not necessary, it is a good practice, because in many cases, you do not want to provide full visibility, or you want to do something special when the value of something is changed. This also helps when debugging a program.

Now let's use the above class to demonstrate some of these concepts. Pretend that this is the main method for AnotherClass:

MyClass myObject = new MyClass(); //myObject is an instance of MyClass

MyClass mySecondObject = new MyClass(2); // mySecondObject is another instance

// of MyClass

//At this point, the number stored in myObject is zero, and the number stored in

// mySecondObject is 2.

//INVALID:

myObject.num = 3;

//AnotherClass cannot directly see the variable num in myObject, because the class

// file MyClass declared it as private. However, the following code is valid because

// it uses the provided public methods:

myObject.setValue( 3 );

//Now the value of num in myObject is 3.

mySecondObject.setValue( myObject.getValue() );

myObject.setValue( 1 );

//Now mySecondObject's num value is 3, and myObject's num value is 1.

Generally, you will always want to (or be required to) encapsulate your data / fields, that is to say, declare them as private, and make public methods that get or set the value stored in them. This will, in the long run, allow your classes to be more flexible and adaptable for other uses.

Answer 3

Information hiding is an object-oriented concept in which different classes are kept separate from one another, so that a major change in one class results in no changes in any other classes.

Information hiding depends on code implementing the concepts of low coupling and high cohesion.

Answer 4

Data Hiding ensures that members of a class are not visible to classes that dont need to see/view them. This is accomplished using the access modifiers.

An Access Modifier is a key word in java that determines what level of access or visibility a particular java variable/method or class has. There are 4 basic access modifiers in java. They are:

1. Public

2. Protected

3. Default and

4. Private

To implement Data hiding i would make members private.

Members marked private can't be accessed by code in any class other than the class in which the private member was declared. Let's make a small change to the Parent class from an earlier example.

package pack1;

public class Parent {

private String getName() {

return "Parent";

}

}

Now the getName() method is private and is not visible from within the Child class and the same piece of code would throw up the below compilation error when you try to compile the class.

cannot find symbol

symbol : method getName()

This error method looks as if the method getName() does not exist at all. Of course the method exists but unfortunately it is declared private and hence no class (except the class that has the exact code written into it) can access it. This includes a child class that extends the parent class that has the method.

Answer 5

Data hiding is a bit of a misnomer because you cannot physically hide data within a class. What you can do is limit access to that data by declaring it private. This is not hiding data, its perfectly visible to anyone with access to the class definition.

What you call data hiding, programmers call encapsulation. Private data is only accessible to class members and friends of the class. By limiting accessibility, class designers ensure that the class representation cannot be invalidated by errant code outside of the class and its friends, that is code that is outwith the control of the class designer.

Class designers can also declare data protected or public, but as soon as they do that the data is no longer encapsulated. Protected data is the same as private data but is also accessible to derived classes. The class designer has no control over derived class implementations and this undermines encapsulation. If encapsulation were not an issue, the data would not need protected let alone be private, it could simply be declared public. The protected keyword should only ever apply to private interfaces (functions or methods) that class implementers also require access to.

The public interface is available to any code and provides the means by which ordinary users of the class can interact with objects of the class. There is no need for an ordinary user to know the implementation details of a class, the public interface should provide everything they require in order to use the class. Class implementers, on the other hand, can make use of the protected interface to provide a more specialised interface, one that suits their specific, derived classes. But only the class designer has access to the private interface.

Answer 6

A class is a pattern to combine to two different variables which can be used to create an object. Data hiding is to separate public from private class.

Answer 7

it is possible by private declaration