Java类与对象

面向对象的编程思想力图使在计算机语言中对事物的描述与现实世界中该事物
的本来面目尽可能地一致，类（ class）和对象（ object）就是面向对象方法的核心概念。
类是对某一类事物的描述，是抽象的、概念上的定义；对象是实际存在的该类事物的
个体，因而也称实例（ Instance）。
比如：美女是类，范冰冰就是对象。狗是类，你家里的小狗就是对象。

类

在使用类之前，必须先定义它，然后才可利用所定义的类来声明变量，并创建对
象。类定义的语法如下：
class 类名称
{
数据类型 属性 ；
…. 声明成员变量（属性）
返回值的数据类型 方法名称（参数 1，参数 2…）
{
程序语句 ； 定义方法的内容
return 表达式 ；
}
}
类中有属性，和方法

class Person {
    String name;
    int age;

    void talk() {
        System.out.println("我是： " + name + "，今年： " + age + "岁");
    }
}

类名中单词的首字母是大写的，这是规定的一种符合标准的写法。

新建对象

在上面的范例中，已经创建好了一个 Person 的类，相信类的基本形式读者应该已经很清楚了，但是在实际中单单有类是不够的，类提供的只是一个摸板，必须依照它创建出对象之后才可以使用。下面定义了由类产生对象的基本形式：
类名 对象名 = new 类名() ;
1. 声明指向”由类所创建的对象”的变量。
2. 利用 new 创建新的对象，并指派给先前所创建的变量。

Person p ; // 先声明一个 Person 类的对象 p
p = new Person() ; // 用 new 关键字实例化 Person 的对象 p

也可以是：

Person p = new Person() ; // 声明 Person 对象 p 并直接实例化此对象

对象只有在实例化之后才能被使用，而实例化对象的关键字就是 new，是不是和我们声明变量和数组类似呢。

由图中可以看出，当语句执行到 Person p 的时候，只是在栈内存中声明了一个Person 的对象 p，但是这个时候 p 并没有在堆内存中开辟空间，所以这个时候的 p 是一个未实例化的对象，用 new 关键字实际上就是开辟堆内存，把堆内存的引用赋给了p，这个时候的 p 才称为一实例化对象。

对象访问类中的属性和方法

访问属性： 对象名称.属性名
访问方法： 对象名称.方法名()
例如：如果想访问 Person 类中的 name 和 age 属性，可以用如下方法来访问：

p.name ; // 访问 Person 类中的 name 属性
p.age ; // 访问 Person 类中的 age 属性

因此：若想将 Person 类的对象 p 中的属性 name 赋值为”张三”，年龄赋值为 25，则可以采用下面的写法：

p.name = "张三" ;
p.age = 25 ;

如果想调用 Person 中的 talk()方法，可以采用下面这种写法：

p.talk() ; // 调用 Person 类中的 talk()方法

下面来看一下具体代码中的实现

// 下面这个范例说明了使用 Person 类的对象调用类中的属性与方法的过程
class TestPersonDemo {
    public static void main(String[] args) {
        Person p = new Person();
        p.name = "张三";
        p.age = 25;
        p.talk();
    }
}

输出结果：
我是：张三，今年： 25 岁
访问过程如图

创建多个对象

public class TestPersonDemo1 {
    public static void main(String[] args) {
        // 声明并实例化一 Person 对象 p1
        Person p1 = new Person();
        // 声明并实例化一 Person 对象 p2
        Person p2 = new Person();

        // 给 p1 的属性赋值
        p1.name = "张三";
        p1.age = 25;
        // 给 p2 的属性赋值
        p2.name = "李四";
        p2.age = 30;

        // 分别用 p1、 p2 调用 talk()方法
        p1.talk();
        p2.talk();

    }
}

输出结果：
我是：张三，今年： 25 岁
我是：李四，今年： 30 岁
是不是和声明多个变量很像呢

类的封装性private

当我们不想让其它的类去改变我们本类的属性及方法时，可以利用封装。封装属性和方法的格式如下：
封装属性： private 属性类型 属性名
封装方法： private 方法返回类型 方法名称（参数）

class Person {
    private String name;
    private int age;

    private void talk() {
        System.out.println("我是： " + name + "，今年： " + age + "岁");
    }

    public void setName(String str) {
        name = str;
    }

    public void setAge(int a) {
        if (a > 0)
            age = a;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

可以看出，封装就是利用关键字private对属性及方法的修饰。用private 声明的属性或方法只能在其类的内部被调用，而不能在类的外部被调用，要设置或取得属性值，则只能用 setXxx()、getXxx()方法，这是一个明确且标准的规定

#