今天要说的是 Java 中两个非常重要的概念——类和对象。
什么是类，什么又是对象呢？类是对特定集合的概括描述，比如，人，这个类，外在特征上，有名字，有年龄，能说话，能吃饭等等，这是我们作为人类的相同特征，那么对象呢？我们口口声声说要面向对象编程，可是找了这么久也没找到对象，这还怎么编程（滑稽）。此对象非彼对象，Java 中的对象是某个具体类的实例，就好比你和我都是人类这个大类的一个实例个体，也就是说，我们都是人类的一个具体对象，我们有各自的名字和年龄。
那为什么要用类和对象这样的概念呢？
这是一个好问题，类是从面向过程编程向面向对象编程转变的产物。以前的程序，用 C 语言为例子，设计程序是算法 + 数据结构的集合，先设计算法，然后再选择合适的数据结构去使用算法。而现在面向对象编程则刚好相反，先选择合适的数据结构，再设计相应的算法来解决问题。简单来说，面向过程注重考虑的是事情该怎么做，采用的是上帝视角来处理事情，而面向对象注重的是事情该谁来做，里面的主角是各钟类型的对象。面向过程是由上而下的解决问题，而面向对象则是由下而上
来举一个生动形象的栗子，双十一快到了，该准备剁手了，那具体的剁手步骤呢？
面向过程是这样的：先设置好预算 budget，然后选择商品 A,B,C,D，一个个加入收藏，等待双十一，付款，完成。一步一步有条不紊的进行。各个商品的名称价格信息分别用两个字符串数组进行存储和处理。
而面向对象则是这样的：因为需要处理的商品数据，因此可以构建一个商品类 Goods，商品类有名称，链接，价格等属性，此外还需要进行商品预算管理，因此可以构建一个购物车类 Cart，对商品进行预算进行统计管理，添加商品，删除商品等方法，然后再设置一个 Money 类来对财务进行统一管理，有设置预算，支付等方法，构建好这几个类之后，需要做的就是新建商品对象，往购物车里添加商品对象，然后等待双十一，付款，完成。
面向对象的思想中，主体是对象，通过对象与对象之间的交互来解决问题，就像上面那样，关注的是商品等对象，而面向过程则关注的是如何解决问题，即如何在预算范围内买到合适的商品。
当然，你也许会说，这样一看，似乎面向对象更加复杂也更加麻烦，对于简单的问题，确实如此，因为面向对象的出现本身是为了解决那些复杂的项目，并提供更好的维护方法。所以往往越是复杂的问题，越能体现出面向对象的优越性。那问题来了，既然如此，我举上面那个栗子来打脸干嘛呢？？？切莫着急，等说完后面的内容，最后再来回过头看看这个问题，就知道怎么回事了。
那现在来看看 Java 中的类到底是什么样的，按惯例先举个小栗子：
class Goods{
String title;
double price;
}
这里定义了一个最简单的类，因为仅做示例用，它实际上并没有什么卵用，只是为了说明类的一般定义方式，即 class + 类名后面再接大括号，在大括号里面写上类的属性及方法。这里的 title 跟 price 都是在类中定义的，也叫做类成员变量，一般在类的最前端定义我们需要关注的数据变量或者对象，这一部分也称为类的实例域。类定义好了，我们需要使用的话怎么使用呢？这时候需要用到 new 关键字来创建类的实例，也就是对象。
public class Test{
public static void main(String[] args) {
Goods goodsA = new Goods();
goodsA.price=1.1;
goodsA.title="123";
System.out.println(goodsA.price);
}
}
class Goods{
String title;
double price;
}
这里是在同一个文件下定义和使用类，而实际上，为了便于管理，通常把每个类放到单独的文件中，并用类名来定义文件名，比如 Goods 类放到 Goods.java 文件中，而 Test 则放在 Test.java 文件中，那一个文件中引用另一个文件中定义的类，会不会报错呢？答案是不会的，编译器会自动帮我们寻找，只要按规范书写类名及文件名即可。当然使用 IDE 的话，在开头会声明类所属的包，关于包的概念在之前已有阐述，这里就不做过多介绍了。编译器会自动在包中寻找相应的类。但是需要在 Goods 的定义前加上 public 关键字，表示可以被外部类调用。如果需要使用其他包中的类，则需要使用 import 关键字来导入类，如，import java.util.*；这里的 * 代表导入 java.util 下的所有类，导入之后就能像一般类一样正常使用了。
现在定义的类，只有属性，没有方法，看起来就像是一个将两个数据捆绑在一个类中而已，就像 C 语言中的 struct。接下来，我们要扩展这个类。
首先，我们需要初始化我们的商品标题和价格，这里为了用做介绍，强行使用了初始化块（滑稽）。
public class Goods{
String title;
double price;
{
title = "";
price = 0.0;
}
}
初始化块，顾名思义，就是专门用做初始化的代码块，会在类初始化的时候先于构造器运行，因为某些变量的初始化并不是赋值这么简单，需要经过一些骚操作才能实现，而如果放到构造器中，会显得臃肿，特别是有多个构造器的时候。所以这里的初始化块是大材小用系列。完全可以写成以下形式，这里只是为了介绍初始化块而强行加上的内容。
public class Goods{
String title=”“;
double price=0.0;
}
接下来加上一个构造器，什么是构造器？就是构造这个类的一个特殊方法，每个类都至少有一个构造器。那上面的栗子不是没有吗？事实上，如果没有显式的添加构造器方法，系统会提供一个默认的无参构造器，但是这个构造器什么也不做，所以才会毫无存在感。现在我们要赋予它神圣的使命，让它变得有价值起来。
public class Goods{
String title="";
double price=0.0;
public Goods(String aTitle,double aPrice){
title = aTitle;
price = aPrice;
}
}
构造器的名称跟类名一致，前面加上 public 修饰符，小括号内是参数列表，这里用了两个参数，分别用来指定类的 title 跟 price 信息。这样，之前 Test 类就可以这样写了。
public class Test{
public static void main(String[] args) {
Goods goodsA = new Goods("123",1.1);
System.out.println(goodsA.price);
}
}
这样使用起来是不是更加简单粗暴，一般的简单初始化代码也会放到构造器中进行。我们还可以定义多个构造器。
public class Goods{
String title="";
double price=0.0;
public Goods(String aTitle,double aPrice){
title = aTitle;
price = aPrice;
}
public Goods(double aPrice){
price = aPrice;
title = "Goods";
}
}
public class Test{
public static void main(String[] args) {
Goods goodsA = new Goods("notebook",1.1);
Goods goodsB = new Goods(2.2);
System.out.println("goodsA title:"+goodsA.title+" price:"+goodsA.price);
System.out.println("goodsB title:"+goodsB.title+" price:"+goodsB.price);
}
}
这样既可以使用两个参数的构造器，也可以使用只有一个参数的构造器，会执行不同的构造器方法。
构造器有了，接下来加上两个方法，用于读取价格和标题，以及设置价格和标题。
public class Goods{
private String title="";
private double price=0.0;
public Goods(String aTitle,double aPrice){
title = aTitle;
price = aPrice;
}
public Goods(double aPrice){
price = aPrice;
title = "Goods";
}
public String getTitle(){
return title;
}
public double getPrice(){
return price;
}
public void setTitle(String aTitle){
title = aTitle;
}
public void setPrice(double aPrice){
price = aPrice;
}
}
这样我们的类就已经很丰满，呸，饱满了。这里我们添加了四个方法，两个方法用于读取成员变量，两个方法用于设置成员变量，此外，我们还将两个成员变量设置成了 private，这样这两个成员变量就只能在类的内部的方法中使用，在其他类中是禁止使用的。你可能会问，为什么要弄的这样复杂呢，两个数据直接操作不好吗？这就是封装的意义了，把数据完全封装在类里，只开放接口进行访问和修改，这样类就像一个插座一样，外部代码不需要知道插座里面是什么东西，只需要知道这是三孔插座还是两孔插座，知道怎样使用就可以了，这样的好处在于，可以很方便的进行维护，因为数据形式是容易改变的，但只要提供的接口不改变，其他代码就不需要改变，降低代码之间的依赖程度，这样就能实现模块化的效果。
那现在 Test 类也需要做相应调整了，因为 Goods 类成员已经声明为 private 了，所以只能通过类方法来进行访问。通常把用与访问类成员的方法叫做访问器，设置类成员的方法叫做更改器。
public class Test{
public static void main(String[] args) {
Goods goodsA = new Goods("notebook",1.1);
Goods goodsB = new Goods(2.2);
System.out.println("goodsA title:"+goodsA.getTitle()+" price:"+goodsA.getPrice());
System.out.println("goodsB title:"+goodsB.getTitle()+" price:"+goodsB.getPrice());
}
}
好了，现在我们的类变得有些厉害了，那如果现在需要将商品链接也加进去，该怎么办呢？
public class Goods{
private String title="";
private double price=0.0;
private String link = "";
public Goods(String aTitle,double aPrice,String aLink){
title = aTitle;
price = aPrice;
link = aLink;
}
public Goods(String aTitle,double aPrice){
title = aTitle;
price = aPrice;
link = "www.baidu.com";
}
public Goods(double aPrice){
price = aPrice;
title = "Goods";
link = "www.baidu.com";
}
public String getTitle(){
return title;
}
public double getPrice(){
return price;
}
public String getLink() {
return link;
}
public void setTitle(String aTitle){
title = aTitle;
}
public void setPrice(double aPrice){
price = aPrice;
}
public void setLink(String aLink){
link = aLink;
}
}
加上一个成员变量，再加上相应的访问器和更改器即可，当然，这里新增了一个构造器，这样的话，不仅之前的代码仍可以使用，还能使用新方法，骚出新高度。
public class Test{
public static void main(String[] args) {
Goods goodsA = new Goods("notebook",1.1);
Goods goodsB = new Goods(2.2);
Goods goodsC = new Goods("Java class",233,"www.cnblogs.com/mfrank/p/7747587.html");
System.out.println("goodsA title:"+goodsA.getTitle()+" price:"+goodsA.getPrice()+" link:"+goodsA.getLink());
System.out.println("goodsB title:"+goodsB.getTitle()+" price:"+goodsB.getPrice()+" link:"+goodsB.getLink());
System.out.println("goodsC title:"+goodsC.getTitle()+" price:"+goodsC.getPrice()+" link:"+goodsC.getLink());
}
}
这样就能输出三个对象的所有信息了，等等，不觉得输出的时候太麻烦了吗，重复三次及以上的地方就需要考虑用一个函数来代替。嗯，来给我们的 Goods 类加上一个输出方法。
public class Goods{
private String title="";
private double price=0.0;
private String link = "";
public Goods(String aTitle,double aPrice,String aLink){
title = aTitle;
price = aPrice;
link = aLink;
}
public Goods(String aTitle,double aPrice){
title = aTitle;
price = aPrice;
link = "www.baidu.com";
}
public Goods(double aPrice){
price = aPrice;
title = "Goods";
link = "www.baidu.com";
}
public String getTitle(){
return title;
}
public double getPrice(){
return price;
}
public String getLink() {
return link;
}
public void setTitle(String aTitle){
title = aTitle;
}
public void setPrice(double aPrice){
price = aPrice;
}
public void setLink(String aLink){
link = aLink;
}
public void print(){
System.out.println("title:"+title+" price:"+price+" link:"+link);
}
}
public class Test{
public static void main(String[] args) {
Goods goodsA = new Goods("notebook",1.1);
Goods goodsB = new Goods(2.2);
Goods goodsC = new Goods("Java class",233,"www.cnblogs.com/mfrank/p/7747587.html");
goodsA.print();
goodsB.print();
goodsC.print();
}
}
你看，我们的类定义好之后，主函数里的代码是不是就变得很简单了。这就是封装的好处，封装好以后只需要知道怎样使用就行了，不需要关注内部是怎样实现的。
好了，关于类与对象的内容就说到这了，总结一下，类是某一特定集合的特征描述，对象是类的具体实例，在使用的时候类的时候，需要用 new 关键字来 new 一个对象，然后才能使用类方法来操作这个对象。类可以看作是对象的模版，就像一个工厂一样，可以生成衣服，但每件衣服的款式是可以不一样的。
至此，本篇讲解结束，欢迎大家继续关注。