自学JAVA知识点总结 - 初级

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

语句块

• 语句块：语句块（有时叫做复合语句），是用{}扩起来的简单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 和 staticpublic abstract class SuperClass{
        abstract void m（）; //抽象方法
      }
       
      class SubClass extends SuperClass{
        void m（）{
          System.out.println（"test"）;
        }
      }

  • synchronized（同步）：同一时间只能被一个线程访问。
  • transient（过渡）：序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机（JVM）跳过该特定的变量。 该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。
  • volatile（易失）：volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。