黑马程序员技术交流社区

标题: 面向对象小结 [打印本页]

---

作者: wangzhiyong515    时间: 2014-5-12 16:03
标题: 面向对象小结
面向对象:
            是相对于面向过程而言的一种编程思想。是基于面向过程的。

面向过程：以过程为主。
面向对象：以结果为主，找对象做事情。

面向对象的思想特点：
             A:是一种更符合人们思考习惯的思想。
             B:把复杂的给简单化。
            C:让我们的角色发生了改变。

        举例：
                吃饭：
                        面向过程：自己先去买菜买米，回家洗菜洗米，还得做...，最后吃。
                        面向对象：去饭店。找个对象(女朋友)。

2:怎么样才算面向对象?
        请按照我下面的几个步骤：
                A:分析有哪些类。
                B:分析类应该有什么。
                C:分析类与类之间的关系。

        举例：
                把大象装进冰箱。

面向过程：
                A:开冰箱门
                B:把大象装进去
                C:关冰箱门

                代码体现：
                class Test {
                        public static void main(String[] args){
                                /*
                                System.out.println("开冰箱门");
                                System.out.println("把大象装进去");
                                System.out.println("把大象装进去");
                                System.out.println("把大象装进去");
                                System.out.println("关冰箱门");
                                */

                                //在面向过程中，有些动作要重复执行，定义方法
                                open();
                                in();
                                in();
                                in();
                                close();
                        }
                       
                        public static void open() {
                                System.out.println("开冰箱门");
                        }

                        public static void in() {
                                System.out.println("把大象装进去");
                        }

                        public static void close(){
                                System.out.println("关冰箱门");
                        }
                }

面向对象：(UML 统一建模语言+设计模式 设计师)
                A:分析有哪些类。
                        大象类
                        冰箱类
                        测试类
                B:分析类应该有什么。
                        大象类
                                把大象装进去
                        冰箱类
                                开冰箱门
                                关冰箱门
                        测试类
                                main方法
                C:分析类与类之间的关系。
                        在测试类中，创建大象和冰箱对象，并调用其功能。

                代码体现：
                        class 大象 {
                                public void in() {
                                        System.out.println("把大象装进去");
                                }
                        }

                        class 冰箱 {
                                public void open() {
                                        System.out.println("开冰箱门");
                                }

                                public void close(){
                                        System.out.println("关冰箱门");
                                }
                        }

                        class Test {
                                public static void main(String[] args) {
                                        冰箱 b = new 冰箱();
                                        大象 d = new 大象();

                                        b.open();
                                        d.in();
                                        b.close();
                                }
                        }

3:类与对象
        Java语言是为了描述现实世界事物的。

        现实世界事物又是怎么体现的:
                属性：外在特征
                行为：具备的功能

        把现实世界的事物通过Java语言来体现，而Java语言中最基本的单位是：类。
        所以，每一个显示世界的具体事物其实对应的是一个类。

        现实世界事物                类
                属性                成员变量
                行为                成员方法

        类：类是很多对象的抽象表现形式。
        对象：对象是类的具体表现形式。
                学生：类
                张三：对象
                班长：对象

4:类的组成：
        A:成员变量
                成员变量和局部变量的区别?
                        a:类中位置区别
                                成员变量：类中，方法外。
                                局部变量：类中，方法声明上，或者方法体中。
                        b:内存位置区别
                                成员变量：堆内存。
                                局部变量：栈内存。
                        c:生命周期区别
                                成员变量：随着对象的创建而存在，随着对象的消失而消失。
                                局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。
                        d:初始化值区别
                                成员变量：都有默认初始化值。
                                局部变量：没有默认初始化值。先定义，再赋值，最后使用。

        B:构造方法
                a:构造方法特点
                        方法名和类名相同。
                        没有返回值类型。
                        没有返回值。
                b:构造方法注意实现
                        如果没给，系统给一个无参构造方法。
                        如果给了，系统将不给。这个时候要么不用无参构造方法，要么自己给一个无参构造方法。
                                推荐：无参给出。
                特殊事项：
                        构造方法中可不可以出现return语句?
                        可以。return;
        C:成员方法
                和前面的函数一样，只不过一般不建议加static。

5:private关键字和this关键字:
        private关键字:权限修饰符。表示私有的意思。可以修饰成员变量和成员方法。

        this:表示当前类的引用对象。
                应用场景：解决局部变量隐藏成员变量问题。

        this的三种用法：
                this.成员变量
                this(...)
                this.成员方法()

        对应的：把super也说一下：
                super.成员变量
                super(...)
                super.成员方法()

6:一个标准的学生类
        class Student {
                //姓名
                private String name;
                //年龄
                private int age;
               
                public Student(){}

                public Student(String name,int age) {
                        this.name = name;
                        this.age = age;
                }

                public void setName(String name) {
                        this.name = name;
                }

                public String getName() {
                        return name; //return this.name;
                }

                public void setAge(int age){
                        this.age = age;
                }

                public int getAge() {
                        return age;
                }
        }
       
7:如何使用一个标准的学生类呢?
        给成员变量赋值的方式：
                A:通过构造方法赋值
                B:通过setXxx()方法赋值

        class StudentTest {
                public static void main(String[] args) {
                        //通过构造方法赋值
                        Student s1 = new Student("张三",18);
                        System.out.println(s1.getName()+"---"+s1.getAge());

                        //通过setXxx()方法赋值
                        Student s2 = new Student                        s2.setName("张三");
                        s2.setAge(20);
                        System.out.println(s2.getName()+"---"+s2.getAge());
                }
        }

8:继承
        我们在定义一个类的时候，不需要从头开始。可以在某些类的基础上，扩充自己的功能即可。
        让我们的类和那个已经存在的类产生一个关系，我就能够具备别人的成员。这个关系：继承。

        继承的好处：
                A:提高代码的复用性。
                B:让类与类之间产生了一个关系，是多态的前提。
        继承的弊端：
                破坏了耦合性。类之间的关系过强，会导致一个类的改动直接影响其他的类。

        继承的特点：
                A:Java中类只支持单继承。
                B:可以多层继承。

        什么时候考虑使用继承?
                假设法：is a的关系。

        方法重写：
                一般是指在子类中出现了和父类一模一样的方法声明，方法体不一样。

                注意：
                        A:父类的私有方法不能被重写。
                        B:子类重写后的方法的访问权限要大于等于父类方法的访问权限。
                        C:子类重写后的方法的返回值类型：
                                基本类型：一致。
                                引用类型：是父类本身或者父类的子类。
                开发中，基本上不会出现注意里面的问题，因为开发中方法声明都是一模一样的。

9:多态
        同一个对象，在不同时刻表现出现的不同状态。
                举例：水(水，冰，水蒸气)
                      狗(动物,狗)
                从代码的角度来看：编译期状态和运行期状态不一致的现象。
                        Fu fu = new Fu();
                        Zi zi = new Zi();
                        Fu fu = new Zi();

        前提：
                A:有继承或者实现关系。
                B:有方法的重写。
                C:父类或者父接口的引用指向子类对象。

        class Fu {
                public int num = 10;
               
                public void show() {
                        System.out.println("Fu"+num);
                }
        }

        class Zi extends Fu {
                public int num = 10;
                public int num2 = 20;
               
                public void show() {
                        System.out.println("Zi"+num);
                        System.out.println("Zi"+num2);
                }

                public void method() {
                        System.out.println("method");
                }
        }

        测试类：
        class Test {
                public static void main(String[] args) {
                        /*
                        Fu f = new Fu();
                        System.out.println(f.num);
                        f.show();

                        Zi zi = new Zi();
                        System.out.println(zi.num);
                        zi.show();
                        */

                        //多态
                        Fu f = new Zi();
                        System.out.println(f.num);
                        //System.out.println(f.num2);

                        f.show();
                        //f.method();
                }
        }

        多态中成员的特点：
                成员变量：编译和运行都看左边。
                成员方法：编译看左边，运行看右边。

                为什么?
                        因为方法有重写，而变量没有。

---

作者: 彭旭文    时间: 2014-5-12 17:38
很好的总结，谢谢了...

---

作者: 大漠孤烟    时间: 2014-5-12 20:40
举例很形象、、、、

---

作者: 郝林杰    时间: 2014-5-12 22:02
也来看看啊

---

作者: 种一棵树    时间: 2014-5-12 23:39
学习学习

---

作者: 孟凡超    时间: 2014-5-13 08:56
看看。。。。。。

---

作者: wangzhiyong515    时间: 2014-6-12 12:26

彭旭文 发表于 2014-5-12 17:38
很好的总结，谢谢了...

大家互相学习

---

作者: cuixinfu    时间: 2014-7-29 00:55
很不错的总结  

---

作者: 为梦想而活着    时间: 2014-7-29 07:20
解释的真通俗易懂~

---

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

黑马程序员IT技术论坛 X3.2