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

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

智能推荐

艾美捷Epigentek DNA样品的超声能量处理方案-程序员宅基地

文章浏览阅读15次。空化气泡的大小和相应的空化能量可以通过调整完全标度的振幅水平来操纵和数字控制。通过强调超声技术中的更高通量处理和防止样品污染，Epigentek EpiSonic超声仪可以轻松集成到现有的实验室工作流程中，并且特别适合与表观遗传学和下一代应用的兼容性。Epigentek的EpiSonic已成为一种有效的剪切设备，用于在染色质免疫沉淀技术中制备染色质样品，以及用于下一代测序平台的DNA文库制备。该装置的经济性及其多重样品的能力使其成为每个实验室拥有的经济高效的工具，而不仅仅是核心设施。

11、合宙Air模块Luat开发：通过http协议获取天气信息_合宙获取天气-程序员宅基地

文章浏览阅读4.2k次，点赞3次，收藏14次。目录点击这里查看所有博文本系列博客，理论上适用于合宙的Air202、Air268、Air720x、Air720S以及最近发布的Air720U（我还没拿到样机，应该也能支持）。先不管支不支持，如果你用的是合宙的模块，那都不妨一试，也许会有意外收获。我使用的是Air720SL模块，如果在其他模块上不能用，那就是底层core固件暂时还没有支持，这里的代码是没有问题的。例程仅供参考！..._合宙获取天气

EasyMesh和802.11s对比-程序员宅基地

文章浏览阅读7.7k次，点赞2次，收藏41次。1 关于meshMesh的意思是网状物，以前读书的时候，在自动化领域有传感器自组网，zigbee、蓝牙等无线方式实现各个网络节点消息通信，通过各种算法，保证整个网络中所有节点信息能经过多跳最终传递到目的地，用于数据采集。十多年过去了，在无线路由器领域又把这个mesh概念翻炒了一下，各大品牌都推出了mesh路由器，大多数是3个为一组，实现在面积较大的住宅里，增强wifi覆盖范围，智能在多热点之间切换，提升上网体验。因为节点基本上在3个以内，所以mesh的算法不必太复杂，组网形式比较简单。各厂家都自定义了组_802.11s

线程的几种状态_线程状态-程序员宅基地

文章浏览阅读5.2k次，点赞8次，收藏21次。线程的几种状态_线程状态

stack的常见用法详解_stack函数用法-程序员宅基地

文章浏览阅读4.2w次，点赞124次，收藏688次。stack翻译为栈，是STL中实现的一个后进先出的容器。要使用 stack，应先添加头文件include<stack>，并在头文件下面加上“ using namespacestd;"1. stack的定义其定义的写法和其他STL容器相同, typename可以任意基本数据类型或容器：stack<typename> name;2. stack容器内元素的访问..._stack函数用法

2018.11.16javascript课上随笔（DOM）-程序员宅基地

文章浏览阅读71次。<li> <a href = "“#”>-</a></li><li>子节点：文本节点（回车），元素节点，文本节点。不同节点树：　　节点（各种类型节点）childNodes:返回子节点的所有子节点的集合，包含任何类型、元素节点（元素类型节点）：child。node.getAttribute(at...

随便推点

layui.extend的一点知识第三方模块base 路径_layui extend-程序员宅基地

文章浏览阅读3.4k次。//config的设置是全局的layui.config({ base: '/res/js/' //假设这是你存放拓展模块的根目录}).extend({ //设定模块别名 mymod: 'mymod' //如果 mymod.js 是在根目录，也可以不用设定别名 ,mod1: 'admin/mod1' //相对于上述 base 目录的子目录}); //你也可以忽略 base 设定的根目录，直接在 extend 指定路径（主要：该功能为 layui 2.2.0 新增）layui.exten_layui extend

5G云计算：5G网络的分层思想_5g分层结构-程序员宅基地

文章浏览阅读3.2k次，点赞6次，收藏13次。分层思想分层思想分层思想-1分层思想-2分层思想-2OSI七层参考模型物理层和数据链路层物理层数据链路层网络层传输层会话层表示层应用层OSI七层模型的分层结构TCP/IP协议族的组成数据封装过程数据解封装过程PDU设备与层的对应关系各层通信分层思想分层思想-1在现实生活种，我们在喝牛奶时，未必了解他的生产过程，我们所接触的或许只是从超时购买牛奶。分层思想-2平时我们在网络时也未必知道数据的传输过程我们的所考虑的就是可以传就可以，不用管他时怎么传输的分层思想-2将复杂的流程分解为几个功能_5g分层结构