澳门新浦京app下载Java到底是不是一种纯面向对象语言?

本文由码农网 –
Dee1024原创翻译,转载请看清文末的转载要求,欢迎参与我们的付费投稿计划!

英文原文:Why Java Is a Purely Object-Oriented Language Or Why Not


Java是否确实是 “纯面向对象”?让我们深入到Java的世界,试图来证实它。

在我刚开始学习Java的前面几年,我从书本里知道了Java是遵循“面向对象编程范式(Object
Oriented Programming
paradigm)”的。在Java世界内一切都是对象,甚至包括字符串(String)这些都是对象(在
C 语言中,字符串是字符数组),那时候,我认为Java是一种面向对象的语言。

但是在后来,我在网上陆续看到不少开发者说“Java实际上不是纯粹的面向对象,因为并不是所有的东西在Java世界都是一个对象”。他们很多的论点都可以概括为以下两点:

  • 所有的静态内容(static关键字修饰的变量和方法)不属于任何对象,这些是非对象的东西。

  • 所有基本类型(char,boolean,byte,short,int,long,float,double)都不是对象,因
    为我们不能做类似对象的所具有的操作(例如:使用“.”来访问对象的属性和方法)。

在那时,由于个人知识经验储备有限,我又很容地相信上面的论点,并且也开始认为
“Java 不是纯粹的面向对象编程语言”。

到了更后来,我发现JVM在创建对象的时候,实际上会创建两个对象:

  • 一个是实例对象。
  • 另一个是Class对象。该Class对象在JVM内仅仅会装载一次,该类的静态方法和静态属性也一同装载,JVM使用该Class对象来创建具体的实例对象(如上面的对象)。

例如,在下面的 Java 语句中,将有两个对象被创建:

Employee emp = new Employee ();

一个是实例对象 emp
;另一个则是Class对象,我们可以通过Employee.class引用到它;这个Class对象拥有所有的这个类定义的静态变量和静态方法。同时,如果我们访问通过emp对象来访问静态内容,会发现它其实指向的对象就是Employee.class。

这也揭开了另一个迷:为什么静态内容在一个对象中(不管是emp还是emp2)改变了,在另一个对象中也同时改变,因为这两个对象改变的都是在Employee.class同一个对象里面的内容。

现在,上面说到的第一个论点我们要取消了。因为,静态内容确实被证实属于一个对象

但是我们还要确认第二个论点:正如早前提到的,原始类型在Java中不是对象,它们无法做类似对象的操作。为了解决这个问题,Java官方为每一个原始类型推出了对应的包装类(比如:Integer对应int,Long对应
long,Character对应char),所以,其实现在我们可以为原始类型创建一个包装对象,同时对它们做对象相关的操作。并且,由于自动拆装箱,我们可以把一个原始类型值赋值给它对应的包装类的引用。但是我们仍然不能对这些原始类型做对象的操作,我们需要创建对应包装类的对象。

例如:

Integer obj = new Integer (5); // here we can do i.toString ();
int i = 5; // but we can't do i.toString () here

到目前为止,从一个最终用户的角度上来看的,我们可以确认
“原始类别不是对象”。(Java 开发人员是
Java的最终用户,因为我们正在使用它,而不是创造它)。

如果站在JVM的视角,会有新的发现:

其实,在JVM看来它把所有的“原始类型”都是当作对象处理,要证明这一点可以通过Class类的源代码或者Javadoc中Class类的说明。

根据 java.lang.Class类的源代码,该类的注释是:

Java 官方描述:

Instances of the class Class represent classes and interfaces in a
running Java application. An enum is a kind of class and an annotation
is a kind of interface. Every array also belongs to a class that is
reflected as a Class object that is shared by all arrays with the same
element type and number of dimensions. The primitive Java types
(boolean, byte, char, short, int, long, float, and double), and the
keyword void are also represented as Class objects.

参考译文:
Class
类的实例表示正在运行的Java应用程序的类和接口。像枚举是一种类,注解则是一种接口。每个数组也属于被反射作为由具有相同的元素类型和尺寸的数目的所有阵列共享一类对象的类。原始的Java
类型(boolean, byte, char, short, int, long, float, and
double)和关键字void也表示为Class 对象。

同时也根据 Javadoc 中对 Class.isPrimitive ()方法的定义来判断。
  
Java 官方描述:

public boolean isPrimitive ()
Determines if the specified Class object represents a primitive
type.
There are nine predefined Class objects to represent the eight
primitive types and void. These are created by the Java Virtual
Machine, and have the same names as t he primitive types that they
represent, namely boolean,byte, char, short, int, long, float, and
double.
These objects may only be accessed via the following public static
final variables, and are the only Class objects for which this method
returns true.
Returns:
true if and only if this class represents a primitive type
Since:
JDK1.1

参考翻译:
public boolean isPrimitive ()
判断指定的 Class 对象是否代表一个基本类型。
一共有 9 种设定好的 Class 对象来表示对应的基本类型和 void
关键字。这些对象都是由 JVM 创建的。
return
当且仅当该类表示一个真正的基本类型

以上都说明,在 JVM 内部,其实原始类型就是对象。

当你打开 Javadoc对 Class 类的定义中,通过 “CTRL+F ”
查找关键字“primitive”,将会发现证据在表面
“在JVM里,它把基本类型当作对象来处理的”。

我们可以再来看一个例子: Integer.TYPE,在这部分文档清晰记录着:

Java 官方描述:

public static final Class<Integer> TYPE
The Class instance representing the primitive type int.

以上都说明,在 JVM 内部,其实原始类型就是对象。

那么,既然说 “JVM”会为所有的基本类型创建一个对象,那我们为什么还那么常用
“原始类型”, 而不是直接使用对应的包装类对象呢?

这是因为,为“原始类型”创建的对象,在JVM内部是很轻量级的,相对与我们直接创建的对应包装类对象做了许多优化;
也正因为轻量的缘故,这些原始类的功能就比较少(例如我们不能调用其内部的方法,因为他们内部已经优化成没有方法了)

使用实际的例子来说明,为什么我们更应该使用 “原始类型”:

“原始类型”有更快的速度(例如,下面的代码执行,在我们的机器上需要9秒,但当我把Long改成long
之后,0 秒内就完成了)

public static void main (String[] args) {
    long millis = System.currentTimeMillis ();
    Long sum = 0L; // uses Long, not long
    for (long i = 0; i <= Integer.MAX_VALUE; i++) {
        sum += i;
    }
    System.out.println (sum);
    System.out.println ((System.currentTimeMillis () - millis) / 1000);
}

“原始类型”允许我们直接使用 “==”来进行比较。

new Integer (3) == new Integer (3); // false
new Integer (100) == new Integer (100); // false
Integer.valueOf (5) == Integer.valueOf (5); //true
Integer.valueOf (200) == Integer.valueOf (200); //false

我们注意看第四句,输出结果确实为 “false” 。这个是因为在 [-128; 127]
这个区间的265个整数会被JVM 缓存存放, 所以在这个区间, JVM
返回相同的对象;然而,超出这个区间, JVM
就不再有缓存了,将会创建新的对象,所以结果是不等的。

所以总结一下是:
在JVM内部,原始类型就是被当作对象来处理的。但是我们开发者直接把“原始类型”当作对象使用,开发者应该使用对应的包装来。

以上就是为什么我说“Java确实是一个纯粹的面向对象语言”的证实过程。

英文原文

Java class对象说明 Java 静态变量声明和赋值说明,javaclass

先看下JDK中的说明:
  java.lang.Object
    java.lang.Class<T>

Instances of the class Class represent classes and interfaces in a
running Java application. An enum is a kind of class and an annotation
is a kind of interface. Every array also belongs to a class that is
reflected as a Class object that is shared by all arrays with the same
element type and number of dimensions. The primitive Java types
(boolean, byte, char, short, int, long, float, and double), and the
keyword void are also represented as Class objects.

在一个运行着的JAVA应用中,类的任何实例都可以用Class对象来指代,Class可以指代所有的类和接口。枚举属于类,注解属于接口,均可以用Class指代。每个数组均属于反射的Class对象,数组中的每个元素和维度也同样拥有Class对象。Java基本类型(boolean,
byte, char, short, int, long, float, and
double)以及关键字void也都可以用Class指代。

上面内容总结下,就是Java中所有的对象以及基本类型都是可以用Class指代的。接下来看一个Demo。

/**
 * 
 * 旨在测试Class对象和Instance之间的关系;
 * 旨在测试静态变量的声明和赋值过程;
 * @author zzy
 *
 */
public class ObjClass {
    private enum tmpEnum {A, B, C};
    public static void main(String[] args){
        int[] tmpArray = {1,2,3};
        Class classType;

        try {
            // 通过类名直接获取Class对象,JVM中没有加载。
            classType = InClass.class;
            System.out.println(".class: " + classType);
            System.out.println(".class finish.");

            // Java加载类
            classType = Class.forName("InClass");
            System.out.println("Class.forName: " + classType);
            System.out.println("Class.forName: finish.");


            // 创建实例
            InClass newClassType = new InClass();
            classType = newClassType.getClass();
            System.out.println("new Object.getClass: " + classType);
            System.out.println("new Object.getClass: finish.");

            // 数组对象
            classType = tmpArray.getClass();
            System.out.println("Array.getClass:" + classType.getSimpleName());
            System.out.println("Array.getClass: finish.");

            // 枚举对象
            classType = tmpEnum.class;
            System.out.println("enum.class:" + classType);
            System.out.println("enum.class: finish.");

        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }            
    }    
}
class InClass{
    // 对静态变量声明之前赋值 
    {
        staticPara = 10;
    }
    public static int staticPara;

    // 构造函数
    public InClass(){
        System.out.println("construction...");
    }

    // 静态代码块
    static {
        System.out.println("static function...");
    }

    // 静态变量赋值
    {    
        staticPara = 20;
    }

    {
        System.out.println("normal function, staticPara:" + staticPara);
    }

    // 静态变量赋值
    {
        staticPara = 30;
    }    
}

输出结果:

.class: class InClass
.class finish.
static function…
Class.forName: class InClass
Class.forName: finish.
normal function, staticPara:20
construction…
new Object.getClass: class InClass
new Object.getClass: finish.
Array.getClass:int[]
Array.getClass: finish.
enum.class:class ObjClass$tmpEnum
enum.class: finish.

 

说明:

  1.  .class方式获取类文件的Class对象,并不需要加载JVM中。

  2.  Class.forName的方式JVM会加载类,同时会编译。
如此,类中的静态代码块就会被执行。

  3.
 创建实例过程中(已经加载至JVM中,也就是说编译过了),调用构造函数,并执行非静态代码块。

  4.
 静态代码对于变量的声明和赋值顺序是没有影响的(编译过程处理),所以结果是20。

  5. 数据对象和枚举对象也是可以被Class对象指定的。

class对象说明 Java
静态变量声明和赋值说明,javaclass 先看下JDK中的说明: java.lang.Object
java.lang.ClassT Instances of the class Class represent class…

Java——是否确实的 “纯面向对象”?让我们深入到Java的世界,试图来证实它。

在我刚开始学习 Java 的前面几年,我从书本里知道了 Java 是遵循
“面向对象编程范式(Object Oriented Programming
paradigm)”的。在Java世界内一切都是对象,甚至包括字符串(String)这些都是对象(在
C 语言中,字符串是字符数组),那时候,我认为 Java是一种面向对象的语言。

但是在后来,我在互联网站上陆续看到不少开发者说
“Java实际上不是纯粹的面向对象,因为并不是所有的东西在 Java
世界都是一个对象”。他们很多的论点都可以概括为以下两点:

  • 所有的静态内容( static
    关键修饰的变量和方法)不属于任何对象,所以这些是非对象的东西。
  • 所有基本类型(char,boolean,byte,short,int,long,float,double)都不是对象,因为我们不能做类似正常对象的所具有的操作(例如:使用“.”来访问对象的属性和方法)。

在那时,由于个人知识经验储备有限,我又很容地相信上面的论点,并且也开始认为
“Java 不是纯粹的面向对象编程语言”。

到了更后来,在我的一次JVM学习过程中,我有了新的发现:

JVM 在创建对象的时候,实际上会创建两个对象:

  • 一个是实例对象。
  • 另一个是Class 对象。该 Class 对象在JVM内仅仅会装载一次,该类的静态方法和静态属性也一同装载,JVM使用该 Class 对象来创建具体的实例对象(如上面的对象)。

例如,在下面的 Java 语句中,将有两个对象被创建:

Employee emp = new Employee();

一个是实例对象 emp ;另一个则是 Class对象,我们可以通过 Employee.class 引用到它;这个 Class 对象拥有所有的这个类定义的静态变量和静态方法,同时,如果我们访问
通过 emp 对象来访问静态内容,会发现它其实指向的对象就是 Employee.class 。

这也揭开了另一个迷:为什么静态内容在一个对象中(不管是emp还是emp2)改变了,在另一个对象中也同时改变,因为这两个对象改变的都是在
Employee.class 同一个对象里面的内容。

现在,上面说到的第一个论点我们要取消了。因为,静态内容确实被证实属于一个对象。

但是我们还要确认第二个论点:正如早前提到的,原始类型在Java中不是对象,它们无法做类似对象的操作。为了解决这个问题,Java
官方为每一个原始类型推出了对应的包装类(比如:Integer 对应 int,Long
对应 long,Character 对应
char),所以,其实现在我们可以为原始类型创建一个包装对象,同时对它们做对象相关的操作。并且,由于自动拆装箱,我们可以把一个原始类型值赋值给它对应的包装类的引用。但是我们仍然不能对这些原始类型做对象的操作——我们需要创建对应包装类的对象。

例如:

Integer obj = new Integer(5); // here we can do i.toString();
int i = 5; // but we can't do i.toString() here

到目前为止,从一个最终用户的角度上来看的,我们可以确认
“原始类别不是对象”。(
Java开发人员是Java的最终用户,因为我们正在使用它,而不是创造它 )。

如果站在JVM的视角,会有新的发现:

其实,在JVM看来它把所有的 “原始类型” 都是当作对象处理”
,要证明这一点可以通过 Class类的源代码 或者 Javadoc中Class类的说明。

根据 java.lang.Class 类的源代码,该类的注释是:

Java官方描述:

Instances of the class Class represent classes and interfaces in a
running Java application. An enum is a kind of class and an annotation
is a kind of interface. Every array also belongs to a class that is
reflected as a Class object that is shared by all arrays with the same
element type and number of dimensions. The primitive Java types
(boolean, byte, char, short, int, long, float, and double), and the
keyword void are also represented as Class objects.

参考译文:

Class类的实例表示正在运行的Java应用程序的类和接口。像枚举是一种类和注解则是一种接口。每个数组也属于被反射作为由具有相同的元素类型和尺寸的数目的所有阵列共享一类对象的类。原始的Java类型(boolean,
byte, char, short, int, long, float, and
double)和关键字void也表示为Class对象。

同时也根据Javadoc中对Class.isPrimitive()方法的定义,来判断

Java官方描述:

public boolean isPrimitive()
Determines if the specified Class object represents a primitive
type.
There are nine predefined Class objects to represent the eight
primitive types and void. These are created by the Java Virtual
Machine, and have the same names as t he primitive types that they
represent, namely boolean,byte, char, short, int, long, float, and
double.
These objects may only be accessed via the following public static
final variables, and are the only Class objects for which this method
returns true.
Returns:
true if and only if this class represents a primitive type
Since:
JDK1.1

参考翻译:

public boolean isPrimitive()
判断指定的Class对象是否代表一个基本类型。
一共有9种设定好的Class对象来表示对应的基本类型和void关键字。这些对象都是由JVM创建的。…
return

当且仅当该类表示一个真正的基本类型

以上都说明,在JVM内部,其实原始类型就是对象。

当你打开 Javadoc
对 Class 类的定义中,通过
“CTRL+F ” 查找关键字 “primitive”, 将会发现证据在表面
“在JVM里,它把基本类型当作对象来处理的”。

我们可以再来看一个例子: Integer.TYPE,在这部分文档清晰记录着:

Java官方描述:

public static final Class<Integer> TYPE
The Class instance representing the primitive type int.

以上都说明,在JVM内部,其实原始类型就是对象。

那么,既然说 “JVM”会为所有的基本类型创建一个对象,那我们为什么还那么常用
“原始类型”, 而不是直接使用对应的包装类对象呢?

这是因为,为 “原始类型”
创建的对象,在JVM内部是很轻量级的,相对与我们直接创建的对应包装类对象做了许多优化;
也正因为轻量的缘故,这些原始类的功能就比较少(例如我们不能调用其内部的方法,因为他们内部已经优化成没有方法了)

使用实际的例子来说明,为什么我们更应该使用 “原始类型”:

“原始类型”有更快的速度(例如,下面的代码执行,在我们的机器上需要9秒,但当我把 Long 改成 long 之后,0秒内就完成了)

public static void main(String[] args) {
    long millis = System.currentTimeMillis();
    Long sum = 0L; // uses Long, not long
    for (long i = 0; i <= Integer.MAX_VALUE; i++) {
        sum += i;
    }
    System.out.println(sum);
    System.out.println((System.currentTimeMillis() - millis) / 1000);
}

“原始类型”允许我们直接使用 “==”来进行比较

new Integer(3) == new Integer(3); // false
new Integer(100) == new Integer(100); // false
Integer.valueOf(5) == Integer.valueOf(5); //true
Integer.valueOf(200) == Integer.valueOf(200); //false

我们注意看第四句,输出结果确实为 “false” 。这个是因在 [-128;
127] 这个区间的265个整数会被 JVM 缓存存放, 所以在这个区间,
JVM返回相同的对象;然而,超出这个区间,
JVM就不再有缓存了,将会创建新的对象,所以结果是不等的。

所以总结一下是:
在JVM内部,原始类型就是被当作对象来处理的。但是我们开发者直接把
“原始类型” 当作对象使用,开发者应该使用对应的包装来。

以上就是为什么我说
“ Java确实是一个纯粹的面向对象语言 ”的证实过程。如果你们对这个有什么其他的观点,请在评论留言,一起讨论。

You can leave a response, or trackback from your own site.

Leave a Reply

网站地图xml地图