A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© fmi110 高级黑马   /  2015-8-17 21:31  /  240 人查看  /  1 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

a
  1. 1、面向对象特征:        1        封装(encapsulation)
  2.                                         2        继承(inheritance)
  3.                                         3        多态(polymorphism)

  4. 2、成员变量和局部变量的区别:
  5.         1 成员变量:
  6.                 a 成员变量定义在类中,在整个类中都可以被访问
  7.                 b 成员变量随着对象的建立而建立,随着对象的消失而消失,存在于对象
  8.         所在的堆内存中。
  9.                 c 成员变量有默认的初始值

  10.         2 局部变量:
  11.                 a 局部变量定义在局部范围内,如函数,语句内等,只在所属的区域内有效
  12.                 b 局部变量存储在栈内存中,作用范围结束,变量空间就会释放
  13.                 c 局部变量没有默认初始化值。未初始化不能使用。(编译报错)

  14. 3、匿名对象
  15.         匿名对象是对象的简化形式。
  16.         匿名对象的使用情况
  17.                 1 当对对象方法进进行一次调用时
  18.                 2 匿名对象作为实际参数进行传递
  19.                 ————————————————————————————————————————————————————
  20.                 class Car
  21.                 {
  22.                         public void run(){
  23.                                 System.out.println("This is a Anonymous        class demo.");
  24.                         }
  25.                 }
  26.                 class CarDemo
  27.                 {
  28.                         public static void main(String[] args){
  29.                                 new Car().run();//建立一个匿名对象,调用对象方法
  30.                                 show(new Car());//新建一个匿名对象作为函数参数
  31.                         }
  32.                         public static void show(Car car){
  33.                                 car.run();
  34.                         }
  35.                 }
  36.                 ————————————————————————————————————————————————————
  37. 4、基本数据类型参数及引用数据类型参数传递
  38.         1 基本数据类型参数传递(传值):
  39.                 class Demo
  40.                 {
  41.                         public static void main(String[] args){
  42.                                 int x = 3;
  43.                                 show(x);
  44.                                 System.out.println("x = "+x);
  45.                         }
  46.                         public static void show(int x){
  47.                                 x = 4;
  48.                         }
  49.                 }

  50.                 输出结果:x = 3;

  51.                 过程分析:
  52.                         1 JVM调用main方法,main方法入栈
  53.                         2 将x变量设置为3
  54.                         3 main方法调用show,并将3作为基本数据类型传递给show方法的参数x,
  55.                 即参数x的值是3
  56.                         4 show方法执行x=4后,show方法的参数x值变为4
  57.                         5 show方法执行结束,show方法出栈。 show方法参数x也随之出栈
  58.                         6  main方法打印x的值。 此时x指的是main方法中的x变量的值(show方法中的参数x已经随show方法一块
  59.                 出栈了)。 所以,打印出来的x值为3而不是4。
  60.                         7 main方法执行结束,出栈。

  61.         2 引用数据类型参数传递(传址):
  62.                 class Demo
  63.                 {
  64.                         int x = 3;
  65.                         public static void main(String[] args){
  66.                                 Demo d = new Demo();
  67.                                 d.x = 9;
  68.                                 show(d);
  69.                                 System.out.println(d.x);
  70.                         }
  71.                         public static void show(Demo d){
  72.                                 d.x = 4;
  73.                         }
  74.                 }
  75.                 输出结果: 4

  76.                 过程分析:
  77.                         1 jvm调用main方法,main方法入栈。
  78.                         2 在堆内存中创建一个类Demo的对象,在栈中建立变量d,并将d指向堆中
  79.                 新建的对象,然后将此对象的x设为9
  80.                         3  main方法调用show方法,d作为引用数据类型参数赋值给show方法参数d,也就是说,此时show方法的
  81.                 参数d和main方法中的变量d同时指向了堆内存中同一个实体对象
  82.                         4 show方法执行d.x=4后,堆内存中的实体对象的x属性值变为4
  83.                         5 show方法执行结束,show方法出栈,show方法参数d也随之出栈。 虽然show方法参数d出栈了,但是,
  84.                 由于main方法的变量d依然引用着堆内存中的实体对象,因此堆内存中的实体对象不会被垃圾回收器清除。
  85.                         6 main方法打印d.x的值。 此时,d指的是main方法中的引用变量x,d.x指的依然是堆内存中的实体对象中x
  86.                 的值。 所以,打印出来的值为4而不是9。
  87.                         7 main方法执行结束,出栈

  88.         总结:在java中,方法参数的传递永远都是传值,而这个值,对于基本数据类型,值就是你赋给变量的那个值。
  89. 而对于引用数据类型,这个值是对象的引用(对象的地址),而不是这个对象本身。

  90. 5、封装:指隐藏对象的属性和实现细节,进对外提供公共的访问方式

  91.                 好处:
  92.                         1 将变化隔离
  93.                         2 便于使用
  94.                         3 提高了重用性
  95.                         4 提高了安全性

  96.                 封装的原则:
  97.                         1 将不需要对外提供的内容全部隐藏起来
  98.                         2 把属性隐藏,提供公共的方法对其访问。如getXxx,setXxx

  99.                 PS:
  100.                         1 私有是封装的一种体现
  101.                         2 private 关键字:是一个权限修饰符,用于修饰成员(变量和方法),被私有化的成员
  102.                 只在本类中有效
  103.                         3 常用场景之一:将成员变量私有化,对外提供对应的set、 get方法对其进行访问,提高对数据访问的安全
  104.                 性。
复制代码


1 个回复

倒序浏览
总结的很全面哦,可以用来当复习资料
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马