Java基础——面向对象
在程序中，最核心的是数据结构和算法，不同的程序需要根据需要设计不同的数据结构，然后依赖程序的功能以及数据结构设计对应的算法，这种设计方式是程序的底层设计，也就是解决具体的功能。当程序项目复杂到一定程度时，就不仅要专注于底层的设计，更要对
程序的结构进行设计，面向对象(Object-Oriented，简称OO)就是一种常见的程序结构设计方法。
面向对象思想的基础是将相关的数据和方法放在一起，组合成一种新的复合数据类型，然后使用新创建的复合数据类型作为项目的基础。
面向对象简介
前面介绍的有关Java 语言的基础知识，只是程序的基础知识，而本章介绍的面向对象的相关知识，则是和设计有关的知识。
面向对象的设计方式采用的是从外到内的设计方式，先设计整个项目的结构，然后再根据关联关注内部的每个细节。再分解整个项目时，也是按照模块化进行分解的。就像要制造一辆汽车，面向对象的设计思路是这样的：首先汽车要生产发动机、变速箱等模块，然后再去考虑每个模块的具体实现。使用这种设计思路，把每个部分都模块化，便于将功能进行分解，可以开发更复杂的项目。再将模块划分出来以后，然后就来设计每个具体的模块，再设计模块时，如果模块还很复杂，则可以继续进行分解。如果模块已经划分的足够细致了，那么就可以进行具体的设计了。设计具体模块的方式是确定模块需要的核心数据的结构，以及该模块需要具备的功能，也就是本章一开始提到的数据结构和算法，使每个模块都成为一个独立的完整结构，可以向其它的模块提供对应的服务(功能)。整个系统(项目)则通过模块之间的互相关联运转起来，而每个模块只需要开放一个接口给其它的模块即可。
上面提到的就是面向对象的设计方式，总结起来是两大部分：
①：模块划分
②：模块实现
在具体的面向对象编程(Object-Oriented Programm，简称OOP)中，划分出来的每个模块一般称为类(class)，而模块内部的数据称为field，一般称为属性，模块内部的功能一般称为方法(method)。
按照面向对象的设计方式，在实际的项目开发过程中，面向对象技术一般分为3个部分：
①：面向对象分析(Object-Oriented Analysis，简称OOA)
该步骤按照面向对象的思考方式提取项目的需求信息，一般由系统分析员负责，本部分形成文档为《项目需求分析说明书》。
②：面向对象设计(Object-Oriented Design，简称OOD)
该步骤按照《项目需求分析说明书》进行模块划分，以及进行模块的概要设计，一般由高级程序员负责，本部分形成文档为《项目概要设计说明书》。
③：面向对象编程(Object-Oriented Programm，简称OOP)
该步骤按照《项目概要设计说明书》细化每个模块的结构，一般由程序员负责，本部分形成文档为《项目详细设计说明书》。
最后由编码员(Coder)按照《项目详细设计说明书》进行具体的编码。这个就是面向对象开发的标准过程的简单描述。而实际的程序开发过程中，则更关注于OOP 部分，也就是实际实现时的具体设计以及编码的问题。面向对象技术除了这些设计方式以外，还有很多的概念和语法知识需要在编程时进行学习，下面以Java 语言的语法为基础来介绍面向对象编程的内容。
------------------------------------------------------------------------------------------------------------------------------------------------------------------
类
类(class)是Java 语言的最小编程单位，也是设计和实现Java 程序的基础，本部分将深入介绍类的相关知识。
类的概念
类是一组事物共有特征和功能的描述。类是对于一组事物的总体描述，是按照面向对象技术进行设计时最小的单位，也是组成项目的最基本的模块。类的概念是抽象的，类似于建筑设计中的图纸，是对于现实需要代表的具体内容的抽象。类只包含框架结构，而不包含具体的数据。所以类代表的是总体，而不代表某个特定的个体。
例如设计电脑(computer)这个类，电脑是一组事物，则该类中包含的常见特征如下：
★类型：笔记本或台式机
★内存容量
★硬盘容量
★CPU 类型
★屏幕尺寸
★主板类型
对于每一台具体的电脑来说，每个特征都有自己具体的数值，或者说是将特征数据具体化，而类需要代表的是总体特征，只需要具备特征的类型和结构，不需要具有具体的数值，因为一般一组事物的某个特征的数值都是不尽相同的，但是都统一的具备该特征。同理，如果设计登录模块中的用户(user)类，则该类中包含的常见特征如下：
★用户名
★密码
对于每个具体的用户来说，都有自己特定的用户名和密码，但是对于用户这个类来说，只需要具备用户名和密码这两个特征的类型和结构即可。从这里也可以很直观的体会到，类是抽象的，是一组事物共有特征的描述。上面是对于类结构具体特征的描述，其实类中除了包含特征的描述以外，还可以包含该类事物共有的功能，这些功能也是类的核心内容。
例如电脑这个类，包含的基本功能有：
★打开
★关闭
用户这个类，包含的基本功能有：
程序的结构进行设计，面向对象(Object-Oriented，简称OO)就是一种常见的程序结构设计方法。
面向对象思想的基础是将相关的数据和方法放在一起，组合成一种新的复合数据类型，然后使用新创建的复合数据类型作为项目的基础。
面向对象简介
前面介绍的有关Java 语言的基础知识，只是程序的基础知识，而本章介绍的面向对象的相关知识，则是和设计有关的知识。
面向对象的设计方式采用的是从外到内的设计方式，先设计整个项目的结构，然后再根据关联关注内部的每个细节。再分解整个项目时，也是按照模块化进行分解的。就像要制造一辆汽车，面向对象的设计思路是这样的：首先汽车要生产发动机、变速箱等模块，然后再去考虑每个模块的具体实现。使用这种设计思路，把每个部分都模块化，便于将功能进行分解，可以开发更复杂的项目。再将模块划分出来以后，然后就来设计每个具体的模块，再设计模块时，如果模块还很复杂，则可以继续进行分解。如果模块已经划分的足够细致了，那么就可以进行具体的设计了。设计具体模块的方式是确定模块需要的核心数据的结构，以及该模块需要具备的功能，也就是本章一开始提到的数据结构和算法，使每个模块都成为一个独立的完整结构，可以向其它的模块提供对应的服务(功能)。整个系统(项目)则通过模块之间的互相关联运转起来，而每个模块只需要开放一个接口给其它的模块即可。
上面提到的就是面向对象的设计方式，总结起来是两大部分：
①：模块划分
②：模块实现
在具体的面向对象编程(Object-Oriented Programm，简称OOP)中，划分出来的每个模块一般称为类(class)，而模块内部的数据称为field，一般称为属性，模块内部的功能一般称为方法(method)。
按照面向对象的设计方式，在实际的项目开发过程中，面向对象技术一般分为3个部分：
①：面向对象分析(Object-Oriented Analysis，简称OOA)
该步骤按照面向对象的思考方式提取项目的需求信息，一般由系统分析员负责，本部分形成文档为《项目需求分析说明书》。
②：面向对象设计(Object-Oriented Design，简称OOD)
该步骤按照《项目需求分析说明书》进行模块划分，以及进行模块的概要设计，一般由高级程序员负责，本部分形成文档为《项目概要设计说明书》。
③：面向对象编程(Object-Oriented Programm，简称OOP)
该步骤按照《项目概要设计说明书》细化每个模块的结构，一般由程序员负责，本部分形成文档为《项目详细设计说明书》。
最后由编码员(Coder)按照《项目详细设计说明书》进行具体的编码。这个就是面向对象开发的标准过程的简单描述。而实际的程序开发过程中，则更关注于OOP 部分，也就是实际实现时的具体设计以及编码的问题。面向对象技术除了这些设计方式以外，还有很多的概念和语法知识需要在编程时进行学习，下面以Java 语言的语法为基础来介绍面向对象编程的内容。
------------------------------------------------------------------------------------------------------------------------------------------------------------------
类
类(class)是Java 语言的最小编程单位，也是设计和实现Java 程序的基础，本部分将深入介绍类的相关知识。
类的概念
类是一组事物共有特征和功能的描述。类是对于一组事物的总体描述，是按照面向对象技术进行设计时最小的单位，也是组成项目的最基本的模块。类的概念是抽象的，类似于建筑设计中的图纸，是对于现实需要代表的具体内容的抽象。类只包含框架结构，而不包含具体的数据。所以类代表的是总体，而不代表某个特定的个体。
例如设计电脑(computer)这个类，电脑是一组事物，则该类中包含的常见特征如下：
★类型：笔记本或台式机
★内存容量
★硬盘容量
★CPU 类型
★屏幕尺寸
★主板类型
对于每一台具体的电脑来说，每个特征都有自己具体的数值，或者说是将特征数据具体化，而类需要代表的是总体特征，只需要具备特征的类型和结构，不需要具有具体的数值，因为一般一组事物的某个特征的数值都是不尽相同的，但是都统一的具备该特征。同理，如果设计登录模块中的用户(user)类，则该类中包含的常见特征如下：
★用户名
★密码
对于每个具体的用户来说，都有自己特定的用户名和密码，但是对于用户这个类来说，只需要具备用户名和密码这两个特征的类型和结构即可。从这里也可以很直观的体会到，类是抽象的，是一组事物共有特征的描述。上面是对于类结构具体特征的描述，其实类中除了包含特征的描述以外，还可以包含该类事物共有的功能，这些功能也是类的核心内容。
例如电脑这个类，包含的基本功能有：
★打开
★关闭
用户这个类，包含的基本功能有：
★登录
通过在类的内部包含共有的功能，使得每个类都可以在内部实现一些规定的功能，从而减少和外部的交互，降低整个项目的复杂度。
这就是面向对象技术中类的概念的基本描述，每个类就代表一组事物，通过基本的特征和功能实现该类事物在项目内部的表达。以上是从设计角度理解类的概念，其实从语法角度理解类的概念也很简单，类就是一种复合数据类型，或者说是一种程序员设计的新类型。因为在实际开发中，程序员可以根据需要声明新的类，所以在面向对象的开发中，程序员可以根据需要设计新的数据类型——类，从而实现项目要求的功能。把设计角度中类的概念，转换为语法角度类的概念，是每个面向对象技术初学者都必须经历的阶段，通过进行该转换，可以把虚拟的类的概念转换成具体的类的概念，也是面向对象技术入门的标志。对于一组事物来说，共有的特征和功能有很多，在实际抽象成类时，只需要抽象出实际项目中的需要的属性和功能即可。
类的声明
类是一种复合数据类型，则声明一个类就相当于创建了一种新的数据类型，在面向对象技术中就通过不断的创建新的数据类型来增强程序可以代表的数据的能力。
类声明总体的语法格式如下：
访问控制符[修饰符] class 类名{
[属性声明]
[方法声明]
[构造方法声明]
}
说明：该语法格式中中括号内部的部分为可选。其中访问控制符用于限定声明的类在多大范围内可以被其它的类访问，主要有默认访问控制符(无关键字)和public；修饰符用于增强类的功能， 使声明的类具备某种特定的能力；class 是声明类时使用的关键字；类名是一个标识符，用于作为新声明的类的名称，要求必须符合标识符的命名规范。注：在Java 语言的编码规范中，类名第一个字母要求大写。例如如下示例：
public class Computer{}
class User{}
接着的大括号内部用于声明类的内部结构，类内部一般包括三类声明,且这三类声明都是可选的。说明如下：
★属性声明
用于代表共有特征
★方法声明
用于代码共有功能
★构造方法声明
用于初始化类的变量下面是这些声明的详细说明。
★属性声明
属性，有些翻译为域、字段等，属性是类内部代表共有特征的结构，或者可以把属性理解为类的某个具体特征，类通过一系列的属性来代表一种新的数据类型。对于类比较基础的理解就是通过多个属性组合成的新的数据类型，这也是复合数据类型的由来。
属性声明的语法格式如下：
访问控制符[修饰符] 数据类型 属性名[=值];
属性的访问控制符限定该属性被访问的范围，包含如下四种：public、protected、默认的(无关键字)和private，分别代表不同的访问限制，具体的限制范围后续将有详细说明。修饰符用于使属性具备某种特定的功能。数据类型为该属性的类型，可以是Java 语言中的任意数据类型，也就是说，既可以是基本数据类型也可以是复合数据类型。属性名是一个标识符，用于代表该属性的名称，在声明属性时的同时可以为该属性进行赋值。
示例格式为：
public int cpuType;
public char sex = ‘男';
在实际声明属性时，也可以一次声明多个属性,例如：
public int x = 10, y = 20;
不过为了程序结构的清晰，一般书写为如下格式：
public int x = 10;
public int y = 20;
另外，属性的作用范围是类的内部，可以在类内部的任何位置引用属性，包括在方法和构造方法的内部，而不论属性是否声明在方法的上面。 总得来说，类就是通过一系列属性的组合成为一种新的数据类型，从而可以代表一种更复杂的结构，也相当于为程序员提供了一种组合已有数据类型形成新数据类型的方法，从而更直观的去代表代表需要表达的数据。
方法声明
方法在类的内部代表该类具有的共有功能，将这些功能以方法的形式放置在类的内部，可以在需要时进行调用。方法的声明和前面讲解的方法一致，只是在类内部增加了属性以后，可以在方法内部直接进行访问，而不需要进行参数传递了。
关于方法的声明示例如下：
public class Box{
int width;
int height;
int length;
public int vol(){
return width * height * length;
}
}
在该示例中，声明了一个名字为Box 的类，假设使用这个类来代表箱子，其中包含三个属性：length、width 和height，依次代表箱子的长宽高，则在该类内部包含一个基本的功能，求箱子体积的vol 方法，该方法的功能是计算箱子的体积。
下面是关于上面提到的用户类的基本实现,示例代码如下：
public class User{
public String username;
public String password;
public boolean login(){
逻辑代码
}
}
通过在类的内部包含共有的功能，使得每个类都可以在内部实现一些规定的功能，从而减少和外部的交互，降低整个项目的复杂度。
这就是面向对象技术中类的概念的基本描述，每个类就代表一组事物，通过基本的特征和功能实现该类事物在项目内部的表达。以上是从设计角度理解类的概念，其实从语法角度理解类的概念也很简单，类就是一种复合数据类型，或者说是一种程序员设计的新类型。因为在实际开发中，程序员可以根据需要声明新的类，所以在面向对象的开发中，程序员可以根据需要设计新的数据类型——类，从而实现项目要求的功能。把设计角度中类的概念，转换为语法角度类的概念，是每个面向对象技术初学者都必须经历的阶段，通过进行该转换，可以把虚拟的类的概念转换成具体的类的概念，也是面向对象技术入门的标志。对于一组事物来说，共有的特征和功能有很多，在实际抽象成类时，只需要抽象出实际项目中的需要的属性和功能即可。
类的声明
类是一种复合数据类型，则声明一个类就相当于创建了一种新的数据类型，在面向对象技术中就通过不断的创建新的数据类型来增强程序可以代表的数据的能力。
类声明总体的语法格式如下：
访问控制符[修饰符] class 类名{
[属性声明]
[方法声明]
[构造方法声明]
}
说明：该语法格式中中括号内部的部分为可选。其中访问控制符用于限定声明的类在多大范围内可以被其它的类访问，主要有默认访问控制符(无关键字)和public；修饰符用于增强类的功能， 使声明的类具备某种特定的能力；class 是声明类时使用的关键字；类名是一个标识符，用于作为新声明的类的名称，要求必须符合标识符的命名规范。注：在Java 语言的编码规范中，类名第一个字母要求大写。例如如下示例：
public class Computer{}
class User{}
接着的大括号内部用于声明类的内部结构，类内部一般包括三类声明,且这三类声明都是可选的。说明如下：
★属性声明
用于代表共有特征
★方法声明
用于代码共有功能
★构造方法声明
用于初始化类的变量下面是这些声明的详细说明。
★属性声明
属性，有些翻译为域、字段等，属性是类内部代表共有特征的结构，或者可以把属性理解为类的某个具体特征，类通过一系列的属性来代表一种新的数据类型。对于类比较基础的理解就是通过多个属性组合成的新的数据类型，这也是复合数据类型的由来。
属性声明的语法格式如下：
访问控制符[修饰符] 数据类型 属性名[=值];
属性的访问控制符限定该属性被访问的范围，包含如下四种：public、protected、默认的(无关键字)和private，分别代表不同的访问限制，具体的限制范围后续将有详细说明。修饰符用于使属性具备某种特定的功能。数据类型为该属性的类型，可以是Java 语言中的任意数据类型，也就是说，既可以是基本数据类型也可以是复合数据类型。属性名是一个标识符，用于代表该属性的名称，在声明属性时的同时可以为该属性进行赋值。
示例格式为：
public int cpuType;
public char sex = ‘男';
在实际声明属性时，也可以一次声明多个属性,例如：
public int x = 10, y = 20;
不过为了程序结构的清晰，一般书写为如下格式：
public int x = 10;
public int y = 20;
另外，属性的作用范围是类的内部，可以在类内部的任何位置引用属性，包括在方法和构造方法的内部，而不论属性是否声明在方法的上面。 总得来说，类就是通过一系列属性的组合成为一种新的数据类型，从而可以代表一种更复杂的结构，也相当于为程序员提供了一种组合已有数据类型形成新数据类型的方法，从而更直观的去代表代表需要表达的数据。
方法声明
方法在类的内部代表该类具有的共有功能，将这些功能以方法的形式放置在类的内部，可以在需要时进行调用。方法的声明和前面讲解的方法一致，只是在类内部增加了属性以后，可以在方法内部直接进行访问，而不需要进行参数传递了。
关于方法的声明示例如下：
public class Box{
int width;
int height;
int length;
public int vol(){
return width * height * length;
}
}
在该示例中，声明了一个名字为Box 的类，假设使用这个类来代表箱子，其中包含三个属性：length、width 和height，依次代表箱子的长宽高，则在该类内部包含一个基本的功能，求箱子体积的vol 方法，该方法的功能是计算箱子的体积。
下面是关于上面提到的用户类的基本实现,示例代码如下：
public class User{
public String username;
public String password;
public boolean login(){
逻辑代码
}
}
在User 类的内部，包含用户名和密码这两个属性，根据需要选择Java语言提供的String 字符串类型进行代表，然后在该类的内部声明登录的login方法，在方法内部根据逻辑书写对应的实现代码。
构造方法声明
构造方法(Constructor)，也称作构造函数、构建器等，是初学者在学习时最容易混淆的概念之一。下面首先讲述构造方法和方法的区别。构造方法和方法无任何关系，只是在翻译时名称比较类似罢了。而且构造方法和方法的功能不同，声明和调用的语法也不相同。
构造方法的功能：实现类这种数据类型的变量的初始化。由于类是一种复合数据类型，而复合数据类型的变量也比较复杂，所以专门需要对该类变量进行初始化，则语法上提供了专门的结构——构造方法。这就是构造方法出现的原因。而方法实现的是逻辑的功能，对应于逻辑上的算法，更多的是实现程序逻辑。所以构造方法是语法结构，而方法是逻辑功能，两者之间根本无关。
构造方法声明的语法格式：
访问控制 符构造方法名称(参数列表){
构造方法体;
}
在该语法中，访问控制符指声明的构造方法被访问的权限，构造方法名称是标识符，语法上要求构造方法的名称必须类名相同，后续小括号内部是参数列表，其语法格式和方法参数列表的语法格式相同。
下面是构造方法的示例：
public class Box{
int length;
int width;
int height;
public Box(){
length = 10;
width = 10;
height = 10;
}
public Box(int l,int w,int h){
length = l;
width = w;
height = h;
}
}
在该Box 类中，声明了两个构造方法，一个没有参数，一个包含三个int 类型的参数。在没有参数的构造方法中，将三个属性的值都初始化为10。带参数的构造方法中，可以传递进来三个参数，然后在构造方法内部依次把参数的值赋值给属性。通常情况下，构造方法的声明放在属性声明和方法声明的中间。一个类内部的构造方法可以有任意多个，但是要求这些构造方法不能相同。因为在一个类内部构造方法的名称都是相同的，所以只要参数列表相同的构造方法都是相同的构造方法。例如以下两个构造方法是相同的：
public Test(int a,int[] b){}
public Test(int b,int[] a){}
如果一个类声明中不包含构造方法的声明，则系统会自动为该类添加一个构造方法，当然如果类中已声明了构造方法则系统不会添加，这个系统自动添加的构造方法一般被称为默认构造方法，其声明格式如下：
public 构造方法名称(){}
所以以下两个代码是相同的：
public class DefaultConstructor{
int a;
}
和
public class DefaultConstructor{
int a;
public DefaultConstructor(){}
}
在第一个代码中，没有声明构造方法，则系统自动添加默认的构造方法，而第二个代码中声明的构造方法和默认构造方法的结构一致，所以两个代码在功能上是完全相同的。总之，构造方法是系统提供的一个结构，该结构的功能是实现对于类的变量的初始化，可以根据逻辑的需要声明对应的构造方法，并在构造方法内部根据需要进行具体的初始化。
面向对象基础使用
下面以一个简单的示例来描述面向对象的基本使用，主要是类声明的相关语法，以及基础的类设计的知识。使用面向对象的方式来描述房屋的结构，要求如下：
①： 门：（颜色为红色、可以被推开和关闭）
②：窗户：（颜色为白色、有一块玻璃(透明色、可以卸下)、可以被推开和关闭）
③：地：(由100 块地板砖组成)
④：地板砖：(黄色、长1 米、宽1 米)
说明：其中红色用1 代替，白色用2 代替，黄色用3 代替透明色用0 代替。在使用面向对象描述时，将其中的名词转换为类，将该类内部的特征转换为属性，将该类内部的功能转换为方法，在构造方法内部实现对于属性的初始化。则在该要求中，抽象的类一共有5 个：门、窗户、玻璃、地和地板砖。其中的颜色作为对应类的属性，推开和关闭作为对应类的方法。前面介绍过类是一种数据类型，则可以声明类类型的变量，并可以将该变量作为类的属性，这种类和类的关系在面向对象中称作使用关系。
则按照该思路实现的代码如下：
/**
* 门的类
* 文件名：Door.java
*/
public class Door {
/**颜色*/
int color;
public Door(){
color = 1; //初始化颜色
}
public void open(){}
public void close(){}
}
/**
* 窗的类
* 文件名：Window.java
*/
public class Window {
/**颜色*/
int color;
public Window(){
color = 2; //初始化颜色
}
public void open(){}
public void close(){}
}
/**
* 玻璃类
* 文件名：Glass.java
*/
public class Glass {
/**颜色*/
int color;
public Glass(){
color = 0; //初始化颜色
}
public void remove(){}
}
/**
* 地板类
* 文件名：Floor.java
*/
public class Floor {
FloorBrick[] fb;
public Floor(){
fb = new FloorBrick[100];
for(int i = 0;i < fb.length;i++){
fb[i] = new FloorBrick(); //初始化每个元素
}
}
}
/**
* 地板砖类
* 文件名：FloorBrick.java
*/
public class FloorBrick {
/**颜色*/
int color;
/**长度*/
int length;
/**宽度*/
int width;
public FloorBrick(){
color = 3; //初始化颜色
length = 1; //初始化长度
width = 1; //初始化宽度
}
}
说明：在Floor 类的代码中涉及到对于类类型的变量初始化的问题，相关语法将在后续详细介绍。在该示例中，使用面向对象的思想描述了要求的房屋结构，并以Java语言语法的格式将面向对象的思想转化为具体的代码，从而实现对于面向对象技术的基本使用。
----------------------------------------------------------------------------------------------------------------------------------------------------------------
对象
对象(Object)是面向对象技术的核心，按照面向对象的思考方式，现实中的每个实体都是一个对象，比如一个人、数据库中的一张表等，总结起来，就是面向对象技术中的经典语句——万事万物皆对象。
什么是对象？
其实面向对象技术只是提供了一种思考的方式，其思考方式就是把一个复杂的结构看成是一个整体，这样可以降低认知的复杂性。比如认识一个电脑，按照面向对象的认知方式，就是先把电脑分成一个个的对象：显示器对象、硬盘对象、CPU 对象等等，然后再一个一个的进行认知。同时面向对象技术也是一种设计方式，其设计方式是把一个负责的模块划分为一个个小的模块分开进行设计，这样可以降低设计的复杂性。比如设计一个电脑，按照面向对象的设计方式，就是把电脑分成一个个的对象：显示器对象、硬盘对象、CPU 对象等等，然后再一个一个的进行设计。正因为面向对象无论在认知和设计方面都降低了复杂性，所以在程序设计语言中得到了广泛的应用。其实也就是是对现实已存在的内容的升华，所以面向对象存在于生活的很多方面，并不是计算机程序设计领域里的“阳春白雪”。
在语法角度来看，对象就是一个变量，只是该变量比较复杂，其内部既包含属性(数据)，也包含方法(功能)。在Java 语言中，把复合数据类型(包括数组、类和接口)的变量都称作对象。所以对象的概念相对来说，就显得跟具体了。每个对象中存储类中对应属性的数值，或者从数据角度来理解对象的话，也可以把对象看作是类似C 语言中结构体变量类似的结构。
下面来介绍一下Java 语言中对象相关的语法。
对象的语法
对象相关的语法主要包含四个部分：对象的声明、对象的初始化、引用对象中的属性和引用对象中的方法。
例如，有如下一个类的代码：
public class Box{
/**长度*/
int length;
/**宽度*/
int width;
/**高度*/
int height;
public Box(){
length = 10;
width = 10;
height = 10;
}
public Box(int l,int w,int h){
length = l;
width = w;
height = h;
}
/**求体积的方法*/
public int volume(){
return length * width * height;
}
}
对象的声明
对象的声明，就是声明一个变量，其语法格式和变量声明的语法完全相同，格式如下：
数据类型 对象名;
这里要求数据类型必须为复合数据类型，基本数据类型声明的结构只能称为变量，而不能称为对象。
示例代码：
Box b;
这里声明了一个Box 类型的对象b，该对象在内存中不占用存储空间，其值为null。当然声明对象时也可以采用如下格式：
Box b,b1;
对象的初始化
由于只声明的对象在内存中没有存储空间，所以需要为对象在内存中申请空间，并初始化各个属性的值，这个过程称作对象的初始化。
对象的初始化，都是通过直接或间接调用构造方法实现。
对象的初始化可以和对象的声明写在一起，也可以分开进行书写，其语法格式如下：
对象名= new 构造方法(参数);
例如：
Box b = new Box();
Box b1;
b1 = new Box(2,3,4);
其中对象b 使用Box 类中不带参数的构造方法进行初始化，按照Box类的结构，对象b 中每个属性的值被都被初始化为10。而对象b1 使用Box 类中带参数的构造方法进行初始化，依据构造方法的结构，依次指定对象b1 中的长、宽、高依次是2、3、4。在初始化对象时，调用的构造方法必须在类中声明过，否则不能调用。因为类名和构造方法的名称相同，所以名称一般不容易发生错误，在实际使用时注意参数列表的结构也需要匹配。有些时候，因为某些原因，把构造方法隐藏起来，这个时候可以使用其它的途径来创建对象，例如使用某些方法的返回值进行初始化等。对象在初始化以后就可以进行使用了。
引用对象中的属性
对象是一个复合变量，很多时候需要引用对象内部的某一个属性，其语法格式为：
对象名.属性名
该语法中“.”代表引用，使用该表达式可以引用对象内部的属性，则该表达式的类型和该属性在类中声明的类型一致。
例如：
b.width = 5;
该语法中，b 是对象名，width 是对象b 中的属性，因为在类Box 中width 属性的类型是int 型，则该表达式的类型也是int 类型，在程序中可以把该表达式看成是int 类型的变量进行实际使用。而在实际的面向对象程序中，一般都避免使用对象直接引用属性(使用访问控制符实现访问限制)，而替代的以getter 和setter 方法进行访问。
引用对象中的方法
如果需要执行对象内部的功能，则需要引用对象中的方法，也就是面向对象术语中的“消息传递”，其语法格式如下：
对象名.方法名(参数)
这里“.”也代表引用，使用该代码可以引用对象内部的方法，该语法中的参数必须和引用方法的声明结构匹配。
例如：
int v= b.volume();
这里引用对象b 中的volume 方法，实现的功能是求对象b 的体积，并且把求得的体积赋值给变量v。在实际的项目中，通过引用对象中的方法实现项目中信息的传递以及功能的实现，通过对象和对象之间的关联，构造成一个有机的系统，从而代表实际项目中标的各种需求。对象相关的语法就介绍这么多，在后续的学习中将经常用到。
对象的存储形式
对象是一个复合数据类型的变量，其存储方式和一般变量的存储方式也不相同。在Java 的执行环境中，存储区域一般分为两类：
①：栈内存——该区域存储基本数据类型
②：堆内存——存储实际的对象内容。
而实际的对象存储比一般变量复杂，对象的存储分为两部分：对象的内容、对象内容的起始地址。
构造方法声明
构造方法(Constructor)，也称作构造函数、构建器等，是初学者在学习时最容易混淆的概念之一。下面首先讲述构造方法和方法的区别。构造方法和方法无任何关系，只是在翻译时名称比较类似罢了。而且构造方法和方法的功能不同，声明和调用的语法也不相同。
构造方法的功能：实现类这种数据类型的变量的初始化。由于类是一种复合数据类型，而复合数据类型的变量也比较复杂，所以专门需要对该类变量进行初始化，则语法上提供了专门的结构——构造方法。这就是构造方法出现的原因。而方法实现的是逻辑的功能，对应于逻辑上的算法，更多的是实现程序逻辑。所以构造方法是语法结构，而方法是逻辑功能，两者之间根本无关。
构造方法声明的语法格式：
访问控制 符构造方法名称(参数列表){
构造方法体;
}
在该语法中，访问控制符指声明的构造方法被访问的权限，构造方法名称是标识符，语法上要求构造方法的名称必须类名相同，后续小括号内部是参数列表，其语法格式和方法参数列表的语法格式相同。
下面是构造方法的示例：
public class Box{
int length;
int width;
int height;
public Box(){
length = 10;
width = 10;
height = 10;
}
public Box(int l,int w,int h){
length = l;
width = w;
height = h;
}
}
在该Box 类中，声明了两个构造方法，一个没有参数，一个包含三个int 类型的参数。在没有参数的构造方法中，将三个属性的值都初始化为10。带参数的构造方法中，可以传递进来三个参数，然后在构造方法内部依次把参数的值赋值给属性。通常情况下，构造方法的声明放在属性声明和方法声明的中间。一个类内部的构造方法可以有任意多个，但是要求这些构造方法不能相同。因为在一个类内部构造方法的名称都是相同的，所以只要参数列表相同的构造方法都是相同的构造方法。例如以下两个构造方法是相同的：
public Test(int a,int[] b){}
public Test(int b,int[] a){}
如果一个类声明中不包含构造方法的声明，则系统会自动为该类添加一个构造方法，当然如果类中已声明了构造方法则系统不会添加，这个系统自动添加的构造方法一般被称为默认构造方法，其声明格式如下：
public 构造方法名称(){}
所以以下两个代码是相同的：
public class DefaultConstructor{
int a;
}
和
public class DefaultConstructor{
int a;
public DefaultConstructor(){}
}
在第一个代码中，没有声明构造方法，则系统自动添加默认的构造方法，而第二个代码中声明的构造方法和默认构造方法的结构一致，所以两个代码在功能上是完全相同的。总之，构造方法是系统提供的一个结构，该结构的功能是实现对于类的变量的初始化，可以根据逻辑的需要声明对应的构造方法，并在构造方法内部根据需要进行具体的初始化。
面向对象基础使用
下面以一个简单的示例来描述面向对象的基本使用，主要是类声明的相关语法，以及基础的类设计的知识。使用面向对象的方式来描述房屋的结构，要求如下：
①： 门：（颜色为红色、可以被推开和关闭）
②：窗户：（颜色为白色、有一块玻璃(透明色、可以卸下)、可以被推开和关闭）
③：地：(由100 块地板砖组成)
④：地板砖：(黄色、长1 米、宽1 米)
说明：其中红色用1 代替，白色用2 代替，黄色用3 代替透明色用0 代替。在使用面向对象描述时，将其中的名词转换为类，将该类内部的特征转换为属性，将该类内部的功能转换为方法，在构造方法内部实现对于属性的初始化。则在该要求中，抽象的类一共有5 个：门、窗户、玻璃、地和地板砖。其中的颜色作为对应类的属性，推开和关闭作为对应类的方法。前面介绍过类是一种数据类型，则可以声明类类型的变量，并可以将该变量作为类的属性，这种类和类的关系在面向对象中称作使用关系。
则按照该思路实现的代码如下：
/**
* 门的类
* 文件名：Door.java
*/
public class Door {
/**颜色*/
int color;
public Door(){
color = 1; //初始化颜色
}
public void open(){}
public void close(){}
}
/**
* 窗的类
* 文件名：Window.java
*/
public class Window {
/**颜色*/
int color;
public Window(){
color = 2; //初始化颜色
}
public void open(){}
public void close(){}
}
/**
* 玻璃类
* 文件名：Glass.java
*/
public class Glass {
/**颜色*/
int color;
public Glass(){
color = 0; //初始化颜色
}
public void remove(){}
}
/**
* 地板类
* 文件名：Floor.java
*/
public class Floor {
FloorBrick[] fb;
public Floor(){
fb = new FloorBrick[100];
for(int i = 0;i < fb.length;i++){
fb[i] = new FloorBrick(); //初始化每个元素
}
}
}
/**
* 地板砖类
* 文件名：FloorBrick.java
*/
public class FloorBrick {
/**颜色*/
int color;
/**长度*/
int length;
/**宽度*/
int width;
public FloorBrick(){
color = 3; //初始化颜色
length = 1; //初始化长度
width = 1; //初始化宽度
}
}
说明：在Floor 类的代码中涉及到对于类类型的变量初始化的问题，相关语法将在后续详细介绍。在该示例中，使用面向对象的思想描述了要求的房屋结构，并以Java语言语法的格式将面向对象的思想转化为具体的代码，从而实现对于面向对象技术的基本使用。
----------------------------------------------------------------------------------------------------------------------------------------------------------------
对象
对象(Object)是面向对象技术的核心，按照面向对象的思考方式，现实中的每个实体都是一个对象，比如一个人、数据库中的一张表等，总结起来，就是面向对象技术中的经典语句——万事万物皆对象。
什么是对象？
其实面向对象技术只是提供了一种思考的方式，其思考方式就是把一个复杂的结构看成是一个整体，这样可以降低认知的复杂性。比如认识一个电脑，按照面向对象的认知方式，就是先把电脑分成一个个的对象：显示器对象、硬盘对象、CPU 对象等等，然后再一个一个的进行认知。同时面向对象技术也是一种设计方式，其设计方式是把一个负责的模块划分为一个个小的模块分开进行设计，这样可以降低设计的复杂性。比如设计一个电脑，按照面向对象的设计方式，就是把电脑分成一个个的对象：显示器对象、硬盘对象、CPU 对象等等，然后再一个一个的进行设计。正因为面向对象无论在认知和设计方面都降低了复杂性，所以在程序设计语言中得到了广泛的应用。其实也就是是对现实已存在的内容的升华，所以面向对象存在于生活的很多方面，并不是计算机程序设计领域里的“阳春白雪”。
在语法角度来看，对象就是一个变量，只是该变量比较复杂，其内部既包含属性(数据)，也包含方法(功能)。在Java 语言中，把复合数据类型(包括数组、类和接口)的变量都称作对象。所以对象的概念相对来说，就显得跟具体了。每个对象中存储类中对应属性的数值，或者从数据角度来理解对象的话，也可以把对象看作是类似C 语言中结构体变量类似的结构。
下面来介绍一下Java 语言中对象相关的语法。
对象的语法
对象相关的语法主要包含四个部分：对象的声明、对象的初始化、引用对象中的属性和引用对象中的方法。
例如，有如下一个类的代码：
public class Box{
/**长度*/
int length;
/**宽度*/
int width;
/**高度*/
int height;
public Box(){
length = 10;
width = 10;
height = 10;
}
public Box(int l,int w,int h){
length = l;
width = w;
height = h;
}
/**求体积的方法*/
public int volume(){
return length * width * height;
}
}
对象的声明
对象的声明，就是声明一个变量，其语法格式和变量声明的语法完全相同，格式如下：
数据类型 对象名;
这里要求数据类型必须为复合数据类型，基本数据类型声明的结构只能称为变量，而不能称为对象。
示例代码：
Box b;
这里声明了一个Box 类型的对象b，该对象在内存中不占用存储空间，其值为null。当然声明对象时也可以采用如下格式：
Box b,b1;
对象的初始化
由于只声明的对象在内存中没有存储空间，所以需要为对象在内存中申请空间，并初始化各个属性的值，这个过程称作对象的初始化。
对象的初始化，都是通过直接或间接调用构造方法实现。
对象的初始化可以和对象的声明写在一起，也可以分开进行书写，其语法格式如下：
对象名= new 构造方法(参数);
例如：
Box b = new Box();
Box b1;
b1 = new Box(2,3,4);
其中对象b 使用Box 类中不带参数的构造方法进行初始化，按照Box类的结构，对象b 中每个属性的值被都被初始化为10。而对象b1 使用Box 类中带参数的构造方法进行初始化，依据构造方法的结构，依次指定对象b1 中的长、宽、高依次是2、3、4。在初始化对象时，调用的构造方法必须在类中声明过，否则不能调用。因为类名和构造方法的名称相同，所以名称一般不容易发生错误，在实际使用时注意参数列表的结构也需要匹配。有些时候，因为某些原因，把构造方法隐藏起来，这个时候可以使用其它的途径来创建对象，例如使用某些方法的返回值进行初始化等。对象在初始化以后就可以进行使用了。
引用对象中的属性
对象是一个复合变量，很多时候需要引用对象内部的某一个属性，其语法格式为：
对象名.属性名
该语法中“.”代表引用，使用该表达式可以引用对象内部的属性，则该表达式的类型和该属性在类中声明的类型一致。
例如：
b.width = 5;
该语法中，b 是对象名，width 是对象b 中的属性，因为在类Box 中width 属性的类型是int 型，则该表达式的类型也是int 类型，在程序中可以把该表达式看成是int 类型的变量进行实际使用。而在实际的面向对象程序中，一般都避免使用对象直接引用属性(使用访问控制符实现访问限制)，而替代的以getter 和setter 方法进行访问。
引用对象中的方法
如果需要执行对象内部的功能，则需要引用对象中的方法，也就是面向对象术语中的“消息传递”，其语法格式如下：
对象名.方法名(参数)
这里“.”也代表引用，使用该代码可以引用对象内部的方法，该语法中的参数必须和引用方法的声明结构匹配。
例如：
int v= b.volume();
这里引用对象b 中的volume 方法，实现的功能是求对象b 的体积，并且把求得的体积赋值给变量v。在实际的项目中，通过引用对象中的方法实现项目中信息的传递以及功能的实现，通过对象和对象之间的关联，构造成一个有机的系统，从而代表实际项目中标的各种需求。对象相关的语法就介绍这么多，在后续的学习中将经常用到。
对象的存储形式
对象是一个复合数据类型的变量，其存储方式和一般变量的存储方式也不相同。在Java 的执行环境中，存储区域一般分为两类：
①：栈内存——该区域存储基本数据类型
②：堆内存——存储实际的对象内容。
而实际的对象存储比一般变量复杂，对象的存储分为两部分：对象的内容、对象内容的起始地址。