控制语句 - 语句块、方法体、修饰符

语句块

- 语句块：语句块(有时叫做复合语句)，是用{}扩起来的简单Java语句，确定了局部变量的作用域；语句块中的语句是一个整体，会被一起执行；语句块可以嵌套在另一个语句块中，但不能在两个嵌套的语句块内声明同名的变量；语句块可以使用外部定义的变量，但外部无法使用语句块中定义的变量，因为语句块中定义的变量作用于只限于语句块内。
```
public class Test{
  public static void main(String[] args){
    int a;
    int b;
    {
      int a; //编译错误，不可在嵌套语句块中重复定义变量a
      int c; //语句块中的语句
    } //变量c作用于到此为止
  }
}
```

方法体

方法体：方法就是一段用来完成特定功能的代码片段，类似于其它语言的函数；用于定义该类(class)实例(对象)的行为特征和功能实现，可反复调用方法，执行方法内的语句。
面向对象中，整个程序的基本单位是类(class)，方法是从属于类和对象的。

// 方法声明格式
[修饰符1 修饰符2 ...] 返回值类型 方法名(形式参数列表){
  java语句;
}

// 方法例子
public class test {
  public static void main(String[] args) { //程序的入口，main方法，固定格式
    Animal c = new Animal(); //创建对象
    int b = c.dog(10, 20, 30)+1000; //实参，必须为int类型
    System.out.println(b);
  }
}
class Animal{
  int dog(int a, int b, int c) { //int类型的a,b,c是形式参数，没有具体的数据
    int sum = a+b+c; //当该方法被调用并将实参传递过来后，进行计算
    System.out.println("狗的数量：" + sum);
    return sum; //return作用：1.结束方法的运行 2.返回值
    System.out.println("这段不会返回"); //因为上面有return，这段代码将不会执行
  }
}

详细说明：
- 形式参数：又称虚拟变量，在方法声明时用于接受外界传入的数据，没有具体的数据。
- 实际参数：调用方法时实际传给方法的数据。
- 返回值：方法在执行完毕后返还给调用它的环境的数据。
- 返回值类型：事先约定的返回值的数据类型，如无返回值，必须指定为void。
注意事项：
- 实参的数目、数据类型和次序必须和所调用方法，声明的形式参数列表匹配。
- return 语句终止方法的运行并指定要返回的数据。
- Java中在方法调用时传递参数，遵循值传递的原则(传递的都是数据的副本，不影响原数据，但都指向同一个对象)。

方法重载（Overload）：方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。调用时，会根据不同的参数自动匹配对应的方法。只有形参类型、形参个数、形参顺序不同才能构成重载。
返回值不同、参数名称不同，不构成方法的重载

public class test {
  public static void main(String[] args) {
    dog(10, 20, 30); //对应方法一
    dog(10, 20); //对应方法二
    dog(10.5, 20.5); //对应方法三
  }
  
  // 方法一
  static void dog(int a, int b, int c) {
    int sum = a+b+c;
    System.out.println("狗的数量：" + sum);
  }
  
  //方法二
  static void dog(int a, int b) { //dog传递到这里时候会被重写为对应的值 int 10, 20
    int sum = a+b;
    System.out.println("狗的数量：" + sum);
  }
  
  //方法三
  static void dog(double a, double b) { //dog传递到这里时候会被重写为对应的值 double 10.5, 20.5
    double sum = a+b;
    System.out.println("狗的数量：" + sum);
  }
}

方法重写（Override）：子类通过重写父类的方法，可以用自身的行为替换父类的行为。方法的重写是实现多态的必要条件。

public class Test {
  public static void main(String[] args) {
    Horse h = new Horse();
    h.run(); //输出重写后的父类方法
  }
}
class Vehicle{
  public void run() {
    System.out.println("跑！");
  }
  public void stop() {
    System.out.println("停！");
  }
}

class Horse extends Vehicle{
  // 重写父类run方法
  public void run() {
    System.out.println("马奔跑，嘚嘚嘚嘚....");
  }
}

• 方法名、形参列表相同

• 返回值类型和声明异常类型，子类小于等于父类

• 访问权限，子类大于等于父类

修饰符

访问修饰符：Java 支持 4 种不同的访问权限，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。

访问控制权限

修饰符	当前类	同包内	同包子类	不同包子类	其他包
public(公共)	✔	✔	✔	✔	✔
protected(保护)	✔	✔	✔	✔
default(缺省)	✔	✔	✔
private(私有)	✔

可用范围

修饰符	类(class)	接口(interface)	方法(method)	变量(variables)
public(公共)	✔	✔	✔	✔
default(缺省)	✔	✔	✔	✔
protected(保护)			✔	✔
private(私有)			✔	✔

default(缺省)：即留空，不使用任何修饰符，在同包内可访问。
public(公共)：在同类内可访问。注意：不能修饰外部类
private(私有)：所属类可访问。

protected(保护)：对同包内的类和所有子类可访问。注意：不能修饰外部类。

package me.hzyis.test;
public class Test {
  public static void main(String[] args) {
      Test t = new Test();
      t.pr = 123; //同类可调用private修饰的变量
  }
  
  private int pr; //私有变量pr
  int def; //缺省使用默认权限
  protected int pro;
  public int pu;
}
class boy extends Test{
  void sayPr2() {
    //pr = 123; //不可用，因为pr变量是私有变量，不同类无法调用，即使是继承也不可用
    def = 123; //可用，因为def是defalut修饰，同包内的类都可以调用
    pro = 123; //可用，因为pro是protectied修饰，同包内的类都可以调用
    pu = 123; //可用，因为pu是public修饰，同包内的类都可以调用
  }
}
 
================================= 分割线 =================================

package me.hzyis.test2;
import me.hzyis.test.*;
public class Test2 {
  public static void main(String[] args) {
    Test t = new Test();
  }
}
class boy extends Test{
  void sayPr2() {
    //pr = 123; //不可用，因为pr变量是私有变量，不同类无法调用
    //def = 123; //不可用，因为def是default修饰，不同包的类无法调用
    pro = 123; //可用，因为pro是protectied修饰，不同包内的子类都可以调用
    pu = 123; //可用，因为pu是public修饰，不同包内的子类都可以调用
  }
}

非访问修饰符：为了实现一些其他的功能，Java 也提供了许多非访问修饰符。
- static(静态)：用来修饰类方法和类变量。
  - 静态变量：声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝；静态变量也被称为类变量；局部变量不能被声明为 static 变量。
  - 静态方法：声明独立于对象的静态方法；静态方法不能使用类的非静态变量；静态方法从参数列表得到数据，然后计算这些数据。
- final(最终)：变量一旦赋值后，不能被重新赋值，成为常量。
```
final class test{ //类不能被继承，类似Math、String等
  final void study(){ //方法无法被子类重写，但可以被重载
    final int A = 10; //int变量a无法被重新赋值，成为常量。
    A = 20; //报错，无法被重新赋值
  }
}
```
- abstract(抽象)：变量一旦赋值后，不能被重新赋值，成为常量。
  - 抽象类：不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
    一个类不能同时被 abstract 和 final 修饰
  - 抽象方法：一种没有任何实现的方法，该方法的的具体实现由子类提供。
    抽象方法不能被声明成 final 和 static
```
public abstract class SuperClass{
  abstract void m(); //抽象方法
}
 
class SubClass extends SuperClass{
  void m(){
    System.out.println("test");
  }
}
```
- synchronized(同步)：同一时间只能被一个线程访问。
- transient(过渡)：序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。
- volatile(易失)：volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

自学JAVA知识点总结 - 初级

控制语句 - 语句块、方法体、修饰符

语句块

方法体

修饰符