语句块，是用花括号扩起的任意数量的简单Java语句。块确定了局部变量的作用域。块中的程序代码，作为一个整体，是一起执行的。块可以被嵌套在另一个块中，但是不能在两个嵌套的块内声明同名的变量。语句块可以使用外部的变量，而外部不能使用语句块中定义的变量，因为语句块中定义的变量作用域只限于语句块。

方法是用来完成特定功能的代码片段，类似于函数。

方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
方法声明格式：

[修饰符]   返回值类型    方法名(形式参数列表){

Java语句；… … …

}

方法的调用方式：
  对象名.方法名(实参列表)
  方法的详细说明
  1. 形式参数：在方法声明时用的没有确定值比如(int a,int b)。
  2. 实参：调用方法时实际传给方法的数据。
  3. 返回值：方法在执行完毕后返还给调用它的环境的数据。
  4. 返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为为void。
  5. 方法调用:若声明时有static修饰则可直接调用若无则需要new一个新对象

 public class FangFa {
 public static void main(String[] args) {
    int num1 = 10;
    int num2 = 20;
    //调用求和的方法：将num1与num2的值传给add方法中的n1与n2
    // 求完和后将结果返回，用sum接收结果。有static时
    int sum = add(num1, num2);
    System.out.println("sum = " + sum);//输出：sum = 30
    //无satic时
    FangFa s=new FangFa();//new时要用该类名
    s.print();
}
/** 求和的方法 */
public static int add(int n1, int n2) {
    int sum = n1 + n2;
    return sum;//使用return返回计算的结果
    }
void print(){
    System.out.println("我喜欢你！");

Java 表达式，语句和代码块
在本教程中，您将借助示例学习Java表达式，Java语句，表达式与语句之间的区别以及Java块。
在前面的章节中，我们使用了表达式，语句和块，而没有对其进行太多解释。既然您已经了解了变量，运算符和字面量，那么将更容易理解这些概念。
Java表达式
Java表达式由变量，运算符，字面量和方法调用组成。要了解有关方法调用的更多信息，请访问Java方法。例如，
int score;
score = 90;
score = 90是一个返回int数据类型的表达式。再看一个实例，
Double a = 2.2, b = 3.4, result;
result = a + b - 3.4;
在这里，a + b - 3.4是一个表达。
if (number1 == number2)
System.out.println("1比2大");
这里number1 == number2是一个返回布尔值的表达式。同样，"1比2大"是一个字符串表达式。
Java语句
在Java中，每个语句都是完整的执行单元。例如，
int score = 9*5;
在这里，我们有一个声明。这句话的完整执行涉及9和5乘法整数，然后将结果分配给变量score。
在上面的语句中，我们有一个表达式9 * 5。在Java中，表达式是语句的一部分。
表达式语句
我们可以通过使用终止表达式来将表达式转换为语句;。这些称为表达式语句。例如，
// 表达式
number = 10
// 语句
number = 10;
在上面的实例中，我们有一个表达式number = 10。在这里，通过添加分号(;)，我们已经将表达式转换为一条语句(number = 10;)。
再看一个实例，
// 表达式
++number
// 语句
++number;
同样，++number是表达式，而++number;是语句。
声明语句
在Java中，声明语句用于声明变量。例如，
Double tax = 9.5;
上面的语句声明了一个tax的变量,并初始化值为9.5。
注意：Java中的决策和循环中使用了一些控制流语句。您将在后面的章节中了解控制流语句。
Java 代码块
块是用大括号括起来的一组语句(零个或多个){ }。例如，class Main {
public static void main(String[] args) {
String band = "Beatles";
if (band == "Beatles") { // 开始代码块
System.out.print("Hey ");
System.out.print("Jude!");
} //结束代码块
}
}
输出：Hey Jude!
在上面的示例中，我们有一个if {....}代码块。
在此，在块内，我们有两个语句：System.out.print("Hey ");
System.out.print("Jude!");
但是，一个块可以没有任何语句。例如以下示例，class Main {
public static void main(String[] args) {
if (10 > 5) { // 开始代码块
} // 结束代码块
}
}
这是有效的Java程序。在这里，我们有一个if {...}代码块。但是，此块内没有任何语句。class AssignmentOperator {
public static void main(String[] args) {  // 开始代码块
} //结束代码块
}
在这里，我们有public static void main() {...}代码块。但是，类似于上面的示例，此块没有任何语句。

1、java中存在块语句，块语句分为四种
1、静态块
2、普通块
3、构造块
4、同步块
静态块的执行时机是在class文件装载的时候;静态块只会执行一次，
多个静态块的时候，按出现顺序执行，存放类的信息，用来在生成类之前进行的初始化，对一些static 变量赋值。如果某些代码必须要在项目启动时候就执行的时候，我们可以采用静态代码块，这种代码是主动执行的。普通块存在于方法体中，用于设置变量的作用域，构造块，初始对象信息，每创建一个对象，初始化一次，先于构造器执行当一个类有很多个构造方法，每个构造方法里都要重复执行一段代码时，可以把这段代码放入进构造块中，每次创建对象时都会被执行。同步块:请点下面：其中，在一个类中，静态块，构造方法和构造块的执行顺序为：(类第一次加载的时候)父类静态块，子类的静态块，父类的构造块，父类的构造方法，子类的构造块，子类的构造方法程序代码如下：Parent:
public class Parent {
{
System.out.println("我是父类的普通语句块");
}
Parent(){
System.out.println("我是父类的构造方法");
}
static{
System.out.println("我是父类的静态语句块");
}
}Child:
public class Child extends Parent{
static {
System.out.println("我是子类的静态语句块");
}
{
System.out.println("我是子类的普通语句块");
}
Child(){
System.out.println("我是子类的构造方法");
}
}
Test:
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
Child child = new Child();
}
}
程序的输出如下：
2、引用分类(不是引用类型分类)从JDK1.2版本开始，把对象的引用分为四种级别，从而使程序能更加灵活的控制对象的生命周期。这四种级别由高到低依次为：强引用、软引用、弱引用和虚引用。1、强引用：2、软引用3、弱引用4、虚引用请看下面的网址：

Java代码块教程
代码块是指使用 {}括起来的一段代码，根据位置声明的不同，代码块可以分为普通代码块、构造块、静态代码块和同步代码块。
Java代码块详解
语法
{}
参数
参数
描述
{}
在 {} 里面写的代码，{} 包围起来的数据就是代码块
说明
在 Java语言中，代码块就是被 {} 包围起来的代码语句。
案例
普通代码块
普通代码块就是指直接在方法或者是在语句中定义的代码块。
package com.haicoder.net.chunk;
public class ChunkTest{
public static void main(String[] args){
System.out.println("嗨客网(www.haicoder.net)");
{
String name = "嗨客网";
System.out.println("\n普通代码块里面  -> name : " + name);
}
String name = "www.haicoder.net";
System.out.println("\n普通代码块外面 -> name : " + name);
}
}
运行结果如下：
我们看到普通的代码块是写在方法里面的，它的代码块里面和代码块外面变量不会影响，他们之间是隔离开来的。
构造块
构造块是写在类里面的写的代码块。我们定义一个类，用来封装构造块。
package com.haicoder.net.chunk;
public class Chunk{
{
System.out.println("1 嗨客网 构造块在构造方法之前");
}
public Chunk(){
System.out.println("3 嗨客网 构造方法");
}
{
System.out.println("2 嗨客网 构造块在构造方法之后");
}
}
定义一个类，来调用封装好的代码块
package com.haicoder.net.chunk;
public class ChunkTest{
public static void main(String[] args){
System.out.println("嗨客网(www.haicoder.net)");
Chunk chunk = new Chunk();
}
}
运行结果如下：
我们可以看到，我们在构造方法的前后各自定义了一个方法块。我们会发现构造块里面语句会在构造方法里面的语句之前执行。
静态代码块
静态代码块，就是我们在 {} 方法块前面加
package com.haicoder.net.chunk;
public class Chunk{
{
System.out.println("2 嗨客网 构造块在构造方法之前");
}
static {
System.out.println("0 嗨客网 在构造方法前的静态代码块");
}
public Chunk(){
System.out.println("4 嗨客网 构造方法");
}
{
System.out.println("3 嗨客网 构造块在构造方法之后");
}
static {
System.out.println("1 嗨客网 在构造方法后的静态代码块");
}
}
调用定义了代码块的类：
package com.haicoder.net.chunk;
public class ChunkTest{
public static void main(String[] args){
System.out.println("嗨客网(www.haicoder.net)");
Chunk chunk = new Chunk();
Chunk chunk1 = new Chunk();
}
}
运行结果如下：
从运行结果我们可以看到，静态代码块会在构造块之前运行，然后是构造块，最后是构造函数。而且我们知道 static 是类维度的，所以无论我们创建多少个对象，静态代码块始终只执行一次。
Java代码块总结
在 {} 包起来的一段代码块，它里面可以定义一些特有的逻辑操作。在定义对象的时候，静态代码块的执行顺序是第一个，它执行仅执行一次。构造块是在类维度的，普通代码块是在方法维度的。