java语言(7): 深入浅出的 类和对象

类和对象

一、面向对象简述

面向过程的操作是以程序的基本功能实现为主，实现之后就完成了，也不考虑修改的可能性，面向对象，更多的是要进行子模块化的设计，每一个模块都需要单独存在，并且可以被重复利用，所以，面向对象的开发更像是一个具备标准的开发模式。

在面向对象定义之中，也规定了一些基本的特征： 
（1）封装：保护内部的操作不被破坏； 
（2）继承：在原本的基础之上继续进行扩充； 
（3）多态：在一个指定的范围之内进行概念的转换。

对于面向对象的开发来讲也分为三个过程：OOA（面向对象分析）、OOD（面向对象设计）、OOP（面向对象编程）。

二、类与对象的基本概念

类与对象时整个面向对象中最基础的组成单元。

类：是抽象的概念集合，表示的是一个共性的产物，类之中定义的是属性和行为（方法）； 
对象：对象是一种个性的表示，表示一个独立的个体，每个对象拥有自己独立的属性，依靠属性来区分不同对象。

可以一句话来总结出类和对象的区别：类是对象的模板，对象是类的实例。类只有通过对象才可以使用，而在开发之中应该先产生类，之后再产生对象。类不能直接使用，对象是可以直接使用的。

三、类与对象的定义和使用

在Java中定义类，使用关键字class完成。语法如下：

class 类名称 {
         属性 (变量) ;
         行为 (方法) ;
}

定义一个Person类:

class Person {     // 类名称首字母大写
    String name ;
    int age ;
    public void tell() {        // 没有static
          System.out.println("姓名：" + name + "，年龄：" + age) ;
         }
}

类定义完成之后，肯定无法直接使用。如果要使用，必须依靠对象，那么由于类属于引用数据类型，所以对象的产生格式（两种格式）如下：

（1）格式一：声明并实例化对象

//类名称 对象名称 = new 类名称 () ;

（2）格式二：先声明对象，然后实例化对象：

/*
类名称 对象名称 = null ;
对象名称 = new 类名称 () ;
*/

引用数据类型与基本数据类型最大的不同在于：引用数据类型需要内存的分配和使用。所以，关键字new的主要功能就是分配内存空间，也就是说，只要使用引用数据类型，就要使用关键字new来分配内存空间。

当一个实例化对象产生之后，可以按照如下的方式进行类的操作： 
对象.属性：表示调用类之中的属性； 
对象.方法()：表示调用类之中的方法。

例1：使用对象操作类

package com.wz.classandobj;

class Person { 
    String name ;
    int age ;
    public void get() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Person per = new Person() ;// 声明并实例化对象
            per.name = "张三" ;//操作属性内容
            per.age = 30 ;//操作属性内容
            per.get() ;//调用类中的get()方法
        }
}

姓名：张三，年龄：30

例2

package com.wz.classandobj;

class Person { 
    String name ;
    int age ;
    public void get() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Person per = null;//声明对象
            per = new Person() ;//实例化对象
            per.name = "张三" ;//操作属性内容
            per.age = 30 ;//操作属性内容
            per.get() ;//调用类中的get()方法
        }
}

姓名：张三，年龄：30

————————————————————————————————————————————————————

对上述2个例子进行分析：

首先，给出两种内存空间的概念： 
（1）堆内存：保存对象的属性内容。堆内存需要用new关键字来分配空间； 
（2）栈内存：保存的是堆内存的地址（在这里为了分析方便，可以简单理解为栈内存保存的是对象的名字）。

任何情况下，只要看见关键字new，都表示要分配新的堆内存空间，一旦堆内存空间分配了，里面就会有类中定义的属性，并且属性内容都是其对应数据类型的默认值。

于是，上面两种对象实例化对象方式内存表示如下： 

两种方式的区别在于①②，第一种声明并实例化的方式实际就是①②组合在一起，而第二种先声明然后实例化是把①和②分步骤来。

如果使用了没有实例化的对象，结果如何？ 如下：

package com.wz.classandobj;

class Person { 
    String name ;
    int age ;
    public void get() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Person per = null;//声明对象
            //per = new Person() ;//实例化对象
            per.name = "张三" ;//操作属性内容
            per.age = 30 ;//操作属性内容
            per.get() ;//调用类中的get()方法
        }
}

/*运行结果
Exception in thread "main" java.lang.NullPointerException
    at com.wz.classandobj.TestDemo.main(TestDemo.java:15)
*/

此时，程序只声明了Person对象，但并没有实例化Person对象（只有了栈内存，并没有对应的堆内存空间），则程序在编译的时候不会出现任何的错误，但是在执行的时候出现了上面的错误信息。这个错误信息表示的是“NullPointerException（空指向异常）”，这种异常只要是应用数据类型都有可能出现。

四、对象引用传递初步分析

引用传递的精髓：同一块堆内存空间，可以同时被多个栈内存所指向，不同的栈可以修改同一块堆内存的内容。

下面通过若干个程序，以及程序的内存分配图，来进行代码的讲解。

范例1：

class Person {     
         String name ;
         int age ;
         public void tell() {        
                   System.out.println("姓名：" + name + "，年龄：" + age) ;
         }
}
public class TestDemo {
         public static void main(String args[]) {
                   Person per1 = new Person() ;         // 声明并实例化对象
                   per1.name = "张三" ;
                   per1.age = 20 ;
                   Person per2 = per1 ;  // 引用传递
                   per2.name = "李四" ;
                   per1.tell() ;
         }
}

内存分配图如下：

范例2：

class Person {
         String name ;
         int age ;
         public void tell() {
                   System.out.println("姓名：" + name + "，年龄：" + age) ;
         }
}
public class TestDemo {
         public static void main(String args[]) {
                   Person per1 = new Person() ;         // 声明并实例化对象
                   Person per2 = new Person() ;
                   per1.name = "张三" ;
                   per1.age = 20 ;
                   per2.name = "李四" ;
                   per2.age = 30 ;
                   per2 = per1 ;// 引用传递
                   per2.name = "王五" ;
                   per1.tell() ;
         }
}

垃圾：指的是在程序开发之中没有任何对象所指向的一块堆内存空间，这块空间就成为垃圾，所有的垃圾将等待GC（垃圾收集器）不定期的进行回收与空间的释放。

五、面向对象的封装性

封装(encapsulation)又叫隐藏实现(Hiding the implementation)。就是只公开代码单元的对外接口，而隐藏其具体实现。比如手机，手机的键盘，屏幕，听筒等，就是其对外接口。你只需要知道如何按键就可以使用手机，而不需要了解手机内部的电路是如何工作的。封装机制就像手机一样只将对外接口暴露，而不需要用户去了解其内部实现。

举例1:

package com.wz.classandobj;

class Book{

    String title;
    double price;

    public void getInfo(){
        System.out.println("图书的名称："+title+" 图书的价格："+price);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Book book = new Book();
            book.title = "Java开发";
            book.price = -89.9;
            book.getInfo();
        }
}

输出结果：

图书的名称：Java开发 图书的价格：-89.9

以上代码没有任何语法错误，却存在一个业务逻辑的错误，因为图书的价格不能为负数。造成这种情况的的原因在于：对象可以在一个类的外部直接访问属性。 
如何解决？我们需要将Book类中的属性设置为对外不可见（只能是本类访问），可以使用private关键字来定义属性。

修改代码如下：

package com.wz.classandobj;

class Book{

    private String title;
    private double price;

    public void getInfo(){
        System.out.println("图书的名称："+title+" 图书的价格："+price);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Book book = new Book();
            book.title = "Java开发";
            book.price = -89.9;
            book.getInfo();
        }
}

输出结果：

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
    The field Book.title is not visible
    The field Book.price is not visible

    at com.wz.classandobj.TestDemo.main(TestDemo.java:16)

在访问属性的时候，外部的对象无法再直接调用类中的属性了，此时就相当于Book类的属性对外部不可见。

但是，要想让程序可以正常运行，那么必须让外部可以操作Book类的属性。在Java开发中，针对属性有这样的定义，在类中定义的属性都要求使用private声明，如果属性需要被外部所使用，那么按照要求，定义属性相应的setter和getter方法。

以Book类中的String title 为例： 

（1）setter方法是设置属性内容：public void setTitle(String t)

主要：有参数。

（2）getter方法是取得属性内容： public String getTitle()

注意：无参数。

举例2:

package com.wz.classandobj;

class Book{

    private String title;
    private double price;

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public double getPrice() {
        return price;
    }


    public void setPrice(double price) {
        this.price = price;
    }

    public void getInfo(){
        System.out.println("图书的名称："+title+" 图书的价格："+price);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Book book = new Book();
            book.setTitle("Java开发"); 
            book.setPrice(-89.9);
            book.getInfo();
        }
}

输出结果：

图书的名称：Java开发 图书的价格：-89.9

发现，图书的价格是负数，需要加入检查业务逻辑错误的代码，可以在setter中增加验证，如果值为正，赋值，否则为默认值0.0：

public void setPrice(double price) {
        if(price > 0.0){
            this.price = price;
        }
    }

对于数据验证，在Java标准开发中应该由辅助代码完成。在实际开发中，setter往往只是简单的设置属性内容，getter只是简单的取得属性内容。

开发建议：以后在定义类的时候，所有的属性都要编写private封装，封装之后的属性如果需要被外部操作，则编写setter、getter。

六、类中的构造方法

对象格式如下：

/*
①类名称 ②对象名称 = ③new ④类名称（）；

①类名称：规定了对象的类型。即：对象可以使用哪些属性和方法都是由类定义的； 
②对象名称：如果需要使用对象，需要有一个名称，这是一个唯一的标记； 
③new：分配新的堆内存空间； 
④类名称()：调用了名称和类名称相同的方法，这就是构造方法。

*/

实际上，构造方法一直在被我们调用，但我们并没有去定义它，为什么能够使用呢？这是因为在整个Java开发中，为了保证程序可以正常执行，即便用户没有定义任何构造方法，也会在程序编译后自动为类增加一个没有参数，方法名称与类名称相同，没有返回值的构造方法。

构造方法的定义：方法名称和类名称相同，没有返回值声明。

//无参，无返回值的构造方法
    public Book() {

    }

如果在Book类中没有定义以上的构造方法，那么也会自动生成一个无参，无返回值的构造方法。

范例1：

package com.wz.classandobj;

class Book{

    //无参，无返回值的构造方法
    public Book() {
        System.out.println("无参构造方法");
    }

}

public class TestDemo {
        public static void main(String args[]) {
            Book book = null;//声明对象
        }
}

运行输出结果为空。 

在主方法中加入实例化对象的代码：

public class TestDemo {
        public static void main(String args[]) {
            Book book = null;//声明对象
            book = new Book();//实例化对象
        }
}

运行输出结果：

无参构造方法

以上说明，构造方法是在对象使用关键字new实例化的时候被调用。

构造方法与普通方法最大的区别是： 
1）、构造方法在实例化对象（new）的时候只调用一次，而普通方法是在实例化对象之后可以随意调用多次。

2）、在实际开发中，构造方法的作用是在类对象实例化的时候设置属性的初始化内容。

范例2如下：

package com.wz.classandobj;

class Book{

    private String title;
    private double price;

    public Book(String title, double price) {
        this.title = title;
        this.price = price;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public double getPrice() {
        return price;
    }


    public void setPrice(double price) {
        this.price = price;
    }

    public void getInfo(){
        System.out.println("图书的名称："+title+" 图书的价格："+price);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Book book = new Book("Java开发",89.9);//设置属性的初始化内容
            book.getInfo();

        }
}

运行结果：

//图书的名称：Java开发 图书的价格：89.9

如果一个类中已经明确定义了一个构造方法，则无参构造方法将不会自动生成。而且，一个类之中至少存在一个构造方法。另外，既然构造方法也属于方法，那么构造方法也可以重载，但是由于构造方法的特殊性，所以在构造方法重载时注意其参数的类型及参数的个数即可。

范例3：

package com.wz.classandobj;

class Book{

    private String title;
    private double price;


    public Book() {
        System.out.println("无参的构造方法");
    }


    public Book(String title) {
        this.title = title;
        System.out.println("有一个参数的构造方法");
    }


    public Book(String title, double price) {
        this.title = title;
        this.price = price;
        System.out.println("有俩个参数的构造方法");
    }

    public void getInfo(){
        System.out.println("图书的名称："+title+" 图书的价格："+price);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Book book1 = new Book();
            book1.getInfo();

            Book book2 = new Book("Java开发");
            book2.getInfo();

            Book book3 = new Book("Java开发",89.9);
            book3.getInfo();

        }
}

运行结果：

/*无参的构造方法
图书的名称：null 图书的价格：0.0
有一个参数的构造方法
图书的名称：Java开发 图书的价格：0.0
有俩个参数的构造方法
图书的名称：Java开发 图书的价格：89.9
*/

在进行构造方法重载时有一个编写建议：所有重载的构造方法按照参数的个数由多到少，或者是由少到多排列。

如果在类中为属性直接设置默认值，结果会怎样？

范例4：

ackage com.wz.classandobj;

class Book{

    private String title = "Android开发";
    private double price = 199.9;


    public Book() {
        System.out.println("无参的构造方法");
    }


    public Book(String title) {
        this.title = title;
        System.out.println("有一个参数的构造方法");
    }


    public Book(String title, double price) {
        this.title = title;
        this.price = price;
        System.out.println("有俩个参数的构造方法");
    }

    public void getInfo(){
        System.out.println("图书的名称："+title+" 图书的价格："+price);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Book book1 = new Book();
            book1.getInfo();

            Book book2 = new Book("Java开发");
            book2.getInfo();

            Book book3 = new Book("Java开发",89.9);
            book3.getInfo();

        }
}

运行结果：

无参的构造方法
图书的名称：Android开发 图书的价格：199.9
有一个参数的构造方法
图书的名称：Java开发 图书的价格：199.9
有俩个参数的构造方法
图书的名称：Java开发 图书的价格：89.9

从上面可以发现：如果在类中为属性直接设置默认值，而且这个默认值是在构造方法执行完后才会设置的，且属性内容为对应数据类型的默认值时才设置类中定义的这个默认值。但是，要注意的是在构造方法没有执行之前，属性内容都是其对应数据类型的默认值。

七、类中的匿名对象

没名字的对象称为匿名对象，对象的名字按照之前的内存关系来讲，在栈内存之中，而对象的具体内容在堆内存之中保存，这样，没有栈内存指向堆内存空间，就是一个匿名对象。

package com.wz.classandobj;

class Book{

    private String title;
    private double price;

    public Book(String title, double price) {
        this.title = title;
        this.price = price;
        System.out.println("有俩个参数的构造方法");
    }

    public void getInfo(){
        System.out.println("图书的名称："+title+" 图书的价格："+price);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            //匿名对象
            new Book("Java开发",89.9).getInfo();

        }
}

运行结果：

有俩个参数的构造方法
图书的名称：Java开发 图书的价格：89.9

匿名对象由于没有对应的栈内存指向，所以只能使用一次，一次之后就将成为垃圾，并且等待被GC回收释放。

Java类和对象 详解（一）

Java类和对象 详解（二）

————————————————————————————————————————————

抽象类

一、基本概念

普通类是一个完善的功能类，可以直接产生实例化对象，并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。

那么什么叫抽象方法呢？在所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰。

而拥有抽象方法的类就是抽象类，抽象类要使用abstract关键字声明。

范例：定义一个抽象类

abstract class A{//定义一个抽象类

    public void fun(){//普通方法
        System.out.println("存在方法体的方法");
    }

    public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰

}

范例1：直接实例化抽象类的对象

package com.wz.abstractdemo;

abstract class A{//定义一个抽象类

    public void fun(){//普通方法
        System.out.println("存在方法体的方法");
    }

    public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰

}

public class TestDemo {

    public static void main(String[] args) {
        A a = new A();
    }
}

//运行结果
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    Cannot instantiate the type A

    at com.wz.abstractdemo.TestDemo.main(TestDemo.java:15)

从上可知，A是抽象的，无法直接进行实例化操作。为什么不能直接实例化呢？当一个类实例化之后，就意味着这个对象可以调用类中的属性或者放过了，但在抽象类里存在抽象方法，而抽象方法没有方法体，没有方法体就无法进行调用。既然无法进行方法调用的话，又怎么去产生实例化对象呢。

抽象类的使用原则如下： 
（1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public； 
（2）抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理； 
（3）抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类； 
（4）子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）；

范例2：

package com.wz.abstractdemo;

abstract class A{//定义一个抽象类

    public void fun(){//普通方法
        System.out.println("存在方法体的方法");
    }

    public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰

}
//单继承
class B extends A{//B类是抽象类的子类，是一个普通类

    @Override
    public void print() {//强制要求覆写
        System.out.println("Hello World !");
    }

}
public class TestDemo {

    public static void main(String[] args) {
        A a = new B();//向上转型

        a.fun();//被子类所覆写的过的方法
    }
}

//运行结果
Hello World !

现在就可以清楚的发现： 
（1）抽象类继承子类里面有明确的方法覆写要求，而普通类可以有选择性的来决定是否需要覆写； 
（2）抽象类实际上就比普通类多了一些抽象方法而已，其他组成部分和普通类完全一样； 
（3）普通类对象可以直接实例化，但抽象类的对象必须经过向上转型之后才可以得到。

虽然一个类的子类可以去继承任意的一个普通类，可是从开发的实际要求来讲，普通类尽量不要去继承另外一个普通类，而是去继承抽象类。

三、抽象类的使用限制

（1）抽象类中有构造方法么？ 
由于抽象类里会存在一些属性，那么抽象类中一定存在构造方法，其存在目的是为了属性的初始化。 
并且子类对象实例化的时候，依然满足先执行父类构造，再执行子类构造的顺序。

范例3：

package com.wz.abstractdemo;

abstract class A{//定义一个抽象类

    public A(){
        System.out.println("*****A类构造方法*****");
    }

    public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰

}
//单继承
class B extends A{//B类是抽象类的子类，是一个普通类

    public B(){
        System.out.println("*****B类构造方法*****");
    }

    @Override
    public void print() {//强制要求覆写
        System.out.println("Hello World !");
    }

}
public class TestDemo {

    public static void main(String[] args) {
        A a = new B();//向上转型
    }

}

/*执行结果：

*****A类构造方法*****
*****B类构造方法*****

*/

（2）抽象类可以用final声明么？ 
不能，因为抽象类必须有子类，而final定义的类不能有子类；

（3）抽象类能否使用static声明？ 
范例4：外部抽象类

package com.wz.abstractdemo;

static abstract class A{//定义一个抽象类

    public abstract void print();

}

class B extends A{

    public void print(){
        System.out.println("**********");
    }
}
public class TestDemo {

    public static void main(String[] args) {
        A a = new B();//向上转型
        a.print();
    }

}

//执行结果
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    Illegal modifier for the class A; only public, abstract & final are permitted

    at com.wz.abstractdemo.A.<init>(TestDemo.java:3)
    at com.wz.abstractdemo.B.<init>(TestDemo.java:9)
    at com.wz.abstractdemo.TestDemo.main(TestDemo.java:18)

范例5：内部抽象类

package com.wz.abstractdemo;

abstract class A{//定义一个抽象类

    static abstract class B{//static定义的内部类属于外部类
        public abstract void print();
    }

}

class C extends A.B{

    public void print(){
        System.out.println("**********");
    }
}
public class TestDemo {

    public static void main(String[] args) {
        A.B ab = new C();//向上转型
        ab.print();
    }

}

//运行结果
**********

由此可见，外部抽象类不允许使用static声明，而内部的抽象类运行使用static声明。使用static声明的内部抽象类相当于一个外部抽象类，继承的时候使用“外部类.内部类”的形式表示类名称。

（4）可以直接调用抽象类中用static声明的方法么？ 
任何时候，如果要执行类中的static方法的时候，都可以在没有对象的情况下直接调用，对于抽象类也一样。 
范:6：

package com.wz.abstractdemo;

abstract class A{//定义一个抽象类

    public static void print(){
        System.out.println("Hello World !");
    }

}

public class TestDemo {

    public static void main(String[] args) {
        A.print();
    }

}

//运行结果
Hello World !

（5）有时候由于抽象类中只需要一个特定的系统子类操作，所以可以忽略掉外部子类。这样的设计在系统类库中会比较常见，目的是对用户隐藏不需要知道的子类。 
范例7：

package com.wz.abstractdemo;

abstract class A{//定义一个抽象类
    public abstract void print();

    private static class B extends A{//内部抽象类子类

        public void print(){//覆写抽象类的方法
            System.out.println("Hello World !");
        }
    }

    //这个方法不受实例化对象的控制
    public static A getInstance(){
        return new B();
    }

}

public class TestDemo {

    public static void main(String[] args) {

        //此时取得抽象类对象的时候完全不需要知道B类这个子类的存在
        A a = A.getInstance();
        a.print();
    }
}

//运行结果
Hello World !

Java抽象类 详解