BloveSaga

在希腊帕尔纳斯山南坡上,有一个驰名世界的戴尔波伊神托所,在它的入口处的巨石上赫然锈刻着这样几个大字: 认识你自己!

  BlogJava :: 首页 :: 新随笔 :: 联系 :: 聚合  :: 管理 ::
  34 随笔 :: 12 文章 :: 122 评论 :: 0 Trackbacks

#

   理解继承是理解面向对象程序设计的关键.在Java中,通过关键字extends继承一个已有的类,被继承的类称为父类(超类,基类),新的类称为子类(派生类).在Java中不允许多继承.code:
class Animal
{
 int height,weight;
 void eat()
 {
  System.out.println("Animal eat!");
 }
 void sleep()
 {
  System.out.println("Animal sleep!");
 }
 void breathe()
 {
  System.out.println("Animal breathe!");
 }
}
class Fish extends Animal
{
 
}
class DoMain
{
 public static void main(String[] args)
 {
  Animal an=new Animal();
  Fish fn=new Fish();
  
  an.breathe();
  fn.breathe();
  fn.height=30;
  fn.weight=20;
 }
}
Result:
F:\Java Develop>javac Animal.java

F:\Java Develop>java DoMain
Animal breathe!
Animal breathe!
(这说明派生类继承了父类的所有方法和成员变量.)

方法的覆盖(override)
在子类中定义一个与父类同名,返回类型,参数类型均相同的一个方法,称为方法的覆盖,方法的覆盖发生在子类与父类之间.
code:
class Animal
{
 int height,weight;
 void eat()
 {
  System.out.println("Animal eat!");
 }
 void sleep()
 {
  System.out.println("Animal sleep!");
 }
 void breathe()
 {
  System.out.println("Animal breathe!");
 }
}
class Fish extends Animal
{
 int weight,height;   //隐藏了父类的weight,height;
 void breathe()  //override method breathe()
 {
  super.breathe();  //用super调用父类的构造方法
  System.out.println("Fish bubble");
 }
}
class DoMain
{
 public static void main(String[] args)
 {
 // Animal an=new Animal();
  Fish fn=new Fish();
  
  an.breathe();
  fn.breathe();
  fn.height=30;
  fn.weight=20;
 }
}
输出结果:
F:\Java Develop>javac Animal.java

F:\Java Develop>java DoMain
Animal breathe!
Fish bubble

特殊变量super
* 使用特殊变量super提供对父类的访问
* 可以使用super访问父类被子类隐藏的变量或覆盖的方法
* 每个子类构造方法的第一条语句都是隐含的调用super,如果父类没有这种形式的构造函数就会报错.
code:
class Animal
{
 int height,weight;
 Animal()
 {
  System.out.println("Animal construct");
 }
 void eat()
 {
  System.out.println("Animal eat!");
 }
 void sleep()
 {
  System.out.println("Animal sleep!");
 }
 void breathe()
 {
  System.out.println("Animal breathe!");
 }
}

class Fish extends Animal
{
 Fish()
 {
  System.out.println("Fish construct");
 }
 void breathe()  //override method breathe()
 {
  System.out.println("Fish bubble");
 }
}
class DoMain
{
 public static void main(String[] args)
 {
  //Animal an=new Animal();
  Fish fn=new Fish();
  
  //an.breathe();
  //fn.breathe();
  //fn.height=30;
  //fn.weight=20;
 }
}
输出结果:
F:\Java Develop>javac Animal.java

F:\Java Develop>java DoMain
Animal construct
Fish construct

posted @ 2006-06-04 11:18 蓝色Saga 阅读(240) | 评论 (0)编辑 收藏

  苏东坡和佛印和尚是好朋友,但二人喜欢言语相讽,各不相让,经常是苏东坡占下风.
  有一次,苏东破问佛印说:
  "你看我像什么?"
  "我看你像尊佛."佛印说.
  苏东破暗喜,随即就问佛印:
  "那你可知道我看你像什么呢?"
  "像什么?"
  "像一堆屎!"
  佛印语塞.苏东坡哈哈大笑.
  回家后,苏东坡面带笑容哼哼叽叽.
  苏小妹见状问道:
  "哥哥,什么事情这么高兴呀?"
  "哼,佛印这次总算载我手里了!"苏东坡得意的说.
  问明原委,苏小妹大叫道:
  "哥哥,这次你输得更惨了!"
  "为什么?"苏东坡急忙问.
  苏小妹说:
  "因为心中有什么,外在才看到什么.心中有佛,看别人才是佛;心中有屎,看别人就是屎!"
posted @ 2006-06-04 10:54 蓝色Saga 阅读(161) | 评论 (0)编辑 收藏

   E=MC^2,这是伟大的爱因斯坦著名的质能公式:能量等于质量乘以速度的平方。
  人与人在质量,能力(智商)上的差别是很小的,也就是说“M”基本上是个常数。因此,人能发出的能量(success),就取决于其速度(C^2)。

   时间就是胜利。

    竞赛以快取胜,搏击以快打慢,军事先下手为强,商战从"大鱼吃小鱼"到"快鱼吃慢鱼"。跆拳道要求心快,眼快,手快;中华武学一言以蔽之,百法有百解,唯快无解!
    大而慢等于弱,小而快可变强,大而快王中王!快就是机会,快就是效率,快就是瞬间的"大",无数的瞬间构成长久的"强"。
    竞争的实质,就是在最快的时间内做最好的东西。人生最大的成功,就在于在最短的时间里达到最多的目标。质量是"常量",经过努力都可以做好以至于难分伯仲;而时间,永远是"变量”:一流的质量可以有很多,而最快的冠军只有一个-任何领先,都是时间的领先!

  我们慢,不是因为我们不快,而是因为对手更快。
  盛田昭夫说:
  "如果你每天落后人家半步,一年后就是一百八是三步,十年后即为十万八千里。"

   在非洲的大草原上,一天早晨,曙光刚刚划破夜空,一只羚羊从睡梦中猛然惊醒。
  "赶快跑!" 它想到,“如果慢了,就可能被狮子吃掉!“
   于是,起身就跑,向着太阳的方向飞奔而去。
   就在羚羊醒来的同时,一只狮子也醒了。
  ”赶快跑“,狮子也想到,”如果慢了,就可能被饿死!“
   于是,起身就跑,也向着太阳的方向飞奔而去。

   谁快就谁赢,谁快就谁生存。一个是自然界兽中之王,一个是事草的羚羊,等级差异,实力悬殊,但生存却面临同一个问题-如果羚羊快,狮子就饿死;如果狮子快,羚羊被吃掉。
  贝尔在研究电话时,另一个叫格雷的人也在研究。两人同时取得突破。但贝尔在专利局赢了-比格雷早了两个钟头。当然,他们两人当时是不知道对方的,但贝尔就因为这120分钟而一举成名,誉满天下,同时也获得了巨大的财富。

  谁快谁赢得机会,谁快谁赢的财富。
  全世界的目光只会聚焦在第一名的身上。冠军才是真正的成功者。第一名后面,都是输家。
  时间的"量"不变,但"质"却不同。关键时刻一秒值万金。
posted @ 2006-06-04 10:53 蓝色Saga 阅读(301) | 评论 (0)编辑 收藏

    从今天开始从零学习JAVA,希望可以认识到更多的朋友,可以让自己的JAVA之路走得更为顺利一些!买了几本书来看也听了几接课,觉得JAVA很吸引我,我想我可以走得更远的.自信是最重要的.
    OOP(Object Oriented Programming)描述的是对象与对象之间的相互作用.听老师将面向过程与面向对象的最大区别是: 过程化程序设计先确定算法,再确定数据结构,再确定运算.面向过程编程,习惯于先建立数据结构存放数据并定义方法(函数)来操作数据;而面向对象的则是构建一个模型,将数据与方法组织在一起.
    我们可以把现实世界的事物抽象为对象.对象一般都有两个特征:状态(Status),行为(Behavior).软件的对象概念是由显示世界对象抽象而来.把现实世界的状态保存软件对象的变量中;现实世界对象的行为通过软件对象的方法(函数)来实现.
    我们把相似的对象划分成一个类.在软件中类就是一个模板,它定义了通用于一个特定种类的所有对象的状态(变量)和行为(方法).类是创建对象的模板,对象是类的实例.
    面向对象编程的难点在于思路的转变.我们通常习惯与考虑解决问题的方法,而不是抽象成对象再去解决它.
 类的构造方法
* 构造方法的名字和类名相同,并且没有返回值.
* 构造方法主要用于定义类的初始化状态.
* 我们不能直接调用构造方法,必须通过new关键字来自动调用,从而创建类的实例.
* Java的类都要求有构造方法,如果没有定义构造方法,Java编译器会提供一个缺省的构造方法,也就是不参数的构造方法.
方法的重载(overload)
 重载
构成的条件:方法的名称相同,但参数类型或参数个数不同,才能构成方法的重载.
code:
class Point
{
 int x,y;
 /*
  *带参数的构造方法和不带参数的构造方法就构成了方法(函数)的重载
 */
 Point(int a,int b)
 {
  x=a;
  y=b;
 }
 Point()
 {
  
 }
 void output()
 {
  System.out.println(x);
  System.out.println(y);
 }
 public static void main(String[] args)
 {
  //调用不带参数的构造方法
  //Point p=new Point();
  //pt.x=10;
  //pt.y=20;
  //p.output();
  Point p1=new Point(3,3); //调用带参数的构造方法
  p1.output();
 }
}
特殊变量this
* this变量代表对象本身
* 当类中有两个同名变量,一个属于类(类的成员变量),一个属于某个特定的方法(方法中的局部变量),使用this区分成员变量和局部变量.
* 使用this简化构造函数的调用
code:
class Point
{
 int x,y;
 /*
  *带参数的构造方法和不带参数的构造方法就构成了方法(函数)的重载
 */
 Point(int a,int b)
 {
  x=a;
  y=b;
 }
 Point()
 {
  this(1,1);
 }
 void output()
 {
  System.out.println(x);
  System.out.println(y);
 }
 /*output()方法定义的形参与成员变量同名了,
 *那么在output()里就看不到成员变量的x,y了,它被隐藏了.
 */
 void output(int x, int y)
 {
  this.x=x;
  this.y=y;
 }
 public static void main(String[] args)
 {
  Point pt=new Point(3,3);
  pt.output(5,5);
  pt.output();
 }
}
一个类所有的实例(对象)调用的成员方法在内存中只有一份拷贝,尽管在内存中可能有多个对象,而数据成员在内的没个对象中都存在着一份拷贝.this变量允许相同的实例方法为不同的对象工作.每当调用一个实例方法时,this变量被设置成引用该实例方法的特定的类的对象.方法的代码接着会与this所代表的对象的特定数据建立关联.
posted @ 2006-06-04 10:51 蓝色Saga 阅读(134) | 评论 (0)编辑 收藏

仅列出标题
共7页: 上一页 1 2 3 4 5 6 7