Java学习笔记(day02)

基本运算符(假设A = 20; B = 10)

  • 算术运算符
操作符 描述 例子
+ 加法 - 相加运算符两侧的值 A + B 等于 30
- 减法 - 左操作数减去右操作数 A – B 等于 -10
* 乘法 - 相乘操作符两侧的值 A * B等于200
/ 除法 - 左操作数除以右操作数 B / A等于2
取余 - 左操作数除以右操作数的余数 B%A等于0
++ 自增: 操作数的值增加1 B++ 或 ++B 等于 21
-- 自减: 操作数的值减少1 B-- 或 --B 等于 19
  • ++a , a++ 的区别
public class Test {
    public static void main(String[] args) {
        int i = 10;
        int j = 10;
        int b;
        int c;
        /*
        b = ++i;
        其实就相当于以下两句代码:
        i = i+1;
        b = i;
         */
        b = ++i;
        System.out.println(b);
        /*
        c = j++;
        其实就相当于以下两句代码:
        c = j;
        j = j+1;
         */
        c = j++;
        System.out.println(c);
    }
}
输出结果:
11
10

Process finished with exit code 0

简单理解就是: ++在前, 就先自增, 用自增后的值去做运算; ++在后, 就先去做运算或者赋值,然后再自增

  • 关系运算符
运算符 描述 例子
== 检查如果两个操作数的值是否相等,如果相等则条件为真。 (A == B)为假。
!= 检查如果两个操作数的值是否相等,如果值不相等则条件为真。 (A != B) 为真。
> 检查左操作数的值是否大于右操作数的值,如果是那么条件为真。 (A> B)为假。
< 检查左操作数的值是否小于右操作数的值,如果是那么条件为真。 (A <B)为真。
>= 检查左操作数的值是否大于或等于右操作数的值,如果是那么条件为真。 (A> = B)为假。
<= 检查左操作数的值是否小于或等于右操作数的值,如果是那么条件为真。 (A <= B)为真。
  • 位运算符
操作符 描述
如果相对应位都是1,则结果为1,否则为0
| 如果相对应位都是 0,则结果为 0,否则为 1
^ 如果相对应位值相同,则结果为0,否则为1
按位取反运算符翻转操作数的每一位,即0变成1,1变成0。
<< 按位左移运算符。左操作数按位左移右操作数指定的位数。
>> 按位右移运算符。左操作数按位右移右操作数指定的位数。
>>> 按位右移补零操作符。左操作数的值按右操作数指定的位数右移,移动得到的空位以零填充。
A = 20; B = 10;
二进制:
A: 0001 0100
B: 0000 1010
A&B: 0000 0000
A|B: 0001 1110
A^B: 0001 1110
~B: 1111 0101
A<<2: 0101 0000
A>>2: 0000 1010
<< : 相当于*2
>> : 相当于/2

位运算的效率高

面试题: 求2^3 = 8效率最高的方法: 2<<2

public class Test {
    public static void main(String[] args) {
        System.out.println(2 << 2);
    }
}
输出结果:
8

Process finished with exit code 0
  • 逻辑运算符(布尔变量A为true,变量B为false)
操作符 描述 例子
&& 称为逻辑与运算符。当且仅当两个操作数都为真,条件才为真。 (A && B)为假。
| | 称为逻辑或操作符。如果任何两个操作数任何一个为真,条件为真。 (A | | B)为真。
称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true,则逻辑非运算符将得到false。 !(A && B)为真。

&& 也叫做短路与, 当左边的条件为false时, 不会再去看右边的条件是否为真

  • 赋值运算符
操作符 描述 例子
= 简单的赋值运算符,将右操作数的值赋给左侧操作数 C = A + B将把A + B得到的值赋给C
+ = 加和赋值操作符,它把左操作数和右操作数相加赋值给左操作数 C + = A等价于C = C + A
- = 减和赋值操作符,它把左操作数和右操作数相减赋值给左操作数 C - = A等价于C = C - A
* = 乘和赋值操作符,它把左操作数和右操作数相乘赋值给左操作数 C * = A等价于C = C * A
/ = 除和赋值操作符,它把左操作数和右操作数相除赋值给左操作数 C / = A,C 与 A 同类型时等价于 C = C / A
(%)= 取模和赋值操作符,它把左操作数和右操作数取模后赋值给左操作数 C%= A等价于C = C%A
<< = 左移位赋值运算符 C << = 2等价于C = C << 2
>> = 右移位赋值运算符 C >> = 2等价于C = C >> 2
&= 按位与赋值运算符 C&= 2等价于C = C&2
^ = 按位异或赋值操作符 C ^ = 2等价于C = C ^ 2
| = 按位或赋值操作符 C | = 2等价于C = C | 2
  • 条件运算符
public class Test {
    public static void main(String[] args) {
        /*
        格式: 表达式A ? 表达式B : 表达式C
        当表达式A为true时,执行表达式B,为false时执行表达式C
         */
        System.out.println(1+1 == 2 ? "1+1=2" : "1+1!=2");
    }
}
输出结果:
1+1=2

Process finished with exit code 0
  • instanceof运算符
用于操作对象实例,检查该对象是否是一个特定类型(类类型或接口类型).
instanceof运算符使用格式如下:
( Object reference variable ) instanceof  (class/interface type);

Scanner

/*java.util.Scanner 是 Java5 的新特征,我们可以通过 Scanner 类来获取用户的输入。
常用的两个方法:
next(): 不能接收含有空格的字符串,遇到空格结束.
nextline(): 能接收含有空格的字符串,遇到回车结束.
*/
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        if(sc.hasNextLine()){
            System.out.println(sc.nextLine());
        }
        sc.close();
    }
}
输出结果:
请输入:
hahaha
hahaha

Process finished with exit code 0

java循环

public class Test {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,6};
        System.out.println("==============for===============");
        for (int i = a.length - 1; i >= 0; i--) {
            System.out.print(a[i]);
        }
        System.out.println("\n");
        System.out.println("==============while===============");
        int j = a.length - 1;
        while(j >= 0){
            System.out.print(a[j]);
            j--;
        }
        System.out.println("\n");
        System.out.println("==============do while===============");
        int c = a.length - 1;
        do {
            System.out.print(a[c]);
            c--;
        }while (c>=0);
        System.out.println("\n");
        System.out.println("==============增强for===============");
        for (int e:a) {
            System.out.print(e);
        }
    }
}
==============for===============
654321

==============while===============
654321

==============do while===============
654321

==============增强for===============
123456
Process finished with exit code 0

do…while循环至少会执行一次循环体.

for循环和while循环只有在条件成立的时候才会去执行循环体.

for循环语句和while循环语句的小区别:使用区别:控制条件语句所控制的那个变量,在for循环结束后,就不能再被访问到了,而while循环结束还可以继续使用,如果你想继续使用,就用while,否则推荐使用for。原因是for循环结束,该变量就从内存中消失,能够提高内存的使用效率


java方法

定义

  • Java方法是语句的集合,它们在一起执行一个功能

  • 方法是解决一类问题的步骤的有序组合

  • 方法包含于类或对象中

  • 方法在程序中被创建,在其他地方被引用

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

方法的优点

  • 使程序变得更简短而清晰
  • 有利于程序维护
  • 可以提高程序开发的效率
  • 提高了代码的重用性

方法的重写

  • 方法名, 参数必须一致.
  • 修饰符, 范围可以扩大不能缩小
  • 抛出异常的范围不能扩大, 只能缩小

方法的重载

  • 方法名相同, 但是必须拥有不同类型, 个数的参数,

    就是说一个类的两个方法拥有相同的名字,但是有不同的参数列表.

    Java编译器根据方法签名判断哪个方法应该被调用.

    方法重载可以让程序更清晰易读。执行密切相关任务的方法应该使用相同的名字.

    重载的方法必须拥有不同的参数列表. 你不能仅仅依据修饰符或者返回类型的不同来重载方法.

方法的值传递和引用传递

  • java 基本数据类型传递参数时是值传递 ;引用类型传递参数时是引用传递
  • 值传递不会改变原有的值
  • 引用传递,如果在方法中改变了传递进来的引用数据, 原来的也就跟着变化了

递归

说得简单一些就是一个方法自己调用自己, 必须有一个能够结束调用的条件, 否则一直调用会造成栈溢出.

public class Test {
    public static void main(String[] args) {
        System.out.println(jieCheng(5));
    }
private static int jieCheng(int i){
        /*
        计算阶乘
        5! = 5*4*3*2*1;
         */
        if (i == 1){ // 结束调用自己的条件
            return 1;
        } else {
            return i * jieCheng(i-1);
        }
    }
}
输出结果:
120

Process finished with exit code 0
/*
有50瓶饮料,喝完后每三个空瓶子可以换一瓶,问总共可以喝多少瓶饮料?
*/
public class Test {
    public static void main(String[] args) {
        System.out.println(drink(50));
    }
    private static int drink(int i){
            /*
            5! = 5*4*3*2*1;
             */
            if (i < 3){
                return i;
            } else {
                return i + drink(i/3 + i%3);
            }
        }
}

输出结果:
76

Process finished with exit code 0

数组

  • 数组: 相同类型的 数据的一组有序集合, 其中每一个数据叫做数组的一个元素, 可以通过索引来访问每一个元素, arr[0]就代表数组的第一个元素, arr[arr.length - 1]代表最后一个元素. 0<=数组的索引<=数组的长度-1, 不在这个范围将会引发数组越界异常

  • 数组的声明和创建:

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

    类型[] 数组名 = {数组元素1,数组元素2,数组元素3...};

    类型 数组名[] = {数组元素1,数组元素2,数组元素3...};

Arrays类

java.util.Arrays类是Java提供的工具类,专门用于操作数组.常用的方法如下:

  • sort() 排序
  • fill 给数组元素值
  • copyof()
  • toString() 将数组转化成字符串输出
  • asList(T... a) 返回由指定数组支持的固定大小的列表。