• Java入门实操复习心得（全）

    JAVA实操复习心得

    由于图片有点问题，完整的文档放在我的资源里了
    csdn：java技能树学习链接

    (1条消息) Java技能树 (csdn.net)

    推荐b站：韩顺平java

    1. 输出Hello

    package Java2022_6_2;

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    2. 转义字符

    /*02 转义字符*/
public class ChangeChar {
    public static void main(String[] args) {
        System.out.println("北\t上\t广");      //提示：\t表示间隔
        System.out.println("---------");

        System.out.println("北\n上\n广");      //提示：\n表示换行
        System.out.println("---------");

        System.out.println("北\\上\\广");      //提示：\\表示输出\
        System.out.println("---------");

        System.out.println("北\"上\'广");      //提示：\"表示输出"    \'表示输出‘
        System.out.println("---------");

        System.out.println("北\r上\r广");      //提示：\r表示后面会替换掉前面的数据
        System.out.println("---------");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    image-20220602010432353

    3. 变量，字符串拼接

    public class Var {
    public static void main(String[] args) {
        int a = 100;
        int b = 100;
        String str = "一百";
        System.out.println(a);
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a/b);
        System.out.println(a*b);
        System.out.println("----------");

        System.out.println(a+str);					//字符串拼接：a本身是一个整数类型，被变为字符串类型
        System.out.println("----------");

        System.out.println(str+100);                //把两个数据拼接（连接）在一起
        System.out.println("----------");

        System.out.println(100+str);
        System.out.println("----------");

        System.out.println(100+3+str);
        System.out.println("----------");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    image-20220602011155949

    4. Byte与Short的区别

    public class ByteOrShort {
    public static void main(String[] args) {
        byte n1 = 3;        //byte：开辟1个字节的空间
        short n2 = 3;       //short：开辟2个字节的空间
        System.out.println(n1);
        System.out.println(n2);
    }
}

--输出结果：
    3
    3

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    5. float跟double的区别

    public class FloatOrDouble {
    public static void main(String[] args) {
        double n1 = 3.1415926535;
        float n2 = 3.1415926535f;
        System.out.println(n1+"\t"+n2);
        System.out.println("----------");

        double num1 = 2.7;
        double num2 = 8.1/3;
        System.out.println(num1==num2);
        System.out.println(num1+"\t\t"+num2);
        System.out.println("----------");

        if(Math.abs(num1-num2)<0.000001){
            System.out.println("num1等于num2");
        }
        else{
            System.out.println("num1不等于num2");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    image-20220602135019288

    6. char

    public class CharVar {
    public static void main(String[] args) {
        char c1 = 'a';
        char c2 = 97;           //97对应的ASCII码 是a
        char c3 = '许';
        char c4 = '\t';         //\t表示空格
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println("----------");
        System.out.println((int)c3);
        System.out.println("----------");
        char c5 = 35768;
        System.out.println(c5);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    image-20220602135811164

    7. boolean（true、false）

    public class BooleanVar {
    public static void main(String[] args) {
        boolean b1 = true;          //注意boolean类型的值不能是o，1或-1，这里与C语言不同
        if(b1==true){
            System.out.println("考试通过");
        }
        else{
            System.out.println("考试不通过");
        }
    }
}

--运行结果：
    考试通过

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    8. 自动类型转换1

    public class AutoConvert {
    public static void main(String[] args) {
        //只允许从低精度向高精度的转换
        // char int long float double
        // byte short int long float double
        double d = 100;                 //输出结果为100.0，是因为int型转换为double型
        int i = 'a';                    //输出结果为97，是因为char型转换为int型
        System.out.println(d);
        System.out.println(i);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    9. 自动类型转换2

    public class AutoConvert {
    public static void main(String[] args) {
        //只允许从低精度向高精度的转换
        // char int long float double
        // byte short int long float double
        double d = 100;
        int i = 100;
        float f = 10.1f;
        System.out.println(d+i+f);		//输出的数据类型是精度最高的，也就是double型
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    image-20220605091724815

    10. 强制类型转换

    public class ForceConvert {
    public static void main(String[] args) {
        //允许从高精度向低精度的转换
        // char int long float double
        // byte short int long float double
        int i = (int)1.9;
        byte b = (byte)2000;
        System.out.println(i);          //结果为1，精度丢失
        System.out.println(b);          //结果为-48，数据溢出
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    11. String类型转换

    public class StringConvert {
    public static void main(String[] args) {
        int i = 10;
        double d = 10.0;
        float f = 10.0f;

        String s1 = i+"";       //i拼接上一个空字符串后，所表示的数值就是String类型。
        String s2 = d+"";
        String s3 = f+"";

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
    }
}

--输出结果：
10
10.0
10.0
    

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    public class StringConvert {
    public static void main(String[] args) {
        //问题1：怎么把String类型转换为int、double或float类型
        String s1 = "123";
        int x1 = Integer.parseInt(s1);      //parseInt表示传入值
        double y1 = Double.parseDouble(s1);
        float z1 = Float.parseFloat(s1);
        System.out.println(x1);
        System.out.println(y1);
        System.out.println(z1);

        System.out.println("---------------");
        //问题2：怎么把String类型转换为char类型
        System.out.println(s1.charAt(0));       //charAt(int index)中的index是索引的意思，0是输出第一个字符
        System.out.println(s1.charAt(1));       //index为1时，输出第二个字符
        System.out.println(s1.charAt(2));       //index为2时，输出第三个字符
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    image-20220605094200062

    12. 除法运算

    public class DevUse {
    public static void main(String[] args) {
        System.out.println(10/3);       //结果的精度为int型
        System.out.println(10.0/3);     //结果的精度为double型

        double d = 10/3;        //3     3转成精度大的double型 3.0
        System.out.println(d);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    image-20220607110806824

    13. 取模规则（公式：a % b = a - (a / b * b)）

    public class DevUse {
    public static void main(String[] args) {
        System.out.println(10 % 3);             //1
        System.out.println(-10 % 3);            //-1
        System.out.println(10 % (-3) );         //1
        System.out.println(-10 % (-3) );        //-1
        /*
            -10 % (-3) 
         = -10 - (-10 / (-3) * (-3)) 
         = -10 - (3 * (-3)) 
         = -10 + 9
         = -1
         */
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    14. 自增

    public class AutoAdd {
    public static void main(String[] args) {
        int i = 1;
        System.out.println(i++);       //1

        int j = 1;
        System.out.println(++j);       //2

        int k = 1;
        k = k++;
        System.out.println(k);         //1
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    15. 逻辑运算符

    public class LogicOperater {
    public static void main(String[] args) {
        //      &, &&, |, ||, !, ^
        boolean b1 = true;
        boolean b2 = true;
        boolean b3 = false;
        boolean b4 = false;
        if(b1 & b2){
            System.out.println("1");
            //执行，true & true = true
        }
        if(b1 & b3){
            System.out.println("2");
            //不执行，true & false = false
        }
        if(b1 | b3){
            System.out.println("3");
            //执行，true | false = true
        }
        if(b1 & !b3){
            System.out.println("4");
            //执行，!false = true
        }
        if(b1 ^ b3){
            System.out.println("5");
            //执行，true ^ false = true
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    image-20220607214853641 
    public class LogicOperater {
    public static void main(String[] args) {
        //在&&运算中，左边如果是false，则不再对右边进行运算
        int i = 20;
        if(i<10 && i++>20){             //i<10 是false ，所以后面的i++不再执行
            System.out.println("对");
        }
        else {
            System.out.println("错");
        }
        System.out.println(i);          //20

        
        在&运算中，左边如果是false，对右边仍然进行运算
        int j = 20;
        if(j<10 & j++>20){
            System.out.println("对");
        }
        else {
            System.out.println("错");
        }
        System.out.println(j);          //21
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    image-20220607215748131

    16. 赋值运算符

    public class Operater {
    public static void main(String[] args) {
        int i = 10;
        i += 4;
        System.out.println(i);          //14

        byte b = 10;
        /*
        b += 4；
        会报错，因为b是byte型，而b+4是int型
         */

        b = (byte)(b+4);
        //正确写法
        System.out.println(b);          //14
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    17. 三元运算符

    public class ThreeOperater {
    public static void main(String[] args) {
        /*
        a>b ? a : b;
        若a大，就输出a，否则输出b
        */
        int a = 10;
        int b = 20;
        int c = 30;

        //目的：求出a,b,c 哪个数最大？
        int max1 = a>b ? a : b;             //10<20，输出20
        int max2 = max1 > c ? max1 : c;      //20<30，输出30

        System.out.println(max2);       //30
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    --把他们合并到一起，求出a,b,c 哪个数最大？
public class ThreeOperater {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;

        int max2 = (a>b ? a : b) > c ? (a>b ? a : b): c;
        System.out.println(max2);       //30
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    18. Scanner（）

    package Java2022_6_7;

import java.util.Scanner;

public class Input {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);   //返回一个scanner

        System.out.println("输入您的年龄");
        int age = scanner.nextInt();
        System.out.println("您的年龄"+age);

        System.out.println("输入您的工资");
        double wage = scanner.nextDouble();
        System.out.println("您的工资"+wage);
    }
}

运行结果：
    输入您的年龄
    22
    您的年龄22
    输入您的工资
    7000
    您的工资7000.0

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    19. 位运算符

    package Java2022_6_21;

public class BitOperater {
    public static void main(String[] args) {
        //位运算符：
        // &    有0全0
        // |    有1全1
        // ~    按位取反
        // ^    相异为1，相同为0
        System.out.println(2&3);//00000010  &  00000011 = 00000010 ,结果为2
        System.out.println(2|3);//00000010  |  00000011 = 00000011 ,结果为3
        System.out.println(2^3);//00000010  |  00000011 = 00000001 ,结果为1
        System.out.println(~3);
        /*
        00000000 00000000 00000000 00000011
        按位取反:
        11111111 11111111 11111111 11111100
        再减去1:
        11111111 11111111 11111111 11111011
        首位不变，其它位按位取反：
        10000000 00000000 00000000 00000100
        结果为-4
         */
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    左移，右移，无符号右移(<<， >>，>>>)

    提示1：左移几次，就乘上几次2；右移几次，就除去几次2。

    提示2：负数要用补码来进行运算，要先对其补码进行移动，最后再将补码变为原码，即得到结果。

    public class BitOperater {
    public static void main(String[] args) {
        // >>2    向右移动2位
        // <<2    向左移动2位
        // >>>2   无符号右移2位
        int i = 4>>2;       // 4/2/2 = 1
        System.out.println(i);
        /*
        00000000 00000000 00000000 00000100
        向右移动2位：
        00000000 00000000 00000000 00000001
        结果为1
        */

        int y = 4<<2;        // 4*2*2 = 16
        System.out.println(y);

        int z = 4<<2;        // 4*2*2 = 16
        System.out.println(z);

        int k = 8<<3;        // 8*2*2*2 = 64
        System.out.println(k);
        /*
        * 00000000 00000000 00000000 00001000
        * 向左移动3位
        * 00000000 00000000 00000000 01000000
        * 结果为64
        * */

        //负数要用补码来进行运算，要先对其补码进行移动，最后再将补码变为原码，即得到结果.
        //在移动过程中其符号位保持不变
        int l = -4<<2;            //(-4)*2*2 = -16
        System.out.println(l);
        /*
        * -4的原码      10000000 00000000 00000000 00000100
        * -4的反码      11111111 11111111 11111111 11111011
        * 补码=反码+1   11111111 11111111 11111111 11111100
        * 补码左移2位：  11111111 11111111 11111111 11110000
        *
        * 最后将补码变为原码（步骤：补码减1，然后取反）
        * 11111111 11111111 11111111 11101111
        * 10000000 00000000 00000000 00010000
        * 结果为-16
        * */
        int m = -4>>2;            //(-4)/2/2 = -1
        System.out.println(m);
        /*
        * -4的补码      11111111 11111111 11111111 11111100
        * 补码右移2位    10111111 11111111 11111111 11111111
        * 最后将补码变为原码（步骤：补码减1，然后取反）
        *  10111111 11111111 11111111 11111110
        *  10000000 00000000 00000000 00000001
        * 结果为-1
        * */


        //无符号右移
        int n = -4>>>2;        //结果为：1073741823
        System.out.println(n);
        /*
        * -4的补码        11111111 11111111 11111111 11111100
        * 无符号右移2位    00111111 11111111 11111111 11111111
        * 此时已经是正数，正数的补码就是其本身，即为原码：
        *                00111111 11111111 11111111 11111111
        * */
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67

    20. Switch

    package Java2022_6_22;
import java.util.Scanner;

public class SwitchUse {
    public static void main(String[] args) {

        System.out.println("请输入a-g:");
        Scanner scanner = new Scanner(System.in);
        char c = scanner.next().charAt(0);

        switch (c){
            case 'a':
                System.out.println("星期一");
                break;
            case 'b':
                System.out.println("星期二");
                break;
            case 'c':
                System.out.println("星期三");
                break;
            case 'd':
                System.out.println("星期四");
                break;
            case 'e':
                System.out.println("星期五");
                break;
            default:
                System.out.println("周末");
                break;
        }
        System.out.println("退出switch");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    image-20220622115413792

    21. Switch成绩管理（大于等于60分及格，小于60不及格）

    package Java2022_6_22;
import java.util.Scanner;

public class SwitchScore {
    public static void main(String[] args) {
        System.out.println("请输入分数（0-100）");
        Scanner scanner = new Scanner(System.in);
        double v = scanner.nextDouble();
        if(v>=0 && v<=100) {        //用来过滤
            //v(0-100)  100/60=1 60/60=1 59/60=0
            switch ((int)v/60) {
                case 0:
                    System.out.println("成绩不合格");
                    break;
                case 1:
                    System.out.println("成绩合格");
                    break;
                default:
                    System.out.println("输入的成绩有误！");
                    break;
            }
        }
        else
            System.out.println("成绩有误，不在0-100内！");

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    image-20220622120906547 
    package Java2022_6_22;

import java.util.Scanner;

public class SwitchSeason {
    public static void main(String[] args) {

        System.out.println("请输入1-12月份中的一个月份");
        Scanner scanner = new Scanner(System.in);
        int i = scanner.nextInt();

        switch (i){
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;
            default:
                System.out.println("您输入的月份有误");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    22. switch穿透，判断季节

    package Java2022_6_22;

import java.util.Scanner;

public class SwitchSeason {
    public static void main(String[] args) {

        System.out.println("请输入1-12月份中的一个月份");
        Scanner scanner = new Scanner(System.in);
        int i = scanner.nextInt();

        switch (i){
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;
            default:
                System.out.println("您输入的月份有误！");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    image-20220622121725041 image-20220622121822960

    23. For循环

    package Java2022_6_22;

public class ForUse {
    public static void main(String[] args) {

        int i = 0;          //提升作用域
        for (; i < 10; i++) {
            System.out.println("i="+i);

        }
        System.out.println(i);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    image-20220624090006781

    24. For求9倍数

    问题：1-100 取出9的倍数，求出有多少个，并且这些数相加的总数是多少？

    package Java2022_6_22;

public class ForUse {
    public static void main(String[] args) {

        int j=0;
        int sum = 0;
        for (int i=1; i<100; i++) {

            if(i%9==0) {       //取出9的倍数
                j++;           //j起到计数器的作用，求出有多少个9的倍数
                sum=sum+i;
                System.out.println(i);
            }
        }

        System.out.println("共有"+j+"个9的倍数");

        System.out.println("这些数相加的总数是"+sum);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    image-20220624091050515

    25. 使用For循环嵌套做一个99乘法表

    package Java2022_6_24;

public class MulFor {
    public static void main(String[] args) {
        // 1*1
        // 1*2 2*2
        // 1*3 2*3 3*3
        // 1*4 2*4 3*4 4*4
        // …………一共9层
        for (int i=1; i<=9; i++) {
            for (int j=1; j<=i; j++) {
                System.out.print(j+"*"+i+"="+(j*i)+"\t");    //print:不换行输出
            }
            System.out.println();   //println:自动换行
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    image-20220624092322641

    26. For嵌套，打印一个金字塔

    package Java2022_6_24;

public class GoldTown {
    public static void main(String[] args) {
        //      *           1 = 1*2-1       空格数: 5
        //     ***          3 = 2*2-1              4
        //    *****         5 = 3*2-1              3
        //   *******        7 = 4*2-1              2
        //  *********       9 = 5*2-1              1

        int n = 5;      //n:是层数
        for (int i=1; i<=n; i++) {
            for (int j=n; j>=i; j--) {      //作用：输出每一行的空格数
                System.out.print(" ");      //无换行输出空格
            }
            for (int j=1; j<=i*2-1; j++) {
                System.out.print("*");      //无换行输出*
            }
            System.out.println();       //作用：换行
        }

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    image-20220624093831961

    –打印镂空金字塔：

    package Java2022_6_24;

public class GoldTown {
    public static void main(String[] args) {
        //打印镂空金字塔
        //      *
        //     * *
        //    *   *
        //   *     *
        //  *       *

        int n = 5;      //n:是层数
        for (int i=1; i<=n; i++) {
            for (int j=n; j>=i; j--) {      //作用：输出每一行的空格数
                System.out.print(" ");      //无换行输出空格
            }
            for (int j=1; j<=i*2-1; j++) {
                if (j==1 || j==i*2-1) {     //if条件：当是第一个位子或者是最后一个位子时，输出*
                    System.out.print("*");
                }
                else {
                    System.out.print(" ");
                }
            }
            System.out.println();       //作用：换行
        }

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    image-20220624094642019

    27. continue、break、return的区别

    –continue作用：跳过一个数，但不结束循环。

    package Java2022_6_24;

public class CoBrRe {
    public static void main(String[] args) {

        for (int i = 0; i<4; i++) {
            System.out.println(i);

            if(i == 2) {
                continue;       //continue的作用是跳过一个数，但不结束循环
            }
            System.out.println("正在执行循环");
        }
        System.out.println("已退出循环");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    image-20220624095135523

    –break作用：跳出循环，直接结束，不会再执行下一数。

    package Java2022_6_24;

public class CoBrRe {
    public static void main(String[] args) {

        for (int i = 0; i<4; i++) {
            System.out.println(i);

            if(i == 2) {        
                break;		//break作用：跳出循环，直接结束，不会再执行下一个数
            }
            System.out.println("正在执行循环");
        }
        System.out.println("已退出循环");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    image-20220624095428166

    –return作用：直接跳出main()方法，下面的语句都不再执行

    package Java2022_6_24;

public class CoBrRe {
    public static void main(String[] args) {

        for (int i = 0; i<4; i++) {
            System.out.println(i);

            if(i == 2) {
                return;         //return作用：直接跳出main()方法，下面的语句都不再执行
            }
            System.out.println("正在执行循环");
        }
        System.out.println("已退出循环");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    28. 水仙花数

    问题1：153是水仙花数吗？

    package Java2022_6_24;

public class WaterNum {
    public static void main(String[] args) {

        //什么是水仙花数？例如153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27

        int n = 153;
        int HunNum = n/100;          //得到百位上的数
        int TenNum = n%100 /10;      //得到十位上的数
        int OneNum = n%10;           //得到个位上的数

        if (HunNum*HunNum*HunNum + TenNum*TenNum*TenNum + OneNum*OneNum*OneNum == n) {
            System.out.println(n+"是水仙花数");
        }
        else {
            System.out.println(n+"不是水仙花数");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    image-20220624104810920

    问题2：使用键盘录入一个数，判读其是否为水仙花数？

    package Java2022_6_24;

import java.util.Scanner;

public class WaterNum {
    public static void main(String[] args) {

        //什么是水仙花数？例如153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27
        System.out.println("请输入要判断的数：");
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();

        int HunNum = n/100;          //得到百位上的数
        int TenNum = n%100 /10;      //得到十位上的数
        int OneNum = n%10;           //得到个位上的数

        if (HunNum*HunNum*HunNum + TenNum*TenNum*TenNum + OneNum*OneNum*OneNum == n) {
            System.out.println(n+"是水仙花数");
        }
        else {
            System.out.println(n+"不是水仙花数");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    image-20220624105123629

    问题3：100-1000有哪些数是水仙花数？

    package Java2022_6_24;

import java.util.Scanner;

public class WaterNum {
    public static void main(String[] args) {

        //什么是水仙花数？例如153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27

        for (int n=100; n<=1000; n++) {
            int HunNum = n/100;          //得到百位上的数
            int TenNum = n%100 /10;      //得到十位上的数
            int OneNum = n%10;           //得到个位上的数

            if (HunNum*HunNum*HunNum + TenNum*TenNum*TenNum + OneNum*OneNum*OneNum == n) {
                System.out.println(n+"是水仙花数");
            }
            else {
                continue;       //不是水仙花数就不输出，执行continue，跳过当前的数
            }
        }
    }
}

--验证一下370是水仙花数：
      3*3*3 + 7*7*7 +0*0*0 = 27+343+0 = 370

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    image-20220624105513022

    29. 打印a-z或者Z-A

    package Java2022_6_24;

public class PrintAtoZ {
    public static void main(String[] args) {
        // a-z Z-A
        for (char ch1='a'; ch1<='z'; ch1++) {
            System.out.print(ch1+" ");    //" " :使得每打印一个字母后都跟一个空格
        }
        System.out.println();             //换行
        for (char ch2='Z'; ch2>='A'; ch2--) {
            System.out.print(ch2+" ");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    image-20220624112359553

    30. 数组求最大值

    问题：判断1,5,3,-63,100,500中的最大值是哪个？

    package Java2022_6_24;

public class ArrayMax {
    public static void main(String[] args) {
        //问题：判断1,5,3,-63,100,500中的最大值是哪个？

        int [] arr = {1,5,3,-63,100,500};
        int Max = arr[0];       //假设一个最大值，使得其它数与它进行比较
        for (int i=1; i<arr.length; i++) {
            if (Max<arr[i]) {
                Max = arr[i];
            }
        }
        System.out.println("arr数组中的最大值为"+Max);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    image-20220624113124961

    31. 数组赋值

    结论：a数组赋值给b数组后，修改其中任意一个数组都会影响到另一个数组。

    package Java2022_6_24;

public class ArrNum {
    public static void main(String[] args) {

        String [] You = {"你","你的父亲","你的母亲"};                 //String []：字符串类型的数组
        String [] You2 = You;        //把You数组，复制给You2数组
        System.out.println(You[0]+"\t"+You[1]+"\t"+You[2]);     //依次打印："你","你的父亲","你的母亲"
        System.out.println(You2[0]+"\t"+You2[1]+"\t"+You2[2]);
        System.out.println("------------------");

        //如果对You2数组中的值进行修改，那么会影响到You1数组，因为对数组来说改的是地址
        You2 [0] = "我";
        You2 [1] = "我爸爸";
        You2 [2] = "我妈妈";
        System.out.println("You2数组="+You2[0]+"\t"+You2[1]+"\t"+You2[2]);

        //You数组被完全修改了
        System.out.println("You数组="+You[0]+"\t"+You[1]+"\t"+You[2]);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    image-20220624115347239

    32. 数组拷贝 copy

    package Java2022_6_24;

import javax.sound.midi.Soundbank;

public class ArrayCopy {
    public static void main(String[] args) {

        //任务：把arr1数组中的数据拷贝到arr2中
        int [] arr1 = {0,1,2};
        int[] arr2 = new int[arr1.length];      //开辟一个大小和arr1一样长的空数组

        /*想要拷贝，这里就不能使用赋值符号！
        * 因为直接把arr1赋值给arr2的话，
        * 修改arr2的同时，会把arr1给修改了，这不是我们想要的。
        * 需要使用for循环。
        * */
        for (int i=0; i<arr2.length; i++) {         //依次拷贝
            arr2[i] = arr1[i];
        }
        for (int i=0; i<arr2.length; i++) {         //输出当前arr2数组中的值
            System.out.print(arr2[i]+" ");
        }

        System.out.println();       //换行
        System.out.println("----------------------------");

        //测试修改arr2数组中的值，观察是否影响到arr1数组
        arr2[0]= 666;

        for (int i=0; i<arr1.length; i++) {
            System.out.print(arr1[i]+" ");          //输出当前arr2数组中的值
        }

        System.out.println();       //换行
        for (int i=0; i<arr2.length; i++) {
            System.out.print(arr2[i]+" ");          //输出当前arr2数组中的值
        }
    }
}

--结论：不会影响。

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    image-20220624121301803

    33. 数组逆序

    package Java2022_6_24;

public class ArrayReverse {
    public static void main(String[] args) {

        int arr [] = {11, 22, 33, 44, 55, 66};
        for (int i = 0; i < arr.length/2; i++) {
            int temp = arr[arr.length -1 - i];          //-1是为了防止越界
            arr[arr.length -1 - i] = arr[i];
            arr[i] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    image-20220624154100412

    34. 冒泡排序

    任务：使用冒泡排序，将数字55,66,44,22,11从小到大排序。

    package Java2022_6_24;

public class PopSort {
    public static void main(String[] args) {

        //任务：使用冒泡排序，将数字55,66,44,,22,11从小到大排序
        int arr1[] = {55,66,44,22,11};

        for (int i = 0; i < arr1.length; i++) {
            for (int j = 1; j < arr1.length; j++) {
                int temp = arr1[j-1];

                if (arr1[j-1] > arr1[j]) {
                    arr1[j-1] = arr1[j];
                    arr1[j] = temp;
                }
            }
        }

        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i]+" ");
        }

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    image-20220624155017979

    35. 对象赋值

    结论：a对象直接赋值给b对象时，修改其中一个，必定导致另一个跟着变化，与数组赋值有异曲同工之妙。

    package Java2022_6_24;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import javax.swing.plaf.synth.SynthOptionPaneUI;

public class Object01 {
    public static void main(String[] args) {
        Person Xiaoming = new Person();
        Xiaoming.name = "小明";
        Xiaoming.age = 18;

        Person Tiedan = new Person();
        Tiedan = Xiaoming;
        System.out.println(Tiedan.age+"\t"+Tiedan.name);        //此时输出的铁蛋信息和小明一样
        System.out.println("-------------------");

        Tiedan.name = "铁蛋";
        System.out.println(Xiaoming.age+"\t"+Xiaoming.name);     //Tiedan.name修改为铁蛋时，小明名字也变成了铁蛋
    }
}

class Person {
    String name;
    int age;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    image-20220624160057485

    原理图：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TZRotXwe-1657026827687)(C:\Users\16250\AppData\Roaming\Typora\typora-user-images\image-20220624161744536.png)]

    36. 方法传参机制 （对象的方法）

    package Java2022_6_24;

public class ObjectMethod {
    public static void main(String[] args) {
        Person2 Jerry = new Person2();
        Jerry.age = 20;
        Jerry.name = "Jerry";

        Jerry.method(Jerry);                //使用method方法后，发现Jerry的名字被修改为Tom了
        System.out.println(Jerry.age+"\t"+Jerry.name);
    }
}

class Person2 {
    String name;
    int age;
    void method(Person2 p) {
        p.name = "Tom";
        p.age = 18;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    image-20220624163002976

    问题：当改为p=null; 时，是否会影响到Jerry对象的值？

    class Person2 {
    String name;
    int age;
    void method(Person2 p) {
        p=null;
    }
}

--结论：不会

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    image-20220624164123082

    原理图：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Np9q8yPQ-1657026827688)(C:\Users\16250\AppData\Roaming\Typora\typora-user-images\image-20220624163851790.png)]

    38. 方法的递归1

    package Java2022_6_24;

public class DiGuiMethod {
    public static void main(String[] args) {
        Num num = new Num();
        num.method(4);
    }
}

class Num {
    void method(int n) {         //创建一个方法名为method，传参为n
        if (n > 2) {
            method(n-1);
        }
        System.out.println("n="+n);     //输出n的值
    }
}

--想象中：第一次调用4>2 , 4-1=3。第二次调用3>2 3-1=2。第三次调用2不大于2，应该输出3，4就结束。
--实际上：输出了2，3，4

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    image-20220624165046048

    原理图：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lrfbnCsB-1657026827689)(C:\Users\16250\AppData\Roaming\Typora\typora-user-images\image-20220624170129802.png)]

    38. 递归2（阶乘）

    package Java2022_6_25;

public class DiGui2Method {
    public static void main(String[] args) {
        Num2 num2 = new Num2();
        System.out.println(num2.method(5));
    }
}

class Num2 {
    public int method (int n) {
        if (n == 1) {
            return 1;
        }
        else {
            return method (n-1)*n;
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    image-20220625091340696 image-20220625091249968

    39. 方法重载

    package Java2022_6_25;

public class OverloadMethod {
    public static void main(String[] args) {
        Num3 num3 = new Num3();
        num3.add(1,2);
        num3.add(1,2,3);
        num3.add(1,2,3,4);
    }
}

class Num3 {
    //要么改变形参个数，要么改变形参的类型
    void add(int n1,int n2) {
        System.out.println(n1+n2);
    }

    void add(int n1,int n2,int n3) {
        System.out.println(n1+n2+n3);
    }
    
    void add(int n1,int n2,int n3,int n4) {
        System.out.println(n1+n2+n3+n4);
    }
}

结果：
    3
    6
    10

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    任务1：想要使多个参数相加在一起，例如n1+n2+n3+n4，有没有更简便的方法？

    package Java2022_6_25;

public class OverloadMethod {
    public static void main(String[] args) {
        Num3 num3 = new Num3();
        num3.add(1,2,3,4,5,6);				//只需要修改这一行，就能实现不同参数相加
    }
}

class Num3 {
    void add(int...nums) {
        int res = 0;
        for (int i=0; i<nums.length; i++) {
            res+=nums[i];
        }
        System.out.println(res);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    image-20220625093030156

    任务1：实现不同类型的参数相加，例如1.0+2+3+4+5+6？

    package Java2022_6_25;

public class OverloadMethod {
    public static void main(String[] args) {
        Num3 num3 = new Num3();
        num3.add(1.0,2,3,4,5,6);
    }
}

class Num3 {
    void add(double d1,int...nums) {
        int res = 0;
        for (int i=0; i<nums.length; i++) {
            res+=nums[i];
        }
        System.out.println(d1+res);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    image-20220625093324040

    40. 构造器

    package Java2022_6_25;

public class ConstractUse {
    public static void main(String[] args) {
        Person p1 = new Person("小明",18);
        Person p2= new Person("大明");   //使用第二个构造器，age默认为0
        System.out.println(p1.name+"\t"+p1.age);
        System.out.println(p2.name+"\t"+p2.age);
    }
}

class Person {
    String name;
    int age;

    public Person (String name, int age) {      //构造器的名字与类名一样
        this.name = name;
        this.age = age;
    }
    //构造器可以有两个参数，也可以仅有一个参数。如果只有一个参数的话，那就是方法重载。

    public Person (String name) {      //构造器的名字与类名一样
        this.name = name;
        this.age = age;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    image-20220625094201933

    41. 对象对比（构造器）

    制作一个构造器，判断两个对象是否相同？

    package Java2022_6_25;

public class ConstracUse2 {
    public static void main(String[] args) {
        Dog dog1 = new Dog("小白",10);
        Dog dog2 = new Dog("旺财", 3);
        boolean compto = dog1.compto(dog2);
        System.out.println(compto);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {        //制作一个构造器，用来传入两个参数
        this.name = name;
        this.age = age;
    }

    public boolean compto(Dog dog) {         //制作一个构造器，判断两个对象是否相同。
        if(this.age==dog.age && this.name.equals(dog.name)) {
            //age不用equals的原因：因为equals是字符串对比，而age是int型。
            return true;
        }
        else {
            return false;
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    image-20220625095504941

    简化构造器compto的写法：

       public boolean compto(Dog dog) {         //制作一个构造器，判断两个对象是否相同。
       return this.age==dog.age && this.name.equals(dog.name);
       //结果会返回true或者false。
    }

    • 1
    • 2
    • 3
    • 4

    42. 继承（一）

    常规情况下：

    package Java2022_6_25;

public class TestCatBird {      //公共类，用来调用Cat类和Bird类
    public static void main(String[] args) {
        Cat cat = new Cat();
        Bird bird = new Bird();

        cat.name = "白猫";
        bird.name = "黑鸟";
        cat.age = 3;
        bird.age = 5;
        System.out.println(cat.name+"\t"+cat.age);
        System.out.println(bird.name+"\t"+bird.age);
    }
}


package Java2022_6_25;

public class Cat {
    String name;
    int age;

    public void shut() {
        System.out.println("猫在叫");
    }
}


package Java2022_6_25;

public class Bird {
    String name;
    int age;

    public void shut() {
        System.out.println("鸟在叫");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    image-20220625100632450

    问题：只要在Cat类和Bird类中添加私有的“private”，即使在同一包内，TestCatBird主类也无法调用它们，怎么解决这个问题？

    package Java2022_6_25;

public class Cat {
    private String name;		//private:表示私有的。
    private int age;			//private:表示私有的。

    public void shut() {
        System.out.println("猫在叫");
    }
}

package Java2022_6_25;

public class Bird {
    private String name;
    private int age;

    public void shut() {
        System.out.println("鸟在叫");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    解决办法，使用有参构造：

    image-20220625101247545

    继承（二）

    但是代码的冗余度很高，所以可以建一个共有属性类Animal：

    package Java2022_6_25;

public class Animal {
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    getter and setter的快捷路径：

    image-20220625102133122

    Bird类继承了Animal类的时候，需要导包：

    image-20220625102430803

    最终代码如下：

    --主类：
    
package Java2022_6_25;

public class TestCatBird {      //公共类，用来调用Cat类和Bird类
    public static void main(String[] args) {
        Cat cat = new Cat("蓝猫",6);
        Bird bird = new Bird("麻雀",7);
        System.out.println(cat.getName()+"\t"+cat.getAge());
        System.out.println(bird.getName()+"\t"+bird.getAge());
    }
}

--Animal类：
package Java2022_6_25;

public class Animal {
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

--Cat类：
package Java2022_6_25;

public class Cat extends Animal{

    //导包后的内容
    public Cat(String name, int age) {      //有参构造
        super(name, age);
    }
    //

    public void shut() {
        System.out.println("猫在叫");
    }
}

--Bird类：
package Java2022_6_25;

public class Bird extends Animal{       //Bird类 继承了 Animal类

    //导包后的内容
    public Bird(String name, int age) {     //有参构造
        super(name, age);
    }
    //

    public void shut() {
        System.out.println("鸟在叫");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    image-20220625103634004

    也可以使用多态去调用，结果是一样的：

    image-20220625103730858

    继承（三）

    问题：若是是Cat2类继承Cat类，那Cat2类与Animal类是什么关系，是孙子类吗？

    答：不是孙子类，Cat2类和Cat类一样，仍然是Animal类的子类。

    package Java2022_6_25;

public class Cat2 extends Cat{
    public Cat2(String name, int age) {
        super(name, age);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    43. 继承关系super （父类与子类的执行顺序）

    在子类的有参构造器中会隐含一个super();

    而super会先调用父类的无参构造器，所以会先打印父类中的语句。

    package Java2022_6_25;

public class ABExtendsQue {
    public static void main(String[] args) {
        B b = new B();      //a     b      B
    }
}


class A {
    public A() {
        System.out.println("a");        //执行顺序1     a
    }
}



class B extends A{              //A是B的父类
    String name;
    public B() {                //无参构造器
        //传递一个b，this会执行此类的有参构造器
        this("b");           //执行顺序2
        System.out.println("B");    //执行顺序4     B
    }

    public B(String name) {      //有参构造器
        //在有参构造器中会隐含一个super(); 而super会先调用父类的无参构造器，所以会先打印a
        super();
        this.name = name;
        System.out.println(name);     //执行顺序3  b
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    image-20220625105902313

    44. 向上转型

    Object是Animal的父类，Animal是Cat的父类。

    向上转型：是把Cat提升到Animal的高度。能用父类的所有方法，但父类没有的方法不能用。

    image-20220625141256700 
    package Java2022_6_25.up;

public class Animal {
    public void run() {
        System.out.println("爷会跑");
    }

    public void eat() {
        System.out.println("爷会吃");
    }
}

class Cat extends Animal {
    public void run() {                 //方法重写
        System.out.println("猫会跑");
    }
    public void cli() {
        System.out.println("猫会爬");
    }
}

class Dog extends Animal {
    public void run() {                 //方法重写
        System.out.println("狗会跑");
    }
    public void shut() {                 //方法重写
        System.out.println("狗会叫");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    package Java2022_6_25.up;

public class AnimalTest {
    public static void main(String[] args) {
       Animal animal = new Cat();          //编译看左边，运行看右边。
        //也可以写成 Object animal = new Cat(); 因为Object是Animal的父类。

        //向上转型是把Cat提升到Animal的高度，能用父类的所有方法
        animal.eat();
        animal.run();      //Cat类里没有，但父类Animal里有，所以可以使用。

        //animal.cli();     不能使用，因为父类里没有这个方法。要想使用就需要向下转型。
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    image-20220625142115075

    44. 向下转型

    Animal类与上面一致。

    package Java2022_6_25.up;

public class AnimalTest {
    public static void main(String[] args) {
       Animal animal = new Cat();          //编译看左边，运行看右边。

        //向上转型是把Cat提升到Animal的高度，能用父类的所有功能
        animal.eat();
        animal.run();

        //animal.cli();     不能使用，因为父类里没有这个方法，要想使用就需要向下转型。
        Cat cat = (Cat) animal;         //类似与数据类型的向下强转。
        cat.cli();                      //现在可以使用cli()方法了。
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    image-20220625142422383

    45. 编译运行多态

    package Java2022_6_25.mulQue;

public class MulQue {
    public static void main(String[] args) {
        B b = new B();
        System.out.println(b.count);        //20       ，看25行

        b.method();                         //20       ，看26行
        A a = b;
        System.out.println(a == b);         //true，证明了a和b是同一个地址值
        System.out.println(a.count);        //10       ，看17行
        a.method();                         //20       ，看27行
    }
}

class A {
    int count = 10;						//第17行
    public void method() {
        System.out.println(this.count);
    }
}


class B extends A {
    int count = 20;						//第25行
    public void method() {				 //第26行
        System.out.println(this.count);   //第27行 //this.count 先看局部，局部没有看全局，也就是20
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    image-20220625143838878

    46. 多态动态绑定

    package Java2022_6_25.mulQue;

public class MulQue2 {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb.i);           //20
        System.out.println(bb.sum());       //50
        System.out.println("------------------------------");
        AA aa = bb;          //编译看左边，运行看右边。
        System.out.println(aa.i);        //10   //编译看左边
        System.out.println(aa.sum());    //50   //运行看右边，执行第30行的代码
        System.out.println(aa.sum2());   //60   //运行看右边，执行第34行的代码
    }
}

class AA {
    int i = 10;
    public int sum() {        //看右边，所以不执行这一条 //第17行
        return i+10;
    }
    public int sum2() {
        return getI()+20;
    }
    public int getI() {
        return i;
    }
}

class BB extends AA {
    int i = 20;
    public int sum() {      //看右边，执行这一条 //第30行
        return i+30;
    }
    public int sum2() {     //第34行
        return getI()+40;
    }
    public int getI() {
        return i;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    image-20220625145732131

    47. 对象的对比

    package Java2022_6_27.Person;

public class Person {
    private String name;
    private int age;
    private String job;
    private char sex;

    public Person(String name, int age, String job, char sex) {	//构造器（自动生成）
        this.name = name;
        this.age = age;
        this.job = job;
        this.sex = sex;
    }
	
    //对象对比一共有三种情况：和自己比返回true，和其他对象比返回true，和其他对象比返回false
    public boolean equals(Object obj) {		
        if(this == obj) {			//如果自己和自己对比，那一定返回true
            return true;
        }
        if(obj instanceof Person) {     //如果obj是Person的之类的话，就可以向下转型
            Person person = (Person) obj;
            if(this.name.equals(person.name) && this.age == person.age
             && this.job.equals(person.job) && this.sex == person.sex) {
                return true;		//如果以上的全部数据都相同就返回true
            }
        }
        return false;   		//只要一个不同就返回false
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    package Java2022_6_27.Person;
//（1）对象自己和自己比返回true
public class PersonTest {
    public static void main(String[] args) {
        Person doctor1 = new Person("小明", 20, "医生", '男');	
        Person doctor2 = new Person("小明", 30, "医生", '男');
        boolean equals = doctor1.equals(doctor1);	//对象自己和自己比
        System.out.println(equals);			//返回true
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    image-20220627185232923 
    package Java2022_6_27.Person;
//（2）和其他对象比返回true
public class PersonTest {
    public static void main(String[] args) {
        Person doctor1 = new Person("小明", 20, "医生", '男');
        Person doctor2 = new Person("小明", 20, "医生", '男');
        boolean equals = doctor1.equals(doctor2);	//和其他对象比
        System.out.println(equals);			//条件全部相同，所以返回true
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    image-20220627183835738 
    package Java2022_6_27.Person;
//（3）和其他对象比返回false
public class PersonTest {
    public static void main(String[] args) {
        Person doctor1 = new Person("小明", 20, "医生", '男');
        Person doctor2 = new Person("小明", 30, "医生", '男');
        boolean equals = doctor1.equals(doctor2);	//和其他对象比
        System.out.println(equals);			//年龄不同，所以返回false
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    image-20220627184356297

    48. equals 与 == 的区别

    equals：对比的是它们的引用类型的值是否相同（两个对象的地址值是否相等）

    == ：对比的是它们数据类型的值是否相同

    --例子1：
 public boolean equals(Object obj) {	//这里的equals对比的是两个对象的地址值是否相等
        if(this == obj) {
            return true;
        }
  
 --例子2：  
 if(
    this.name.equals(person.name) 		//name是string类型的，所以用 equals 进行比较
    && this.age == person.age			//age是int类型的，所以用 == 进行比较
    && this.job.equals(person.job) 
    && this.sex == person.sex
 ) 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    49. 类变量

    package Java2022_6_27.Person;

public class ClassVar {
    public static void main(String[] args) {
        Child child1 = new Child("小明");
        child1.join();
        Child child2 = new Child("小明");
        child2.join();
        System.out.println(Child.count); //结果为2。new了两个对象，调用了join(),count++。
        System.out.println(child1.count);   //2
        System.out.println(child2.count);   //2
        //三种访问类型的结果都一样，因为静态类变量可以直接用类去调用，其结果随着类的加载而加载。
    }
}


class Child {
    public String name;             //name属性
    public static int count = 0;        //count属性

    public Child(String name) {     //name属性的有参构造
        this.name = name;
    }

    public void join() {      //方法
        count++;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    image-20220627193143002 
    --相反的例子：
public class ClassVar {
    public static void main(String[] args) {
        System.out.println(Child.count);	//0	
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    image-20220627193239901 image-20220627194347792

    50. 类方法

    package Java2022_6_28;

import Java2022_6_27.Person.Person;

public class ClassMethod {
    public static void main(String[] args) {
        Person02 person02 = new Person02("黎明");
        person02.payfee(200);
        Person02 person03 = new Person02("王歌");
        person03.payfee(100);

        //测试普通方法能否获取静态变量？ 答：可以。
        person02.Count();       //用对象去调用静态方法
    }
}


class Person02 {
    private String name;
    private static double fee;      //学费
    private static double count;    //总学费

    public Person02(String name) {            //有参构造方法
        this.name = name;
    }

    public void payfee(double fee) {          //普通方法
        count+=fee;
    }

    public static void Count() {              //静态方法
        System.out.println(count);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    image-20220628101249646

    51. 代码块

    （1）情况一：

    对象创建后，代码块就会执行。

    package Java2022_6_28;

public class CodeBlock {
    public static void main(String[] args) {
        AA aa = new AA();       //创建对象aa
    }
}
class AA {
    {		//普通代码块
        System.out.println("AA的代码块");       //在对象创建后，该代码块就会执行
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    image-20220628101711496

    （2）情况二：

    调用静态成员变量时，不会创建对象，所以普通代码块中的语句不会执行。

    package Java2022_6_28;

public class CodeBlock {
    public static void main(String[] args) {
        System.out.println(AA.age);         //调用AA类中的静态成员变量age
    }
}
class AA {
    public static int age = 0;                //age是静态成员变量
    {		//普通代码块
        System.out.println("AA的代码块");       //该代码块语句不会执行，因为我们在调用静态成员变量时，不会创建对象
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    image-20220628102241538

    （3）情况三：

    调用静态成员变量时，先输出的是静态代码块中的内容。

    package Java2022_6_28;

public class CodeBlock {
    public static void main(String[] args) {
        System.out.println(AA.age);         //调用AA类中的静态成员变量age
    }
}
class AA {
    public static int age = 0;                //age是静态成员变量
    static {        //静态代码块
        System.out.println("AA的代码块");       //先执行
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    image-20220628102526330

    （4）情况四：

    执行子类的静态代码块，必定会先执行父类的静态代码块。

    或者可以说是：

    调用子类的静态成员变量时，必定会先执行父类的静态代码块。

    package Java2022_6_28;

public class CodeBlock {
    public static void main(String[] args) {
        //测试调用BB类中的静态成员变量age,观察AA中的静态代码块会不会执行?
        //答：会。会先执行AA中的静态代码块，再执行BB的，因为BB继承于AA。
        System.out.println(BB.age);
    }
}
class AA {
    public static int age = 0;                //age是静态成员变量
    static {        //静态代码块
        System.out.println("AA的代码块");       //先执行
    }
}

class BB extends AA {
    public static int age = 1;                //age是静态成员变量
    static {        //静态代码块
        System.out.println("BB的代码块");		
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    image-20220628103725954

    （5）情况五：

    如果父类的代码块只是普通代码块，则调用子类的静态成员变量时，父类的普通代码块不会执行。

    package Java2022_6_28;

public class CodeBlock {
    public static void main(String[] args) {
        //测试调用BB类中的静态成员变量age,观察AA中的静态代码块会不会执行?
        //答：会。会先执行AA中的静态代码块，再执行BB的，因为BB继承于AA。
        System.out.println(BB.age);
    }
}
class AA {
    public static int age = 0;                //age是静态成员变量
    {        //普通代码块
        System.out.println("AA的代码块");       //不会执行
    }
}

class BB extends AA {
    public static int age = 1;                //age是静态成员变量
    static {        //静态代码块
        System.out.println("BB的代码块");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    image-20220628104010737

    52. 静态代码块，普通代码块

    在调用构造方法之前会自动调用super()方法，以及super()的普通代码块

    package Java2022_6_28;

import org.omg.CORBA.PUBLIC_MEMBER;

public class ClassBlockMethod {
    public static void main(String[] args) {
        B b = new B();
    }
}

class A {
    {                   //普通代码块
        System.out.println("A的普通代码块");
    }
    static {
        System.out.println("A的静态代码块");
    }
    public A() {        //A的构造方法
        System.out.println("A的构造器");
    }
}

class B extends A {
    {                   //普通代码块
        System.out.println("B的普通代码块");
    }
    static {
        System.out.println("B的静态代码块");
    }
    public B() {        //B的构造方法
        System.out.println("B的构造器");
        //在调用构造方法之前会自动调用super()方法，以及super()的普通代码块
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    image-20220628105344647

    53. final修饰符

    被final修饰的方法，不能被子类重写。

    final class A{} 表示A类不能被继承

    image-20220628110301582

    如果静态属性被final修饰，那么调用静态属性的时候，静态代码块将不再执行。

    package Java2022_6_28;

public class FinalUse { //可以修饰基本数据类型
    public static void main(String[] args) {
        System.out.println(C.num);
    }
}

class C {
    public static final int num = 0;
    static {
        System.out.println("C的静态代码块");		//不执行
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    image-20220628110719825

    54. final使用

    任务：计算圆的面积和周长。

    package Java2022_6_28;

import sun.dc.pr.PRError;

public class FinalUse02 {
    public static void main(String[] args) {
        Circle circle = new Circle();
        System.out.println(circle.ZhongChang(10));      //62.800000000000004
        System.out.println(circle.MianJi(10));          //314.0
    }
}

class Circle {      //圆
    private static final double PI = 3.14;

    public double MianJi(double R){          //计算面积
        return R*R*PI;
    }
    public double ZhongChang(double R){      //计算周长
        return 2*R*PI;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    55. 接口

    implements ：意思是实现

    自动实现方法（@Override）：

    image-20220628153306766 
    package Java2022_6_28;

public class Interface01 {
    public static void main(String[] args) {
        //因为接口不能实例化，所以不能new一个接口
    }
}


interface Animal {
    int i = 10;     //public static final int i = 10;//public static final可以省略
    void run();     //public abstract void run();//public abstract可以省略
}
interface Cat {
    void cli();
}
interface Dog extends Animal,Cat{           //接口Dog只能继承接口，不能继承类

}
abstract class Bird2 implements Dog {   //抽象类实现接口，不用重写方法体

}

class Bird implements Animal,Cat {

    @Override
    public void run() {
        System.out.println("鸟会跑");
    }

    @Override
    public void cli() {
        System.out.println("不仅猫会爬，鸟也会爬");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    56. 接口的属性调用

    三种方式都可以调用接口的属性：

    （1）对象.属性
    （2）接口名.属性
    （3）(实现了接口的类).属性

    package Java2022_6_28;

public class Interface02 {
    public static void main(String[] args) {
        BBB bbb = new BBB();
        System.out.println(bbb.i);      //对象.属性
        System.out.println(AAA.i);      //接口名.属性
        System.out.println(BBB.i);      //(实现了接口的类).属性
    }
}

interface AAA {
    int i = 10; //public static final int i = 10;
}

class BBB implements AAA {      //BBB类实现了AAA接口

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    57. 继承+实现属性的调用

    package Java2022_6_28;

public class Interface03 {
    public static void main(String[] args) {
        X x = new X();/*
        X继承于Z，同时又实现了接口Y，体现了多态，所以下面两种写法也可以。
        Y x = new X();
        Z x = new X();
        */
        x.show();
    }
}


interface Y {
    int i = 10;
}

class Z{
    int i = 20;
}

class X extends Z implements Y {      //X继承于Z，同时又实现了接口Y
    public void show() {
        System.out.println(Y.i+"  "+super.i);     //最后+的是X类的父类，也就是Z，所以用super.i
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    image-20220628160550792

    58. 局部内部类

    内部类可以访问外部类的所有东西，包括外部类的private。

    但是外部类，不能访问内部类的变量。

    package Java2022_6_28;

public class OutInpClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.oomethod();
    }
}

class Outer {
    private int i = 10;         //私有属性i
    public void oomethod() {      //method方法
        class inner{            //inner是局部内部类
            int ii = 20;
            public void iimethod() {
                System.out.println("只是内部类的ii="+ii);
                System.out.println("只是外部类的i="+i);
            }
        }
        inner inner = new inner();
        inner.iimethod();       //内部类可以访问外部类的所有东西，包括外部类的private
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    image-20220628161736650

    59. 内外部的类属性同名，要怎样去调用外部值

    outer.hashCode()的值会等于Outer.this.hashCode()的值

    package Java2022_6_28;

public class OutInpClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.oomethod();
        System.out.println("这是out的has值为"+outer.hashCode());
        //460141958
    }
}

class Outer {
    private int i = 10;         //私有属性i
    public void oomethod() {      //method方法
        class inner{            //inner是局部内部类
            int ii = 20;
            public void iimethod() {
                System.out.println("这是内部类的ii="+ii);             //20
                System.out.println("这是外部类的i="+Outer.this.i);	//10
                System.out.println("Outer.this的has值为"+Outer.this.hashCode());
                //460141958
            }
        }
        inner inner = new inner();
        inner.iimethod();       //内部类可以访问外部类的所有东西，包括外部类的private
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    image-20220703094744389

    60. 匿名内部类调用

    package Java2022_7_3;

public class AnoInnerClass {
    public static void main(String[] args) {
        DD dd = new DD();
        dd.method();
    }
}

interface EE {
    void method();
}

class DD {
    public void method() {
        EE ee = new EE() {      //匿名内部类
            //EE是接口名，把EE做为匿名内部类，只能用一次就销毁
            //ee是对象名，所以可以一直使用

            //编译类型是DD$1，是系统帮我们做的，DD$1的值返回给ee
            @Override
            public void method() {
                System.out.println("匿名内部类");
            }
        };
        ee.method();
        System.out.println(ee.getClass()); //DD$1
        //class Java2022_7_3.DD$1
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    image-20220703100732646

    61. 成员内部类（调用成员内部类）

    法一：

    package Java2022_7_3;

public class InnerVar {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        Outer02.Inner02 inner02 = outer02.new Inner02();    //调用成员内部类
        inner02.method();
    }
}

class Outer02 {
    class Inner02 {
        public void method() {
            System.out.println("inner02");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    image-20220704094540259

    法二：

    public class InnerVar {
    public static void main(String[] args) {
        Outer02.Inner02 inner02 = new Outer02().new Inner02();    //调用成员内部类
        inner02.method();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    62. 静态内部类

    package Java2022_7_4;

public class StaticInnerClass {
    public static void main(String[] args) {
        AAA.BBB bbb = new AAA.BBB();
        bbb.method();
    }
}


class AAA{
    static int i = 10;      //外部属性
    static class BBB {
        public void method() {
            System.out.println("BBB");
            //静态内部类可以调用外部类的属性，但被调用的外部属性必须也是静态的
            System.out.println(i);
        }
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    image-20220704095449052

    63. enum（枚举类）

    package Java2022_7_4;

public class Season {
    public static void main(String[] args) {
        System.out.println(Season2.SPRING);
        System.out.println(Season2.SUMMER);
        System.out.println(Season2.AUTHMN);
        System.out.println(Season2.WINTER);
    }
}

enum Season2 {		//枚举类
    //常量用大写表示，多个枚举类用逗号隔开
    SPRING("春天","下雨"),SUMMER("夏天","很热"),AUTHMN("秋天","凉爽"),WINTER("冬天","很冷");

    //构造器
    private String name;        //枚举名字
    private String Use;         //它的性质

    //有参构造
    Season2(String name, String use) {
        this.name = name;
        Use = use;
    }

    //toString方法
    @Override
    public String toString() {
        return "Season2{" +
                "name='" + name + '\'' +
                ", Use='" + Use + '\'' +
                '}';
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    image-20220704100620009

    64. enum（枚举类）+for循环

    package Java2022_7_4;

public class Enum2 {
    public static void main(String[] args) {
        Week [] weeks = Week.values();
        for (Week week: weeks) {
            System.out.println(week);
        }
    }
}

enum Week {
    MONDAY("周一"),TUESDAY("周二"),THESDAY("周三"),THURSDAY("周四"),FRIDAY("周五"),SATUDAY("周六"),SUNDAY("周日");
    private String name;

    Week(String name) {
        this.name = name;
    }

    //覆盖父类(enum)的一个toString方法

    @Override
    public String toString() {
        return "Week{" +
                "name='" + name + '\'' +
                '}';
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    image-20220704101702577

    65. String 类

    package Java2022_7_4;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

public class StingTest01 {
    public static void main(String[] args) {
        AA aa = new AA();
        System.out.println(aa.str.equals(aa.str2));		//true
    }
}

class AA {
    String str = "abc";
    String str2 = new String("abc");
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    public class StingTest01 {
    public static void main(String[] args) {
        AA aa = new AA();
        System.out.println(aa.str==(aa.str2));		//false
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    image-20220704104031714

    intern()：返回该对象的字符串引用

    aa.str2.intern()	//返回对象的常量值
aa.str2				//返回对象

所以：
 System.out.println(aa.str2==(aa.str2.intern());   	//false

    • 1
    • 2
    • 3
    • 4
    • 5

    66. System

    System.exit(0); //表示退出

    package Java2022_7_5;

public class System01 {
    public static void main(String[] args) {
        System.out.println("123");
        System.exit(0);            //0表示退出
        System.out.println("456");
        //结果：只输出了123
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    image-20220705091647139 
    package Java2022_7_5;

public class System01 {
    public static void main(String[] args) {
        int i = 2;
        Long startTime = System.currentTimeMillis();     //从1970-2022的毫秒数
        for (; i < 1000000000; i++) {
            i*=i;
        }
        Long endTime = System.currentTimeMillis();
        Long Time = (endTime - startTime);
        System.out.println("for循环执行的和时间"+Time);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    image-20220705093113470

    67. BigInteger（处理大数据的方法）

    subtract相减、multiply乘、divide除、add加

    package Java2022_7_5;

import java.math.BigInteger;

public class BigInteger01 {
    public static void main(String[] args) {
        BigInteger bigInteger = new BigInteger("111111111111111111111");
        BigInteger bigInteger2 = new BigInteger("222222222222222222222");

        System.out.println(bigInteger.subtract(bigInteger2));
        //subtract：相减
        //multiply：乘
        //divide：除
        //add；加
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    image-20220705094718271

    若除法的结果是无限不循环小数，使用divide的时候就会报错，我们需要降低精度

    package Java2022_7_5;

import java.math.BigDecimal;
import java.math.BigInteger;

public class BigInteger01 {
    public static void main(String[] args) {
        BigDecimal bigDecimal = new BigDecimal("10000000.55555");
        BigDecimal bigDecimal2 = new BigDecimal("333333.3333");

        System.out.println(bigDecimal.divide(bigDecimal2,BigDecimal.ROUND_CEILING));
        //CEILING：意思是天花板，指的是上线
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    image-20220705095514241

    68. Date（时间）

    打印当前时间

    package Java2022_7_5;

import java.util.Date;

public class Date01 {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println("当前时间"+date);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    image-20220705100117459

    显示当前的时间，中文表示

    package Java2022_7_5;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Date01 {
    public static void main(String[] args) {
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("YYYY年MM月dd日 hh:mm:ss");
        //MM表示月份、mm表示分钟
        String s = simpleDateFormat.format(date);
        System.out.println(s);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    image-20220705101141797

    69. Calendar（日历）

    package Java2022_7_5;

import java.util.Calendar;

public class CalendarUse {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.get(calendar.YEAR));
        System.out.println(calendar.get(calendar.MONTH)+1);
        System.out.println(calendar.get(calendar.DAY_OF_MONTH));

        System.out.println(calendar.get(calendar.YEAR)+"年"+(calendar.get(calendar.MONTH)+1)+"月"+calendar.get(calendar.DAY_OF_MONTH)+"日");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    image-20220705103823640

    70. collection+map的结构图

    image-20220705104233484 image-20220705104152325

    71. ArrayList

    package Java2022_7_5;

import java.util.ArrayList;

public class ArrayListUse {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("a");
        arrayList.add(null);
        arrayList.add(null);
        for (Object list : arrayList) {
            System.out.println(list);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    image-20220705130218232

    72. ArrayListSource

    package Java2022_7_5;

import java.util.ArrayList;

public class ArrayListSource {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        for (int i = 1; i <= 10; i++) {
            arrayList.add(i);
        }
        System.out.println(arrayList);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    image-20220705130601739

    73. VectorSource

    package Java2022_7_5;

import java.util.Vector;

public class VectorSource {
    public static void main(String[] args) {
        Vector vector = new Vector();
        for (int i = 1; i <= 10; i++) {
            vector.add(i);
        }
        System.out.println(vector);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    image-20220705131714570

    74. Set

    package Java2022_7_5;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SetUse {
    public static void main(String[] args) {
        Set set = new HashSet();
        //HashSet是实现set接口的一个类的对象
        set.add(123);
        set.add("xiaoming");
        set.add(null);
        set.add("xiaohong");
        set.add("xiaogang");
        set.add("xiaoming");
        set.add(null);
        //由于set的插入与取出的顺序是不同的，所以可以通过以下二个方法来排序
/*        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }*/

        for (Object o : set) {				//快捷方式：I
            System.out.println(o);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    75. map

    package Java2022_7_5;

import java.util.HashMap;
import java.util.Map;

public class MapUse {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("1","xiaoming");
        map.put("1","xiaoming");    //会替代上一行
        map.put("3","xiaohong");
        map.put("4","xiaogang");
        System.out.println(map);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    image-20220705134415071 
    package Java2022_7_5;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.util.HashMap;
import java.util.Map;

public class MapUse {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put(null,null);

        Object o = new Object();
        map.put(o,123);

        System.out.println(map.get(new Object()));  //null
        System.out.println(map.get(o));     //123
        System.out.println(map);      //{null=null, java.lang.Object@1b6d3586=123}
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    image-20220705135318465

    76. Collection

    package Java2022_7_5;

import java.util.ArrayList;
import java.util.Collections;

public class CollectionUse {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add("4");
        arrayList.add("5");
        Collections.reverse(arrayList);	//反转，像栈一样，先进后出
        System.out.println(arrayList);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    image-20220705145832848 
    package Java2022_7_5;

import java.util.ArrayList;
import java.util.Collections;

public class CollectionUse {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add("4");
        arrayList.add("5");
        Collections.sort(arrayList);	//按照字符的大小排序，从小到大
        System.out.println(arrayList);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    image-20220705150206684 
    package Java2022_7_5;

import java.util.ArrayList;
import java.util.Collections;

public class CollectionUse {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add("4");
        arrayList.add("5");
        Collections.swap(arrayList,0,4); //调换位置，把0位置上的数和4位置上数进行调换
        System.out.println(arrayList);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    image-20220705150503775 
    package Java2022_7_5;

import java.util.ArrayList;
import java.util.Collections;

public class CollectionUse {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add("4");
        arrayList.add("5");
        Collections.shuffle(arrayList);     //把顺序打乱，每次都是随机排序
        System.out.println(arrayList);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    image-20220705150628882 
    package Java2022_7_5;

import java.util.ArrayList;
import java.util.Collections;

public class CollectionUse {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add("4");
        arrayList.add("5");
        ArrayList dest = new ArrayList();
        for (int i = 0; i < 5; i++) {
            dest.add(i);
        }
        Collections.copy(dest,arrayList);       //复制，把ArrayList复制给dest
        System.out.println("arrayList="+arrayList);
        System.out.println("dest="+dest);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    image-20220705151108764 
    package Java2022_7_5;

import java.util.ArrayList;
import java.util.Collections;

public class CollectionUse {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add("4");
        arrayList.add("5");
        System.out.println(Collections.max(arrayList)); //求最大值
        System.out.println(Collections.min(arrayList)); //求最小值
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    image-20220705151422754 
    package Java2022_7_5;

import java.util.ArrayList;
import java.util.Collections;

public class CollectionUse {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add("4");
        arrayList.add("5");
        Collections.replaceAll(arrayList,"1","6");
        //把某个已有的值替换为新的值，把1换成6
        System.out.println(arrayList);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    image-20220705151721055

    77. 泛型（Generic）

    package Java2022_7_5;

import java.util.ArrayList;

public class GenericUse {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(new Dog("小白",10));
        arrayList.add(new Dog("小绿",15));
        arrayList.add(new Dog("小蓝",19));

        System.out.println(arrayList);
    }
}

class Dog {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    image-20220705152955552

    上面是可以正常执行的，但当我们引入新的类，就会产生混乱：

    package Java2022_7_5;

import java.util.ArrayList;

public class GenericUse {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(new Dog("小白",10));
        arrayList.add(new Dog("小绿",15));
        arrayList.add(new Dog("小蓝",19));

        arrayList.add(new Cat());
        System.out.println(arrayList);
    }
}

class Dog {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

class Cat {

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YzSdyZ5K-1657026827691)(C:\Users\16250\AppData\Roaming\Typora\typora-user-images\image-20220705153119700.png)]

    为避免这种情况的发生，我们引入一个泛型，再次写入Cat时就会提示错误：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8oWAL3Hh-1657026827691)(C:\Users\16250\AppData\Roaming\Typora\typora-user-images\image-20220705153552963.png)]

    package Java2022_7_5;

import java.util.ArrayList;

public class GenericUse {
    public static void main(String[] args) {
        ArrayList<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog("小白",10));
        dogs.add(new Dog("小绿",15));
        dogs.add(new Dog("小蓝",19));

        System.out.println(dogs);
    }
}

class Dog {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9ZnOFgqr-1657026827692)(C:\Users\16250\AppData\Roaming\Typora\typora-user-images\image-20220705153708782.png)]

    78. 泛型Map

    79. 泛型继承

    package Java2022_7_5;

public class GenericUse04 {
    public static void main(String[] args) {
        Chicken<A> aChicken = new Chicken<>(new B());
    }
}

class A {

}
class B extends A{

}

class Chicken<E> {
    E e;

    public Chicken(E e) {
        this.e = e;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    80. 多线程

    package Java2022_7_5;

public class ThreadUse {
    public static void main(String[] args) {
        Cat02 cat02 = new Cat02();
        cat02.start();
    }
}

class Cat02 extends Thread{
    public void run() {
        int temp = 0;
        while (true) {
            try {
                sleep(1000);    //进程休眠，隔了一秒，再输出
                System.out.println("我是猫");
                temp++;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (temp == 4) {        //当输出第四次"我是猫"的时候结束
                break;
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    image-20220705163009386

    81. 多线程分工

    package Java2022_7_5;

public class ThreadUse {
    public static void main(String[] args) throws InterruptedException {
        Cat02 cat02 = new Cat02();
        cat02.start();

        for (int i = 0; i < 10; i++) {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName()+"在执行，i="+i);
        }
    }
}

class Cat02 extends Thread{
    public void run() {
        int temp = 0;
        while (true) {
            try {
                System.out.println(Thread.currentThread().getName()+"在执行，temp="+temp); //Thread-0

                sleep(1000);    //进程休眠，隔了一秒，再输出
                System.out.println("我是猫");
                temp++;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (temp == 4) {        //当temp=4的时候结束
                break;
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    image-20220705164205769

    82. runnable多线程

    package Java2022_7_5;

public class GenericUse05 {
    public static void main(String[] args) {
        Dog11 dog11 = new Dog11();
        Thread thread = new Thread(dog11);
        thread.start();
    }
}

class Animal {

}

class Dog11 extends Animal implements Runnable{
    @Override
    public void run() {
        System.out.println("狗在叫");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    image-20220705164933221

    83. 多个子线程

    package Java2022_7_5;

public class RunableUse {
    public static void main(String[] args) {
        Cat11 cat11 = new Cat11();
        Bird bird = new Bird();
        Thread thread = new Thread(cat11);
        Thread thread2 = new Thread(bird);
        thread.start();
        thread2.start();
    }
}

class Cat11 implements Runnable{

    @Override
    public void run() {
        int count = 0;
        for (int i = 0; i < 5; i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("猫爬树"+" "+Thread.currentThread().getName()+ ++count);
        }
    }
}

class Bird implements Runnable{

    @Override
    public void run() {
        int count = 0;
        for (int i = 0; i < 5; i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("鸟飞翔"+" "+Thread.currentThread().getName()+ ++count);
        }
    }
}

//结论：两个进程一直在执行，互不影响

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    image-20220705170009887

    84. 线程插队（thread.join();）

    package Java2022_7_5;

public class GenericUse06 {
    public static void main(String[] args) throws InterruptedException {
        Drinking drinking = new Drinking();
        Thread thread = new Thread(drinking);
        thread.start();

        int count = 0;
        for (int i = 0; i < 20; i++) {
            System.out.println("新兵喝"+(++count)+"碗汤");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (i == 5) {       //从第5碗的时候，发生抢占，司令员一次性喝完，才到新兵喝
                System.out.println("司令员先喝，我们等会喝");
                thread.join();
                System.out.println("司令员喝完了，到我们了");
            }
        }
    }
}

class Drinking implements Runnable{

    @Override
    public void run() {
        int count = 0;
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("司令员喝"+(++count)+"碗汤");  
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    image-20220705180251054

    85. 线程礼让（thread.yield(); //礼让不一定会成功）

    package Java2022_7_5;

public class GenericUse06 {
    public static void main(String[] args) throws InterruptedException {
        Drinking drinking = new Drinking();
        Thread thread = new Thread(drinking);
        thread.start();

        int count = 0;
        for (int i = 0; i < 20; i++) {
            System.out.println("新兵喝"+(++count)+"碗汤");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (i == 5) {       //从第5碗的时候，发生抢占，司令员一次性喝完，才到新兵喝
                System.out.println("司令员先喝，我们等会喝");
                thread.yield();     //礼让的话，不一定成功
                System.out.println("司令员喝完了，到我们了");
            }
        }
    }
}

class Drinking implements Runnable{

    @Override
    public void run() {
        int count = 0;
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("司令员喝"+(++count)+"碗汤");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    86. 线程中断

    中断后会抛出异常

    package Java2022_7_5;

public class GenericUse06 {
    public static void main(String[] args) throws InterruptedException {
        Drinking drinking = new Drinking();
        Thread thread = new Thread(drinking);
        thread.start();

        int count = 0;
        for (int i = 0; i < 20; i++) {
            System.out.println("新兵喝"+(++count)+"碗汤");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (i == 5) {       //从第5碗的时候，发生抢占，司令员一次性喝完，才到新兵喝
                System.out.println("新兵先喝，我们等会喝");
                thread.interrupt();                        //中断
                System.out.println("新兵喝完了，到我们了");
            }
        }
    }
}

class Drinking implements Runnable{

    @Override
    public void run() {
        int count = 0;
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {      //抛出中断异常
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
                e.printStackTrace();
            }
            System.out.println("司令员喝"+(++count)+"碗汤");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    image-20220705181335521

    87. 线程级别（thread.setPriority(Thread.MAX_PRIORITY);）

    88. 线程同步（多线程售票）

    package Java2022_7_5;

public class SellTicket {
    public static void main(String[] args) {
        Sell sell = new Sell();
        Thread thread1 = new Thread(sell);
        Thread thread2 = new Thread(sell);
        Thread thread3 = new Thread(sell);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class Sell implements Runnable {
    private static int ticket = 100;


    @Override
    public void run() {
        while (true) {
            if(ticket <= 0) {
                System.out.println("售票结束");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"窗口售票，票还有"+(--ticket));
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    image-20220705182901740

    由于是同时进入的，所以不安全，我们要把他改为同步的：

    package Java2022_7_5;

public class SellTicket {
    public static void main(String[] args) {
        Sell sell = new Sell();
        Thread thread1 = new Thread(sell);
        Thread thread2 = new Thread(sell);
        Thread thread3 = new Thread(sell);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class Sell implements Runnable {
    private static int ticket = 100;
    private boolean loop = true;
    public synchronized void method() {
        if(ticket <= 0) {
            System.out.println("售票结束");
            loop = false;
            return;
        }
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"窗口售票，票还有"+(--ticket));
    }

    @Override
    public void run() {
        while (loop) {
            method();
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38

    执行到0的时候结束售票，一共有三个线程，所以有三次结束售票。

    image-20220705204412673

    89. 创建文件

    法一：

    package Java2022_7_5;

import org.junit.Test;

import java.io.File;
import java.io.IOException;

public class FileCreate {
    @Test
    public void fileC() {
        String filePath = "d:\\javaceshi.txt";
        File file = new File(filePath);
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7Ni5oQwQ-1657026827693)(C:\Users\16250\AppData\Roaming\Typora\typora-user-images\image-20220705205157063.png)]

    法二：

    package Java2022_7_5;

import org.junit.Test;

import java.io.File;
import java.io.IOException;

public class FileCreate {
    @Test
    public void fileC() {
        File FatherPath = new File("d:\\");
        File file = new File(FatherPath,"javaceshi.txt");
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    法三：

    package Java2022_7_5;

import org.junit.Test;

import java.io.File;
import java.io.IOException;

public class FileCreate {
    @Test
    public void fileC() {
        File file = new File("d:\\","javaceshi.txt");
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    90. 文件夹（目录的创建）

    创建单个文件夹：

    package Java2022_7_5;

import org.junit.Test;

import java.io.File;

public class DocCreate {
    @Test
    public void DocC() {
        String DocC = "d:\\demo";
        File file = new File(DocC);
        if(file.exists()) {
            System.out.println("目录已经存在");       //文件存在，就不会再创建
        }else {
            if (file.mkdir()) {
                System.out.println("文件夹创建成功");
            }else {
                System.out.println("文件夹创建失败");
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    image-20220705210026534 image-20220705210042683

    创建多级文件（file.mkdirs()）：

    package Java2022_7_5;

import org.junit.Test;

import java.io.File;

public class DocCreate {
    @Test
    public void DocC() {
        String DocC = "d:\\demo\\demo01\\demo02\\demo03";
        File file = new File(DocC);
        if(file.exists()) {
            System.out.println("目录已经存在");       //文件存在，就不会再创建
        }else {
            if (file.mkdirs()) {        //创建多级文件
                System.out.println("文件夹创建成功");
            }else {
                System.out.println("文件夹创建失败");
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    image-20220705210253059 image-20220705210307846 public static void main(String[] args) { Sell sell = new Sell(); Thread thread1 = new Thread(sell); Thread thread2 = new Thread(sell); Thread thread3 = new Thread(sell); thread1.start(); thread2.start(); thread3.start(); } }

    class Sell implements Runnable {
    private static int ticket = 100;
    private boolean loop = true;
    public synchronized void method() {
    if(ticket <= 0) {
    System.out.println(“售票结束”);
    loop = false;
    return;
    }
    try {
    Thread.sleep(50);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    System.out.println(Thread.currentThread().getName()+“窗口售票，票还有”+(–ticket));
    }

    @Override
public void run() {
    while (loop) {
        method();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    }

    
执行到0的时候结束售票，一共有三个线程，所以有三次结束售票。

<img src="C:\Users\16250\AppData\Roaming\Typora\typora-user-images\image-20220705204412673.png" alt="image-20220705204412673" style="zoom:80%;" />



#### 89. 创建文件

法一：

```java
package Java2022_7_5;

import org.junit.Test;

import java.io.File;
import java.io.IOException;

public class FileCreate {
    @Test
    public void fileC() {
        String filePath = "d:\\javaceshi.txt";
        File file = new File(filePath);
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    [外链图片转存中…(img-7Ni5oQwQ-1657026827693)]

    法二：

    package Java2022_7_5;

import org.junit.Test;

import java.io.File;
import java.io.IOException;

public class FileCreate {
    @Test
    public void fileC() {
        File FatherPath = new File("d:\\");
        File file = new File(FatherPath,"javaceshi.txt");
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    法三：

    package Java2022_7_5;

import org.junit.Test;

import java.io.File;
import java.io.IOException;

public class FileCreate {
    @Test
    public void fileC() {
        File file = new File("d:\\","javaceshi.txt");
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    90. 文件夹（目录的创建）

    创建单个文件夹：

    package Java2022_7_5;

import org.junit.Test;

import java.io.File;

public class DocCreate {
    @Test
    public void DocC() {
        String DocC = "d:\\demo";
        File file = new File(DocC);
        if(file.exists()) {
            System.out.println("目录已经存在");       //文件存在，就不会再创建
        }else {
            if (file.mkdir()) {
                System.out.println("文件夹创建成功");
            }else {
                System.out.println("文件夹创建失败");
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    image-20220705210026534 image-20220705210042683

    创建多级文件（file.mkdirs()）：

    package Java2022_7_5;

import org.junit.Test;

import java.io.File;

public class DocCreate {
    @Test
    public void DocC() {
        String DocC = "d:\\demo\\demo01\\demo02\\demo03";
        File file = new File(DocC);
        if(file.exists()) {
            System.out.println("目录已经存在");       //文件存在，就不会再创建
        }else {
            if (file.mkdirs()) {        //创建多级文件
                System.out.println("文件夹创建成功");
            }else {
                System.out.println("文件夹创建失败");
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    image-20220705210253059 image-20220705210307846
  • 相关阅读:
    超千万下载量的NPM包遭黑客攻击，美国监管机构紧急警告
    初学者入门的可视化超级色彩公式
    大三Web课程设计——悬崖上的波妞(4页) HTML+CSS（可以很好的应付老师的作业）
    Linux系统管理指南：用户权限、进程管理和网络配置精解
    基于若依(SpringBoot前后分离版-vue)的WebSocket消息推送实现
    官宣 | 效率源文档修复神器正式出道：超高性价比工具，破损文档1秒修复
    猿创征文｜在第一轮复习中，考研路上的成长历程
    JVM GC与频繁GC
    OpenCore-Legacy-Patcher 0.5.1正式版
    导出oracle远程数据库到本地
  • 原文地址：https://blog.csdn.net/sk_girl/article/details/125628213