OOP概念,类与对象

OOP——面向对象编程
类与对象
- 类
- 对象

OOP——面向对象编程

首先，我们来举一个例子：
现在我要用用代码实现下列要求，定义一只猫，它的名字叫”小芳”，年龄是“3岁”，并且会叫,叫声是“喵喵~”
我们分析这个要求时会发现，我们需要定义两个变量和一个方法，变量分别是名字和年龄，方法是 cry，我们来写一下看看

public class CatTest{
    public static void main(String[] args){
        String catName="小芳";
        int catAge=3;
        cry(catName,catAge);
    }
    public static void cry(String name,int age){
        System.out.println("喵喵~");
        System.out.println("我是"+name+",我今年"+age+"岁了。");
    }
}

这种实现方式是一种面向过程的结构化程序设计，是一种以过程为核心的编程思想，即分析出解决问题所需要的步骤，然后一一实现，使用时在main方法中再一一调用。这种方法并不是说不好或者不对，但是我们想一下，如果我养了好几只猫，甚至是我开了个宠物店，养了几十上百只猫，那我做系统的时候难道要定义几十上百个买的变量吗？有些同学会说那用数组啊，大家仔细看，这里名字（catName）是String字符串类型的，而年龄（catAge）是int类型的，我们说过数组只能存储同一类型的数据，而且数组的长度是不能变的，如果我多养一只难道要写一遍程序吗？再说了，如果用把不同类型的数据分成一个数组，那我们如果还有别的变量例如品种，食性，价格等等··每个猫的叫声也不一样，颜色不一样，我们真的能做到简化代码吗？如果真的遇到这种情况我们该怎么办呢？
这里我们就介绍一下我们的新知识——OOP(Object Oriented Programming) 面向对象编程
那我们再从另一个角度出发重新思考一下这个问题，我既然养了这么多猫，那我先找到他们的共同点，然后对每一个猫都单独进行操作这样行不行呢？首先，它们都有名字，年龄；其次，它们都会叫。那我如果有一个东西能专门把这些共同的东西封装起来，下次我用的时候直接提取是不是要方便很多呢？我们继续往下看~

类与对象

面向对象有两个核心概念——类(Class)和对象(object)

类(Class)的概念

类（Class）定义了一件事物的抽象特点。通常来说，类定义了事物的属性和行为。举例来说，”猫”这个类会包含猫的一切基础特征，例如它的名字、年龄，毛皮颜色和叫的能力。

注意：类是对某一事物的描述，是抽象的，概念上的定义

1)定义一个类

定义格式：

class  类名{
    ...
}

代码案例：

    class Cat{
    //定义了一个类， 类名是 cat， 代表 “猫”  
    }

2)定义类的成员(属性(变量)和行为(方法))

每个事物都有自身的属性和行为，所以我们把他们抽象的提取出来，然后定义在类里面，成为它的成员，其中属性是个值，我们定义为变量(成员变量)，行为是个动作，我们定义为方法。

a)定义类的成员变量(属性)

例如：我们把“猫”这个事物的属性抽象的提取出来，它们都有 “名字”，“年龄”,但是重点是我们没有具体指哪个猫，所以我们要定义的是变量“名字”，“年龄”，但是没有值。
代码案例：

class Cat{
    String name;
    int age;
}

a)定义类的方法(行为)

例如：我们把“猫”的行为提取出来，它们都会“叫”
代码案例：

class Cat{
    String name;
    int age;
    public  void cry(String name,int age){
        System.out.println("喵喵~");
        System.out.println("我是"+name+",我今年"+age+"岁了。");
    }
}

对象(object)的概念

对象是类的实例，JAVA中有一句话叫做“万物皆对象”。举例来说，我们说类cat是指“猫”这个类别，而我们说的对象，就是专指某一个猫！这个猫叫“小芳”，年龄是“3岁”。我们现在不是对变量名字和年龄进行操作，而是对这个叫小芳的猫进行操作。

注意：对象是实际存在的该事物的个体，是具体的，现实的

1)创建一个对象

我们学到基本数据类型时就说过，JAVA中有很多种类型，以后我们也会自己创建类型，就int而言，int代表了整型，同样的，我们创建的类Cat 也一样，它被我们定义为代表了“猫”的类型。int代表了一个整型，它是一个类别，并不是单指某一个整数，所以我们定义或者说指定某一个具体的整数(例如18)时会这么写

int  age=18;

这样就定义了一个int类型的变量age，用age来存这个具体的数18；
同样的，我们的Cat类型也一样，它代表了一个“猫”的类型，但是不是单指某一个猫，如果我们要单指某一个猫(例如小芳)，那我们就要创建一个变量来指向它，这个时候，我们就称这只猫是一个对象。而这个过程就是创建对象：

创建对象的语法：
引用类型  引用类型变量(引用/变量名/对象名) = new  引用类型();

例如，我们创建一个类Cat的实例(对象)

Cat cat=new Cat();

Cat：指 Cat 类，就像声明整型时的int一样 (int age;)
cat：引用类型变量，也被简称为引用，就像int age；中的age一样，它是一个变量名，也叫对象名，但是一般都简称为“引用”(刚开始会听起来怪怪的，以后习惯就好了)
new Cat();这就是一个对象(或者说是一个创建对象的语句)。这个引用的值不是一个像18一样的具体值，而是指向这个对象，例如：这个cat代表了这个小猫，而小猫是一个真实的个体(对象)。

引用类型变量：
1)引用类型变量可以存储该类对象的地址信息，通常称为“指向该类的对象”，当一个引用类型变量指向该类的对象，就可以通过这个变量对对象实施访问。
2)除8种基本类型之外，用类、接口、数组等声明的变量都称为引用类型变量，简称“引用”。
3)需要记住的是，只要出现new关键字，都是创建了一个对象！

2)访问对象的成员变量，调用对象的方法

我们之前就说过，类定义了一个事物的抽象特点，所以对象肯定是含有这些特点的，那我们怎么调用这些属性和方法。
在面向对象中，我们使用 “.” 代表“…的”,也就是说我们要用引用点出这些属性和方法，
代码案例：

public class CatTest(){
    public static void main(String[] args){
        Cat cat=new Cat();//创建一个Cat对象
        cat.name="小芳";// 访问这个对象的成员变量name,并给它赋值为"小芳"
        cat.age=3;// 访问这个对象的成员变量age,并给它赋值为3
        cat.cry(cat.name,cat.age);// 调用这个对象的方法cry,给它传值为这个对象的成员变量name和age
    }
}

运行结果如下：

喵喵~
我是小芳，我今年3岁了。

3）引用类型变量的赋值

引用类型变量存储的是对象的地址信息，对引用类型变量的赋值，除了使用上面的new关键字以外，还可以有另外一种赋值方式，即：相同类型的引用类型变量之间相互赋值。
代码案例:

Cat cat1=new Cat();
Cat cat2=cat1;

代码分析：新建Cat类型变量cat1，使它指向一个新建对象，然后新建一个Cat类型变量cat2,然后把cat1赋值给cat2。

需要注意的是：引用类型变量之间的赋值不会创建新的对象，但会使两个以上的引用指向同一个对象(两个引用指向的地址信息相同)。什么意思呢，就像我给这个小猫取个名字叫“玛丽”，然后再给它取个小名叫 “二蛋”，这个时候“玛丽”和“二蛋”都是指这只猫，如果“玛丽”的年龄增长1岁，那么“二蛋”的年龄肯定也增长一岁，所以如果多个引用指向一个对象，那么不管使用哪个引用对这个对象进行操作，都会影响所有对该对象的引用！

代码案例：

Cat cat1=new Cat();
Cat cat2=cat1;
Cat cat3=cat1;
//这时3个引用都指向同一个对象
cat1.age=4;
cat3.age=5;
System.out.println(cat1.age);
System.out.println(cat1.age);
System.out.println(cat1.age);

运行结果：

5
5
5

4)null和NullPointerException

如果在声明引用类型变量时没有给它赋值，则不能点出(调用)任何属性和方法，因为它并没有指向任何一个对象，就像是基本类型没有赋值一样。
代码案例：

Cat cat;

此代码相当于

Cat cat=null;

此时如果想调用任何属性和方法会发生空指针异常(NullPointerException),异常我们后面会学到，在具体讲。
OOP概念,

JAVA OOP(一)——OOP概念，类与对象