类与对象相关语法
字段成员的语法细则
字段初始化
private int hour = 0; // 将钟表的时间初始化为0:0:0
private int minute = 0;
private int second = 0;
空值
字段默认值：
byte/short/int/long: 0
float/double: 0.0
char: ‘\u0000’
boolean: false
引用变量默认值：null
只读字段final
private final int second = 0; // 将字段second定义成只读字段
方法成员的语法细则
方法的4大要素
1.方法名
2.形式参数列表
3.方法体
4.返回值类型
方法签名
返回值类型 方法名(形参列表)
重载方法
public void set( ) // 不带参数的方法set()：从键盘输入时间
{
Scanner sc = new Scanner( System.in );
hour = sc.nextInt();
minute = sc.nextInt();
second = sc.nextInt();
}
public void set(int h, int m, int s) // 带参数的方法set()：用参数设定时间
{
hour = h;
minute = m;
second = s;
}
类成员访问权限的语法细则
公有权限public
私有权限private
保护权限protected
默认权限(未指定访问权限)
对象的定义与访问
定义对象
1.使用new运算符
2.引用及引用变量:
Clock obj1;
// 预先定义一个Clock类型的引用变量obj1
// 此时obj1的引用值为null，即还未引用任何对象
obj1 = new Clock( );
//上述两条语句可简写为一条语句：
Clock obj1 = new Clock( );
3.注意："="两边类型应当一致
访问对象
1.成员运算符"."
对象名.字段名
对象名.方法名(实参列表)
2.访问字段与方法
访问钟表对象的 公有成员
Clock obj1 = new Clock( ); // 创建一个钟表对象obj1
obj1.set( ); // 调用对象obj1的公有方法set()，输入时分秒数据
obj1.show( ); // 调用对象obj1的公有方法show()，显示其时间
可以用钟表类Clock定义 多个钟表对象
Clock obj2 = new Clock( ); // 创建第二个钟表对象obj2
obj2.set( 8, 30, 15 );
// 调用对象obj2的公有方法set()，设置时间8:30:15
obj2.show( ); // 调用对象obj2的公有方法show()，显示其时间
一个对象可以被 多次引用
Clock obj ; // 再定义一个Clock类的引用变量obj
obj = obj1;
// 赋值后，obj与obj1引用同一个对象，该对象被引用了2次
obj.set( 12, 0, 0);
// 通过引用变量obj操作钟表对象，将其时间设为12:0:0
obj.show( ); // 显示对象的时间，显示结果应为：12:0:0
obj1.show( );
// 显示obj1所引用对象的时间，显示结果也为：12:0:0
数据类型
基本数据类型
byte、short、int、
long、float、double、
char、boolean
1.Java语言中，使用基本数据类型定义变量，定义时直接为变量分配内存单元
2.后续程序将通过变量名访问变量的内存单元
引用数据类型
类类型、数组类型、接口类型、枚举类型等
1.先定义引用数据类型的引用变量
2.再用运算符new创建引用数据类型的对象，并将所返回的对象引用保存到引用变量中
3.后续程序通过引用变量访问对象及其下属成员
变量及对象的内存分配
栈内存(程序内存)：基本数据类型(程序中定义的局部变量)、引用数据类型(对象的定义)
堆内存(系统内存)：对象中定义的变量
三种不同的变量
1.字段：定义在类中的变量成员，用于保存属性数据。
字段相当于是类中的全局变量，可以被类中的所有方法成员访问
2.局部变量：类中方法成员在方法体中定义的变量，仅能在所定义的方法体或复合语句中访问
3.形式参数（形参）：类中方法成员在头部小括号里面定义的变量，用于接收原始数据。形参仅能在所定义的方法体中访问
注：Java语言中没有全局变量的概念
数据传递
传递基本数据类型数据 时直接传递数值，即值传递。
传递引用数据类型的对象 时所传递的是对象引用（不是对象本身），这被称为是引用传递。
类与对象的编译原理
类代码的编译
public void set( int h, int m, int s )
{
hour = h;
minute = m;
second = s;
}
↓编译后
public void set( Clock this, int h, int m, int s )
{
this.hour = h;
this.minute = m;
this.second = s;
}
————————————————————————————————
public void show( )
{
System.out.println(hour +”:” +minute +”:” +second );
}
↓编译后
public void show( Clock this )
{
System.out.println(this.hour +”:” +this.minute +”:” +this.second );
}
调用对象方法成员语句的编译
Clock obj1 = new Clock( ); // 创建钟表对象obj1
obj1.set( 8, 0, 0 ); // 将obj1的时间设为8:0:0
obj1.show( ); // 显示obj1的时间，显示结果：8:0:0
set( obj1, 8, 0, 0 );
void set(Clock this, int h, int m, int s) { … }
this.hour = h; this.minute = m; this.second = s;
show( obj1 );
同类的多个对象在内存中共用一份方法代码
Clock obj1 = new Clock( ); // 创建钟表对象obj1
Clock obj2 = new Clock( ); // 创建钟表对象obj2
obj1.set( 8, 0, 0 );
obj2.set( 9, 30, 15 );
set( obj1, 8, 0, 0 );
set( obj2, 9, 30, 15 );
void set(Clock this, int h, int m, int s) { … }
1.程序员在编写方法成员代码时，形参this是隐含的，在方法体中访问其他类成员也不需要添加this引用，这些都由编译器在编译时自动添加
2.程序员可以在访问类成员时显式添加“this.”，也可以通过this获取当前对象的引用，或把this作为实参将当前对象的引用继续传递给其他方法
3.程序员还可以利用this来区分与形参或局部变量重名的字段
public void set( int hour, int minute, int s )
{
this.hour = hour; // “this.hour”指代的是字段hour
this.minute = minute; // “this.minute”指代的是字段minute
second = s; // 形参s与字段second不重名，可以不用this
}
类的构造方法
规定：
1.构造方法的名字必须与类名相同
2.构造方法通过形参传递初始值，实现对新建对象字段成员的初始化
3.构造方法可以重载，即定义多个同名的构造方法，这样可以提供多种形式的初始化方法
4.构造方法没有返回值，定义时不能写返回值类型，写void也不行
5.构造方法通常是类外调用，其访问权限不能设为private
格式：
类名( ) { } // 默认构造方法
初始化对象(带形参与无形参的构造方法)
public Clock( int p1, int p2, int p3 ) // 带形参的构造方法
{
hour = p1;
minute = p2;
second = p3;
}
public Clock( ) // 不带形参的构造方法
{
this( 0, 0, 0 ); // 调用本类重载的带形参构造方法（须为第一条语句）
// hour = 0; minute = 0; second = 0; // 或直接赋值
}
Clock obj1 = new Clock( 8, 30, 15 ); // 给了实参，将调用带形参的构造方法
Clock obj2 = new Clock( ); // 未给实参，将调用不带形参的构造方法
Clock obj = obj1; // 未实际创建对象，不会调用构造方法
拷贝构造方法
public Clock( Clock oldObj )
{
hour = oldObj.hour;
minute = oldObj.minute;
second = oldObj.second;
}
Clock obj1 = new Clock( 8, 30, 15 );
Clock obj2 = new Clock( obj1 );
显示对象的创建过程
public Clock( ) // 不带形参的构造方法
{
hour = 0;
minute = 0;
second = 0;
System.out.println( “Clock( ) called.” ); // 添加显示信息的语句
}
public Clock( int p1, int p2, int p3 ) // 带形参的构造方法
{
hour = p1;
minute = p2;
second = p3;
System.out.println( “Clock(int p1, int p2, int p3) called.” ); // 添加显示信息的语句
}
public Clock( Clock oldObj ) // 拷贝构造方法
{
hour = oldObj.hour;
minute = oldObj.minute;
second = oldObj.second;
System.out.println( “Clock( Clock oldObj ) called.” ); // 添加显示信息的语句
}
Clock obj1 = new Clock( ); // 未给实参：Clock( ) called.
Clock obj2 = new Clock( 8, 30, 15 ); // 给3个int型实参：Clock(int p1, int p2, int p3) called.
Clock obj3 = new Clock( obj2 ); // 给1个Clock型实参：Clock( Clock oldObj ) called.
类的静态成员
public class Clock { // 定义钟表类Clock
public static int totalClock = 0; // 定义一个静态字段，记录已创建的Clock对象个数
private static void plusObj( ) { totalClock ++; } // 定义一个静态方法，将计数加1
private int hour, minute, second; // 字段成员
}
Clock c1 = new Clock( ); // 创建第一个对象c1
Clock c2 = new Clock( ); // 创建第二个对象c2
System.out.println( Clock . totalClock ); // 通过类名访问静态成员totalClock
System.out.println( c1 . totalClock ); // 或通过任一对象引用（c1或c2）访问静态成员
System.out.println( c2 . totalClock );
静态变量详解析
Java语言不允许在类外定义全局变量或函数
1.关键字static：在类中定义静态字段需使用关键字static进行限定，通常放在访问权限之后，数据类型之前。定义静态字段时可以初始化
2.在本类访问静态字段：在本类的方法成员中访问静态字段，直接使用字段名访问，访问时不受权限约束。这一点与访问普通字段是一样的
3.不能通过this访问静态字段：静态字段是类字段，没有包含在对象中，因此不能使用关键字this访问静态字段。这一点与访问普通字段是不一样的。注：this是指向当前对象的引用变量
4.在类外访问静态字段：在类外其他方法（例如主方法）中访问静态字段需以“类名.静态字段名”的形式访问，或通过任何一个该类对象引用以“对象引用名.静态字段名”的形式访问。类外访问静态字段受权限约束。在类外访问静态字段时可以不创建对象，直接通过类名访问Clock. totalClock
5.静态方法访问本类其他成员：静态方法只能访问本类中的静态字段，不能访问实例字段，因为静态方法可以在没有创建任何对象的情况下直接调用，而实例字段必须在对象创建之后才会分配内存空间，因而不能访问。静态方法只能调用本类中的其他静态方法，不能调用实例方法，因为实例方法可能会间接访问实例字段
静态成员的应用
1.以类的形式管理全局变量或外部函数
2.将具有相同属性值的字段提炼出来，定义成静态字段，这样可以让所有对象共用同一个静态字段，从而减少内存占用。
3.将专门处理静态字段的方法定义成静态方法
public class MathTest { // 测试类：测试Java语言中数学类Math的静态成员
public static void main(String[] args) { // 主方法
System.out.println( "random()= " +Math.random() ); // 随机数函数（静态方法）
System.out.println( "random()= " +Math.random() );
System.out.println( "sqrt(36)= " +Math.sqrt(36) ); // 求平方根函数（静态方法）
System.out.println( "sin(30)= " +Math.sin(30 *Math.PI/180) ); // 正弦函数（静态方法） }
}
}