控制语句 - 语句块、方法体、修饰符
语句块
-
- 语句块:语句块(有时叫做复合语句),是用{}扩起来的简单Java语句,确定了局部变量的作用域;语句块中的语句是一个整体,会被一起执行;语句块可以嵌套在另一个语句块中,但不能在两个嵌套的语句块内声明同名的变量;语句块可以使用外部定义的变量,但外部无法使用语句块中定义的变量,因为语句块中定义的变量作用于只限于语句块内。
public class Test{ public static void main(String[] args){ int a; int b; { int a; //编译错误,不可在嵌套语句块中重复定义变量a int c; //语句块中的语句 } //变量c作用于到此为止 } }
- 语句块:语句块(有时叫做复合语句),是用{}扩起来的简单Java语句,确定了局部变量的作用域;语句块中的语句是一个整体,会被一起执行;语句块可以嵌套在另一个语句块中,但不能在两个嵌套的语句块内声明同名的变量;语句块可以使用外部定义的变量,但外部无法使用语句块中定义的变量,因为语句块中定义的变量作用于只限于语句块内。
方法体
-
- 方法体:方法就是一段用来完成特定功能的代码片段,类似于其它语言的函数;用于定义该类(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("马奔跑,嘚嘚嘚嘚...."); } }
- 方法体:方法就是一段用来完成特定功能的代码片段,类似于其它语言的函数;用于定义该类(class)实例(对象)的行为特征和功能实现,可反复调用方法,执行方法内的语句。
• 方法名、形参列表相同
• 返回值类型和声明异常类型,子类小于等于父类
• 访问权限,子类大于等于父类
修饰符
-
- 访问修饰符: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 修饰的成员变量在每次被线程访问时,都强制从共享内存中重新读取该成员变量的值。而且,当成员变量发生变化时,会强制线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。
- static(静态):用来修饰类方法和类变量。