Java某课学习总结 第二节

WanBaiCheng
102 阅读4分钟

选择结构

if

单个if

boolean flag = true;
if(flag) {
    System.out.prinlnt("结果是true");
}

$ 结果是true

if/else

boolean flag = false;
if(flag) {
    System.out.prinlnt("结果是true");
} else {
    System.out.prinlnt("结果是false");
}

$ 结果是false

if/else if/else

int index = 2;
if(flag == 1) {
    System.out.prinlnt("结果是1");
} else if(flag == 2){
    System.out.prinlnt("结果是2");
} else {
    System.out.prinlnt("结果不是1或者2");
}

$ 结果是2

switch

int i = 1; 
switch(i) {
    case 1: System.out.println("结果是1");
    default: System.out.println("没有匹配到结果");
}

$ 结果是1
  没有匹配到结果

case关键字用于匹配switch后面括号的内容, 匹配到就会执行冒号后面的执行语句 default关键字 是用于 当前面的所有case 没有一个匹配到时候 就会执行default后面的执行语句

执行结果出现了case 1配置执行语句 还有default默认执行的语句 出现这种情况是因为末尾没有break关键字 那么匹配到i=1的时候 还会继续往下匹配执行

int i = 1; 
switch(i) {
    case 1: System.out.println("结果是1");break;
    default: System.out.println("没有匹配到结果");
}

$ 结果是1

加上break关键字 结果就正常了

循环结构

for

for(int i = 0; i < 10; i++) {}

for的括号中 可以放三个表达式 分别用分号分隔

  • 第一个表达式是条件 可以用于初始化的循环值
  • 第二个表达式是循环的条件 为true就会继续执行 反之就会停止循环
  • 第三个表示是每次循环执行的操作
for(;;){} // 死循环 因为没有结束的条件
// 第一个表达式为空 循环值可以定义在外面
int i = 0;
for(; i < 10; i++) {}
// 第二个表达式为空
for(int j = 0; ;j++) {} // 死循环 没有结束条件
// 第三个表达式为空
for(int z = 0; z < 10;) {} // 死循环 没有递增条件 所以z永远小于10

三个表达式都不是必填的 可以空缺 但是分号不能空缺

for(int i = 0, j = 0; i <= 10, j <= 5; i++, j++) {}

用逗号分隔 可以写多个条件

for(;;) {
    for(;;) {}
}

也可以嵌套循环, 外面的循环叫外重循环, 里面的循环叫内重循环

while

while(true){}

while括号中 只有判断条件 只要判断条件一直满足就一直循环

上面的代码 就是个死循环 因为一直为true

do while

do{
    // 循环体
} while(循环条件);

do..while 跟while相比 do..while会先执行一次循环体 然后再去判断循环条件 是否进行下次循环

而while跟for都是先判断循环条件 不满足 就不进行循环

break/continue 关键字

在上述的三种循环中 都是可以使用break和continue关键字的

break

for(int i = 0; i< 2; i++) {
    if(i == 1) { break; }
    System.out.println(i);
}

$ 0

上面代码值输出一个结果的原因是 当i=1的时候 执行了break break关键字 是用于直接跳出循环的

switch中使用break关键字 也是用于跳出的

continue

for(int i = 0; i< 2; i++) {
    if(i == 1) { continue; }
    System.out.println(i);
}

$ 0
$ 2

输出上面结果的原因是 当i=1的时候 执行了continue continue关键字的作用是 跳过当前循环,执行下次循环

一维数组

语法格式

  • 数据类型[] 数组名
  • 数组类型 数组名[]
String[] str;
String str2[];

数组的创建

// 声明的同时并创建数组
int[] arr = new int[100]; // 声明并创建了一个长度为100的int类型的数组

//  注意: 数组长度是必须指定

数组的初始化

int[] arr = {1, 2, 3};
// 此时数组的长度就是初始化时给数组的元素的个数

数组的引用

int[] arr = {1, 2, 3};

数组下标从0开始 如果想要取第一个元素 就要arr[0] 去取值

数组的长度

int[] arr = {1, 2, 3};
System.out.println(arr.lenght);

$ 3

lenght属性表示数组的长度

其他类型的数组

int[] arr = {1, 2, 3};
char[] chs = {'a', 'b'};
String[] strs = {"aa", "bb"};
...

增强性for循环

int[] arr = {1, 2, 3};
for(int n:arr) {
    System.out.println(n);
}

$ 1
$ 2 
$ 3

增强for就是又叫为forEach循环

上图中 n表示遍历的每一项 而n前面关键字表示为n的类型, n冒号右边就是要用for遍历的变量

二维数组

int[][] intArr = new int[3][3];
float[] floatArr[] = new float[4][4];
// [行][列]
// 行不能省略 列可以省略(不能相反)
double doubleArr = new double[5][];
// 二维数组初始化
int[][] num = {{1,2,3}, {4,5,6}};
// 二维数组的每行的长度可以不一样
int[][] num2 = {{1,2}, {3,4,5,6}};

方法

class Test{
    // 这是一个方法
    public static void main(String[] args) {}
}

Scanner sc = new Scanner(System.in);
sc.next();  // 这是方法
sc.nextInt(); // 这是方法

方法声明

访问修饰符 返回类型 方法名(参数列表) {
    方法体
}

方法分类

  • 无参无返回值方法
  • 无参有返回值方法
  • 有参无返回值方法
  • 有参有返回值方法

无参无返回值方法

class Test {
    int a = 10;
    int b = 5;
    
    // 无参无返回值方法
    public void sum() {
        int count = a  + b;
        System.out.prinlnt(count);
    }
}

无参有返回值方法

class Test {
    int a = 10;
    int b = 5;
    
    // 无参有返回值方法
    public int sum() {
        int count = a  + b;
        return count;
    }
    
    public static void main(String[] args) {
        Test test = new Test();
        int sumValue = test.sum();
        System.out.prinlnt(sumValue);
    }
}

有参无返回值方法

class Test {
    int a = 10;
    int b = 5;
    
    // 有参无返回值方法
    public void sum(int a, int b) {
        int count = a  + b;
       System.out.prinlnt(count);
    }
    
    public static void main(String[] args) {
        Test test = new Test();
        test.sum(a, b);
    }
}

有参有返回值方法

class Test {
    int a = 10;
    int b = 5;
    
    // 有参有返回值方法
    public int sum(int a, int b) {
        int count = a  + b;
        return count;
    }
    
    public static void main(String[] args) {
        Test test = new Test();
        int count = test.sum(a, b);
        System.out.println(count);
    }
}

数组作为方法参数

public void sum(int[] intArr) {}

方法的重载

重载就是同一个方法名, 但是传入的参数数量不同或者类型不同 执行对应的不同的同名方法

class Sum {
    // 方法一
    public void sum() { System.out.println("我是普通的方法一"); }
    
    // 参数不同会触发 方法一的重载
    public void sum(int a) { System.out.println("我是参数数量不同触发方法一"); }
    // 参数数量不同会触发 方法一的重载
    public void sum(int a, int b) { }
    // 参数类型不同会触发 方法一的重载
    public void sum(boolean a) { System.out.println("我是参数类型不同触发方法一"); }
    
    // 返回值不同 不会触发重载
    public int sum() {}
    // 参数名不同 不会触发重载
    public int sum(int b) {}
}

class Test {
    public stativ void main(String[] args) {
        Sum sumInstance = new Sum();
        sumInstance.sum();
        sumInstance.sum(10);
        sumInstance.sum(true);
    }
}

$ 我是普通的方法一
$ 我是参数数量不同触发方法一
$ 我是参数类型不同触发方法一

基本数据类型和引用数据类型在方法中的传值

基本数据类型在方法的传值

class Test {

    public void num(int a, int b) { 
        a = 100;
        b = 200;
    }
    
    public stativ void main(String[] args) {
        int a = 10, b = 5;
        Sum sumInstance = new Sum();
        System.out.println(a, b);
        sumInstance.num(a, b);
        System.out.println(a, b);
    }
}

$ 10 5
$ 10 5

发现调用了num方法 在num中改变a/b的值 不会影响到外部

外部两次的打印都是10 5

引用数据类型在方法的传值

class Test {

    public void num(int[] arr) { 
       arr[0] = 10;
    }
    
    public stativ void main(String[] args) {
        int[] arr = {1, 2, 3};
        Sum sumInstance = new Sum();
        System.out.println(arr[0]);
        sumInstance.num(arr);
        System.out.println(arr[0]);
    }
}

$ 1
$ 10

发现调用了num方法 num方法内部的修改 会影响传入的数组

基本数据类型和引用数据类型有这样的区别

是因为 基本数据类型在方法中传参时是会复制栈中的值 而 引用数据类型在方法传参的时候 传入的是对应在栈中的引用地址

引用数据类型 在内存中表现 真正的数据会存放在堆中 栈中存放是堆地址中的引用 变量的赋值操作 操作是栈中的引用地址

可变参数列表

public void sum(int...n) {}

上述代码表示 无论传多少个变量 都会被n接收 所以n是个int类型的数组

public void sum(int a, int...n) {}

如果有两个以上参数 可变参数 是一定要放在最后

class Test {
    public void sum(int...n) {}

    public static void main(String[] args){ 
        Test test = new Test();
        int[] arr = {1, 2, 3};
        test.sum(arr); // 可以传入数组
        test.sum(1,2,3,4);  // 也可以传入多个参数
    }
}

可变参数列表 是可以直接传入数组的

class Test {
    public void sum(int[] arr) {}

    public static void main(String[] args){ 
        Test test = new Test();
        int[] arr = {1, 2, 3};
        test.sum(arr); // 可以传入数组
        test.sum(1,2,3,4);  // 不能传入多个参数
    }
}

当方法的类型是个数组时 那么方法就不能传入多个参数

可变参数列表作为参数时 可以传多个参数 或者 传入数组 但是 数组作为参数时 就只能传入数组

public void sum(int...n, int...y) {} // 编译报错

一个方法只能有一个可变参数列表

class Test {
    public void sum(int a) {}
    public void sum(int...n) {}
}

当使用可变参数列表重载时 可变参数列表的方法是最后访问的

文档注释

/**
 * main方法的文档注释
 */
public void main() {}

在编辑器敲入/** 再按回车键就会生成文档注释

javadoc命令

javadoc的命令 是用于根据文档注释生成文档的

$ javadoc -d doc xxx.java

上述命令的意思是 -d 指定目录 然后对xxx.java生成文档 放到-d 后面的目录中

avatar
文章
阅读
粉丝