面向对象编程是以程序的数据为中心 , 函数为数据服务 ( 面向过程是以函数为中心 ) , 数据是通过间接方式包含对自身操作的引用
例如 : 不是通知 drawRectangle()函数"使用这个形状绘制矩形" , 而是要求矩形"绘制自身"
static 方法和成员变量,只是为了那些想独立于任何实例之外的内容,提前分配内存而准备了。例如 public static void main () ^_^
继承
a kind of : 类B是类A的一种 , 可以继承 //这种属于继承a part of : 类B是类A中的一部分 , 则不准许B继承A的功能 , 而是要用A和其他东西组合出B //这种属于合成
例如头这个类是由 眼 , 鼻 , 口 , 耳 组成
判断:该使用继承还是合成?利用上传:新类可以上传给基类,则用继承,是kind of关系 ,否则是 part of关系,用合成
多数情况还是应该考虑使用合成.
命名约定:
(1)宏定义用大写字母加下划线表示,如MAX_LENGTH;
(2)类名首字母大写,其他小写开头,函数用小写字母开头的单词组合而成,如setName, getName ; 不适用于构造函数
(3)指针变量加前缀p,如*pNode ;
(4)BOOL 变量加前缀b,如bFlag ; if ( bFlag ) if(!bFlag)
(5)int 变量加前缀i,如iWidth ;
(6)float 变量加前缀f,如fWidth ;
(7)double 变量加前缀d,如dWidth ;
(8)字符串变量加前缀str,如strName ;
(9)枚举变量加前缀e,如eDrawMode ;
(10)类的成员变量加前缀m_,如m_strName, m_iWidth ;
对于int, float, double 型的变量,如果变量名的含义十分明显,则不加前缀,避免烦琐。如用于循环的int 型变量i,j,k ;float 型的三维坐标(x,y,z)等。
以下是使用断言的几个原则://宏, 判断非法使用
(1)使用断言捕捉不应该发生的非法情况。不要混淆非法情况与错误情况之间的区别,后者是必然存在的并且是一定要作出处理的。
(2)使用断言对函数的参数进行确认。
(3)在编写函数时,要进行反复的考查,并且自问:“我打算做哪些假定?”一旦确定了的
假定,就要使用断言对假定进行检查。
(4)一般教科书都鼓励程序员们进行防错性的程序设计,但要记住这种编程风格会隐瞒错误。当进行防错性编程时,如果“不可能发生”的事情的确发生了,则要使用断言进行报警
面向对象的主要特征:
1.封装性 使用者不必知晓行为实现的细节,只须用设计者提供的消息来访问该对象.
正式由于封装的特性,才可以实现目前大量采用的,例如使用JAVA提供的class等等.
2.继承性 面向对象可复用的真实体现( 可复用--是这可重复使用,继承的类可以不用重写父类中的方法而直接使用)
3.多态性 对象根据所接收的消息而做出动作,例如一个add函数,它即可以做整数的加法操作,也可以做字符串的连接操作 . ( 面向对象中,重要的center )
多态方法调用,能让类表现出各自所独有的特点,只要这些类都是从一个基类里派生出来的就行了.
当你通过基类的reference调用方法的时候,这些不同就会通过行为表现出来.
需要继承的支持,其实就是上传.
好处:当增加新的派生类时,不用增加新的代码,直接可以使用.
如果你可以写只用一个基类,而不是具体的派生类做参数的方法,利用后绑定,在程序运行的时候根据对象的类型来决定绑定哪个对象,进尔调用哪个对象的方法.
在OOP的设计中,绝大多数方法都是这样,只跟基类打交道.
构造函数会从最顶层的基类到派生类逐层调用,因为派生类只能访问他自己的成员,他看不到基类的成员(因为他们通常是private的),
只有基类的构造函数才知道怎么样初始 化基类的成员
上传: shape s = new Circle();下传:继承可以确保所有的子类类具有基类的接口,且绝对不会少。那么子类除了有父类的方法,
也可以有自己的额外的新方法(这些方法是基类所没有的),那么一旦向上转型,就不能调用子类中的新方法,那么能不能用一种方式调用这些新方法呢?
当然有了,这时候就需要向下转型. ( 危险,最好先做判断 例如: instanceof )
安全:因为上传时,派生类肯定是基类,即 circle肯定是个shape ,所以是安全的,但是下传时就不一定了,可能是个circle ,也可能是个square,每个子类有自己的函数,
究竟是那个类型的对象只有运行时才能判断出来,如果不慎调用错误是很危险的.
多态性 小例子
------ Example Start ----------------------------------------------------------
package com.moveofgod.test;
//basic class
class Bird{
public String strName ;
public void call(Bird a)
{
strName = "bird";
System.out.println(strName);
}
public void identify()
{
System.out.println("This is a bird ");
}
}
//chicken class
class Chicken extends Bird{
int iPrice ;
public void call(Bird a)
{
strName = "chicken";
System.out.println(strName);
}
public void identify(){
iPrice = 50 ;
System.out.println("This is a chicken ");
System.out.println(iPrice);
}
//子类中的新方法,向下转型,即下传
public void buy()
{
System.out.println("You can buy the Chicken");
}
}
//duck class , duck class is the new class , the basic class and chicken don't be modified ...
class Duck extends Bird{
int iPrice ;
public void call(Bird a)
{
strName = "duck";
System.out.println(strName);
}
public void identify(){
iPrice = 100 ;
System.out.println("This is a duck ");
System.out.println(iPrice);
}
//子类中的新方法,向下转型,即下传
public void buy()
{
System.out.println("You can buy the Duck");
}
}
public class UpCastTest {
public static void main(String args[])
{
Chicken rChicken = new Chicken() ;
Duck rDuck = new Duck() ;
//向上转型,上传
Bird rBird1 = new Chicken();
Bird rBird2 = new Duck();
rBird1.call(rChicken);
rBird1.identify();
rBird2.call(rDuck);
rBird2.identify();
//向下转型,下传
if( rBird1 instanceof Chicken ){ //由于下传危险,所以最好先判断
Chicken chicken1 = (Chicken)rBird1 ; //向下转型,强制类型转换
chicken1.buy(); //此方法是chicken中特有的类,基类中没有
}
}
}