JAVA面向对象1：类与对象

面向对象的概念

1、封装性

封装是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节，这就是封装思想。例如，用户是用电脑，只需要是用手指敲键盘就可以了，无需知道电脑内部是如何工作，即使用户可能碰巧知道电脑的工作原理，但在使用时，并不完全依赖电脑工作原理这些细节。

2、继承性

继承性主要描述的是类与类之间的关系，通过继承，可以在无须重新编写原有类的情况下，对原有类的功能进行扩展。例如，有一个汽车的类，该类中描述了汽车的普通特性和功能，而轿车的类中不仅应该包含汽车的特性和功能，还应该增加轿车特有的功能，这时，可以让轿车类继承汽车类，在轿车类中单独添加轿车特性的方法就可以了。继承不仅增强了代码复用性，提高了开发效率，而且为程序的修改补充提供了便利。

3、多态性

多态性指的是在程序中允许出现重名现象，它指在一个类中定义的属性和方法被其他类继承后，他们可以具有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同的类中具有不同的语义。例如，当听到“Cut”这个单词时，理发师的行为是剪发，演员的行为是停止表演，不同的对象，所表现的行为是不一样的。

---

类与对象

1、类的定义

在面向对象的思想中最核心的就是对象，为了在程序中创建对象，首先需要定义一个类。类是对象的抽象，它用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法，其中成员变量用于描述对象的特征，也被称作属性，成员方法用于描述对象的行为，简称为方法。
案例1：

class Person {
    int age;              //定义int类型的变量age
    //定义speak()方法
    void speak() {
        System.out.println("大家好，我今年" + age + "岁！");
    }
}

案例1中定义了一个类。其中，Person是类名，age是成员变量，speak()是成员方法。在成员方法speak()中可以直接访问成员变量age。

注意！！！
在Java中，定义在类中的变量被称为成员变量，定义在方法中的变量被称为局部变量。如果在一个方法中定义的局部变量与成员变量同名，这种情况是允许的，此时方法中通过变量名访问到的是局部变量，而并非成员变量，如下：

class Person {
    int age=10;          //类中定义的变量被称作成员变量
    void speak() {
        int age=60;      //方法内部定义的变量被称作局部变量
        System.out.println("大家好，我今年" + age + "岁！");
    }
}

上面的代码中，在Person类的speak()方法中有一条打印语句，访问了变量age，此时访问的是局部变量age，也就是说当有另外一个程序来调用speak()方法时，输出的值是60，而不是10.

2、对象的创建与使用

应用程序想要完成具体的功能，仅有类是远远不够的，还需要根据类创建实例对象。在Java程序中可以使用new关键字来创建对象，具体格式如下：

类名 对象名称=new 类名()；

例如，创建Person类的实例对象代码如下：

Person p=new Person();

上面的代码中，”new Person()”用于创建Person类的一个实例对象，”Person p”则是声明了一个Person类型的变量p。中间的等号用于将Person对象在内存中的地址赋值给变量p，这样变量p便持有了对象的引用。

通常会将变量p引用的对象简称为p对象。

在创建Person对象后，可以通过对象的引用来访问对象所有的成员，具体格式如下：

对象引用.对象成员

接下来通过一个案例来学习如何访问对象的成员。
案例2：

class Example01 {
    public static void main(String[] args) {
        Person p1=new Person();         //创建第一个Person对象
        Person p2=new Person();         //创建第二个Person对象
        p1.age=18;                      //为age属性赋值
        p1.speak();                     //调用对象的方法
        p2.speak();
    }
}

案例2中，p1、p2分别引用类Person类的两个实例对象。p1、p2打印的age值不同是因为p1对象和p2对象是两个完全独立的个体，它们分别拥有着各自的age属性，对p1对象的age进行赋值不会影响到p2对象age属性的值。
案例2中，通过“p1.age=18;”将p1对象的age属性赋值为18，但并没有对p2对象的age属性进行赋值，按理说p2对象的age属性应该是没有值的。但是打印出来后发现，其值为0。这是因为在实例化对象时，Java虚拟机会自动为成员变量进行初始化，针对不同类型的成员变量，Java虚拟机会赋予不同的初始值，如表1.

表1：

成员变量类型	初始值	成员变量类型	初始值
byte	0	double	0.0D
short	0	char	空字符，’\u0000’
int	0	boolean	false
long	0	引用数据类型	null
float	0.0F

当对象被实例化后，在程序中可以通过对象的引用变量来访问该对象的成员。需要注意的是，当没有任何变量引用这个对象时，它将成为垃圾对象，不能再被使用。接下来通过两段代码来分析对象是如何成为垃圾的。

{
    Person p1=Person();
    ...
}

上面代码中使用变量p1引用了一个Person类型的对象，当这段代码运行完毕时，变量p1就会超出其作用域而被销毁，这时Person类型的对象就没有被任何变量引用，变成垃圾。
案例3：

class Person {
    void say() {
        System.out.println("我是一个人！");
    }
}

class Example {
    public static void main(String[] args) {
        Person p2=new Person();             //创建Person对象
        p2.say();                           //调用say()
        p2=null;                            //将Person对象置为null
        p2.say();
    }
}

在案例3中，创建了一个Person类的实例对象，并两次调用了该对象的say()方法。第一次调用say()方法时可以正常打印，但在10行代码中将变量p2的值置为null，当再次调用say()方法时抛出了空指针异常。在Java中，null是一种特殊的常量，当一个变量的值为null时，则表示该变量不指向任何一个对象。当把变量p2置为null时，被p2所引用的Person对象就会失去引用，成为垃圾对象。

3、类的设计

在Java中，对象是通过类创建出来的。因此，在程序设计时，最重要的就是类的设计。
假设要在程序中描述一个学校所有学生的信息，可以先设计一个学生类(Student)，在这个类中定义两个属性name、age分别表示学生的姓名、年龄，定义一个方法introduce()表示学生做自我介绍。根据上述描述设计出来的Student类如下。
案例4：

public class Student {
    String name;
    int age;
    public void introduce() {
        //方法中打印属性name和age的值
        System.out.println("大家好，我叫"+name+"，我今年"+age+"岁！");
    }
}

再案例4的Student类中，定义了两个属性name和age。其中name属性为String类型，在Java中使用String类的实例对象表示一个字符串，如：

    String name="李芳";

4、类的封装

接下来针对案例4中设计的Student类创建对象，并访问该对象的成员。
案例5：

public class Example5 {
    publica static void main(String[] args) {
        Student stu=new Student();      //创建学生对象
        stu.name="李芳";                 //为对象的name赋值
        stu.age=-30;                    //为对象的age赋值
        stu.introduce();                //调用对象的方法
    }
}

案例5中第5行代码中，将年龄赋值为一个负数-30，这在程序中不会有任何问题，但在现实生活中明显是不合理的。为了解决年龄不能为负数的问题，在设计一个类时，应该对成员变量的访问做出一些限定，不允许外界随意访问。这就需要实现类的封装。

所谓类的封装是指在定义一个类时，将类中的属性私有化，即使用private关键字来修饰，私有属性只能在他所在类中被访问。为了能让外界访问私有属性，需要提供一些使用public修饰的共有方法，其中包括用于获取属性值的getXxx()方法和设置属性值的setXxx()方法。
案例6：

class Student {
    private String name;            //将name属性私有化
    private int age;                //将age属性私有化
    //下面是共有的getXxx()和setXxx()方法
    public String getName() {
        return name;
    }
    public void setName(String stuName) {
        name=stuName;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int stuAge) {
        //下面是对传入的参数进行检查
        if (stuAge<=0) {
            System.out.println("年龄不合法……");
        } else {
            age=stuAge;             //对属性赋值
        }
    }
    public void introduce() {
        System.out.println("大家好，我叫"+name+"，我今年"+age+"岁！");
    }
}

class Example6 {
    public static void main(String[] args) {
        Student stu=new Student();
        stu.setName("李芳");
        stu.setAge(-30);
        stu.introduce();
    }
}

在案例6的Student类中，使用private关键字将属性name和age声明为私有，对外界提供了几个公有的方法，其中getName()方法用于获取name属性的值，setName()方法用于设置name属性的值，同理，getAge()和setAge()方法用于获取和设置age属性的值。在main()方法中创建Student对象，并调用setAge()方法传入一个负数-30，在setAge()方法中对参数stuAge的值进行检查，由于当前传入的值小于0，因此会打印“年龄不合法……”的信息，age属性没有被赋值，仍为默认初始值0。