Java访问一口气讲完！o(*≧▽≦)ツ┏━┓

Java this关键字

Java面向对象设计 - Java this关键字

什么是 this？

Java有一个名为 this 的关键字。它是对类的当前实例的引用。

它只能在实例的上下文中使用。

以下代码显示如何使用this关键字。

public class Main {
  int varA = 1;
  int varB = varA; // Assign value of varA to varB
  int varC = this.varA; // Assign value of varA to varC
}

当实例变量或类变量被具有相同名称的另一个变量隐藏时，我们需要使用关键字this限定一个实例变量，并使用类名称定义一个类变量。

使用 this 来区分当前对象。

Java 中为解决变量的命名冲突和不确定性问题，引入关键字 this 代表其所在方法的当前对象的引用：

1. 构造方法中指该构造器所创建的新对象；
2. 方法中指调用该方法的对象；
3. 在类本身的方法或构造器中引用该类的实例变量（全局变量）和方法。

this 只能用在构造器或者方法中，用于获得调用当前的构造器方法的对象引用。可以和任何的对象引用一样来处理这个this对象。

说明：

1. 当实例变量和局部变量重名，JAVA 平台会按照先局部变量、后实例变量的顺序寻找。即，方法中使用到的变量的寻找规律是先找局部变量，再找实例变量。如果没用找到，将会有一个编译错误而无法通过编译。
2. 如果使用 this.a，则不会在方法（局部变量）中寻找变量 a ,而是直接去实例变量中去寻找，如果寻找不到，则会有一个编译错误。
3. 在一个方法内，如果没有出现局部变量和实例变量重名的情况下，是否使用 this 关键字是没有区别的。
4. 在同一个类中，Java 普通方法的互相调用可以省略 ​this. ​，而直接使用方法名 + 参数。因为 Java 编译器会帮我们加上。

例子

下面的代码显示了如何使用 this 关键字来引用一个实例变量，它的名字被一个局部变量隐藏。

public class Main {
  int num = 2014; // An instance variable

  void printNum(int num) {
    System.out.println("Parameter num: " + num);
    System.out.println("Instance variable num: " + this.num);
  }

  public static void main(String[] args) {
    Main tt6 = new Main();
    tt6.printNum(2000);
  }
}

上面的代码生成以下结果。

注意

下面的代码显示了如何使用 this 关键字来引用一个实例变量，它的名字被一个局部变量隐藏。

例如，以下代码非常常见：

Student 类声明了一个实例变量 id。在其 setId() 方法中，它还命名参数 id，并使用 this.id 引用实例变量。

它还使用 this.id 在其 getId() 方法中引用实例变量id。

public class Student {
  private int id; // An instance variable

  public void setId(int id) {
    this.id = id;
  }

  public int getId() {

    return this.id;
  }
}

我们可以使用关键字 this 来限定实例方法名称。以下代码显示使用关键字 this 调用 m2() 方法的 m1() 方法。

public class Main {
  void m1() {
    // Invoke the m2() method
    this.m2(); // same as "m2();"
  }

  void m2() {
    // do something
  }
}

Java 访问级别成员

Java面向对象设计 - Java访问级别成员

类可以是public或default(或包级别)。

类成员的访问级别确定程序的哪个区域可以访问它。以下四个访问级别修饰符之一可以用于类成员：

• public
• private
• protected
• Default 或者 package-level访问

前三种类型的访问级别使用以下三个关键字之一指定：public，private或protected。

第四种类型称为默认访问级别（或包级别），并且通过不使用访问修饰符来指定。

如果使用 public 关键字将类成员声明为public，则可以从Java代码中的任何位置访问它，如果类本身是可访问的。

如果使用 private 关键字将类成员声明为private，则只能在声明类的主体内访问，而在其他任何地方都不能访问。

如果使用 protected 关键字将类成员声明为protected，则可以从同一个包或从类的后代访问，即使后代位于不同的包中也是如此。

如果我们不为类成员使用任何访问级别修改器，则它具有包级别访问权限。具有包级别访问权限的类成员可以从同一个包访问。

类成员的访问级别可以从最严格到最不严格，作为private，package-level，protected和public。

例子

以下代码显示如何使用不同的访问级别：

public class Main {
  private int num1; // private access level
  int num2; // package-level access
  protected int num3; // protected access level
  public int num4; // public access level

  public static int count = 1; // public access level

  // private access level
  private void m1() {
  }

  // package-level access
  void m2() {
  }

  // protected access level
  protected void m3() {
  }

  // public access level
  public void m4() {
  }

  // private access level
  private static void doSometing() {

  }
}

注意

可以为类的实例和静态成员指定访问级别。

它是一个约定，指定访问级别修改器作为声明中的第一个修饰符。

要声明静态公共字段，请首先使用 public 修饰符，然后使用 static 修饰符作为约定。

我们必须考虑类及其成员的访问级别，以确定类成员是否可访问。

以下代码显示了如何在创建Java bean时使用访问级别修饰符。

class Account {
  private double balance;

  public double getBalance() {
    return this.balance;
  }

  public int save(double amount) {
    if (amount < 0.0 || Double.isNaN(amount) || Double.isInfinite(amount)) {
      System.out.println("Invalid credit amount:  " + amount);
      return -1;
    }
    this.balance = this.balance + amount;
    return 1;
  }

  public int spend(double amount) {
    if (amount < 0.0 || Double.isNaN(amount) || Double.isInfinite(amount)) {
      System.out.println("Invalid debit amount:  " + amount);
      return -1;
    }
    if (this.balance < amount) {
      System.out.println("Insufficient  fund. Debit   attempted: " + amount);
      return -1;
    }
    this.balance = this.balance - amount;
    return 1;
  }
}

public class Main {
  public static void main(String[] args) {
    Account ac = new Account();
    double balance = ac.getBalance();
    System.out.println("Balance = " + balance);

    ac.save(2);
    ac.spend(1);

    balance = ac.getBalance();
    System.out.println("Balance = " + balance);

    // Attempt to credit and debit invalid amounts
    ac.save(-2);
    ac.spend(Double.POSITIVE_INFINITY);

    balance = ac.getBalance();
    System.out.println("Balance = " + balance);

    // Attempt to debit more than the balance
    ac.spend(200.00);

    balance = ac.getBalance();
    System.out.println("Balance = " + balance);
  }
}

上面的代码生成以下结果。

Java final关键字 

Java面向对象设计 - Java final关键字

final关键字不允许修改或替换其原始值或定义。

final关键字可以在以下三个上下文中使用：

• 变量声明
• 类声明
• 方法声明

final 变量

如果一个变量被声明为final，它只能被赋值一次。最终变量的值在设置后不能修改。

变量声明包括局部变量的声明，方法/构造函数的形式参数，实例变量和类变量。

变量声明包括局部变量的声明，方法/构造函数的形式参数，实例变量和类变量。

final int YES  = 1;

我们可以只设置一次final变量的值。

有两种方法来初始化final变量:

• 在声明时予以初始化。
• 将其初始化延迟到稍后的时间。

但是，我们必须在第一次读取最终变量之前初始化它。

• final局部变量

  你可以声明一个局部变量fi​​nal。如果将局部变量声明为空的最终变量，则必须在使用前初始化它。

• final参数

  我们可以声明一个参数final。当调用方法或构造函数时，参数将使用实际参数的值自动初始化。

  因此，您不能更改方法或构造函数体内的最终形式参数的值。

• final实例变量

  我们可以声明一个实例变量final和blank final。

  空白最终实例变量必须初始化一次，并且只有在调用类的任何构造函数时才初始化一次。

• final类变量

  我们可以声明一个类变量final和blank final。我们必须在其中一个静态初始化器中初始化一个空的最终类变量。

• final引用变量

  引用变量存储对象的引用。最终引用变量意味着，一旦引用一个对象（或null），它就不能被修改以引用另一个对象。

以下代码显示了test2()方法的最终形式参数x:

public void  test2(final int x)  {

如果我们有一个类的多个静态初始化器，我们必须在一个静态初始化器中初始化所有空的最终类变量一次。

public class Main {
  public static final int YES = 1;
  public static final int NO = 2;
  public static final String MSG;

  static {
    MSG = "final static variable";
  }
}

final 类

如果一个类被声明为final，它不能被扩展（或子类化）。

final 方法

如果一个方法声明为final，它不能在包含该方法的类的子类中重新定义（覆盖或隐藏）。

原文地址：https://blog.csdn.net/m0_69824302/article/details/142348294

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！