Java_面向对象的封装_继承_多态.doc

《Java_面向对象的封装_继承_多态.doc》由会员分享，可在线阅读，更多相关《Java_面向对象的封装_继承_多态.doc（54页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、封装，接口,继承，覆盖，构造过程，多态，static、this、super、final用法一、封装 (encapsulation) 定义：封装就是将客户端不应看到的信息包裹起来。使内部执行对外部来看不一种不透明的、是一个黑箱，客户端不需要内部资源就能达到他的目的。1事物的内部实现细节隐藏起来 2对外提供一致的公共的接口间接访问隐藏数据 3可维护性 -二、 继承 (inherit) JAVA继承特点 继承：父类的成员能否继承到子类？ 对类成员访问的限制及子类继承情况： （从严 到宽 ）private 私有，本类内部 不能继承(default) 本类同包 同包子类可继承 protected 本类同

2、包子类 可以继承public 公开 任何地方都可以访问 能继承到子类 -覆盖 1、定义： 覆盖了一个方法并且对其重写，以求达到不同的作用。2、用法：a、最熟悉的覆盖就是对接口方法的实现b、在继承中也可能会在子类覆盖父类中的方法3、产生 “覆盖”的条件：1、方法名：相同 2、参数表：相同（个数，类型） 3、访问限制符：相同或者更宽 4、返回值类型：相同 或者 子类返回的类型是父类返回的类型的子类 5、不能抛出比subclass(父类)更多的异常 注意：当我们在子类中创建的静态方法，它并不会覆盖父类中相同名字的静态方法。 class Parent public void nonStaticMeth

3、od() System.out.println(Parents Non-Static Method is Called); public static void staticMethod() System.out.println(parents static method is called); class Child extends Parent public void nonStaticMethod() System.out.println(childs non-static method is called); public static void staticMethod() Syst

4、em.out.println(childs static method is called); public class Test public static void main(String args) Parent p1 = new Parent(); Parent p2 = new Child(); Child c = new Child(); System.out.print(Parent.static: ); Parent.staticMethod(); System.out.print(p1.static: ); p1.staticMethod(); System.out.prin

5、t(p2.static: ); p2.staticMethod(); System.out.print(p1.nonStatic: ); p1.nonStaticMethod(); System.out.print(p2.nonStatic: ); p2.nonStaticMethod(); System.out.print(Child.static: ); Child.staticMethod(); System.out.print(c.static: ); c.staticMethod(); System.out.print(c.nonStatic: ); c.nonStaticMetho

6、d(); 程序的运行结果为：Parent.static: parents static method is calledp1.static: parents static method is calledp2.static: parents static method is calledp1.nonStatic: Parents Non-Static Method is Calledp2.nonStatic: childs non-static method is calledChild.static: childs static method is calledc.static: child

7、s static method is calledc.nonStatic: childs non-static method is called值得注意的是p2实际上是一个Child的类型的引用，然而在调用静态方法的时候，它执行的却是父类的静态方法，而不是Child的静态方法，而调用 p2的非静态方法的时候执行的是Child的非静态方法，为什么呢？原因是静态方法是在编译的时候把静态方法和类的引用类型进行匹配，而不是在运行的时候和类引用进行匹配。因此我们得出结论：当我们在子类中创建的静态方法，它并不会覆盖父类中相同名字的静态方法。 -构造（java编程思想定义为：构造器初始化）对象的构造过程：

8、首先为对象分配内存空间，包括其所有父类的可见或不可见的变量的空间，并初始化这些变量为默认值，如int类型为0，boolean类型为false，对象类型为null。 然后用下述5个步骤来初始化这个新对象：1)分配参数给指定的构造方法；2)如果这个指定的构造方法的第一个语句是用this指针显式地调用本类的其它构造方法，则递归执行这5个 步骤；如果执行过程正常则跳到步骤5；3)如果构造方法的第一个语句没有显式调用本类的其它构造方法，并且本类不是Object类（Object是所有其它类的祖先），则调用显式（用super指针）或隐式地指定的父类的构造方法，递归执行这5个步骤；如果执行过程正常则跳到步骤5

9、；4)按照变量在类内的定义顺序来初始化本类的变量，如果执行过程正常则跳到步骤5；5)执行这个构造方法中余下的语句，如果执行过程正常则过程结束。对分析本文的实例最重要的，用一句话说，就是“父类的构造方法调用发生在子类的变量初始化之前”。可以用下面的例子来证明：列1class Animal Animal() System.out.println(Animal);class Cat extends Animal Cat() System.out.println(Cat);class Store Store()System.out.println(Store);public class Petstor

10、e extends StoreCat cat = new Cat();Petstore()System.out.println(Petstore);public static void main(String args) new Petstore();运行这段代码，它的执行结果如下：StoreAnimalCatPetstore从结果中可以看出，在创建一个Petstore类的实例时，首先调用了它的父类Store的构造方法；然后试图创建并初始化变量cat；在创建cat时，首先调用了Cat类的父类Animal的构造方法；其后才是Cat的构造方法主体，最后才是Petstore类的构造方法的主体。列2c

11、lass Animal Animal() System.out.println(Animal);class Cat extends AnimalCat() System.out.println(Cat);class Cat2 extends AnimalCat2() System.out.println(Cat2);class Store Cat2 cat=new Cat2();Store() System.out.println(Store);public class Petstore extends StoreCat cat = new Cat();Petstore() System.ou

12、t.println(Petstore);public static void main(String args) new Petstore();运行这段代码，它的执行结果如下： AnimalCat2StoreAnimalCatPetstore这例1和例2，使我更了解了类的构造过程：类在new实例的时候a。第一步构造类的成员变量 这里需要注意的： a）即使变量定义散布于方法定义之间，它们仍旧会在任何方法（包括构造函数）被调用之前得到初始化 b）初始化的顺序是先“静态”对象（初始化过后，静态对象不会再被初始化），而后是“非静态”对象。 第二步调用构造方法。b。如果有父类，那么就是先构造父类的成员变

13、量，然后再调用父类的构造方法，然后再a。-this用法java中的this随处可见，用法也多，现在整理有几点：1. this是指当前对象自己。 当在一个类中要明确指出使用对象自己的的变量或函数时就应该加上this引用。如下面这个例子中: public class HelloString s = Hello; public Hello(String s) System.out.println(s = + s); System.out.println(1 - this.s = + this.s); this.s = s; System.out.println(2 - this.s = + this

14、.s); public static void main(String args) Hello x=new Hello(HelloWorld!); 运行结果：s = HelloWorld! 1 - this.s = Hello 2 - this.s = HelloWorld! 在这个例子中，构造函数Hello中，参数s与类Hello的变量s同名，这时如果直接对s进行操作则是对参数s进行操作。若要对类Hello的成员变量s进行操作就应该用this进行引用 class A public A() new B(this).print(); public void print() System.out.

15、println(Hello from A!); class B A a; public B(A a) this.a = a; public void print() a.print(); System.out.println(Hello from B!); public class Cpublic static void main(String args) A x=new A();运行结果： Hello from A! Hello from B! 在这个例子中，对象A的构造函数中，用new B(this)把对象A自己作为参数传递给了对象B的构造函数。2。在构造函数中，通过this可以调用同一c

16、lass中别的构造函数，如class Flower Flower (int pig) System.out.println(pig:+ pig ); Flower(String ss) ss=string; System.out.println(ss:+ ss); Flower(int pig, String ss) this(pig); System.out.println(pigpig+ pig); public class Zxpublic static void main(String args) Flower a=new Flower(7,java);运行结果：pig：7；pigpi

17、g：7；值得注意的是：1：在构造调用另一个构造函数，调用动作必须置于最起始的位置。2：不能在构造函数以外的任何函数内调用构造函数。 -static 1. 调用静态方法时,不需要产生对象.因为静态方法属于类本身,而不属于对象. 调用时: 类名.静态方法名() 就可以2. class Point int x; static int y; /定义了1个静态变量 static void output() System.out.println(out); public static void main(String args) Point.output(); /调用静态方法 Point pt1=new

18、point(); Point pt2=new point(); pt1.y=5; pt2.y=6; System.out.println(pt1.y); System.out.println(pt2.y); 结果pt1 6pt2 6 静态常量和静态方法,都只属于某个类,加载的时候 已经有内存空间了.所有对象都共享同1个静态变量,同1个静态方法.引用直接通过类名引用. 但非静态方法,可以调用静态方法和静态变量;但反过来,静态方法不能调用非静态变量和非静态方法.(即 x)- finalfinal类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不

19、需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。 1.定义及编程技巧 final类不能被继承，没有子类，final类中的方法默认是final的。 final方法不能被子类的方法覆盖，但可以被继承。 final成员变量表示常量，只能被赋值一次，赋值后值不再改变。 final不能用于修饰构造方法。 注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的2、final方法 如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。 使用final方法的原因有二： 第一、把方法锁定，防止任何

20、继承类修改它的意义和实现。 第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。技巧：final static 类型成员变量。static使得变量只存在一个拷贝。final使得它不能改变。3.关于final成员赋值的讨论： a.final 成员能且只能被初始化一次 b.final成员必须在声明时或者在构造方法中被初始化，而不能在其它的地方被初始化。eg1public class Aox int height; Aox(int h) height=h; void bb() System.out.println(height); public static void m

21、ain(String args) Aox boxobj = new Aox(25); boxobj.bb(); boxobj=new Aox(32); boxobj.bb(); 运行结果：2532 eg2public class Aox int height; Aox(int h) height=h; void bb() System.out.println(height); public static void main(String args) Aox boxobj = new Aox(25); boxobj.bb(); / boxobj=new Aox(32); 出错！ boxobj.b

22、b(); - super 1.super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句） 2.super:它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时）如：super.变量名 super.成员函数据名（实参） -包 1.从本质上来说，包是将类组合在一起形成代码模块的一种机制，可以将包看成一个“文件夹”，而包里的各类，则是“文件”。 用途：避免命名冲突；可以在更广的范围保护类，数据和方法。 2.创建包 package a； /a是包名 3.导入包 1) import package a.* /a是包名。字符*

23、则导入了包里的所有类和接口。 2) import package a.b /a是包名，b是类名。该操作导入了a包里的b类，而不会导入其它类。 4.使用其它包的类，而没有用import导入该包，操作如下： a.b x new a.b（）; /a是包名，b是a包里的类，x是刚创建的该类的实例名。怎样理解封装，继承，多态！三者的区别？封装：每个对象都包括进行操作所需要的所有信息，而不依赖于其他对象来完成自己的操作。通过类的实例来实现。 好处：良好的封装可以降低耦合度；类的内部可以自由修改；类具有对外的清晰接口。 继承：IS-A的关系。A is-a B：A是B，A可以继承B。A是B的一个特例，特殊化，

24、A又可以具备自己独有的个性。三点： 子类拥有父类非private的属性和功能（父类的构造函数例外，可以用base关键字访问，base代表着父类）； 子类具有自己的属性和功能，即子类可以扩展父类没有的属性和功能； 子类可以以自己的方式重写父类的功能。 缺点：父类变，子类不得不变，父子是一种强耦合的关系。 多态：不同的对象可以执行相同的动作，但要通过他们自己的实现代码来执行。注意点： 子类以父类的身份出现； 子类在运行时以自己的方式实现； 子类以父类的身份出现时，子类特有的属性和方法不可以使用。 为了使子类的实例完全接替来自父类的类成员，父类必须将该成员声明为虚拟的（virtual），子类可以选择

25、使用override将父类的实现替换为自己的实现，这就是多态。 1。类是对对象的一个抽象，同时类也为对象进行了封装。所谓封装是说类的设计者只是为使用者提供类 对象可以访问的部分，而对于类中其他隐藏起来的成员变量 方法，用户不能访问。 实现方式：A：在类的定义中设置对对象中成员变量和方法进行访问的权限; B：提供一个统一的供其他类引用的方法; C：其它对象不能直接修改文本对象所拥有的属性和方法。 2。访问权限： A:private的成员变量和方法只能被这个类本身的方法访问; B:默认的成员变量和方法只被同一个包内的其它所有类都可访问，包外不可; C: protected的成员可以被这个类的本身、

26、它的子类（同不同包均可）访问; D: public 完全公开。一个程序里最多只能有一个类被修饰为public,若程序中没有任何public 类，且文件名是程序中的一个类名，则该类被视做public 注：不能用protected和private饰！ 3。类的继承： 3.1 类继承的实现： A：java中Object类是java中所有类的祖宗！（P209） 儿子A extends 老爸-只能有一个老爸！ 3.2 this和super: this: this.数据成员 this.实例方法 this(参数)-引用本类中其他构造方法。 super:表示当前对象父类对象的引用 super.数据成员 sup

27、er.实例方法 super(参数)-引用父类的构造方法。-通常在实现子 类的构造方法时，要先调用父类的构造方法！并且用来调用父类构造方法的super()必须放在子类构造方法的句首 3.3 初始化顺序： A 对象的初始化顺序： 先静态成员，再非静态成员，再构造方法， B 继承中构造方法的调用顺序： 先父类，再子类。 3.4 对象之间的类型转换： 对象转换的圣经：只能说猫是哺乳动物，不能说哺乳动物是猫！当说猫是哺乳动物时，猫将失掉猫独有的属性和行为！（作为猫时新增的成员变量和方法） 哺乳动物 aa=new 猫（）-猫是哺乳动物（要通过IS-A测试） 4.千呼万唤始出来-多态！ 所谓多态就是同一方法

28、获得不同的行为特性！ 分为： A 编译时多态性-重载 (参数个数不同或参数类型不同) B 动态多态性-覆盖（ 改写后的方法不能比覆盖的方法有更严格的访问权限-只能更加开放& 改写后的方法不能比被覆盖的法产生更多的例外） * 放点小音乐吧！ * * 第一曲 final： 1。final type 变量名=初值-常量 2。final 方法-该方法任何时候都不可以覆盖，但可以被重载。 3。final 类 -该类不能被继承并覆盖其内容。（像System类，String类） 第二曲 native: 本地引用说明符 java允许在程序中直接引用本地机上非java语言编写的程序。 native type p

29、rogramName(参数列表); programName是要引用的程序名，以方法的形式出现。由于是引用，具体执行的操作都包含在源程序中，所有programName后无具体方法体！ * 一。深入继承： 1设计继承树： (1)找出具有共同属性和行为的对象(狼和狗与羊-动物共同的属性) (2)设计代表共同状态与行为的类(都属于动物！-父类) (3)决定子类是否需要让某项行为有特定不同运作的方式(都会吃，但羊只吃草-方法的覆盖) (4)通过寻找使用共同行为的子类找出更多抽象化的机会(狼和狗属于犬科！-再继承) (5)检查设计是否合理(IS-A) (6)大功告成！ 2继承的意义： (1)避免了重复的代

30、码(子类会时时响应父类的改变) (2)定义出共同的协议(服务于多态) ？当定主义出一组类的父型时，你可以用子型的任何类来填补任何需要或期待父型的位置？ 二。深入多态： (1) class Vet public void giveShot(Animal a) a.makeNoise(); class PetOwner public void start() Vet v=new Vet(); Dog d=new Dog(); Hippo h=new Hippo(); v.giveShot(d); V.giveSHot(h); 在此例中如果用Animal类型来声明它的参数(返回类型、数组的类型)，则

31、程序代码就可以处理所有Animal的子类。这意味 着其它人只要注意到要扩充过Animal就可以利用你的Vet!(P168) 如果此例不用多态，那么每一种动物都要写出不同的方法-这是何等悲哀！ (2)接口： 多态意味着“很多形式”，可以把儿子当作爸爸或爷爷！ 可以通过继承来定义相关类间的共同协议(方法就是协议的标志！)，这样就等同于在对其他程序代码声明：“我所有的子类都能肠系用这些方法来执行这几项工作！” 为了避免出现“致命方块”所以java不允许出现多继承，接口正是我们的救星！java接口是100% 的纯抽象类。而且使用接口可以继承一个以上的来源，同时其他类也可以实现同一个接口中。所以可以为不

32、同的需求组合出不同的继承层次！ 三。如何判断应该是设计类、子类、抽象类或接口呢？ (1)如果新类无法对其他的类通过IS-A测试时，就设计不继承其他类的类。 (2)只有在需要某类的特殊化版本时，以覆盖或增加新的方法来继承现有的类。 (3)当你需要定义一群子类的模板，又不想让其他人初始化此模版时，设计出抽象的类给他们用。 (4)如果想要只定义出类可以扮演的角色，使用接口。 说那么多 自己 经常用用就知道了封装，继承，多态 封装 就是 把 孩子放到一块管理 继承 就是 生孩子 多态 男人 ,女人 ,人妖 ,就是 人的多态你认为大家不理解吗？这些东西，只有用了先知道。 多态，你写过名称相同，参数不同的

33、函数吗？ 继承，你的所有aspx页面，不都是继承Page吗？ 封装，你没有自己写过类吗？你类里没有封装方法吗？接口主要涉及跨平台、跨语言、移植性要求较高的编程 一般情况下不会用到的.面向对象的三个特征.继承,封装和多态. C#是一种现代的面向对象的语言. 继承(inheritance):继承是一个面向对象的词语.说明,一个类(派生类)能分享,其它类(基类)的特征和行为.派 生类和基类是is a的关系. base classes(基类):通常基类可以自己实例化,或被继承.派生类继承基类中的成员,被标记为protected或更大 的权限.语法: class (derive class name):

34、(base class name) 例子: /基类 public class Contact /默认私有的字段 string name; string email; string address; /构造函数 public Contact() / statements . /属性 public string Name get return name; set name = value; public string Email get return email; set email = value; public string Address get return address; set ad

35、dress = value; /派生类 public class Customer : Contact /自己的私有字段 string gender; decimal income; public Customer() / statements . 在上面的例子中,Customer 是 Contact的子类,不但,继承了父类的成员,name,email,address;还有自己的成员,gender,income. abstract classes(抽象类):抽象类是一种特殊的基类.除过普通的类成员,它们还有抽象的类成员.抽象类成员, 是不能被实例化的方法和属性.所有直接从抽象类派生的类,必须实现抽象的方法和属性.抽象类不能被实例化. 例子: /抽象类 abstrac