JAVA 学习

Java循环

循环结构允许程序在特定条件满足时反复执行某段代码。Java中有三种主要的循环结构：for循环、while循环和do-while循环。

1. for循环

for循环通常用于需要明确循环次数的情况。基本语法如下：

1
2
3
java复制代码for (initialization; condition; update) {
    // 循环体
}
示例
1
2
3
4
5
6
7
8
9
10
java复制代码public class ForLoopExample {
    public static void main(String[] args) {
        // 计算0到9的和
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            sum += i;
        }
        System.out.println("Sum of 0 to 9 is: " + sum);
    }
}

2. while循环

while循环在每次迭代之前检查条件。如果条件为真，则执行循环体。基本语法如下：

1
2
3
java复制代码while (condition) {
    // 循环体
}
示例
1
2
3
4
5
6
7
8
9
10
11
12
java复制代码public class WhileLoopExample {
    public static void main(String[] args) {
        // 计算0到9的和
        int sum = 0;
        int i = 0;
        while (i < 10) {
            sum += i;
            i++;
        }
        System.out.println("Sum of 0 to 9 is: " + sum);
    }
}

3. do-while循环

do-while循环先执行循环体，然后检查条件。如果条件为真，则继续执行循环体。基本语法如下：

1
2
3
java复制代码do {
    // 循环体
} while (condition);
示例
1
2
3
4
5
6
7
8
9
10
11
12
java复制代码public class DoWhileLoopExample {
    public static void main(String[] args) {
        // 计算0到9的和
        int sum = 0;
        int i = 0;
        do {
            sum += i;
            i++;
        } while (i < 10);
        System.out.println("Sum of 0 to 9 is: " + sum);
    }
}

嵌套循环

循环中可以包含另一个循环，这被称为嵌套循环。最常见的使用场景是处理二维数组。

示例
1
2
3
4
5
6
7
8
9
10
11
java复制代码public class NestedLoopExample {
    public static void main(String[] args) {
        // 打印5x5星号矩阵
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

break和continue语句

  • break：用于终止循环。
  • continue：用于跳过当前迭代，继续下一次迭代。
示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
java复制代码public class BreakContinueExample {
    public static void main(String[] args) {
        // 使用break退出循环
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                break;
            }
            System.out.println("i = " + i);
        }

        // 使用continue跳过迭代
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) {
                continue;
            }
            System.out.println("i = " + i);
        }
    }
}

增强的for-each循环

用于遍历数组或集合的每个元素，语法简洁明了。主要用于读取，不适合修改元素值。

示例
1
2
3
4
5
6
7
8
java复制代码public class ForEachExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        for (int number : numbers) {
            System.out.println("Number: " + number);
        }
    }
}

Java数组概述

在Java中，数组是一种用于存储固定大小的相同类型元素的容器。数组的元素可以是基本数据类型（如int, char, float等）或对象类型（如String, Object等）。

静态数组和动态数组

  1. 静态数组：数组的大小在声明时就已经固定，不能改变。
  2. 动态数组：数组的大小可以在程序运行时动态确定。

静态数组

静态数组是指在声明数组时已经确定了数组的大小。以下是静态数组的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
java复制代码public class StaticArray {
    public static void main(String[] args) {
        int[] staticArray = new int[5]; // 声明一个大小为5的整数数组
        staticArray[0] = 10;
        staticArray[1] = 20;
        staticArray[2] = 30;
        staticArray[3] = 40;
        staticArray[4] = 50;

        // 遍历数组
        for (int i = 0; i < staticArray.length; i++) {
            System.out.println("Element at index " + i + ": " + staticArray[i]);
        }
    }
}

动态数组

动态数组的大小可以在运行时动态确定。你已经展示了一个二维数组的动态生成示例，以下是进一步的解释和示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
java复制代码import java.util.Arrays;

public class DynamicArray {
    public static void main(String[] args) {
        // 动态生成二维数组
        int[][] dynamicArray = new int[3][];
        dynamicArray[0] = new int[3];
        dynamicArray[1] = new int[2];
        dynamicArray[2] = new int[1];

        // 初始化数组
        for (int i = 0; i < dynamicArray.length; i++) {
            for (int j = 0; j < dynamicArray[i].length; j++) {
                dynamicArray[i][j] = i + j;
            }
        }

        // 打印数组
        for (int i = 0; i < dynamicArray.length; i++) {
            System.out.println("Row " + i + ": " + Arrays.toString(dynamicArray[i]));
        }
    }
}

数组操作

  1. 遍历数组：通过for循环或增强的for-each循环遍历数组元素。
  2. 数组排序：使用Arrays.sort(array)方法对数组进行排序。
  3. 数组复制：使用System.arraycopy()或Arrays.copyOf()方法复制数组。

示例：遍历和排序数组

1
2
3
4
5
6
7
8
9
10
11
12
13
import java.util.Arrays;
import java.util.Scanner;
//动态生成数组
public class A{
	   public static void main(String[] args)
	   {
		 int[][] a =new int[][]{{1,2,3},{3},{2,4}};
		    for(int[] i:a)
		   System.out.println(Arrays.toString(i));

	   }

}
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
import java.util.Arrays;

public class ArrayOperations {
    public static void main(String[] args) {
        int[] array = {5, 3, 8, 1, 2};

        // 遍历数组
        System.out.println("Original array:");
        for (int i : array) {
            System.out.print(i + " ");
        }
        System.out.println();

        // 数组排序
        Arrays.sort(array);
        System.out.println("Sorted array:");
        for (int i : array) {
            System.out.print(i + " ");
        }
        System.out.println();

        // 数组复制
        int[] copiedArray = Arrays.copyOf(array, array.length);
        System.out.println("Copied array:");
        for (int i : copiedArray) {
            System.out.print(i + " ");
        }
    }
}

JAVA 输入输出

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
import java.util.Scanner;

public class A {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        // 输入字符串
        System.out.print("Enter a string: ");
        String inputString = sc.nextLine();
        System.out.println("You entered string: " + inputString);
        
        // 输入整数
        System.out.print("Enter an integer: ");
        int inputInt = sc.nextInt();
        System.out.println("You entered integer: " + inputInt);
        
        // 输入浮点数
        System.out.print("Enter a float number: ");
        float inputFloat = sc.nextFloat();
        System.out.println("You entered float: " + inputFloat);
        
        // 输入布尔值
        System.out.print("Enter a boolean (true/false): ");
        boolean inputBoolean = sc.nextBoolean();
        System.out.println("You entered boolean: " + inputBoolean);
        
        // 输入单个字符
        System.out.print("Enter a character: ");
        char inputChar = sc.next().charAt(0); // 读取输入的第一个字符
        System.out.println("You entered character: " + inputChar);
        
        sc.close();
    }
}

这段代码展示了如何使用 Scanner 类从控制台接收不同类型的输入：

  1. 字符串输入 (nextLine()): 使用 nextLine() 方法可以接收用户输入的整行文本。
  2. 整数输入 (nextInt()): 使用 nextInt() 方法可以接收一个整数输入。
  3. 浮点数输入 (nextFloat()): 使用 nextFloat() 方法可以接收一个浮点数输入。
  4. 布尔值输入 (nextBoolean()): 使用 nextBoolean() 方法可以接收一个布尔值输入 (true 或 false)。
  5. 单个字符输入 (next().charAt(0)): 使用 next() 方法读取输入的字符串，再通过 charAt(0) 获取字符串的第一个字符作为输入的字符。

每次输入后，代码会打印出用户输入的值。记得在实际应用中，尤其是在接收不同类型的输入时，要确保输入的格式与你期望的一致，以避免出现异常。

格式输出

1
2
3
4
5
6
7
8
9
import java.util.Scanner;

public class A {
    public static void main(String[] args) {
        int i=6;
        System.out.printf("i的值为%d",i);
    }
}
按十进制方式输出i的值

类与对象

封装：

1
通过 private ,default,protected,public 关键字生成方法的封装，仅对外提供公共访问方式

示例一:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class A{
    private String username;
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }

}

class test {
    public static void main(String[] args) {
        A student1 = new A();
        student1.setUsername("li");
        String username=student1.getUsername();
        System.out.println(username);
    }

}
继承：
1
通过 extends
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
40
41
42
43
44
45
46
47
48
49
50
51
52
// Shape 类作为父类
abstract class Shape {
    // 抽象方法，子类需要实现这个方法
    public abstract double calculateArea();
}

// Circle 类继承自 Shape
class Circle extends Shape {
    private double radius;

    // 构造方法
    public Circle(double radius) {
        this.radius = radius;
    }

    // 实现父类的抽象方法来计算圆的面积
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

// Rectangle 类继承自 Shape
class Rectangle extends Shape {
    private double length;
    private double width;

    // 构造方法
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    // 实现父类的抽象方法来计算矩形的面积
    @Override
    public double calculateArea() {
        return length * width;
    }
}

// 测试类，展示多态的应用
public class ak47 {
    public static void main(String[] args) {
        // 使用多态性，父类引用指向子类对象
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(3, 4);

        // 调用各自的 calculateArea 方法，实际调用的是对应子类的方法
        System.out.println("圆的面积: " + circle.calculateArea());
        System.out.println("矩形的面积: " + rectangle.calculateArea());
    }
}
多态：
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
// 抽象类 Animal
abstract class Animal {
    // 抽象方法，子类需要实现这个方法
    public abstract void makeSound();
}

// Dog 类继承自 Animal
class Dog extends Animal {
    // 实现父类的抽象方法
    public void makeSound() {
        System.out.println("汪汪汪!");
    }
}

// Cat 类继承自 Animal
class Cat extends Animal {
    // 实现父类的抽象方法
    public void makeSound() {
        System.out.println("喵喵喵!");
    }
}

// 测试类，展示多态的应用
public class PolymorphismExample {
    public static void main(String[] args) {
        // 使用多态性，父类引用指向子类对象
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        // 调用各自的 makeSound 方法，实际调用的是对应子类的方法
        myDog.makeSound();
        myCat.makeSound();
    }
}
类的定义
1
2
3
4
[修饰符] class 类名 [extends 父类名] [implements 接口名] {
        
        //类体，包括雷达成员变量及方法
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Stu{
    //属性设为私有
    private int id=1;
    // 方法 get set 你自己定义的
    public void setId(int id){
        this.id =id;
    }
    public int getId(){
        return this.id;
    }
    //我自己定义的方法
    public void myprint()
    {
        System.out.println("miku");
    }

    //构造函数
    public Stu(){ }
    public Stu(int id){
        this.id=id;
    }


}