Java 类和对象中的一些知识点梳理

系统管理员 2024-03-30 11:36 31阅读 0赞

**目录**

1、参数的值传递

2、垃圾回收机制

3、Java 中的 this 关键字

4、对类和成员的访问控制

5、static 关键字

6、静态初始化块和普通的实例代码块

--------------------

#### 1、参数的值传递 ####

基本类型的参数，如 int 或 double，都是按值传递给方法的。这意味着对参数值的任何更改都只存在于该方法的范围内。当方法返回时，参数就消失了，对它们的任何更改也都丢失了。这里有一个例子：// Java 中都是值传递

public class PassPrimitiveByValue {
    
        public static void main(String[] args) {
            int x = 3;
               
            // invoke passMethod() with x as argument
            passMethod(x);
               
            // print x to see if its value has changed
            System.out.println("After invoking passMethod, x = " + x);
        }
        // change parameter in passMethod()
        public static void passMethod(int p) {
            p = 10;
        }
    }

当你运行这个程序时，输出是：

After invoking passMethod, x = 3

#### 2、垃圾回收机制 ####

Java 运行时环境当确定对象不再被使用时，会删除对象。这个过程称为垃圾收集。

当不再有对该对象的引用时，该对象才有资格进入到垃圾收集过程。通过将变量设置为特殊值 null，可以显式地删除该对象的引用。一个程序可以对同一个对象有多个引用；在对象符合垃圾收集条件之前，必须删除对对象的所有引用。

Java 运行时环境有一个垃圾收集器，它会定期释放不再引用的对象所使用的内存。垃圾收集器在确定时间合适时候会自动执行其工作。

#### 3、Java 中的 this 关键字 ####

在实例方法或构造函数中，this 是对当前对象的引用。可以使用 this 从实例方法或构造函数中引用当前对象的任何成员。

**this 和字段一起使用**

使用 this 关键字最常见原因是，方法或构造函数参数遮蔽了字段。例如，Point 类是这样编写的：

public class Point {
        public int x = 0;
        public int y = 0;
            
        //constructor
        public Point(int a, int b) {
            x = a;
            y = b;
        }
    }

但也可以写成这样：

public class Point {
        public int x = 0;
        public int y = 0;
            
        //constructor
        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

构造函数的每个参数都遮蔽了对象的一个字段——在构造函数内部，x是构造函数第一个参数。要引用 Point 字段 x，构造函数必须使用 this.x。

**this 与构造函数一起使用**

在构造函数内部，还可以使用 this 关键字调用同一类中的另一个构造函数。这种做法称为显式构造函数调用。

public class Rectangle {
        private int x, y;
        private int width, height;
            
        public Rectangle() {
            this(0, 0, 1, 1);
        }
        public Rectangle(int width, int height) {
            this(0, 0, width, height);
        }
        public Rectangle(int x, int y, int width, int height) {
            this.x = x;
            this.y = y;
            this.width = width;
            this.height = height;
        }
        ...
    }

#### 4、对类和成员的访问控制 ####

访问级别的修饰符可以决定其他类是否可以使用类中特定的字段或调用特定的方法。Java 有两个级别的访问控制:

*  类级别——public 或 package-private (没有显式修饰符)。
 *  成员级别——public, private, protected, or package-private (no explicit modifier)。

**类：**如果一个类用修饰符 public 声明，在这种情况下，该类对任何地方的所有类都是可见的。如果一个类没有修饰符(默认的，也称为 package-private)，那么它只在它自己的包中可见。

**成员：**跟类声明一样，你可以使用 public 修饰符或不使用修饰符(package-private)，这些修饰符与修饰类时一样，都具有相同的含义。但是对于成员，还有两个额外的访问修饰符：private 和 protected。private 修饰符指定该成员只能在其自己的类中进行访问。protected 修饰符指定该成员只能在其自己的包中进行访问(与package-private一样)，此外，还可以被其类在另一个包中的子类进行访问。

下表显示了每个修饰符允许对成员的访问权限：

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td>Modifier</td> 
 <td>Class</td> 
 <td>Package</td> 
 <td>Subclass</td> 
 <td>World</td> 
 </tr> 
 <tr> 
 <td>public</td> 
 <td>Y</td> 
 <td>Y</td> 
 <td>Y</td> 
 <td>Y</td> 
 </tr> 
 <tr> 
 <td>protected</td> 
 <td>Y</td> 
 <td>Y</td> 
 <td>Y</td> 
 <td>N</td> 
 </tr> 
 <tr> 
 <td>no modifier</td> 
 <td>Y</td> 
 <td>Y</td> 
 <td>N</td> 
 <td>N</td> 
 </tr> 
 <tr> 
 <td>private</td> 
 <td>Y</td> 
 <td>N</td> 
 <td>N</td> 
 <td>N</td> 
 </tr> 
 </tbody> 
</table>

#### 5、static 关键字 ####

**static 修饰变量**

如果希望定义对所有对象都通用的变量，可以使用 static 修饰符进行修饰。声明中带有 static 修饰符的字段称为静态字段或类变量。它们与类进行关联，而不是与对象进行关联。类的每个实例共享一个类变量，该变量位于内存中的一个固定位置。任何对象都可以改变类变量的值，但是也可以在不创建类对象的情况下操作类变量。

例如，你想要创建一些 Bicycle 对象，并为每个对象分配一个序列号，第一个对象从1开始。这个 ID 号对于每个对象都是唯一的，因此这是一个实例变量。与此同时，还需要有一个字段用来跟踪已经创建了多少个 Bicycle 对象，以便知道将什么 ID 分配给下一个对象。这样的字段与任何单独的对象都无关，而是与整个类相关。因此，定义了一个类变量 numberOfBicycles，如下所示：

public class Bicycle {
            
        private int cadence;
        private int gear;
        private int speed;
            
        // add an instance variable for the object ID
        private int id;
        
        // add a class variable for the number of Bicycle objects instantiated
        private static int numberOfBicycles = 0;
            ...
    }

类变量由类名本身引用，如：

Bicycle.numberOfBicycles // 推荐引用方式
    // 虽然也可以通过类的实例进行引用，但并不鼓励，因为这样做并没有明确表示它们是类变量。
    myBike.numberOfBicycles // 不推荐引用方式

你可以在 Bicycle 构造函数中设置实例变量 id，并增加 numberOfBicycles 类变量的值：

public class Bicycle {
            
        private int cadence;
        private int gear;
        private int speed;
        private int id;
        private static int numberOfBicycles = 0;
            
        public Bicycle(int startCadence, int startSpeed, int startGear){
            gear = startGear;
            cadence = startCadence;
            speed = startSpeed;
    
            // increment number of Bicycles and assign ID number
            id = ++numberOfBicycles;
        }
    
        // new method to return the ID instance variable
        public int getID() {
            return id;
        }
            ...
    }

**static 修饰方法**

Java 支持静态方法和静态变量。静态方法，在其声明中用关键字 static 修饰，应该用类名调用，而不需要创建类的实例，如：

// 虽然也可以通过类的实例进行调用，但并不鼓励，因为这样做并没有明确表示它们是类方法。
    ClassName.methodName(args)

类方法不能直接访问类中的实例变量或实例方法——它们必须使用对象引用。而且，类方法不能使用 this 关键字，因为没有 this 的实例可以引用。

**static 定义常量**

static 修饰符与 final 修饰符一起用于定义常量。final 修饰符表示该字段的值不能更改。例如，下面的变量声明定义了一个名为 PI 的常量，其值是 PI 的近似值(圆的周长与直径的比值)：

static final double PI = 3.141592653589793;

以这种方式定义的常量不能再重新赋值，如果有程序这样做，则会出现编译时错误。按照惯例，常量值的名称用大写字母拼写。如果名称由一个以上的单词组成，单词之间用下划线进行分隔。

#### 6、静态初始化块和普通的实例代码块 ####

**静态初始化块**

你通常可以在声明中为字段提供一个初始值：

public class BedAndBreakfast {
    
        // initialize to 10
        public static int capacity = 10;
    
        // initialize to false
        private boolean full = false;
    }

当初始化值可用并且初始化可以放在一行上进行时，这种方法可以工作得很好。但是，这种初始化形式由于简单而具有局限性。如果初始化时需要一些额外的逻辑(例如，错误处理或填充复杂数组的 for 循环)，那么，上述简单的赋值是不够的。实例变量可以在构造函数中初始化，在构造函数中可以使用错误处理或其他逻辑。为了给类变量提供相同的功能，Java 提供了静态初始化块。// 一项技术出现的原因，总是因为解决了对应的问题

静态初始化块是用大括号 \{\} 括起来的普通代码块，前面有static关键字。这里有一个例子:

static {
        // whatever code is needed for initialization goes here
    }

一个类可以有任意数量的静态初始化块，它们可以出现在类中的任何地方。运行时系统会保证静态初始化块会按照它们在源代码中出现的顺序被调用。// 一个静态初始化块只会被调用一次

有一个替代静态块的方法——你可以写一个私有静态方法：

class Whatever {
        public static varType myVar = initializeClassVariable();
            
        private static varType initializeClassVariable() {
    
            // initialization code goes here
        }
    }

使用私有静态方法的优点是，如果需要重新初始化类变量，还可以重用它们。

**普通的实例代码块**

通常，会在构造函数中放入初始化实例变量的代码。使用构造函数初始化实例变量有两种选择：初始化块和 final 方法。实例变量的初始化块看起来就像静态初始化块，但是没有static关键字:

{
        // whatever code is needed for initialization goes here
    }

Java 编译器会将初始化代码块复制到每一个构造函数中。因此，这种方法可用于在多个构造函数之间共享代码块。

**final 方法不能在子类中重写**。下面是一个使用 final 方法初始化实例变量的例子：

class Whatever {
        private varType myVar = initializeInstanceVariable();
            
        protected final varType initializeInstanceVariable() {
    
            // initialization code goes here
        }
    }

如果子类可能希望能重用初始化方法，上述代码会尤其有用。该方法是 final 的，因为在实例初始化期间调用非 final 方法会导致问题。