类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程也叫类的实例化。每个对象都是类的一个具体实例（Instance），拥有类的成员变量和成员函数。
C++类的定义
有些教程将类的成员变量称为类的属性（Property），将类的成员函数称为类的方法（Method）。在面向对象的编程语言中，经常把函数（Function）称为方法（Method）。
与结构体一样，类只是一种复杂数据类型的声明，不占用内存空间。而对象是类这种数据类型的一个变量，或者说是通过类这种数据类型创建出来的一份实实在在的数据，所以占用内存空间。
类的定义
类是用户自定义的类型，如果程序中要用到类，必须提前说明，或者使用已存在的类（别人写好的类、标准库中的类等），C++语法本身并不提供现成的类的名称、结构和内容。
一个简单的类的定义：
class Student{

public:

    //成员变量

    char *name;

    int age;

    float score;

    //成员函数

    void say(){

        cout<<name<<"的年龄是"<<age<<"，成绩是"<<score<<endl;

    }

};

class是 C++ 中新增的关键字，专门用来定义类。Student是类的名称；类名的首字母一般大写，以和其他的标识符区分开。{ }内部是类所包含的成员变量和成员函数，它们统称为类的成员（Member）；由{ }包围起来的部分有时也称为类体，和函数体的概念类似。public也是 C++ 的新增关键字，它只能用在类的定义中，表示类的成员变量或成员函数具有“公开”的访问权限。
注意在类定义的最后有一个分号;，它是类定义的一部分，表示类定义结束了，不能省略。
整体上讲，上面的代码创建了一个 Student 类，它包含了 3 个成员变量和 1 个成员函数。
类只是一个模板（Template），编译后不占用内存空间，所以在定义类时不能对成员变量进行初始化，因为没有地方存储数据。只有在创建对象以后才会给成员变量分配内存，这个时候就可以赋值了。
类可以理解为一种新的数据类型，该数据类型的名称是 Student。与 char、int、float 等基本数据类型不同的是，Student 是一种复杂数据类型，可以包含基本类型，而且还有很多基本类型中没有的特性，以后大家会见到。
创建对象
有了 Student 类后，就可以通过它来创建对象了，例如：
Student liLei;  //创建对象
Student是类名，liLei是对象名。这和使用基本类型定义变量的形式类似：
int a;  //定义整型变量
从这个角度考虑，我们可以把 Student 看做一种新的数据类型，把 liLei 看做一个变量。
在创建对象时，class 关键字可要可不要，但是出于习惯我们通常会省略掉 class 关键字，例如：
class Student LiLei;  //正确

Student LiLei;  //同样正确

除了创建单个对象，还可以创建对象数组：
Student allStu[100];

该语句创建了一个 allStu 数组，它拥有100个元素，每个元素都是 Student 类型的对象。
访问类的成员
创建对象以后，可以使用点号.来访问成员变量和成员函数，这和通过结构体变量来访问它的成员类似，如下所示：
#include <iostream>

using namespace std;

//类通常定义在函数外面

class Student{

public:

    //类包含的变量

    char *name;

    int age;

    float score;

    //类包含的函数

    void say(){

        cout<<name<<"的年龄是"<<age<<"，成绩是"<<score<<endl;

    }

};

int main(){

    //创建对象

    Student stu;

    stu.name = "小明";

    stu.age = 15;

    stu.score = 92.5f;

    stu.say();

    return 0;

}


运行结果：
小明的年龄是15，成绩是92.5

stu 是一个对象，占用内存空间，可以对它的成员变量赋值，也可以读取它的成员变量。
类通常定义在函数外面，当然也可以定义在函数内部，不过很少这样使用。
使用对象指针
C语言中经典的指针在 C++ 中仍然广泛使用，尤其是指向对象的指针，没有它就不能实现某些功能。
上面代码中创建的对象 stu 在栈上分配内存，需要使用&获取它的地址，例如：
Student stu;

Student *pStu = &stu;

pStu 是一个指针，它指向 Student 类型的数据，也就是通过 Student 创建出来的对象。
当然，你也可以在堆上创建对象，这个时候就需要使用前面讲到的new关键字（C++ new和delete运算符简介），例如：
Student *pStu = new Student;

在栈上创建出来的对象都有一个名字，比如 stu，使用指针指向它不是必须的。但是通过 new 创建出来的对象就不一样了，它在堆上分配内存，没有名字，只能得到一个指向它的指针，所以必须使用一个指针变量来接收这个指针，否则以后再也无法找到这个对象了，更没有办法使用它。也就是说，使用 new 在堆上创建出来的对象是匿名的，没法直接使用，必须要用一个指针指向它，再借助指针来访问它的成员变量或成员函数。
栈内存是程序自动管理的，不能使用 delete 删除在栈上创建的对象；堆内存由程序员管理，对象使用完毕后可以通过 delete 删除。在实际开发中，new 和 delete 往往成对出现，以保证及时删除不再使用的对象，防止无用内存堆积。
栈（Stack）和堆（Heap）是 C/C++ 程序员必须要了解的两个概念，我们已在《C语言内存精讲》专题中进行了深入讲解，相信你必将有所顿悟。
有了对象指针后，可以通过箭头->来访问对象的成员变量和成员函数，这和通过结构体指针来访问它的成员类似，请看下面的示例：
pStu -> name = "小明";

pStu -> age = 15;

pStu -> score = 92.5f;

pStu -> say();

下面是一个完整的例子：

#include <iostream>

using namespace std;

class Student{

public:

    char *name;

    int age;

    float score;

    void say(){

        cout<<name<<"的年龄是"<<age<<"，成绩是"<<score<<endl;

    }

};

int main(){

    Student *pStu = new Student;

    pStu -> name = "小明";

    pStu -> age = 15;

    pStu -> score = 92.5f;

    pStu -> say();

    delete pStu;  //删除对象

    return 0;

}

运行结果：
小明的年龄是15，成绩是92.5

虽然在一般的程序中无视垃圾内存影响不大，但记得 delete 掉不再使用的对象依然是一种良好的编程习惯。

1、private修饰符的作用
为了防止数据被意外篡改，使用private修饰符可以将数据域声明为私有的，这也称为是数据域的封装。
2、访问器(accessor)和修改器(mutator)的定义
简单点说，访问器和修改器就是类中定义的方法。

为了能够访问私有数据域，可以提供一个get方法返回数据域的值。get方法称为是访问器；

为了能更新一个数据域，可以提供一个set方法来给数据域设置新值。set方法称为是修改器。
3、private在Java中的使用

public class UserFile{
    public static void main(String[] args){
    	/* 创建一个叫做John的对象，年龄为20岁 */
        UserManagementCenter John = new UserManagementCenter(20);
        /* 使用修改器方法来设置John的用户ID */
        John.setUserID(12345);
        /** 使用访问器方法来查看John的用户ID */
        System.out.print(John.getUserID());
    }
}

class UserManagementCenter{
    private long userID;
    int userAge;
    static int userCount = 0;

    public UserManagementCenter(){
        userCount++;
        userAge = 0;
    }
    public UserManagementCenter(int age){
        userAge = age;
        userCount++;
    }
    /** 设置用户的ID账号 */
    public void setUserID(long newID){
        userID = newID;
    }
    /** 访问Jone的用户ID */
    public long getUserID(){
        return userID;
    }
}

这个程序输出的是Jone的用户ID‘12345’，使用private来修饰的变量只能在定义这个变量的类中被直接调用，而在类外直接调用private的变量Java编译器会提示出错。

这句话也说明了，如果在主类中定义一个private的变量那么在主函数main()是可以通过创建对象直接修改和访问的，见如下程序
/** private的数据可以在定义private的类中被方法访问 */
public class UserFile {
    private long id;
    public static void main(String[] args){
        /** 创建一个叫做dopa的对象，年龄为20岁 */
        UserFile dopa = new UserFile(20);
        dopa.id = 12345;
        System.out.print(dopa.id);
    }
}

程序输出为‘12345’

面向对象
什么是面向对象程序设计
面向对象程序设计(OOP)就是使用对象进行程序设计。对象(object) 代表现实世界中可以明确标识的一个实体。例如:一个学生、一张桌子、一个圆、一个按钮甚至-一笔贷款都可以看作一个对象。每个对象都有自己独特的标识、状态和行为。
类的属性

一个对象的状态(state, 也称为特征( property) 或属性( atribute)) 是由数据域及其当前值来表示的。例如，圆对象具有一个数据域radius,它是描述圆的特征的属性。矩形对象具有数据域width和height,它们都是描述矩形特征的属性。
对象的方法

一个对象的行为( behavior, 也称为动作(action)) 是由方法定义的。调用对象的一个方法就是要求对象完成一一个动作。例如，可以为圆对象定义名为getArea(和getPerimeter()的方法。圆对象可以调用getArea()返回其面积，调用getPeri-meter()返回其周长。还可以定义setRadius(radius)方法，圆对象调用这个方法来修改半径。
实例化

使用一个通用类来定义同一类型的对象。类是一一个模板、蓝本或者合约，用来定义对象的数据域以及方法。对象是类的实例。可以从一个类中创建多个实例。创建实例的过程称为实例化( instantiation)。对象(object) 和实例(instance) 经常是可以互换的。类和对象之间的关系类似于苹果派配方和苹果派之间的关系。可以用一种配方做出任意多的苹果派来
类和对象的创建
创建与初始化对象
使用new关键字创建对象
public class Student {
    String name;    //null
    int age;    //0

    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }

}


public class Application {
    public static void main(String[] args) {
        Student xiaoming = new Student();
        Student xiaohong = new Student();

        xiaoming.name="小明";
        xiaoming.age= 3 ;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        xiaohong.name="小红";
        xiaohong.age= 3 ;
        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);

        xiaohong.study();
    }
}



构造器
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:


必须和类的名字相同


必须没有返回类型,也不能写void


构造器必须要掌握
代码如下
public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    //显示定义的构造器

    String name;
    int age;

    //使用new关键字，本质是在调用构造器
    //用来初始化

    public Person() {
    }


    //有参构造：一旦定义了有参构造，无参构造想使用就必须显式定义
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }

}

public class Application {
    public static void main(String[] args) {
    
        //实例化一个对象
        Person person = new Person("张瑞",20);


        System.out.println(person.name);
        System.out.println(person.age);



    }
}



创建对象的内存分析

上图所表示的是关于创建对象的内存分析

在pet类中定义两个对象dog和cat
pet中定义一个shout方法
存在一个main方法
对dog（引用变量）和cat（引用变量）进行实例化
dog进行赋值，cat没有赋值，为默认状态
pet中具有name和age属性

可以根据画出来的图完成代码，也可以根据代码画出内存分析
学习面向对象前必须了解方法的调用
调用方法的时候

动态的方法可以调用静态的方法
静态的方法不能直接调用动态的方法

使用动态的方法必须先实例化
关于值传递和引用传递
值传递
public class Demo03 {
    //值传递
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);

        Demo03.change(a);

        System.out.println(a);

    }
    //因为是值传递，走过a=10之后没有返回值直接跳出，回去之后a依然等于1

    public static void change(int a){
        a=10;
    }

}




可以debug调试观察
引用传递
引用传递本质也是值传递，调用的是对象
public class Demo04 {

    //引用传递：对象 本质还是值传递
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);

        Demo04.change(person);
        System.out.println(person.name);

    }
    public static void change(Person person){
        person.name="张瑞";
    }
}
//定义一个Person类
class Person{
    String name;    //初始值null
}


小结

类是一个模板，对象是一个具体的实例
方法：定义，调用
对用的引用：引用类型和基本类型，对象是通过引用来操作的，栈---->堆
属性默认初始化

数字：0
char：u0000
boolean：false
引用：null


对象的创建和使用

必须使用new关键字创造对象	Person zhang = new Person();
对象的属性：zhang.name
对象的方法：zhang.sleep



写在最后

知之者不如好之者，好之者不如乐之者。

具有相同或相似性质的一组对象的抽象就是类，类是对一类事物的描述，是抽象的、概念上的意义；


对象是实际存在的该类事物的每个个体，因此也称为实例；


对象的抽象是类，类的具体化就是对象，也可以说类的实例就是对象。类用来描述一系列对象，概述了每个对象应包括的数据，并概述了每个对象的行为特征。


面向对象的三个基本特征：
一、封装
        对象要有一个明确的边界；边界的划分（对象各司其职、对象的粒度、对象的可重用性）
        具体来说：
                1.属性： 私有 private（提供set和get方法）
                2.方法： 公开或私有public/private
                3.方法声明 --> 公开
                  方法实现 --> 隐藏
                 实现改变时，对对象的使用者没有影响。
 
二、继承
        共性放到父类，特性放到子类；子类，父类 --> 其实就是特殊 --> 一般
        1.关键字： extends  例如：Dog extends Animal{}
        2.java中一个类最多只能有一个直接的父类，即单继承（具有简单性、树形结构），
          C++中是单继承
          java中要实现多继承，通过接口来实现。
        3.父类中所有属性和方法都能继承给子类；父类中的私有方法不能继承给子类。
        4.java中的访问修饰符
            

访问修饰符


访问权限


 继承　


private       


本类内部                  


不能继承


default       


本类+同包 


同包子类可以继承           


protected     


本类+同包+不同子包  


可以继承


public        


公开


可以继承

 

        5.构造对象过程
                   （1）分配空间
                   （2）递归地构造父类对象
                                a. 父类 初始化属性
                                b. 父类 构造方法
                   （3）初始化属性
                   （4）调用构造方法

        6.super  
               用法：
                   super（）  调用父类的构造方法，只能出现在构造方法的第一行
                   super.方法名   super表示父类的对象，通过它去调用父类的方法
               注意：在写类的时候，一定要写默认无参的构造方法，如果一个构造方法的
                     第一句既不是this(),也不是super()时，那么就会在这里隐含的调用
                     他的父类的无参的构造方法，即隐含的有super()。

三、多态
            运行时多态。
            子类的对象放在父类的引用中，例如 Animal a=new Dog,子类对象当父类对象来使用。
        1.多态原则：
                  （1）对象类型不变
                  （2）只能用引用调用其引用类型中定义的方法
                  （3）运行时，根据对象的实际类型去找子类覆盖之后的方法
             例子：
                  有Animal类中有eat()和sleep()两个方法，sleep()中睡8小时；子类Dog中有
                  eat()方法，sleep()方法中睡6小时，还有wangwang()方法。
                  现创建Animal a=new Dog(); 不能调用a.wangwang(),调用a.sleep()输出睡6小时。

          2.对象的强制转换
                 格式： 引用 instanceof 类型
                        引用所指的对象是否与类相符，返回值boolean值。
                 用法：
                       Animal a=new Cat();
                       if(a instanceof Dog)
                       {
                          Dog d=(Dog)a;
                          d.wangwang();
                        }
                 说明:如果只有Dog d=(Dog)a;运行时错误，因为a是Cat而不是Dog （多态原则第一条）

          3.多态的灵活变换
                  （1）用于参数列表上:
                               public void m(A a){} 可以用A类的任何子类对象作为参数
                  （2）用在返回值上：
                              public A m(){}  这个方法可能返回A类的任何子类对