Java后端笔记1-基础

一、笔记01
二进制

反码 = 原码各位取反
补码 = 反码 + 1
正数的反码和补码都是其原码

负数的原码，直接把对应正数的最高位改为1
负数的反码,符号位为“1”,数值部分按位取反
负数的补码：负数的反码加1

8位二进制编码的-128没有原码和反码，只有补码

		 -1            		1
 反码：1111 1110        0000 0001
 原码：1000 0001        0000 0001
 补码：1111 1111        0000 0001

例： 37 和 -37

数字	37	-37
原码	0010 0101	1010 0101
反码	0010 0101	1101 1010
补码	0010 0101	1101 1011

-128 和 128 一样？

数字	128	-128
原码	1000 0000	无
反码	1000 0000	无
补码	1000 0000	1000 0000

字节（byte）
8 bit（位） = 1byte 或 1B

Java环境搭建及开发
1、JDK（开发工具包） ——》 JRE（运行时环境） ——》 JVM
2、Java虚拟机——JVM：Java程序运行环境

数据类型

Java默认类型中：整型是int，小数是double

public class Demo1_数据类型 {
    public static void main(String[] args) {
        /*
        * 数据类型：
        *   基本数据类型：byte、char、short、int、long、float、double、boolean
        *   引用数据类型：String、Integer.....
        * */
        int maxValue = Integer.MAX_VALUE;
        System.out.println(maxValue);
        /**
         * 2147483647是int类型最大值，加一得到 1000 0...0 0000 ：最高位为1表示负数，数值为128，所以结果为-128
         */
        int a = 2147483647;
        System.out.println(a + 1);
        /**
         * 1默认是int
         * byte + 1会自动转int
         */
        byte b = 127;
        System.out.println(b + 1);
    }
}

二、笔记02
IDEA

修改默认方式位eclipse

eclipse快捷键

优化导包	ctrl+shift+o
注释代码	ctrl+/ 、 ctrl+shift+/
删除一行代码	ctrl+D
撤回/前进	ctrl+Z/ctrl+Y
查看当前类所有方法	ctrl+O
格式代码	ctrl+alt+L
查找文件	ctrl+H
快速封装方法	alt+shift+M
查看类或接口的实现	鼠标焦点位于方法名位置，按住ctrl+T即可跳到方法实现位置
生成块语句	ctrl+alt+T
去除当前无关包	ctrl+shift+O
复制选中（块）语句	ctrl+alt+⬇
查找或者替换	ctrl+F
多行编辑	按住alt+shift，鼠标选择需要编辑的语句
断点调试快捷键	F6跳到下一个断点，F8释放断点（调试）

数据转换
自动转换

public class Demo1_自动转换 {
    public static void main(String[] args) {
        /**
         * byte + byte结果是int
         */
        /*
         * 先输入“a + b;”后按alt+enter即可验证两个变量之和结果类型
         * */
        //自动转换：byte、short、char ——》int ——》long ——》float ——》double
        byte b1 = 2;
        short s = 23;
        int a = 120;
        double d = 185;

        int a1 = b1 + s;
        int a2 = s + a;
        double f = a + d;
    }
}

强制转换

public class Demo2_数据强转 {
    public static void main(String[] args) {
        /*
        * 一般是将大的类型往小的类型转换，可能会丢失部分数据
        * 方式：在结果数据前用括号标明数据类型
        * */

        byte b = 127;
        b = (byte)(b + 1);//b+1是int类型
        System.out.println(b);//-128，超出byte最大数值，最高位为1是负数
        //数字相加默认都是int类型
        byte b1 = 2;
        byte b2 = 3;
        byte b3 = (byte)(b2 + b1);
        System.out.println(b3);

        int a1 = 2147483647;
        int a2 = 2;
        int a3 = a1 + a2;//a2=2：a3=-2147483648, a2=1：a3=-2147483647
        System.out.println(a3);

        int d1 = (int) 3.14F;
        System.out.println(d1);
    }
}

算术运算

public class Demo3_算术运算 {
    public static void main(String[] args) {
        /*
        * 取余运算中，运算结果取正运算。
        * 结果符号由前面的数字决定：即%前的数字为正，结果为正，为负结果也为负
        * */
        System.out.println(5 % 3);  //2
        System.out.println(5 % -3); //2
        System.out.println(-5 % 3); //-2
        System.out.println(-5 % -3);//-2
    }
}

逻辑运算

public class Demo4_逻辑运算 {
    public static void main(String[] args) {
        /*
         * 与、或、非、短路与、短路或、异或
         * */
        boolean one = false;
        boolean two = false;
        // 与 & ：全部执行
        System.out.println(false & (one = true));
        // 短路与 && ：前面是false，后面都不执行
        System.out.println(false && (two = true));

        System.out.println("one is " + one + ", two is " + two);//one is true, two is false
        /*
         * 或 | ：全部执行
         * 短路或 || ：前面结果为true时，后面不执行
         *
         * */
        System.out.println("///");
        boolean three = false;
        boolean four = false;
        // 或 | ：全部执行
        System.out.println(true | (three = true));
        // 短路或 || ：前面是true，后面都不执行
        System.out.println(true || (four = true));

        System.out.println("three is " + three + ", four is " + four);//three is true, four is false
        /*
         * 异或 ^ ：不同为true，相同为false
         * */
        System.out.println("///");
        System.out.println(true ^ true);  //false
        System.out.println(true ^ false); //true
        System.out.println(false ^ true); //true
        System.out.println(false ^ false);//false
    }
}

三元运算

public class Demo5_三元运算 {
    public static void main(String[] args) {
        /*
         * 三元运算
         *   逻辑表达式 ? 结果一 : 结果二
         *   逻辑表达式为true，得到结果一；为false得到结果二
         * */
        System.out.println(100 > 20 ? "大于" : "不大于");
    }
}

方法

public class Demo6_方法 {

    public static void main(String[] args) {
        max2();
        max3();
    }

    private static void max3() {
        int i = 12;
        int j = 85;
        int k = 45;
        int temp = i > j ? i : j;
        System.out.println(temp > k ? temp : k);
    }

    private static void max2() {
        int i = 56;
        int j = 32;
        System.out.println(i > j ? i : j);
    }

}

扩展

public class Demo7_扩展 {
    public static void main(String[] args) {
        page1();
        page2();
        page3();
    }

    private static void page3() {
        int pageSize = 10;
        int totalCount = 120;
        page(pageSize, totalCount);
    }

    private static void page1() {
        int pageSize = 10;
        int totalCount = 251;
        page(pageSize, totalCount);
    }

    private static void page2() {
        int pageSize = 10;
        int totalCount = 249;
        page(pageSize, totalCount);
    }

    /*
     * 输出分页结果
     * */
    private static void page(int pageSize, int totalCount) {
        int currentPage = currentPage(pageSize, totalCount);
        int currentNumber = currentNumber(pageSize, totalCount);
        System.out.println(totalCount + "是第" + currentPage + "页第" + currentNumber + "条数据");
    }

    /*
     * 获取页数
     * */
    private static int currentPage(int pageSize, int totalCount) {
        return totalCount % pageSize == 0 ? totalCount / pageSize : totalCount / pageSize + 1;
    }

    /*
     * 获取条数
     * */
    private static int currentNumber(int pageSize, int totalCount) {
        return totalCount % pageSize == 0 ? pageSize : totalCount % pageSize;
    }
}

三、笔记03

public class Demo4_扩展 {
    public static void main(String[] args) {
        optimize();
        mulTable();
        tagMethod();
    }


    private static void mulTable() {
        System.out.println("----------------------------------------------------");
        int line = 9;
        for (int i = 1; i <= line; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i + " x " + j + " = " + (i * j) + "\t");
            }
            System.out.println();
        }
    }


    /*多重循环优化
     *
     * */
    private static void optimize(){
        System.out.println("----------------------------------------------------");
        long start1 = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            for (int j = 0; j < 1000; j++) {
                for (int k = 0; k < 100; k++) {
                    // TODO something
                }
            }
        }
        long end1 = System.currentTimeMillis();
        System.out.println("外层循环大于内层循环所用时间：" + (end1 - start1));
        //优化
        long start2 = System.currentTimeMillis();
        for (int i = 0; i < 100; i++) {
            for (int j = 0; j < 1000; j++) {
                for (int k = 0; k < 10000; k++) {
                    // TODO something
                }
            }
        }
        long end2 = System.currentTimeMillis();
        System.out.println("外层循环小于内层循环所用时间：" + (end2 - start2));
    }


    /*标记
     * 可以给内外循环一个标记名，break/continue利用标记名来跳出/跳过哪一层循环
     * break/continue默认是内层循环
     * */
    private static void tagMethod() {
        System.out.println("----------------------------------------------------");
        outer:
        for (int i = 0; i < 5; i++) {
            inner:
            for (int j = 0; j < 5; j++) {
                if (i == 2) {
                    break outer;
                } else if (j == 3) {
                    continue;
                }
                System.out.println("inner" + j);
            }
            System.out.println("outer" + i);
        }
    }
}

四、笔记04
方法重载
1、同名方法
2、参数个数不同
3、参数个数相同但类型不同
3、参数个数相同但顺序不同
4、与修饰符无关

内存
堆：存放对象的实例
栈：存放加载main过程的代码块
方法区：存放.class文件