黑马程序员技术交流社区

标题: 【阳哥笔记】极速秒杀Java基础之笔记系列—Day07(面向对象)！ [打印本页]
作者: 阳哥忠粉    时间: 2015-6-4 18:37
标题: 【阳哥笔记】极速秒杀Java基础之笔记系列—Day07(面向对象)！




笔记总链接：http://bbs.itheima.com/thread-200600-1-1.html

3、面向对象

3.4 构造函数

    特点：
    1、函数名与类名相同。
    2、不用定义返回值类型。
    3、没有具体的返回值。
   
    P.S.   
    在构造函数前面加上返回值就只是一般函数了。

    作用：给对象进行初始化。

    示例：
  1. class Person{
  2.        private String name ;
  3.        private int age ;

  5.        //定义一个Person类的构造函数
  6.        //构造函数，而且是空参数的
  7.       Person(){
  8.             System.out.println("person run");
  9.       }

  11.        public void speak(){
  12.             System.out.println(name + ":" + age);
  13.       }
  14. }

  16. class ConsDemo{
  17.        public static void main(String[] args){
  18.              //构造函数：构建创造对象时调用的函数
  19.              //作用：可以给对象进行初始化
  20.             Person p = new Person();
  21.             p.speak();
  22.       }
  23. }
复制代码
   运行结果：


    P.S.
    1、一般函数和构造函数什么区别呢？
    构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
    一般函数：对象创建后，需要函数功能时才调用。

    构造函数：对象创建时，会调用并且只调用一次。
    一般函数：对象创建后，可以被调用多次。

    2、创建对象都必须要通过构造函数初始化。
    一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。
    如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

    3、多个构造函数是以重载的形式存在的。

    示例：
  1. class Person{
  2.           private String name ;
  3.           private int age ;
  4.       
  5.           Person(){
  6.                    name = "baby" ;
  7.                    age = 1;
  8.                    System.out.println("person run");
  9.           }

  11.           //如果有的孩子一出生就有名字
  12.           Person(String n){
  13.                  name = n;
  14.           }
  15.             
  16.            //如果有的孩子一出生就有名字和年龄
  17.           Person(String n, int a){
  18.                  name = n;
  19.                  age = a;
  20.           }
  21.             
  22.           public void speak(){
  23.               System.out.println(name + ":" + age);
  24.           }
  25. }

  27. class ConsDemo{
  28.        public static void main(String[] args){
  29.             Person p1 = new Person();
  30.             p1.speak();
  31.             Person p2 = new Person("旺财" );
  32.             p2.speak();
  33.             Person p3 = new Person("小强" ,10);
  34.             p3.speak();
  35.       }
  36. }
复制代码
   运行结果：


3.5 this关键字

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

    什么时候使用this关键字呢？
    当在函数内需要用到调用该函数的对象时，就用this。

    示例：
  1. class Person{
  2.           private String name ;
  3.           private int age ;

  5.           Person(String name){
  6.              //通过this区分成员变量和局部变量
  7.              this.name = name;
  8.           }
  9.          
  10.           Person(String name, int age){
  11.              //this也可以用于在构造函数中调用其他构造函数
  12.              this(name);
  13.              this.age = age;
  14.           }
  15.             
  16.           public void speak(){
  17.              System.out.println(name + ":" + age);
  18.           }
  19. }

  21. class ConsDemo{
  22.        public static void main(String[] args){
  23.             Person p1 = new Person("旺财" );
  24.             p1.speak();
  25.             Person p2 = new Person("小强" ,10);
  26.             p2.speak();
  27.       }
  28. }
复制代码
   运行结果：


    P.S.
    通过this在构造函数中调用其他构造函数的时候，只能定义在构造函数的第一行，因为初始化动作要先执行，否则就会报错。

    示例：
  1. class Person{
  2.           private String name ;
  3.           private int age ;
  4.          
  5.           Person(String name, int age){
  6.              this.name = name;
  7.              this.age = age;
  8.           }

  10.           /*
  11.           判断是否是同龄人
  12.           */
  13.           public boolean compare(Person p){
  14.                 return this.age == p.age;
  15.           }
  16. }

  18. class ConsDemo{
  19.        public static void main(String[] args){
  20.             Person p1 = new Person("旺财" ,10);
  21.             Person p2 = new Person("小强" ,10);
  22.             System.out.println(p1.compare(p2));
  23.       }
  24. }
复制代码
   运行结果：


3.6 static关键字

    static关键字：用于修饰成员（成员变量和成员函数）。

    被修饰后的成员具备以下特点：
    1、随着类的加载而加载。
    2、优先于对象存在。
    3、被所有对象所共享。
    4、可以直接被类名调用。

    示例：
  1. class Person{
  2.         //成员变量，实例变量
  3.        String name;
  4.        //静态变量，类变量
  5.        //所有对象共享的属性用static修饰
  6.        static String country = "CN";
  7.        public void show(){
  8.             System.out.println(country + ":" + name);
  9.              //等效语句：System.out.println(Person.country + ":" + this.name);
  10.       }
  11. }

  13. class StaticDemo{
  14.        public static void main(String[] args){
  15.             Person p = new Person();
  16.             System.out.println(p.country);
  17.              //可以用类名直接调用
  18.             System.out.println(Person.country);
  19.       }
  20. }
复制代码
   运行结果：

    成员变量和静态变量的区别？
    1. 两个变量的生命周期不同
        成员变量随着对象的创建而存在，随着对象被回收而释放。
        静态变量随着类的加载而存在，随着类的消失而消失。
    2. 调用方式不同
        成员变量只能被对象调用。
        静态变量可以被对象调用，还可以被类名调用。
    3. 别名不同
       成员变量也称为实例变量。
       静态变量也称为类变量。
    4. 数据存储位置不同
       成员变量存储在堆内存的对象中，所以也叫对象的特有数据。
       静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

    使用注意：
    1. 静态方法只能访问静态成员，如果访问非静态成员，就会报错！
        原因：静态方法和变量存在的时候，对象还不存在，非静态变量也不存在，肯定无法访问。

    示例：
  1. class Person{
  2.        String name;
  3.        static String country = "CN";
  4.        //静态方法
  5.        public static void show(){
  6.             System.out.println(country + ":" + name);
  7.       }
  8. }
复制代码
   运行结果：


    P.S.
    非静态方法既可以访问静态成员，又可以访问非静态成员。

    2、静态方法中不可以写this，super关键字。
         原因：静态方法存在的时候，对象还不存在，this代表的就是调用方法的那个对象，既然不存在，肯定不可以写在静态方法中。

    3、主函数是静态的，主函数特殊之处：
         1. 格式是固定的。
         2. 被jvm所识别和调用。

         主函数各成分解析：
         public：权限必须是最大的，被jvm调用。
         static：不需要对象调用，直接用主函数所属类名调用即可。 命令行窗口中输入：java StaticDemo，实际上就是在执行StaticDemo.main();。
         void：主函数不需要具体的返回值。
         main：函数名，不是关键字，只是一个jvm识别的固定的名字。
         String[] args：这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。

    示例：
  1. class MainDemo{
  2.        public static void main(String[] args){
  3.              for(int x = 0; x < args.length; x++){
  4.                   System.out.println(args[x]);
  5.             }
  6.       }
  7. }
复制代码
    运行结果：


    静态什么时候用？
    1. 静态变量
       当分析对象中所具备的成员变量的值都是相同时，这时这个成员就可以被静态修饰。
       只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。
       如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。

    2. 静态函数
       函数是否用静态修饰，就参考一点，就是该函数功能是否需要访问到对象中的特有数据。
       简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。
       如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，但是非静态需要被对象调用。
       如果没有访问特有数据的方法，该对象的创建是没有意义。

    示例：
  1. class Demo{
  2.        int age ;
  3.        static int num = 9;

  5.        public static void speak(){
  6.             System.out.println(num);
  7.       }

  9.        public void show(){
  10.             System.out.println(age);
  11.       }
  12. }

  14. class StaticDemo{
  15.        public static void main(String[] args){
  16.             Demo.speak();
  17.             new Demo().show();
  18.       }
  19. }
复制代码
    运行结果：

    静态代码块
    随着类的加载而执行，而且只执行一次。
    作用：用于给类进行初始化。  

    示例：
  1. class StaticCode{
  2.        static int num;
  3.        static{
  4.              num = 10;
  5.       }
  6.        static void show(){
  7.             System.out.println(num);
  8.       }
  9. }

  11. class StaticCodeDemo{
  12.        public static void main(String[] args){
  13.             StaticCode.show();
  14.       }
  15. }
复制代码
    运行结果：


    构造代码块
    作用：可以给所有对象进行初始化。

    示例：
  1. class Person{
  2.        private String name ;
  3.       
  4.        //构造代码块，可以给所有对象进行初始化的
  5.       {
  6.             System.out.println("person run");
  7.       }

  9.        //是给对应的对象进行针对性的初始化
  10.       Person(){
  11.              name = "baby" ;
  12.       }

  14.       Person(String name){
  15.              this.name = name;
  16.       }

  18.        public void speak(){
  19.             System.out.println("name:" + name);
  20.       }
  21. }

  23. class StaticCodeDemo{
  24.        public static void main(String[] args){
  25.             Person p1 = new Person();
  26.             p1.speak();
  27.             Person p2 = new Person("旺财");
  28.             p2.speak();
  29.       }
  30. }
复制代码
   运行结果：


~END~



~爱上海，爱黑马~




作者: java梦想    时间: 2015-6-4 19:03
前排第一个？
作者: 时光匆匆    时间: 2015-6-4 19:30
又来顶帖子了！赞一个
作者: 307323665    时间: 2015-6-4 22:38
各种详细
作者: wx_d9b6mRbI    时间: 2015-6-5 08:23
正好用得到
作者: tougboy    时间: 2015-6-5 09:42
谢谢阳哥
作者: wangiuh    时间: 2015-6-5 10:49
面向对象也是类与类之间的沟通 类就是对象 简单的理解
作者: 乌卡卡    时间: 2015-6-5 15:48
静态变量不是很好理解
作者: 熊乾坤    时间: 2015-6-5 19:00
顶一下！
作者: li520    时间: 2015-6-6 00:03
谢谢咯咯
作者: 灵界    时间: 2015-6-6 00:04
阳哥好神速
作者: javazhang    时间: 2015-6-6 15:05
示例中，static关键字中有一个person类中没有主方法main
作者: 李俊超    时间: 2015-6-7 02:27
面向对象，封装，继承，多态。我们要始终围绕着面向对象的特性，减少重复代码的编码。发扬封装和继承思想：对功能扩展开放，对源码修改关闭原则。通过继承父类和实现接口完善功能。
作者: 李俊超    时间: 2015-6-7 02:31
容易混淆的几个点：
构造方法：无参构造方法，有参构造方法 ：与类名相同，参数可以为空参，也可以传入基本数据类型和引用类型（类、数组、接口）；静态方法和方法区：有时候傻傻分不清楚：？？？


作者: gghost2012    时间: 2015-6-7 08:12
给力，赞一下
作者: 海角秋风    时间: 2015-6-7 09:16
太详细了。。。好好保留下来。。。
作者: 小囧    时间: 2015-6-8 21:04
巩固巩固
作者: moheng116    时间: 2015-6-9 23:25
看看阳哥的总结
作者: 黑马蛋蛋    时间: 2015-6-10 00:54
很赞的笔记
作者: duzhi409    时间: 2015-6-10 23:54
总结的挺详细的，顶阳哥
作者: 爱java爱生活    时间: 2015-6-11 00:42
给力啊期待再次的更新；
作者: 魏海洲    时间: 2015-6-11 19:06

很赞的笔记
作者: 魏海洲    时间: 2015-6-11 19:07

示例中，static关键字中有一个person类中没有主方法main
作者: Jackie7    时间: 2015-6-13 22:24
mark了，明儿休息，好好看看。
作者: MQ_H    时间: 2015-6-14 12:48
总结的很好，能省不少时间。
作者: 柒仴、看雲佉    时间: 2015-6-14 18:38
复习一下下
作者: Jackie7    时间: 2015-6-14 22:43
今天懒，没预习，赶紧看下这章的笔记、、、不过貌似有点难啊。
作者: wxRocky    时间: 2015-6-15 10:02
C++没学好，没记住。
作者: weiwei1    时间: 2015-6-15 12:24
对于我这样新来的帮助很大
作者: 天涯111    时间: 2015-6-15 13:55
跟着阳哥的笔记走，感觉学起来容易多了。！！！
作者: RockLee    时间: 2015-6-15 20:49
面向对象也是类与类之间的沟通 类就是对象 简单的理解
作者: Jackie7    时间: 2015-6-15 22:09
听了一天课下来，反倒是脑袋发胀，越来越糊涂了。。。。今儿晚上不睡觉的节奏。。
作者: Jackie7    时间: 2015-6-16 21:45
Jackie7 发表于 2015-6-15 22:09
听了一天课下来，反倒是脑袋发胀，越来越糊涂了。。。。今儿晚上不睡觉的节奏。。 ...

感觉懂了，但是有同学来问问题的时候，还真就说不上来，特别是那个构造函数内存图，有点解释不清，我还得看看。唉，压力老大了，今儿还学了继承，还有个 给父类初始化的内存图，也没太懂，就只知道结论是初始化的时候，其实是初始化的子类中对象的super()那部分。看刘意老师讲的时候，听了一半就听不懂了。。。今儿做作业，练习写继承的代码的时候，还是有些犹豫，还得练啊！
作者: wxRocky    时间: 2015-6-24 09:12
只要刻苦奋斗，总能学会。
作者: 陈化身1    时间: 2015-6-24 10:27
太详细了，赞一个
作者: zhjunwenyy    时间: 2015-6-24 12:55
很给力啊
作者: 繁星中的白矮星    时间: 2015-6-24 15:53
赞一个！
作者: kime    时间: 2015-6-24 15:55
辛苦了，非常给力
作者: 魏海洲    时间: 2015-6-24 22:11
正好用得到
作者: a1224577182    时间: 2015-6-24 22:15
感谢分享！
作者: 疾风追马    时间: 2015-6-25 00:36
今天看到这里截止。
作者: 进军黑马    时间: 2015-6-25 19:02
特牛，，，我喜欢
作者: wenxueaaa555    时间: 2015-6-25 19:22
厉害，总结的很全面，一看就了解了
作者: a7228274    时间: 2015-6-26 16:47

又来顶帖子了！赞一个
作者: e275919713    时间: 2015-6-26 21:40

面向对象，封装，继承，多态。我们要始终围绕着面向对象的特性，减少重复代码的编码。发扬封装和继承思想：对功能扩展开放，对源码修改关闭原则。通过继承父类和实现接口完善功能。
作者: 呵呵君    时间: 2015-6-26 21:54
老师说 整个基础班其实就是在围绕着面向对象讲,先收下了.嘿嘿
作者: 侯月超    时间: 2015-6-26 23:17
总结的挺详细的，顶阳哥
作者: 孙培广    时间: 2015-6-27 00:10
我们明天也学面向对象了，写的很好，就是看不懂，呵呵
作者: 风随心动    时间: 2015-7-1 18:43
顶一个！！
作者: e275919713    时间: 2015-7-1 21:22
阳哥好神速
作者: Enhon1992    时间: 2015-7-2 09:00
学学习学习！！！
作者: 路遥知马力    时间: 2015-7-8 22:59
刚学到这里，笔记很好！
作者: 小绿    时间: 2015-7-8 23:03
给力 赞一个
作者: softzhang    时间: 2015-7-10 21:01
很直观。适合复习。
作者: 逍遥最好    时间: 2015-7-10 21:09
过来顶帖，非常好的笔记！
作者: xyxlx111    时间: 2015-7-10 21:36
非常好，顶一个
作者: wx_HWRW5aF7    时间: 2015-7-10 21:42
来赞一个
作者: 人造番茄    时间: 2015-7-10 22:05
感谢阳哥，真的是很有用的笔记
作者: 星痕-凌    时间: 2015-7-11 22:45
又来顶帖子了！赞一个!！！！！！！！！！！！！！！！！！！！！！！！！！
作者: 奇峰    时间: 2015-7-23 21:12
赞一个
作者: 王勋亮    时间: 2015-7-23 21:13
压力山大
作者: heavenzizou    时间: 2015-7-23 21:33
楼主大才
作者: 陈建民1    时间: 2015-7-23 21:33
多看看，就当课后复习了
作者: 王勋亮    时间: 2015-7-24 09:41
很不错的笔记！
作者: maqijian    时间: 2015-7-24 12:03
感谢分享！！！
作者: syzc321    时间: 2015-7-24 12:34
谢谢大神！ 非常有用的笔记，以后经常看！
作者: syzc321    时间: 2015-7-24 12:35
谢谢大神！ 非常有用的笔记，以后经常看！
作者: 王勋亮    时间: 2015-7-24 13:38
构造函数总结的好！
作者: yongaidongbing    时间: 2015-7-25 00:12
。。。。。。。。。。。。。。。
作者: wy8215866    时间: 2015-7-25 00:46
！！！！！！！！！！！！！！！！！！！！！！
作者: DreamStart    时间: 2015-7-28 09:05
好给力哦,不过static静态代码块那个例子我不懂,可否给解释下
作者: wyd1    时间: 2015-8-20 23:36
这么给力啊
作者: wangboxiao12345    时间: 2015-8-20 23:51
这个很好啊
作者: 放心飞    时间: 2015-8-26 15:34
继续学习中，加油。
作者: 放心飞    时间: 2015-8-26 15:40
学习的感觉真的很好呵呵
作者: 舒旺    时间: 2015-8-26 18:16
32个赞  很不错  
作者: qq56414019    时间: 2015-8-26 18:43
赞一个，很有帮助哦，  支持阳哥
作者: a513200780    时间: 2015-8-28 19:23
这是那个视频的笔记，貌似不是毕老师25天的
作者: 放心飞    时间: 2015-9-6 14:01
又看完一节了，继续加油，
作者: JY.    时间: 2015-9-29 07:58
顶一个！！！！！！！！！！！！！！！！~~~~~~~~~~~~~~
作者: lnsin    时间: 2015-10-27 23:51
谢谢分享
作者: 邵新红    时间: 2015-12-18 06:34
这个帖子真好！
作者: 罗宁    时间: 2015-12-18 21:10
阳哥就是阳哥给力
作者: lixy    时间: 2015-12-29 11:40
我想问一下，阳哥姓李吗？
作者: lixy    时间: 2015-12-29 15:30
再来顶一下
作者: 追忆睡梦已醒    时间: 2016-3-15 08:28
多余一个文科生来说，真的是颠覆式的，很好
作者: liu631980435    时间: 2016-3-15 08:54
样个威武爱上哈佛按收费好



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2