java学习第二天

Posted 2021-03-12 see-t2

循环结构

1. if语句

使用boolean表达式或boolean值作为选择条件，有三种结构形式

if-else语句和三元运算符
    从语义上二者的含义相同.
    从本质上说,if-else是语句结构,三元运算符是一种运算符号.
    三元运算符必须有一个结果,表达式必须有结果,必须有返回.
    而if-else,不能返回什么结果,只能控制语句的结构.

if---else if---else
    此时的else语句,表示上述所有条件都为false的时候才会执行的代码.

2. switch语句

switch支持的类型是byte，short，char，int。
本质:switch仅仅只能支持int类型.

case之后的表达式结果必须是常量

default表示,所有的case的值都不正确,一般放在switch的最后,也不需要使用break语句

3. if和switch的选择:

if和switch都属于选择语句,也就是说功能是相似的.

if: 判断条件是boolean类型的.
switch: 判断条件是 整数表达式 == int类型的值

选择:
如果是对整数表达式判断等于多少,首选使用switch.
其他情况,使用if语句.

4. 死循环

while(true){
    System.out.println("帅哥");
}

do{
    System.out.println("帅哥");
}while(true);

for(;;){
    System.out.println("帅哥");
}

5. 循环语句对比

for循环中只有boolean表达式不能打印HelloWorld，其他语句可以

一般情况下，指定次数的循环，选用for循环要方便点
for循环性能更高,变量定义在for循环里面,for循环执行完毕,就会释放该变量的存储空间

案例：矩形图案
三角形图案
九九乘法表
嵌套循环的总次数是内外两次循环相乘

6. 控制循环结构语句

break:
    终止当前所在的循环，break之后的语句执行不了

continue:
    跳过当前的循环，进入下一次循环操作

return:
    表示结束循环所在的方法，方法都结束了，循环结构自然也就结束了

break、continue、return后面的语句永远没有机会执行，所有不能再跟任何语句，否则编译失败

break和return都能结束当前循环，如果循环之后的操作还得执行:break

方法

方法定义（Method）：程序中完成独立功能，可重复使用的一段代码集合（其实就指一个特定的功能操作）

方法定义格式:

[修饰符] 返回值类型 方法名称([形式参数...]){
    方法体
    [return 值]
}
//方法必须要调用才能生效（看着菜单点菜）    main方法专门由JVM负责调用，我们只管启动JVM
如果方法使用static修饰：
    此时我们使用方法所在 类的名称.方法名(参数)
如果方法没有使用static修饰：
    此时我们得使用方法所在类的对象来调用

public class MethodDemo
{
    static void doWork(){
        System.out.println("共同的两百行代码");
    }
    public static void main(String[] args){
        System.out.println("代码片段A");
        MethodDemo.doWork();
        System.out.println("代码片段B");
        MethodDemo.doWork();
        System.out.println("代码片段C");
        MethodDemo.doWork();
        System.out.println("代码片段D");
        MethodDemo.doWork();
    }
}

方法定义的位置:

在类中定义，java中最小的程序单元是类
方法定义在其他方法之外，方法和方法之间是兄弟关系
方法定义的先后顺序不影响调用

2. 方法中的术语:

修饰符：static修饰的方法属于类，直接使用类名调用即可，现在都使用static修饰

返回值类型：方法完成的功能是否需要给调用者返回一个结果
            如果不需要给调用者返回结果，使用关键字void声明

方法名称：遵循标识符的规范，使用动词，首字母小写

形式参数：仅仅只是占位

参数列表：参数的类型+参数的个数+参数的循序
方法签名：方法名称 + 方法形参列表（在同一个类中方法签名是唯一的）

返回值：在方法内部，使用return关键字
            给调用者返回一个结果值，此时该方法不能使用void修饰
            结束当前方法

方法的调用：谁调用了方法，谁就是该方法的调用者

3. 如何设计方法

是否需要定义返回值类型?
是否需要形式参数?
无参数无返回    有参数无返回    无参数有返回    有参数有返回

针对有返回的方法，调用者必须定义一个变量去接收返回的结果

4. 方法重载设计

方法重载的定义：在同一个类中，某方法允许存在一个以上的同名方法，只要它们的参数列表不同即可

方法重载的作用：屏蔽了同一功能的方法由于参数不同造成方法名称不同

方法重载判断原则：`两同一不同`
    两同：同类中，方法名相同
    一不同：方法参数列表不同

注意：方法重载和方法的返回值类型无关，只是一般要求返回值类型一致

    public class OverloadDemo
{
    public static void main(String[] args){
        int sum1 = getSum(1,2);
        double sum2 = getSum(1.0, 2.0);
    }

    static int getSum(int x, int y){
        return x + y;
    }
    static double getSum(double x, double y){
        return x + y;
    }


}

为什么System.out.println()可以打印任意类型的数据?
多个println方法是重载关系

5. JVM内存模型，JVM内存划分，人为的根据不同内存空间的存储特点以及存储数据

程序计数器：当前线程所执行的字节码的行号指示器
本地方法栈：为虚拟机使用的native方法服务
JAVA虚拟机栈：
    描述java方法执行的内存模型，每个方法被执行的时候都会创建一个栈帧用于存储局部变量表、操作栈、动态链接、方法出口等信息
    
    每一个方法，创建一个栈帧，栈帧存放了当前方法的数据信息（局部变量），当方法调用完毕，该方法的栈帧就被销毁了
JAVA堆：
    被所有线程共享的一块内存区域，在虚拟机启动时创建。所有的对象实例以及数组都要在堆上分配（使用new关键字，就表示在堆中开辟一块新的存储空间）
方法区：
    线程共享的内存区域，存储已被虚拟机加载的类信息、常量、静态变量及时编译器编译后的代码数据等（这个区域的内存回收目标主要是针对常量池的回收和对类型的卸载）

6. GC（Garbage Collection）：垃圾回收器，java的自动垃圾回收机制

程序员不需要再手动的去控制内存的释放。当JVM发觉内存资源紧张时，就会自动地去清理无用对象（没有被引用到的对象）所占用的内存空间

Java的垃圾回收器，自动回收的是堆空间的内存，而栈空间内存会随着该方法的执行结束，自动释放该方法的栈帧内存

数组

1. 数组定义

什么是数组：
    把具有相同类型的若干变量按有序的形式组织起来的一种数据形式（按一定顺序排列的同类型数据的集合称为数组）
    
数组的定义：

int[] ages;//推荐方式
int ages[];

数组必须先初始化，才能使用，初始化表示在内存中分配空间

2. 初始化数组

静态初始化

int[] nums = new int[]{1,3,5,7,9};//推荐不简写
int[] nums = {1,3,5,7,9};

由我们自己来为每一个数组元素设置初始值，而数组长度由系统（JVM）决定

动态初始化

int[] ages = new int[100];

由我们来设置数组的元素个数（数组长度），而每一个数组元素的初始值由系统（JVM）决定

一旦初始化完成，数组的长度就固定了，不能改变

int[] arr1 = new int[]{};       
int[] arr2 = new int[0];    与   int[] arr3 = null;

3. 数组基本操作

获取、设置、遍历数组

public class ArrayOperateDemo1{
    public static void main(String[] args){
        int[] ages = new int[]{1,3,5,7,9};
        System.out.println(ages[0]);
        
        ages[0] = 100;
        System.out.println(ages[0]);

        for(int i = 0; i < ages.length; i++){
            System.out.println(ages[i]);
        }
    }
}

获取数组最大最小元素

//获取最大值
class ArrayOperateDemo2
{
    public static void main(String[] args){
        int[] ages = new int[]{1,3,5,7,9,-1};
        int max = ages[0];
        for(int i = 0; i < ages.length; i++){
            if(max < ages[i]){
                max = ages[i];
            }
        }
        System.out.println(max);
    }
}

按格式打印数组元素
    直接打印数组时，打印出来的是hashCode值

逆序排列数组元素

class ArrayOperateDemo4
{
    public static void main(String[] args){
        String[] arr = new String[]{"A", "B", "C", "D"};
        printArray(arr);

        String[] newArr = reverse(arr);
        printArray(newArr);
    }

    static String[] reverse(String[] oldArr){
        String[] newArray = new String[oldArr.length];
        for(int i = oldArr.length-1; i >=0; i--){
            newArray[oldArr.length-1-i] = oldArr[i];
            //i = 3             xxx = 0
            //i = 2             xxx = 1
            //i = 1             xxx = 2
        }
        return newArray;
    }
    
    static void printArray(String[] arr){
        String ret = "[";
        for(int i = 0; i < arr.length; i++){
            ret = ret + arr[i];
            if(i != arr.length-1){
                ret = ret + ",";
            }
        }
        ret += "]";
        System.out.println(ret);
    }
}

元素出现索引（第一次 indexOf、最后一次 lastIndexOf）线性查找

class ArraySearchDemo
{
    public static void main(String[] args){
        int[] arr = {20,30,10,50,10,-30};
        int beginIndex = indexOf(arr, 10);
        System.out.println(beginIndex);

        int lastIndex = lastIndexOf(arr, 10);
        System.out.println(lastIndex);
    }


    /*
        查询key元素在arr数组中第一次出现的位置
        参数：
            arr：从哪一个数组中去查询
            key：当前要去查询的元素
            返回；
                key存在于arr中，返回第一次出现的索引
                key不存在于arr数组中，返回-1

    */

    static int indexOf(int[] arr, int key){
        for(int i = 0; i < arr.length; i++){
            if(key == arr[i]){
                return i;
            }
        }
        return -1;
    }

    static int lastIndexOf(int[] arr, int key){
        for(int i = arr.length - 1; i >= 0; i--){
            if(key == arr[i]){
                return i;
            }
        
        }
        return -1;
    }
}

4. 操作数组常见异常

NullPointerException: 空指针异常（空引用）

String[] bs = null;
System.out.println(bs.length);

ArrayIndexOutOfBoundsException: 数组的索引越界异常

int[] ages = new int[]{1,3,5,7};
System.out.println(ages[4]);