java的三大特性,封装,继承,多态

封装

Java代码  

  1. /**
  2. * 所谓封装,就是将对象具有的成员变量和成员函数包装和隐藏起来,让外界无法直接使用,
  3. * 被封装的成员只能通过某些特定的方式才能访问。
  4. * 实现封装有两个步骤:
  5. *   1、将不能暴露的成员隐藏起来,我们就不能让其在类的外部被直接访问或赋值。
  6. *      实现方法是将该成员定义为私有的,在成员定义前加上private访问权限修饰符。
  7. *   2、用公共方法来暴露对该隐藏成员的访问,可以给成员加上public修饰符,将该成员定义为公共的
  8. */
  9. package com.study.feature;
  10. /**
  11. *
  12. * @className :Package
  13. * @package : com.study.feature
  14. * @Description :封装性的测试
  15. * @author:lgf
  16. * @date :2012 三月 12  10:20:35
  17. * @version : 1.0
  18. */
  19. public class Package {
  20. // 使用private隐藏
  21. private String strValue;
  22. // 通过get和set进行访问
  23. public String getStrValue() {
  24. return this.strValue;
  25. }
  26. public void setStrValue(String strValue) {
  27. this.strValue = strValue;
  28. }
  29. }

继承 
父类 ExtendsFather.java

Java代码  

  1. /**
  2. * 继承是一种联结类的层次模型,并且允许和鼓励类的重用,它提供了一种明确表述共性的方法。
  3. * 对象的一个新类可以从现有的类中派生。
  4. * 1. 为什么要使用继承?
  5. *  a.提高程序的扩展性。
  6. b.提高了代码的重用性。
  7. 2. 子类能继承到父类的那些方法和属性
  8. 第一种:所有的属性和方法都被子类继承到了。
  9. 第二种:
  10. a、子类和父类在同一个包下:
  11. 公有的受保护的属性和方法被子类继承到了。
  12. b、子类和父类不在同一个包下:
  13. 公有的方法和属性被子类继承到了。
  14. 3. 子类的对象能调用父类的那些方法和属性?
  15. a、子类和父类在同一个包下:
  16. 公有的受保护的属性和方法能被子类调用。
  17. b、子类和父类不在同一个包下:
  18. 公有的方法和属性能被子类调用。
  19. 在类和抽象类中,默认的就是受保护的。
  20. 在接口中,默认的就是公有的。
  21. */
  22. package com.study.feature;
  23. /**
  24. * 父类
  25. * @className :ExtendsFather
  26. * @package : com.study.feature
  27. * @Description :继承测试
  28. * @author:lgf
  29. * @date :2012 三月 12  10:33:02
  30. * @version : 1.0
  31. */
  32. public class ExtendsFather {
  33. // 定义不同四种修饰符的属性
  34. private     String privateValue;
  35. protected   String protectedValue;
  36. String defaultValue;
  37. public      String publicValue;
  38. // 定义不同四种修饰符的方法
  39. private void privateFunction(){
  40. System.out.println("privateFunction");
  41. }
  42. protected void protectedFunction(){
  43. System.out.println("protectedFunction");
  44. }
  45. void defaultFunction(){
  46. System.out.println("defaultFunction");
  47. }
  48. public void publicFunction(){
  49. System.out.println("publicFunction");
  50. }
  51. }

同包下的子类 ExtendsChildrenSamePackage.java

Java代码  

  1. package com.study.feature;
  2. /**
  3. *
  4. *
  5. * @className :ExtendsChildrenSamePackage
  6. * @package : com.study.feature
  7. * @Description : 同一个包下面的继承关系
  8. * @author:lgf
  9. * @date :2012 三月 12  10:51:23
  10. * @version : 1.0
  11. */
  12. public class ExtendsChildrenSamePackage extends ExtendsFather{
  13. public static void main(String[] args) {
  14. ExtendsFather children = new ExtendsChildrenSamePackage();
  15. //children.privateValue = "no"; 无法访问到
  16. children.defaultValue = "ok";
  17. children.protectedValue = "ok";
  18. children.publicValue = "ok";
  19. //除了private修饰的方法,其他都继承到了
  20. //children.privateFunction();
  21. children.defaultFunction();
  22. children.protectedFunction();
  23. children.publicFunction();
  24. }
  25. }

不同包下的子类 ExtendsChildrenOtherPackage.java

Java代码  

  1. /**
  2. *
  3. */
  4. package com.study.featureSecond;
  5. import com.study.feature.ExtendsFather;
  6. /**
  7. *
  8. * @className :ExtendsChildrenOtherPackage
  9. * @package : com.study.featureSecond
  10. * @Description :不同包下面的继承关系
  11. * @author:lgf
  12. * @date :2012 三月 12  10:50:47
  13. * @version : 1.0
  14. */
  15. public class ExtendsChildrenOtherPackage extends ExtendsFather{
  16. public static void main(String[] args) {
  17. ExtendsFather children = new ExtendsChildrenOtherPackage();
  18. //children.privateValue = "no"; 无法访问到
  19. //children.defaultValue = "no"; 无法访问到
  20. //children.protectedValue = "no"; 无法访问到
  21. children.publicValue= "ok";
  22. //除了public修饰的方法,其他都未继承到了
  23. //children.privateFunction();
  24. //children.defaultFunction();
  25. //children.protectedFunction();
  26. children.publicFunction();
  27. }
  28. }

重载和重写 ExtendsOverRideLoad.java

Java代码  

  1. /**
  2. *
  3. */
  4. package com.study.feature;
  5. /**
  6. *
  7. * @className :ExtendsClass
  8. * @package : com.study.feature
  9. * @Description :重载和重写
  10. * @author:lgf
  11. * @date :2012 三月 12  11:00:35
  12. * @version : 1.0
  13. */
  14. public class ExtendsOverRideLoad extends ExtendsFather {
  15. @Override
  16. public void publicFunction() {
  17. //super.publicFunction(); 可以调用父类的方法
  18. System.out.println("Override publicFunction");
  19. }
  20. public void publicFunction(String str) {
  21. //super.publicFunction(); 可以调用父类的方法
  22. System.out.println("overload publicFunction");
  23. }
  24. public static void main(String[] args) {
  25. ExtendsFather child= new ExtendsOverRideLoad();
  26. //Override publicFunction
  27. child.publicFunction();
  28. //child.publicFunction("s");  仅仅只能使用到父类有的方法,重载的方法无法调用
  29. ExtendsOverRideLoad childSecond = new ExtendsOverRideLoad();
  30. //Override publicFunction
  31. childSecond.publicFunction();
  32. //overload publicFunction
  33. childSecond.publicFunction("overLoad");
  34. }
  35. }

多态

父类  Animal.java

Java代码  

  1. /**
  2. * 1. Java中除了static和final方法外,其他所有的方法都是运行时绑定的
  3. * 2. 构造方法是被隐式声明为static方法
  4. * 3. 动态绑定
  5. *  将一个方法调用和一个方法主体连接到一起称为绑定(Binding)。
  6. *  根据绑定的时机不同,可将绑定分为“早期绑定”和“后期绑定”两种。
  7. *  如果在程序运行之前进行绑定(由编译器和链接程序完成),称为早期绑定。
  8. *  如果在程序运行期间进行绑定,称为后期绑定,后期绑定也称为“动态绑定”或“运行时绑定”。
  9. *  在Java中,多态性是依靠动态绑定实现的,即Java虚拟机在运行时确定要调用哪一个同名方法。
  10. *
  11. *  4. 多态总结
  12. *      一、使用父类类型的引用指向子类的对象
  13. *      二、该引用只能调用父类中定义的方法和变量
  14. *      三、如果子类中重写了父类中的一个方法,那么在调用这个方法的时候,
  15. *          将会调用子类中的这个方法;(动态连接、动态调用)
  16. *      四、变量不能被重写(覆盖),”重写“的概念只针对方法,
  17. *          如果在子类中”重写“了父类中的变量,那么在编译时会报错。
  18. *  5. 多态详解 多态是通过:
  19. *      5.1 接口 和 实现接口并覆盖接口中同一方法的几不同的类体现的
  20. *      2 父类 和 继承父类并覆盖父类中同一方法的几个不同子类实现的.
  21. *
  22. *  6. 一个类型引用只能引用引用类型自身含有的方法和变量
  23. */
  24. package com.study.feature;
  25. /**
  26. * @className :Animal
  27. * @package : com.study.feature
  28. * @Description :多态的测试
  29. * @author:lgf
  30. * @date :2012 三月 12  13:50:36
  31. * @version : 1.0
  32. */
  33. public class Animal {
  34. public void eat(){
  35. System.out.println("eating");
  36. }
  37. }

多态实现

Java代码  

  1. /**
  2. *
  3. */
  4. package com.study.feature;
  5. /**
  6. *
  7. * @className :Cat
  8. * @package : com.study.feature
  9. * @Description :猫
  10. * @author:lgf
  11. * @date :2012 三月 12  13:54:01
  12. * @version : 1.0
  13. */
  14. public class Cat extends Animal{
  15. public void eat(){
  16. System.out.println("eating fish");
  17. }
  18. }

Java代码  

  1. /**
  2. *
  3. */
  4. package com.study.feature;
  5. /**
  6. *
  7. * @className :Dog
  8. * @package : com.study.feature
  9. * @Description :狗
  10. * @author:lgf
  11. * @date :2012 三月 12  13:55:38
  12. * @version : 1.0
  13. */
  14. public class Dog extends Animal{
  15. public void eat(){
  16. System.out.println("eating Bone");
  17. }
  18. }

结果

Java代码  

  1. /**
  2. *
  3. */
  4. package com.study.feature;
  5. /**
  6. *
  7. * @className :Main
  8. * @package : com.study.feature
  9. * @Description :多态测试
  10. * @author:lgf
  11. * @date :2012 三月 12  13:57:11
  12. * @version : 1.0
  13. */
  14. public class Main {
  15. public static void main(String[] args) {
  16. Animal animal = null;
  17. animal = new Animal();
  18. animal.eat();//eating
  19. Animal cat = new Cat();
  20. cat.eat();//eating fish
  21. Animal dog = new Dog();
  22. dog.eat();//eating Bone
  23. }
  24. }

例子2

Java代码  

  1. /**
  2. *
  3. */
  4. package com.study.feature;
  5. /**
  6. *
  7. * @className :Father
  8. * @package : com.study.feature
  9. * @Description :多态
  10. * @author:lgf
  11. * @date :2012 三月 12  14:53:41
  12. * @version : 1.0
  13. */
  14. public class Father {
  15. public void functionOne(){
  16. functionSecond();
  17. }
  18. public void functionSecond(){
  19. System.out.println("Father functionSecond");
  20. }
  21. }

Java代码  

    1. /**
    2. *
    3. */
    4. package com.study.feature;
    5. /**
    6. *
    7. * @className :Children
    8. * @package : com.study.feature
    9. * @Description :测试
    10. * @author:lgf
    11. * @date :2012 三月 12  14:55:15
    12. * @version : 1.0
    13. */
    14. public class Children extends Father{
    15. public void functionSecond(){
    16. System.out.println("Children functionSecond");
    17. }
    18. public static void main(String[] args) {
    19. Father c = new Children();
    20. c.functionOne();//Children functionSecond
    21. }
    22. }
时间: 2024-11-08 22:51:22

java的三大特性,封装,继承,多态的相关文章

(1) 深入理解Java面向对象三大特性 封装 继承 多态

转眼已经工作快6年了,最开始做了2年J2EE:然后整了2年的数据仓库,主要是Cognos的报表开发:现在从事4G LTE核心网的开发,用的语言任然是Java,但写代码的机会不多,基本都是看代码找BUG,偶尔做点new feature也是在比较成熟的框架上复制.粘贴.修改,大部分时间还是在理解业务,钱多.事少.离家近,当时来这家公司图的是后面2点,2年过去了,英文水平有所提升,对敏捷开放也有一定的了解,但技术方面明显退步了或者说没有进步吧,本来以前也不怎么好,因为工作上用不到,自己也没怎么学习,所

Java面向对象三大特性 封装 继承 多态

1.封装 封装的定义: 首先是抽象,把事物抽象成一个类,其次才是封装,将事物拥有的属性和动作隐藏起来,只保留特定的方法与外界联系 为什么需要封装: 封装符合面向对象设计原则的第一条:单一性原则,一个类把自己该做的事情封装起来,而不是暴露给其他类去处理,当内部的逻辑发生变化时,外部调用不用因此而修改,他们只调用开放的接口,而不用去关心内部的实现 举例: public class Human { private int age; private String name; public int get

面向对象的三大特性---封装继承多态

面向对象的三大特性---封装继承多态 首先我们来创建一个控制台程序 新建一个父类Person 创建一个子类继承父类Person 子类: main函数: 输出结果: 根据结果显示创建子对象,首先调用父类的构造函数在调用子类的构造函数. 继承的传递性 例如: A:B,B:C,则A:C ⅰ.继承过来之后被隐藏,有意隐藏加一个关键字"new",如果加了关键字"new",就告诉子类,父类里面的sayHi只能被隐藏,不能被覆写  ⅱ.继承过来之后被覆写/重写,覆写需要在父类里面

面向对象三大特性(封装/继承/多态)

引入:在面向对象思想中,有三大特性,封装  继承  多态. 思考:我们在使用类和对象实现编程的时候,到底是遵循这什么样的逻辑呢?为什么要这样规范类呢? 引入:面向对象很重要的思想就是隐藏,即外部不知道类内部是如何实现业务逻辑的,只管调用和使用结果,这个就是面向对象三大特性之一:  封装 1.封装[掌握] 定义:封装,字面意思就是将内容装到某个容器中,并进行密封保存,在面向对象思想中,封装指数据和对数据的操作捆绑到一起,形成 对外界的隐藏,同时对外提供可以操作的接口. 1.数据:即要操作的数据,在

JAVA的三大特征 封装继承多态- 简单总结

简单总结一下 封装-即从很多类的抽取相同的代码 写在一个类里. 好处是 代码的重用,安全. 继承-减少代码的书写. 其好处也是 代码的重用. 多态- 把不同的子类对象都当作父类来看,可以屏蔽不同子类对象之间的差异,写出通用的代码,做出通用的编程,以适应需求的不断变化. 总的来说还是接口的重用. 那么总结一下,JAVA的三大特征 其好处 就是代码与接口的重用. 封装可以隐藏实现细节,使得代码模块化: 继承可以扩展已存在的代码模块(类): 它们的目的都是为了——代码重用. 而多态则是为了实现另一个目

面向对象三大特性:封装,继承,多态(一,封装和继承)

封装.继承和多态是面向对象程序设计的三个核心特性. 封装是面向对象技术中的一个重要概念,是一种信息隐藏技术,它体现了面向对象程序设计的思想. 继承是面向对象程序设计方法的一个重要手段,通过继承可以更有效地组织程序结构,明确类间的关系,育雏利用已有的类来完成更复杂.更深入的程序开发. 多态允许以一种统一的风格处理已存在的变量和相关的类,多态性使得向系统增加功能变的容易. 一.封装 封装的含义是:类的设计者把类设计成一个黑匣子,使用者只能看见类中定义的公共变量和公共方法,而看不见方法的具体实现细节,

面向对象三大特性:封装,继承,多态(二、多态)

多态 一,多态的概念 多态(polymorphism), 是指一个名字可以有多种语义.在面向对象语言中,多态是指在一棵继承树中的类中可以有多个同名但不同方法体及不同形参的方法.通常有两种途径实现多态:方法的重载和覆盖. 多态性允许以统一的风格处理已存在的变量及相关的类.多态性使得向系统里增加新功能变得容易.继承性和多态性是降低软件复杂性有有效技术. 二,多态的实现 1.方法的重载 方法重载时: 参数必须不同.参数个数不同或类型不同. 返回值可以相同,也可以不同. 重载的价值在于它允许通过使用一个

面向对象三大特性:封装,继承,多态(三、多态的进一步讲解)

多态(polymoph)指的是“执行期间(而非编译期间)”判断所引用对象的实际类型.,根据其实际的类型调用其相应的方法. 多态也叫动态绑定,也叫迟绑定. 多态的存在有三个必要条件: 要有继承 要有重写 父类引用指向子类对象

【转】java提高篇(二)-----理解java的三大特性之继承

[转]java提高篇(二)-----理解java的三大特性之继承 原文地址:http://www.cnblogs.com/chenssy/p/3354884.html 在<Think in java>中有这样一句话:复用代码是Java众多引人注目的功能之一.但要想成为极具革命性的语言,仅仅能够复制代码并对加以改变是不够的,它还必须能够做更多的事情.在这句话中最引人注目的是"复用代码",尽可能的复用代码使我们程序员一直在追求的,现在我来介绍一种复用代码的方式,也是java三大

类与对象 面向对象和面向过程对比 面向对象三大特征:封装 继承 多态

 初识面向对象 面向过程: 一切以事务的发展流程为中心. 面向对象: 一切以对象为中心. 一切皆为对象. 具体的某一个事务就是对象 打比方: 大象进冰箱 步骤: 第一步, 开门, 第二步, 装大象, 第三步, 关门 面向对象:大象, 你进冰箱. 此时主语是大象. 我操纵的是大象. 此时的大象就是对象 1. 面向过程: 一切以事物的流程为核心. 核心是"过程"二字, 过程是指解决问题的步骤, 即, 先?干什么, 后干什么. 基于该思想编写程序就好比在编写一套流水线. 是一种机械 式的编程