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

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

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

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏算法与数据结构

利用代码计算原码,反码和补码

1103
来自专栏程序员互动联盟

【编程基础】C++异常处理简介

遗憾的是,在实践中人们通常会忽略出错情况,就好像程序处在一个无错误的状态下进行工作的。毫无疑问,导致上述问题的一个原因就是,检测错误是一个乏味的工作并且导致代码...

2905
来自专栏程序员互动联盟

【编程基础】写代码,你应该知道九类规则

网上有太多讲编码规范、编码习惯的文章,但我总是念的多,实际去认真阅读理解的少。或多或少的按照自己的思维去编写代码。这种习惯让我吃大亏,比如一个指针未赋值导致偶尔...

4215
来自专栏Jed的技术阶梯

Java设计模式之迭代器模式

老板让我打印各个项目的报表,包括项目名称,人数,开销等信息,这个好办,看下面的类图:

2772
来自专栏每周一脱topic

Effictive python学习总结连载(1)

python从读研开始就在用了,拿来做过web后台、安全分析、爬虫、测试框架等等,挺强大的。最近借放假和看书和整理的机会,系统的总结下。主要是2方面:一个是书或...

2172
来自专栏IT派

程序员们,再不升级 Java 10 就晚了!

正如我们大家都知道的,Java 的最新版本已经来到了10。本文将重点介绍当前正在开发的一些有趣的 Java 新功能。

1162
来自专栏代码世界

计算机基础,Python基础--变量以及简单的循环

一、计算机基础 1.CPU   相当于人体的大脑,用于计算处理数据。 2.内存    用于存储数据,CPU从内存调用数据处理计算,运算速度很快。 PS:问:...

2807
来自专栏屈定‘s Blog

设计模式--组合模式的思考

组合模式是一种抽象树形结构的模式,其在业务开发中也是一种很有用的设计模式,下面开始分析.

4233
来自专栏AndroidTv

谈谈你对 Java 平台的理解声明提问正文

1174
来自专栏Web 开发

JavaScript Cookbook 2nd 之 Function

昨晚翻了一下,虽然都是一些旧知识,不过深入下去对照着其他资料一起看,还是能发现一些有意思的地方。

940

扫码关注云+社区

领取腾讯云代金券