Java静态方法_java怎么把string转成静态的

1.字符串拼接（复习）

仅对于下面理解输出有帮助
内容来自Java核心卷1 P45
与绝大多数的程序设计语言一样，Java语言允许使用 + 号连接（拼接）两个字符串。 当将一个字符串与一个非字符串的值进行拼接时，后者被转换成字符串

3.6.2 拼接
与绝大多数的程序设计语言一样，Java语言允许使用 + 号连接（拼接）两个字符串。
String expletive = "Expletive";
String PC13 = "deleted";
String message = expletive + PC13;
上述代码将“ Expletivedeleted” 赋给变量 message (注意， 单词之间没有空格， + 号按照
给定的次序将两个字符串拼接起来)。
当将一个字符串与一个非字符串的值进行拼接时，后者被转换成字符串（在第 5 章中可
以看到，任何一个 Java 对象都可以转换成字符串）。例如：
int age = 13;
String rating = "PC" + age;
rating 设置为“ PG13”。
这种特性通常用在输出语句中。例如：
System.out.println("The answer is " + answer);
这是一条合法的语句， 并且将会打印出所希望的结果（因为单词 is 后面加了一个空格， 输出
时也会加上这个空格）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.静态方法(好理解)

复习完方法再解面向对象的

一.体验程序

public class MethodTest01 {
    public static void main(String[] args) {
        int x=100;
        int y=100;
        int z=x+y;
        System.out.println(x+"+"+y+"="+z);
        add(10,20);
        add(39,20);
        MethodTest01.add(20,60);
    }
    public static void add(int a,int b)
    {
        int c=a+b;
        System.out.println(c);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

100+100=200
30
59
80
方法是可以完成某个特定功能并且可以被重复利用的代码片段

二.方法语法机制

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

① [修饰符列表]，此项是可选项，不是必须的，目前大家统一写成 public static，后面的 博客再说
② 返回值类型，此项可以是 java 语言当中任何一种数据类型，包括基本数据类型，也包括所有的引用数据类型，当然，如果一个方法执行结束之后不准备返回任何数据，则返回值类型必须写 void。返回值类型例如：byte,short,int,long,float,double,boolean,char,String,void 等
只要有“return”关键字的语句执行，当前方法必然结束，但不是整个程序结束
不能利用return返回多个值，以后用数组实现
区别
break 用来终止switch和离他最近的循环
return 用来终止离它最近的一个方法

调用方法语法形式

.那个点表示调用的意思

  MethodTest01.add(20,60);
1

如果在本类中，MethodTest01可以省略
类名.方法名(实际参数列表);

三.方法重载

方法重载（overload）是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。

public class OverloadTest01 {
    public static void main(String[] args) {

        System.out.println(sum(10,20));

        System.out.println(sum(20.0,30.0));
        System.out.println(sum(20L,50L));
    }

    public static int sum(int a,int b) {
        return a+b;
    }
    public static double sum(double a,double b){
        return  a+b;
    }
    public static long sum(Long a,Long b){
        return a+b;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

代码满足以下三个条件的时候构成方法重载
① 在同一个类当中。
② 方法名相同。
③ 参数列表不同：个数不同算不同，顺序不同算不同，类型不同也算不同。

public class OverloadTest02 {
    public static void main(String[] args) {
        m1();
        m1(10,20.0);
        m2(20.0,10);
        //m5();
        //m6();
    }
    public static void m1(){

    }
    public static void m1(int a,double b){
        System.out.println("int a,double b");
    }
    public static void m2(double a,int b){
        System.out.println("double a,int b");
    }
    /*

    public static int m5(){
        return 1;
    }
    public static double m5(){
        return 1.0;
    }
    public static void m6(){

    }
    static void m6(){
        
    }*/
}


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
31
32
33
34

int a,double b
double a,int b
从m5,m6可知方法重载与返回值类型，修饰符列表无关
引申：我们从System.out.println()中可以体会到println其实也是一种方法重载

四.方法递归

通俗理解：方法自己调用自己
当递归无结束条件，程序一定会发生StackOverflowError等异常
方法递归耗费空间内存比较大，能用for、while循环尽量代替，但在极少情况，不用递归，程序无法实现

public class RecursionTest02{
    public static void main(String[] args){
        int value1=sum(3);
        System.out.println(value1);
    }
    int result1=0;
    public static int sum(int n){
        if(n ==1)
            return 1;

        return n+sum(n-1);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

6
内存图分析