2021/1/4——2021/1/9Java阶段一学习总结

day01

流程控制语句

顺序结构语句：

按照代码执行的先后顺序，依次执行

选择结构语句：

1.if语句：

格式1：
	if(条件表达式){
	//输出体
	}
格式2：
	if（条件表达式）{
	//输出体
	}else{
	//输出体
	}
格式3：
	if（条件表达式）{
	
	}else if(条件表达式){

	}else{
	
	}

2.switch语句：

switch（）{
	case 值1:
		语句1;
	break;
	case 值2:
		语句2;
	break;
	case 值3:
		语句3;
	break;
	...
	default :
		语句n+1;
	break;
}

循环结构语句:

1.while语句:

//初始化语句;
while(条件表达式){
//循环体语句；
//步长语句；
}

2.do  while语句:

//初始化语句；
do{
//循环体语句；
//步长语句
}while（条件表达式）

3.for循环语句:

for（初始化语句;条件表达式;步长语句）{
//循环体语句；
}

4.for循环的嵌套：

       for(初始化语句;条件表达式;步长语句){
          //内层循环是外层循环的循环体语句
          for(初始化语句;条件表达式;步长语句){
                   循环体语句;
          }
      }
将内层循环看成是外层循环的循环体语句;

day02

跳转控制语句：

break:结束语句
continue:结束当前循环并立即进入下一次循环；
return:结束方法
break：
	（1）不能单独使用；
		（2）只能在switch和循环中使用；
comtinue：在循环中使用居多；

在Java中如何定义方法：

1.有具体返回值的方法：

权限修饰符 + 静态修饰符 + 具体的返回值类型 + 方法名(数据类型1 变量名1 ,数据类型2 变量名2 ,....){
       //完成的业务逻辑
        return 结果;
   }
 调用方法:
 	赋值调用

2.无具体返回值的方法:

权限修饰符+静态修饰符+返回值类型 +方法名(形参列表){
     没有return 语句 ;
     直接完成输出操作
    }

方法重载(overLoad)：

  含义:
          多个方法的方法名相同,参数列表不同,与返回值无关 ---将这些方法称为"方法重载"
  参数列表不同有两种情况
                 1)参数个数不同 (参数类型一致)
                  2)参数类型不一致(参数个数一致)

day03

数组

数组：能够存储同一数据类型元素的容器；
特点：既能够存储基本数据类型也能够存储引用数据类型
数组的定义格式:
		数据类型[]  变量名;
		数据类型    变量名[];
动态初始化格式:
		数据类型[] 变量名=new  数据类型{长度}；
静态初始化格式:
		数据类型[] 变量名={}；

Java中的内存分配

栈内存： 存储一些局部变量，在方法定义中或者方法声明上的变量；
		 堆内存：存储new出来的（创建对象）；
方法区：  存储一些字节码文件、字符串常量；
本地方法区： 和系统相关；
寄存器：  和cpu相关；

数组的基本应用

1.遍历数组：

核心代码:
        System.out.print("[");
        for (int x=0;x<arr.length;x++) {
            if (x == arr.length - 1) {
                System.out.println(arr[x] + "]");
            } else {
                System.out.print(arr[x] + ", ");
            }
        }

2.最值问题

最大值核心代码:
        int max=arr[0];
        for (int x=1;x<arr.length;x++){
            if(max<arr[x]){
                max=arr[x];
            }
        }
        return max;
最小值核心代码:
        int min=arr[0];
        for (int x=1;x<arr.length;x++){
            if(min>arr[x]){
                min=arr[x];
            }
        }
        return min;
    }

3.元素查找法：

核心代码:
        for (int x=0;x<arr.length;x++){
            if (key==arr[x]){
                return x;
            }
        }
        return -1;
    }

4.数组的逆序：

核心代码:
       for (int x=0;x<(arr.length)/2;x++){
            int temp=arr[x];
            arr[x]=arr[arr.length-1-x];
            arr[arr.length-1-x]=temp;
        }
    }

day04

基本数据类型和引用数据类型(数组)作为形式参数有什么特点

基本数据类型作为形式参数时，形参的改变对实参没有影响；
引用数据类型作为形式参数时，形参的改变回影响实际参数；

数组的高级排序----冒泡

核心代码:
        for (int a=0;a<arr.length-1;a++){
            for (int b=0;b<arr.length-1-a;b++){
                if (arr[b]>arr[b+1]){
                    int temp=arr[b];
                    arr[b]=arr[b+1];
                    arr[b+1]=temp;
                }
            }
        }

面向对象思想的特点:

1.将我们从执行者转换为指挥者；
2.将复杂过程情简单化；
3.符合现实生活的思想行为习惯；

类和对象的关系：

学生类 (统称)
    将事物的属性-----成员变量(类中,方法外)
                    (name,age,high,gender)

    将事物的行为-----成员方法(和我们之前学习的方法是一样的,去掉static)
                            public 有返回值类型 方法名(形式参数列表){
                                    return 结果;
                            }

                         public void 方法名(形式参数列表){
                                 输出...
                          }
测试类

    对象:描述具体事物
    创建对象的格式:
    类名 对象名 = new 类名() ;
    Student s = new Student() ;

    //给学生赋值:姓名,年龄,身高,性别
    对象名称.成员变量= 赋值;
    //使用学生的行为:访问成员方法
    对象名.方法名() ;

day05

成员变量和局部变量的区别

成员变量：成员变量的位置是在类中方法外，它在内存中的位置是在堆内存中，它会随着对象的创建而存在，
	随着对象创建结束后等待垃圾回收器回收，系统会根据它的类型对它进行默认初始化；
局部变量：局部变量的位置是在方法的定义或方法声明上的，它在内存中的位置是在栈内存中，
	它会随着方法的调用而而存在，方法调用一结束它也会随之消失，必须在使用它之前赋值，不赋值就会报错。

形式参数如果现在是一个类(除了String类),它作为参数传递有什么特点

String类作为形参传递,效果和基本数据类型作为形式参数传递是一样的                                                            
形参的改变不影响实际参数

匿名对象

格式：new  类名() ;
           new 类名().成员方法名() ; 访问当前类中的成员方法
特点:
       1)匿名对象:使用完毕,会立即垃圾回收器回收,节省内存空间!
           应用场景:都是在移动端使用居多---Android :基于Java (大部分都是使用匿名对象,节省内存)
       2)开发中,匿名对象使用一次即可,不要使用多次! (使用完毕,就立即被回收)
       3)匿名对象可以作为参数传递

封装

1.封装：将一个类中的成员变量(属性)私有化,对外提供公共的访问方法,来保证类的安全性
2.private关键字：被private修饰的成员变量,成员方法只能在本类中访问,外界类不能访问
3.目的:为了外界不能够直接访问