java学习之：类和对象、语句块、方法、递归结构！

语句块和方法

语句块

语句块确定了局部变量的作用域。语句块嵌套，但是不能在两个嵌套的块内声明同名的变量。语句块可以使用语句块外的变量，语句块中定义的变量作用域只限于语句块，所以外部不能使用语句块中定义的变量

public class Main {
    public static void main(String[] args) {
        int n;
        int a;
        {
            int k;
            int n; //编译错误：不能重复定义变量n
        } //变量k的作用域到此为止
    }
}

方法

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

方法的声明格式

[修饰符1  修饰符2  …]   返回值类型  方法名(形式参数列表){
    Java语句；… … … }

方法的调用格式

public class Main {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
        //调用求和的方法：将num1与num2的值传给add方法中的n1与n2
        // 求完和后将结果返回，用sum接收结果
        int sum = add(num1, num2);
        System.out.println("sum = " + sum);
    }
    /** 求和的方法 */
    public static int add(int n1, int n2) {
        int sum = n1 + n2;
        return sum; //使用return返回计算的结果
    }

结果：

sum = 30

注意

1.实参的数目、数据类型和次序与形参一致

2.return 可以终止方法的运行或返回数据。

3.基本类型传递的是该数据值的copy值。

递归结构

递归是一种常见的解决问题的方法，递归的基本思想就是自我调用，一个使用递归技术的方法将会直接或者间接的调用自己。

递归结构包括：

1.定义递归头。递归的结束条件

2.递归主体。调用自身方法的条件

例：递归计算n！

public class Main {
    public static void main(String[] args) {
        System.out.printf( factorial(10));
        long d2 = System.currentTimeMillis();
    }
    /** 求阶乘的方法*/
    static long  factorial(int n){
        if(n==1){  //递归头
            return 1;
        }else{  //递归体
            return n*factorial(n-1);//n! = n * (n-1)!
        }
    }
}

结果：

3628800

递归过程：

递归的缺陷

递归调用会占用大量内存，在递归调用层次多时速度要比循环慢的多 如：

public class Main {
    public static void main(String[] args) {
        long d1 = System.currentTimeMillis();  
        System.out.printf(actorial(10));
        long d2 = System.currentTimeMillis();
        System.out.printf(d2-d1); 
    }
    /** 求阶乘的方法*/
    static long  factorial(int n){
        if(n==1){  //递归头
            return 1;
        }else{  //递归体
            return n*factorial(n-1);//n! = n * (n-1)!
        }
    }
}

结果：

3628800
558

若用循环迭代的方法：

public class Main {
    public static void main(String[] args) {
        long d3 = System.currentTimeMillis();
        int a = 10;
        int result = 1;
        while (a > 1) {
            result *= a * (a - 1);
            a -= 2;
        }
        long d4 = System.currentTimeMillis();
        System.out.println(result);
        System.out.printf(d4 - d3);
    }
}

结果：

3628800
0

所以递归调用层次多时速度要比循环慢的多

类和对象

类

类（class）是既包括数据又包括对数据的操作的封装体。是许多对象的一个“模板”，是对某种类型的的对象定义变量和方法的原型。

类的声明：

class类名<泛型>[extends父类] [implements 接口列表]{

  成员变量的声明；

  成员方法的声明；

}

示例：简单学生类的定义

public class SxtStu {
    //属性（成员变量）
    int id;
    String sname;
    int age;  
    //方法
    void study(){
        System.out.println("我正在学习！");
    }  
    //构造方法
   SxtStu(){
   }
}

注：一个源文件必须有且只有一个public class，并且类名和文件名保持一致！

对象

对象（实例）是类的实例，任何一个对象都属于某个类。对象是动态的，每个对象都有自己的生命周期，都经历一个从创建、运行到消亡的变化过程。对象使用后将被完全销毁，释放所占的储存单元。

对象的创建

对象 = new 类的构造方法（[参数列表]）；

如：

s = new Student;

对象引用变量和调用方法：

对象.成员变量；

对象.成员方法（[参数列表]）

Java的内存分析

栈

栈描述的是方法执行的内存模型。每个方法被调用都会创建一个栈帧(存储局部变量、操作数、方法出口等)。栈的存储特性是“先进后出，后进先出”，栈是由系统自动分配，速度快!栈是一个连续的内存空间。

堆

堆是一个不连续的内存空间，分配灵活，速度慢。堆用于存储创建好的对象。

方法区（静态区）

方法区实际也是堆，用来存放程序中永远是不变或唯一的内容。(类信息【Class对象】、静态变量、字符串常量等)

示例：模拟学生使用电脑学习

class Computer {
    String brand;  //品牌
}
public class SxtStu {
    // field
    int id;
    String sname;
    int age;
    Computer comp;
    void study() {
        System.out.println("我正在学习！使用我们的电脑，"+comp.brand);
    }
    SxtStu() {
    }
    public static void main(String[] args) {
        SxtStu stu1 = new SxtStu();
        stu1.sname = "张三";
        Computer comp1 = new Computer();
         comp1.brand = "联想";
        stu1.comp = comp1;
        stu1.study();
    }
}

示例的内存分析图：

​​示例来源​​

构造方法

构造方法(constructor)，用于对象的初始化。构造方法为了对对象初始化。构造器的名称应与类的名称一致。Java通过new关键字来调用构造器，从而返回该类的实例。

声明格式

[修饰符] 类名(形参列表){
    //n条语句
}

如：

class Point {
    double x, y;
    public Point(double _x, double _y) {
        x = _x;
        y = _y;  
    }
    public class Main{
    public static void main(String[] args) {
        Point p = new Point(3.0, 4.0);
        Point origin = new Point(0.0, 0.0);
    }
}

构造方法中有返回值，但是不能通过return 来返回某个值，若没有定义构造方法，则编译器会自动定义一个无参数的构造函数。