【JAVA零基础入门系列】Day11 Java中的类和对象

2019-06-15 00:00:00 对象 基础 入门

今天要说的是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下的所有类,导入之后就能像一般类一样正常使用了。

《【JAVA零基础入门系列】Day11 Java中的类和对象》
《【JAVA零基础入门系列】Day11 Java中的类和对象》
《【JAVA零基础入门系列】Day11 Java中的类和对象》
  

  

现在定义的类,只有属性,没有方法,看起来就像是一个将两个数据捆绑在一个类中而已,就像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一个对象,然后才能使用类方法来操作这个对象。类可以看作是对象的模版,就像一个工厂一样,可以生成衣服,但每件衣服的款式是可以不一样的。

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

真正重要的东西,用眼睛是看不见的。

【JAVA零基础入门系列】(已完结)导航目录

  • Day1 开发环境搭建
  • Day2 Java集成开发环境IDEA
  • Day3 Java基本数据类型
  • Day4 变量与常量
  • Day5 Java中的运算符
  • Day6 Java字符串
  • Day7 Java输入与输出
  • Day8 Java的控制流程
  • Day9 Java中的那个大数值
  • Day10 Java中的数组
  • Day11 Java中的类和对象
  • Day12 Java类的简单应用
  • Day13 Java类的继承与多态
  • Day14 Java对象的克隆
  • Day15 对象的比较

相关文章