Java基础自学记录六

最新推荐文章于 2024-09-13 21:40:38 发布
最新推荐文章于 2024-09-13 21:40:38 发布
阅读量582 收藏
点赞数
分类专栏： Java基础 文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MXYLL_/article/details/127096650
版权

面向对象编程基础

此为笔者个人笔记，如有错误还请指出

//例子一
public class Test{
    public static void main(String[] args){
        Cat cat1 = new Cat();
        cat1.name = "小白";
        cat1.color = "white";
        cat1.age = 2;
    }
}
class Cat{
    String name;
    String color;
    int age;
}

类信息只加载一次

在这里插入图片描述

属性与成员变量是一个意思

类的注意事项

  • 类的定义与变量类似，但多了一个访问修饰符 访问修饰符 属性类型 属性名

    • public
    • protected
    • 默认
    • private

  • 实行定义类型可以是任意类型

  • 创建的对象实际上是对象引用(可类比于人的名字)

创建对象的方式与访问方式

Cat cat = new Cat();
Cat cat;
cat = new Cat();

类与对象的内存分配机制

跟数组一样，拷贝时也是拷贝的地址，浅拷贝

public class Test{
    public static void main(String[] args){
        Person p1 = new Person();
        p1.name = "mio";
        p1.age = 2;
        p1.height = 3.3333;
        Person p2;
        p2 = p1;
        System.out.println(p2.name + "\t" + p2.age + "\t" + p2.height);
        p2.height = 4.33;
        System.out.println(p1.name + "\t" + p1.age + "\t" + p1.height);
        p2 = null;
        //System.out.println(p2.name + "\t" + p2.age + "\t" + p2.height);//仅p2指向了空，p1不改变，此行抛出异常
        System.out.println(p1.name + "\t" + p1.age + "\t" + p1.height);
    }
}
class Person{
    String name;
    double height;
    int age;
}

在这里插入图片描述

成员方法

class Person{
    String name;
    double height;
    int age;
    public void Speak(){
        System.out.println("I'm a good person");
    }
    public int cal01(int n = 1000){
        int sum = 0;
        for(int i = 1; i <= 1000; i++){
            sum+=i;
        }
        return sum;
    }
}

调用成员方法时会在栈空间创建一个栈，执行成员方法，成员方法执行结束返回后此栈消失，返回到调用的地方，返回后继续执行后续代码

成员方法的好处：提高代码复用性、将实现细节封装，供其他用户调用即可

成员方法的定义：

public 返回数据类型 方法名(参数列表) {
    //方法体
    //...
    return 返回值;//不是必须，由返回数据类型决定void就不用了(或者只写return;)
}

方法的使用细节

  • 访问修饰符(四种，控制访问权限)
  • 方法名的命名遵循驼峰命名法，最好见名知意
  • 一个方法最多有一个返回值
  • 一个方法可以有一个或者多个参数，方法类型可以是任意类型
  • 注意参数和传入类型的兼容性(传小不传大)
  • 方法定义时的参数称为形式参数，调用时的参数称为形式参数

  • 实参形参要顺序、个数、类型一致

  • 方法体中不能嵌套定义方法

方法调用细节

  • 同类中方法调用直接使用方法名即可

  • 跨类方法A调用B需要B.方法名(参数);

  • 跨类方法调用时注意方法的访问修饰符

练习题

public class Exercise{
    public static void main(String[] args){
        AA a = new AA();
        a.oOrJ(39876212);
        a.Print(34, 78, @);
        int c=10, d=20;
        a.Swap(c, d);//仍是10和20
    }
}
class AA{
    public boolean oOrJ(int a){
        //偶true奇false
        return a%2==0? true : false;
    }
    public void Print(int l, int r, char c){
        for(int i = 0; i < l; i++){
            for(int j = 0; j < r; j++){
                System.out.print(c+"\t");
            }
            System.out.println();
        }
    }
    public void Swap(int a, int b){
        int temp = a;
        a = b;
        b = temp;
    }
}

方法传参机制

parameter

调用方法时，会创建一个新栈，若在新栈中若不是引用类型的数据进行修改，此修改对调用处的两元素是没有效果的(形参无法影响实参)

若是数组、类等引用类型的数据，修改是有效的(传的是地址，可以通过形参影响实参)


public class Exercise{
    public static void main(String[] args){
        AA a = new AA();
        Person p = new Person();
        p.name="11";
        p.height=12.3;
        p.age=33;
        a.changePerson(p);
        System.out.println(p.age);
        //输出33，置空的只是方法栈中的指针，方法栈中修改Person的属性的值才会对main里面的p有作用
    }
}
class Person{
    String name;
    double height;
    int age;
}
class AA{
    public void changePerson(Person p){
        p = null;
        p = new Person();
        //同样不改变，开辟了新的对象，与之前的没关系了
    }
}

Exercise

public class Exercise{
    public static void main(String[] args){
        int[][] a = {{1, 2, 3, 4},
                     {2, 2, 3, 4},
                     {3, 3, 4, 3}};
        MyTools myTools = new MyTools();
        myTools.Print(a);
        Person p = new Person();
        p.name="11";
        p.height=12.3;
        p.age=33;
        Person q = myTools.copyPerson(p);
        System.out.println(p.age);
    }
}
class Person{
    String name;
    double height;
    int age;
}
class MyTools{
    public void Print(int[][] a){
        for(int[] i : a){
            for(int j : i){
                System.out.print(j+"\t");
            }
            System.out.println();
        }
    }
    public Person copyPerson(Person wt){
        Person ans = new Person();
        ans.name = wt.name;
        ans.height = wt.height;
        ans.age = wt.age;
        return ans;
    }
}

方法递归调用

  • 每执行一次方法，就创建一个新的受保护的独立空间

  • 方法的局部变量是独立的，不会互相影响(每次递归中相同的变量名)

  • 若使用的是引用类型的数据，则递归过程中会共享此引用类型数据

  • 递归时先写出口，避免无限递归

  • 遵守谁调用返回给谁的原则

Exercise

public class Exercise{
    public static void main(String[] args){
        MyTools m = new MyTools();
        int ans = m.Fab(7);
        System.out.println(ans);
        //没找的是0，障碍物是1，找过的是2，走不通的路是3
        int[][] mp = {{1,1,1,1,1,1,1},
                      {1,0,0,0,0,0,1},
                      {1,0,0,0,0,0,1},
                      {1,1,1,0,0,0,1},
                      {1,0,0,0,0,0,1},
                      {1,0,0,0,0,0,1},
                      {1,0,0,0,0,0,1},
                      {1,1,1,1,1,1,1}};
    }
}
class MyTools{
    //指引方向：下右上左
    int[][] tws = {{1,0},
                   {0,1},
                   {-1,0},
                   {0,-1}};
    //求出斐波那契数列的第n项
    public int Fab(int n){
        if(n == 1 || n == 2) return 1;
        return Fab(n - 1) + Fab(n - 2);
    }
    //猴子吃桃问题 n 天剩一个桃子 n-1剩4个桃吃3个  n为第一天，返回有多少个桃子
    public int Peach(int n){
        if(n == 2) return 4;
        //前一天的桃子数等于今天剩桃子数+1  *  2
        return (Peach(n - 1) + 1) * 2;
    }
    //小老鼠走迷宫
    public boolean findWay(int[][] mp, int x, int y){
        int x1, y1;
        if(mp[6][5] == 2) {
            return true;
        } else{
            if(mp[x][y] == 0){
                mp[x][y] = 2;//走过
                for(int i = 0; i < 4; i++){
                    x1 = x + tws[i][0];
                    y1 = y + tws[i][1];
                    if(findWay(mp, x1, y1)){
                        return true;
                    }//找到就true，没找到就换个方向找(有墙或标记了不通)
				   Print(mp);//打印当前路线，便于观察
				   System.out.println("========================");
                }
                mp[x][y] == 3; //四个方向都寄了，标记此路不通
			   return false;//四个都没走通，向上级返回false
            }else{ //mp[x][y]==1,2  障碍/走过
                return false;
            }
        }
    }
	//打印二维数组
	public void Print(int[][] a){
        for(int[] i : a){
            for(int j : i){
                System.out.print(j+"\t");
            }
            System.out.println();
        }
    }
    //汉诺塔问题，n个盘子,从a借助b移动到c
    public void Hannuota(int n, char a, char b, char c){
        //递归出口
        if(n == 1){
            System.out.println(a+"->"+c);
        }
        //先将n-1个借助c移动到b
        Hannuota(n - 1, a, c, b);
        //再第n个移动到c
        System.out.println(a+"->"+c);
        //再将b上的n-1个借助a移动到c
        Hannuota(n - 1, b, a, c);
    }
    //八皇后问题
    
    //思路：一个放在一行一列
    //第二个放在二行一列，判断是否满足(一定要考虑同一条斜线上的！！！)，不满足就把所有列放完
    //依次进行每一个
    //得到一个正确的后回溯到第一个皇后放第二列，继续执行后续步骤
    //每个皇后的行都不变，只对列进行变化
    
    //判断是否可以放置在此位置的方法：
    private boolean isOk(int row, int target, int[] num){
        for(int i == 0; i < num.length; i++){
            //前面是横，后面是斜线
            if(num[i] = target || Math.abs(row - i) == Math.abs(target - num[i])){
                return false;
            }
        }
        return true;
    }
    //打印棋盘
    private void PrintQueens(int[] arr){
        for(int i = 0; i <arr.length; i++){
            for(int j = 0; j < arr.length; j++){
                if(j != arr[i]){
                    System.out.print("*");
                }else{
                    System.out.print("^");
                }
            }
            System.out.println();
        }
        System.out.println("========");
    }
    //记录解决方法数
    private long solves;
    //主函数
    public int Queens(int n){
        solves = 0;
        goQueens(0, new int[n]);
        return solves;
    }
    //用于递归的函数
    private void goQueens(int row, int[] ans){
        if(row == ans.length){
            solves++;
            PrintQueens(ans);
            return ;
        }else{
            for(int i = 0; i < ans.length; i++){
                if(isOk(row, i, ans)){
                    ans[row] = i;
                    goQueens(row + 1, ans);
                    ans[row] = 0;
                }
            }
        }
    }
}

方法重载介绍

同一个类中函数名同但功能不同

好处：减轻的起名和记名的麻烦

使用细节

  • 方法名必须相同
  • 形参列表必须不同(可以类型与顺序不同) 即使返回值类型不同，参数相同也不是重载
  • 返回类型可以相同也可以不同

可变参数的使用

Java允许将多个同名同功能但参数个数不同的方法封装成同一个方法

语法：访问修饰符 返回类型 方法名(数据类型… 形参名);

使用可变参数时，可以视为数组

public class Learn{
    public static void main(String[] args){
        MyTools m = new MyTools();
        int ans = m.hecheng(2, 3, 5, 7, 9, 10);
        System.out.println("和是"+ans);
    }
}

class MyTools{
    public int sum(int... nums){
        int ans = 0;
        for(int i = 0; i < nums.length; i++){
            ans += nums[i];
        }
        return ans;
    }
    public int hecheng(int a1, int... nums){
        int sums = sum(nums);
        return a1 * sums;
    }
}

注意事项和使用细节

  • 可变参数的实参可以是0 or 多个

  • 实参可以是数组

  • 本质就是数组

  • 可变参数和普通参数一起作为形参，可变参数必须保证在最后

  • 一个形参列表中只能出现一个可变参数(万万不可多)

作用域

局部变量一般指成员方法中定义的变量

方法属性可以和局部变量同名，访问遵循就近原则

同一作用域中，两个局部变量不能重名

属性生命周期长，随对象的创建而创建，伴随着对象的死亡而死亡，局部变量生命周期短，随着代码块执行而创建，随着代码块结束而死亡

全局变量/属性可以加修饰符，局部变量不可以

全局变量可以被本类使用，局部变量只能在本类中对应的方法中使用

构造器(构造函数)

完成对新对象的初始化

方法名要和类名字一致

语法：

class MyTools{
    public MyTools(){
        System.out.println("正在使用构造器");
    }
    public int sum(int... nums){
        int ans = 0;
        for(int i = 0; i < nums.length; i++){
            ans += nums[i];
        }
        return ans;
    }
    public int hecheng(int a1, int... nums){
        int sums = sum(nums);
        return a1 * sums;
    }
}

注意

  • 构造器的修饰符可以默认，也可以是public protected private
  • 构造器没有返回值
  • 方法名和类名必须一样
  • 参数列表和成员方法的参数列表一样的规则
  • 构造器的调用由系统完成
  • 在创建对象的时候，系统会自动调用该类的构造器完成初始化
  • 如果程序员没有自定义构造方法，系统会自动给类生成一个默认无参数的构造方法，可以使用javap反编译看一下
  • 一旦定义了自己的构造器，默认构造器就失效了，除非显示定义一下 Person(){};
public class Learn{
    public static void main(String[] args){
        Person p1 = new Person("ylll", 19);
        System.out.println(p1);
    }
}
class Person{
    String name;
    int age;
    public Person(String pName, int pAge){
        name = pName;
        age = pAge;
        System.out.println("你好"+pAge+"岁的"+pName);
    }
}
class Dog{
    String name;
}

在这里插入图片描述

Exercise

public class Exercise{
    public static void main(String[] args){
        Person p1 = new Person();
        Person p2 = new Person("yll", 19);
        System.out.println("Hello! "+ p1.age+ "  "+ p1.name);
        System.out.println("Hello! "+ p2.age+ "  "+ p2.name);
    }
}
class Person{
    String name;
    int age;
    public Person(String pName, int pAge){
        name = pName;
        age = pAge;
        //System.out.println("你好"+pAge+"岁的"+pName);
    }
    public Person(){
        age = 18;
    }
}

对象创建流程分析

Person p = new Person("yll", 19);
class Person{
    String name;
    int age = 90;
    public Person(String pName, int pAge){
        name = pName;
        age = pAge;
        //System.out.println("你好"+pAge+"岁的"+pName);
    }
    public Person(){
        age = 18;
    }
}

先默认创建对象，而后再初始化，构造函数执行的是对象的初始化

  • 1、加载Person类信息(Person.class)，只会加载一次
  • 2、在堆中分配空间(地址)
  • 3、完成对象初始化(默认初始化null 0 -> 显式初始化null 90 -> 构造器初始化yll 19)
  • 将对象在队中的地址返回对象名(或者叫对象的引用)

this关键字

JVM给每个对象分配this，代表当前对象，相当于一个指向自己的指针

为了将属性与成员方法进行区分，如果不加this，会把name和age视作局部变量

class Person{
    String name;
    int age = 90;
    public Person(String name, int age){
        //name = name;
        //age = age;
        this.name = name;
        this.age = age;
    }
}

可以通过hashCode()来判断是否是同一个值

public class Exercise{
    public static void main(String[] args){
        Person p = new Person("yll", 19);
        System.out.println("p.hashCode()="+p.hashCode());
        Person p1 = p;
        System.out.println("p1.hashCode()="+p1.hashCode());
    }
}

class Person{
    String name;
    int age = 90;
    public Person(String name, int age){
        //name = name;
        //age = age;
        this.name = name;
        this.age = age;
        System.out.println("this.hashCode()="+this.hashCode());
    }
}

在这里插入图片描述

哪个对象调用，this就代表哪个对象

注意事项

  • this用于区分类的属性和局部变量
  • 访问成员方法：this.方法名()
  • 访问构造器：this(参数列表) 注意只能在构造器中使用
  • this不能在类定义外使用，只能在类定义的方法中使用
public class Exercise{
    public static void main(String[] args){
        
    }
}

class Person{
    String name;
    int age;
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
    public boolean compareTo(Person p){
        return this.name.equals(p.name) && this.age == p.age; 
    }
}

Homework

public class Homework{
    public static void main(String[] args){
        MyTools m = new MyTools();
        
        //1、
        double[] d1 = {1.4,2.5,3254.21,53436.232,1.34,777.77,12345.6,2324.3142,46436.2};
        double dmax = m.max(d1);
        System.out.println(dmax);
        
        //2、
        char[] ch1 = {'1', '2', 'y', 'm', 'x', 'l', '9', '0'};
        int index = m.find(ch1, 'y');//2
        System.out.println("下标是："+index);
        
        //4、
        int[] i1 = {13,3,35,65,7,3,34,432,13,6,45,7,5};
        System.out.println("i1:");
        for(int i: i1){
            System.out.print(i+"\t");
        }
        System.out.println();        
        int[] i2 = m.copyArr(i1);
        System.out.println("i2:");
        for(int i: i2){
            System.out.print(i+"\t");
        }
        System.out.println();
    }
}
class MyTools{
    public double max(double[] nums){
        double max = nums[0];
        for(double num: nums){
            if(num > max) max = num;
        }
        return max;
    }
    public int find(char[] chs, char target){
        int ans = -1;
        for(int i = 0; i < chs.length; i++){
            if(chs[i] == target){
                ans = i;
                break;
            }
        }
        return ans;
    }
    public int[] copyArr(int[] old){
        int[] newArr = new int[old.length];
        for(int i = 0; i < old.length; i++){
            newArr[i] = old[i];
        }
        return newArr;
    }
}

public class Homework{
    public static void main(String[] args){
        Book b = new Book();
        b.price = 151;
        b.updatePrice();
        System.out.println("原价151，现价"+b.price);
        b.price = 111;
        b.updatePrice();
        System.out.println("原价111，现价"+b.price);
    }
}
class Book{
    double price;
    public void updatePrice(){
        if(price > 150) price = 150;
        else if(price > 100) price = 100;
        else ;
    }
}

public class Homework{
    public static void main(String[] args){
        Dog d = new Dog("ww", "blue", 3);
        d.show();
    }
}
class Dog{
    String name;
    String color;
    int age;
    public Dog(String name, String color, int age){
        this.name = name;
        this.color = color;
        this.age = age;
    }
    public void show(){
        System.out.println(color+"色的小狗名叫"+name+";今年"+age+"岁了");
    }
}
MXYLL_
关注
专栏目录
Java自学笔记（九）
weixin_40211315的博客
03-16 125
接口这里直接给出定义方式（关于概念，先把它当作是一个抽象类，确实有些类似，但是略有不同，抽象类概括的是某物的本质，接口是某物外的性质）public interface 接口名称{            抽象方法……}(所以接口不能实例化对象，抽象方法了)接口里面的成员变量其实是常量，声明方式为: public static final int i = 1;如果不书写public static fi...
Java自学笔记⑥
Kong_bai_r的博客
11-28 299
类与对象 局部变量 在成员方法内定义一个变量，那么这个变量被称为局部变量。 public String getName(){ //定义一个getName方法 int id=0; //局部变量id setName("java"); //调用类中其他方法 return id+this.name; //设置方法返回值 } 对象的创建 //Test test=new Test; //Test test=new Test("a"); //Test:类名 test：创建Test类对象
【JavaSE】方法的妙用
兮动人
08-09 263
文章目录1. 为什么需要成员方法？2. 成员方法的好处 1. 为什么需要成员方法？ Method02.java 看一个需求： 请遍历一个数组 , 输出数组的各个元素值。 解决思路 1：传统的方法，就是使用单个 for 循环，将数组输出，看看问题是什么？ public class Method02 { public static void main(String[] args) { int[][] map = {{0, 1, 1}, {1, 1, 1}, {1, 1, 3}};
java倒数第二小的值_剑指offer61：扑克牌中的顺子，并且应用到Java计算数组中第二小的元素...
weixin_39673002的博客
02-25 165
剑指 Offer 61. 扑克牌中的顺子从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。2～10为数字本身，A为1，J为11，Q为12，K为13，而大、小王为 0 ，可以看成任意数字。A 不能视为 14。我的解法：如果没有大小王视为任何牌的话，这道题就遍历数组找到最大值最小值，求个差看等不等于4就完事了，但是现在涉及到大小王，情况就复杂了很多。思考了很久，结合leetcode大...
Java I/O流详解
qq_28791753的博客
03-21 2362
JAVA I/O流详解，字节流，字符流
【JavaSE】成员方法快速入门和方法的调用机制原理
兮动人
08-08 348
1. 基本介绍 在某些情况下，我们要需要定义成员方法(简称方法)。比如人类:除了有一些属性外( 年龄，姓名…),我们人类还有一些行为比如:可以说话、跑步…,通过学习，还可以做算术题。这时就要用成员方法才能完成。现在要求对 Person 类完善。 2. 成员方法快速入门 Method01.java 添加 speak 成员方法,输出 “我是一个好人” 2) 添加 cal01 成员方法,可以计算从 1+…+1000 的结果 添加 cal02 成员方法,该方法可以接收一个数 n，计算从 1+…+n 的结果 添
从底层入手，图解 Java NIO BIO MIO AIO 四大IO模型与原理
架构师尼恩
01-05 6029
疯狂创客圈 Java 分布式聊天室【 亿级流量】实战系列之 -21【 博客园 总入口 】 文章目录写在前面1.1. Java **IO读写原理**1.1.1. 内核缓冲与进程缓冲区1.1.2. java IO读写的底层流程1.2. **四种主要的IO模型**1.3. **同步阻塞IO（Blocking IO）**1.4. **同步非阻塞NIO（None Blocking IO）**1.5. ...
0 基础 Java 自学之路（2021年最新版）
热门推荐
程序员囧辉
04-08 40万+
屌丝逆袭之路
Java自学--基础笔记
07-19
学习Java过程记录笔记
暑假自学加强Java的学习记录.zip
03-09
1. **Java基础知识**：Java是一种面向对象的编程语言，由Sun Microsystems（现已被Oracle公司收购）于1995年推出。它的设计目标是“一次编写，到处运行”，这意味着Java代码可以在任何支持Java虚拟机（JVM）的平台上...
JAVA后端自学技能实操合集-linux jdk8
12-19
在IT行业中，Java后端开发是一项非常重要的技能，尤其对于自学开发者来说，掌握相关知识能够为职业发展奠定坚实基础。本资源"JAVA后端自学技能实操合集-linux jdk8"聚焦于Java编程语言在Linux环境下的应用，特别是...
spring事务详细讲解-深入浅出
小电玩
09-08 540
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1526
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
yang_brother的博客
09-10 588
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 625
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
基于SpringBoot的考研资讯平台设计与实现
最新发布
linzhongshu的专栏
09-13 592
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
Linux服务器Java启动脚本
Jack魏
09-08 574
本文章介绍了如何在Linux服务器上执行Java并启动jar包，通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动，那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。
MyBatis面试
Tony_yitao的博客
09-09 799
MyBatis面试
Java自学教程：从基础到高级
6. **其他高级主题**：从第7章开始，教程可能涵盖了异常处理、输入输出（IO）、数据库技术、安全技术、网络编程（包括Servlet技术和XML处理），这些都是Java开发中的重要技能。 通过阅读这份教程，读者可以系统地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值