Java基础1

最新推荐文章于 2019-06-10 18:13:46 发布
最新推荐文章于 2019-06-10 18:13:46 发布
阅读量288 收藏 1
点赞数
分类专栏： JavaSE







说明:
这里写图片描述



---------------------------------------------------------------------------------------







说明:
这里写图片描述


----------------------------------------------------------------------------------------







说明:
这里写图片描述


----------------------------------------------------------------------------------------

多态

说明:
1>要有继承关系。 
2>要有方法重写。 
3>要有父类引用子类对象。


----------------------------------------------------------------------------------------

Java中静态代码块、构造代码块、构造方法块


代码块：

//Java
class Fu {
    public Fu() {
        System.out.println("构造方法Fu");
    }
    {
        System.out.println("构造代码块Fu");
    }
    static {
        System.out.println("静态代码块Fu");
    }
}
class Zi extends Fu {
    static {
        System.out.println("静态代码块Zi");
    }
    {
        System.out.println("构造代码块Zi");
    }
    public Zi() {
        System.out.println("构造方法Zi");
    }
}
class Jicheng04 {
    public static void main(String[] args) {
        Zi z = new Zi();
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

结果:

结果是：
    静态代码块Fu
    静态代码块Zi
    构造代码块Fu
    构造方法Fu
    构造代码块Zi
    构造方法Zi

说明:

A:一个类的静态代码块,构造代码块,构造方法的执行流程
    静态代码块 > 构造代码块 > 构造方法
B:静态的内容是随着类的加载而加载
    静态代码块的内容会优先执行
C:子类初始化之前先会进行父类的初始化


---------------------------------------------------------------------------------------

成员变量、this和super问题、类的初始化过程问题

代码块：

//Java
class Fu{
    public int num = 10;
    public Fu(){
        System.out.println("fu");
    }
}
class Zi extends Fu{
    public int num = 20;
    public Zi(){
        System.out.println("zi");
    }
    public void show(){
        int num = 30;
        System.out.println(num); //30
        System.out.println(this.num); //20
        System.out.println(super.num); //10
    }
}
class ExtendsTest {
    public static void main(String[] args) {
        Zi z = new Zi();  //子类对象实例化
        z.show();
    }
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

结果:

结果是：
    fu
    zi
    30
    20
    10

说明:

A:成员变量 就近原则
B:this和super的问题
        this访问本类的成员
        super访问父类的成员
C:子类构造方法执行前默认先执行父类的无参构造方法
D:一个类的初始化过程
        成员变量进行初始化
        默认初始化
        显示初始化
        构造方法初始化-------------------------------------------------------------------------------------

-------------------------------------------------------------------------------------

继承中的问题

代码块：

//Java
class X {
    Y b = new Y();
    X() {
        System.out.print("X");
    }
}

class Y {
    Y() {
        System.out.print("Y");
    }
}

public class Z extends X {
    Y y = new Y();
    Z()
    {
        //super
        System.out.print("Z");
    }
    public static void main(String[] args) {
        new Z(); 
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

结果:

结果是：YXYZ

说明:

    A:成员变量的问题
        int x = 10; //成员变量是基本类型
        Student s = new Student(); //成员变量是引用类型
    B:一个类的初始化过程
        成员变量的初始化
            默认初始化
            显示初始化
            构造方法初始化
    C:子父类的初始化(分层初始化)
        先进行父类初始化，然后进行子类初始化
<问题>
    虽然子类中构造方法默认有一个super()
    初始化的时候，不是按照那个顺序进行的。
    而是按照分层初始化进行的。
    它仅仅表示要先初始化父类数据，再初始化子类数据。


--------------------------------------------------------------------------------------

局部代码块、构造代码块、静态代码块、多线程代码块

代码块定义

代码块： 
在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。

代码块 定义
局部代码块 在方法中出现；限定变量生命周期，及早释放，提高内存利用率
构造代码块 在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
静态代码块 在类中方法外出现，加了static修饰；用于给类进行初始化，在加载的时候就执行，并且值执行一次

代码块

代码块语法遵循标准markdown代码，例如：

class Student {
    static {
        System.out.println("Student 静态代码块");
    }

    {
        System.out.println("Student 构造代码块");
    }

    public Student() {
        System.out.println("Student 构造方法");
    }
}

class StudentDemo {
    static {
        System.out.println("static:静态代码块");
    }

    public static void main(String[] args) {
        System.out.println("我是main方法");

        Student s1 = new Student();
        Student s2 = new Student();
    }
}
... prompt'''
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

答案：

main 静态代码块 
我是main方法 
Student 静态代码块 
Student 构造代码块 
Student 构造方法 
Student 构造代码块 
Student 构造方法

--------------------------------------------------------------------------------------

final修饰类、方法、变量问题


class Student {
    int age = 10;
}

class FinalTest {
    public static void main(String[] args) {
        //局部变量是基本数据类型
        int x = 10;
        x = 100;
        System.out.println(x);
        final int y = 10;
        //无法为最终变量y分配值
        //y = 100;
        System.out.println(y);
        System.out.println("--------------");

        //局部变量是引用数据类型
        Student s = new Student();
        System.out.println(s.age);
        s.age = 100;
        System.out.println(s.age);
        System.out.println("--------------");

        final Student ss = new Student();
        System.out.println(ss.age);
        ss.age = 100;
        System.out.println(ss.age);

        //重新分配内存空间
        //无法为最终变量ss分配值
        ss = new Student();
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

答案

100 
10 
** 
10 
100 
** 
10 
100

说明

<1>final可以修饰类，方法，变量

特点：
    final可以修饰类，该类不能被继承。
    final可以修饰方法，该方法不能被重写。(覆盖，复写)
    final可以修饰变量，该变量不能被重新赋值。因为这个变量其实常量。

常量：
    A:字面值常量
        "hello",10,true
    B:自定义常量
        final int x = 10;

<2>final修饰局部变量的问题 
基本类型：基本类型的值不能发生改变。 
引用类型：引用类型的地址值不能发生改变，但是，该对象的堆内存的值是可以改变的。

2 final修饰变量的初始化时机

代码块

代码块语法遵循标准markdown代码，例如：

class Demo {
    //int num = 10;
    //final int num2 = 20;

    int num;
    final int num2;

    {
        //num2 = 10;
    }

    public Demo() {
        num = 100;
        //无法为最终变量num2分配值
        num2 = 200;
    }
}

class FinalTest2 {
    public static void main(String[] args) {
        Demo d = new Demo();
        System.out.println(d.num);
        System.out.println(d.num2);
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

说明

final修饰变量的初始化时机
    A:被final修饰的变量只能赋值一次。
    B:在构造方法完毕前。(非静态的常量)


----------------------------------------------------------------------------------

多态的成员访问特点


说明:

成员访问特点的说明

/* 
多态：同一个对象(事物)，在不同时刻体现出来的不同状态。 
举例： 
猫是猫，猫是动物。 
水(液体，固体，气态)。

多态的前提：
    A:要有继承关系。
    B:要有方法重写。
        其实没有也是可以的，但是如果没有这个就没有意义。
            动物 d = new 猫();
            d.show();
            动物 d = new 狗();
            d.show();
    C:要有父类引用指向子类对象。
        父 f =  new 子();

用代码体现一下多态。

多态中的成员访问特点：
    A:成员变量
        编译看左边，运行看左边。
    B:构造方法
        创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
    C:成员方法
        编译看左边，运行看右边。
    D:静态方法
        编译看左边，运行看左边。
        (静态和类相关，算不上重写，所以，访问还是左边的)

    由于成员方法存在方法重写，所以它运行看右边。

*/

代码块

class Fu {
    public int num = 100;

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

    public static void function() {
        System.out.println("function Fu");
    }
}

class Zi extends Fu {
    public int num = 1000;
    public int num2 = 200;

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

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

    public static void function() {
        System.out.println("function Zi");
    }
}

class Duotai {
    public static void main(String[] args) {
        //要有父类引用指向子类对象。
        //父 f =  new 子();
        Fu f = new Zi();
        System.out.println(f.num);
        //找不到符号
        //System.out.println(f.num2);

        f.show();
        //找不到符号
        //f.method();
        f.function();
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

答案

100 
show Zi 
function Fu

多态的好处和弊端

好处和弊端

多态的好处 
提高了程序的维护性(由继承保证) 
提高了程序的扩展性(由多态保证)<可以使代码非常的简洁> 
多态的弊端 
不能访问子类特有功能 
那么我们如何才能访问子类的特有功能呢?




---------------------------------------------------------------------------------

多态的向上转型和向下转型

定义

多态的弊端：
    不能使用子类的特有功能。
我就想使用子类的特有功能?行不行?
    行。
怎么用呢?
    A:创建子类对象调用方法即可。(可以，但是很多时候不合理。而且，太占内存了)
    B:把父类的引用强制转换为子类的引用。(向下转型)
对象间的转型问题：
    向上转型：
        Fu f = new Zi();
    向下转型：
        Zi z = (Zi)f; //要求该f
        多态分两种：

(1) 编译时多态（设计时多态）：方法重载。 
(2) 运行时多态：Java运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。（我们平时说得多的事运行时多态，所以多态主要也是指运行时多态）

代码块

class Fu {
    int age=40;
    public void show() {
        System.out.println("show fu");
    }
}

class Zi extends Fu {
    int age=20;
    public void show() {
        System.out.println("show zi");
    }

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

}

class DuoTaiDemo4 {
    public static void main(String[] args) {
        //测试
        Fu f = new Zi();               //向上转型
        f.show();                      //成员方法看右边
        System.out.println(+(f.age));  //成员变量看左边，打印
        //f.method();

        //创建子类对象
        //Zi z = new Zi();
        //z.show();
        //z.method();

        //你能够把子的对象赋值给父亲，那么我能不能把父的引用赋值给子的引用呢?
        //如果可以，但是如下
        Zi z = (Zi)f;               //向下转型
        z.show();
        z.method();
    }
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

答案

show zi 
show zi 
method zi

多态的好处和弊端

好处和弊端

多态的好处 
提高了程序的维护性(由继承保证) 
提高了程序的扩展性(由多态保证)<可以使代码非常的简洁> 
多态的弊端 
不能访问子类特有功能 
那么我们如何才能访问子类的特有功能呢?

内存结构图

这里写图片描述

多态的代码示例

class Animal {
    public void eat(){
        System.out.println("Animal eat");
    }
}

class Dog extends Animal {
    public void eat() {
    System.out.println("Dog eat");
    }
    public void lookDoor() {
    System.out.println("Dog lookDoor");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("Cat eat");
    }
    public void playGame() {
        System.out.println("Cat Playgame");
    }
}

class DuoTaiDemo5 {
    public static void main(String[] args) {
        //内存中的是狗
        Animal a = new Dog();  //向上转型
        a.eat();

        Dog d = (Dog)a;        //向下转型
        d.eat();
        d.lookDoor();
        //内存中是猫
        a = new Cat();        //a指向了猫
        a.eat();
//      a.playGame();

        Cat c = (Cat)a;
        //内存中是猫
        Dog dd = (Dog)a; //ClassCastException  猫不能变成狗
    }
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

多态内存结构图

这里写图片描述



---------------------------------------------------------------------------------




--------------------------------------------------------------------------------


说明:
最是那一低头的温柔
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础1
万汉龙的博客
12-18 121
​​​​​直接赋值常量值，禁止声明新对象（直接赋值常量值，只是创建了一个对象引用，而这个对象引用指向常量值。） 反例：String s = new String("abc"); 正例：​​​​​​String s = "abc"; 当成员变量值无需改变时，尽量定义为静态常量（在类的每个对象实例中，每个成员变量都有一份副本，而成员静态常量只有一份实例。） 反例： private final lo...
java关键字 final 的使用
冰月灵狐
06-23 195
由于继承中有一个现象：方法重写。 所以父类的功能，就会被子类给覆盖掉。 有些时候，我们不想让子类去覆盖掉父类的功能，只能让他使用。 针对这种情况，Java提供了一个关键字：final final:最终的意思。它可以修饰类，方法，变量。 特点： final 可以修饰类，该类不能被继承。 final class Fu{ } final 可以修饰方法，该方法不...
内部类概述和讲解
gafeng123456的博客
02-17 327
内部类概述: 把类定义在其他类的内部，这个类就被称为内部类。 举例：在类A中定义了一个类B，类B就是内部类。内部的访问特点： A:内部类可以直接访问外部类的成员，包括私有。 B:外部类要访问内部类的成员，必须创建对象。 class Outer { private int num = 10; class Inner { public voi
2017 - 10 -15 面向对象
ouqia的博客
10-16 212
1 静态调用    静态方法中只能调用静态方法，不能调用非静态。    可以通过创建对象调用非静态方法 class ArrayDemo{      public  static void  main（String arg[]）{            ...........      //静态方法      //printArray(arr);      //非静态方法
JAVA基础(1)
chengly0129的专栏
11-30 393
1.逻辑运算符         A:&,|,^,!,&&,||(常用)         B:逻辑运算符用于连接boolean类型的式子         C:结论             &:有false则false             |:有true则true             ^:相同则false，不同则true。                 情侣关系。
2019年06月10日 java高开面试真题 2
路在手上的博客
06-10 363
2019年06月10日 java高开面试真题 2 北京*信 2019年06月10日 java高开面试真题 广视** Spring Cloud 面试类 Spring Cloud 常用组件？ Spring Boot类面试题 Spring Boot 启动顺序？ Spring Boot 配置文件有几种？ Spring Boot 的application.properties是否可以重命名？ S...
Java基础课程
06-23
Java基础课程PPT资源；知识点：自定义动画、选择器高级应用、响应式网站开发、行业命名规范、域名注册-搭建个人网站 让学员熟练掌握css、js、JQuery等技术，可做到独立编写PC+移动端网站页面。并且能够独立开发web...
java基础案例教程
01-08
java基础的案例分析和实例教学,适合新手及回顾查阅,对于夯实基础有好处
java基础知识图
01-18
总结了java基础的架构，从JDK安装到反射的知识
大学生挑战杯-喜树根器官培养和抗癌物质喜树碱生成的研究.rar
07-26
大学生挑战杯-喜树根器官培养和抗癌物质喜树碱生成的研究.rar
b278视频及游戏管理平台-springboot+vue.zip（可运行源码+sql文件+）
07-26
视频及游戏管理平台是一个很好的项目，结合了后端（Spring Boot）和前端（Vue.js）技术，实现了前后端分离。 视频及游戏管理平台是一个很好的项目，结合了后端（Spring Boot）和前端（Vue.js）技术，实现了前后端分离。 视频及游戏管理平台是一个很好的项目，结合了后端（Spring Boot）和前端（Vue.js）技术，实现了前后端分离。 视频及游戏管理平台是一个很好的项目，结合了后端（Spring Boot）和前端（Vue.js）技术，实现了前后端分离。 视频及游戏管理平台是一个很好的项目，结合了后端（Spring Boot）和前端（Vue.js）技术，实现了前后端分离。 视频及游戏管理平台是一个很好的项目，结合了后端（Spring Boot）和前端（Vue.js）技术，实现了前后端分离。
大模型应用-为Ollma开发的简单的HTML网页UI应用-附项目源码-优质项目实战.zip
07-26
大模型应用_为Ollma开发的简单的HTML网页UI应用_附项目源码_优质项目实战
基于JAVA局域网监听软件的设计与开发(源代码+论文).rar
07-26
基于JAVA局域网监听软件的设计与开发(源代码+论文).rar
小程序-光影娱乐带后台（源码）.zip
07-26
小程序-光影娱乐带后台（源码）.zip
基于Cadence的模块化电路设计与应用研究
07-26
在当前电子产品的需求不断扩大尧更新频率持续加快的形势下袁电路模块化设计成为了提高电子产 品设计效率尧最大化降低研制成本极其重要且有效的实施途径遥通过对模块化电路设计流程进行分析袁系统地 梳理出了Cadence软件下模块化电路设计的实现方式袁以及基于Capture CIS 的模块化电路调用方法袁为广大设 计师开展产品模块化电路设计提供了方法参考遥
基于人工蜂群优化算法ABC-Kmean-Transformer-GRU实现数据回归预测算法研究Matlab代码.rar
最新发布
07-26
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
基于JavaWeb的blog博客发布系统（源代码+数据库sql）.rar
07-26
基于JavaWeb的blog博客发布系统（源代码+数据库sql）.rar
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值