Java学习-2入门

一、运算符

1.算术运算符

+、-、*、/、%

• 运算中不同类型数据，结果按范围大的类型
• String字符串用‘+’时代表连接操作，String范围比int大
• 自增自减，++、–，让一个变量加1或减1
• 只有变量才可以自增自减，常量不可以

		int num5 = 10;
        //自增：++
        ++num5;//单独使用时，前后++无区别11
        num5++;//12
        //混合使用，前++是立刻加1，打印出来的是加后的结果
        System.out.println(++num5);//13
        //后++，打印出来的是加前的结果13，打印后加1
        System.out.println(num5++);//13
        System.out.println(num5);//14
        //自减：--
        int num6=12;
        num6--;//11
        --num6;//10
        System.out.println(--num6);//9
        System.out.println(num6--);//9
        System.out.println(num6);//8

2.赋值运算符

+=、=、-=、*=、/=、%=

• 只有变量才可以进行赋值运算
• 复合类型运算符包含了强制类型转换

		a+=1;//a=a+1
        b-=1;//b=b-1
        c*=1;//c=c*1
        d/=1;//d=d/1
        f%=1;//f=f%1
        byte num7=1;
        num7+=2;
        System.out.println(num7);//最后num7为int类型

3.比较运算符

==、>、<、<=、>=、!=

• 比较运算后结果为true或false
• 不允许连着判断1<2<3，可以用逻辑运算符连接
• equals函数比较的是堆里存的内容，==用于栈里存的内容

4.逻辑运算符

&&、||、!

• &&两边都是true，才是true
• ||两边有一个为true，就是true
• ！本来是true，变成false
• &&和||，可以根据左边的结果直接得出最终结果，右边的不再执行，节省性能
• 只能用于布尔值

		System.out.println(true && false);//false
        System.out.println(true || false);//true
        System.out.println(!false);//true
        System.out.println(false && ++num8<10);//num8不加1
        System.out.println(num8);//1
        System.out.println(false && ++num8<10 || !false);//true

5.三元运算符

格式：数据类型 变量名c = 条件判断 ？表达式a : 表达式b

• 元：数据；三元：需要三个数据进行操作
• 条件判断为true，等于a，否则为b
• a和b的类型应该与c的类型一致
• 结果必须被使用

		//一元：--、++、+=、-=、！、*=、/=、%=
        //二元：+、-、=、==、||
        int sum = 1<3 ? 'a' : 'b';//a
        System.out.println(1>3 ? 'a' : 'b');//b

表达式：用运算符连接起来的式子

7.位运算

左移运算“<<”右移运算">>"都是移动二进制数
不常用

6.运算优先级

单目乘除为关系，逻辑三目后赋值（括号最高）

二、方法

方法：将功能的代码放在大括号里

1.方法定义

public static void 方法名(){
方法体
}
修饰符 返回值类型 方法名称(参数类型 参数名称,参数类型 参数名称,…){
方法体
return 返回值
}

• 方法名命名规则与变量名一样
• 方法体：大括号中可以包含任意条语句
• 方法定义的先后顺序无所谓
• 方法定义不能嵌套包含，方法里不能在定义方法
• 方法定义后需要调用才执行
• return 停止当前方法，将结果传给调用方
• 一个方法可以有多个return 但是只能同时有一个执行

	public static int max(int a,int b){
        if(a>b){
            return a;
        }
        return b;
    }

2.方法调用

方法名称(参数);
System.out.println(方法名称（参数））
int a=方法名称（参数）

• void类型的方法不能赋值调用和打印调用
• 没有返回值的方法不能打印调用和赋值调用

public class test {
    //num以内的偶数和，num>=1
    public static int practice(int num){
        int sum =0;
        for(int i=1;i<=num;i++){
            if (i%2==0){
                sum +=i;
            }
        }
        //System.out.println(sum);
        return sum;//返回值类型为int
    }
    public static void main(String arg[]){
        practice(100);//没有使用这个方法的结果
        System.out.println(practice(10));//打印方法的结果
        int a=practice(10);//赋值调用，将方法结果赋值给a
        System.out.println(a);
    }
}

3.方法重载

overload：方法名称一样，但参数列表不一样
注意：参数个数，参数类型，参数类型顺序

//ab是否相等
    public static boolean same(byte a,byte b){
        if(a == b){
            return true;
        }else{
            return false;
        }
    }
    public static boolean same(short a,short b ){
        boolean same= a == b ? true:false;
        return same;
    }
    public static boolean same(int a,int b){
        return a==b;
    }
    public static boolean same(long a,long b){
        return a==b;
    }
    public static void main(String arg[]){
        byte a =10;
        byte b = 20;
        System.out.println(same(a,b));
        System.out.println(same((short)a,(short)b));
        System.out.println(same(10,20));
        System.out.println(same(10L,20L));

    }

三、流程控制

1.顺序结构

按语句顺序执行

2.选择结构（if，switch）

if语句：

		int num9 = 18;
        //单if语句
        if (num9>=18) {
            System.out.println("成年");
        }
        //if-else
        if (num9%2 == 0){
            System.out.println("偶数");
        }else{
            System.out.println("奇数");
        }
        //if-else if-else
        if(age>14 && age<20){
            System.out.println("一次元");
        }else if(age>=20 && age<30){
            System.out.println("二次元");
        }else if(age>=30 && age<40){
            System.out.println("三次元");
        }else{
            System.out.println("其他次元");
        }

switch:

• 多个case后面的数值不可重复
• switch后小括号里的数据类型只能是byte/int/char/short/String/enum枚举
• switch格式灵活，case顺序可以颠倒，break可以省略，但是会一直执行所有case
• 匹配哪一个case，就从哪个位置向下执行，直到break或整体执行完

		//switch,判断
        switch (new SimpleDateFormat("yyyy-MM-dd").format(new Date())){
            case "2021-04-12":
                System.out.println("星期一");
                break;
            case "2021-04-13":
                System.out.println("星期二");
                break;
            default:
                System.out.println(0);
                break;
        }

3.循环结构（for，while，while do）

循环结构的组成

• 初始化语句：在循环最开始执行，只做一次
• 条件判断：如果成立循环继续，不成立退出循环
• 循环体：重复做的内容
• 步进语句：每次循环之后都要执行的操作

for：for(初始化表达式;条件判断;步进表达式){循环体}
while：while(条件判断){}
do while：do{循环体；步进表达式}while(条件判断)

		//for循环
        for(int i =1;i<10;i++){
            System.out.println(i);
        }
        //while可以没有步进表达式和初始化语句
        while(1==1){//死循环
            System.out.println(1);
        }
        //while
        int i = 1;//初始化语句
        while (i<10){
            System.out.println("num1:"+ i);//循环体
            i++;//步进表达式
        }
        //do while
        int i=1;
        do {
            System.out.println(i);
            i++;
        }while(i<10);

三种循环区别

• 如果条件判断为false，for和while执行0次，dowhile执行一次
• for循环小括号内定义的变量只能在for循环内使用
• for循环知道循环次数，while可以不确定循环次数

练习：用循环求1-100偶数之和

		int sum =0;
        for(int i=1;i<=100;i++){
            if (i%2==0){
                sum +=i;
            }
        }
        System.out.println("1-100偶数和："+sum);

循环控制：
break关键字

在switch里，一旦执行，将结束整个switch
在循环里，一旦执行，循环停止

continue关键字

一旦执行，跳过当前循环剩下步骤，开始下次循环

		for(int i =1;i<10;i++){
            if (i==5){
                break;//i=5时，后面的就不再循环，结束循环
            }
            if(i==3){
                continue;//i=3时，不输出，跳过进入i=4的循环，输出4
            }
            System.out.println(i);
        }
        //结果为124

死循环

条件判断永远是true
标准格式：while(true){}

循环嵌套

一个循环的循环体也是一个循环
总循环次数=外层循环次数*内层循环次数
结束所有循环break outer

		outer://定义outer
        for(int i=0;i<24;i++){//外层
            for(int j=0;j<60;j++){//内层
                System.out.println("时："+i+"分："+j);//输出24*60次
                if (j==10){
                    break outer;//跳出外层循环
                }
            }
        }

四、数组

一种容器，可以存放多个数据

特点

• 数组是一种引用类型
• 数组中多个数据的类型相同
• 数组长度在运行时不能改变

1.数组定义

数组初始化：创建数组，赋予默认值
动态初始化

创建时指定数组长度
格式：数据类型[] 数组名称= new 数据类型[数组长度]；

• 左边‘数据类型’表示数组中存的数据类型
• 右边‘数据类型’要和左边一样

静态初始化

创建时不指定长度，指定内容
基本格式：数据类型[] 数组名称= new 数据类型[] {1,2,3…};
省略格式：数据类型[] 数组名称= {1,2,3…};

• 可以根据后边花括号里的数据，确定数组长度

		//动态初始化
        int[] array1 = new int[100];//创建数组，长度100
        String[] array2 = new String[100];
        //静态初始化
        int[] array3 = new int[] {10,20,3,4,6};
        String[] array4 = new String[] {"aaaa","cccc","sss","bbb"};
        int[] array5 = {3,1,4,2};//省略
        //可以拆开
        int[] array6;
        array6 = new int[]{1,2,3};
        int[] array7;
        array7 = new int[10];

2.访问数组元素

格式：数组名[索引值]
索引值：从0开始，表示数组元素的编号，到数组长度-1

给数组元素赋值

		System.out.println(array1);//直接打印数组名，结果是数组内存地址的哈希值
        System.out.println(array3[0]);//10
        System.out.println(array1[0]);//动态数组没有赋值，int默认为0，float默认0.0,字符默认/u0000，布尔默认fasle，引用默认null
        array1[0]=2;//赋值给数组1的第0位元素
        array3[0]=3;
        System.out.println(array3[0]);

数组遍历

	public static void main(String[] args) {
        int[] array = new int[3];//定义长度3的数组
        array[0] = 1;
        array[1] = 2;
        array[2] = 3;
        //1，for循环遍历array
        for (int i = 0;i < array.length;i++){
            System.out.println(array[i]);
        }
        //2，foreach方法遍历
        for (int a : array) {
            System.out.println(a);
        }
        //3，Arrays.toString将array转换成字符串输出
        System.out.println(Arrays.toString(array));
        //输出array在堆内存中的地址
        System.out.println(array.toString());
    }

3.java内存划分

栈：存放方法中的局部变量，方法运行在栈里
堆：new的存在堆里，有地址值16进制，有默认值
方法区：存放.class信息，包含方法信息
本地方法栈：与操作系统相关
寄存器：与cpu相关

数组内存图

1，堆里和栈里开辟内存空间
2，堆里初始化内容，栈里初始化数组名称
3，堆里内存地址给栈

4.二维数组

二维数组：一维数组对应的元素也是一个一维数组
定义格式：

1,数据类型[][] 数组名称= new 数据类型[一维数组数量][一维数组长度]
2,直接给二维数组赋值，数据类型[][] 数组名称= {{1},{2,4},{1,4,5}}

		//一次定义2个长度是2的一维数组
        int[][] array1 = new int[2][2];
        //定义2个不指定长度的一维数组,每个一维数组长度可以不一样
        int[][] array2 = new int[2][];
        //定义时给定初始值
        int[][] array3 = {{1},{2,3},{5,7,8}};
        //坐标定位赋值
        array1[0][0] = 1;
        array1[0][1] = 2;
        array1[1][0] = 3;
        array1[1][1] = 4;

遍历

		for (int i = 0;i < array1.length;i++){
            for (int j = 0;j < array1[i].length;j++){
                System.out.println(array1[i][j]);
            }
        }
        for (int i = 0;i < array1.length;i++){
            System.out.println(Arrays.toString(array1[i]));
        }

二维数组内存

开发工具

IDE：集成开发环境
Eclipse、IntelliJ IDEA

intellij下载：https://www.jetbrains.com/zh-cn/idea/