零基础入门学习java第十一节：Java中的类和对象

Posted 2021-02-16 java008

今天要说的是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一个对象，然后才能使用类方法来操作这个对象。类可以看作是对象的模版，就像一个工厂一样，可以生成衣服，但每件衣服的款式是可以不一样的。

至此，本篇讲解结束，欢迎大家继续关注。