Java基础班第五天笔记

第五天总结

1. 面向对象

    1.1 面向对象概念

             1.1.1 理解面向对象

                        a.面向对象是相对于面向过程而言的

                        b.面向对象和面向过程都是一种思想

                        c.面向对象基于面向过程

                        d.面向过程强调的是功能行为，面向对象强调的是具有功能的对象

             1.1.2 面向对象的特点

                        a.符合人们思考习惯的思想

                        b.可以将复杂的事情简单化

                        c.让程序员从执行者转变成指挥者

                        d.完成需求时

                               ⑴.先要去找具有所需的功能的对象来使用

                               ⑵.如果没有这样的对象，那么就创建一个这样的对象

                               ⑶.简化开发，提高代码的s复用性

             1.1.3 面向对象开发、设计和特征

                        开发的过程：开发的过程就是在不断的创建对象，使用对象

                                     指挥对象去做事情。

                        设计的过程：就是在管理和维护对象之间的关系

                        面向对象的特征：

                             a.封装(encapsulation)

                             b.继承(inheritance)

                             c.多态(polymorphism)

             1.1.4 举例

                        a.把大象装进冰箱

                               面向过程

                                    1，打开冰箱

                                    2，装进大象

                                    3，关闭冰箱

                                    代表语言：C语言，开发时重点在于定义函数

                               面向对象

                                    1，冰箱打开

                                    2，冰箱存储

                                    3，冰箱关闭

                        b.人开门

                              分析：有两个对象人和门。

                              问题：那么开门这个行为是属于人还是属于门呢？

                                        因为开门这个方法会使用到门中的一些数据(如:门轴，门链等)

                                        所以开门这个方法应该定义在门中，而让人去调用门的开门方法。

                              结论：当定义成员函数出现含糊时，就分析这个函数需要用到了哪个类的成员

                                    数据，哪个类用到就定义在哪个类中。

 

2. 类与对象之间的关系

    (一).使用计算机语言就是不断的在描述现实生活中的事物

    (二).Java中描述事物通过类的形式体现，类时具体事物的抽象，概念上的定义

    (三).对象即是该类事物的实体。

    2.1 类与对象

            比如汽车的图纸和汽车，我们可以将图纸理解为类，汽车理解为堆内存中的对象。

    2.2 类的定义

            a.在现实生活中，描述事物无非就是描述事物的属性和行为，比如：人有身高，体重，

              有跑步，睡觉，走路等行为。

            b.在Java中，用类(class)来描述事物也会是如此

                  ⑴.属性：成员变量

                  ⑵.行为：成员函数

            c.类就是将对象中共性内容不断抽取出来的抽象描述

            d.定义类其实就是在定义成员变量和成员函数

    2.3 .class文件

            a.当对象在创建(new)的时候需要的是.class文件，所以如果该类已经编译好了，生成了对应的

              .class文件，那么如果把源文件删除了还是可以创建该类的对象，如果没有编译生成.class文件

              那么如果把源文件删除了，那就无法创建该类的对象。

            b.只有创建了该类的对象，该类的.class文件才会被加载到内存中

    2.4 局部变量与成员变量的区别

             a.定义的位置

                   局部变量定义在函数或者语句中

                   成员变量定义在类中

             b.内存中的位置

                   局部变量在栈内存中

                   成员变量在堆内存中

             c.初始化值

                   局部变量没有初始化值，必须显示初始化后才能使用

                   成员变量有默认初始化值

             d.生命周期

                   局部变量一旦作用域结束，就立刻释放

                   成员变量也称为实例(对象)变量，随着对象的创建而存在，随着对象的被回收而消失

    2.5 创建对象，使用对象

            // 对Car这类事物进行描述

            class Car

            {

                public void driver()

                {

                    System.out.println("topSpeed=" + topSpeed + " color=" + color);

                }

                String color;

                int topSpeed

            }

            class CarDemo

            {

                public static void main(String[] args)

                {

                    Car c = new Car(); // 创建汽车的对象

                    c.color = "red";   // 对Car对象的color属性进行修改

                    c.topSpeed = 350;  // 对Car对象的topSpeed属性进行修改

                    c.driver();        // 调用Car的driver的功能

                }

            }

    2.6 对象创建在内存中的过程

            Person p = new Person("张三", 20);

            Java程序启动时，首先将main函数压入栈中，有一个Person类型的p变量，

            然后在堆内存中开辟了一段空间存储着Person对象的数据，

            首先成员变量name初始化为null，成员变量age初始化为0，

            然后Person(String, int)构造函数压入栈中，将"张三"和20

           
4000
传入，然后成员变量name被赋值为"张三"，age被赋值为20，最后把Person对象

            的内存首地址赋值给p变量。

    2.7 匿名对象

            a.匿名对象是对象的简化形式

            b.匿名对象两种使用情况

                   ⑴.当对对象方法仅进行一次调用时

                   ⑵.匿名对象可以作为实际参数进行传递

   

3. 封装

    3.1 概述

             隐藏对象的实现细节和属性，仅对外提供公共的访问方式

    3.2 封装的好处

             a.将变化隔离

             b.便于使用

             c.提高复用性

             d.提高安全性

    3.3 封装的原则

             a.将不需要对外提供的内容都隐藏起来

             b.将属性都隐藏，对外提供公共的访问方式

   

    3.4 private关键字

             a.是一种权限修饰符

             b.用于修饰成员(成员变量和成员函数)

             c.被private修饰的成员只能在本类中访问

             d.常用之一：将成员变量私有化，对外提供set和get方法进行访问，

                          提高数据的安全性

             注意：private(私有)仅仅是封装的表现形式之一

 

4. 构造函数(constructor)

    4.1 特点

            a.构造函数名与类名相同

            b.构造函数不能定义返回值类型

            c.构造函数不能返回具体的返回值

            d.构造函数在对象创建时就会被调用

            e.默认构造函数的访问权限如果不定义，就会取决于类的访问权限

    4.2 作用

            给对象进行初始化

    4.3 注意事项

            a.如果我们不自定义构造函数，那么编译器会提供给我们一个默认的

              没有形参的构造函数，如果我们自定义了任意形式的一个构造函数

              那么默认的无参构造函数编译器就不会提供给我们。

            b.多个构造函数可以以重载的形式存在

            c.一般函数与构造函数之间没有重载关系。

            d.一般函数名可以与构造函数同名

            e.构造函数可以有return;可以省略不写，编译器会加上

            注意：

                class Person

                {

                    // 这个已经不是构造函数了，因为构造函数是没有返回值类型的，

                    // 所以这样写Person()变成了一般函数。编译时可以通过的，

                    // 这样就没有自定义构造函数，所以编译器会提供一个默认构造函数

                    public void Person()

                    {

                    }

                }

                class Student

                {

                    public Student(String name, int age)

                    {

                        // 可以提前结束构造函数初始化

                        if (age < 0)

                            return;

                        this.name = name;

                        this.age = age;

                    }

                }

    4.4 构造函数与一般函数的区别

             a.构造函数用于给对象初始化，初始化动作只执行一次，没有返回类型

             b.一般函数可以被多次调用，有返回类型

 

5. this关键字

    5.1 概述

            this代表对象，是一个对象的引用。哪个对象调用了this所在的函数，

            this就代表哪个对象。

    5.2 this关键字的使用

            a.当成员变量和局部变量同名时，可以用this区分

            b.使用this(参数列表)的方式就可以实现构造函数之间的调用，注意,

              只能定义在构造函数的第一行，因为初始化动作必须先执行

            c.当功能内部使用到了本类对象时，用this表示

            d.可以定义返回本类类型的成员函数，这样创建匿名对象时，可以

              连续调用多个方法