在设计面向对象的系统时，没有所谓的“顶部”，首先从设计类开始，在往每个类中添加方法。
识别类的简单规则是在分析问题的过程中寻找名词，而方法对应动词。
类之间的关系
依赖：如果一个类的方法操纵另一个类的对象，我们就说一个类依赖于另一个类。
聚合：类A的对象包含类B的对象。
继承：一个类继承于另一个类。
类和对象
在面向对象的概念当中，类（class）是既包括数据又包括作用于数据的一组操作的封装体。类的数据称为成员变量，类对数据的操作称为成员方法。成员变量反映类的状态和特征，成员方法反映类的行为和能力。类的成员变量和方法统称为类的成员。
对象(Object)是类的实例(instance)。对象是动态的，拥有生命周期，都会经历一个从创建、运行到消亡的过程。对象与类的关系就像变量与数据类型一样。
类声明
{ 修饰符 } class <Classname> { extends <Classname> }
{ implements <Interface1>,<Interface2>，[..],<InterfaceN> }
{
// 类主体
}
声明成员变量
public class Person{
private int age;
}
(声明)成员方法
[修饰符] 返回值类型 方法名([参数列表])[throws 异常类]
{
语句序列;
[return []]
}
public class class Person{
private int age;
public int getAge(){
return age;
}
public void setAge(int a){
age=a;
}
}
声明main方法
public static void main(String [] args)
对象声明
Date aday;//声明一个是Date类的aday对象变量，如果不进行实例化，是不可以调用Date类里的方法的，如：aday.toString();//是错误的。
对象实例化
创建类的实例必须调用类的构造方法。类的构造方法是一类和类同名的方法，用于创建类的实例并初始化对象。
对象 = new 类的构造方法([参数列表]);
aday = new Date();
当使用new创建了一个对象的时候，系统为对象中的成员变量进行了初始化，不但为变量分配了相应的存储单元，还为变量设置了所属数据类型的初始值。
这时就可以调用Date类里的方法了。
方法调用时的参数传递原则
方法参数：1、基本数据类型 public int sum ( int i);。
2、对象引用 public Object getObj (Object obj);
如果形参的数据类型是基本数据类型，则实际参数向形参传递的是值，即传值。
如果形参的数据类型是引用数据类型，则实际参数向形式参数传递的是引用。
用个例子来说明
public class Tester {
public static void main(String[] args) {
int primitive = 2;
changePrimitive(primitive);
//primitive的值依然是2
MyClass myClass = new MyClass();
changeObject(myClass);
//myClass仍然指向的是执行changeObject之前的那个对象
//myClass.i等于3了
}
public static void changePrimitive(int primitive) {
primitive = 3;
}
//在这里myClass1只是一个副本和myClass指向的是同一个对象，千万不要被去参数名称为myClass迷惑
//这里我有意区分
public static void changeObject(MyClass myClass1) {
//这个时候对原来的对象的值操作有效，因为它指向的地址就是原来的对象
myClass1.i = 3;
//这里修改的只是副本指向的对象
//而原来的myClass依然指向原来的对象
myClass1 = new MyClass();
}
}
class MyClass {
int i;
}
2，封装，继承，多态
(1)封装性
封装就是将属性私有化，提供公有的方法访问私有属性。
做法就是：修改属性的可见性来限制对属性的访问，并为每个属性创建一对取值（getter）方法和赋值（setter）方法，用于对这些属性的访问。
如：private String name;
public String getName(){
return;
}
public void setName(String name){
this.name=name;
}
继承
Java中只支持单继承，子类不能够继承父类的构造方法。但在子类当中可以使用super调用父类的构造方法。格式为super([参数列表])
子类可以对父类赋值兼容。
由于继承相对而言比较简单，所以不再赘述。
多态性
多态性有两种
a，编译时多态。
b，运行时多态。
方法的多态性主要有方法的重载和覆盖。
一个类中如果有多个同名的但是带有不同参数的方法列表，称为方法的重载。
方法名称相同，参数项不相同。那么认为一个方法是另一个方法的重载方法。
注意：重载只跟参数有关，与返回类型无关。方法名和参数相同而返回类型不相同，不能说是重载。
典型的方法重载：System.out.println(); Sysstem.out代表了一个java.io.PrintSteam对象，具有多个println(打印)方法，该方法可以接收不同类型的数据作为参数根据类型不同，
调用不同的打印方法。
在java.lang包中的Math类中的max方法。
Public static int max(int a,intb);
Public static int max(long a,long b);
Public static int max(float a,float b);
Public static int max(double a,double b);
方法的覆盖表现出两种多态性，当对象获得本类的实例时，为编译时多态性，否则为运行时多态性。
Person p=new Person();
Student stu=new Student();//假设Student是Person的子类,它们有同样的print()方法。
Person p1=new Student();
p.print();//编译时多态，执行本类方法
stu.print();//编译时多态，执行覆盖方法
p1.print();//运行时多态，执行Student覆盖方法
p1声明为父类对象但是却获得了子类的实例，那么它究竟执行的是子类覆盖方法还是父类方法呢？
这里有两种情况，这取决于子类是否覆盖了父类的该方法。如果子类覆盖了该方法，就执行子类的该方法，否则执行父类方法。但是在编译时，仅仅依据对象所属的类无法确定到底该执行哪个类的方法，只有到运行是才能呢个确定，所以是运行时多态。
这里请注意，父类对象并不能没有被子类覆盖的方法
原文：http://www.cnblogs.com/love-javabean/p/3662710.html