java基础_本关任务:定义名为 print 的静态方法,携带一个参数,无论该参数是 int 型、double-程序员宅基地

技术标签： java

基础语法

八进制

每3位二进制作为一个单元，最小数是0，最大数是7，0-7有8个数字

十六进制

每4位二进制作为一个单元，最小数是0，最大数是15
0-15有16个数字，依次用：0-9 A B C D E F

基本数据类型

在这里插入图片描述

类型转换

自动类型转换

类型范围小的变量，可以直接赋值给类型范围大的变量

小范围的类型会自动转换成大范围的类型进行运算
最终类型由表达式的最高类型决定
byte、short、char是直接转换成int类型参与运算

强制类型转换

强行将类型范围大的变量、数据赋值给类型范围小的变量

数据类型变量 = （数据类型）变量 / 数据

运算符

运算符种类：+ - * / %
如果两个整数做除法，结果一定是整数，因为最高类型是整数
System.out.println(a*1.0/b);//最高位运算相乘再除可以得小数

自增、自减

在这里插入图片描述

++、-- 。对当前变量值+1、-1
自增、自减运算符在变量前后有区别吗?
如果单独使用放前后是没有区别的
非单独使用：在变量前，先进行变量自增/自减，再使用变量
非单独使用：在变量后，先使用变量，再进行变量自增/自减

案例

赋值运算符

在这里插入图片描述

作用

基本作用是赋值；
+= 可以实现数据得累加，把别人的数据加给自己

逻辑运算符

把多个条件的布尔结果放一起运算，最终返回一个布尔结果

短逻辑运算符
在这里插入图片描述

逻辑运算符特点

三元运算符

格式：条件表达式？值1 : 值2;

运算符优先级

在这里插入图片描述

API、键盘录入

API（Application Programming Interface）应用程序编程接口
键盘录入

1、导包 import java.util.Scanner
2、抄写代码得到扫描器对象（Scanner sc = new Scanner(System.in)）
3、抄写代码等待接受用户输入的数据：sc.nextInt() sc.next();

程序流程控制

分支结构

if分支

switch分支

if、switch分支各自适合做什么业务场景
在这里插入图片描述

switch分支使用注意事项
在这里插入图片描述
switch的穿透性

如果代码执行到没有写break的case块，执行完后将直接进入下一个case块执行代码（而且不会进行任何匹配），直到遇到break才跳出分支

解决什么问题？

存在多个case分支的功能代码是一样时，可以用穿透性把流程集中到同一处处理，这样可以简化代码

循环结构

for循环

for循环格式和执行流程是怎样的

while循环

while循环的格式，执行流程

什么时候用for循环、while循环

for和while使用总结

do-while循环

先执行再判断循环条件

三种循环的区别

死循环

一直执行下去的方法，没有干预不会停止

嵌套循环

循环中又包含循环

特点

外部循环每循环一次，内部循环全部执行完一次

跳转关键字：break、continue

break：跳出并结束当前所在循环的执行；
continue：用于跳出当前循环的当此执行，进入下一次循环；

随机数：Random类

作用：用于在程序中获取随机数的技术

使用步骤

1、导包 import java.uitl.Random;

2、写一行代码代表获取到随机数对象 Random r = new Random();

3、调用随机数的功能获取0-9的随机数 int number = r.nextInt(10);

注意：
nextInt(n)功能只生成0 - n-1之间的随机数，不包含n（也可以直接定义范围r.nextInt(3 , 10)）

Random生成区间随机数的技巧：减加法

猜数字游戏实现

1、生成随机数
2、使用死循环让用户直到猜到正确的
3、判断猜测数据与随机数大小（使用break跳出死循环）

数组

数组就是用来存储一批同种类型数据的内存区域（可以理解为容器）

数组定义方式

静态初始化数组

动态初始化组

定义数组的时候只确定元素的类型和数组的长度，之后再存入具体数据

写法：

元素默认值规则

两种初始化使用场景总结、注意事项说明

遍历

遍历：就是一个一个数据的访问

数组遍历、元素求和

快速遍历快捷方式：
变量名.fori +enter

数组案例

猜数字游戏

import java.util.Random;
import java.util.Scanner;

public class Test01 {
    
    public static void main(String[] args){
    
        //1、定义一个动态初始化的数组存储5个随机的1-20之间的数据
        int[] arr = new int[5];
        //2、动态生成5个1-20之间随机数并存入数组
        Random ra = new Random();
        for (int i = 0; i < arr.length; i++) {
    
            arr[i] = ra.nextInt(20) + 1;
        }
        Scanner sc = new Scanner(System.in);

        //3、使用一个死循环让用户进行猜测
        OUT:
        while(true){
    
            System.out.println("请输入一个1-20之间的整数进行猜测");
            int guessDate = sc.nextInt();

            //4、遍历数组中的每个数据，看是否存数据与猜测的数据相同，相同代表猜中了，给出提示
            for (int i = 0; i <arr.length; i++) {
    
                if(guessDate == arr[i]){
    
                    System.out.println("猜中了");
                    break OUT;
                }
            }
            System.out.println("没猜中，请继续");
        }
        //5、输出数组的全部元素，让用户看到自己确实是中了某个数据
        for (int i = 0; i < arr.length; i++) {
    
            System.out.println(arr[i] +"\t");
        }
    }
}

随机排名

import java.util.Random;
import java.util.Scanner;

public class Test2 {
    
    public static void main(String[] args) {
    
        //1、初始化一组数组，存储5个工号
        int[] codes = new int[5];
        //2、定义一个循环，循环5次，依次录入一个工号存入对应的位置
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < codes.length; i++) {
    
            //录入工号
            System.out.println("请输入第" + (i + 1) + "个员工的工号： ");
            int code = sc.nextInt();
            //存入到数组中去
            codes[i] = code;
        }
        //3、遍历数组中的每个元素，然后随机一个索引出来，让该元素与随机索引位置处的元素值进行交换
        Random ra = new Random();
        for (int i = 0; i < codes.length; i++) {
    
            //当前遍历的元素值：cedes[i]
            //随机一个索引位置出来：codes[index]
            int index = ra.nextInt(codes.length);

            //定义一个临时变量存储index位置处的值
            int temp = codes[index];
            codes[index] = codes[i];
            codes[i] = temp;
        }
        //4、遍历数组元素输出就是随机排名的结果
        for (int i = 0; i < codes.length; i++) {
    
            System.out.print(codes[i] + "\t");
        }
    }
}

冒泡排序

public class Test3 {
    
    public static void main(String[] args) {
    
        //1、定义一个数组，存储一些数据
        int[] arr = {
    3,412,42,44,11};
        //2、定义一个循环控制比较的轮数
        for (int i = 0; i < arr.length - 1; i++) {
    
            //3、定义一个循环控制每轮比较的次数，占位
            for (int j = 0; j < arr.length - i -1; j++) {
    
                //判断j当前位置的元素值，是否大于下一个位置，若大，则交换
                if(arr[j] > arr[j + 1]){
    
                    int temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        //遍历数组输出内容
        for (int i = 0; i < arr.length; i++) {
    
            System.out.print(arr[i] + "\t");
        }
    }
}

java内存分配介绍

两个数组变量指向同一个数组对象

数组常见问题

Debug工具

方法

方法是一种语法结构，它可以把一段代码封装成一个功能，以方便重复调用

方法定义格式

方法格式的注意点

方法的其他写法

方法不需要返回结果，则申明返回值类型为void；方法不需要参数，则形参列表可以不写
方法没有声明返回值类型，内部不能使用return返回数据

方法常见问题

方法案例

求和

public class Test1 {
    
    //使用方法计算1-n得值并返回
    public static void main(String[] args) {
    
        System.out.println("1-100的和是 " + sum(100));
    }
    public static int sum(int n){
    
        int sum = 0;
        for (int i = 0; i <= n; i++) {
    
            sum += i;
        }
        return sum;
    }
}

定义方法重点关注的两点

方法是否需要申明返回值类型

方法是否需要定义形参列表

数组求最值改方法实现

public class Test2 {
    
    public static void main(String[] args) {
    
        //需求：通过方法求数组中的最大值
        int[] ages = {
    21,32,53,13,24};
        System.out.println("年龄最大的是+ " + maxArrayDate(ages));

    }

    //定义返回值类型，传入参数
    public static int maxArrayDate(int[] arr) {
    
        //找出最大值返回
        int max = arr[0];

        for (int i = 0; i < arr.length; i++) {
    
            if (max < arr[i]) {
    
                max = arr[i];
            }
        }
        return max;
    }
}

方法的内存原理

方法的调用流程–内存图解

方法没有被调用的时候，在方法区中的字节码文件中存放
方法被调用时，需要进入到栈内存中运行

方法的参数传递机制

基本类型的参数传递

java的参数传递机制：值传递

引用类型的参数传递

方法的参数传递案例

打印整型数组内容

public class Test3 {
    
    public static void main(String[] args) {
    
        int[] numbers = {
    13,13,442,52};

        printArray(numbers);
    }

    public static void printArray(int[] arr){
    
        System.out.print("[");
        if (arr != null && arr.length > 0 ){
    
            for (int i = 0; i < arr.length; i++) {
    
                System.out.print(i == arr.length-1 ? arr[i] : arr[i] + ",");
            }
        }
        System.out.println("]");
    }
}

从数组中查询指定元素的索引

public class Test4 {
    
    public static void main(String[] args) {
    
        //需求：从整型数组中查询某个数据的索引返回，不存在则返回-1
        int[] arr = {
    32,43,52,65};
        int index = index(arr, 329);
        System.out.println(index);

    }
    public static int index(int[] code, int date){
    
        for (int i = 0; i < code.length; i++) {
    
            if(date == code[i]){
    
                return i;
            }
        }
        return -1;
    }
}

比较两个数组是否一样

public class Test5 {
    
    public static void main(String[] args) {
    
        int[] arr1 = {
    32, 43, 62, 56};
        int[] arr2 = {
    32, 543, 24, 44};
        boolean b = compare(arr1, arr2);
        System.out.println(b);
    }

    public static boolean compare(int[] arr1, int[] arr2) {
    
        if (arr1.length == arr2.length) {
    
            for (int i = 0; i < arr1.length; i++) {
    
                if (arr1[i] != arr2[i]) {
    
                    return false;
                }
            }
            return true;
        }
        return false;
    }
}

方法重载、关键字

方法重载：同一个类中，出现多个方法名称相同，但是形参列表不同的，那这些方法就是重载方法

好处：相似功能业务场景：可读性好，方法名称相同提示是同一类型的功能，通过形参不同实现功能差异化的选择，这是一种专业的代码设计

方法重载的识别技巧

return 关键字
立即跳出并结束当前方法的执行；return单独使用可以放在任何方法中。

编程案例

案例一：买飞机票

import java.util.Scanner;

public class Test1 {
    
    public static void main(String[] args) {
    
        //1、让用户输入机票原价、月份、头等舱或经济舱
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入机票原价 ");
        double money = scanner.nextDouble();

        System.out.println("请输入月份 ");
        int month = scanner.nextInt();

        System.out.println("请选择经济舱或头等舱 ");
        String type = scanner.next();
        System.out.println("机票优惠后的价格为： " + money(money,month,type));
    }

    //2、定义方法接收信息，统计优惠后的价格返回
    public static double money(double money, int month, String type) {
    
        if (month >= 5 && month <= 10) {
    
            switch (type) {
    
                case "头等舱":
                    money *= 0.9;
                    break;
                case "经济舱":
                    money *= 0.85;
                    break;
                default:
                    System.out.println("您输入的舱位有误");
                    money = -1;
            }
        } else if (month == 11 || month == 12 && month >= 1 && month <= 4) {
    
            switch (type) {
    
                case "头等舱":
                    money *= 0.7;
                    break;
                case "经济舱":
                    money *= 0.65;
                    break;
                default:
                    System.out.println("您输入的舱位有误");
                    money = -1;
            }
        }else {
    
            System.out.println("传入的月份有误");
            money = -1;
        }
        return money;
    }
}

案例二：找素数

public class Test2 {
    
    public static void main(String[] args) {
    
        //1、定义一个循环找到101-200之间所有元素
        System.out.print("101到200之间的素数为 ");
        for (int i = 101; i < 200; i++) {
    
            //信号位：标记
            boolean falg = true; //一开始认为当前数据为素数

            //2、判断当前遍历的这个数是否为素数
            for (int j = 2; j < 100; j++) {
    
                if (i % j == 0 ){
    
                    falg = false;
                    break;
                }
            }
            //3、根据判定的结果选择是否输出这个数据，是素数则输出
            if (falg){
    
                System.out.print( i + "\t");
            }
        }

    }
}

输出结果

开发验证码

import java.util.Random;

public class Test4 {
    
    public static void main(String[] args) {
    
        String code = code(4);
        System.out.println("随机验证码是 " + code);

    }

    //定义方法获取随机数
    public static String code(int n){
    
        //先用for循环获取，定义createCode
        String createCode = "";
        //获取随机数
        Random ra = new Random();
        for (int i = 0; i < n; i++) {
    
            //定义随机数0、1、2分别代表大写字母、小写字母、数字
            int i1 = ra.nextInt(3);

            switch (i1){
    
                case 0:
                    //大写字符A 65 - Z 65 + 25
                    char char1 = (char) (ra.nextInt(26) + 65);
                    createCode += char1;
                    break;
                case 1:
                    //小写字符A 97 - Z 97 + 25
                    char char2 = (char) (ra.nextInt(26) + 97);
                    createCode += char2;
                    break;
                case 2:
                    //数字0 - 9
                    int char3 = ra.nextInt(10);
                    createCode += char3;
                    break;
            }
        }
        return createCode;
    }
}

运行结果

数组元素赋值

public class Test5 {
    
    public static void main(String[] args) {
    
        int[] arr1 = {
    13,54,243,32};
        int[] arr2 = new int[arr1.length];

        copy(arr1,arr2);

        printArray(arr1);
        printArray(arr2);
    }
    //打印方法
    public static void  printArray(int[] a){
    
        System.out.print("[");
        for (int i = 0; i < a.length; i++) {
    
            int i1 = a[i];
            System.out.print(i == a.length -1 ? i1 : (i1 + "," ));
        }
        System.out.println("]");
    }
    //赋值方法
    public static void copy(int[] a1,int[] a2){
    
        for (int i = 0; i < a1.length; i++) {
    
            a2[i] = a1[i];
        }
    }
}

运行结果

评委打分案例

import java.util.Scanner;

public class Test3 {
    
    public static void main(String[] args) {
    
        //1、定义初始化数组，存入评委打分分数
        int[] scores = new int[6];
        //键盘录入
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < scores.length; i++) {
    
            System.out.println("请第" + (i + 1) +"评委打分");
            int score = scanner.nextInt();
            //将分数存入相应数组位置
            scores[i] = score;
        }
        //通过循环找出最大值、最小值、总值来得到去求最值后的平均分
        //先定义最值、平均值变量接收数据
        int max = scores[0];
        int min = scores[0];
        int sum = 0;
        for (int i = 0; i < scores.length; i++) {
    
            if (scores[i] > max){
    
                max = scores[i];
            }
            if (scores[i] < min){
    
                min = scores[i];
            }
            sum += scores[i];
        }
        System.out.println("最大值是 " + max + "最小值是 " + min + "平均值" + (sum - max -min)/ (scores.length - 2));
    }
}

运行结果

数字加密

import java.util.Scanner;

public class Test4 {
    
    public static void main(String[] args) {
    
        //输入需要加密的个数
        System.out.println("需要加密多少位");
        Scanner scanner = new Scanner(System.in);
        int length = scanner.nextInt();

        //用数组存储键盘录入
        int[] scores = new int[length];



        for (int i1 = 0; i1 < scores.length; i1++) {
    
            System.out.println("请输入第 " + (i1 + 1) + "位数字");
            int number = scanner.nextInt();
            //将录入数据存入数组
            scores[i1] = number;
        }
        //打印录入数据
        printArray(scores);
        //核心加密

        for (int i = 0; i < scores.length; i++) {
    
            scores[i] = (scores[i] + 5) % 10;
        }

        //定义i和j进行双向递减直达碰面完成数据互换
        for (int i = 0 , j = scores.length -1; i < j; i++ , j--) {
    
            int temp = scores[j];
            scores[j] = scores[i];
            scores[i] = temp;
        }
        printArray(scores);
    }
    //打印方法
    public static void printArray(int[] arr){
    
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
    
            System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + "," );
        }
        System.out.println("]");
    }
}

运行结果

面向对象

设计对象、注意事项

内存机制

垃圾回收：当堆内存当中的对象没有被任何变量引用时，就会被判定为内存中的垃圾

构造器

this关键字

封装

面向对象三大特征：封装、多态、继承
封装：告诉我们如何正确设计对象的属性和方法
封装的原则：对象代表什么，就得封装对应的数据，并提供数据对应的行为

JavaBean、案例

成员变量、局部变量区别

作用域成员变量随着对象出现局部变量在所归属的大括号中起作用

面向对象综合案例

Movie类

public class Movie {
    
    private String name;
    private double score;
    private String actor;

    public Movie(String name, double score, String actor) {
    
        this.name = name;
        this.score = score;
        this.actor = actor;
    }

    public Movie() {
    
    }

    public String getName() {
    
        return name;
    }

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

    public double getScore() {
    
        return score;
    }

    public void setScore(double score) {
    
        this.score = score;
    }

    public String getActor() {
    
        return actor;
    }

    public void setActor(String actor) {
    
        this.actor = actor;
    }
}

案例

public class SystemDemo {
    
    public static void main(String[] args) {
    
        Movie[] movies = new Movie[3];
        movies[0] = new Movie("流浪地球",9.7,"吴京");
        movies[1] = new Movie("我和我的父辈",9.8,"吴京");
        movies[2] = new Movie("战狼",9.7,"吴京");

        //通过for循环将数组中存储的访问并打印
        for (int i = 0; i < movies.length; i++) {
    
            //将访问到的对象赋值并打印
            Movie movie = movies[i];

            System.out.println("片名" + movie.getName());
            System.out.println("评分" + movie.getScore());
            System.out.println("演员" + movie.getActor());
            System.out.println("----------");
        }
    }

}

输出结果

String、ArrayList

String的概述、对象创建的原理

创建字符串的两种方式

String常用API

String案例

验证码

import java.util.Random;

public class Test1 {
    
    public static void main(String[] args) {
    
        //1、定义可能出现的字符信息
        String dates = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01233456789";
        //2、循环5次，每次生成一个随机索引，再拼接返回
        Random rs = new Random();
        String cores = "";
        for (int i = 0; i < 5; i++) {
    
            //随机一个索引
            int index = rs.nextInt(dates.length());
            // public char charAt(int index) 获取某个索引位置处的字符
            char c = dates.charAt(index);
            cores += c;
        }
        System.out.println(cores);
    }
}

运行结果

集合概述、ArrayList的使用

泛型概述

ArrayList集合常用方法

集合案例：遍历并删除元素

import java.util.ArrayList;

public class Test1 {
    
    public static void main(String[] args) {
    
        //创建integer泛型类的集合，添加数据
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(98);
        arrayList.add(77);
        arrayList.add(66);
        arrayList.add(89);
        arrayList.add(79);
        arrayList.add(50);
        arrayList.add(100);
        System.out.println(arrayList);
        //遍历集合，将分数低于80的移除
        //遍历方式一：删除后将i自减一位
//        for (int i = 0; i < arrayList.size(); i++) {
    
//            //获取集合中的分数
//            Integer integer = arrayList.get(i);
//            //判断分数是否低于80，低于则移除
//            if (integer < 80){
    
//                arrayList.remove(i);
//                i--;
//            }
//        }
        //遍历方式二：从集合最后一位开始遍历
        for (int i = arrayList.size() - 1; i >= 0; i--) {
    
            Integer integer = arrayList.get(i);
            //判断分数是否低于80，低于则移除
            if (integer < 80){
    
                arrayList.remove(i);
            }
        }
        System.out.println(arrayList);
    }
}

运行结果

集合案例：学生信息系统的数据搜索

学生类

public class Student {
    
    private String studyNumber;
    private String name;
    private int age;
    private String className;

    public Student() {
    
    }

    public Student(String studyNumber, String name, int age, String className) {
    
        this.studyNumber = studyNumber;
        this.name = name;
        this.age = age;
        this.className = className;
    }

    public String getStudyNumber() {
    
        return studyNumber;
    }

    public void setStudyNumber(String studyNumber) {
    
        this.studyNumber = studyNumber;
    }

    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;
    }

    public String getClassName() {
    
        return className;
    }

    public void setClassName(String className) {
    
        this.className = className;
    }
}

测试

import java.util.ArrayList;
import java.util.Scanner;

public class Test2 {
    
    public static void main(String[] args) {
    
        //1、定义学生类
        //2、创建集合存储学生对象，创建学生对象封装学生信息
        //把学生对象添加到集合中去
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("20221118", "天地一号", 12, "天府"));
        students.add(new Student("20221119", "天地二号", 13, "天府"));
        students.add(new Student("20221120", "天地三号", 14, "天府"));
        students.add(new Student("20221121", "天地四号", 15, "天府"));
        //3、遍历学生信息展示
        System.out.println("学生信息展示");
        for (int i = 0; i < students.size(); i++) {
    
            Student student = students.get(i);
            System.out.println(student.getStudyNumber() + "\t" + student.getName()
                    + "\t" + student.getAge() + "\t" + student.getClassName());
        }
        //4、定义方法完成按照学号的搜索
        Scanner scanner = new Scanner(System.in);


        while (true) {
    
            System.out.println("请输入学号查找 ");
            String s = scanner.next();
            //5、调用方法查询
            Student studentById = getStudentById(students, s);
            //6、判断studentById是否含有学生地址
            if (studentById == null) {
    
                System.out.println("查无此人请重新输入 ");
            } else {
    
                System.out.println("您查询的学生信息如下");
                System.out.println(studentById.getStudyNumber() + "\t" + studentById.getName()
                        + "\t" + studentById.getAge() + "\t" + studentById.getClassName());
                break;
            }
        }

    }



    /**
     * 根据学生的学号查询学生对象返回
     *
     * @param students    存储全部学生对象的集合
     * @param studyNumber 搜索的学生的学号
     * @return 学生对象 | null
     */
    public static Student getStudentById(ArrayList<Student> students, String studyNumber) {
    
        //1、遍历全部学生对象
        for (int i = 0; i < students.size(); i++) {
    
            Student student = students.get(i);
            //2、询问当前遍历的学生对象的学号，是否为我们要找的学号
            if (student.getStudyNumber().equals(studyNumber)) {
    
                //此学生对象即为要寻找的
                return student;
            }
        }
        return null;
    }
}

运行结果

Static静态关键字

修饰成员变量

内存机制

修饰成员方法

Static访问注意事项

应用知识-工具类

应用知识-代码块

案例-斗地主游戏

应用知识-单例模式

单例模式

饿汉单例设计模式

懒汉单例模式设计

继承

继承的设计规范、内存运行原理

继承的特点

成员变量成员方法访问特点

方法重写

子类构造器的特点

子类构造器访问父类无参构造器

this、super使用总结

语法

包

权限修饰符

final

常量

常量概述和基本作用

常量做信息标志和分类

枚举

枚举的概述

枚举的使用场景演示

抽象类

概述

抽象类案例

抽象类的特征、注意事项小结

抽象类的应用知识：模板方法模式

接口

接口概述、特点

接口的基本使用：被实现

接口与接口的关系：多继承

接口新增方法、注意事项

多态

多态的概述、形式

多态的优势

多态下引用数据类型的类型转换

多态综合案例

USB

/**
 USB接口 == 规范
 */
public interface USB {
    
    //接入、拔出
    void connect();

    void unconnect();

}

KeyBoard

/**
 实现类
 */
public class KeyBoard implements USB {
    
    private String name;

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

    public String getName() {
    
        return name;
    }

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

    public KeyBoard() {
    
    }

    @Override
    public void connect() {
    
        System.out.println(name + "成功连接了电脑");

    }

    @Override
    public void unconnect() {
    
        System.out.println(name + "成功退出了电脑");
    }
    /**
     独有功能
     */
    public void keyDown(){
    
        System.out.println(name + "敲击了：来了，老弟~~~");
    }
}

Mouse

/**
 实现类
 */
public class Mouse implements USB {
    
    private String name;

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

    public String getName() {
    
        return name;
    }

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

    public Mouse() {
    
    }

    @Override
    public void connect() {
    
        System.out.println(name + "成功连接了电脑");

    }

    @Override
    public void unconnect() {
    
        System.out.println(name + "成功退出了电脑");
    }
    /**
     独有功能
     */
    public void dbClick(){
    
        System.out.println(name + "双击");
    }
}

Computer

public class Computer {
    
    private String name;

    public Computer() {
    
    }

    public String getName() {
    
        return name;
    }

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

    public Computer(String name) {
    
        this.name = name;
    }
    public void start(){
    
        System.out.println(name + "电脑开机了");
    }
    /**
     * 提供安装USB设备的入口
     */
    public void USBInstall(USB usb){
    
        //多态：USB可能是KeyBoard或者Mouse
        usb.connect();
        //先判断再强转
        if (usb instanceof KeyBoard){
    
            ((KeyBoard) usb).keyDown();
        }else if (usb instanceof  Mouse){
    
            ((Mouse) usb).dbClick();
        }
        usb.unconnect();
    }
}

Test

public class Test {
    
    public static void main(String[] args) {
    
        //a.创建出电脑对象
        Computer c = new Computer("戴尔");
        c.start();

        //b.创建键盘对象、鼠标对象
        USB a = new KeyBoard("腹灵");
        c.USBInstall(a);

        USB b = new Mouse("雷蛇");
        c.USBInstall(b);

    }
}

代码实现

内部类

静态内部类

成员内部类

局部内部类

匿名内部类

匿名内部类常见使用形式

常用API

Object

Objects

StringBulider

Math

System

BigDecimal

日期与时间

Date

SimpleDateFormat

案例

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

public class SimpleDate {
    
    public static void main(String[] args) throws ParseException {
    
        //1、把字符串时间拿到程序中来
        String dateStr = "2021年08月06日 11:11:11";

        //2、把字符串时间解析为日期对象：形式必须与解析时间的形式完全一致，否则运行时解析报错
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date date = dateFormat.parse(dateStr);

        //3、往后走2天14小时49分06秒
        long time = date.getTime() + (2L * 24 * 60 * 60 + 14 * 60 * 60 + 49 * 60 + 6) * 1000;

        //4、格式化这个时间毫秒值就是结果
        System.out.println(dateFormat.format(time));
    }
}

运行结果

Calendar

JDK8新增日期类

Instant

DateTimeFormatter

Duration/Period

Duration 用于计算两个“时间”间隔

Period 用于计算两个“日期”间隔

ChronoUnit

包装类

正则表达式

概述

正则表达式的匹配规则

正则表达式的常见案例

正则表达式在方法中的应用

正则表达式爬取信息

Arrays类

概述

Arrays类对于Comparator比较器的支持

常见算法

选择排序

本文链接：https://blog.csdn.net/TheFoolman/article/details/127861122

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

JWT(Json Web Token)实现无状态登录_无状态token登录-程序员宅基地

文章浏览阅读685次。1.1.什么是有状态？有状态服务，即服务端需要记录每次会话的客户端信息，从而识别客户端身份，根据用户身份进行请求的处理，典型的设计如tomcat中的session。例如登录：用户登录后，我们把登录者的信息保存在服务端session中，并且给用户一个cookie值，记录对应的session。然后下次请求，用户携带cookie值来，我们就能识别到对应session，从而找到用户的信息。缺点是什么？服务端保存大量数据，增加服务端压力服务端保存用户状态，无法进行水平扩展客户端请求依赖服务.._无状态token登录

SDUT OJ逆置正整数-程序员宅基地

文章浏览阅读293次。SDUT OnlineJudge#include<iostream>using namespace std;int main(){int a,b,c,d;cin>>a;b=a%10;c=a/10%10;d=a/100%10;int key[3];key[0]=b;key[1]=c;key[2]=d;for(int i = 0;i<3;i++){ if(key[i]!=0) { cout<<key[i.

年终奖盲区_年终奖盲区表-程序员宅基地

文章浏览阅读2.2k次。年终奖采用的平均每月的收入来评定缴税级数的，速算扣除数也按照月份计算出来，但是最终减去的也是一个月的速算扣除数。为什么这么做呢，这样的收的税更多啊，年终也是一个月的收入，凭什么减去12*速算扣除数了？这个霸道（不要脸）的说法，我们只能合理避免的这些跨级的区域了，那具体是那些区域呢？可以参考下面的表格：年终奖一列标红的一对便是盲区的上下线，发放年终奖的数额一定一定要避免这个区域，不然公司多花了钱..._年终奖盲区表

matlab 提取struct结构体中某个字段所有变量的值_matlab读取struct类型数据中的值-程序员宅基地

文章浏览阅读7.5k次，点赞5次，收藏19次。matlab结构体struct字段变量值提取_matlab读取struct类型数据中的值

Android fragment的用法_android reader fragment-程序员宅基地

文章浏览阅读4.8k次。1，什么情况下使用fragment通常用来作为一个activity的用户界面的一部分例如, 一个新闻应用可以在屏幕左侧使用一个fragment来展示一个文章的列表,然后在屏幕右侧使用另一个fragment来展示一篇文章 – 2个fragment并排显示在相同的一个activity中,并且每一个fragment拥有它自己的一套生命周期回调方法,并且处理它们自己的用户输_android reader fragment

FFT of waveIn audio signals-程序员宅基地

文章浏览阅读2.8k次。FFT of waveIn audio signalsBy Aqiruse An article on using the Fast Fourier Transform on audio signals. IntroductionThe Fast Fourier Transform (FFT) allows users to view the spectrum content of _fft of wavein audio signals

随便推点

Awesome Mac：收集的非常全面好用的Mac应用程序、软件以及工具_awesomemac-程序员宅基地

文章浏览阅读5.9k次。https://jaywcjlove.github.io/awesome-mac/ 这个仓库主要是收集非常好用的Mac应用程序、软件以及工具，主要面向开发者和设计师。有这个想法是因为我最近发了一篇较为火爆的涨粉儿微信公众号文章《工具武装的前端开发工程师》，于是建了这么一个仓库，持续更新作为补充，搜集更多好用的软件工具。请Star、Pull Request或者使劲搓它 issu_awesomemac

java前端技术---jquery基础详解_简介java中jquery技术-程序员宅基地

文章浏览阅读616次。一.jquery简介 jQuery是一个快速的，简洁的javaScript库，使用户能更方便地处理HTML documents、events、实现动画效果，并且方便地为网站提供AJAX交互 jQuery 的功能概括1、html 的元素选取2、html的元素操作3、html dom遍历和修改4、js特效和动画效果5、css操作6、html事件操作7、ajax_简介java中jquery技术

Ant Design Table换滚动条的样式_ant design ::-webkit-scrollbar-corner-程序员宅基地

文章浏览阅读1.6w次，点赞5次，收藏19次。我修改的是表格的固定列滚动而产生的滚动条引用Table的组件的css文件中加入下面的样式：.ant-table-body{ &amp;::-webkit-scrollbar { height: 5px; } &amp;::-webkit-scrollbar-thumb { border-radius: 5px; -webkit-box..._ant design ::-webkit-scrollbar-corner

javaWeb毕设分享健身俱乐部会员管理系统【源码+论文】-程序员宅基地

文章浏览阅读269次。基于JSP的健身俱乐部会员管理系统项目分享:见文末!

论文开题报告怎么写？_开题报告研究难点-程序员宅基地

文章浏览阅读1.8k次，点赞2次，收藏15次。同学们，是不是又到了一年一度写开题报告的时候呀？是不是还在为不知道论文的开题报告怎么写而苦恼?Take it easy!我带着倾尽我所有开题报告写作经验总结出来的最强保姆级开题报告解说来啦，一定让你脱胎换骨，顺利拿下开题报告这个高塔，你确定还不赶快点赞收藏学起来吗？_开题报告研究难点

原生JS 与 VUE获取父级、子级、兄弟节点的方法及一些DOM对象的获取_获取子节点的路径 vue-程序员宅基地

文章浏览阅读6k次，点赞4次，收藏17次。原生先获取对象var a = document.getElementById("dom");vue先添加ref <div class="" ref="divBox">获取对象let a = this.$refs.divBox获取父、子、兄弟节点方法var b = a.childNodes; 获取a的全部子节点 var c = a.parentNode; 获取a的父节点var d = a.nextSbiling; 获取a的下一个兄弟节点 var e = a.previ_获取子节点的路径 vue