[Java基础] 面向对象编程-高级（八）

已于 2023-08-22 11:34:41 修改
阅读量45 收藏 1
点赞数 1
文章标签： java
于 2023-08-20 23:57:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lu__Z/article/details/132390088
版权

目录

一、类变量‼️

1. 基本介绍

类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量

在这里插入图片描述

在这里插入图片描述

2. 定义

  1. 访问修饰符 static 数据类型 变量名
  2. static 访问修饰符 数据类型 变量名

3. 访问

  1. 类名.类变量名
  2. 对象名.类变量名

4. 使用

当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量

5. 注意示例

  • 类变量与实例变量的区别：类变量是该类的所有对象共享的，实例变量是每个对象独享的
  • 加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量
  • 实例对象不能通过类名.类变量名 来访问
  • 类变量是在类加载时就初始化了
  • 类变量的生命周期是随类的加载开始的，随类销往而销毁

二、类方法‼️

1. 基本介绍

类方法也叫静态方法

2. 定义

  1. 访问修饰符 static 数据返回类型 方法名(){}
  2. static 访问修饰符 数据返回类型 方法名(){}

3. 调用

  1. 类名.类方法名
  2. 对象名.类方法名

4. 使用

当方法中不涉及到任何和对象相关的成员，则可以将饭给发设计成静态方法，提高效率

5. 注意示例

  • 类方法和普通方法都是随着类的加载而加载的，将结构信息存储在方法区：类方法中无this的参数；普通方法中隐含着this的参数
  • 普通方法和对象有关，需要通过对象名调用
  • 类方法中不允许使用和对象有关的关键字this和super；普通方法可以
  • 类方法中只能访问静态变量和静态方法
  • 普通成员方法既可以访问非静态成员，也可访问静态成员

三、main方法

1. 深入理解

  • 解释main方法的形式：public static void main(String [] args):
  • main方法是虚拟机调用
  • java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public
  • java虚拟机在执行main()方法时不必创建对象。所以该方法必须是static
  • 该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数
  • java执行的程序 参数1 参数2 参数3 参数4

2. 特别提示

  1. 在main()方法中，我们可以直接调用main方法所在类的静态方法或静态属性
  2. 但是，不能直接访问该类的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员

四、代码块‼️‼️

1. 基本介绍

代码化块又称为初始化块，属于类的成员，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来

但和方法不同，没有方法名，没有返回，没有参数，只要方法体，而且不用通过对象或显式调用，而是加载类时，或创建对象时隐式调用

2. 基本语法

  • [修饰符]{
    代码；
    };

注意：
1）修饰符可选，要写的话也只能写static
2）代码块分两种1⃣️使用static修饰的静态代码块2⃣️没有static修饰的普通代码块
3）；号可以写，也可省略

3. 优点

  1. 相当于另外一种形式的构造器（对构造器的补充机制），可以做初始化操作
  2. 如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性

4. 注意示例‼️‼️

  • static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块，每创建一个对象，就执行一次
  • 类什么时候被加载‼️
    1⃣️创建对象实例时(new)
    2⃣️创建子类对象实例，父类也会被加载
    3⃣️使用类的静态成员时(静态属性，静态方法）
  • 普通的代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会调用一次。如果只是使用类的静态成员时，普通代码块井不会执行。
  • 创建一个对象时，在一个类调用顺序是：‼️
    1⃣️调用静态代码块和静态属生初给化
    （注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用）[举例说明]
    2⃣️调用普通代码块和普通属性的初始化
    (注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用
    3⃣️调用构造方法
  • 构造器的最前面其实隐含了super() 和 调用普通代码块，静态相关的代码块，属性初始化，在类加载时，就执行完毕因此是优先于构造器和普通代码块执行的
  • 创建一个子类对象时，调用顺序：‼️‼️
    1⃣️父类的静态代码块和静态属性(优先级一样，按定义顺序执行)
    2⃣️子类的静态代码块和静态属性(优先级一样，按定义顺序执行)
    3⃣️父类的普通代码块和普通属性初始化(优先级一样，披定义顺序执行）
    4⃣️父类的构造方法
    5⃣️子类的普通代码块和普通属性初始化(优先级一样，披定义顺序执行）
    6⃣️子类的构造方法

五、单例设计模式

1. 基本介绍

采取一定的方法保证在整个的软件系统中对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法

2. 饿汉式、懒汉式 -步骤

1⃣️构造器私有化
2⃣️类的内部创建对象
3⃣️向外暴露一个静态的公共方法

3. 饿汉式 VS 懒汉式

  1. 创建对象的时机不同：饿汉式是在类加载就创建了对象实例，懒汉式是在使用时创建的
  2. 饿汉式不存在线程安全问题，懒汉式存在
  3. 饿汉式有浪费资源的可能

六、final关键字

1. 基本介绍

可以修饰类、属性、方法、局部变量

2. 使用时机

  1. 类：不希望类被继承
  2. 方法：不希望父类的某个方法被子类覆盖/重写
  3. 属性：不希望类的某个属性被修改
  4. 局部变量：不希望局部变量被修改

3. 示例

  • final修饰的属性又叫常量，一般用XX_XX_XX命名
  • final修饰的属性在定义时，必须赋初值，并且以后不能再修改
  • 赋初值可以在：
    1⃣️定义时
    2⃣️在构造器中
    3⃣️在代码块中
  • 如果final修饰的属性是静态的，赋初值位置：⚠️
    1⃣️定义时
    2⃣️在静态代码块（不能在构造器中赋值）
  • final类不能被继承，但可以实例化对象
  • 如果类不是final类，但含有final方法，则该方法虽然不能被重写，但是可以被继承
  • final不能修饰构造方法
  • final和static往往搭配使用，效率更高，不会导致类加载，底层编译器做了优化处理

七、抽象类‼️

1. 基本介绍

  1. 用abstract关键字来修饰一个类时，这个类就是抽象类
    访问修饰符 abstract 类名{
    }
  2. 用abstract关键字修饰一个方法时，这个方法就是抽象方法
    访问修饰符 abstract 返回类型 方法名(参数列表)；//没有方法体
  3. 抽象类的价值更多作用是在于设计，设计好后，让子类继承并实现抽象类

2. 注意示例

  • 抽象类不能被实例化
  • 抽象类不一定包含abstract方法
  • 一旦包含abstract方法，则这个类必须声明为abstract
  • abstract只能修饰类和方法，不能修饰属性和其他的
  • 抽象类可以有任意成员
  • 抽象方法不能有主体
  • 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
  • 抽象方法不能使用private、final、static来修饰，因为这些关键字都和重写相违背

八、模版设计模式

1. 基本介绍

抽象类体现的就是一种模版设计模式，抽象类可以作为多个子类的通用模版，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式

2. 解决问题

  1. 当功能内部一部分是实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出来，让子类去实现
  2. 编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，这就是一种模版模式

3. 代码示例

package Java.AbstractTemplate;

abstract public class AbstractTemplate {
    public abstract void job();

    public void calculateTime() {
        long start = System.currentTimeMillis();
        job();
        long end = System.currentTimeMillis();
        System.out.println("执行时间为 " + (end - start));
    }
}

package Java.AbstractTemplate;

public class AA extends AbstractTemplate{
    @Override
    public void job() {
        int num = 0;
        for (int i = 0; i < 80000; i++) {
            num += i;
        }
    }
}

package Java.AbstractTemplate;

public class BB extends AbstractTemplate {
    @Override
    public void job() {
        int num = 0;
        for (int i = 0; i < 8000; i++) {
            num *= i;
        }
    }
}


package Java.AbstractTemplate;

public class Test {
    public static void main(String[] args) {

        AA aa = new AA();
        aa.calculateTime();

        BB bb = new BB();
        bb.calculateTime();
    }
}

九、接口‼️

1. 基本介绍

接口就是给出一些没有实现的方法，封装在一起，到某个类要使用的时候，再根据具体情况把这些方法写出来

interface 接口名{
		//属性
		//抽象方法
}
class 类名 implements 接口{
		1自己属性
		2自己方法
		3必须实现的接口的抽象方法
}
  • 【JDK7.0】接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体
  • 【JDK8.0后】接口类可以有静态方法、默认方法，也就是说接口中可以有方法的具体实现
  • 接口体现了程序设计的多态和高内聚低耦合的设计思想
package Java.Interface;

public interface Interface {
    public void start();

    public void end();
}

package Java.Interface;

public class Camera implements Interface{
    @Override
    public void start() {
        System.out.println("照相机开始工作");
    }

    @Override
    public void end() {
        System.out.println("照相机结束工作");
    }
}


package Java.Interface;

public class Phone implements Interface{
    @Override
    public void start() {
        System.out.println("手机开始工作");
    }

    @Override
    public void end() {
        System.out.println("手机结束工作");
    }
}


package Java.Interface;

public class Computer {
    public void work(Interface usbInterface){
        usbInterface.start();
        usbInterface.end();
    }
}


package Java.Interface;

public class Test {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Camera camera = new Camera();
        Computer computer = new Computer();
        computer.work(phone);
        computer.work(camera);
    }
}

2. 注意示例

  • 接口不能被实例化
  • 接口中所有的方法是public方法，接口中抽象方法可以不用abstract修饰
  • 一个普通类实现接口，就必须将该接口的所有方法实现
  • 抽象类实现接口，可以不用实现接口的方法
  • 一个类可以实现多个接口
  • 接口中的属性只能是final的，并且是 public static final 修饰符（比如：int a = 1;—>实际上是public static final int a = 1;）
  • 接口中属性的访问形式：接口名.属性名
  • 接口不能继承其他类，但是可以继承多个接口
  • 接口的修饰符只能是public和默认，这点和类的修饰符一样

3. 接口 VS 继承

  • 继承的价值：解决代码的复用性和可维护性
  • 接口的价值：设计好的各种规范，让其他类去实现这些方法，比继承更加灵活
  • 接口在一定程度上实现代码的解耦
package Java.Interface;

public class Extends_VS_Interface {
    public static void main(String[] args) {
        LittleMonkey littleMonkey = new LittleMonkey("悟空");
        littleMonkey.flying();
        littleMonkey.swimming();
        littleMonkey.climbing();
    }
}

class Monkey {
    private String name;

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

    public void climbing() {
        System.out.println(name + " 爬树");
    }

    public String getName() {
        return name;
    }
}

interface Fishable {
    void swimming();
}

interface Birdable {
    void flying();
}

class LittleMonkey extends Monkey implements Fishable, Birdable {
    public LittleMonkey(String name) {
        super(name);
    }

    @Override
    public void swimming() {
        System.out.println(getName() + " 学会了游泳");
    }

    @Override
    public void flying() {
        System.out.println(getName() + " 学会了飞行");
    }
}

4. 多态特性

  1. 多态参数
  2. 多态数组
package Java.Interface;

import com.zhou.package1.Person;

public class InterfacePolyArr {
    public static void main(String[] args) {
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera_();

        for (int i = 0; i < 2; i++) {
            usbs[i].work();
            if (usbs[i] instanceof Phone_){
                ((Phone_) usbs[i]).call();
            }
        }
    }
}
interface Usb{
    void work();
}
class Phone_ implements Usb{
    @Override
    public void work() {
        System.out.println("手机工作中");
    }

    public void call() {
        System.out.println("手机正在打电话");
    }
}

class Camera_ implements Usb {

    @Override
    public void work() {
        System.out.println("照相机工作中");
    }
}
  1. 接口存在多态传递现象

在这里插入图片描述

package Java.Interface;

public class Phone implements Interface{
    @Override
    public void start() {
        System.out.println("手机开始工作");
    }

    @Override
    public void end() {
        System.out.println("手机结束工作");
    }
}

十、内部类‼️⚠️⚠️‼️

基本介绍

一个类的内部又完整的嵌套了另一个类的结构

基本语法

class Outer{	//外部类
	class Inner{	//内部类
	}
}
class Other{	//外部其他类
}

分类

  • 定义在外部类的局部位置上（比如方法内）：
  1. 局部内部类（有类名）
  2. 匿名内部类（没有类名）
  • 定义在外部类的成员位置
  1. 成员内部类（没有static修饰）
  2. 静态内部类（使用static修饰）

1. 局部内部类

定义在外部类局部位置上（有类名）

  • 不能添加访问修饰符，可以使用final修饰，本身是一个局部变量
  • 作用域：1⃣️定义它的方法中 2⃣️代码块中
  • 局部内部类——访问——>外部内部类 [直接访问]
  • 外部类——访问——>局部内部类 [创建对象，再访问]
  • 外部其它类——不能❌访问——>局部内部类
  • 如果外部类和局部内部类的成员重名时，默认遵循就近原则（访问：外部类名.this.成员）

2. 匿名内部类‼️⚠️

定义在外部类局部位置上（没有类名）

new 类/接口（参数列表）{
	类体
};
  • 不能添加访问修饰符，本身是一个局部变量
  • 作用域：1⃣️定义它的方法中 2⃣️代码块中 ‼️
  • 匿名内部类——访问——>外部内部类 [直接访问]
  • 外部类——访问——>匿名内部类 [创建对象，再访问]
  • 外部其它类——不能❌访问——>匿名内部类 ⚠️
  • 如果外部类和匿名内部类的成员重名时，默认遵循就近原则（访问：外部类名.this.成员）
package Java.InnerClass;

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

class Outer {
    public void fun() {
        //ia的编译类型是IA
        //ia的运行类型是Outer$1
        /**
         *  class Outer$1 implements IA{
         *  }
         */
        IA ia = new IA() {
            @Override
            public void cry() {
                System.out.println("匿名内部类");
            }
        };
        System.out.println("ia的运行类型：" + ia.getClass());
        ia.cry();


        //other的编译类型是Other
        //other的运行类型是Outer$2
        /**
         *  class Outer$2 exends Other{
         *  }
         */
        //注意：（"Tom"）参数列表会传递给构造器
        Other other = new Other("Tom"){
            @Override
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
        };
        System.out.println("other的运行类型：" + other.getClass());
        other.test();
    }
}

interface IA {
    void cry();
}
class Other{
    public Other(String name) {
        System.out.println("接收到name= " + name);
    }

    public void test() {
    }
}


package Java.InnerClass;

public class AnonymousClassExercise {
    public static void main(String[] args) {
//        new Other_("Tom"){
//            @Override
//            public void test() {
//                System.out.println("匿名内部类重写了test方法");
//            }
//        }.test();

        fun(new IA_() {
            @Override
            public void show() {
                System.out.println("匿名内部类作为实参");
            }
        });
    }

    public static void fun(IA_ ia_) {
        ia_.show();
    }
}
interface IA_{
    void show();
}
//class Other_{
//    public Other_(String name) {
//        System.out.println("接收到name=" + name);
//    }
//
//    public void test() {
//    }
//}

3. 成员内部类

定义在外部类的成员位置，没有static修饰

  • 可以添加任意访问修饰符，本身是一个成员
  • 作用域：整个类体
  • 成员内部类——访问——>外部内部类 [直接访问]
  • 外部类——访问——>成员内部类 [创建对象，再访问]
  • 外部其它类——访问——>成员内部类
		Outer outer = new Outer();

        //第一种：把new Inner_()当作outer_的成员
        Outer.Inner inner1 = outer.new Inner();
        inner1.show();

        //第二种：在外部类中，编写一个方法，返回Inner_对象
        Outer.Inner inner2 = outer.getInner_();
        inner2.show();
  • 如果外部类和成员内部类的成员重名时，默认遵循就近原则（访问：外部类名.this.成员）
package Java.InnerClass;

public class MemberClass {
    public static void main(String[] args) {
        Outer_ outer_ = new Outer_();
//        outer_.fun();

        //第一种：把new Inner_()当作outer_的成员
        Outer_.Inner_ inner_1 = outer_.new Inner_();
        inner_1.show();

        //第二种：在外部类中，编写一个方法，返回Inner_对象
        Outer_.Inner_ inner_2 = outer_.getInner_();
        inner_2.show();
    }
}
class Outer_ {
    private String name = "Tom";
    private static int age = 18;

    public void fun() {
        System.out.println("外部类的fun()");
    }
    public class Inner_{
        public void show() {
            System.out.println(name + " " + age);
            fun();
        }
    }

    public Inner_ getInner_() {
        return new Inner_();
    }
}

4.静态内部类

定义在外部类的成员位置，使用static修饰

  • 可以添加任意访问修饰符，本身是一个成员
  • 作用域：整个类体
  • 静态内部类——访问——>外部内部类 [直接访问]
  • 外部类——访问——>静态内部类 [创建对象，再访问]
  • 外部其它类——访问——>静态内部类
        //第一种：把new Inner_()当作outer_的成员
        Outer.Inner inner1 = new Outer.Inner();
        inner1.show();

        //第二种：在外部类中，编写一个方法，返回Inner_对象
        Outer.Inner inner2 = Outer.getInner_();
        inner2.show();
  • 如果外部类和静态内部类的成员重名时，默认遵循就近原则（访问：外部类名.成员）
你怎么知道我头发乌黑浓密
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 242
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 984
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 94
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 524
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
26.jdk源码阅读之ConcurrentLinkedQueue
前端、移动端、后端源码级底层原理分享
07-29 575
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 603
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 375
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 436
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
新建springboot项目找不到java版本8?
weixin_74009895的博客
07-28 131
新建springboot项目找不到java版本8?
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 195
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
高级java每日一道面试题-2024年7月29日-并发篇-什么时候用乐观锁,什么时候用悲观锁?
qq_43071699的博客
07-29 331
悲观锁适用于数据竞争激烈的场景，能够提供强一致性，但可能导致较多的线程等待。乐观锁适用于读多写少的场景，能够提供更高的并发性能，但可能需要多次尝试才能成功更新数据。
19.jdk源码阅读之FutureTask
前端、移动端、后端源码级底层原理分享
07-25 872
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
c++ 智能指针shared_ptr与make_shared
Txwtech笛克特科
07-25 282
shared_ptr是C++11引入的一种智能指针，‌它允许多个shared_ptr实例共享同一个对象，‌通过引用计数来管理对象的生命周期。‌当最后一个持有对象的shared_ptr被销毁时，‌它会自动删除所指向的对象。‌这种智能指针主要用于解决资源管理问题，‌避免内存泄漏。make_shared是C++标准库中的一个函数，‌用于创建一个shared_ptr智能指针，‌它接受一个或多个参数来构造一个对象，‌并返回一个指向该对象的shared_ptr。类SerialModbus的成员指针。
Java —— 线程
JL_L666的博客
07-26 662
程序(program)：为完成特定的任务，选用某一种语言编写的，即指，静态对象。进程(process)：程序的一次执行过程，或是。程序是静态的、进程是。进程是调度和分配资源的最小单位。注意：不同的进程之间是不共享内存的、进程之间的数据交换和通信的成本很高。线程(thread)：进程可以进一步细化为线程，是运行中进程的一条或多条执行路径。线程调度策略单核CPU与多核CPU并行与并发上。
Jvm基础（一）
G81948577的博客
07-19 1155
本地方法就是不使用java编写的，比如C++编写的程序，只是需要传递参数。
教务管理平台/高校教务管理系统的设计与实现/教务网站/学生成绩管理系统/学生课程管理系统
weixin_47958760的博客
07-27 783
本毕业设计的内容是设计并且实现一个基于JSP技术的教务管理平台。采用MYSQL为数据库开发平台，SSM框架，Tomcat网络信息服务作为应用服务器。教务管理平台的功能已基本实现，主要有学生、教师、课程信息、课程选择、教师课表、学生成绩、图书信息、考试等管理功能。 论文主要从系统的分析与设计 、数据库设计和系统的详细设计等几个方面来进行论述，系统分析与设计部分主要论述了系统的功能分析、系统的设计思路，数据库设计主要论述了数据库的设计，系统的详细设计部分主要论述了几个主要模块的详细设计过程。
Springboot使用Dynamic-Datasource配置多数据源
最新发布
shenxiaomo1688的博客
07-29 705
grace-destroy: false #是否优雅关闭数据源，默认为false，设置为true时，关闭数据源时如果数据源中还存在活跃连接，至多等待10s后强制关闭。driver-class-name: com.mysql.jdbc.Driver # 3.2.0开始支持SPI可省略此配置。strict: false #严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源。primary: master #设置默认的数据源或者数据源组,默认值即为master。
Java 使用 POI 导出Excel，设置同一个单元格的内容显示不同的文字颜色
viman3344的专栏
07-27 380
在使用Apache POI的库生成Excel的时候，如何在一个Cell中的文字中显示不同的颜色？下面是一个示例代码，演示如何在单元格中设置不同颜色的文本。more。
关于Jenkins自动化部署Maven项目:
gzx233的博客
07-27 921
测试工程:Jenkins自动化部署maven项目全流程
Java编程实训：面向对象编程-接口深度解析
"Java编程实训课程涵盖了从Java开发环境的设置到高级概念的讲解，包括Java编程基础、自定义方法、面向对象编程的类和对象、封装、继承和多态，以及接口和常量的使用。课程旨在帮助初学者深入理解Java语言的核心概念...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

你怎么知道我头发乌黑浓密

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值