<h2><a name=\"Object\">What is an <span>Object</span>?</a></h2>
<p>An <span>object</span> can be considered a \"<em>thing</em>\" that can perform a set of <strong>related </strong>activities. The set of activities that the <span>object</span> performs defines the <span>object</span>\'s behavior. For example, the hand can grip something or a <em>Student </em>(<em><span>object</span></em>) can give the name or address.</p>
<p>In pure <em>OOP </em>terms an <span>object</span> is an instance of a class.</p>
<h2><a name=\"Class\">What is a Class?</a></h2>
<p><img src=\"images/class.gif\" alt=\"\" /></p>
<p>A <em>class </em>is simply a representation of a type of <em><span>object</span></em>. It is the blueprint/ plan/ template that describe the details of an <em><span>object</span></em>. A class is the blueprint from which the individual <span>object</span>s are created. <em>Class </em>is composed of three things: a name, attributes, and operations.</p>
<pre id=\"pre0\" style=\"margin-top: 0pt;\"><span>public</span> <span>class</span> Student
{<br />     //class body<br />&nbsp;}
</pre>
<p>According to the sample given below we can say that the <em>student </em><span>object</span>, named <em><span>object</span>Student</em>, has created out of the <em>Student </em>class.</p>
<pre id=\"pre1\" style=\"margin-top: 0pt;\">Student <span>object</span>Student = <span>new</span> Student();
</pre>
<p>In real world, you\'ll often find many individual <span>object</span>s  all of the same kind. As an example, there may be thousands of other  bicycles in existence, all of the same make and model. Each bicycle has  built from the same blueprint. In <span>object</span>-<span>oriented</span> terms, we say that the bicycle is an instance of the class of <span>object</span>s known as bicycles.</p>
<p>In the software world, though you may not have realized it, you have already used classes. For example, the <em>TextBox </em>control, you always used, is made out of the <em>TextBox </em>class, which defines its appearance and capabilities. Each time you drag a <em>TextBox </em>control, you are actually creating a new instance of the <em>TextBox </em>class.</p>
<h2><a name=\"identify\">How to identify and design a Class?</a></h2>
<p>This is an art; each designer uses different techniques to identify classes. However according to <span>Object</span> <span>Oriented</span> Design Principles, there are five principles that you must follow when design a class,</p>
<ul>
<li>SRP - The Single Responsibility Principle - <br />A class should have one, and only one, reason to change. </li>
<li>OCP - The Open Closed Principle - <br />You should be able to extend a classes behavior, without modifying it. </li>
<li>LSP - The Liskov Substitution Principle- <br />Derived classes must be substitutable for their base classes. </li>
<li>DIP - The Dependency Inversion Principle- <br />Depend on abstractions, not on concretions. </li>
<li>ISP - The Interface Segregation Principle- <br />Make fine grained interfaces that are client specific. </li>
</ul>
<p>For more information on design principles, please refer to <a title=\"What Is Object-Oriented Design?\" href=\"http://www.objectmentor.com/omSolutions/oops_what.html\"><span>Object</span> Mentor</a>.</p>
<p>Additionally to identify a class correctly, you need to identify the  full list of leaf level functions/ operations of the system (granular  level use cases of the system). Then you can proceed to group each  function to form classes (classes will group same types of functions/  operations). However a well defined class must be a meaningful grouping  of a set of functions and should support the re-usability while  increasing expandability/ maintainability of the overall system.</p>
<p>In software world the concept of dividing and conquering is always  recommended, if you start analyzing a full system at the start, you will  find it harder to manage. So the better approach is to identify the  module of the system first and then dig deep in to each module  separately to seek out classes.</p>
<p>A software system may consist of many classes. But in any case, when  you have many, it needs to be managed. Think of a big organization, with  its work force exceeding several thousand employees (let&rsquo;s take one  employee as a one class). In order to manage such a work force, you need  to have proper management policies in place. Same technique can be  applies to manage classes of your software system as well. In order to  manage the classes of a software system, and to reduce the complexity,  the system designers use several techniques, which can be grouped under  four main concepts named Encapsulation, Abstraction, Inheritance, and <em>Polymorphism</em>. These concepts are the four main gods of <em>OOP </em>world and in software term, they are called four main <span>Object</span> <span>Oriented</span> <span>Programming</span> (<em>OOP</em>) Concepts.</p>