自学JAVA知识点总结 - 初级-第8页 - Aaron's Home -黄泽雨个人博客

记录与分享

自学JAVA知识点总结 - 初级

编程语言 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(静态):用来修饰类方法和类变量。

                 (1) 静态变量:声明独立于对象的静态变量,无论一个类实例化多少对象,它的静态变量只有一份拷贝;静态变量也被称为类变量;局部变量不能被声明为 static 变量。

                 (2) 静态方法:声明独立于对象的静态方法;静态方法不能使用类的非静态变量;静态方法从参数列表得到数据,然后计算这些数据。

 

               • final(最终):变量一旦赋值后,不能被重新赋值,成为常量。

final class test{ //类不能被继承,类似Math、String等
  final void study(){ //方法无法被子类重写,但可以被重载
    final int A = 10; //int变量a无法被重新赋值,成为常量。
    A = 20; //报错,无法被重新赋值
  }
}

 

               • abstract(抽象):变量一旦赋值后,不能被重新赋值,成为常量。

                 (1) 抽象类:不能用来实例化对象,声明抽象类的唯一目的是为了将来对该类进行扩充。

一个类不能同时被 abstract 和 final 修饰

                 (2) 抽象方法:一种没有任何实现的方法,该方法的的具体实现由子类提供。

抽象方法不能被声明成 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 修饰的成员变量在每次被线程访问时,都强制从共享内存中重新读取该成员变量的值。而且,当成员变量发生变化时,会强制线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。

 

 


↓ 点击翻页 ↓

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

分享