Java基础面向对象—类的声明

类定义 = 类声明 + 类体
如下：
类声明{//类体
成员变量声明;
构造方法声明;
成员方法声明;
初始化程序块;
}

类声明
[public] [abstract|final] class 类名 [extends 父类名] [implements 接口名列表]
{. . .}
public用来声明任何类均可访问该类
非public——只有与该类在同一package的类能够访问
一个java源文件中至多只能有一个public类，该类的类名与源文件名相同

abstract: 声明该类为抽象类（不能实例化出对象）
final: 声明该类不能被继承
extends：表示该类从父类继承得到。父类名可以是用户自定义的类, 也可以是Java预定义的类
implements：该类实现了接口名列表中的所有接口

——成员变量声明
[public|protected|private] [static] [final] [transient] [volatile] 类型 变量名;
public|protected|private: 成员变量的访问权限
static: 限制该成员变量为类变量（无static：该成员变量为实例变量）
final: 用于声明一个常量, 该常量的值在程序中不能修改
transient: 声明一个暂时性变量（不会被串行化）
volatile: 禁止编译器通过保存多线程共享变量的多个拷贝来提高效率
显式初始化: 成员变量声明中可以包含简单的赋值表达式，这种在声明成员变量时对变量的显式赋值称为显式初始化
例：

class Rectangle{
private int width = 0;
private int height = 0;
...
}

成员方法声明
[public|protected|private] [static] [final|abstract] [native] [synchronized] 返回类型 方法名 ([参数列表])
[throws 异常类型列表]
{ [语句块] }
public, protected, private, static：与成员变量类似，设定成员变量的访问权限
abstract：声明该方法是抽象方法，无方法体
final：声明该方法不能被重写
native：本地方法
synchronized：多线程访问共享数据
throws：抛出异常的列表

方法调用中的参数传递
要求（1）：实参与形参在次序和数量上匹配，并在类型上兼容
（2）：实参传递给形参的过程，是值传递的过程，具体可分为以下两种
——基本类型的参数：传值
——引用类型（对象或数组等）的参数：传递实参变量的值（一个指向对象或数组的引用），传递过后形参和实参均 指向同一个对象或数组
注意： 在方法体中将形参指向另一对象, 则实参变量所指向的对象不再受方法影响；
修改形参所指向的对象的内容, 则修改在方法结束后保留下来

（1）基本类型的参数，示例：

public class PassTest {
public void changeInt(int value) { // 基本类型的参数
value = 55;
}
public static void main(String args[]) {
int val;
PassTest pt = new PassTest();
val = 11;
pt.changeInt(val); // 基本类型参数的值传递
System.out.println(“Int value is: ”

可以看到，对于基本类型参数，在方法体内对参数重新复制，不会改变原有变量的值。这是因为基本类型数据的值就是数值本身，参数传递过程传递的是值的副本。同样，在方法体内对参数进行运算，也不影响原变量的值。

（2）引用类型的参数，示例：

public class PassTest {
public void changeStr(String value) { //引用类型参数
value = new String(“different”); //方法中改变形参所指对象
}
public static void main(String args[]) {
String str;
PassTest pt = new PassTest();
str = new String(“Hello”);
pt.changeStr(str); //引用类型参数的传递
System.out.println(“Str value is: ” + str);
}
}

可见，对于引用类型，在方法体内对方法参数进行重新赋予引用，并不会改变原有变量所持有的引用。但是，方法体内对参数所指向对象的属性进行运算，将改变原有变量所指向对象的属性值。
示例（3）：

public class PassTest {
float ptValue;
public void changeObjValue(PassTest ref) { //引用类型参数
ref.ptValue = 99.0f; //改变参数所指对象的成员变量值
}
public static void main(String args[]) {
PassTest pt = new PassTest();
pt.ptValue = 101.0f;
pt.changeObjValue(pt); //引用类型参数的传递
System.out.println(“Pt value is: ” + pt.ptValue);
}
}

运行结果：

在方法声明时需要注意的问题：
（1）关于可变长参数
——形式：类型 … 参数名
在方法内部将可变长参数作为数组对待；
可变长参数只能作为参数列表中最后一个参数。
例如：

public class VariousArgs{
public double ratingAverage(double r, int ... points){
int sum=0;
for(int p: points)
sum+=p;
return ((sum*r)/points.length);
}
public static void main(String[] args){
VariousArgs va=new VariousArgs();
System.out.println( va.ratingAverage(0.5, new int[]{95,90,85}) );
System.out.println( va.ratingAverage(0.5, 94,92,90,88,86));
}
}

运行截图：

（2）
若局部变量名与类的成员变量名相同，则类的成员变量被隐藏，需使用this将该成员显露出来。
例如：

public class UnmaskField{
private int x = 1;
private int y = 1;
public void changeFields(int a, int b) {
x = a; //x指成员变量
int y = b; //局部变量y使同名的类成员变量被隐藏
this.y = 8; //this.y指成员变量
System.out.println(“x=” + x + “; y=” + y); //局部变量y的值
}
public void PrintFields() { System.out.println(“x=” + x + “; y=” + y); }
public static void main(String args[]) {
UnmaskField uf = new UnmaskField();
uf.PrintFields();
uf.changeFields(10,9);
uf.PrintFields();
}
}

本文地址：https://blog.csdn.net/m0_46977476/article/details/110228131