Java基础知识（一）

已于 2024-03-05 09:41:55 修改
阅读量858 收藏 20
点赞数 23
分类专栏： Java 文章标签： java
于 2024-02-07 18:01:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Auderiy/article/details/136072239
版权

Java基础知识（一）

参考文档：https://docs.oracle.com/en/java/javase/17/docs/api/index.html

一、数组

1、 一维数组

数组：可以用来存储同种数据类型的多个值

  • int类型数组可以包含byte、short、int
  • double数组可以包含byte、short、int、long、float、double

定义：

  • 数据类型[] 数组名
  • 数据类型 数组名[]
package TestCode;

public class TestClass {
    public static void main(String[] args) {
        int[] arr1 = new int[2];
        arr1[0] = 11;
        arr1[1] = 22;

        int[] arr2 = {33, 44, 55};

        int[] arr3 = arr2;
    }
}

图片.png

2、 二维数组

package TestCode;

public class TestClass {
    public static void main(String[] args) {
        int[][] arr = new int[2][3];
    }
}

图片.png

package TestCode;

public class TestClass {
    public static void main(String[] args) {
        int[][] arr = new int[2][];
        int[] arr1 = {11, 22};
        int[] arr2 = {44, 55, 66};
        
        arr[0] = arr1;
        arr[1] = arr2;
    }
}

图片.png

3、 Arrays

二分查找法查找元素：public static int binarySearch(数组,查找元素)

  • 前提数组中的元素必须是有序的且是升序
  • 如果查找元素存在返回真实的索引，否则返回插入点（查找元素应该在的位置）-1

拷贝数组：public static int[] copyOf(原数组, 新数组长度)

  • 根据第二个参数创建新数组
    • 如果新数组长度小于原数组，部份拷贝
    • 如果新数组长度等于原数组，完全拷贝
    • 如果新数组长度大于原数组，补上默认初始值

数组排序：public static void sort(数组)

  • 默认升序，底层是快速排序（以下代码是降序）
package TestCode;

import java.util.Arrays;
import java.util.Comparator;

public class TestClass {
    public static void main(String[] args) {
        /*
            public static void sort(数组，排序规则）
            参数一：要排序的数组
            参数二：排序的规则
            细节：
                只能给引用数据类型的数组进行排序
                如果数组是基本数据类型的，需要变成其对应的包装类
        */
        Integer[] arr = {2, 3, 1, 5, 6, 7, 8, 4, 9};

        //第二个参数是一个接口，所以在调用方法时需要传递这个接口的实现类对象，作为排序规则
        //这个实现类只需使用一次，所以采取匿名内部类的方式就可以

        /*
            底层原理:
            利用插入排序和二分查找的方式进行排序的
            默认把0索引的数据当作是有序的序列，1索引到最后认为是无序的序列
            遍历无序的序列得到里面的每一个元素，假设当前遍历得到的元素是A元素
            把A往有序序列中进行插入，在插入的时候利用二分查找确定A的元素插入点。
            拿着A元素和插入点元素进行比较，比较的规则就是compare方法的方法体
            如果方法的返回值是负数，A继续和前面的数据进行比较
            如果方法的返回值是正数，A继续和后面的数据进行比较
            如果方法的返回值是0，A继续和后面的数据进行比较
            直到确定A的最终位置为止
        */


        /*
            compare方法的形参：
            参数一 o1：表示在无序的序列中遍历得到的每一个元素
            参数二 o2：表示有序序列中的元素

            返回值：
            负数：表示当前要插入的元素是小的，放在前面
            正数：表示当前要插入的元素是大的，放在后面
            0：表示当前要插入的元素和现在的元素比是一样的 会放在后面
         */

        //o1 - o2 升序排列
        //o2 - o1 降序排列

        //匿名内部类
        /*Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });*/
        
        //lambda表达式
        /*Arrays.sort(arr, (Integer o1, Integer o2) -> {
            return o2 - o1;
        });*/
        Arrays.sort(arr, (o1,  o2) -> o2 - o1);

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

二、面向对象

1、类和对象

JavaBean类：用来描述一类事物的类，不写main方法
测试类：编写main方法的类，可以在测试类创建JavaBean类的对象赋值调用
注：一个java文件中可以定义多个类，但只能一个类是public修饰，且这个类名必须和文件名一致，建议一个文件定义一个类

标准的JavaBean类：

  1. 类名大驼峰
  2. 成员变量用private修饰
  3. 提供至少两个构造方法
    1. 无参
    2. 带全部参数
  4. 成员方法
    1. 每个成员变量对应的set和get方法
package TestCode;

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

    public Student() {
    }

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

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

2、封装（private）

  • private关键字是一个权限修饰符
  • 可以修饰成员变量和成员方法
  • 被private修饰只能在本类中访问
  • 使用setXxx()方法给成员变量赋值，public修饰
  • getXxx()方法获取成员变量的值，public修饰

3、构造方法

构造器、构造函数：在创建对象的时候给成员变量进行赋值
特点：

  • 方法名与类名完全一致
  • 没有返回值类型，也不需要void
  • 没有返回值，不需要return

执行：

  • 创建对象的时候虚拟机调用，每创建一次就调用一次

注意：

  • 构造方法没有被定义，系统会提供默认的无参构造，定义了就不再提供
  • 构造方法重载：方法名相同 但参数个数不同

4、内存图

  1. 加载class文件
  2. 申明局部变量
  3. 在堆内存中开辟一个空间
  4. 默认初始化 或 显式初始化
  5. 构造方法初始化
  6. 将堆内存中的地址值赋值给局部变量
package TestCode;

public class Student {
    //name没有被赋值，需要默认初始化
    String name;
    //age被赋值，是显示初始化
    int age = 23;

    public void test()
    {
        System.out.println("test");
    }
}


package TestCode;

public class TestClass {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.name = "zhangsan";
        s1.age = 25;
        s1.test();

        Student s2 = new Student();
        s2.name = "lisi";
        s2.age = 26;
        s2.test();
        
        Student s3 = s2;
    }
}

图片.png

5、this

作用：区分局部变量和成员变量
本质：代表方法调用者的地址值

package TestCode;

public class Student {
    private int age;
    public void method(){
        int age = 10;
        System.out.println(age);
        System.out.println(this.age);
    }
}


package TestCode;

public class TestClass {
    public static void main(String[] args) {
        Student s = new Student();
        s.method();
    }
}

图片.png

6、成员变量和局部变量

区别成员变量局部变量
类中位置类中，方法外方法内
初始化位置有默认初始化值没有，使用前需要赋值
内存位置堆内存栈内存
生命周期跟随对象跟随方法
作用域整个类方法中

7、static

static表示静态，可以修饰成员变量和成员方法
注意：

  • 静态方法中只能访问静态变量和静态方法
  • 非静态方法可以访问所有
  • 静态方法中没有this关键字

静态变量

特点：

  • 被该类所有对象共享
  • 不属于对象，属于类
  • 随着类的加载而加载，优先于对象

调用方式：

  • 类名调用（推荐）
  • 对象名调用

静态方法

特点：

  • 多在测试类和工具类中使用（工具类：私有化构造方法且方法定义为静态）
  • JavaBean类中很少会用

调用方式：

  • 类名调用（推荐）
  • 对象名调用
package TestCode;

public class Student {
    String name;
    int age;
    static String teacherName;

    public static void method(){
        System.out.println("静态方法");
    }

    public void show(){
        System.out.println(this.name + " " + this.age + " " + teacherName);
    }

}

package TestCode;

public class TestClass {
    public static void main(String[] args) {
        Student.teacherName = "李老师";
        Student.method();
        Student s1= new Student();
        s1.name = "zhangsan";
        s1.age = 23;
        s1.show();

        Student s2= new Student();
        s2.show();
    }
}

图片.png

8、继承

子类 extends 父类
特点：

  • 只支持单继承，不支持多继承，但支持多层继承
  • 所有类都直接或间接继承Object
  • 子类只能访问父类的非私有成员
  • 只有父类中非private非static非final成员方法才会被继承
  • 成员变量访问采用就近原则，局部 -> 本类成员 -> 父类成员
  • 父类构造方法不会被子类继承，子类所有的构造方法默认先访问父类中无参构造再执行自己

重写：

  • @Override重写注解
  • 形参列表必须与父类一致
  • 访问权限子类必须大于等于父类
  • 返回值类型子类必须小于等于父类
  • 非private非static非final方法才能被重写

图片.png

9、多态

父类类型 对象名称 = 子类对象；
前提：

  • 有继承关系
  • 有父类引用指向子类对象
  • 有方法重写

特点：

  • 方法中使用父类型作为参数，可以接收所有子类对象
  • 不能使用子类的特有功能，但可以类型转换成子类类型，从而调用子类独有功能
  • 转换时用instanceof关键字进行判断防止转化类型与真实对象类型不一致报错
package TestCode;

public class Person {
    String name = "All";

    public Person() {
    }

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

    public void show(){
        System.out.println("全部人员：" + this.name);
    }
}


package TestCode;

public class Admin extends Person{
    String name = "Admin";

    public Admin() {
        super();
    }

    @Override
    public void show(){
        System.out.println("管理员：" + this.name);
    }

}


package TestCode;

public class Teacher extends Person{
    String name = "Teacher";

    public Teacher() {
        super();
    }

    @Override
    public void show(){
        System.out.println("老师：" + this.name);
    }

}


package TestCode;

public class Student extends Person{
    String name = "Student";

    public Student() {
        super();
    }

    @Override
    public void show(){
        System.out.println("学生：" + this.name);
    }

}


package TestCode;

public class TestClass {
    public static void main(String[] args) {
        /*Person p = new Teacher();
        if (p instanceof Admin){
            Admin admin = (Admin) p;
            admin.show();
        }else if (p instanceof Teacher){
            Teacher teacher = (Teacher) p;
            teacher.show();
        }else if (p instanceof Student){
            Student student = (Student) p;
            student.show();
        }*/
        Person p = new Teacher();
        if (p instanceof Admin admin){
            admin.show();
        }else if (p instanceof Teacher teacher){
            teacher.show();
        }else if (p instanceof Student student){
            student.show();
        }


    }
}

10、包和final

包

包：用来管理不同功能Java类的文件夹
规则：

  • 公司域名反写 + 包作用，全部小写
  • 使用同一个包中的类不需要导包
  • java.lang类不需要导包
  • 其他都需要导包
  • 同时使用两个包中的同名类，需要用全类名
final

final：

  • 修饰类：最终类，不能被继承
  • 修饰方法：最终方法，不能被重写
  • 修饰变量：叫做常量 只能被赋值一次
    • 基本类型：数据值不能发生改变
    • 引用类型：地址值不能发生改变，内部能发生改变

11、权限修饰符和代码块

修饰符
修饰符同一个类中同一个包其他类不同包下的子类不同包下的无关类
private√
空√√
protected√√√
public√√√√
代码块

构造代码块：

  • 写在成员位置
  • 可以将构造方法中重复代码抽取出来
  • 创建本类对象时先执行构造代码块再执行构造方法

静态代码块：

  • static{}
  • 随着类的加载而加载，自动触发并只执行一次
  • 类加载时做一些数据初始化使用

12、抽象类和抽象方法

抽象方法：
将共性的行为 (方法)抽取到父类之后。由于每一个子类执行的内容是不一样所以，在父类中不能确定具体的方法体该方法就可以定义为抽象方法。
抽象类:
如果一个类中存在抽象方法，那么该类就必须声明为抽象类

抽象方法的定义格式:
public abstract 返回值类型 方法名(参数列表);
抽象类的定义格式：
public abstract class 类名{}

特点：

  • 抽象类象不能实例化
  • 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
  • 可以有构造方法 （作用 ：当创建子类对象时，给属性进行赋值）
  • 抽象类的子类 要么重写抽象类中的所有抽象方法、要么是抽象类

13、接口

接口是一种规则，对行为的抽象

接口的定义和使用

  • 接口用关键字interface来定义
    public interface 接口名{}

  • 接口不能实例化

  • 接口和类之间是实现关系，通过implements关键字表示

    • public class 类名 implements 接口名{}

  • 接口的子类(实现类)

    • 要么重写接口中的所有抽象方法
    • 要么是抽象类

:::tips
注意1: 接口和类的实现关系，可以单实现，也可以多实现。
public class 类名 implements 接口名1，接口名2 {}
注意2:实现类还可以在继承一个类的同时实现多个接口。
public class 类名 extends 父类 implements 接口名1，接口名2 {}
:::

接口中成员的特点
  • 成员变量只能是常量 —— 默认修饰符: public static final
  • 没有构造方法
  • 成员方法

    • 默认修饰符: public abstract

    • JDK7以前: 接口中只能定义抽象方法

    • JDK8的新特性:接口中可以定义有方法体的方法 - 不用重写也可以被调用

      • 接口中默认方法的定义格式:

        • 格式: public default 返回值类型 方法名(参数列表)
        • 范例: public default void show(){}

      • 接口中默认方法的注意事项

        • 默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉default关键字
        • public可以省略，default不能省略
        • 如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写

    • JDK8的新特性:接口中可以定义静态方法。 —— 不能被重写

      • 接口中静态方法的定义格式:

        • 格式:public static 返回值类型 方法名(参数列表) {}
        • 范例: public static void show() {}

      • 接口中静态方法的注意事项

        • 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
        • public可以省略static不能省略

    • JDK9的新特性:接口中可以定义私有方法 —— 抽取默认和静态方法的重复代码并不允许被其他使用

      • 格式1:private 返回值类型 方法名(参数列表){}

      • 范例1: private void show(){}

      • 格式2:private static 返回值类型方法名(参数列表){}

      • 范例2: private static void method(){}

14、内部类

图片.png

  • 内部类可以直接访问外部类的成员包括私有
  • 外部类访问内部类成员必须创建对象
成员内部类
  • 在成员位置，属于外部类成员
  • 可以被修饰符修饰
  • JDK16之后可以定义静态变量
  • 获取内部类对象方式
    • 在外部类中编写方法，对外提供内部类对象
    • 直接创建：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
package TestCode;

public class Outer {
    private int a = 10;

    class Inner{
        private int a = 20;
        public void show(){
            int a = 30;
            System.out.println(a);
            System.out.println(this.a);
            System.out.println(Outer.this.a);
        }
    }

}


package TestCode;

public class TestClass {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    }
}

图片.png

package TestCode;

public class Outer {
    private int a = 10;

    class Inner{
        private int a = 20;
        public void show(){
            int a = 30;
            System.out.println(a);
            System.out.println(this.a);
            System.out.println(Outer.this.a);
        }
    }

    public Inner getInstance(){
        return new Inner();
    }

}


package TestCode;

public class TestClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.getInstance().show();
    }
}
静态内部类
  • 静态内部类只能访问外部类中的静态变量和静态方法，如果想要访问非静态需创建对象。
  • 创建静态内部类对象：外部类名.内部类名 对象名 = new 外部类名.内部类名();
  • 调用静态方法：外部类名.内部类名.方法名();
package TestCode;

public class Outer {
    static class Inner{
        public void show1(){
            System.out.println("非静态方法");
        }
        public static void  show2(){
            System.out.println("静态方法");
        }
    }

}


package TestCode;

public class TestClass {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner();
        inner.show1();

        Outer.Inner.show2();
    }
}
局部内部类
  • 局部内部类：将内部类定义在方法里
  • 外界无法使用，需要在方法里创建对象才可使用
  • 可直接访问外部类的成员也可访问方法内的局部变量
匿名内部类

  • 包含了继承或实现、方法重写、创建对象，即是一个类的子类对象或接口的实现类对象。

  • 使用场景：如果实现类只使用一次就可以用匿名内部类

  • 格式：

    new 类名或者接口名(){
	重写方法;
};

package TestCode;

public abstract class Father {
    int num;
    public abstract void method();
}


package TestCode;

public class Outer {
    public void show(){
        //匿名内部类所产生的对象，一定不是new的类型的对象（因为是抽象类），而是new类型的子类对象！
        Father father = new Father() {
            @Override
            public void method() {
                System.out.println("匿名内部类");
            }
        };
        father.method();
    }


}


package TestCode;

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

注：
参考视频：
https://www.bilibili.com/video/BV17F411T7Ao?p=1&vd_source=a89593e8d33b31a56b894ca9cad33d33
https://www.bilibili.com/video/BV1yW4y1Y7Ms?p=1&vd_source=a89593e8d33b31a56b894ca9cad33d33

Nydia.J
关注
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
java基础知识大全(必看经典)
03-22
Java 基础知识大全 本资源摘要信息是 Java 基础知识大全的总结，涵盖了 Java 语言的基本概念、特点、历史发展等方面的知识点。以下是本资源摘要信息的详细内容： 一、 Java 语言的特点 * 面向对象：Java 语言是...
Java基础知识总结（2021版）
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
Java基础知识总结（超详细整理）
热门推荐
龙源IT 的博客
07-17 30万+
Java语言的特点，1.面向对象(OOP)就是Java语言的基础，也是Java语言的重要特性。面向对象的概念：生活中的一切事物都可以被称之为对象，生活中随处可见的事物就是一个对象，我们可以将这些事物的状态特征（属性）以及行为特征（方法）提取并出来，并以固定的形式表示。 2.简单好用，Java语言是由C和C++演变而来的，它省略了C语言中所有的难以理解、容易混淆的特性（比如指针），变得更加严谨、简洁、易使用。 3.健壮性、Java的安全检查机制，将许多程序中的错误扼杀在摇蓝之中。 另外，在
java基础知识点
学Java，找哪吒
09-18 2万+
🏆作者简介：哪吒，CSDN2022博客之星Top1、CSDN2021博客之星Top2、多届新星计划导师✌、博客专家💪，专注Java硬核干货分享，立志做到Java赛道全网Top N。🏆本文收录于，，目前已经700+订阅，CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。🏆姐妹篇，，包含面向对象、基本数据类型、数组、继承和多态、泛型、枚举等Java基础知识点。🏆姐妹进阶篇，
Java基础知识点汇总
qq_41286666的博客
05-04 4万+
Java基础知识点汇总1. Java基础语法2. 面向对象3. 异常处理4. 集合5. IO流 1. Java基础语法 类型转换 // 强制类型转换 float a = 20.34f; int b = (int)a; //自动类型转换 int c = 10; float d = c; //操作较大的数时，注意溢出问题 //JDK7新特性，数字之间可以用下划线分割
Java基础知识面试题
学Java，找哪吒
08-24 5万+
一、JDK 和 JRE 有什么区别？ JDK（Java Development Kit），Java开发工具包 JRE（Java Runtime Environment），Java运行环境 JDK中包含JRE，JDK中有一个名为jre的目录，里面包含两个文件夹bin和lib，bin就是JVM，lib就是JVM工作所需要的类库。 二、== 和 equals 的区别是什么？ 1、对于基本类型，==比较的是值； 2、对于引用类型，==比较的是地址； 3、equals不能用于基本类型的比较； 4、如果
java基础知识点总结（一）
nann-viiv 的博客
01-21 7603
打算重新看看java基础，把开始学的时候模糊的概念理清楚，不定时更新~~~ 一、环境篇 1. JDK和JRE 三个概念： JDK： java development kit（java开发工具） JRE： java runtime environment（java运行时环境） JVM： java Virtual Machine（java虚拟机） a. JDK： JDK就是我们开发人员使用的开发工具，它里面包含了JRE、JVM和基础类库。所以编程的话只需要安装JDK，配置环境变量，path路径就可以了。 b.
JAVA基础知识点总结
sen_sen97的博客
07-11 1万+
Java 是一门面向对象的编程语言。 语言特点：面向对象，平台无关性，支持多线程，编译与解释并存JVM：Java Virtual Machine，Java 虚拟机。 JRE： Java 运⾏时环境。 JDK: Java Development Kit，它是功能⻬全的 Java SDK。 JDK 包含 JRE，JRE 包含 JVM。Java 程序从源代码到运行主要有三步： 编译：将我们的代码（.java）编译成虚拟机可以识别理解的字节码(.class) 解释：虚拟机执行 Java 字节码，将字节码翻译成机器能
Java面试知识点汇总
程序员世杰
05-07 7万+
为了找到心仪的工作而努力吧 最近在刷各种面经，把学会的知识点汇总一下以便查漏补缺： 未完待续…
java语言基础知识（完整版）
Healer_小振的博客
08-30 6万+
一、java开发环境 编译运行过程（常见面试题） 编译期： 将.java源文件交给编译器编译成.class字节码文件的过程 （2）运行期： 把编译后的.class字节码文件经过JVM加载并运行.class字节码文件 配置环境变量 windows 10系统下配置JDK环境变量： （1）.安装JDK，安装过程中可以自定义安装目录等信息，例如我们选择安装目录为D:/java/jdk1.8.0_08； （2）.安装完成后，右击“我的电脑”，点击“属性”； （3）.选择“高级系统设置”选项卡，...
java 基础知识总结
12-24
自己在网上找的相对好一点的java复习资料，留个纪念 。详细讲述了Java课程的知识点
java基础知识.md
04-13
java的基础知识总结，对基本的知识点，容易错的知识点进行总结。文档中写有很多的案例。
2024版Java基础知识总结（超详细整理）
09-24
2024版Java基础知识总结（超详细整理）2024版Java基础知识总结（超详细整理）2024版Java基础知识总结（超详细整理）2024版Java基础知识总结（超详细整理）2024版Java基础知识总结（超详细整理）2024版Java基础知识...
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 402
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 510
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 780
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1150
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 318
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
JAVA基础知识总结：从概述到反射
JAVA基础知识总结是一份非常经典的总结文档，从Java的最基础知识开始，逐步延伸到反射等高级主题。下面是对标题、描述、标签和部分内容的详细解释和知识点总结： 一、Java概述 * Java的诞生：1991年，Sun公司的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值