ITPub博客

首页 > Linux操作系统 > Linux操作系统 > 自己总结面向对象编程的总结

自己总结面向对象编程的总结

原创 Linux操作系统 作者:小科学家 时间:2009-04-11 20:04:01 0 删除 编辑

面向对象的思想:
    它是超乎语言之上的概念,其它面向对象思想的语言都是一样的。
面向对象的三大特征:封装,继承,多态。
封装:对外部不可见,封装数据,可以起到保护作用,不会一不小会漏掉一些数据。
继承:用于扩展类的功能,在JAVA中只有单继承,如果要实现像C++那样多继承,在JAVA中就要用到接口,它可以避免了多继承中成员方法,成员变量的重复的特点。
多态:(最重要)

下面我对面向对象的其中一部分知识点做出概括:

对象的定义:
  类名 对象名 = new 类名();举例:Student stu = new Student();
  我分析一下这里的机制。首先在栈内存有Student类型的name:stu, value:xx(这个值是与堆内存的联系----指针)。因为在堆内存存的就是一个个对象模块,所以new出来的Student这个实际对象就会在堆内存出现。此时就会执行Student的构造方法,然后返回对象实例的引用。俗点说,大家只要记住这点就好了:声明一个对象(栈内存中开辟了一个空间),实例化一个对象(堆内存开辟了空间,此时对象的引用stu就拥有了Student使用权)。
栈:对象名,堆:对象属性,全局代码区:所有方法的代码,全局数据区:存放static类型的数据

垃圾收集器的机制:最简单的理解如下:
  在程序中,不再有任何指向的空间---垃圾空间。JAVA中的垃圾是由JVM回收,自动完成


封装:让使用者只能通过实现定制好的方法来访问数据,可以方便地加入控制逻辑,限制对属性的不合理操作,也便于修改,增强代码的可维护性。就用private关键字实现封装。采用SetXxx()和GetSxx()来访问封装类内部的成员方法和成员变量。private起到了让外部看不到。就起到了封装,不会随便漏掉数据了。

 

JAVA权限修饰符: public protected private
private:只能访问类内部的成员方法和成员变量
default:除了拥有private功能之外,其他对象还可以访问同一个包中类的成员方法和成员变量。当我们定于成员方法或成员变量时,不写任何修饰符的时候,就默认用default。一般不写default。也就是说default类只能被同一个包中的类访问
protected:除了拥有default能访问同一个包中的方法和属性之外,还可以访问子类的方法和属性。
public : 这个不用说了,任何地方都可以访问本类的方法和属性。
定义class的权限修饰只能用public 和default。

匿名对象:比如new Student().sing();它的意思是调用Student类的sing()方法。
特点:可以不定义对象引用的名称,而直接调用这个对象的方法。
使用:如果对一个对象只需要进行一次方法的调用,那么就可以使用匿名对象。
常用:经常将匿名对象作为实参传递给一个方法调用。

String类的使用:
①特点:String类中的内容一旦声明则不可改变
   解释:不可以尝试通过方法改变已经声明字符串的内容。这点可以从内存角度来解释。
②两种使用方法:第一:private String name1 = "刘少科"; 第二:private String name2 = new String("刘少科");如果大家这样输出:System.out.print(name1==name2);System.out.print(name1.equals(name2));输出内容前者是false后者是true。
equals:是两个内容的比较,字符串的内容或者对象里面的内容
"==":数值比较,比较的是内存地址的值是否相等。这点大家可以参考有关文档,我不详细介绍了。
总结:直接赋值----只开辟了一个空间,使用new:开辟了两个空间(其中有一个是垃圾空间)
③ String使用了JAVA中的共享设计模式:举例:private String name1="刘少科"; private name2 = "刘少科"; System.out.private(name1==name2);是TRUE还是FALSE?String类非常特别。解释:当你定义name2时,如果已经定义了内容一样了name1,则name2不会再生成另外一块空间,此时,name1和name2都会指向"刘少科",所以它们的地址是一样的,怎上面的返回值肯定是true。
④补充:举例:String str="liushaoke"; for(int i=0;i<100;i<++){ str+=i;}System.out.print(str);如果大家有这种写法,则尽量回避这种情况。用内存的机制可以发现,它将会带来很多的垃圾空间。此时可以用StringBuffer类。


构造方法:
①特点:它具有与类名相同的名称,它不含返回值类型的定义,也没有返回值
②调用机制:构造方法在实例化对象时被自动调用,主要用来为类中的属性作初始化工作
③形式:如果没有写构造方法,则每当实例化对象时,自动生成一个无参的什么都不做的构造方法,如果明确写了无参构造方法,则不会再自动生成无参的构造方法。构造方法的重载我会在后面在总结。建议:无论采用哪种方法为类中的属性赋值,最好都经过Setter方法,由Setter方法对输入的内容进行检测,而Getter方法只是将内容简单地返回。


方法重写(overwrite/override):有几个基本原则
①在子类中可以根据需要对从父类中继承来的方法进行重写。
②重写方法必须和被重写方法具有相同的方法名称,参数列表和返回类型。
③重写方法不能使用被重写方法更严格的访问权限
注意:第二点很容易犯错误,一定要copy原来的方法,如果自己写的话,极容易出错,这种错误很难找,要有这种重写的意识。

方法重载(overload):
特点:方法名相同。但是参数的类型或个数不同l。

this的使用:
①在类的方法定义中使用的this关键字代表使用该方法的对象的引用。
②当必须指出当前使用方法的对象时是谁?这时候就要用到this。
③有时候用this可以处理方法中成员变量和参数重名的情况,比如
private String name;
public void run(String name){
 this.name = name;
}
④this可以看成一个变量,它的值是当前对象的引用。
对第四点解释:它不是任何对象的引用,this是指向自己本身的类的引用,它是堆内存的,与栈内存没有任何一点关系。因为它是指向自己本身。俗点说this就是当前的类,只不过是一个引用。
⑤this调用本类属性,本类方法,构造方法这三点,是this的基本运用,也是最常用的,综合起来就是一点------表示当前对象。举例:
class Student{
  private String name;private String age;
  public Student(){}
  public Student(String name){ this.name=name}
  public Student(String name,String age){this(name);this.age=age}
}
我在这里举这个例子就可以说明前面的一些理论。注意,构造方法重载中的this(name);这个一定要放在Student含两个参数构造方法的首行。


super的使用:和this很相似
①调用父类的方法:调用父类的特定构造方法。如 super();super(name);super(name,age);
 我举个例子:
 class a extends Student{
  public void printStuInfor(){
   super();
   super("刘少科");
   super("刘少科",22);
  }
}
也就是说可以通过super(),里面根据传入的参数区调用父类中指定的构造方法,默认是调用无参构造方法
②调用父类中被覆盖的方法:通过调用super().父类的方法就可以在实例化子类时调用父类的方法------------相当方法被重写了,所以这时在子类就可以增加自己新的方法就可以了,默认就会执行super()方法。


this与super() 的区别:
   两者用法很相似。
   this与super调用构造的操作能同时在一个构造方法出现吗?肯定不行,只能用一个。

 

static的用法:
①static属性可以被static和非static类型的方法所使用,非static属性不可以被static方法使用。
②static声明的属性,表示此属性为公有属性,也就是说:所有对象都可以访问此属性。它是存放在全局数据区。可以用类名加点来直接访问static属性。如果你想尝试通过某个具体的对象改变static属性的内容,对不起,你改不了。
③静态方法不能调用非静态属性和方法,非静态方法可以调用静态属性和方法。
④static代码块:
  首先解释一下JAVA的四种代码块的区别:
  一,普通代码块:是写在一个方法之中的语句块
  二,构造块:是直接写在类中的一个语句块,构造块优先于构造方法执行
  三,静态块:是直接写在类中的,通过static声明的语句块,优先于构造块和构造方法,主要作用是为静态属性初始化,只执行一次。
  四,同步代码块:经典的用处是在多线程的线程同步。


继承的使用:
   特点:实现功能的扩展,良好的扩展性有利于以后功能的扩展。
   规定:JAVA只支持单继承,没有多继承,就像一个小孩只有一个血缘关系的父亲。
   注意:子类可以继承父类中的公有属性和共有方法,而不能直接操纵父类中的私有方法。
        可以通过封装的特性来访问父类的私有属性和私有方法。
   补充:要先有父类才能有子类的产生,所以当你实例化子类时,它会先执行父类的构造方法,先产生父类,之后才会执行子类的有关方法。它会调用super();如果在子类没有写super();在实例化时会自动掉用默认的super();

final关键字的使用:-----相当于太监。呵呵呵
①final标记的泪不能被继承
②标记的方法不能被子类重写
③final标记的变量(成员变量或局部变量)即成为常量,只能赋值一次。
全局常量的定义:public static final。数据存在全局数据区。final定义的变量一般用大写。


抽象类:
①定义:类和方法必须用abstract修饰
②原则:抽象类不能被直接实例化,抽象方法只能声明,而不需要实现。
③含有抽象方法的类必须被声明为抽象类,抽象类的子类必须重写父类的抽象方法。
注意:抽象类必须有子类,子类如果不是抽象类的话,则必须重写抽象类的全部方法
我问大家:抽象类可以有构造方法吗?还有抽象类可以用final声明吗?
解释:构造方法是对象实例化时使用的。子类对象在实例化对象时依照先实例化父类中的属性,再实例化本类中的属性,这和在一般的继承中,实例化对象时的机制一样的。final可以声明一个类,但是此类是不能有子类的父类,但是抽象类必须要有子类的实现,所以抽象类一定不可以用final声明。


接口:是抽象方法和常量的集合。
抽象类中包含抽象方法,那如果全部都是抽象方法,则可以用接口来表示。
常量定义:一定要这样用:public static final String name;如果你没有这么写,而写成了String name;则会默认像前面那样。举例:
interface Person{
 public static final String furColor="orange";
 public void Sing();
 public void say();
}
class student implements Person{
  //在这里一定要重写接口中的方法
}
一个类可以同时实现多个接口。
一个接口可以允许继承多个接口
但是一个类是不允许继承多个类的

 

多态的知识点:
●接口和抽象类很重要,多态就是最好的体现。
•方法的多态性(重载):同一个方法名称根据传入参数的不同,完成的功能也不同
•对象的多态性:它是在继承应用上的一种扩展,所以多态是建立在继承关系之上。
  *面向对象程序开发的一个思路:【建议】永远不要去继承一个普通类
子类对象和父类对象之间的转换
★向上转型:子类对象向父类对象转换(⊕自动转型 父类对象=子类对象 )
★向下转型:父类对象向子类对象转换(☉强制转换 子类对象=(子类)父类对象 )
注意点:如果一个方法被子类重写了,则子类与父类发生转换,自动去调用已经被重写过的方法(子类中的方法);★★★★★
对象多态性最核心的部分:方法的覆写与继承的关系,只要有继承关系,只要有覆写过的方法,则子类向父类进行转型时,肯定调用被子类覆写过的方法(核心)
★接口与抽象类的实际应用:基础类,封装,继承,覆写,多态性。

对象多态性
开发建议:不要去继承一个已经实现好的类
如果以后在开发中需要继承,则大部分情况下继承的都会是一个抽象类,当然,也有一个问题,抽象类有JAVA单继承局限,不能多继承。所以用到接口。

接口的实际应用:
 接口的使用:将方法名暴露给用户(比较难理解)
 接口对象的实力:通过对象的多态性,由子类为接口对象实例化

抽象类与接口在使用上非常的相似。
在开发过程上讲:优先使用接口,接口允许多继承的特点。
抽象类与接口的比较:
相同点:对象不能直接实例化,通过多态性,可有其子类实例化
不同点:
抽象类:包括一般方法,抽象方法,变量,常量; 可以有构造方法;抽象类可以实现多个接口;继承时,单继承会有局限。
接口:包括常量,抽象方法;不能有构造方法;接口不能继承一个抽象类;解决单继承的局限。
注意这样一个特点:接口中都是抽象方法,则子类必须全部覆写接口中的全部抽象方法,那么如果现在子类不希望全部都覆写呢?又怎样操作?用适配器Adapter:适配器的设计模式
接口---抽象类---子类

接口可以进一步扩展---------工厂设计模式
接口与抽象类的应用:(需要长时间的训练才能读透,我也不是很熟练哦,呵呵,大家一起进步哦)

 

附录:一个是多态性在抽象类的应用,一个是用抽象类实现继承,一个是用接口实现继承
abstract class Person
{
 private String name ;
 private int age ;
 public Person(String name,int age)
 {
  this.setName(name) ;
  this.setAge(age) ;
 }
 public void setName(String name)
 {
  this.name = name ;
 }
 public void setAge(int age)
 {
  this.age = age ;
 }
 public String getName()
 {
  return this.name ;
 }
 public int getAge()
 {
  return this.age ;
 }
 // 将说话的内容作为一个抽象方法,通过子类去实现
 public void say()
 {
  System.out.println(this.getContent()) ;
 }
 public abstract String getContent() ;
};
// 假设人分为两种 :一种是工人,一种是学生
// 工人有工资,学生有成绩
// 不管是学生还是工人,肯定都可以说话
// 说话的内容不一样
class Worker extends Person
{
 private float salary ;
 public Worker(String name,int age,float salary)
 {
  super(name,age) ;
  this.setSalary(salary) ;
 }
 public void setSalary(float salary)
 {
  this.salary = salary ;
 }
 public float getSalary()
 {
  return this.salary ;
 }
 public String getContent()
 {
  return "工人说 --> 姓名:"+super.getName()+",年龄:"+super.getAge()+",工资:"+this.getSalary() ;
 }
};
class Student extends Person
{
 private float score ;
 public Student(String name,int age,float score)
 {
  super(name,age) ;
  this.setScore(score) ;
 }
 public void setScore(float score)
 {
  this.score = score ;
 }
 public float getScore()
 {
  return this.score ;
 }
 public String getContent()
 {
  return "学生说 --> 姓名:"+super.getName()+",年龄:"+super.getAge()+",成绩:"+this.getScore() ;
 }
};
public class OODemo03
{
 public static void main(String args[])
 {
  Person p = null ;
  // p = new Student("张三",30,90) ;
  p = new Worker("张三",30,3000) ;
  p.say() ;
 }
};

 

 

 

interface USB
{
 // 开始工作
 public void start() ;
 // 停止工作
 public void stop() ;
}
// 对于PC机上认的是一个USB接口
class PC
{
 public static void plugin(USB u)
 {
  u.start() ;
  u.stop() ;
 }
};
class Mp3 implements USB
{
 public void start()
 {
  System.out.println("Mp3开始工作了。。。") ;
 }
 public void stop()
 {
  System.out.println("Mp3停止工作了。。。") ;
 }
};

class UDisk implements USB
{
 public void start()
 {
  System.out.println("U盘开始工作了。。。") ;
 }
 public void stop()
 {
  System.out.println("U盘停止工作了。。。") ;
 }
};

public class OODemo05
{
 public static void main(String args[])
 {
  PC.plugin(new UDisk()) ;
 }
};

 

 

 

interface A
{
 public void fun1() ;
 public void fun2() ;
 public void fun3() ;
}
abstract class B implements A
{
 public void fun1()
 {}
 public void fun2()
 {}
 public void fun3()
 {}
};
class C extends B
{
 public void fun1()
 {
  System.out.println("HELLO 垃圾广告 ...") ;
 }
};
public class OODemo06
{
 public static void main(String args[])
 {
  A a = new C() ;
  a.fun2() ;
 }
};

 

 


interface USB
{
 // 开始工作
 public void start() ;
 // 停止工作
 public void stop() ;
}
class Mp3 implements USB
{
 public void start()
 {
  System.out.println("Mp3开始工作了。。。") ;
 }
 public void stop()
 {
  System.out.println("Mp3停止工作了。。。") ;
 }
};

class UDisk implements USB
{
 public void start()
 {
  System.out.println("U盘开始工作了。。。") ;
 }
 public void stop()
 {
  System.out.println("U盘停止工作了。。。") ;
 }
};
// 假设现在要修改子类,则要修改mian方法,是一个程序的客户端
class Factory
{
 public static USB getUSBInstance()
 {
  return new UDisk() ;
 }
};
public class OODemo07
{
 public static void main(String args[])
 {
  USB u = Factory.getUSBInstance() ;
  u.start() ;
  u.stop() ;
 }
};


 

来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/21359667/viewspace-588691/,如需转载,请注明出处,否则将追究法律责任。

上一篇: CIO看待ERP
请登录后发表评论 登录
全部评论

注册时间:2009-04-11

  • 博文量
    30
  • 访问量
    30861