汉码未来

class MethodDemo1 {
    // 定义无参无返回值方法
    public void printText() {
        // 三条输出语句
        System.out.println("你好新同学");
        System.out.println("Java是就业前景最好的语言");
        System.out.println("学Java就来汉码未来");
    }
    
    public static void main(String[] args) {
	    // 实例化MethodDemo1类
	    MethodDemo1 methodDemo1 = new MethodDemo1();
	    // 调用printText方法
	    methodDemo1.printText();
	}	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class MethodDemo2 {
  	// 定义无参带返回值方法
  	public String getHelloStr() {
        // 初始化变量str
      	String str = "Hello World";
      	// 返回str
      	return str;
    }
  	
  	public static void main(String[] args) {
      	// 实例化MethodDemo2
      	MethodDemo2 methodDemo2 = new MethodDemo2();
      	// 调用getStr方法，并且使用result变量接收返回值
      	String result = methodDemo2.getHelloStr();
      	// 打印返回值
      	System.out.println(result);
    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class MethodDemo3 {
  	// 定义带参数无返回值方法
  	public void printArea(float a, float b) {  // 此处的 a,b 为参数变量
		float result = a * b;
      	System.out.println( "长方形面积为：" + result);
    }
  	
  	public static void main(String[] args) {
      	// 实例化MethodDemo3
      	MethodDemo3 methodDemo3 = new MethodDemo3();
      	// 初始化两个变量
      	float width = 12.3f;
      	float height = 20f;
      	// 调用printArea方法，并将 width、height变量作为参数传入
      	methodDemo3.printArea(width, height);
      	// 也可不提前初始化变量，直接传入浮点型字面量作为参数。
      	methodDemo3.printArea(10.2f, 2.5f);
    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class MethodDemo4 {
    // 定义带参数带返回值方法
    public int getSumOfSquares(int n) {
        int sum = 0;
        for (int i = 1; i <=n; i++) {
          	// 求i的平方，并加和赋值给sum
            sum += i * i;
        }
      	// 返回计算结果
        return sum;
    }

    public static void main(String[] args) {
        // 实例化MethodDemo4
        MethodDemo4 methodDemo4 = new MethodDemo4();
      	// 调用对象下getSumOfSquares方法，并用sumOfSquares变量接收返回结果
        int sumOfSquares = methodDemo4.getSumOfSquares(5);
        System.out.println("1到5的累加平方和为：" + sumOfSquares);
    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class MethodDemo5 {

    /**
     * 查找数组中元素是否包含指定元素
     * @param arr 待查找数组
     * @param element 所查找的元素
     * @return boolean 查找结果,true包含; false不包含
     */
    public boolean contains(int[] arr, int element) {
      	// 定义返回结果，默认为false，即未找到element元素
        boolean result = false;
        for (int value : arr) {
            if (value == element) {
              	// 找到了element元素，将变量更新为true，并跳出循环
                result = true;
                break;
            }
        }
        // 返回计算结果
        return result;
    }

    public static void main(String[] args) {
        // 实例化MethodDemo5
        MethodDemo5 methodDemo5 = new MethodDemo5();
        // 初始化一个数组
        int[] intArray = {1, 3, 5, 6, 7, 9};
        // 初始化待查找元素变量
        int element = 10;
        // 调用contains方法，并接收返回结果
        boolean contains = methodDemo5.contains(intArray, element);
        // 根据返回结果，输出内容
        if (contains) {
            System.out.println("数组intArray中包含元素" + element);
        } else {
            System.out.println("数组intArray中不包含元素" + element);
        }
    }}
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
35
36
37
38
39

class Car {
    public void speedUp(int speed) {
        System.out.println("小汽车加速前，速度为：" + speed);
        speed ++;
        System.out.println("小汽车加速后，速度为：" + speed);
    }

    public static void main(String[] args) {
        // 定义小汽车初始速度变量
        int speed = 10;
        // 实例化Car类，创建一个car对象
        Car car = new Car();
        // 调用car对象下的speed方法
        car.speedUp(speed);
        // 打印调用方法后速度参数的值
        System.out.println("调用speedUp方法后，调用方的speed参数为：" + speed);
    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class NBATeam {
	// 替换第一个球员方法
    public void replaceFirstPlayer(String[] players, String playerName) {
        // 替换第一个球员
        System.out.println("将第一个球员替换：");
        players[0] = playerName;
    }

    public static void main(String[] args) {
        String[] players = {"詹姆斯", "科比", "杜兰特", "乔丹"};

        System.out.println("球队中现有球员：");
        for (String player : players) {
            System.out.print(player + "\t");
        }
        System.out.println();
        
        // 创建team对象并调用其替换球员方法
        NBATeam team = new NBATeam();
        team.replaceFirstPlayer(players, "皮蓬");

        System.out.println("替换后球员：");
        for (String player : players) {
            System.out.print(player + "\t");
        }
    }}
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

class VariableParameter {
    public void sum(int... n) {
        int sum = 0;
      	// 可以对可变参数进行迭代
        for (int i: n) {
            sum = sum + i;
        }
        System.out.println("sum=" + sum);
    }

    public static void main(String[] args) {
        // 创建对象
        VariableParameter variableParameter = new VariableParameter();
        // 调用方法，传递一个参数
        variableParameter.sum(1);
        // 调用方法，传递两个参数
        variableParameter.sum(2, 3);
        // 调用方法，传递三个参数
        variableParameter.sum(5, 6, 7);
    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class VariableParameter1 {
    public void search(int element, int... elements) {
        boolean existed  = false;
        for (int e: elements) {
            if (e == element) {
                existed = true;
                break;
            }
        }
        if (existed) {
            System.out.println("找到元素：" + element);
        } else {
            System.out.println("未找到元素：" + element);
        }
    }

    public static void main(String[] args) {
        // 创建对象
        VariableParameter1 obj = new VariableParameter1();
        // 调用方法
        obj.search(2, 1,2,3,4);
        // 定义数组参数
        int[] arr = {1,2,3,4};
        // 将数组传递给可变参数列表
        obj.search(2, arr);
    }}
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

public class Student {
    public void study() {
        System.out.println("同学真好学!");
    }

    public void study(String name) {
        System.out.println(name + "同学真好学!");
    }

    public void study(String name, int age) {
        System.out.println(name + "同学真好学!" + "他今年" + age + "岁了");
    }

    public static void main(String[] args) {
        // 实例化学生对象
        Student student = new Student();
        // 调用无参数方法
        student.study();
        // 调用单参数方法
        student.study("Colorful");
        // 调用双参数方法
        student.study("小慕", 20);
    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24