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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© fmi110 高级黑马   /  2015-8-18 12:00  /  180 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

sd
  1. 7、 this 关键字
  2.                 this代表其所在函数所属对象的引用。 换言之,this代本类对象的引用。
  3.         当成员变量和局部变量重名,可以用关键字this来区分,this就是所在函数所属对象的引用。
  4.         简单说,哪个对象调用了this所在的函数,this就代表哪个对象。 一般方法调用默认加this。

  5.                 PS:通过 this在构造函数中调用其他构造函数的时候,只能定义在构造函数的第一行,因为初始化动作
  6.         要先进行,否则会报错。

  7.                         class Person {
  8.                                 private String name;
  9.                                 private int age;
  10.                                 Person(){};//无参数构造函数

  11.                                 //一创建就有名字
  12.                                 Person(String name){
  13.                                         this.name = name;
  14.                                 }
  15.                                 Person(String name,int age){//一创建就有名字和年龄
  16.                                         this.age = age;
  17.                                         this(name);//错误。this调用构造器应该放在第一行
  18.                                 }
  19.                                 public void speak(){
  20.                                         System.out.println("name = "+name+"...age = "+age);
  21.                                 }
  22.                         }

  23.                         编译结果:Constructor call must be the first statement in a constructor

  24. 8、 static 关键字:用于修饰成员(成员变量和成员函数)
  25.                 1 被修饰后的成员有如下特点:
  26.                         1 随着类的加载而加载
  27.                         2 优先于对象存在
  28.                         3 被所有同类的对象共享
  29.                         4 可以直接被类名调用
  30.                        

  31.                         class Person {
  32.                                 private String name;
  33.                                 private int age;
  34.                                 private static String country = "CN";
  35.                                 Person(){};//无参数构造函数

  36.                                 //一创建就有名字
  37.                                 Person(String name){
  38.                                         this.name = name;
  39.                                 }
  40.                                 Person(String name,int age){//一创建就有名字和年龄
  41.                                         this(name);
  42.                                         this.age = age;
  43.                                 }
  44.                                 public void speak(){
  45.                                         System.out.println("name = "+name+"...age = "+age+"...country = "+country);
  46.                                 }
  47.                         }
  48.                         class PersonDemo
  49.                         {
  50.                                 public static void main(String[] args){
  51.                                         Person p1 = new Person();
  52.                                         p1.speak();
  53.                                         Person p2 = new Person("HanMeimei",12);
  54.                                         p2.speak();
  55.                                         Person p3 = new Person("Lucy");//多个构造函数通过重载方式实现不同的初始化
  56.                                         p3.speak();
  57.                                 }
  58.                         }
  59.                         输出结果:
  60.                                                 name = null...age = 0...country = CN
  61.                                                 name = HanMeimei...age = 12...country = CN
  62.                                                 name = Lucy...age = 0...country = CN
  63.                         可以看到 static 变量 country 被所有的对象所共享

  64.                 2 成员变量和静态变量的区别?

  65.                         1. 两个变量的生命周期不同
  66.                                 成员变量随着对象的创建而存在,随着对象被回收而释放。
  67.                                 静态变量随着类的加载而存在,随着类的消失而消失。
  68.        
  69.                         2. 调用方式不同
  70.                                 成员变量只能被对象调用。
  71.                                 静态变量可以被对象调用,还可以被类名调用。
  72.                
  73.                         3. 别名不同
  74.                                 成员变量也称为实例变量。
  75.                                 静态变量也称为类变量。
  76.                
  77.                         4. 数据存储位置不同
  78.                                 成员变量存储在堆内存的对象中,所以也叫对象的特有数据。
  79.                                 静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据。

  80.                 3 注意事项:
  81.                         1 静态方法只能访问静态成员,如果访问非静态成员会报错。但是非静态方法既可以访问静态成员,
  82.                         也可以访问非静态成员。

  83.                                 因为静态方法和变量存在的时候,对象还不存在,非静态变量也不存在,肯定无法访问

  84.                         2 静态方法中不可以写 this,super关键字
  85.                                 原因:静态方法存在的时候,对象还不存在, this所代表的对象也不存在,肯定不能写在静态方法中

  86.                         3 主函数 main 是静态的,书写格式固定,被jvm识别和调用。

  87.                 4 静态什么时候用?
  88.                         1. 静态变量
  89.                                 当分析对象中所具备的成员变量的值都是相同时,这时这个成员就可以被静态修饰。
  90.                         只要数据在对象中都是不同的,就是对象的特有数据,必须存储在对象中,是非静态的。
  91.                         如果是相同的数据,对象不需要做修改,只需要使用即可,不需要存储在对象中,定义成静态的。
  92.                        
  93.                         2. 静态函数
  94.                                 函数是否用静态修饰,就参考一点,就是该函数功能是否需要访问到对象中的特有数据。
  95.                         简单点说,从源代码看,该功能是否需要访问非静态的成员变量,如果需要,该功能就是非静态的。
  96.                         如果不需要,就可以将该功能定义成静态的。 当然,也可以定义成非静态,但是非静态需要被对象调用。
  97.                         如果没有访问特有数据的方法,该对象的创建是没有意义。

  98.                 5 静态代码块

  99.                         随着类的加载而执行,且只执行一次。
  100.                         作用:用于给类进行初始化

  101.                  构造代码块
  102.                        
  103.                         作用:可以给所有对象进行初始化
  104.                        
  105.                                 class Person {
  106.                                         private String name;
  107.                                         private static int age;
  108.                                         private static String country ;
  109.                                         Person(String name,int age){//一创建就有名字和年龄
  110.                                                 this.name =name;
  111.                                         }
  112.                                         //age = 10;//错误,初始化应该在在代码块中或者定义时进行
  113.                                        
  114.                                         //静态代码块,用于类初始化
  115.                                         //静态代码块用于初始化类,所以非静态成员不能出出现在静态代码块
  116.                                         static{
  117.                                                 age = 10;
  118.                                         }
  119.                                         //构造代码块,可用于所有对象进行初始化
  120.                                         {
  121.                                                 age = 10;
  122.                                                 name = "haha";
  123.                                         }
  124.                                         public void speak(){
  125.                                                 System.out.println("name = "+name+"...age = "+age+"...country = "+country);
  126.                                         }
  127.                                 }
复制代码


0 个回复

您需要登录后才可以回帖 登录 | 加入黑马