基本知识点

一.流程控制语句(下)

• 分支选择结构

  目录

  基本知识点

  一.流程控制语句(下)

  二.流程跳转语句

  三.方法

  四.数组

  五.面向对象基础

  六.封装

  特殊内容/技巧/算法

  一.死循环

  二.循环嵌套

  三.java内存分配原理

  四.数组的特殊算法

  五.while循环应用之获取任意长整数各位和

  ---

switch case语句

switch(变量或计算表达式){   //被比较的内容,可以是int/byte/short/char/String/枚举类型
    case 值1:                   //等于值1,则执行语句1
        语句1; 
        break;                   //结束switch
    case 值2:                   //等于值2,则执行语句2
        语句2;
        break;                   //结束switch
        ...
        ...
    defaut :                    //若以上结果没有匹配的,执行语句n
        语句n;
        break;                 //结束switch
}
//case后的值必须为常量//switch语句每一个case中必须添加break,否则会造成case穿透.有时可以利用case穿透减少代码量

• 循环结构

for循环

for(定义并初始化循环变量 ; 判断表达式 ; 循环控制语句/步长语句){
    循环体语句;
}
//先定义并初始化循环变量,再执行判断表达式,为真,则按顺序执行循环体语句,执行循环控制语句,再次执行//判断语句,重复以上步骤,知道判断表达式为假,结束循环

while循环

定义循环变量并初始化;
while(判断表达式){
    循环体语句;
    循环控制语句/步长语句;
}
//若判断表达式为真,则重复执行循环体语句和步长语句,直到判断表达式为假为止

do-while循环 ----(基本不用)

定义循环变量并初始化;
do{
    循环体语句;
    循环控制语句/步长语句;
}while(判断表达式)
//先执行一次循环体语句和步长语句,若判断表达式为真,则重复执行
//do-while循环至少会执行一次循环体语句

for循环和while循环的区别

for循环一般用于已知循环次数的情况,在开发中用的最多
while循环一般用于循环次数不明的情况,开发中也比较常见

从内存角度来看,for循环可以节省内存,因为它的循环变量定义在内部,循环结束后该部分内存即被释放,变量也就无法再被访问;
while循环的循环变量定义在外部,不会随循环结束被释放,可以一直被访问.

二.流程跳转语句

• break
  break ---- 结束,中断.用于switch语句和循环语句中,作用是结束switch比较或立即结束循环,一般需要嵌套在判断语句中

for(int i = 0;i < 5;i++){
    System.out.print(i+", ");
    if(i == 3){
        break;
    }
}
//1, 2, 3, 

• continue
  continue ---- 继续.用于循环语句中,作用是立即结束当次循环,开启下一次循环,一般嵌套在判断语句中

for(int i = 0;i < 5;i++){
    if(i == 3){
        continue;
    }
    System.out.print(i+", ");
}
//1, 2, 4, 5,  

• return
  return ---- 返回.用于方法中,作用是立即结束方法,并带回返回值

三.方法

• 用于实现某个功能的代码块就称为方法,又叫函数.可以分为带返回值类型的和不带返回值类型的
• 方法必须要先定义,再被调用才有意义
  定义方法的基本格式:

//带返回值类型的方法:
//1)确定返回值类型
//2)确定需要的参数列表
public static 返回值类型 方法名(参数类型1 变量名1,参数类型2 变量名2,...){
//参数列表可以为空,不需要参数
        用于实现预定功能的方法体;
        return 返回值类型的变量或返回值;
//这里的类型必须与方法声明中的返回值类型一致
}
//不带返回值类型的方法:public static void 方法名(参数类型1 变量名1,参数类型2 变量名2,...){
//参数列表可以为空,不需要参数
        用于实现预定功能的方法体;
}

调用方法的三种不同方式:

注:方法为无参方法(无形式参数)时,调用时也不用传递实参

//赋值调用,适用于带返回值的方法,推荐
数据类型 变量名 = 方法名(实际参数1,实际参数2,...);//数据类型与方法返回值类型一致

//输出调用,可用于带返回值的方法,较少使用
System.out.println(方法名(实际参数1,实际参数2,...));

//直接调用
方法名(实际参数1,实际参数2,...);

• 方法的重载

同一个类里边,方法名相同,参数列表不同(包括参数个数,参数类型,参数类型的顺序)的一系列方法称为方法的重载,在调用时,系统会自动根据参数列表判断调用哪个方法
方法重载可以有效扩大方法的使用范围,针对同一个业务逻辑,不需要根据参数列表的不同写多个不同名方法,增大记忆负担

四.数组

• 数组是用来存储一组相同类型数据的容器,它是一种引用类型,是一种特殊的类,在内存中的存储和基本数据类型有很大的不同
• 数组的定义和初始化

//静态初始化int[] arr = {1,2,3,4};
//动态初始化,系统默认初始化,整型为0,浮点0.0,字符/字符串/引用类型null
int[] arr = new int[4];

五.面向对象基础

• 面向对象三大思想特点

1)更符合我们日常的思想行为习惯
2)复杂事情简单化
3)从执行者变成指挥者

• 面向对象三大特点

封装,继承,多态

• 什么是类?

类是对真实世界中存在的一类事物的描述,包括其属性,行为
在代码中类用class定义,属性通过成员变量表达,如姓名,年龄;行为通过成员方法表达,如吃饭,睡觉

• 什么是对象?

对象是对类的实例化,类描述的是一种/一群/一类的特点,而对象是这一种/一群/一类种某一个特定的个体

• 类和对象的关系

可以理解为类是对象的一种规范,它规定了我这个类中所有的对象应该具有什么属性,可以做出哪些行为

六.封装

• 什么是封装

封装指的是在我们开发过程中,将内部的代码,实现方法,属性等细节隐藏起来,只留给外界少量的简洁的接口进行调用,提高内聚,降低耦合
封装可以通过权限修饰符private(私有的,不公开的)来实现,被关键字private修饰的属性和方法只能在本类中被调用,外界无法直接访问,但是可以通过公开的(public)setXXX()/getXXX()两种方法来实现对属性的间接访问
这样做的好处是可以提高代码,数据的安全性,可以通过if判断输入的数据是否合法,再决定是否存入数据库
对于不希望用户获取的属性可以只提供set方法,反之对于不希望用户修改的属性可以只提供get方法

---

---

特殊内容/技巧/算法

一.死循环

• 死循环指无法通过判断语句正常结束的循环.一般来说,开发中应该避免死循环,但有的时候也可以利用死循环完成特殊的事情,这时候必须配合if语句和break语句使用
  死循环格式:

for(;;){    //用for循环实现的死循环,一般不用
    循环体语句;
    if(判断语句){
        break;
    }
}
---------------------------------------------------------------------------------------------------------
while(true){   //用while循环实现的死循环,一般使用这种方法
    循环体语句;
     if(判断语句){
        break;
    }
}

二.循环嵌套

• 打印九九乘法表

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

        //第一层循环,控制行
        for (int i = 9;i >= 1;i--) {
            for (int j = 1; j <= 9; j++) {   //第二层循环控制列

                if (j < i) {
                    System.out.print("tt");
                }else {
                    int result = i * j;
                    System.out.print(i + "*" + j + "=" + result + "t");
                }
            }
            System.out.println();
        }
    }
}

三.java内存分配原理

• java程序在运行时,将内存分为以下五个部分:

栈:方法在被调用时会在栈中按照调用顺序自下而上为方法开辟一个栈帧,即"进栈",当方法调用结束后,关闭栈帧,即"出栈","先进后出";基本数据类型的局部变量就储存在各自所属栈帧中,当存储的是基本数据类型时,直接存储值,当存储的是引用类型数据时,存储的是其在堆空间中的地址值;

堆:用于存储各类对象的内存区域,在一个引用类型被"new"时(String除外),会在堆内存中为该对象申请一个空间,并为存储的数据赋值(静态初始化直接赋值;动态初始化系统自动赋值,整型/浮点赋值0,字符/引用类型赋值null,布尔类型赋值false),然后将该空间的地址值传递给其他指向该对象的变量,即可通过该地址值访问存储内容.方法区存储的内容不会主动消失,需要jvm在合适的时候启动垃圾回收器(GC)来清理不再使用的空间.

方法区:程序执行时,所用到的类会被加载到方法区,主要是各类的成员方法/静态方法/静态属性(多个对象的成员属性不共享,但成员方法是共享的,因此只需要加载一次),除此以外还有常量池

寄存器

本地方法区

• 基本数据类型内存使用情况图解

public class Test{
    public static void main(String[] args){
        int a =10;
        int b = 20;
        System.out.println("a:"+a+",b:"+b);   //a:10,b:20
        //调用change方法
        change(a,b);
        System.out.println("a:"+a+",b:"+b);   //a:10,b:20
        
    }
    //定义change方法
    public static void change(int a,int b){
        a = b;   //a = b = 20
        b = a + b;  //b = 20 + 20 = 40
    }
}

• 引用数据类型内存使用情况图解(以数组为例)

public class Test{
    public static void main(String[] args){
        int[] arr = new int[5];
        arr[2] = 4;
        System.out.println("arr[2] = "+arr[2]);    //arr[2] = 4
        //调用change方法
        change(arr);
        System.out.println("arr[2] = "+arr[2]);    //arr[2] = 8
    }
    //定义change方法
    public static void change(int[] arr){
        arr[2] *= 2; 
    }
}

• 由此可见,基本数据类型做参数时,形参改变不会影响实参
• 引用类型做参数时,传递的是地址值,指向同一个存储空间,因此形参改变直接影响实参

四.数组的特殊算法

• 求最值

public class ArrayTest{
    public static void main(String[] args){
        //定义并初始化一个数组
        int[] arr = {45,25,43,52,65};
        //使用for循环获取最大值(最小值同理)
        int max = arr[0];  //假设arr[0]为最大值
        for(int i = 1;i < arr.length;i++){
            if(arr[i] > max){
                max = arr[i];
            }
        }
        //输出
        System.out.println("max:"+max)    //max:65;
    }
}

• 冒泡排序

public class BubbleSortTest{
    public static void main(String[] args){
    
        //定义并初始化一个数组
        int[] arr = {12,58,25,36,26};
        //冒泡排序
        for (int i = 0; i < arr.length - 1; i++) {    //第一层循环,需要比较数组长度减一趟

            boolean flag = true;   //定义布尔变量,当当前趟没有发生交换时,结束循环

            for (int j = 0; j < arr.length - 1 - i; j++) {   //第二层循环,进行一趟比较

                if (arr[j] > arr[j + 1]){    //靠前的数值较大
                    flag = false;      //本趟发生交换
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;     //交换数据
                }
            }

            if (flag){
                break;     //当前趟没有发生交换,结束循环
            }
        }
        //输出排序后的数组
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {

            if(i == arr.length - 1){
                System.out.println(arr[i] + "]");
            }else{
                System.out.print(arr[i] + ", ");
            }
        }
        //[12, 25, 26, 36, 58]
    }
}

五.while循环应用之获取任意长整数各位和

public class Test{
    public static void main(String[] args){
        
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //提示并录入数据
        System.out.println("请输入一个整数:");
        int num = sc.nextInt();

        //定义结果变量
        int sum = 0;

        //使用while循环获取结果
        while(num != 0){
        
            sum += num % 10;    //各位相加
            num  /= 10;         //去除低位 
        }

        //输出
        System.out.println("这个数各位之和为:"+num);
    }
}