java基础

已于 2022-11-30 18:27:38 修改
阅读量877 收藏 5
点赞数
CC 4.0 BY-SA版权
分类专栏： java 文章标签： java
于 2022-11-15 18:23:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/TheFoolman/article/details/127861122

基础语法

八进制

每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比较器的支持

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

常见算法

选择排序
java 打印机设置参数设置_Java 打印PDF文档 - 指定打印机、自定义纸张大小、设置打印参数、显示打印对话框等...
weixin_34336068的博客
02-13 1884
这篇文章介绍如何在Java应用程序中打印PDF文档以及进行一些打印设置，包括指定打印机、自定义纸张大小、设置打印参数、以及显示打印对话框等。导入jar文件本文所使用的PDF类库是Spire.PDF for Java, 如果你的项目是maven工程的话，在pom.xml文件中添加如下依赖，即可导入Spire.PDF for Java库jar文件。com.e-icebluee-icebluehttp:...
实验一 Java编程基础
零琴的Hope
10-12 969
实验一 Java编程基础
Educoder-Java继承和多态之方法重载(1,2)
qq_39123467的博客
12-13 700
随便看看
2024年头歌实践-Java继承与多态，3年内被辞退5次，35岁程序员该何去何从
最新发布
2401_84584831的博客
05-07 838
由于篇幅原因，就不多做展示了本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取。
练习-Java继承和多态之方法重载
aiains的博客
07-04 4833
第1关：练习-Java继承和多态之方法重载 任务描述 编程要求 测试说明 任务描述 本关任务：定义名为 print 的静态方法，携带一个参数，无论该参数是 int 型、double 型还是字符串型，都可以将该参数进行打印。 编程要求 仔细阅读右侧编辑区内给出的代码框架及注释，按照提示编写程序代码。 测试说明 平台将使用测试集运行你编写的程序代码，若全部的运行结果正确，则通关。 可在右侧“测试结果”区查看具体的测试集详情。 开始你的任务吧，祝你成功！ /** * 任务：定义名为 pri
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
《Java基础案例教程（第2版）》课后习题答案1
08-08
【Java基础知识点】 1. **Java的起源与特性** - Java是由SUN Microsystems公司（后被Oracle收购）开发的一种面向对象的编程语言。 - Java有三个主要版本：Java Standard Edition (JavaSE)，用于桌面应用；Java ...
《Java基础入门》课后习题及答案
03-23
《Java基础入门》课后习题及答案
Java基础课程
06-23
Java基础课程PPT资源；知识点：自定义动画、选择器高级应用、响应式网站开发、行业命名规范、域名注册-搭建个人网站 让学员熟练掌握css、js、JQuery等技术，可做到独立编写PC+移动端网站页面。并且能够独立开发web...
Java 基础入门（传智播客出品）.pdf
03-01
Java 基础入门，适合初学入门java的同学
如何在静态方法中使用泛型
m0_46639782的博客
08-03 4757
在Java中，静态方法不能直接使用类的泛型参数（Type Parameters），因为泛型是与类实例相关的，而静态方法不依赖于类的实例。但是，我们可以在静态方法上使用自己的泛型参数，使得该静态方法可以使用泛型。要在静态方法中使用泛型，可以在方法上声明自己的泛型参数，与类的泛型参数无关。这样，该静态方法可以独立地使用自己的泛型类型。请注意，静态方法中的泛型参数在调用时会自动推断类型，所以可以在调用时省略类型参数。的实例，使用类的泛型参数。，使用静态方法的泛型参数。上使用了自己的泛型参数。
练习-Java类和对象之可变参数
千浔的博客
03-31 1461
平台将使用测试集运行你编写的程序代码，若全部的运行结果正确，则通关。可在右侧“测试结果”区查看具体的测试集详情。本关任务：定义一个名为 add 的静态方法，返回值为 int，参数数量可变，且为 int，将这些参数相加后返回。仔细阅读右侧编辑区内给出的代码框架及注释，按照提示编写程序代码。开始你的任务吧，祝你成功！
第六天学习
m0_58458581的博客
09-17 126
public class demo3 { public static void main(String[] args) { //整数拓展： 进制 二进制0b 十进制 八进制0 十六进制 int i=10; int i1=010; int i3=0x10; System.out.println(i); System.out.println(i1); System.out.print.
Java实验一 Java编程基础
weixin_45984250的博客
11-16 1181
实验目的： 在集成开发环境下，用Java语言的基本语法来进行简单Java程序的编译和执行，加深对集成开发环境的运用以及Java语言的基本语法的理解。 实验目标： (1)能够运用集成开发工具来完成简单Java程序的编译和执行； (2)能根据实际问题运用Java语言的基本语法来进行Java程序的编写。 实验内容： 1.在一个源文件中编写4个类Hello、A、B和C，主方法包含在类Hello中，类A、B、C中各包含一个静态和非静态方法，在类Hello的主方法中分别调用类A、B、C中的方法。 2.在类中定义一个静态
Java基础知识(下)
luoyingbiao的博客
08-01 777
Java基础知识(下) 1、循环         1、什么时候使用                如果我们发现有很多重复内容的时候就要使用循环         2、好处                让我们的代码看起来更简洁了           3、循环的组成(理解)                1 初始化条件：一般定义的是一个初始变量
Java基础题(五)
Mikasa的博客
04-10 4810
MAKASA刷题打卡day05 刷题打卡day05 好累鸭! 坚持! 冲鸭! 我最棒!！ 1.javac将源程序编译成.class字节码文件；java将字节码转为机器码，.exe程序 2. package语句必须作为源文件的第一条非注释性语句，一个源文件只能指定一个包，只能包含一条package语句 3. 在java中，无论在何处调用，使用静态属性必须以类名做前缀。(错) 解析： 1如果是本类使...
java阶段测试A卷含答案
qq_45410668的博客
08-23 3万+
java阶段测试A卷 一、选择题（每题1分，共100题，共100分） 下列哪一种叙述是正确的（ D） A.abstract修饰符可修饰字段、方法和类。（abstract不可以修饰字段） B.抽象方法的body部分必须用一对大括号{ }包住（无body部分） C.声明抽象方法，大括号可有可无 D.声明抽象方法不可写出大括号 下列说法中，正确的是：( A) A.类是属性和方法的集合体 B.数组...
java中数组遍历的三种方式
热门推荐
胡毛毛的博客
11-08 9万+
1.for循环遍历 通常遍历数组都是使用for循环来实现。遍历一维数组很简单，遍历二维数组需要使用双层for循环，通过数组的length属性可获得数组的长度。 2.Arrays工具类中toString静态方法遍历 利用Arrays工具类中的toString静态方法可以将一维数组转化为字符串形式并输出。 3.foreach语句遍历 java5之后，Java提供了一种更简洁的循环：foreach循环，这种循环遍历数组和集合更加简洁。使用foreach循环遍历数组时，无须获得数组和集合长度，无须根据索引来访问数组
Java测试题（含答案和部分解析）
大土的博客
12-10 7万+
一.单项选择题1.给出如下代码:class Test{ 　　private int m; 　　public static void fun() { 　　　　// some code... 　　} }如何使成员变量m 被函数fun()直接访问（C）A、将private int m 改为protected int m B、将private int m 改为 public int m C、将priva
Java基础教程精讲
根据这个标题和标签，我们可以推断出这可能是关于Java基础、进阶知识、实际应用等方面的教程资源。 Java教程通常会包含以下几方面的知识点： 1. Java基础概念 - Java语言的历史和特点。 - Java的开发环境搭建，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值