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

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

智能推荐

class和struct的区别-程序员宅基地

文章浏览阅读101次。4.class可以有⽆参的构造函数，struct不可以，必须是有参的构造函数，⽽且在有参的构造函数必须初始。2.Struct适⽤于作为经常使⽤的⼀些数据组合成的新类型，表示诸如点、矩形等主要⽤来存储数据的轻量。1.Class⽐较适合⼤的和复杂的数据，表现抽象和多级别的对象层次时。2.class允许继承、被继承，struct不允许，只能继承接⼝。3.Struct有性能优势，Class有⾯向对象的扩展优势。3.class可以初始化变量，struct不可以。1.class是引⽤类型，struct是值类型。

android使用json后闪退,应用闪退问题：从json信息的解析开始就会闪退-程序员宅基地

文章浏览阅读586次。想实现的功能是点击顶部按钮之后按关键字进行搜索，已经可以从服务器收到反馈的json信息，但从json信息的解析开始就会闪退，加载listview也不知道行不行public abstract class loadlistview{public ListView plv;public String js;public int listlength;public int listvisit;public..._rton转json为什么会闪退

如何使用wordnet词典，得到英文句子的同义句_get_synonyms wordnet-程序员宅基地

文章浏览阅读219次。如何使用wordnet词典，得到英文句子的同义句_get_synonyms wordnet

系统项目报表导出功能开发_积木报表多线程-程序员宅基地

文章浏览阅读521次。系统项目报表导出导出任务队列表 + 定时扫描 + 多线程_积木报表多线程

ajax 如何从服务器上获取数据？_ajax 获取http数据-程序员宅基地

文章浏览阅读1.1k次，点赞9次，收藏9次。使用AJAX技术的好处之一是它能够提供更好的用户体验，因为它允许在不重新加载整个页面的情况下更新网页的某一部分。另外，AJAX还使得开发人员能够创建更复杂、更动态的Web应用程序，因为它们可以在后台与服务器进行通信，而不需要打断用户的浏览体验。在Web开发中，AJAX（Asynchronous JavaScript and XML）是一种常用的技术，用于在不重新加载整个页面的情况下，从服务器获取数据并更新网页的某一部分。使用AJAX，你可以创建异步请求，从而提供更快的响应和更好的用户体验。_ajax 获取http数据

Linux图形终端与字符终端-程序员宅基地

文章浏览阅读2.8k次。登录退出、修改密码、关机重启_字符终端

随便推点

Python与Arduino绘制超声波雷达扫描_超声波扫描建模 python库-程序员宅基地

文章浏览阅读3.8k次，点赞3次，收藏51次。前段时间看到一位发烧友制作的超声波雷达扫描神器，用到了Arduino和Processing，可惜啊，我不会Processing更看不懂人家的程序，咋办呢？嘿嘿，所以我就换了个思路解决，因为我会一点Python啊，那就动手吧！在做这个案例之前先要搞明白一个问题：怎么将Arduino通过超声波检测到的距离反馈到Python端？这个嘛，我首先想到了串行通信接口。没错！就是串口。只要Arduino将数据发送给COM口，然后Python能从COM口读取到这个数据就可以啦！我先写了一个测试程序试了一下，OK！搞定_超声波扫描建模 python库

凯撒加密方法介绍及实例说明-程序员宅基地

文章浏览阅读4.2k次。端—端加密指信息由发送端自动加密，并且由TCP/IP进行数据包封装，然后作为不可阅读和不可识别的数据穿过互联网，当这些信息到达目的地，将被自动重组、解密，而成为可读的数据。不可逆加密算法的特征是加密过程中不需要使用密钥，输入明文后由系统直接经过加密算法处理成密文，这种加密后的数据是无法被解密的，只有重新输入明文，并再次经过同样不可逆的加密算法处理，得到相同的加密密文并被系统重新识别后，才能真正解密。2．使用时，加密者查找明文字母表中需要加密的消息中的每一个字母所在位置，并且写下密文字母表中对应的字母。_凯撒加密

工控协议--cip--协议解析基本记录_cip协议embedded_service_error-程序员宅基地

文章浏览阅读5.7k次。CIP报文解析常用到的几个字段：普通类型服务类型:[0x00], CIP对象:[0x02 Message Router], ioi segments:[XX]PCCC（带cmd和func）服务类型:[0x00], CIP对象:[0x02 Message Router], cmd:[0x101], fnc:[0x101]..._cip协议embedded_service_error

如何在vs2019及以后版本(如vs2022)上添加添加ActiveX控件中的MFC类_vs添加mfc库-程序员宅基地

文章浏览阅读2.4k次，点赞9次，收藏13次。有时候我们在MFC项目开发过程中，需要用到一些微软已经提供的功能，如VC++使用EXCEL功能，这时候我们就能直接通过VS2019到如EXCEL.EXE方式，生成对应的OLE头文件，然后直接使用功能，那么，我们上篇文章中介绍了vs2017及以前的版本如何来添加。但由于微软某些方面考虑，这种方式已被放弃。从上图中可以看出，这一功能，在从vs2017版本15.9开始，后续版本已经删除了此功能。那么我们如果仍需要此功能，我们如何在新版本中添加呢。_vs添加mfc库

frame_size (1536) was not respected for a non-last frame_frame_size (1024) was not respected for a non-last-程序员宅基地

文章浏览阅读785次。用ac3编码，执行编码函数时报错入如下：[ac3 @ 0x7fed7800f200] frame_size (1536) was not respected for anon-last frame (avcodec_encode_audio2)用ac3编码时每次送入编码器的音频采样数应该是1536个采样，不然就会报上述错误。这个数字并非刻意固定，而是跟ac3内部的编码算法原理相关。全网找不到，国内音视频之路还有很长的路，音视频人一起加油吧～......_frame_size (1024) was not respected for a non-last frame

Android移动应用开发入门_在安卓移动应用开发中要在活动类文件中声迷你一个复选框变量-程序员宅基地

文章浏览阅读230次，点赞2次，收藏2次。创建Android应用程序一个项目里面可以有很多模块，而每一个模块就对应了一个应用程序。项目结构介绍_在安卓移动应用开发中要在活动类文件中声迷你一个复选框变量