JAVA 类与对象

Java编程语言的基本编程单元是类（class），类提供了对象的结构，并提供了从类的定义中构造对象的机制。

类定义了方法：即一些可执行代码的集合，他们是计算的焦点，可操纵对象中存储的数据。方法提供了类具有的对象所具有的行为。

契约（contract）：说明了当我们在对象上调用某些特定方法时将产生何种结果。这种契约定义了类型（type），所有属于这个类型的对象，都要遵守这个契约。

 

一个简单的类

class Body{

       publiclong idNum;

       publicString name;

       publicBody orbits;

 

       publicstatic long nextID = 0;

}

类时用关键字class来生命的，同时要对类赋予名字，并且在花括号张罗列出类的所有成员。

类的声明创建了类型名，因此对属于这种类型的对象的引用，可以直接声明为：

Body mercury；

这个声明表示mercury是一个变量，它保存着指向具有Body类型的对象的引用。这个声明并未创建对象，他只声明了一个对某个Body对象的引用。

类成员

字段：它们是与类及其对象相关联的数据变量，保存着类或者对象的状态

方法：他们包含类的可执行代码并定义了对象的行为。

嵌套类（nested class ）与 嵌套接口（ nested interface）：他们是在其他的类或者接口声明的内部声明的类与接口。

类修饰符

类声明的前面可以有多个修饰符，修饰符可以按任意顺序排列，但是建议使用下面给出的顺序排列以增强代码的可读性。

1.     注解（annotation ）：注解和注解类型

2.     public ：public 类是可公共访问的，任何人都可以声明对这种类的对象的引用，或者访问这种类的公共成员。如果没有该修饰符，类就只能在它所在的包（package）内访问类。

3.     abstract：抽象类被认为是不完整的，所以我们不能创建抽象类的实例。

4.     final：final类不允许拥有子类。

5.     严格浮点（strict floating point）：声明为strictfp 的类要求类中的所有浮点运算都是精确运算

 

类不能既是final的又是abstract的。

 

字段

实例变量的概念。

字段声明的前面添加修饰符：

1.     注解

2.     访问修饰符（public private protected）

3.     static

4.     final

5.     transient

6.     volatile

字段不可以既是final的又是volatile的。

 

字段的初始化

如果字段未被初始化，那么根据其类型，它将被赋予一个默认的初始值：

类型	初始值
Boolean	false
char	‘\u0000’
byte,short,int,long	0
float,double	+0.0
object reference	null

静态字段

static修饰符来声明静态字段（staticfield），也叫类变量（class variable）。当我们在类中声明static字段时，无论创建了该类的多少个实例，这个字段的副本都只有一份。

final字段

final变量一经赋值就无法改变，任何要改变final字段的尝试都会在编译期报错。

对于基本类型或者string类型的final字段，如果他被一个常量表达式所初始化，也就是说，在一个编译期间即可确定其值的表达式所初始化，那么该字段就被称为常变量（constant variable）。常变量很特殊，这是因为编译器视之为数值而不是字段。如果我们的代码引用了一个常变量，那么编译器并不会产生从对象的字段中取值的字节码，而是会直接将数值插入字节码。这是一种有用的优化措施，但它意味着如果我们要改变一个final字段的值，那么每一处引用到该字段的代码都要重新编译。

 

没有初始化器的final字段被称为空白final（blank final），在简单初始化字段上不适宜的时候可能会用到它。一旦类被初始化（对于static的final字段）或者类的对象被完全构造出来（对非static的final字段，在构造函数中定义值），这些空白的final字段就必须被初始化。

静态块。

 

访问控制

在面向对象编程的健壮性中，一个重要的方面就是它支持封装（encapsulation）和数据隐藏（data hiding）。这种控制是由类、接口和成员的访问修饰符来限定的。

 

类中的所有成员都可以被该类自身的代码访问。

 

为控制其他类的访问权限，类成员有4种访问修饰符：

1.     private ：声明为private 的成员只能被包含它的类自身所访问。

2.     package：包成员无任何访问修饰符，它们只能被包含它们的类和它们所在包中的类所访问。（不写其他修饰符的话，默认就是package）

3.     protected：声明为protected的成员可以被包含它的类的子类、同一包中的类以及包含它的类自身所访问。

4.     public：声明为public的成员可被任何类访问。

 

private和protected 访问修饰符只能作用于成员，不能作用于类或者接口（除非是嵌套类或者接口）

 

创建对象

Body sun=new Body（）；

首先声明了一个可以引用Body类型对象的引用变量（sun），这种声明并不创建对象；它只定义了一个引用对象的变量，而所引用的对象必须被显式地创建。

使用new创建了对象sun ，new构造是目前为止最常用的创建对象的方式。在用new创建对象时，需要指定要创建的对象的类型和构建它所需的所有引元。

我们不用显式地删除对象，虚拟机利用垃圾回收来管理内存。

 

构造器

新创建的对象会被赋予一个初始状态。

类使用构造器（constructor）初始化对象。构造器是一些语句块，用来在new将对象的引用返回之前初始化对象。

构造器拥有与它们要初始化的类相同的名字，就像方法一样，它需要零个或多个引元，但没有返回类型。

构造器将在新建对象被赋予默认初值且执行了显式的初始化式之后调用。

 

一个构造器可以通过this（）来调用同一个类中的另一个构造器作为其第一条可执行语句，这成为显式构造器调用（explicit construct invocation）

 

       非public 的构造器限制了谁能够使用它来创建对象。例如，通过将被某个类的构造器全部设置为只能在其所在包的内部北方为，我们可以防止使用我们的包的程序员创建该类的实例。

       不带引元的构造器很常见：无参（no-arg）构造器。

       如果我们的勒种没有提供任何构造器，那么Java语言会提供一个默认的不作任何事情的无参构造器，这类构造器被称为默认构造器（defaultconstructor），它们只有在不存在任何其他构造器的情况下才会由编译器自动提供。

       如果我们急需要无参构造器，又需要其他带引元的构造器，就必须显式地提供一个无参构造器。

       默认构造器与其所在的类拥有相同地可访问性。

初始化块

字段另一种更复杂地初始化方式就是使用初始块。

初始块式一段出来现在类声明中地语句块，它位于所有成员、构造器、以及声明之外，他可以初始化对象的字段。

它们会被优先执行，就好像它们被放置在类的每一个构造器的开头那样。如果有多个块，它们将按照在类中出现的先后顺序执行。

只有当类中的所有构造器都声明会抛出某个检查型异常时，它的初始化块才可以抛出该异常。

静态初始化

静态初始块（static initialization block）被声明为static，并且只能引用类的静态成员，不能抛出检查型异常

 

方法

方法声明包含两部分：方法头和方法体。

方法头包含可选的的修饰符集、可选的类型参数集、方法的返回类型和签名，还有可选的列出了方法所抛出的异常的throws子句。

方法的签名，包含方法名和由圆括号括起来的参数类型列表，所有的方法都必须有返回类型和签名；

 

方法修饰符推荐顺序：

1.     注解

2.     访问修饰符

3.     abstract

4.     static

5.     final

6.     synchronized: 线程相关

7.     native

8.     严格浮点：strictfp

 

抽象方法不能时static、final、synchronized、native或严格浮点的。

而native方法不能是严格浮点的。

 

静态方法

static方法，类方法，可以由类直接调用

static方法只能访问类中的static字段和其他的static方法。

 

引元数量可变的方法

参数messages被声明为一个String对象序列。序列参数允许使用构成该序列的可变数目（包括0）的引元来调用一个方法，这类方法被称为可变引元（variable-argument）方法。（varargs方法）

 

参数序列messages其实就是一个Body对象的数组。如上图所示理解就好。

方法异常与返回

当调用方法时，控制流将从调用方法传入被调用的方法，被调用的方法中的语句将按照它们的语义顺序执行。

当发生下列三种情况之一时，方法将结束执行并返回到调用者：执行return语句；到达方法结尾；抛出未捕获的异常。

 

参数值

方法中所有参数都是“按值”传递的，换句话说，方法中参数变量的值是调用者所指派的引元之值的副本。

       “引用传递”（pass by reference）真正的含义是当引元传递给函数时，被调用的函数获得的是对原值的引用，而非原值的副本。

       我们可以将方法的参数声明为final，使参数的值在方法执行的过程中不会被改变。

 

使用方法来访问控制

   控制内部数据访问的方法有时被称为访问方法（accessormethod），使用它们可以增强类数据的封装性。

 

this

我们可以在非静态的方法中使用this这个特殊的对象引用，它指向的是方法被调用了的当前对象。在static方法中没有this引用，因为没有可供操作的指定对象。

 

this引用最常见的方法就是将当前对象的引用作为引元传递给其他方法。

 

按照惯例，this只在必要的时候使用：即要访问的字段的名字被局部变量或参数声明隐藏了的时候。例如：

public Body （Stringname ，Body orbits）{

       this();//引用构造方法

       this.name= name ;

       this.orbits= orbits;

}

 

重载方法

每个方法都有签名（signature），签名是由方法名及参数的类型和数量组成的。两个方法只要具有不同类型或数量的参数，它们就可以具有相同的名字，因为它们具有不同的签名。这一特性成为重载（overloading），因为一个简单名可以拥有重载的（多个）含义。

           

导入静态成员名

例子：

Math函数贯穿于整个表达式，看起来很散乱，并且肯定不能提高代码的可读性。

可以用静态导入语句（static import statement）来实现这一目的：

       import static java.lang.Math.exp;

 

按需静态导入语句（static import on demand statement）用一个星号（*）代替了成员名。

import static java.lang.Math.*；

 

main方法

在运行程序的时候，系统将定位并运行这个类的main方法。main必须是public、static和void的，并且必须接受单一的String[ ]类型的引元。

 

ex：

class Echo{

       pubicstatic void main（String[ ] args）{

              for( int i = 0 ; I <args.length ; i++ )

                     System.out.print(args[i]+ “ ”);

              System.out.println() ;

}

}

传入main的String 数组包含了程序引元（program argument），它们通常是用户运行程序时，由用户来输入的。

例如，命令行：

       javaEcho in here ；

其中，java表示Java的字节码解释器，Echo时类的名字，余下的命令是程序的引元。java命令将寻找编译过的Echo类的字节码，将它载入Java虚拟机，并使用包含在String数组中的字符串来调用Echo.main方法。

 

其结果是产生下面的输出：

       inhere

 

本地方法

如果我们需要编写一个程序，它想使用某些现有的非Java编程语言编写的代码，或者我们需要直接操纵某种硬件，那么我们可以编写  本地方法（native method）。

 

通过本地方法，我们可以实现能够用Java语言调用，但却是使用“本地”语言编写的方法，这些本地语言通常是C或者C++。

 

本地方法使用native修饰符来声明的。因为这种方法是由其他语言来实现的，所以其方法体用分号指代。例如：

       publicnative int getCPUID();

本地方法与其他方法类似，它们可以被重载或覆盖，可以是final、static、synchronized、public、protected或者private的。但是，不能被声明为abstract或者strictfp。

本地方法是通过使用那些编写虚拟机的人所提供的API来实现的，这里的虚拟机指的是执行本地方法的虚拟机。其中，为C程序员制定的标准被称为JNI，即java本地接口（Java native interface），对于其他本地语言也有相关的标准。