一、面向对象简述

面向对象是一种现在最为流行的程序设计方法，几乎现在的所有应用都以面向对象为主了，最早的面向对象的概念实际上是由IBM提出的，在70年代的Smaltalk语言之中进行了应用，后来根据面向对象的设计思路，才形成C++，而由C++产生了Java这门面向对象的编程语言。

但是在面向对象设计之前，广泛采用的是面向过程，面向过程只是针对于自己来解决问题。面向过程的操作是以程序的基本功能实现为主，实现之后就完成了，也不考虑修改的可能性，面向对象，更多的是要进行子模块化的设计，每一个模块都需要单独存在，并且可以被重复利用，所以，面向对象的开发更像是一个具备标准的开发模式。

在面向对象定义之中，也规定了一些基本的特征：
（1）封装：保护内部的操作不被破坏；
（2）继承：在原本的基础之上继续进行扩充；
（3）多态：在一个指定的范围之内进行概念的转换。

对于面向对象的开发来讲也分为三个过程：OOA（面向对象分析）、OOD（面向对象设计）、OOP（面向对象编程）。

二、类与对象的基本概念

类与对象时整个面向对象中最基础的组成单元。

类：是抽象的概念集合，表示的是一个共性的产物，类之中定义的是属性和行为（方法）；
对象：对象是一种个性的表示，表示一个独立的个体，每个对象拥有自己独立的属性，依靠属性来区分不同对象。

可以一句话来总结出类和对象的区别：类是对象的模板，对象是类的实例。类只有通过对象才可以使用，而在开发之中应该先产生类，之后再产生对象。类不能直接使用，对象是可以直接使用的。

三、类与对象的定义和使用

在Java中定义类，使用关键字class完成。语法如下：

class 类名称 {
         属性 (变量) ;
         行为 (方法) ;
}

范例：定义一个Person类

class Person {     // 类名称首字母大写
    String name ;
    int age ;
    public void tell() {        // 没有static
          System.out.println("姓名：" + name + "，年龄：" + age) ;
         }
}

类定义完成之后，肯定无法直接使用。如果要使用，必须依靠对象，那么由于类属于引用数据类型，所以对象的产生格式（两种格式）如下：

（1）格式一：声明并实例化对象

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

（2）格式二：先声明对象，然后实例化对象：

类名称 对象名称 = null ;
对象名称 = new 类名称 () ;

引用数据类型与基本数据类型最大的不同在于：引用数据类型需要内存的分配和使用。所以，关键字new的主要功能就是分配内存空间，也就是说，只要使用引用数据类型，就要使用关键字new来分配内存空间。

当一个实例化对象产生之后，可以按照如下的方式进行类的操作：
对象.属性：表示调用类之中的属性；
对象.方法()：表示调用类之中的方法。

范例：使用对象操作类

package com.wz.classandobj;

class Person { 
    String name ;
    int age ;
    public void get() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Person per = new Person() ;// 声明并实例化对象
            per.name = "张三" ;//操作属性内容
            per.age = 30 ;//操作属性内容
            per.get() ;//调用类中的get()方法
        }
}

运行结果：

姓名：张三，年龄：30

以上完成了一个类和对象的操作关系，下面换另外一个操作来观察一下：

package com.wz.classandobj;

class Person { 
    String name ;
    int age ;
    public void get() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Person per = null;//声明对象
            per = new Person() ;//实例化对象
            per.name = "张三" ;//操作属性内容
            per.age = 30 ;//操作属性内容
            per.get() ;//调用类中的get()方法
        }
}

运行结果：

姓名：张三，年龄：30

那么，问题来了，以上两种不同的实例化方式有什么区别呢？
我们从内存的角度分析。首先，给出两种内存空间的概念：
（1）堆内存：保存对象的属性内容。堆内存需要用new关键字来分配空间；
（2）栈内存：保存的是堆内存的地址（在这里为了分析方便，可以简单理解为栈内存保存的是对象的名字）。

任何情况下，只要看见关键字new，都表示要分配新的堆内存空间，一旦堆内存空间分配了，里面就会有类中定义的属性，并且属性内容都是其对应数据类型的默认值。

于是，上面两种对象实例化对象方式内存表示如下：

两种方式的区别在于①②，第一种声明并实例化的方式实际就是①②组合在一起，而第二种先声明然后实例化是把①和②分步骤来。

另外，如果使用了没有实例化的对象，结果如何？
如下：

package com.wz.classandobj;

class Person { 
    String name ;
    int age ;
    public void get() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Person per = null;//声明对象
            //per = new Person() ;//实例化对象
            per.name = "张三" ;//操作属性内容
            per.age = 30 ;//操作属性内容
            per.get() ;//调用类中的get()方法
        }
}

运行结果：

Exception in thread "main" java.lang.NullPointerException
    at com.wz.classandobj.TestDemo.main(TestDemo.java:15)

此时，程序只声明了Person对象，但并没有实例化Person对象（只有了栈内存，并没有对应的堆内存空间），则程序在编译的时候不会出现任何的错误，但是在执行的时候出现了上面的错误信息。这个错误信息表示的是“NullPointerException（空指向异常）”，这种异常只要是应用数据类型都有可能出现。

四、对象引用传递初步分析

引用传递的精髓：同一块堆内存空间，可以同时被多个栈内存所指向，不同的栈可以修改同一块堆内存的内容。

下面通过若干个程序，以及程序的内存分配图，来进行代码的讲解。

我们来看一个范例：

class Person {     
         String name ;
         int age ;
         public void tell() {        
                   System.out.println("姓名：" + name + "，年龄：" + age) ;
         }
}
public class TestDemo {
         public static void main(String args[]) {
                   Person per1 = new Person() ;         // 声明并实例化对象
                   per1.name = "张三" ;
                   per1.age = 20 ;
                   Person per2 = per1 ;  // 引用传递
                   per2.name = "李四" ;
                   per1.tell() ;
         }
}

对应的内存分配图如下：

再来看另外一个：

class Person {
         String name ;
         int age ;
         public void tell() {
                   System.out.println("姓名：" + name + "，年龄：" + age) ;
         }
}
public class TestDemo {
         public static void main(String args[]) {
                   Person per1 = new Person() ;         // 声明并实例化对象
                   Person per2 = new Person() ;
                   per1.name = "张三" ;
                   per1.age = 20 ;
                   per2.name = "李四" ;
                   per2.age = 30 ;
                   per2 = per1 ;// 引用传递
                   per2.name = "王五" ;
                   per1.tell() ;
         }
}

对应的内存分配图如下：

垃圾：指的是在程序开发之中没有任何对象所指向的一块堆内存空间，这块空间就成为垃圾，所有的垃圾将等待GC（垃圾收集器）不定期的进行回收与空间的释放。

未完待续。。。

这段时间博主学习了一些Java中类和对象的知识，今天我们就来聊聊Java中的类和对象。

类和对象的关系。

类其实就是一个模板，比如说类就好比一张房子的设计图纸，或者说是一个倒印模具，创建一个类就好比设计一张图纸，刻一个模板。对象就好比一座建好的房子，一个成型的模型，无疑想要一座房子或者一个模型都先需要一张图纸和一个模板，而这就是类和对象的关系。

类的介绍

首先Java里面的类由关键字class定义,类中的元素称为：成员属性。类中的函数称为：成员方法。

class Person {
    public int age;//成员属性 实例变量
    public String name;
    public String sex;
    public void eat() {//成员方法
       System.out.println("吃饭!");  
   }
    public void sleep() {
       System.out.println("睡觉!");  
   }
}

如下就是定义一个类

class Person {
    public String name;
    public String sex;
    public int age;
    //....人的属性
}

然后拿这个类创建一个对象，然后我们可以通过点号 . 来访问这个对象的成员，看下图

Person person = new Person();//实例化一个对象

可以看到在没有赋值之前是会默认赋值为类型相对应的0值。

类型	对应的0值
整型	0
浮点型	0.0
字符类型r	/u0000
引用类型	null

注：这里之所以有默认的0值，是因为他们都是成员变量，不属于局部变量，所以有默认值，局部变量需要自己赋值才能使用。

类变量（静态变量）

所谓的类变量也就是静态变量，由关键字static修饰，存储在方法区，在类加载的时候就会分配空间，所以类变量是脱离对象的，就是说，就算没有实例化对象也是可以使用类变量的，看下图，没有对象依然可以通过 类名.变量名 使用类变量

同样的，由static修饰的方法也是类方法也叫静态方法，它和类变量具有相同的性质，类加载时分配空间，不依赖于实例化的对象，可以直接通过 类名.函数名() 调用。
如果不是静态的变量和方法，那么我们就需要先通过new关键字实例化一个对象才可以使用。

public && private

在类的定义中有许多的访问权限修饰符，而public和private是两个最常使用的，顾名思义，public修饰的变量是公开的，所谓的公开就是说可以直接访问，举个栗子

当我们使用public修饰成员变量时可以正常使用，通过点号访问对象的成员，但是当我们使用private修饰的时候，就会报错，因为private是私有的，只能在当前类里面使用，不能被外部引用。

如果要其他类中需要使用的话就需要提供公开的接口，给需要使用的类调用，简单来讲就是，我写个公开的方法，你把数据通过方法传给我，我自己来操作，比如以下方法，看名字也能知道这些方法的作用，我们来使用一下这些方法


可以看到，通过公开的接口我们可以对私有的成员变量进行一系列的操作，细心的小伙伴们可能会发现在setName等等方法里面都出现了 this.变量名那么这个是什么呢，this其实是一个关键字，表示当前方法的引用，那么为什么要有这个关键字呢，那是因为当变量名相同时，局部变量有限使用，可能会导致无法赋值等情况，看下图，当去掉this之后，名字明显为初始值，这就是因为局部变量优先使用的原因，导致类里面的成员变量没有被赋值。

一些建议和小结

1.建议实现类的时候将成员变量尽量设置为private属性，防止数据被直接篡改，而方法非必要公开的接口也设置为private属性的，具体根据实际情况来定

2.变量名和方法名使用小驼峰命名规则，尽量做到见名知意，做不到应该给上适当的中文注释，帮助其他人理解代码的意思

3.static修饰的代码和代码块优先于任何代码执行

4.一个类可以创建多个对象，很好理解，一张图纸可以建造多栋相同的房子，比如小区的楼房就是一张图纸建造出来的

5.在实例化一个对象的时候会调用一个构造方法，所谓的构造方法就一个名字与类名相同的方法，可以带参数，没有返回值类型声明，并且如果你没有定义的话，编译器就会自动实现一个不带参数的构造方法，如果你定义了，那么编译器就不会自动生成。并且构造方法也是支持重载的，构造方法的用处之一就是可以在创建对象的时候就进行赋值。


加上一句this.name ，就可以不需要setname了，只需要创建对象的时候，直接传参即可，其他的博主就不在赘述了。

写在最后的话

以上就是博主这段时间的学习内容，今天分享就到这里了，如果文章中有表达不清楚或者表述有错误的地方欢迎评论或者私信指出，博主会及时处理，好了本篇博客就到此结束了，我们下篇博客见。

对象在需求中的使用

在具体问题中如何使用面向对象去分析问题，和如何使用面向对象。

以把大象装冰箱为例进行分析：

在针对具体的需求，可以使用名词提炼的办法进行分析，寻找具体的对象。
需求：把大象装冰箱里
对象：大象、冰箱
分三步：
    1、打开冰箱门
    2、将大象装进去
    3、关闭冰箱门
分析发现打开、装、关闭都是冰箱的功能。即冰箱对象具备如下功能：
    1）冰箱打开
    2）冰箱存储
    3）冰箱关闭
用伪代码描述，上述需求中有两个具体的事物 大象 和  冰箱
描述大象：
    class 大象
        {
        }
描述冰箱
    class冰箱
        {
            void 打开(){}
            void 存储(大象){}
            void 关闭(){}
        }
当把具体的事物描述清楚之后，需要使用这些具体的事物，Java使用具体的事物，需要通过new关键字来创建这个事物的具体实例。
使用对象：
    1、创建冰箱的对象
        冰箱 bx = new 冰箱();  
    2、调用冰箱的功能
        对象.功能()；
        bx.打开();
        bx.存储(new 大象());
        bx.关闭();
总结：
1、先按照名词提炼问题领域中的对象
2、对对象进行描述，其实就是在明确对象中应该具备的属性和功能
3、通过new的方式就可以创建该事物的具体对象
4、通过该对象调用它以后的功能。

对象在代码中的体现

在分析现实生活中的事物时发现，这些事物都有其具体的特点和功能，这些特点和功能就组成了这个特殊的事物。
描述小汽车。
分析：
事物的特点（属性）：
颜色。
轮胎个数。
事物的(功能)：
运行。

发现：事物其实就是由特点（属性）和行为（功能）组成的。
可以简单理解：属性就是数值，其实就是变量；行为就是功能，就是方法。
小汽车 {
颜色；
轮胎个数；
运行() { }
}
通过计算机语言Java来描述这个事物。

定义类的格式

public class 类名 {
	//可编写0至n个属性
    数据类型 变量名1；
    数据类型 变量名2；
	
	//可编写0至n个方法
	修饰符 返回值类型 方法名(参数){
		执行语句;
}
}

汽车类

public class Car {
	String color;
	int number;

	void run() {
		System.out.println(color + ":" + number);
	}
}

通过代码的描述，知道类的真正意义就是在描述事物。属性和功能统称为事物中的成员。
事物的成员分为两种：成员属性和成员功能。
成员属性在代码中的体现就是成员变量
成员功能在代码中的体现就是成员方法

把写好的代码测试一下。需要一个可以独立运行类。

创建对象的格式：

类名 对象名 = new 类名();

测试类

public class CarDemo {
	public static void main(String[] args) { 
		/*
		 *  测试：Car类中的run方法。
		 */
		// 1,创建Car的对象。给对象起个名字。
		Car c = new Car();// c是类类型的变量。c指向了一个具体的Car类型的对象。
		// 2,通过已有的对象调用该对象的功能。格式：对象.对象成员;
		// 3,可以该对象的属性赋值。
		c.color = "red";
		c.number = 4;
		c.run();
	}
}

类和对象的区别

面向对象的编程思想力图在程序中对事物的描述与该事物在现实中的形态保持一致。为了做到这一点，面向对象的思想中提出两个概念，即类和对象。其中，类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体。接下来通过一个图例来抽象描述类与对象的关系，如下图所示。

在上图中，可以将玩具模型看作是一个类，将一个个玩具看作对象，从玩具模型和玩具之间的关系便可以看出类与对象之间的关系。类用于描述多个对象的共同特征，它是对象的模板。对象用于描述现实中的个体，它是类的实例。从上图中可以明显看出对象是根据类创建的，并且一个类可以对应多个对象，接下来分别讲解什么是类和对象。

经过前面几个知识点的学习，基本上掌握了类是用于描述事物的，类中可以定义事物的属性和行为。而对象是通过描述的这个类，使用new关键字创建出来，通过对象就可以调用该对象具体的属性和功能了。

局部变量和成员变量区别

理解清楚了类和对象之后，发现在描述类的属性定义变量差别不大，唯一区别就是位置发生了改变，那么类中定义的变量，和在方法定义的变量有什么差别呢？总结下面几点异同
区别一：定义的位置不同
    定义在类中的变量是成员变量
    定义在方法中或者{}语句里面的变量是局部变量
区别二：在内存中的位置不同
    成员变量存储在对内存的对象中
    局部变量存储在栈内存的方法中
区别三：声明周期不同
    成员变量随着对象的出现而出现在堆中，随着对象的消失而从堆中消失
    局部变量随着方法的运行而出现在栈中，随着方法的弹栈而消失
区别四：初始化不同
    成员变量因为在堆内存中，所有默认的初始化值

    局部变量没有默认的初始化值，必须手动的给其赋值才可以使用。

本文结。