一.回顾运算符：

一．控制语句

1.1 顺序结构 (最常见的)

特点：代码从上往下依次执行

1.2 选择结构 ：

<1.if 判断语句 ：

格式一

/*
1.if(判断条件){
2.    如果符合条件执行的代码;
3.    执行的代码块1；
4.    执行的代码块2；
5.    ……………….；
6.    执行的代码块n；
7.}
*/

格式二

/*
if(判断条件){
      如果符合条件执行的代码;
      执行的代码块1；
   } else{
      执行的代码块2；
}
*/

格式三

/*
if(外部的条件成立) {
    执行代码块1
    if（内部的条件成立）{
        执行代码块2
    }
}
*/

<2.switch语句

switch 判断语句：

Switch语句使用的注意事项：

1.每一个语句结束后需要有一个break,防止switch的穿透

2.switch语句中用于判断的额变量只能是int ,short,char,byte String(jdk7之后才有)

Case后面跟的数据必须是常量。

switch语句的优点 ：语句结构清晰，运行速率快。

switch语句的缺点：

If能过做的switch不一定能做，switch能够做的if一定可以实现。

1.3循环结构

/*
<1.while语句
While循环 ： 先判断在执行
结构：
while(循环条件){
循环体。
}
*/

<2.do while语句

/*
do while循环：先执行后判断，循环体一定会执行一次.
结构:
do{
循环体;
}while(循环条件);
*/

<3.for语句

/*
for循环：
　　结构：
　　for(;;){
　　   死循环
　　}
}
*/

二、数组

//定义一个int类型的数组
        //数组的长度可以指定也可以不是定
        int[] arr = new int[10];
        //数组中添加元素
        arr[0] = 1;
        arr[1] = 2;
        //如果元素没有被赋值 默认以0来填充。

//-------------数组的初始化方式-------------
        //1.静态初始化 : 这个值给多少就是多少，不能过改变
            int[] arr1 = {1,2,3,4,5,6};
        //2.动态初始化 : 不可变的数组  可变数组--->集合  ArrayList
            int[] arr = new int[10];
        //定义一个字符串数组
        //默认为：null
            String[] strArr = new String[10];
//遍历数组
        for(int i = 0 ; i <arr.length ;i++){
            System.out.println(arr[i]);
        }

三、数组的内存分析

1、数组的内存管理

用一块连续的空间来存储元素。

基本原理：

//创建一个int类型的数组
        //arr : 是一个变量  只是数组的一个引用地址
        //局部变量存在栈中
        //成员变量 -- 属性  --- > 对堆区中
        //静态变量  --- >  共享区域
        int[] arr = new int[2];
        arr[1] = 10;

2、数组的使用工具：Arrays

常用来查找元素和排序

int[] arr = {1,2,4,5};
int num = 3;    //查找数组中是否有某一个数
int result = Arrays.binarySearch(arr,num);//对应索引位置
Arrays.sort(arr);  //用Arrays排序
for (int i = 0;i < arr1.length ;i++ )  {
            System.out.println(arr[i]);
}

3、二维数组

java中数组一样存在多维 ： 二维数组 ，三维数组，....

<1.二维数组的定义

 数据类型[][] 数组名 = new 数据类型[][];

动态初始化：

数据类型[][] 数组名 = new 数据类型[][];

注意 ：前面中括号中数值指的是二维数组元素个数，后面一个是指二维数组中一维数组的元素个数。

静态初始化：

数据类型[][] 数组名称 = {{元素1，..},{元素1，..},{元素1，..}};

//二维数组中的元素一定是一维数组。
            int[][] arr = new int[3][4];
            arr[0][0] = 1;
            int[][] arr1 = {{1,2,3},{2,3},{1,4}};
            int num = arr1[2][1];  // 4
            //想要接收二维数组中的元素 : 需要用一个一维数组来接收。
            int[] arr2 = new int[];
            arr2 = new int[3];  // 定义了一个二维数组 ，数组中的元素维3.
//初始化数组int arr3[] = {};  不推荐这样写

<2.总结：数组的特点-->

1.数组中只能存同一种数据类型的数据。

2.数组他会给存入的元素默认分配一个索引值 ，索引从0开始。

3.数组一旦初始化，长度就固定了。

4.数组中元素的内存地址是连续的

2、对象

1、对象

 万物皆对象，是真实存在的唯一的事物

面向对象：处理程序的过程

面向对象的核心 ： 找到合适的对象做合适事情。

语法：

//通过自定义的类来创建一个对象

格式：

类名  对象名（变量名） = new 类名();

2、类

类是模子，用来描述对象的属性（特征）和方法（行为）

Java程序的实现都是以class类名为组织单元

定义类：类名à 类的属性à 类的方法

语法：

类的定义格式 ：

class 类名 {

属性(成员变量) ： 描述事物的公共的特点。

方法 ： 描述事物的行为 (做什么事情)

}

3、属性

对象自身 的各种特征 是抽象的、客观存在的

//属性 格式 : 数据类型 变量名
     String color;
     String name;
     int num;

4、方法

对象执行的操作/行为

语法：

修饰符  返回值类型  方法名  (参数列表){具体的实现}

  public  ： 公开的方法 ， 任何人都可以访问

private ： 私有的，只能自己访问。

public void run(){
        System.out.println("司机开车了,请系好安全带");
};

5、成员变量和局部变量

1.成员变量和局部变量额区别：

<1定义的位置 ：

1.定义在类中，方法外。

2.局部变量是定义在方法中。

<2.作用上：

1.成员变量是用来描述同一类事物(对象)的公共属性。

2.局部变量就是提供一个变量给方法使用

成员变量 : 作用范围是整个类中 ，如果需要在当前类中使

用成员变量，直接拿到变量名就可以使用

//方法
    public void eat(){ //在括号里定义的参数也是局部变量
        int age; //局部变量
        age = 20;
        System.out.println(name +"在吃饭,今年刚满:"+age);
    }

<3.生命周期 ：

1.成员变量随着对象的创建而创建，随着对象的消失而消失。

2.局部变量随着方法调用而创建，出了方法的作用域就消失。

<4．初始值来区分：

1.成员变量，如果你没有赋值，它是有默认值的。

int   默认是0

float 默认是0.0f

double  默认是 0.0

boolean 默认 false

char    默认 ‘ ‘

String （引用类型）null；

2.局部变量：

局部变量是没有初始值的，必须初始化才能使用

成员变量在当前类中是可以直接通过变量名来使用，如果变量需要在其他类中使用，就需要创建对象(目前是这个样子的)