Java基础

最新推荐文章于 2024-09-12 23:58:52 发布
最新推荐文章于 2024-09-12 23:58:52 发布
阅读量126 收藏
点赞数 1
文章标签： java 多态 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yonghumingyibeizhan8/article/details/113885114
版权

变量

类变量

加了一个“static”，从属于类的，在方法外面。

局部变量

必须申明和初始化值

实例变量

在类里面方法外面，从属于对象;如果不自行初始化，这个类型的默认值就为 0,0.0。

布尔值默认为false,除了基本类型，其余的默认值都是null；

public class variable{
    static int allClinks=0; //类变量
    String str = "hello world";//实例变量
    
    public void method(){
        int i = 0 ;  //局部变量
    }
}

常量 final

修饰符不分先后顺序

命名规范

  1. 所有变量、方法、类名需见名知意；

  2. 类成员变量：首字母小写和驼峰原则：monthSalary，除了第一个单词，后面的单词首字母大写；

  3. 局部变量：首字母小写和驼峰原则；

  4. 常量：大写字母和下划线；MAX_VALUE

  5. 类名：首字母大写和驼峰原则：Man、MonthMoney

  6. 方法名：首字母小写和驼峰原则：run（）；runTow（）；

一元运算符

自增++，自减--

a++自增就是在运行例如b=a++;之后再下一行进行a=a+1;操作（隐形操作）

++a自增就是在运行例如b=a++;之前再下一行进行a=a+1;操作（隐形操作）

自减同理；

逻辑运算符

与（and）或（or）非(取反)

与就是两个同时为真才为真

或就是有一个为真结果就是真

非就是取反

位运算

 

三元运算符

x?y:z //如果x==true ，则结果为y，否则为z

包机制

一般利用公司域名倒置作为包名。

 

.*:通配符，全部导入。

JavaDoc

javadoc命令是用来生成自己的API文档用的。

具体参数：

@author 作者名

@version 版本号

@since 指明需要最早使用的jdk版本

@param 参数名

@return 返回值情况

@throws 异常抛出情况

生成文档命令如下：

通过命令行 javadoc -encoding utf-8 -charset utf-8 java文件

 

## 数组，我不想写啦

 

JAVA流程控制

1.Scanner对象

  1. 语法 Scanner s = new scanner

  2. 通过Scanner类的next（）与nextLine（）方法获取输入的字符串，再读取前我们一般要用hasNext（）与hasNextLine（）判断是否还有输入的数据。

  3. 两者是有区别的，next输入的不能有空格，nextLine输入的可以有空格。

public class demo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方式接受：");
        //判断用户有没有输入字符串
        if(scanner.hasNext()){
            String str = scanner.next();      //将输入的内容存到str字符串中。
            //使用next方式接收
            System.out.println("输入的内容为："+str);//输出
        }
        scanner.close();//关闭IO，节省资源
    }
}
​
输入：hello world！
输出：hello
public class demo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用nextLine方式接受：");
        //判断用户有没有输入字符串
        if(scanner.hasNextLine()){
            String str = scanner.nextLine();      //将输入的内容存到str字符串中。
            //使用next方式接收
            System.out.println("输入的内容为："+str);//输出
        }
        scanner.close();//关闭IO，节省资源
    }
}
输入：hello world！
输出：hello world！
public static void main(String[] args) {
        //需求：通过输入多个数字，统计其总和并求其平均数
        System.out.println("请输入数据，整数或浮点数，以非两者符号结束");
        Scanner scanner = new Scanner(System.in);
        int i;
        int count=0;
        int sumInt = 0;
        double d;
        double sum = 0.0;
        double avergae = 0.0;
        while(scanner.hasNextInt()){
            i=scanner.nextInt();
            count++;
            sumInt=sumInt+i;
            System.out.println("输入的数是："+i+" 目前整数总和为："+sumInt);
        }
        while(scanner.hasNextDouble()){
            d=scanner.nextDouble();
            count++;
            sum+=d;
            System.out.println("输入的数是："+d+" 目前小数总和为："+sum);
        }
        if(count!=0){
            avergae=(sum+sumInt)/count;
        }
        else
            System.out.println("还没输入呢！");
        System.out.println("平均数为："+avergae);
​
        scanner.close();
    }

hasnextInt()判断下一个输入的字符是不是整数。

hasnextDouble（）同理。

顺序结构

equals（）判断字符串是否相等。

switch不加break就会case穿透。

break:在任何循环语句的主体部分，均可用break控制循环的流程。break用于强制退出循环，不执行循环中的剩余语句。

continue ：语句用于在循环语句中，用于终止某次循环过程，即跳过该该循环体中尚未执行的语句，接着进行下一次是否执行循环语句的判断。

Java方法

方法重载

重载就是在一个类中，有相同的函数名称，但是形参不同的函数。

方法重载的规则：

  1. 方法名称必须一致

  2. 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同）

  3. 方法的返回类型可以相同也可以不同

  4. 仅仅返回类型不同不足以构成方法重载。

     

方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去匹配，以选择对应的方法，如果匹配失败，则编译器报错。

可变参数

在方法声明中，在指定参数类型后加一个省略号（...）。

一个方法中只能指定一个可变参数，他必须是在方法的最后一个参数，任何普通参数必须在它前面声明。

递归

即本方法调用本方法，自己调用自己。

结构组成部分：

  1. 递归头：什么时候不调用自身方法。如果没有头，将彻底陷入死循环。

  2. 递归体：什么时候需要调用自身方法。

面向对象

方法

方法的定义

  1. 修饰符

  2. 返回类型

  3. break：跳出switch，结束循环。return：结束方法

  4. 方法名：注意规范，见名知意

  5. 参数列表：（参数类型，参数名）

  6. 异常抛出：先不说

    public class Demo01 {
    public static void main(String[] args) {          //main方法
​
    }
    /*
    修饰符 返回值类型 方法名（...形参）{
        方法体
        return 返回值;
    }
     */
    public static String say(){
        return "你好！";
    }
​
}

方法的调用

  1. 静态方法 ：加static就是静态方法，它和类一起加载。类名.方法（）调用时，那个方法必须是静态的，否则要实例化对象。

  2. 非静态方法

  3. 形参与实参

  4. 值传递与引用传递

  5. this关键字

package oop.Demo01;
//引用传递：对象，本质还是值传递
public class Demo04 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);
        change(person);
        System.out.println(person.name);
    }
    public static void change(Person person){
        //person 是一个对象，指向的Person person = new Person();这是一个具体的人，可以改变属性。
        person.name="sb";
    }
​
}
class  Person{//定义了一个person类，有两个属性，name，sex
    String name;
    String sex;
}
输出结果：null
        sb
package oop.Demo01;
​
public class Demo03 {
    //值传递
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);
        change(a);
        System.out.println(a);
    }
    public static void change(int a){
        a=100;
    }
}
输出结果：1
        1

类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体的描述、定义，但是并不能代表某一个具体的事物。

人是类

对象是抽象概念的具体实例

张三是对象

构造器

  1. 和类名相同

  2. 没有返回值，也不能写void

作用：

  1. new 本质是在调用构造方法

  2. 初始化对象的值

注意点：

  1. 定义有参构造之后，如果想使用无参构造，需要显示的构造一个无参构造

alt+insert 快捷键 快速生成构造方法

this. ...代表当前类的 =后面的是参数传进来的值

面向对象的总结

  1. 类与对象：类是一个模板：抽象；对象是一个具体的实例

  2. 方法：要注意定义域调用！！

  3. 对应的应用：

    引用类型： Java有 5种引用类型（对象类型）：类 接口 数组 枚举 标注

    对象是通过引用来操作的：栈-->堆

     

  4. 属性：字段Field 成员变量

    默认初始化：

    数字：0 0.0

    char: u0000

    boolean: false

    引用： null

    修饰符 属性类型 属性名 = 属性值

  5. 对象的创建于使用

    1. 必须使用new关键字创造对象，构造器 Person p = new Person();

    2. 对象的属性 p.name

    3. 对象的方法 p.say()

  6. 类：

    静态的属性   属性

    动态的行为 方法

    封装、继承、多态

封装

属性私有，get,set (追求高内聚低耦合)

Alt+insert自动构造

继承

extends，子类是父类的扩展。

Java中只有单继承没有多继承！！！！！（一个儿子只能有一个爸爸，一个爸爸可以有多个儿子）

继承是类与类之间的关系。除此之外还有其他的 例如依赖、组合、聚合等等。

子类继承父类，使用关键字extends来表示。

在Java中，所有的类，都默认直接或间接继承object类。

Ctrl+h打开结构

super

super注意点:

  1. super调用父类的构造方法，必须在构造方法的第一个

  2. super必须只能出现在子类的方法或者构造方法中!

  3. super和 this不能同时调用构造方法!

    Vs this: 代表的对象不同: this:本身调用者这个对象

    super:代表父类对象的引用

    前提 this:没有继承也可以使用 super:只能在继承条件才可以使用

    构造方法 this() ;本类的构造

    super():父类的构造!

方法重写

重写:需要有继承关系，子类重写父类的方法!

  1. 方法名必须相同

  2. 参数列表列表必须相同

  3. 修饰符:范围可以扩大但不能缩小:public>Protected>Default>private

  4. 抛出的异常:范围，可以被缩小，但不能扩大; ClassNotFoundException --> Exception(大)

    重写，子类的方法和父类必须要一致;方法体不同!

    为什么需要重写: 父类的功能，子类不一定需要,或者不一定满足!

    Alt + Insert : override;

多态

即同一个方法可以根据发送对象的不同而采取多种不同的行为方式。

  1. 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多

  2. 多态存在的条件： 1. 有继承关系 2. 子类重写父类方法 3. 父类引用指向子类对象

注意：多态是方法的多态，属性没有多态。

父类和子类，有联系，类型转换异常：ClassCastException!

存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new son();

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Person();
        //new Student();
        //可以指向的引用类型就不确定了：父类的引用指向子类
​
        //Student能调用的方法都是自己的或继承父类的
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法。
        Person s2 = new Student();
        Object s3 = new Student();
        
        //对象能执行那些方法，主要看对象左边，和右边关系不大！
        s2.run();//子类重写了父类的方法，执行父类的方法，
                 // 如果子类没有重写父类的就调用父类的，如果子类和父类都有就调用子类的
        s1.run();
​
    }
}

不能重写

  1. static 方法，属于类，不属于实例

  2. final 常量；

  3. private 方法；

instanceof（类型转换）

比较两个对象有没有父子关系。引用类型，判断一个对象是什么类型。

 

static

方法与属性调用，静态的与类一起加载，调用时，静态的能直接加载，非静态的需要实例化对象后使用。

public class Student {
    public static int a;//静态变量
    public int b;//非静态变量
    public static void run(){
        System.out.println("这是run静态方法");
    }
    public void go (){
        System.out.println("这是go非静态方法");
    }
    public static void main(String[] args) {
        run();//静态方法可以直接调用
        new Student().go();//只能实例化对象后才能调用非静态方法
    }
}

静态代码块

public class Person {
    {
        //代码块（匿名代码块）在构造器之前，赋初始值用
        System.out.println("匿名代码块");
    }
    static {
        //静态代码块,只执行一次
        System.out.println("静态代码块");
    }
​
    public Person() {//构造器
        System.out.println("构造器");
    }
​
    public static void main(String[] args) {
        new Person();
                    System.out.println("==================");
        Person person1 = new Person();
    }
}
/*
静态代码块
匿名代码块
构造器
==================
匿名代码块
构造器
 */
//

被final修饰后不能被继承了

抽象类

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰类，那么该类是抽象类。

  1. 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。

  2. 抽象类，不能使用new关键字类创造对象，他使用来让子类继承的。

  3. 抽象方法，只有方法的声明，没有方法的实现的。

  4. 子类继承抽象类，那么久必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

public abstract class Action {//抽象类
    //约束，有人帮我们实现，即子类继承后实现
    //abstract，抽象方法，只有方法名，没有方法的实现
    public abstract void dosomething();
    //不能new这个抽象类，只能靠子类去实现它，约束
    public void sayhello(){//抽象类中能写普通方法，抽象方法必须在抽象类中
        System.out.println("hello");
    }
public class A extends Action {//抽象类中的所有方法，继承它的子类都必须实现它的方法，除非它也是抽象类
    @Override
    public void dosomething() {
​
    }
}

接口

只有规范，自己无法写方法，约束与实现分离！！！implements关键字

作用：

  1. 约束

  2. 定义一些方法，让不同的人实现

  3. public abstract

  4. public static final

  5. 接口不能被实例化，接口中没有构造方法

  6. implements可以实现多个接口

  7. 必须要重写接口中的方法

package oop.Demo06;
​
public class UserServiceImp implements UserService,Timer {//implements关键字实现接口
    //接口可以实现多继承
​
    @Override
    public void run() {
​
    }
​
    @Override
    public void add() {
​
    }
​
    @Override
    public void delete() {
​
    }
​
    @Override
    public void update() {
​
    }
​
    @Override
    public void query() {
        System.out.println("hello 我是query！！");
    }
​
    public static void main(String[] args) {
        new UserServiceImp().query();
    }
}
public interface UserService {//interface关键字
    public void run();//只能写规范，实现不能写
    //接口中的所有定义其实都是抽象的 public abstract
    void add();
    void delete();
    void update();
    void query();
}
package oop.Demo06;
​
public interface Timer {
    public void add();
}

内部类

  1. 成员内部类，不能包含静态变量，能有静态常量。

    public class Outer {
    private int id;
    public void out(){
        System.out.println("这是外部类方法");
    }
    public class inner{
        public void in(){
            System.out.println("这是内部类方法");
        }
        public void getId(){//获得外部类的私有属性,私有方法
            System.out.println(id);
        }
    }
​
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过外部类来实例化内部类
        inner inner = outer.new inner();
        inner.in();
        inner.getId();
        outer.out();
    }
}

  2. 静态内部类

    加上static就好了，不依赖外部对象，可以直接用类名访问。可以有静态变量。级别和外部类一样。

  3. 匿名内部类

    public class Test {
    public static void main(String[] args) {
        new B().eat();//没有名字初始化类，不用将类保存到变量中
        C c1 = new C(){
​
            @Override
            public void put() {
​
            }
        };
    }
}
class B{
    public void eat(){
        System.out.println("eat");
    }
}
interface C{
    void put();
}

  4. 局部内部类（写在方法中）

    public class Part {
    public void func(){
        class partIneer{//局部内部类
            public void in(){
                System.out.println("局部内部类");
            }
        }
    }
}

异常机制

实际工作中，遇到的情况不可能是非常完美的。比如:你写的某个模块，用户输入不-定符合 你的要求、你的程序要打开某个支件,这个文件可能不存在或者文件格式不对，你要读取数据库的数据，数据可能是空的等。我们的程序再跑着,内存或硬盘可能满了。等等。 ​ 软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常，英文是:Exception,意思是例外。这些，例外情况，或者叫异常，怎么让我们写的程序做出合理的处 理。而不至于程序崩溃。 ​ 异常指程序运行中出现的不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。 异常发生在程序运行期间,它影响了正常的程序执行流程。

要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常:

  1. 检查性异常:最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。 例如要打开一个不存在文件时， -一个异常就发生了，这些异常在编译时不能被简单地忽略。

  2. 运行时异常:运行时异常是可能被程序员避免的异常。 与检查性异常相反，运行时异常可以在编译时被忽略。

  3. 错误:错误不是异常, 而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，个错误就发生了,它们在编译也检查不到的。

 

捕获异常

public class YiChang {
​
​
    public static void main(String[] args) {
        int a = 5;
        int b = 0;
        try {//ctrl alt+T快捷生成
            System.out.println(a/b);
        }catch (ArithmeticException e){ //catch(想要捕获异常的类型)
            System.out.println("程序出错，被除数不能为零！");
        }catch (Error e){
            System.out.println("Error ");
        }
        catch (Throwable e){
            System.out.println("Throwable");
        }
        finally{//处理善后工作，例如关闭IO等等
            System.out.println("finally");
        }
    }
​
}

抛出异常

throw throws,一般应用在方法中

自定义异常

使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定 义异常。用户自定义异常类，只需继承Exception类即可。 在程序中使用自定义异常类，大体可分为以下几个步骤: 1.创建自定义异常类。 2.在方法中通过throw关键字抛出异常对象。 3.如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理;否则在方法 的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下-步操作。 4.在出现异常方法的调用者中捕获并处理异常。

实际应用中的经验总结

处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理。 在多重catch块后面，可以加一个catch (Exception) 来处理可能会被遗漏的异常。

对于不确定的代码，也可以加上try-catch，处理潜在的异常。

尽量去处理异常，切忌只是简单地调用printStackTrace()去打印输出。

具体如何处理异常，要根据不同的业务需求和异常类型去决定。

尽量添加finally语句块去释放占用的资源。

 

小姚游
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
java基础登陆界面
xian1110的博客
10-01 2311
设置窗体居中显示：jf.setLocationRelativeTo(null);2.（1）先准备窗体:JFrame jf =new JFrame();设置流式布局管理先创建对象（同样要先导入）：FlowLayout flow = new FlowLayout();（2）设置窗体居中显示，名字，退出进程，像素大小，流式布局管理（不设置的话后面的设置按钮后整个窗体都将变为按钮）(3的来源与上文null的来源一致）图形化编程：登陆界面 一个登录界面的组件：账号/密码框，登录/注册按钮，窗体，图片。
Java入门之~Java基础语法
Ara-追着风跑
03-12 7192
Java入门之基础语法篇，收藏学起来
java基础之符号
qq_61669959的博客
04-13 3535
java基础之符号的定义，使用
JAVA基础
weixin_45415270的博客
08-04 172
JAVA基础 类与类之间关系 在我们实际开发的过程中基本情况下肯定涉及到多个类之间的协作，因此，类和类之间就必然存在各种各样的关系，面向对象程序设计中，我们将类之间的关系分为两大类型:1.横向关系 2.依赖关系 横向关系 依赖关系 依赖关系是一种比较紧密的关系，一般表现形式为一个方法的的执行，需要通过另一个对象的支持。 public class Job { } public class Wor...
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零基础到高级进阶特训营 JAVA多线程并发设计+Spring高级+数据库开发+JAVA基础等
08-04
这套课程既可以作为从零基础开始学习的JAVA基础到高级学习教程，对于有JAVA基础的同学来说可以略过前面的JAVA基础章节，直接学习后续的JAVA高级部分课程。更可以灵活的作为章节技术，进行针对性的JAVA学习。还是要...
spring事务详细讲解-深入浅出
小电玩
09-08 481
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1469
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
【学习笔记】手写 Tomcat 三
最新发布
LearnTech_123的博客
09-12 601
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Java集合：Stack详解
yang_brother的博客
09-10 536
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
自定义Stater
m0_63624484的博客
09-07 725
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 554
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
基于SpringBoot的旅游管理系统
heye0910032的博客
09-08 455
随着科技的发展，旅游管理系统的信息化成为提升旅游服务效率的关键。本系统采用JSP技术和SpringBoot框架，结合MySQL数据库，旨在实现一个功能全面、操作简便、安全可靠的旅游管理平台。系统通过需求分析、系统设计、功能实现和测试，确保了良好的用户体验和数据处理能力，为旅游业务的现代化管理提供了强有力的技术支持。本研究成功开发了一个基于SpringBoot的旅游管理系统，该系统通过集成多种旅游管理功能，显著提高了旅游服务的效率和质量。系统的用户友好界面和强大的后端功能，使得管理员和用户都能从中受益。
Linux服务器Java启动脚本
Jack魏
09-08 557
本文章介绍了如何在Linux服务器上执行Java并启动jar包，通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动，那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。
springboot数据库连接由localhost改成IP以后访问报错500（2024/9/7
不起眼小菜菜的博客
09-07 333
步骤很详细，直接上教程……
Java基础判断题测试卷
"JAVA判断题测试.pdf 是一份用于测试和复习Java基础知识的判断题集，包含多个关于Java编程语言核心概念的问题。这份测试涵盖了字符编码、标识符规则、程序结构、循环语句、数组、注释类型、程序编译与执行方式以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值